stmhal: Get USB enumerating a CDC device.

Enumerates CDC device over USB, but doesn't transmit/receive yet.

stmhal/Makefile

@@ -8,9 +8,8 @@ include ../py/py.mk
 
 CMSIS_DIR=cmsis
 HAL_DIR=hal
-#STMUSB_DIR=stmusb
-#STMUSBD_DIR=stmusbd
-#STMUSBH_DIR=stmusbh
+USBDEV_DIR=usbdev
+#USBHOST_DIR=usbhost
 #FATFS_DIR=fatfs
 #CC3K_DIR=cc3k
 DFU=../tools/dfu.py
@@ -22,9 +21,8 @@ INC += -I$(PY_SRC)
 INC += -I$(CMSIS_DIR)/inc
 INC += -I$(CMSIS_DIR)/devinc
 INC += -I$(HAL_DIR)/inc
-#INC += -I$(STMUSB_DIR)
-#INC += -I$(STMUSBD_DIR)
-#INC += -I$(STMUSBH_DIR)
+INC += -I$(USBDEV_DIR)/core/inc -I$(USBDEV_DIR)/class/cdc/inc
+#INC += -I$(USBHOST_DIR)
 #INC += -I$(FATFS_DIR)
 #INC += -I$(CC3K_DIR)
 
@@ -57,10 +55,15 @@ SRC_C = \
 	system_stm32f4xx.c \
 	stm32f4xx_it.c \
 	stm32f4xx_hal_msp.c \
+	usbd_conf.c \
+	usbd_desc.c \
+	usbd_cdc_interface.c \
+	pendsv.c \
 	systick.c  \
 	led.c \
 	pin.c \
 	usart.c \
+	usb.c \
 	printf.c \
 	math.c \
 	malloc0.c \
@@ -70,14 +73,12 @@ SRC_C = \
 	import.c \
 	lexerfatfs.c \
 
-#	pendsv.c \
 #	gpio.c \
 #	lcd.c \
 #	servo.c \
 #	flash.c \
 #	storage.c \
 #	accel.c \
-#	usb.c \
 #	timer.c \
 #	audio.c \
 #	sdcard.c \
@@ -100,8 +101,10 @@ SRC_HAL = $(addprefix $(HAL_DIR)/src/,\
 	stm32f4xx_hal_cortex.c \
 	stm32f4xx_hal_dma.c \
 	stm32f4xx_hal_gpio.c \
+	stm32f4xx_hal_pcd.c \
 	stm32f4xx_hal_rcc.c \
 	stm32f4xx_hal_uart.c \
+	stm32f4xx_ll_usb.c \
 	)
 
 SRC_STMPERIPH = $(addprefix $(STMPERIPH_DIR)/,\
@@ -136,8 +139,14 @@ SRC_STMUSB = $(addprefix $(STMUSB_DIR)/,\
 	)
 #	usb_otg.c \
 
-SRC_STMUSBD = $(addprefix $(STMUSBD_DIR)/,\
-	usbd_core.c \
+SRC_USBDEV = $(addprefix $(USBDEV_DIR)/,\
+	core/src/usbd_core.c \
+	core/src/usbd_ctlreq.c \
+	core/src/usbd_ioreq.c \
+	class/cdc/src/usbd_cdc.c \
+	)
+
+#	usbd_core.c \
 	usbd_ioreq.c \
 	usbd_req.c \
 	usbd_usr.c \
@@ -186,7 +195,7 @@ OBJ += $(PY_O)
 OBJ += $(addprefix $(BUILD)/, $(SRC_C:.c=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_S:.s=.o))
 OBJ += $(addprefix $(BUILD)/, $(SRC_HAL:.c=.o))
-#OBJ += $(addprefix $(BUILD)/, $(SRC_STMUSB:.c=.o))
+OBJ += $(addprefix $(BUILD)/, $(SRC_USBDEV:.c=.o))
 #OBJ += $(addprefix $(BUILD)/, $(SRC_STMUSBD:.c=.o))
 #OBJ += $(addprefix $(BUILD)/, $(SRC_STMUSBH:.c=.o))
 #OBJ += $(addprefix $(BUILD)/, $(SRC_FATFS:.c=.o))

stmhal/boards/PYBOARD4/stm32f4xx_hal_conf.h

@@ -47,6 +47,7 @@
 /* Exported constants --------------------------------------------------------*/
 
 #define STM32F405xx
+#define USE_USB_FS
 
 /* ########################## Module Selection ############################## */
 /**

stmhal/main.c

@@ -20,6 +20,7 @@
 
 #include "misc.h"
 #include "systick.h"
+#include "pendsv.h"
 #include "led.h"
 #include "usart.h"
 #include "mpconfig.h"
@@ -37,16 +38,15 @@
 #include "gccollect.h"
 #include "pyexec.h"
 #include "pybmodule.h"
+#include "usb.h"
 #if 0
 #include "ff.h"
 #include "lexerfatfs.h"
-#include "pendsv.h"
 #include "servo.h"
 #include "lcd.h"
 #include "storage.h"
 #include "sdcard.h"
 #include "accel.h"
-#include "usb.h"
 #include "timer.h"
 #include "pybwlan.h"
 #include "usrsw.h"
@@ -82,8 +82,10 @@ void flash_error(int n) {
 
 void __fatal_error(const char *msg) {
 #if MICROPY_HW_HAS_LCD
+#if 0
     lcd_print_strn("\nFATAL ERROR:\n", 14);
     lcd_print_strn(msg, strlen(msg));
+#endif
 #endif
     for (;;) {
         flash_error(1);
@@ -116,6 +118,9 @@ void fatality(void) {
     led_state(PYB_LED_G1, 1);
     led_state(PYB_LED_R2, 1);
     led_state(PYB_LED_G2, 1);
+    for (;;) {
+        flash_error(1);
+    }
 }
 
 static const char fresh_boot_py[] =
@@ -244,9 +249,7 @@ int main(void) {
 
     // basic sub-system init
     sys_tick_init();
-#if 0
     pendsv_init();
-#endif
     led_init();
 
 #if 0
@@ -469,6 +472,7 @@ soft_reset:
         }
     }
 #endif
+#endif
 
 #ifdef USE_HOST_MODE
     // USB host
@@ -478,6 +482,22 @@ soft_reset:
     pyb_usb_dev_init(PYB_USB_DEV_VCP_MSC);
 #endif
 
+#if 0
+    // test USB CDC
+    extern uint8_t UserTxBuffer[];/* Received Data over UART (CDC interface) are stored in this buffer */
+    extern uint32_t UserTxBufPtrOut; /* Increment this pointer or roll it back to
+                                        start address when data are sent over USB */
+    for (;;) {
+        UserTxBuffer[UserTxBufPtrOut++] = 'a';
+        UserTxBuffer[UserTxBufPtrOut++] = 'b';
+        UserTxBuffer[UserTxBufPtrOut++] = 'c';
+        UserTxBuffer[UserTxBufPtrOut++] = 'd';
+        HAL_Delay(500);
+        led_toggle(PYB_LED_BLUE);
+    }
+#endif
+
+#if 0
     // run main script
     {
         vstr_t *vstr = vstr_new();

stmhal/pendsv.c

@@ -0,0 +1,83 @@
+#include <stdlib.h>
+#include <stm32f4xx_hal.h>
+
+#include "misc.h"
+#include "mpconfig.h"
+#include "qstr.h"
+#include "obj.h"
+#include "pendsv.h"
+
+static void *pendsv_object = NULL;
+
+void pendsv_init(void) {
+    // set PendSV interrupt at lowest priority
+    HAL_NVIC_SetPriority(PendSV_IRQn, 0xf, 0xf);
+}
+
+// call this function to raise a pending exception during an interrupt
+// it will wait until all interrupts are finished then raise the given
+// exception object using nlr_jump in the context of the top-level thread
+void pendsv_nlr_jump(void *o) {
+    pendsv_object = o;
+    SCB->ICSR = SCB_ICSR_PENDSVSET_Msk;
+}
+
+// since we play tricks with the stack, the compiler must not generate a
+// prelude for this function
+void pendsv_isr_handler(void) __attribute__((naked));
+
+void pendsv_isr_handler(void) {
+    // re-jig the stack so that when we return from this interrupt handler
+    // it returns instead to nlr_jump with argument pendsv_object
+    // note that stack has a different layout if DEBUG is enabled
+    //
+    // on entry to this (naked) function, stack has the following layout:
+    //
+    // stack layout with DEBUG disabled:
+    //   sp[6]: pc
+    //   sp[5]: ?
+    //   sp[4]: ?
+    //   sp[3]: ?
+    //   sp[2]: ?
+    //   sp[1]: ?
+    //   sp[0]: r0
+    //
+    // stack layout with DEBUG enabled:
+    //   sp[8]: pc
+    //   sp[7]: lr
+    //   sp[6]: ?
+    //   sp[5]: ?
+    //   sp[4]: ?
+    //   sp[3]: ?
+    //   sp[2]: r0
+    //   sp[1]: 0xfffffff9
+    //   sp[0]: ?
+
+    __asm volatile (
+        "ldr r0, pendsv_object_ptr\n"
+        "ldr r0, [r0]\n"
+#if defined(PENDSV_DEBUG)
+        "str r0, [sp, #8]\n"
+#else
+        "str r0, [sp, #0]\n"
+#endif
+        "ldr r0, nlr_jump_ptr\n"
+#if defined(PENDSV_DEBUG)
+        "str r0, [sp, #32]\n"
+#else
+        "str r0, [sp, #24]\n"
+#endif
+        "bx lr\n"
+        ".align 2\n"
+        "pendsv_object_ptr: .word pendsv_object\n"
+        "nlr_jump_ptr: .word nlr_jump\n"
+    );
+
+    /*
+    uint32_t x[2] = {0x424242, 0xdeaddead};
+    printf("PendSV: %p\n", x);
+    for (uint32_t *p = (uint32_t*)(((uint32_t)x - 15) & 0xfffffff0), i = 64; i > 0; p += 4, i -= 4) {
+        printf(" %p: %08x %08x %08x %08x\n", p, (uint)p[0], (uint)p[1], (uint)p[2], (uint)p[3]);
+    }
+    */
+}

stmhal/pendsv.h

@@ -0,0 +1,3 @@
+void pendsv_init(void);
+void pendsv_nlr_jump(void *val);
+void pendsv_isr_handler(void);

stmhal/stm32f4xx_it.c

@@ -56,6 +56,9 @@
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 
+extern void fatality();
+extern PCD_HandleTypeDef hpcd;
+
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 
@@ -82,6 +85,7 @@ void HardFault_Handler(void)
   /* Go to infinite loop when Hard Fault exception occurs */
   while (1)
   {
+    fatality();
   }
 }
 
@@ -95,6 +99,7 @@ void MemManage_Handler(void)
   /* Go to infinite loop when Memory Manage exception occurs */
   while (1)
   {
+    fatality();
   }
 }
 
@@ -108,6 +113,7 @@ void BusFault_Handler(void)
   /* Go to infinite loop when Bus Fault exception occurs */
   while (1)
   {
+    fatality();
   }
 }
 
@@ -121,6 +127,7 @@ void UsageFault_Handler(void)
   /* Go to infinite loop when Usage Fault exception occurs */
   while (1)
   {
+    fatality();
   }
 }
 
@@ -149,6 +156,8 @@ void DebugMon_Handler(void)
   */
 void PendSV_Handler(void)
 {
+    extern void pendsv_isr_handler(void);
+    pendsv_isr_handler();
 }
 
 /**
@@ -158,7 +167,7 @@ void PendSV_Handler(void)
   */
 void SysTick_Handler(void)
 {
-  HAL_IncTick();
+    HAL_IncTick();
 }
 
 /******************************************************************************/
@@ -168,6 +177,72 @@ void SysTick_Handler(void)
 /*  file (startup_stm32f4xx.s).                                               */
 /******************************************************************************/
 
+/**
+  * @brief  This function handles USB-On-The-Go FS global interrupt request.
+  * @param  None
+  * @retval None
+  */
+#ifdef USE_USB_FS
+void OTG_FS_IRQHandler(void)
+#elif defined(USE_USB_HS)
+void OTG_HS_IRQHandler(void)
+#endif
+{
+    HAL_PCD_IRQHandler(&hpcd);
+}
+
+/**
+  * @brief  This function handles USB OTG FS or HS Wakeup IRQ Handler.
+  * @param  None
+  * @retval None
+  */
+#ifdef USE_USB_FS
+void OTG_FS_WKUP_IRQHandler(void)
+#elif defined(USE_USB_HS)
+void OTG_HS_WKUP_IRQHandler(void)
+#endif
+{
+ 
+  if((&hpcd)->Init.low_power_enable)
+  {
+    /* Reset SLEEPDEEP bit of Cortex System Control Register */
+    SCB->SCR &= (uint32_t)~((uint32_t)(SCB_SCR_SLEEPDEEP_Msk | SCB_SCR_SLEEPONEXIT_Msk));  
+    
+    /* Configures system clock after wake-up from STOP: enable HSE, PLL and select 
+    PLL as system clock source (HSE and PLL are disabled in STOP mode) */
+    
+    __HAL_RCC_HSE_CONFIG(RCC_HSE_ON);
+    
+    /* Wait till HSE is ready */  
+    while(__HAL_RCC_GET_FLAG(RCC_FLAG_HSERDY) == RESET)
+    {}
+    
+    /* Enable the main PLL. */
+    __HAL_RCC_PLL_ENABLE();
+    
+    /* Wait till PLL is ready */  
+    while(__HAL_RCC_GET_FLAG(RCC_FLAG_PLLRDY) == RESET)
+    {}
+    
+    /* Select PLL as SYSCLK */
+    MODIFY_REG(RCC->CFGR, RCC_CFGR_SW, RCC_SYSCLKSOURCE_PLLCLK);
+    
+    while (__HAL_RCC_GET_SYSCLK_SOURCE() != RCC_CFGR_SWS_PLL)
+    {}
+    
+    /* ungate PHY clock */
+     __HAL_PCD_UNGATE_PHYCLOCK((&hpcd)); 
+  }
+#ifdef USE_USB_FS
+  /* Clear EXTI pending Bit*/
+  __HAL_USB_FS_EXTI_CLEAR_FLAG();
+#elif defined(USE_USB_HS)
+    /* Clear EXTI pending Bit*/
+  __HAL_USB_HS_EXTI_CLEAR_FLAG();
+#endif
+  
+}
+
 /**
   * @brief  This function handles PPP interrupt request.
   * @param  None

stmhal/stm32f4xx_it.h

@@ -58,6 +58,11 @@ void SVC_Handler(void);
 void DebugMon_Handler(void);
 void PendSV_Handler(void);
 void SysTick_Handler(void);
+#ifdef USE_USB_FS
+void OTG_FS_IRQHandler(void);
+#elif defined(USE_USB_HS)
+void OTG_HS_IRQHandler(void);
+#endif
 
 #ifdef __cplusplus
 }

stmhal/usb.c

@@ -0,0 +1,240 @@
+#include <string.h>
+
+/*
+#include "usb_core.h"
+#include "usbd_cdc_core.h"
+#include "usbd_pyb_core.h"
+#include "usbd_usr.h"
+*/
+#include "usbd_core.h"
+#include "usbd_desc.h"
+#include "usbd_cdc.h"
+#include "usbd_cdc_interface.h"
+
+#include "misc.h"
+#include "mpconfig.h"
+#include "qstr.h"
+#include "obj.h"
+#include "pendsv.h"
+#include "usb.h"
+
+#ifdef USE_DEVICE_MODE
+//extern CDC_IF_Prop_TypeDef VCP_fops;
+USBD_HandleTypeDef hUSBDDevice;
+#endif
+
+static int dev_is_enabled = 0;
+uint32_t APP_dev_is_connected = 0; /* used by usbd_cdc_vcp */
+static char rx_buf[64];
+static int rx_buf_in;
+static int rx_buf_out;
+static int interrupt_char = VCP_CHAR_NONE;
+mp_obj_t mp_const_vcp_interrupt = MP_OBJ_NULL;
+
+void pyb_usb_dev_init(int usb_dev_type) {
+#ifdef USE_DEVICE_MODE
+    if (!dev_is_enabled) {
+        // only init USB once in the device's power-lifetime
+        switch (usb_dev_type) {
+            case PYB_USB_DEV_VCP_MSC:
+                // XXX USBD_CDC_Init (called by one of these functions below) uses malloc,
+                // so the memory is invalid after a soft reset (which resets the GC).
+                USBD_Init(&hUSBDDevice, &VCP_Desc, 0);
+                USBD_RegisterClass(&hUSBDDevice, &USBD_CDC);
+                USBD_CDC_RegisterInterface(&hUSBDDevice, &USBD_CDC_fops);
+                USBD_Start(&hUSBDDevice);
+                //USBD_Init(&USB_OTG_Core, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_PYB_cb, &USR_cb);
+                break;
+
+            case PYB_USB_DEV_HID:
+                //USBD_Init(&USB_OTG_Core, USB_OTG_FS_CORE_ID, &USR_desc, &USBD_PYB_HID_cb, &USR_cb);
+                // TODO
+                break;
+        }
+    }
+    rx_buf_in = 0;
+    rx_buf_out = 0;
+    interrupt_char = VCP_CHAR_NONE;
+    dev_is_enabled = 1;
+
+    // create an exception object for interrupting by VCP
+    mp_const_vcp_interrupt = mp_obj_new_exception_msg(&mp_type_OSError, "VCPInterrupt");
+#endif
+}
+
+bool usb_vcp_is_enabled(void) {
+    return dev_is_enabled;
+}
+
+bool usb_vcp_is_connected(void) {
+    return APP_dev_is_connected;
+}
+
+void usb_vcp_set_interrupt_char(int c) {
+    if (dev_is_enabled) {
+        interrupt_char = c;
+    }
+}
+
+void usb_vcp_receive(const char *buf, uint32_t len) {
+    if (dev_is_enabled) {
+        for (int i = 0; i < len; i++) {
+
+            // catch special interrupt character
+            if (buf[i] == interrupt_char) {
+                // raise exception when interrupts are finished
+                mp_obj_exception_clear_traceback(mp_const_vcp_interrupt);
+                pendsv_nlr_jump(mp_const_vcp_interrupt);
+                interrupt_char = VCP_CHAR_NONE;
+                continue;
+            }
+
+            rx_buf[rx_buf_in++] = buf[i];
+            if (rx_buf_in >= sizeof(rx_buf)) {
+                rx_buf_in = 0;
+            }
+            if (rx_buf_in == rx_buf_out) {
+                rx_buf_out = rx_buf_in + 1;
+                if (rx_buf_out >= sizeof(rx_buf)) {
+                    rx_buf_out = 0;
+                }
+            }
+        }
+    }
+}
+
+int usb_vcp_rx_any(void) {
+    if (rx_buf_in >= rx_buf_out) {
+        return rx_buf_in - rx_buf_out;
+    } else {
+        return rx_buf_in + sizeof(rx_buf) - rx_buf_out;
+    }
+}
+
+char usb_vcp_rx_get(void) {
+    while (rx_buf_out == rx_buf_in) {
+    }
+    char c = rx_buf[rx_buf_out];
+    rx_buf_out += 1;
+    if (rx_buf_out >= sizeof(rx_buf)) {
+        rx_buf_out = 0;
+    }
+    return c;
+}
+
+void usb_vcp_send_str(const char *str) {
+    usb_vcp_send_strn(str, strlen(str));
+}
+
+void usb_vcp_send_strn(const char *str, int len) {
+#ifdef USE_DEVICE_MODE
+    if (dev_is_enabled) {
+        #if 0
+        USBD_CDC_fops.pIf_DataTx((const uint8_t*)str, len);
+        #endif
+    }
+#endif
+}
+
+#include "usbd_conf.h"
+
+/* These are external variables imported from CDC core to be used for IN 
+   transfer management. */
+#ifdef USE_DEVICE_MODE
+extern uint8_t UserRxBuffer[];/* Received Data over USB are stored in this buffer */
+extern uint8_t UserTxBuffer[];/* Received Data over UART (CDC interface) are stored in this buffer */
+extern uint32_t BuffLength;
+extern uint32_t UserTxBufPtrIn;/* Increment this pointer or roll it back to
+                                  start address when data are received over USART */
+extern uint32_t UserTxBufPtrOut; /* Increment this pointer or roll it back to
+                                    start address when data are sent over USB */
+#endif
+
+void usb_vcp_send_strn_cooked(const char *str, int len) {
+#ifdef USE_DEVICE_MODE
+    #if 0
+    for (const char *top = str + len; str < top; str++) {
+        if (*str == '\n') {
+            APP_Rx_Buffer[APP_Rx_ptr_in] = '\r';
+            APP_Rx_ptr_in = (APP_Rx_ptr_in + 1) & (APP_RX_DATA_SIZE - 1);
+        }
+        APP_Rx_Buffer[APP_Rx_ptr_in] = *str;
+        APP_Rx_ptr_in = (APP_Rx_ptr_in + 1) & (APP_RX_DATA_SIZE - 1);
+    }
+    #endif
+#endif
+}
+
+void usb_hid_send_report(uint8_t *buf) {
+#ifdef USE_DEVICE_MODE
+    #if 0
+    USBD_HID_SendReport(&USB_OTG_Core, buf, 4);
+    #endif
+#endif
+}
+
+/******************************************************************************/
+// code for experimental USB OTG support
+
+#ifdef USE_HOST_MODE
+
+#include "led.h"
+#include "usbh_core.h"
+#include "usbh_usr.h"
+#include "usbh_hid_core.h"
+#include "usbh_hid_keybd.h"
+#include "usbh_hid_mouse.h"
+
+__ALIGN_BEGIN USBH_HOST USB_Host __ALIGN_END ;
+
+static int host_is_enabled = 0;
+
+void pyb_usb_host_init(void) {
+    if (!host_is_enabled) {
+        // only init USBH once in the device's power-lifetime
+        /* Init Host Library */
+        USBH_Init(&USB_OTG_Core, USB_OTG_FS_CORE_ID, &USB_Host, &HID_cb, &USR_Callbacks);
+    }
+    host_is_enabled = 1;
+}
+
+void pyb_usb_host_process(void) {
+    USBH_Process(&USB_OTG_Core, &USB_Host);
+}
+
+uint8_t usb_keyboard_key = 0;
+
+// TODO this is an ugly hack to get key presses
+uint pyb_usb_host_get_keyboard(void) {
+    uint key = usb_keyboard_key;
+    usb_keyboard_key = 0;
+    return key;
+}
+
+void USR_MOUSE_Init(void) {
+    led_state(4, 1);
+    USB_OTG_BSP_mDelay(100);
+    led_state(4, 0);
+}
+
+void USR_MOUSE_ProcessData(HID_MOUSE_Data_TypeDef *data) {
+    led_state(4, 1);
+    USB_OTG_BSP_mDelay(50);
+    led_state(4, 0);
+}
+
+void USR_KEYBRD_Init(void) {
+    led_state(4, 1);
+    USB_OTG_BSP_mDelay(100);
+    led_state(4, 0);
+}
+
+void USR_KEYBRD_ProcessData(uint8_t pbuf) {
+    led_state(4, 1);
+    USB_OTG_BSP_mDelay(50);
+    led_state(4, 0);
+    //lcd_print_strn((char*)&pbuf, 1);
+    usb_keyboard_key = pbuf;
+}
+
+#endif // USE_HOST_MODE

stmhal/usb.h

@@ -0,0 +1,23 @@
+#define VCP_CHAR_NONE   (0)
+#define VCP_CHAR_CTRL_A (1)
+#define VCP_CHAR_CTRL_B (2)
+#define VCP_CHAR_CTRL_C (3)
+#define VCP_CHAR_CTRL_D (4)
+
+#define PYB_USB_DEV_VCP_MSC (0)
+#define PYB_USB_DEV_HID (1)
+
+void pyb_usb_dev_init(int usb_dev_type);
+bool usb_vcp_is_enabled(void);
+bool usb_vcp_is_connected(void);
+void usb_vcp_set_interrupt_char(int c);
+int usb_vcp_rx_any(void);
+char usb_vcp_rx_get(void);
+void usb_vcp_send_str(const char* str);
+void usb_vcp_send_strn(const char* str, int len);
+void usb_vcp_send_strn_cooked(const char *str, int len);
+void usb_hid_send_report(uint8_t *buf); // 4 bytes for mouse: ?, x, y, ?
+
+void pyb_usb_host_init(void);
+void pyb_usb_host_process(void);
+uint pyb_usb_host_get_keyboard(void);

stmhal/usbd_cdc_interface.c

@@ -0,0 +1,461 @@
+/**
+  ******************************************************************************
+  * @file    USB_Device/CDC_Standalone/Src/usbd_cdc_interface.c
+  * @author  MCD Application Team
+  * @version V1.0.1
+  * @date    26-February-2014
+  * @brief   Source file for USBD CDC interface
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
+  *
+  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
+  * You may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at:
+  *
+  *        http://www.st.com/software_license_agreement_liberty_v2
+  *
+  * Unless required by applicable law or agreed to in writing, software 
+  * distributed under the License is distributed on an "AS IS" BASIS, 
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  *
+  ******************************************************************************
+  */
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f4xx_hal.h"
+#include "usbd_cdc_interface.h"
+
+/** @addtogroup STM32_USB_OTG_DEVICE_LIBRARY
+  * @{
+  */
+
+/** @defgroup USBD_CDC 
+  * @brief usbd core module
+  * @{
+  */ 
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+#define APP_RX_DATA_SIZE  2048
+#define APP_TX_DATA_SIZE  2048
+
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+USBD_CDC_LineCodingTypeDef LineCoding =
+  {
+    115200, /* baud rate*/
+    0x00,   /* stop bits-1*/
+    0x00,   /* parity - none*/
+    0x08    /* nb. of bits 8*/
+  };
+
+uint8_t UserRxBuffer[APP_RX_DATA_SIZE];/* Received Data over USB are stored in this buffer */
+uint8_t UserTxBuffer[APP_TX_DATA_SIZE];/* Received Data over UART (CDC interface) are stored in this buffer */
+uint32_t BuffLength;
+uint32_t UserTxBufPtrIn = 0;/* Increment this pointer or roll it back to
+                               start address when data are received over USART */
+uint32_t UserTxBufPtrOut = 0; /* Increment this pointer or roll it back to
+                                 start address when data are sent over USB */
+
+/* UART handler declaration */
+UART_HandleTypeDef UartHandle;
+/* TIM handler declaration */
+TIM_HandleTypeDef    TimHandle;
+/* USB handler declaration */
+extern USBD_HandleTypeDef  hUSBDDevice;
+
+/* Private function prototypes -----------------------------------------------*/
+static int8_t CDC_Itf_Init     (void);
+static int8_t CDC_Itf_DeInit   (void);
+static int8_t CDC_Itf_Control  (uint8_t cmd, uint8_t* pbuf, uint16_t length);
+static int8_t CDC_Itf_Receive  (uint8_t* pbuf, uint32_t *Len);
+
+static void Error_Handler(void);
+static void ComPort_Config(void);
+//static void TIM_Config(void);
+
+USBD_CDC_ItfTypeDef USBD_CDC_fops = 
+{
+  CDC_Itf_Init,
+  CDC_Itf_DeInit,
+  CDC_Itf_Control,
+  CDC_Itf_Receive
+};
+
+/* Private functions ---------------------------------------------------------*/
+
+/**
+  * @brief  CDC_Itf_Init
+  *         Initializes the CDC media low layer
+  * @param  None
+  * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL
+  */
+static int8_t CDC_Itf_Init(void)
+{
+#if 0
+  /*##-1- Configure the UART peripheral ######################################*/
+  /* Put the USART peripheral in the Asynchronous mode (UART Mode) */
+  /* USART configured as follow:
+      - Word Length = 8 Bits
+      - Stop Bit    = One Stop bit
+      - Parity      = No parity
+      - BaudRate    = 115200 baud
+      - Hardware flow control disabled (RTS and CTS signals) */
+  UartHandle.Instance        = USARTx;
+  UartHandle.Init.BaudRate   = 115200;
+  UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
+  UartHandle.Init.StopBits   = UART_STOPBITS_1;
+  UartHandle.Init.Parity     = UART_PARITY_NONE;
+  UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
+  UartHandle.Init.Mode       = UART_MODE_TX_RX;
+  
+  if(HAL_UART_Init(&UartHandle) != HAL_OK)
+  {
+    /* Initialization Error */
+    Error_Handler();
+  }
+  
+  /*##-2- Put UART peripheral in IT reception process ########################*/
+  /* Any data received will be stored in "UserTxBuffer" buffer  */
+  if(HAL_UART_Receive_IT(&UartHandle, (uint8_t *)UserTxBuffer, 1) != HAL_OK)
+  {
+    /* Transfer error in reception process */
+    Error_Handler();
+  }
+  
+  /*##-3- Configure the TIM Base generation  #################################*/
+  TIM_Config();
+  
+  /*##-4- Start the TIM Base generation in interrupt mode ####################*/
+  /* Start Channel1 */
+  if(HAL_TIM_Base_Start_IT(&TimHandle) != HAL_OK)
+  {
+    /* Starting Error */
+    Error_Handler();
+  }
+#endif
+  
+  /*##-5- Set Application Buffers ############################################*/
+  USBD_CDC_SetTxBuffer(&hUSBDDevice, UserTxBuffer, 0);
+  USBD_CDC_SetRxBuffer(&hUSBDDevice, UserRxBuffer);
+  
+  return (USBD_OK);
+}
+
+/**
+  * @brief  CDC_Itf_DeInit
+  *         DeInitializes the CDC media low layer
+  * @param  None
+  * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL
+  */
+static int8_t CDC_Itf_DeInit(void)
+{
+#if 0
+  /* DeInitialize the UART peripheral */
+  if(HAL_UART_DeInit(&UartHandle) != HAL_OK)
+  {
+    /* Initialization Error */
+    Error_Handler();
+  }
+#endif
+  return (USBD_OK);
+}
+
+/**
+  * @brief  CDC_Itf_Control
+  *         Manage the CDC class requests
+  * @param  Cmd: Command code            
+  * @param  Buf: Buffer containing command data (request parameters)
+  * @param  Len: Number of data to be sent (in bytes)
+  * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL
+  */
+static int8_t CDC_Itf_Control (uint8_t cmd, uint8_t* pbuf, uint16_t length)
+{ 
+  switch (cmd)
+  {
+  case CDC_SEND_ENCAPSULATED_COMMAND:
+    /* Add your code here */
+    break;
+
+  case CDC_GET_ENCAPSULATED_RESPONSE:
+    /* Add your code here */
+    break;
+
+  case CDC_SET_COMM_FEATURE:
+    /* Add your code here */
+    break;
+
+  case CDC_GET_COMM_FEATURE:
+    /* Add your code here */
+    break;
+
+  case CDC_CLEAR_COMM_FEATURE:
+    /* Add your code here */
+    break;
+
+  case CDC_SET_LINE_CODING:
+    LineCoding.bitrate    = (uint32_t)(pbuf[0] | (pbuf[1] << 8) |\
+                            (pbuf[2] << 16) | (pbuf[3] << 24));
+    LineCoding.format     = pbuf[4];
+    LineCoding.paritytype = pbuf[5];
+    LineCoding.datatype   = pbuf[6];
+    
+    /* Set the new configuration */
+    ComPort_Config();
+    break;
+
+  case CDC_GET_LINE_CODING:
+    pbuf[0] = (uint8_t)(LineCoding.bitrate);
+    pbuf[1] = (uint8_t)(LineCoding.bitrate >> 8);
+    pbuf[2] = (uint8_t)(LineCoding.bitrate >> 16);
+    pbuf[3] = (uint8_t)(LineCoding.bitrate >> 24);
+    pbuf[4] = LineCoding.format;
+    pbuf[5] = LineCoding.paritytype;
+    pbuf[6] = LineCoding.datatype;     
+    
+    /* Add your code here */
+    break;
+
+  case CDC_SET_CONTROL_LINE_STATE:
+    /* Add your code here */
+    break;
+
+  case CDC_SEND_BREAK:
+     /* Add your code here */
+    break;    
+    
+  default:
+    break;
+  }
+  
+  return (USBD_OK);
+}
+
+/**
+  * @brief  TIM period elapsed callback
+  * @param  htim: TIM handle
+  * @retval None
+  */
+void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
+{
+  uint32_t buffptr;
+  uint32_t buffsize;
+  
+  if(UserTxBufPtrOut != UserTxBufPtrIn)
+  {
+    if(UserTxBufPtrOut > UserTxBufPtrIn) /* rollback */
+    {
+      buffsize = APP_RX_DATA_SIZE - UserTxBufPtrOut;
+    }
+    else 
+    {
+      buffsize = UserTxBufPtrIn - UserTxBufPtrOut;
+    }
+    
+    buffptr = UserTxBufPtrOut;
+    
+    USBD_CDC_SetTxBuffer(&hUSBDDevice, (uint8_t*)&UserTxBuffer[buffptr], buffsize);
+    
+    if(USBD_CDC_TransmitPacket(&hUSBDDevice) == USBD_OK)
+    {
+      UserTxBufPtrOut += buffsize;
+      if (UserTxBufPtrOut == APP_RX_DATA_SIZE)
+      {
+        UserTxBufPtrOut = 0;
+      }
+    }
+  }
+}
+
+/**
+  * @brief  Rx Transfer completed callback
+  * @param  huart: UART handle
+  * @retval None
+  */
+void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
+{
+  /* Increment Index for buffer writing */
+  UserTxBufPtrIn++;
+  
+  /* To avoid buffer overflow */
+  if(UserTxBufPtrIn == APP_RX_DATA_SIZE)
+  {
+    UserTxBufPtrIn = 0;
+  }
+  
+  /* Start another reception: provide the buffer pointer with offset and the buffer size */
+  HAL_UART_Receive_IT(huart, (uint8_t *)(UserTxBuffer + UserTxBufPtrIn), 1);
+}
+
+/**
+  * @brief  CDC_Itf_DataRx
+  *         Data received over USB OUT endpoint are sent over CDC interface 
+  *         through this function.
+  * @param  Buf: Buffer of data to be transmitted
+  * @param  Len: Number of data received (in bytes)
+  * @retval Result of the opeartion: USBD_OK if all operations are OK else USBD_FAIL
+  */
+static int8_t CDC_Itf_Receive(uint8_t* Buf, uint32_t *Len)
+{
+  HAL_UART_Transmit_DMA(&UartHandle, Buf, *Len);
+  return (USBD_OK);
+}
+
+/**
+  * @brief  Tx Transfer completed callback
+  * @param  huart: UART handle
+  * @retval None
+  */
+void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
+{
+  /* Initiate next USB packet transfer once UART completes transfer (transmitting data over Tx line) */
+  USBD_CDC_ReceivePacket(&hUSBDDevice);
+}
+
+/**
+  * @brief  ComPort_Config
+  *         Configure the COM Port with the parameters received from host.
+  * @param  None.
+  * @retval None.
+  * @note   When a configuration is not supported, a default value is used.
+  */
+static void ComPort_Config(void)
+{
+  if(HAL_UART_DeInit(&UartHandle) != HAL_OK)
+  {
+    /* Initialization Error */
+    Error_Handler();
+  }
+  
+  /* set the Stop bit */
+  switch (LineCoding.format)
+  {
+  case 0:
+    UartHandle.Init.StopBits = UART_STOPBITS_1;
+    break;
+  case 2:
+    UartHandle.Init.StopBits = UART_STOPBITS_2;
+    break;
+  default :
+    UartHandle.Init.StopBits = UART_STOPBITS_1;
+    break;
+  }
+  
+  /* set the parity bit*/
+  switch (LineCoding.paritytype)
+  {
+  case 0:
+    UartHandle.Init.Parity = UART_PARITY_NONE;
+    break;
+  case 1:
+    UartHandle.Init.Parity = UART_PARITY_ODD;
+    break;
+  case 2:
+    UartHandle.Init.Parity = UART_PARITY_EVEN;
+    break;
+  default :
+    UartHandle.Init.Parity = UART_PARITY_NONE;
+    break;
+  }
+  
+  /*set the data type : only 8bits and 9bits is supported */
+  switch (LineCoding.datatype)
+  {
+  case 0x07:
+    /* With this configuration a parity (Even or Odd) must be set */
+    UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
+    break;
+  case 0x08:
+    if(UartHandle.Init.Parity == UART_PARITY_NONE)
+    {
+      UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
+    }
+    else 
+    {
+      UartHandle.Init.WordLength = UART_WORDLENGTH_9B;
+    }
+    
+    break;
+  default :
+    UartHandle.Init.WordLength = UART_WORDLENGTH_8B;
+    break;
+  }
+  
+  UartHandle.Init.BaudRate = LineCoding.bitrate;
+  UartHandle.Init.HwFlowCtl  = UART_HWCONTROL_NONE;
+  UartHandle.Init.Mode       = UART_MODE_TX_RX;
+  
+  if(HAL_UART_Init(&UartHandle) != HAL_OK)
+  {
+    /* Initialization Error */
+    Error_Handler();
+  }
+
+  /* Start reception: provide the buffer pointer with offset and the buffer size */
+  HAL_UART_Receive_IT(&UartHandle, (uint8_t *)(UserTxBuffer + UserTxBufPtrIn), 1);
+}
+
+/**
+  * @brief  TIM_Config: Configure TIMx timer
+  * @param  None.
+  * @retval None.
+  */
+#if 0
+static void TIM_Config(void)
+{  
+  /* Set TIMx instance */
+  TimHandle.Instance = TIMx;
+  
+  /* Initialize TIM3 peripheral as follow:
+       + Period = 10000 - 1
+       + Prescaler = ((SystemCoreClock/2)/10000) - 1
+       + ClockDivision = 0
+       + Counter direction = Up
+  */
+  TimHandle.Init.Period = (CDC_POLLING_INTERVAL*1000) - 1;
+  TimHandle.Init.Prescaler = 84-1;
+  TimHandle.Init.ClockDivision = 0;
+  TimHandle.Init.CounterMode = TIM_COUNTERMODE_UP;
+  if(HAL_TIM_Base_Init(&TimHandle) != HAL_OK)
+  {
+    /* Initialization Error */
+    Error_Handler();
+  }
+}
+#endif
+
+/**
+  * @brief  UART error callbacks
+  * @param  UartHandle: UART handle
+  * @retval None
+  */
+void HAL_UART_ErrorCallback(UART_HandleTypeDef *UartHandle)
+{
+  /* Transfer error occured in reception and/or transmission process */
+  Error_Handler();
+}
+
+/**
+  * @brief  This function is executed in case of error occurrence.
+  * @param  None
+  * @retval None
+  */
+static void Error_Handler(void)
+{
+  /* Add your own code here */
+}
+
+/**
+  * @}
+  */ 
+
+/**
+  * @}
+  */ 
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+

stmhal/usbd_cdc_interface.h

@@ -0,0 +1,87 @@
+/**
+  ******************************************************************************
+  * @file    USB_Device/CDC_Standalone/Inc/usbd_cdc_interface.h
+  * @author  MCD Application Team
+  * @version V1.0.1
+  * @date    26-February-2014
+  * @brief   Header for usbd_cdc_interface.c file.
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
+  *
+  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
+  * You may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at:
+  *
+  *        http://www.st.com/software_license_agreement_liberty_v2
+  *
+  * Unless required by applicable law or agreed to in writing, software 
+  * distributed under the License is distributed on an "AS IS" BASIS, 
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  *
+  ******************************************************************************
+  */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __USBD_CDC_IF_H
+#define __USBD_CDC_IF_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "usbd_cdc.h"
+
+/* Exported types ------------------------------------------------------------*/
+/* Exported constants --------------------------------------------------------*/
+/* User can use this section to tailor USARTx/UARTx instance used and associated 
+   resources */
+/* Definition for USARTx clock resources */
+#define USARTx                           USART3
+#define USARTx_CLK_ENABLE()              __USART3_CLK_ENABLE();
+#define DMAx_CLK_ENABLE()                __DMA1_CLK_ENABLE()
+#define USARTx_RX_GPIO_CLK_ENABLE()      __GPIOC_CLK_ENABLE()
+#define USARTx_TX_GPIO_CLK_ENABLE()      __GPIOC_CLK_ENABLE() 
+
+#define USARTx_FORCE_RESET()             __USART3_FORCE_RESET()
+#define USARTx_RELEASE_RESET()           __USART3_RELEASE_RESET()
+
+/* Definition for USARTx Pins */
+#define USARTx_TX_PIN                    GPIO_PIN_10
+#define USARTx_TX_GPIO_PORT              GPIOC  
+#define USARTx_TX_AF                     GPIO_AF7_USART3
+#define USARTx_RX_PIN                    GPIO_PIN_11
+#define USARTx_RX_GPIO_PORT              GPIOC 
+#define USARTx_RX_AF                     GPIO_AF7_USART3
+
+/* Definition for USARTx's NVIC: used for receiving data over Rx pin */
+#define USARTx_IRQn                      USART3_IRQn
+#define USARTx_IRQHandler                USART3_IRQHandler
+
+/* Definition for USARTx's DMA: used for transmitting data over Tx pin */
+#define USARTx_TX_DMA_CHANNEL            DMA_CHANNEL_4
+#define USARTx_TX_DMA_STREAM             DMA1_Stream3  
+#define USARTx_DMA_TX_IRQHandler         DMA1_Stream3_IRQHandler
+#define USARTx_DMA_TX_IRQn               DMA1_Stream3_IRQn
+
+/* Definition for TIMx clock resources */
+#define TIMx                             TIM3
+#define TIMx_CLK_ENABLE                  __TIM3_CLK_ENABLE
+#define TIMx_FORCE_RESET()               __USART3_FORCE_RESET()
+#define TIMx_RELEASE_RESET()             __USART3_RELEASE_RESET()
+
+/* Definition for TIMx's NVIC */
+#define TIMx_IRQn                        TIM3_IRQn
+#define TIMx_IRQHandler                  TIM3_IRQHandler
+
+/* Periodically, the state of the buffer "UserTxBuffer" is checked.
+   The period depends on CDC_POLLING_INTERVAL */
+#define CDC_POLLING_INTERVAL             5 /* in ms. The max is 65 and the min is 1 */
+
+extern USBD_CDC_ItfTypeDef  USBD_CDC_fops;
+
+/* Exported macro ------------------------------------------------------------*/
+/* Exported functions ------------------------------------------------------- */
+#endif /* __USBD_CDC_IF_H */
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

stmhal/usbd_conf.c

@@ -0,0 +1,565 @@
+/**
+  ******************************************************************************
+  * @file    USB_Device/CDC_Standalone/Src/usbd_conf.c
+  * @author  MCD Application Team
+  * @version V1.0.1
+  * @date    26-February-2014
+  * @brief   This file implements the USB Device library callbacks and MSP
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
+  *
+  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
+  * You may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at:
+  *
+  *        http://www.st.com/software_license_agreement_liberty_v2
+  *
+  * Unless required by applicable law or agreed to in writing, software 
+  * distributed under the License is distributed on an "AS IS" BASIS, 
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  *
+  ******************************************************************************
+  */
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f4xx_hal.h"
+#include "usbd_core.h"
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+/* Private macro -------------------------------------------------------------*/
+/* Private variables ---------------------------------------------------------*/
+PCD_HandleTypeDef hpcd;
+
+/* Private function prototypes -----------------------------------------------*/
+/* Private functions ---------------------------------------------------------*/
+
+/*******************************************************************************
+                       PCD BSP Routines
+*******************************************************************************/
+/**
+  * @brief  Initializes the PCD MSP.
+  * @param  hpcd: PCD handle
+  * @retval None
+  */
+void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd)
+{
+  GPIO_InitTypeDef  GPIO_InitStruct;
+  
+  if(hpcd->Instance == USB_OTG_FS)
+  {
+    /* Configure USB FS GPIOs */
+    __GPIOA_CLK_ENABLE();
+    
+    GPIO_InitStruct.Pin = (GPIO_PIN_11 | GPIO_PIN_12);
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;
+    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); 
+    
+	/* Configure VBUS Pin */
+    GPIO_InitStruct.Pin = GPIO_PIN_9;
+    GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
+	
+    GPIO_InitStruct.Pin = GPIO_PIN_10;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
+    GPIO_InitStruct.Pull = GPIO_PULLUP;
+    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_FS;
+    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); 
+
+    /* Enable USB FS Clocks */ 
+    __USB_OTG_FS_CLK_ENABLE();
+    
+    /* Set USBFS Interrupt priority */
+    HAL_NVIC_SetPriority(OTG_FS_IRQn, 6, 0);
+    
+    /* Enable USBFS Interrupt */
+    HAL_NVIC_EnableIRQ(OTG_FS_IRQn);
+  } 
+  
+  else if(hpcd->Instance == USB_OTG_HS)
+  {
+    /* Configure USB FS GPIOs */
+    __GPIOA_CLK_ENABLE();
+    __GPIOB_CLK_ENABLE();
+    __GPIOC_CLK_ENABLE();
+    __GPIOH_CLK_ENABLE();
+    __GPIOI_CLK_ENABLE();
+    
+    /* CLK */
+    GPIO_InitStruct.Pin = GPIO_PIN_5;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
+    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); 
+    
+    /* D0 */
+    GPIO_InitStruct.Pin = GPIO_PIN_3;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Speed = GPIO_SPEED_HIGH;
+    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
+    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct); 
+    
+    /* D1 D2 D3 D4 D5 D6 D7 */
+    GPIO_InitStruct.Pin = GPIO_PIN_0  | GPIO_PIN_1  | GPIO_PIN_5 |\
+                          GPIO_PIN_10 | GPIO_PIN_11 | GPIO_PIN_12 | GPIO_PIN_13;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
+    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct); 
+    
+    /* STP */    
+    GPIO_InitStruct.Pin = GPIO_PIN_0;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
+    HAL_GPIO_Init(GPIOC, &GPIO_InitStruct); 
+    
+    /* NXT */ 
+    GPIO_InitStruct.Pin = GPIO_PIN_4;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
+    HAL_GPIO_Init(GPIOH, &GPIO_InitStruct);   
+    
+    /* DIR */
+    GPIO_InitStruct.Pin = GPIO_PIN_11;
+    GPIO_InitStruct.Mode = GPIO_MODE_AF_PP;
+    GPIO_InitStruct.Pull = GPIO_NOPULL;
+    GPIO_InitStruct.Alternate = GPIO_AF10_OTG_HS;
+    HAL_GPIO_Init(GPIOI, &GPIO_InitStruct);
+    
+    /* Enable USB HS Clocks */
+    __USB_OTG_HS_CLK_ENABLE();
+    __USB_OTG_HS_ULPI_CLK_ENABLE();
+    
+    /* Set USBHS Interrupt to the lowest priority */
+    HAL_NVIC_SetPriority(OTG_HS_IRQn, 6, 0);
+    
+    /* Enable USBHS Interrupt */
+    HAL_NVIC_EnableIRQ(OTG_HS_IRQn);
+  }   
+}
+/**
+  * @brief  DeInitializes the PCD MSP.
+  * @param  hpcd: PCD handle
+  * @retval None
+  */
+void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd)
+{
+  if(hpcd->Instance == USB_OTG_FS)
+  {  
+    /* Disable USB FS Clocks */ 
+    __USB_OTG_FS_CLK_DISABLE();
+    __SYSCFG_CLK_DISABLE(); 
+  }
+  else if(hpcd->Instance == USB_OTG_HS)
+  {  
+    /* Disable USB FS Clocks */ 
+    __USB_OTG_HS_CLK_DISABLE();
+    __SYSCFG_CLK_DISABLE(); 
+  }  
+}
+
+/*******************************************************************************
+                       LL Driver Callbacks (PCD -> USB Device Library)
+*******************************************************************************/
+
+
+/**
+  * @brief  Setup stage callback.
+  * @param  hpcd: PCD handle
+  * @retval None
+  */
+void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
+{
+  USBD_LL_SetupStage(hpcd->pData, (uint8_t *)hpcd->Setup);
+}
+
+/**
+  * @brief  Data Out stage callback.
+  * @param  hpcd: PCD handle
+  * @param  epnum: Endpoint Number
+  * @retval None
+  */
+void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
+{
+  USBD_LL_DataOutStage(hpcd->pData, epnum, hpcd->OUT_ep[epnum].xfer_buff);
+}
+
+/**
+  * @brief  Data In stage callback.
+  * @param  hpcd: PCD handle
+  * @param  epnum: Endpoint Number
+  * @retval None
+  */
+void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
+{
+  USBD_LL_DataInStage(hpcd->pData, epnum, hpcd->IN_ep[epnum].xfer_buff);
+}
+
+/**
+  * @brief  SOF callback.
+  * @param  hpcd: PCD handle
+  * @retval None
+  */
+void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
+{
+  USBD_LL_SOF(hpcd->pData);
+}
+
+/**
+  * @brief  Reset callback.
+  * @param  hpcd: PCD handle
+  * @retval None
+  */
+void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
+{ 
+  USBD_SpeedTypeDef speed = USBD_SPEED_FULL;
+
+  /* Set USB Current Speed */
+  switch(hpcd->Init.speed)
+  {
+  case PCD_SPEED_HIGH:
+    speed = USBD_SPEED_HIGH;
+    break;
+    
+  case PCD_SPEED_FULL:
+    speed = USBD_SPEED_FULL;    
+    break;
+	
+	default:
+    speed = USBD_SPEED_FULL;    
+    break;
+  }
+  USBD_LL_SetSpeed(hpcd->pData, speed);  
+  
+  /* Reset Device */
+  USBD_LL_Reset(hpcd->pData);
+}
+
+/**
+  * @brief  Suspend callback.
+  * @param  hpcd: PCD handle
+  * @retval None
+  */
+void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
+{
+  USBD_LL_Suspend(hpcd->pData);
+}
+
+/**
+  * @brief  Resume callback.
+  * @param  hpcd: PCD handle
+  * @retval None
+  */
+void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
+{
+  USBD_LL_Resume(hpcd->pData);
+}
+
+/**
+  * @brief  ISOC Out Incomplete callback.
+  * @param  hpcd: PCD handle
+  * @param  epnum: Endpoint Number  
+  * @retval None
+  */
+void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
+{
+  USBD_LL_IsoOUTIncomplete(hpcd->pData, epnum);
+}
+
+/**
+  * @brief  ISOC In Incomplete callback.
+  * @param  hpcd: PCD handle
+  * @param  epnum: Endpoint Number  
+  * @retval None
+  */
+void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
+{
+  USBD_LL_IsoINIncomplete(hpcd->pData, epnum);
+}
+
+/**
+  * @brief  Connect callback.
+  * @param  hpcd: PCD handle
+  * @retval None
+  */
+void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
+{
+  USBD_LL_DevConnected(hpcd->pData);
+}
+
+/**
+  * @brief  Disconnect callback.
+  * @param  hpcd: PCD handle
+  * @retval None
+  */
+void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
+{
+  USBD_LL_DevDisconnected(hpcd->pData);
+}
+
+/*******************************************************************************
+                       LL Driver Interface (USB Device Library --> PCD)
+*******************************************************************************/
+/**
+  * @brief  Initializes the Low Level portion of the Device driver.  
+  * @param  pdev: Device handle
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef  USBD_LL_Init (USBD_HandleTypeDef *pdev)
+{ 
+#ifdef USE_USB_FS  
+  /*Set LL Driver parameters */
+  hpcd.Instance = USB_OTG_FS;
+  hpcd.Init.dev_endpoints = 4; 
+  hpcd.Init.use_dedicated_ep1 = 0;
+  hpcd.Init.ep0_mps = 0x40;  
+  hpcd.Init.dma_enable = 0;
+  hpcd.Init.low_power_enable = 0;
+  hpcd.Init.phy_itface = PCD_PHY_EMBEDDED; 
+  hpcd.Init.Sof_enable = 0;
+  hpcd.Init.speed = PCD_SPEED_FULL;
+  hpcd.Init.vbus_sensing_enable = 1;
+  /* Link The driver to the stack */
+  hpcd.pData = pdev;
+  pdev->pData = &hpcd;
+  /*Initialize LL Driver */
+  HAL_PCD_Init(&hpcd);
+  
+  HAL_PCD_SetRxFiFo(&hpcd, 0x80);
+  HAL_PCD_SetTxFiFo(&hpcd, 0, 0x40);
+  HAL_PCD_SetTxFiFo(&hpcd, 1, 0x80); 
+
+
+#endif 
+#ifdef USE_USB_HS  
+  /*Set LL Driver parameters */
+  hpcd.Instance = USB_OTG_HS;
+  hpcd.Init.dev_endpoints = 6; 
+  hpcd.Init.use_dedicated_ep1 = 0;
+  hpcd.Init.ep0_mps = 0x40;
+  
+  /* Be aware that enabling USB-DMA mode will result in data being sent only by
+     multiple of 4 packet sizes. This is due to the fact that USB-DMA does
+     not allow sending data from non word-aligned addresses.
+     For this specific application, it is advised to not enable this option
+     unless required. */
+  hpcd.Init.dma_enable = 0;
+  
+  hpcd.Init.low_power_enable = 0;
+  hpcd.Init.phy_itface = PCD_PHY_ULPI; 
+  hpcd.Init.Sof_enable = 0;
+  hpcd.Init.speed = PCD_SPEED_HIGH;
+  hpcd.Init.vbus_sensing_enable = 1;
+  /* Link The driver to the stack */
+  hpcd.pData = pdev;
+  pdev->pData = &hpcd;
+  /*Initialize LL Driver */
+  HAL_PCD_Init(&hpcd);
+  
+  HAL_PCD_SetRxFiFo(&hpcd, 0x200);
+  HAL_PCD_SetTxFiFo(&hpcd, 0, 0x80);
+  HAL_PCD_SetTxFiFo(&hpcd, 1, 0x174); 
+
+  
+#endif 
+  return USBD_OK;
+}
+
+/**
+  * @brief  De-Initializes the Low Level portion of the Device driver. 
+  * @param  pdev: Device handle
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_DeInit(USBD_HandleTypeDef *pdev)
+{
+  HAL_PCD_DeInit(pdev->pData);
+  return USBD_OK; 
+}
+
+/**
+  * @brief  Starts the Low Level portion of the Device driver.    
+  * @param  pdev: Device handle
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_Start(USBD_HandleTypeDef *pdev)
+{
+  HAL_PCD_Start(pdev->pData);
+  return USBD_OK; 
+}
+
+/**
+  * @brief  Stops the Low Level portion of the Device driver.
+  * @param  pdev: Device handle
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_Stop(USBD_HandleTypeDef *pdev)
+{
+  HAL_PCD_Stop(pdev->pData);
+  return USBD_OK; 
+}
+
+/**
+  * @brief  Opens an endpoint of the Low Level Driver. 
+  * @param  pdev: Device handle
+  * @param  ep_addr: Endpoint Number
+  * @param  ep_type: Endpoint Type
+  * @param  ep_mps: Endpoint Max Packet Size                 
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_OpenEP(USBD_HandleTypeDef *pdev, 
+                                  uint8_t  ep_addr,                                      
+                                  uint8_t  ep_type,
+                                  uint16_t ep_mps)
+{
+  HAL_PCD_EP_Open(pdev->pData, ep_addr, ep_mps, ep_type);
+  return USBD_OK; 
+}
+
+/**
+  * @brief  Closes an endpoint of the Low Level Driver.  
+  * @param  pdev: Device handle
+  * @param  ep_addr: Endpoint Number      
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_CloseEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)   
+{
+  HAL_PCD_EP_Close(pdev->pData, ep_addr);
+  return USBD_OK; 
+}
+
+/**
+  * @brief  Flushes an endpoint of the Low Level Driver.
+  * @param  pdev: Device handle
+  * @param  ep_addr: Endpoint Number      
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_FlushEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)   
+{
+  HAL_PCD_EP_Flush(pdev->pData, ep_addr);
+  return USBD_OK; 
+}
+
+/**
+  * @brief  Sets a Stall condition on an endpoint of the Low Level Driver.
+  * @param  pdev: Device handle
+  * @param  ep_addr: Endpoint Number      
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_StallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)   
+{
+  HAL_PCD_EP_SetStall(pdev->pData, ep_addr);
+  return USBD_OK; 
+}
+
+/**
+  * @brief  Clears a Stall condition on an endpoint of the Low Level Driver.
+  * @param  pdev: Device handle
+  * @param  ep_addr: Endpoint Number      
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_ClearStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)   
+{
+  HAL_PCD_EP_ClrStall(pdev->pData, ep_addr);  
+  return USBD_OK; 
+}
+
+/**
+  * @brief  Returns Stall condition.
+  * @param  pdev: Device handle
+  * @param  ep_addr: Endpoint Number      
+  * @retval Stall (1: yes, 0: No)
+  */
+uint8_t USBD_LL_IsStallEP(USBD_HandleTypeDef *pdev, uint8_t ep_addr)   
+{
+  PCD_HandleTypeDef *hpcd = pdev->pData; 
+  
+  if((ep_addr & 0x80) == 0x80)
+  {
+    return hpcd->IN_ep[ep_addr & 0x7F].is_stall; 
+  }
+  else
+  {
+    return hpcd->OUT_ep[ep_addr & 0x7F].is_stall; 
+  }
+}
+
+/**
+  * @brief  Assigns an USB address to the device
+  * @param  pdev: Device handle
+  * @param  dev_addr: USB address      
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_SetUSBAddress(USBD_HandleTypeDef *pdev, uint8_t dev_addr)   
+{
+  HAL_PCD_SetAddress(pdev->pData, dev_addr);
+  return USBD_OK; 
+}
+
+/**
+  * @brief  Transmits data over an endpoint 
+  * @param  pdev: Device handle
+  * @param  ep_addr: Endpoint Number
+  * @param  pbuf: Pointer to data to be sent    
+  * @param  size: Data size    
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_Transmit(USBD_HandleTypeDef *pdev, 
+                                    uint8_t  ep_addr,                                      
+                                    uint8_t  *pbuf,
+                                    uint16_t  size)
+{
+  HAL_PCD_EP_Transmit(pdev->pData, ep_addr, pbuf, size);
+  return USBD_OK;   
+}
+
+/**
+  * @brief  Prepares an endpoint for reception 
+  * @param  pdev: Device handle
+  * @param  ep_addr: Endpoint Number
+  * @param  pbuf:pointer to data to be received    
+  * @param  size: data size              
+  * @retval USBD Status
+  */
+USBD_StatusTypeDef USBD_LL_PrepareReceive(USBD_HandleTypeDef *pdev, 
+                                          uint8_t  ep_addr,                                      
+                                          uint8_t  *pbuf,
+                                          uint16_t  size)
+{
+  HAL_PCD_EP_Receive(pdev->pData, ep_addr, pbuf, size);
+  return USBD_OK;   
+}
+
+/**
+  * @brief  Returns the last transfered packet size.    
+  * @param  pdev: Device handle
+  * @param  ep_addr: Endpoint Number
+  * @retval Recived Data Size
+  */
+uint32_t USBD_LL_GetRxDataSize(USBD_HandleTypeDef *pdev, uint8_t  ep_addr)  
+{
+  return HAL_PCD_EP_GetRxCount(pdev->pData, ep_addr);
+}
+
+/**
+  * @brief  Delay routine for the USB Device Library      
+  * @param  Delay: Delay in ms
+  * @retval None
+  */
+void  USBD_LL_Delay(uint32_t Delay)
+{
+  HAL_Delay(Delay);  
+}
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

stmhal/usbd_conf.h

@@ -0,0 +1,87 @@
+/**
+  ******************************************************************************
+  * @file    USB_Device/CDC_Standalone/Inc/usbd_conf.h
+  * @author  MCD Application Team
+  * @version V1.0.1
+  * @date    26-February-2014
+  * @brief   General low level driver configuration
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
+  *
+  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
+  * You may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at:
+  *
+  *        http://www.st.com/software_license_agreement_liberty_v2
+  *
+  * Unless required by applicable law or agreed to in writing, software 
+  * distributed under the License is distributed on an "AS IS" BASIS, 
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  *
+  ******************************************************************************
+  */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __USBD_CONF_H
+#define __USBD_CONF_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "stm32f4xx_hal.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "mpconfig.h"
+#include "gc.h" // for gc_alloc and gc_free
+
+/* Exported types ------------------------------------------------------------*/
+/* Exported constants --------------------------------------------------------*/
+/* Common Config */
+#define USBD_MAX_NUM_INTERFACES               1
+#define USBD_MAX_NUM_CONFIGURATION            1
+#define USBD_MAX_STR_DESC_SIZ                 0x100
+#define USBD_SUPPORT_USER_STRING              0
+#define USBD_SELF_POWERED                     0
+#define USBD_DEBUG_LEVEL                      0
+ 
+/* Exported macro ------------------------------------------------------------*/
+/* Memory management macros */
+#define USBD_malloc               gc_alloc
+#define USBD_free                 gc_free
+#define USBD_memset               memset
+#define USBD_memcpy               memcpy
+    
+/* DEBUG macros */
+#if (USBD_DEBUG_LEVEL > 0)
+#define  USBD_UsrLog(...)   printf(__VA_ARGS__);\
+                            printf("\n");
+#else
+#define USBD_UsrLog(...)
+#endif
+
+#if (USBD_DEBUG_LEVEL > 1)
+
+#define  USBD_ErrLog(...)   printf("ERROR: ") ;\
+                            printf(__VA_ARGS__);\
+                            printf("\n");
+#else
+#define USBD_ErrLog(...)
+#endif
+
+#if (USBD_DEBUG_LEVEL > 2)
+#define  USBD_DbgLog(...)   printf("DEBUG : ") ;\
+                            printf(__VA_ARGS__);\
+                            printf("\n");
+#else
+#define USBD_DbgLog(...)
+#endif
+
+/* Exported functions ------------------------------------------------------- */
+
+#endif /* __USBD_CONF_H */
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

stmhal/usbd_desc.c

@@ -0,0 +1,228 @@
+/**
+  ******************************************************************************
+  * @file    USB_Device/CDC_Standalone/Src/usbd_desc.c
+  * @author  MCD Application Team
+  * @version V1.0.1
+  * @date    26-February-2014
+  * @brief   This file provides the USBD descriptors and string formating method.
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
+  *
+  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
+  * You may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at:
+  *
+  *        http://www.st.com/software_license_agreement_liberty_v2
+  *
+  * Unless required by applicable law or agreed to in writing, software 
+  * distributed under the License is distributed on an "AS IS" BASIS, 
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  *
+  ******************************************************************************
+  */
+
+/* Includes ------------------------------------------------------------------*/
+#include "usbd_core.h"
+#include "usbd_desc.h"
+#include "usbd_conf.h"
+
+/* Private typedef -----------------------------------------------------------*/
+/* Private define ------------------------------------------------------------*/
+#define USBD_VID                      0x0483
+#define USBD_PID                      0x5740
+#define USBD_LANGID_STRING            0x409
+#define USBD_MANUFACTURER_STRING      "STMicroelectronics"
+#define USBD_PRODUCT_HS_STRING        "STM32 Virtual ComPort in HS Mode"
+#define USBD_SERIALNUMBER_HS_STRING   "00000000001A"
+#define USBD_PRODUCT_FS_STRING        "STM32 Virtual ComPort in FS Mode"
+#define USBD_SERIALNUMBER_FS_STRING   "00000000001B"
+#define USBD_CONFIGURATION_HS_STRING  "VCP Config"
+#define USBD_INTERFACE_HS_STRING      "VCP Interface"
+#define USBD_CONFIGURATION_FS_STRING  "VCP Config"
+#define USBD_INTERFACE_FS_STRING      "VCP Interface"
+
+/* Private macro -------------------------------------------------------------*/
+/* Private function prototypes -----------------------------------------------*/
+uint8_t *USBD_VCP_DeviceDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
+uint8_t *USBD_VCP_LangIDStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
+uint8_t *USBD_VCP_ManufacturerStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
+uint8_t *USBD_VCP_ProductStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
+uint8_t *USBD_VCP_SerialStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
+uint8_t *USBD_VCP_ConfigStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
+uint8_t *USBD_VCP_InterfaceStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length);
+#ifdef USB_SUPPORT_USER_STRING_DESC
+uint8_t *USBD_VCP_USRStringDesc (USBD_SpeedTypeDef speed, uint8_t idx, uint16_t *length);  
+#endif /* USB_SUPPORT_USER_STRING_DESC */  
+
+/* Private variables ---------------------------------------------------------*/
+USBD_DescriptorsTypeDef VCP_Desc = {
+  USBD_VCP_DeviceDescriptor,
+  USBD_VCP_LangIDStrDescriptor, 
+  USBD_VCP_ManufacturerStrDescriptor,
+  USBD_VCP_ProductStrDescriptor,
+  USBD_VCP_SerialStrDescriptor,
+  USBD_VCP_ConfigStrDescriptor,
+  USBD_VCP_InterfaceStrDescriptor,  
+};
+
+/* USB Standard Device Descriptor */
+#if defined ( __ICCARM__ ) /*!< IAR Compiler */
+  #pragma data_alignment=4   
+#endif
+__ALIGN_BEGIN uint8_t hUSBDDeviceDesc[USB_LEN_DEV_DESC] __ALIGN_END = {
+  0x12,                       /* bLength */
+  USB_DESC_TYPE_DEVICE,       /* bDescriptorType */
+  0x00,                       /* bcdUSB */
+  0x02,
+  0x00,                       /* bDeviceClass */
+  0x00,                       /* bDeviceSubClass */
+  0x00,                       /* bDeviceProtocol */
+  USB_MAX_EP0_SIZE,           /* bMaxPacketSize */
+  LOBYTE(USBD_VID),           /* idVendor */
+  HIBYTE(USBD_VID),           /* idVendor */
+  LOBYTE(USBD_PID),           /* idVendor */
+  HIBYTE(USBD_PID),           /* idVendor */
+  0x00,                       /* bcdDevice rel. 2.00 */
+  0x02,
+  USBD_IDX_MFC_STR,           /* Index of manufacturer string */
+  USBD_IDX_PRODUCT_STR,       /* Index of product string */
+  USBD_IDX_SERIAL_STR,        /* Index of serial number string */
+  USBD_MAX_NUM_CONFIGURATION  /* bNumConfigurations */
+}; /* USB_DeviceDescriptor */
+
+/* USB Standard Device Descriptor */
+#if defined ( __ICCARM__ ) /*!< IAR Compiler */
+  #pragma data_alignment=4   
+#endif
+__ALIGN_BEGIN uint8_t USBD_LangIDDesc[USB_LEN_LANGID_STR_DESC] __ALIGN_END = {
+  USB_LEN_LANGID_STR_DESC,         
+  USB_DESC_TYPE_STRING,       
+  LOBYTE(USBD_LANGID_STRING),
+  HIBYTE(USBD_LANGID_STRING), 
+};
+
+#if defined ( __ICCARM__ ) /*!< IAR Compiler */
+  #pragma data_alignment=4   
+#endif
+__ALIGN_BEGIN uint8_t USBD_StrDesc[USBD_MAX_STR_DESC_SIZ] __ALIGN_END;
+
+/* Private functions ---------------------------------------------------------*/
+
+/**
+  * @brief  Returns the device descriptor. 
+  * @param  speed: Current device speed
+  * @param  length: Pointer to data length variable
+  * @retval Pointer to descriptor buffer
+  */
+uint8_t *USBD_VCP_DeviceDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
+{
+  *length = sizeof(hUSBDDeviceDesc);
+  return hUSBDDeviceDesc;
+}
+
+/**
+  * @brief  Returns the LangID string descriptor.        
+  * @param  speed: Current device speed
+  * @param  length: Pointer to data length variable
+  * @retval Pointer to descriptor buffer
+  */
+uint8_t *USBD_VCP_LangIDStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
+{
+  *length = sizeof(USBD_LangIDDesc);  
+  return USBD_LangIDDesc;
+}
+
+/**
+  * @brief  Returns the product string descriptor. 
+  * @param  speed: Current device speed
+  * @param  length: Pointer to data length variable
+  * @retval Pointer to descriptor buffer
+  */
+uint8_t *USBD_VCP_ProductStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
+{
+  if(speed == 0)
+  {   
+    USBD_GetString((uint8_t *)USBD_PRODUCT_HS_STRING, USBD_StrDesc, length);
+  }
+  else
+  {
+    USBD_GetString((uint8_t *)USBD_PRODUCT_FS_STRING, USBD_StrDesc, length);    
+  }
+  return USBD_StrDesc;
+}
+
+/**
+  * @brief  Returns the manufacturer string descriptor. 
+  * @param  speed: Current device speed
+  * @param  length: Pointer to data length variable
+  * @retval Pointer to descriptor buffer
+  */
+uint8_t *USBD_VCP_ManufacturerStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
+{
+  USBD_GetString((uint8_t *)USBD_MANUFACTURER_STRING, USBD_StrDesc, length);
+  return USBD_StrDesc;
+}
+
+/**
+  * @brief  Returns the serial number string descriptor.        
+  * @param  speed: Current device speed
+  * @param  length: Pointer to data length variable
+  * @retval Pointer to descriptor buffer
+  */
+uint8_t *USBD_VCP_SerialStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
+{
+  if(speed == USBD_SPEED_HIGH)
+  {    
+    USBD_GetString((uint8_t *)USBD_SERIALNUMBER_HS_STRING, USBD_StrDesc, length);
+  }
+  else
+  {
+    USBD_GetString((uint8_t *)USBD_SERIALNUMBER_FS_STRING, USBD_StrDesc, length);    
+  }
+  return USBD_StrDesc;
+}
+
+/**
+  * @brief  Returns the configuration string descriptor.    
+  * @param  speed: Current device speed
+  * @param  length: Pointer to data length variable
+  * @retval Pointer to descriptor buffer
+  */
+uint8_t *USBD_VCP_ConfigStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
+{
+  if(speed == USBD_SPEED_HIGH)
+  {  
+    USBD_GetString((uint8_t *)USBD_CONFIGURATION_HS_STRING, USBD_StrDesc, length);
+  }
+  else
+  {
+    USBD_GetString((uint8_t *)USBD_CONFIGURATION_FS_STRING, USBD_StrDesc, length); 
+  }
+  return USBD_StrDesc;  
+}
+
+/**
+  * @brief  Returns the interface string descriptor.        
+  * @param  speed: Current device speed
+  * @param  length: Pointer to data length variable
+  * @retval Pointer to descriptor buffer
+  */
+uint8_t *USBD_VCP_InterfaceStrDescriptor(USBD_SpeedTypeDef speed, uint16_t *length)
+{
+  if(speed == 0)
+  {
+    USBD_GetString((uint8_t *)USBD_INTERFACE_HS_STRING, USBD_StrDesc, length);
+  }
+  else
+  {
+    USBD_GetString((uint8_t *)USBD_INTERFACE_FS_STRING, USBD_StrDesc, length);
+  }
+  return USBD_StrDesc;  
+}
+
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
+

stmhal/usbd_desc.h

@@ -0,0 +1,43 @@
+/**
+  ******************************************************************************
+  * @file    USB_Device/CDC_Standalone/Inc/usbd_desc.h
+  * @author  MCD Application Team
+  * @version V1.0.1
+  * @date    26-February-2014
+  * @brief   Header for usbd_desc.c module
+  ******************************************************************************
+  * @attention
+  *
+  * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
+  *
+  * Licensed under MCD-ST Liberty SW License Agreement V2, (the "License");
+  * You may not use this file except in compliance with the License.
+  * You may obtain a copy of the License at:
+  *
+  *        http://www.st.com/software_license_agreement_liberty_v2
+  *
+  * Unless required by applicable law or agreed to in writing, software 
+  * distributed under the License is distributed on an "AS IS" BASIS, 
+  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  * See the License for the specific language governing permissions and
+  * limitations under the License.
+  *
+  ******************************************************************************
+  */
+
+/* Define to prevent recursive inclusion -------------------------------------*/
+#ifndef __USBD_DESC_H
+#define __USBD_DESC_H
+
+/* Includes ------------------------------------------------------------------*/
+#include "usbd_def.h"
+
+/* Exported types ------------------------------------------------------------*/
+/* Exported constants --------------------------------------------------------*/
+/* Exported macro ------------------------------------------------------------*/
+/* Exported functions ------------------------------------------------------- */
+extern USBD_DescriptorsTypeDef VCP_Desc;
+
+#endif /* __USBD_DESC_H */
+ 
+/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

stmhal/usbdev/class/cdc/src/usbd_cdc.c

@@ -64,7 +64,7 @@
   */ 
 
 /* Includes ------------------------------------------------------------------*/
-#include "USBD_CDC.h"
+#include "usbd_cdc.h"
 #include "usbd_desc.h"
 #include "usbd_ctlreq.h"