therm Changeset - 5dc11468ff0b · protofusion repositories

Changeset - 5dc11468ff0b

Parent rev.

Child rev.

[Not reviewed]

default

0 2 31

Ethan Zonca - 10 years ago 2014-07-17 23:12:35
ez@ethanzonca.com

Added USB stuff. USB init hangs... Maybe due to clock issue?

33 files changed with 6463 insertions and 27 deletions:

Makefile

evalcompat.h

hw_config.c

400

hw_config.h

main.c

platform_config.h

164

stm32_it.h

system_stm32l1xx.c

382

usb_conf.h

103

usb_core.c

1033

usb_core.h

259

usb_def.h

usb_desc.c

174

usb_desc.h

usb_endp.c

usb_init.c

usb_init.h

usb_int.c

195

usb_int.h

usb_istr.c

232

usb_istr.h

usb_lib.h

usb_mem.c

usb_mem.h

usb_prop.c

414

usb_prop.h

usb_pwr.c

318

usb_pwr.h

usb_regs.c

760

usb_regs.h

680

usb_sil.c

103

usb_sil.h

usb_type.h

0 comments (0 inline, 0 general)

Makefile

➞

Show inline comments

 TARGET:=therm
 TOOLCHAIN_PATH:=/usr/bin
 TOOLCHAIN_PREFIX:=arm-none-eabi
 OPTLVL:=3 # Optimization level, can be [0, 1, 2, 3, s].
 #PROJECT_NAME:=$(notdir $(lastword $(CURDIR)))
 TOP:=$(shell readlink -f "../..")
 DISCOVERY:=Utilities/STM32L100C-Discovery
 STMLIB:=libraries
 OLEDDRV:=oleddrv
 USBDRV:=/STM32_USB-FS-Device_Driver/inc
 STD_PERIPH:=$(STMLIB)/STM32L1xx_StdPeriph_Driver
 STARTUP:=$(STMLIB)/CMSIS/Device/ST/STM32L1xx/Source/Templates/gcc_ride7
 LINKER_SCRIPT:=$(CURDIR)/stm32-flash.ld
 #LINKER_SCRIPT:=$(CURDIR)/../stm32_flash.ld
 INCLUDE=-I$(CURDIR)
 INCLUDE+=-I$(STMLIB)/CMSIS/Include
 INCLUDE+=-I$(STMLIB)/CMSIS/Device/ST/STM32L1xx/Include
 INCLUDE+=-I$(STD_PERIPH)/inc
 INCLUDE+=-I$(DISCOVERY)
 INCLUDE+=-I$(STMLIB)/$(OLEDDRV)
 #INCLUDE+=-I$(STMLIB)/STM32_USB_OTG_Driver/inc
 #INCLUDE+=-I$(STMLIB)/STM32_USB_Device_Library/Class/hid/inc
 #INCLUDE+=-I$(STMLIB)/STM32_USB_Device_Library/Core/inc
 # vpath is used so object files are written to the current directory instead
 # of the same directory as their source files
 vpath %.c $(DISCOVERY) $(STD_PERIPH)/src \
           $(STMLIB)/STM32_USB_OTG_Driver/src \
           $(STMLIB)/STM32_USB_Device_Library/Class/hid/src \
           $(STMLIB)/STM32_USB_Device_Library/Core/src
           $(STMLIB)/STM32_USB-FS_Device_Library/Class/hid/src \
           $(STMLIB)/STM32_USB-FS_Device_Library/Core/src
 vpath %.s $(STARTUP)
 ASRC=startup_stm32l1xx_mdp.s
 # Project Source Files
 SRC=main.c
 SRC+=stm32l1xx_it.c
 SRC+=system_stm32l1xx.c
 SRC+=stm32l100c_discovery.c
 SRC+=ssd1306.c
 # Discovery Source Files
 #SRC+=stm32f4_discovery_lis302dl.c
 #SRC+=stm32f4_discovery.c
 #SRC+=stm32f4_discovery_audio_codec.c
 # Standard Peripheral Source Files
 SRC+=stm32l1xx_syscfg.c
 SRC+=misc.c
 SRC+=stm32l1xx_adc.c
 SRC+=stm32l1xx_dac.c
 SRC+=stm32l1xx_dma.c
 SRC+=stm32l1xx_exti.c
 SRC+=stm32l1xx_flash.c
 SRC+=stm32l1xx_gpio.c
 SRC+=stm32l1xx_i2c.c
 SRC+=stm32l1xx_rcc.c
 SRC+=stm32l1xx_spi.c
 SRC+=stm32l1xx_tim.c
 # USB Source Files
 #SRC+=usb_dcd_int.c
 #SRC+=usb_core.c
 #SRC+=usb_dcd.c
 #SRC+=usbd_hid_core.c
 #SRC+=usbd_req.c
 #SRC+=usbd_core.c
 #SRC+=usbd_ioreq.c
 SRC+=usb_core.c
 SRC+=usb_init.c
 SRC+=usb_int.c
 SRC+=usb_mem.c
 SRC+=usb_regs.c
 SRC+=usb_sil.c
 SRC+=hw_config.c
 SRC+=usb_desc.c
 SRC+=usb_endp.c
 SRC+=usb_istr.c
 SRC+=usb_prop.c
 SRC+=usb_pwr.c
 CDEFS=-DUSE_STDPERIPH_DRIVER
 CDEFS+=-DSTM32L1XX
 CDEFS+=-DMANGUSTA_DISCOVERY
 #CDEFS+=-DUSE_USB_OTG_FS
 CDEFS+=-DHSE_VALUE=8000000
 MCUFLAGS=-mcpu=cortex-m3 -mthumb
 #MCUFLAGS=-mcpu=cortex-m4 -mthumb -mlittle-endian -mfpu=fpa -mfloat-abi=hard -mthumb-interwork
 #MCUFLAGS=-mcpu=cortex-m4 -mfpu=vfpv4-sp-d16 -mfloat-abi=hard
 COMMONFLAGS=-O$(OPTLVL) -g -Wall
 CFLAGS=$(COMMONFLAGS) $(MCUFLAGS) $(INCLUDE) $(CDEFS)
 LDLIBS=
 LDFLAGS=$(COMMONFLAGS) -fno-exceptions -ffunction-sections -fdata-sections \
         -nostartfiles -Wl,--gc-sections,-T$(LINKER_SCRIPT)
 #####
 #####
 OBJ = $(SRC:%.c=%.o) $(ASRC:%.s=%.o)
 CC=$(TOOLCHAIN_PATH)/$(TOOLCHAIN_PREFIX)-gcc
 LD=$(TOOLCHAIN_PATH)/$(TOOLCHAIN_PREFIX)-gcc

evalcompat.h

➞

Show inline comments

@@ new file 100644 @@
 /** EMZ we only really need COM1, EVAL_COM1,
   ******************************************************************************
   * @file    stm32l152d_eval.h
   * @author  MCD Application Team
   * @version V1.0.1
   * @date    09-March-2012
   * @brief   This file contains definitions for STM32L152D_EVAL's Leds, push-buttons
   *          COM ports and Temperature Sensor LM75 (on I2C) hardware resources.
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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.
   *a
   ******************************************************************************
   */
 /* Define to prevent recursive inclusion -------------------------------------*/
 #ifndef __STM32L152D_EVAL_H
 #define __STM32L152D_EVAL_H
 #ifdef __cplusplus
  extern "C" {
 #endif
 /* Includes ------------------------------------------------------------------*/
 #include "stm32l1xx.h"
 typedef enum
+{
   COM1 = 0,
   COM2 = 1
 } COM_TypeDef;
 /**
   * @}
   */
 #define COMn                             1
 /**
  * @brief Definition for COM port1, connected to USART1
  */
 #define EVAL_COM1                        USART1
 #define EVAL_COM1_CLK                    RCC_APB2Periph_USART1
 #define EVAL_COM1_TX_PIN                 GPIO_Pin_9
 #define EVAL_COM1_TX_GPIO_PORT           GPIOA
 #define EVAL_COM1_TX_GPIO_CLK            RCC_AHBPeriph_GPIOA
 #define EVAL_COM1_TX_SOURCE              GPIO_PinSource9
 #define EVAL_COM1_TX_AF                  GPIO_AF_USART1
 #define EVAL_COM1_RX_PIN                 GPIO_Pin_10
 #define EVAL_COM1_RX_GPIO_PORT           GPIOA
 #define EVAL_COM1_RX_GPIO_CLK            RCC_AHBPeriph_GPIOA
 #define EVAL_COM1_RX_SOURCE              GPIO_PinSource10
 #define EVAL_COM1_RX_AF                  GPIO_AF_USART1
 #define EVAL_COM1_IRQn                   USART1_IRQn
 /** @defgroup STM32L152D_EVAL_LOW_LEVEL_Exported_Functions
   * @{
   */
 void STM_EVAL_COMInit(COM_TypeDef COM, USART_InitTypeDef* USART_InitStruct);
 #ifdef __cplusplus
+}
 #endif
 #endif /* __STM32L152D_EVAL_H */
 /**
   * @}
   */
 /**
   * @}
   */
 /**
   * @}
   */
 /**
   * @}
   */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

hw_config.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    hw_config.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   Hardware Configuration & Setup
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 "stm32_it.h"
 #include "usb_lib.h"
 #include "usb_prop.h"
 #include "usb_desc.h"
 #include "hw_config.h"
 #include "usb_pwr.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 ErrorStatus HSEStartUpStatus;
 EXTI_InitTypeDef EXTI_InitStructure;
 uint32_t packet_sent;
 extern __IO uint8_t Send_Buffer[VIRTUAL_COM_PORT_DATA_SIZE] ;
 uint32_t packet_receive;
 extern __IO uint8_t Receive_length;
 void set_packet_sent() {
 	packet_sent = 1;
+}
 uint32_t get_packet_sent() {
 	return packet_sent;
+}
 void clear_packet_sent() {
 	packet_sent = 0;
+}
 void set_packet_receive() {
 	packet_receive = 1;
+}
 uint32_t get_packet_receive() {
 	return packet_receive;
+}
 void clear_packet_receive() {
 	packet_receive = 0;
+}
 uint8_t Receive_Buffer[64];
 uint32_t Send_length;
 static void IntToUnicode (uint32_t value , uint8_t *pbuf , uint8_t len);
 /* Extern variables ----------------------------------------------------------*/
 extern LINE_CODING linecoding;
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : Set_System
 * Description    : Configures Main system clocks & power
 * Input          : None.
 * Return         : None.
 *******************************************************************************/
 void Set_System(void)
+{
 #if !defined(STM32L1XX_MD) && !defined(STM32L1XX_HD) && !defined(STM32L1XX_MD_PLUS)
   GPIO_InitTypeDef GPIO_InitStructure;
 #endif /* STM32L1XX_MD && STM32L1XX_XD */
 #if defined(USB_USE_EXTERNAL_PULLUP)
   GPIO_InitTypeDef  GPIO_InitStructure;
 #endif /* USB_USE_EXTERNAL_PULLUP */
   /*!< At this stage the microcontroller clock setting is already configured,
        this is done through SystemInit() function which is called from startup
        file (startup_stm32f10x_xx.s) before to branch to application main.
        To reconfigure the default setting of SystemInit() function, refer to
        system_stm32f10x.c file
      */
 #if defined(STM32L1XX_MD) || defined(STM32L1XX_HD)|| defined(STM32L1XX_MD_PLUS) || defined(STM32F37X) || defined(STM32F30X)
   /* Enable the SYSCFG module clock */
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
 #endif /* STM32L1XX_XD */
 #if !defined(STM32L1XX_MD) && !defined(STM32L1XX_HD) && !defined(STM32L1XX_MD_PLUS) && !defined(STM32F37X) && !defined(STM32F30X)
   /* Enable USB_DISCONNECT GPIO clock */
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIO_DISCONNECT, ENABLE);
   /* Configure USB pull-up pin */
   GPIO_InitStructure.GPIO_Pin = USB_DISCONNECT_PIN;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
   GPIO_Init(USB_DISCONNECT, &GPIO_InitStructure);
 #endif /* STM32L1XX_MD && STM32L1XX_XD */
 #if defined(USB_USE_EXTERNAL_PULLUP)
   /* Enable the USB disconnect GPIO clock */
   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIO_DISCONNECT, ENABLE);
   /* USB_DISCONNECT used as USB pull-up */
   GPIO_InitStructure.GPIO_Pin = USB_DISCONNECT_PIN;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
   GPIO_Init(USB_DISCONNECT, &GPIO_InitStructure);
 #endif /* USB_USE_EXTERNAL_PULLUP */
 #if defined(STM32F37X) || defined(STM32F30X)
   /* Enable the USB disconnect GPIO clock */
   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIO_DISCONNECT, ENABLE);
   /*Set PA11,12 as IN - USB_DM,DP*/
   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
   GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11 | GPIO_Pin_12;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
   GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
   GPIO_Init(GPIOA, &GPIO_InitStructure);
   /*SET PA11,12 for USB: USB_DM,DP*/
   GPIO_PinAFConfig(GPIOA, GPIO_PinSource11, GPIO_AF_14);
   GPIO_PinAFConfig(GPIOA, GPIO_PinSource12, GPIO_AF_14);
   /* USB_DISCONNECT used as USB pull-up */
   GPIO_InitStructure.GPIO_Pin = USB_DISCONNECT_PIN;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
   GPIO_Init(USB_DISCONNECT, &GPIO_InitStructure);
 #endif /* STM32F37X  && STM32F30X)*/
    /* Configure the EXTI line 18 connected internally to the USB IP */
   EXTI_ClearITPendingBit(EXTI_Line18);
   EXTI_InitStructure.EXTI_Line = EXTI_Line18;
   EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
   EXTI_InitStructure.EXTI_LineCmd = ENABLE;
   EXTI_Init(&EXTI_InitStructure);
+}
 /*******************************************************************************
 * Function Name  : Set_USBClock
 * Description    : Configures USB Clock input (48MHz)
 * Input          : None.
 * Return         : None.
 *******************************************************************************/
 void Set_USBClock(void)
+{
 #if defined(STM32L1XX_MD) || defined(STM32L1XX_HD) || defined(STM32L1XX_MD_PLUS)
   /* Enable USB clock */
   RCC_APB1PeriphClockCmd(RCC_APB1Periph_USB, ENABLE);
 #else
   /* Select USBCLK source */
   RCC_USBCLKConfig(RCC_USBCLKSource_PLLCLK_1Div5);
   /* Enable the USB clock */
   RCC_APB1PeriphClockCmd(RCC_APB1Periph_USB, ENABLE);
 #endif /* STM32L1XX_MD */
+}
 /*******************************************************************************
 * Function Name  : Enter_LowPowerMode
 * Description    : Power-off system clocks and power while entering suspend mode
 * Input          : None.
 * Return         : None.
 *******************************************************************************/
 void Enter_LowPowerMode(void)
+{
   /* Set the device state to suspend */
   bDeviceState = SUSPENDED;
+}
 /*******************************************************************************
 * Function Name  : Leave_LowPowerMode
 * Description    : Restores system clocks and power while exiting suspend mode
 * Input          : None.
 * Return         : None.
 *******************************************************************************/
 void Leave_LowPowerMode(void)
+{
   DEVICE_INFO *pInfo = &Device_Info;
   /* Set the device state to the correct state */
   if (pInfo->Current_Configuration != 0)
+  {
     /* Device configured */
     bDeviceState = CONFIGURED;
+  }
   else
+  {
     bDeviceState = ATTACHED;
+  }
     /*Enable SystemCoreClock*/
   SystemInit();
+}
 /*******************************************************************************
 * Function Name  : USB_Interrupts_Config
 * Description    : Configures the USB interrupts
 * Input          : None.
 * Return         : None.
 *******************************************************************************/
 void USB_Interrupts_Config(void)
+{
 NVIC_InitTypeDef NVIC_InitStructure;
   /* 2 bit for pre-emption priority, 2 bits for subpriority */
   NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
 #if defined(STM32L1XX_MD)|| defined(STM32L1XX_HD) || defined(STM32L1XX_MD_PLUS)
   /* Enable the USB interrupt */
   NVIC_InitStructure.NVIC_IRQChannel = USB_LP_IRQn;
   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
   NVIC_Init(&NVIC_InitStructure);
   /* Enable the USB Wake-up interrupt */
   NVIC_InitStructure.NVIC_IRQChannel = USB_FS_WKUP_IRQn;
   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
   NVIC_Init(&NVIC_InitStructure);
 #elif defined(STM32F37X)
   /* Enable the USB interrupt */
   NVIC_InitStructure.NVIC_IRQChannel = USB_LP_IRQn;
   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
   NVIC_Init(&NVIC_InitStructure);
   /* Enable the USB Wake-up interrupt */
   NVIC_InitStructure.NVIC_IRQChannel = USBWakeUp_IRQn;
   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
   NVIC_Init(&NVIC_InitStructure);
 #else
   /* Enable the USB interrupt */
   NVIC_InitStructure.NVIC_IRQChannel = USB_LP_CAN1_RX0_IRQn;
   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
   NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
   NVIC_Init(&NVIC_InitStructure);
   /* Enable the USB Wake-up interrupt */
   NVIC_InitStructure.NVIC_IRQChannel = USBWakeUp_IRQn;
   NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
   NVIC_Init(&NVIC_InitStructure);
 #endif
+}
 /*******************************************************************************
 * Function Name  : USB_Cable_Config
 * Description    : Software Connection/Disconnection of USB Cable
 * Input          : None.
 * Return         : Status
 *******************************************************************************/
 void USB_Cable_Config (FunctionalState NewState)
+{
 #if defined(STM32L1XX_MD) || defined (STM32L1XX_HD)|| (STM32L1XX_MD_PLUS)
   if (NewState != DISABLE)
+  {
     STM32L15_USB_CONNECT;
+  }
   else
+  {
     STM32L15_USB_DISCONNECT;
+  }
 #else /* USE_STM3210B_EVAL or USE_STM3210E_EVAL */
   if (NewState != DISABLE)
+  {
     GPIO_ResetBits(USB_DISCONNECT, USB_DISCONNECT_PIN);
+  }
   else
+  {
     GPIO_SetBits(USB_DISCONNECT, USB_DISCONNECT_PIN);
+  }
 #endif /* STM32L1XX_MD */
+}
 /*******************************************************************************
 * Function Name  : Get_SerialNum.
 * Description    : Create the serial number string descriptor.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Get_SerialNum(void)
+{
   uint32_t Device_Serial0, Device_Serial1, Device_Serial2;
   Device_Serial0 = *(uint32_t*)ID1;
   Device_Serial1 = *(uint32_t*)ID2;
   Device_Serial2 = *(uint32_t*)ID3;
   Device_Serial0 += Device_Serial2;
   if (Device_Serial0 != 0)
+  {
     IntToUnicode (Device_Serial0, &Virtual_Com_Port_StringSerial[2] , 8);
     IntToUnicode (Device_Serial1, &Virtual_Com_Port_StringSerial[18], 4);
+  }
+}
 /*******************************************************************************
 * Function Name  : HexToChar.
 * Description    : Convert Hex 32Bits value into char.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 static void IntToUnicode (uint32_t value , uint8_t *pbuf , uint8_t len)
+{
   uint8_t idx = 0;
   for( idx = 0 ; idx < len ; idx ++)
+  {
     if( ((value >> 28)) < 0xA )
+    {
       pbuf[ 2* idx] = (value >> 28) + '0';
+    }
     else
+    {
       pbuf[2* idx] = (value >> 28) + 'A' - 10;
+    }
     value = value << 4;
     pbuf[ 2* idx + 1] = 0;
+  }
+}
 /*******************************************************************************
 * Function Name  : Send DATA .
 * Description    : send the data received from the STM32 to the PC through USB
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 uint32_t CDC_Send_DATA (uint8_t *ptrBuffer, uint8_t Send_length)
+{
   /*if max buffer is Not reached*/
   if(Send_length < VIRTUAL_COM_PORT_DATA_SIZE)
+  {
     /*Sent flag*/
     clear_packet_sent();
     /* send  packet to PMA*/
     UserToPMABufferCopy((unsigned char*)ptrBuffer, ENDP1_TXADDR, Send_length);
     SetEPTxCount(ENDP1, Send_length);
     SetEPTxValid(ENDP1);
+  }
   else
+  {
     return 0;
+  }
   return 1;
+}
 /*******************************************************************************
 * Function Name  : Receive DATA .
 * Description    : receive the data from the PC to STM32 and send it through USB
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 uint32_t CDC_Receive_DATA(void)
+{
   /*Receive flag*/
   clear_packet_receive();
   SetEPRxValid(ENDP3);
   return 1 ;
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

hw_config.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    hw_config.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   Hardware Configuration & Setup
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 __HW_CONFIG_H
 #define __HW_CONFIG_H
 /* Includes ------------------------------------------------------------------*/
 #include "platform_config.h"
 #include "usb_type.h"
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported define -----------------------------------------------------------*/
 #define MASS_MEMORY_START     0x04002000
 #define BULK_MAX_PACKET_SIZE  0x00000040
 #define LED_ON                0xF0
 #define LED_OFF               0xFF
 /* Exported functions ------------------------------------------------------- */
 void set_packet_sent();
 uint32_t get_packet_sent();
 void clear_packet_sent();
 void set_packet_receive();
 uint32_t get_packet_receive();
 void clear_packet_receive();
 void Set_USBClock(void);
 void Enter_LowPowerMode(void);
 void Leave_LowPowerMode(void);
 void USB_Interrupts_Config(void);
 void USB_Cable_Config (FunctionalState NewState);
 void Get_SerialNum(void);
 void LCD_Control(void);
 uint32_t CDC_Send_DATA (uint8_t *ptrBuffer, uint8_t Send_length);
 uint32_t CDC_Receive_DATA(void);
 /* External variables --------------------------------------------------------*/
 #endif  /*__HW_CONFIG_H*/
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

main.c

➞

Show inline comments

 #include "main.h"
 #include "stm32l100c_discovery.h"
 #include "ssd1306.h"
 // USB includes
 #include "hw_config.h"
 #include "usb_lib.h"
 #include "usb_desc.h"
 #include "usb_pwr.h"
 #define LED_POWER GPIOB,GPIO_Pin_9
 #define LED_STAT  GPIOA,GPIO_Pin_15
 #define MAX_CS GPIOB,GPIO_Pin_12
 // TODO: Grab buttonpresses with interrupts
 #define SW_BTN  GPIOB, GPIO_Pin_3
 #define SW_UP   GPIOB, GPIO_Pin_7
 #define SW_DOWN GPIOB, GPIO_Pin_6
 #define SW_LEFT GPIOB, GPIO_Pin_5
 #define SW_RIGHT GPIOB, GPIO_Pin_4
 static __IO uint32_t TimingDelay;
 void init_gpio();
 void init_spi();
 void process();
 void machine();
 int main(void)
+{
     // Init clocks
     SystemInit();
     init_gpio();
     Set_USBClock();
     USB_Interrupts_Config();
     USB_Init();
     GPIO_SetBits(LED_POWER);
     RCC_ClocksTypeDef RCC_Clocks;
     // SysTick end of count event each 1ms
     RCC_GetClocksFreq(&RCC_Clocks);
     SysTick_Config(RCC_Clocks.HCLK_Frequency / 1000);
     GPIO_ResetBits(LED_STAT);
     Delay(100);
     init_gpio();
     ssd1306_Init();
     ssd1306_DrawPoint(3,3,1);
     ssd1306_DrawPoint(5,5,0);
     //ssd1306_Init();
     //ssd1306_DrawPoint(3,3,1);
     //ssd1306_DrawPoint(5,5,0);
     GPIO_SetBits(LED_POWER);
     Delay(500);
     GPIO_ResetBits(LED_POWER);
 RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
     init_spi();
     while(1)
+   {
         // Process sensor inputs [TODO: 5hz?]
         process();
         // Run state machine [TODO: 50hz?]
-        machine(); // this argument is sooo wrong
         machine();
         // probably just passed the actual port
         // TODO: Grab buttonpresses with interrupts
         uint8_t sw_btn = GPIO_ReadInputDataBit(SW_BTN);
         uint8_t sw_up = GPIO_ReadInputDataBit(SW_UP);
         uint8_t sw_down = GPIO_ReadInputDataBit(SW_DOWN);
         uint8_t sw_left = GPIO_ReadInputDataBit(SW_LEFT);
         uint8_t sw_right = GPIO_ReadInputDataBit(SW_RIGHT);
         SPI_I2S_SendData(SPI2,0xFA);
         SPI_I2S_SendData(SPI1,0xFA);
         if(!GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_3)) {
             GPIO_ToggleBits(LED_STAT);
+        }
-//        ssd1306_DrawPoint(5,5,0);
         GPIO_SetBits(LED_POWER);
-        Delay(150);
+        Delay(50);
         GPIO_ResetBits(LED_POWER);
-        Delay(150);
+        Delay(50);
+    }
+}
 int32_t temp = 0;
 int32_t setpoint = 0;
 int32_t p = 1;
 int32_t i = 1;
 int32_t d = 1;
 // Process things
 void process()
+{
     // Read MAX temp sensor
     temp = 0;
     GPIO_ResetBits(MAX_CS);
     // Assert CS
     // This may not clock at all... might need to send 16 bits first
     uint8_t retval = SPI_I2S_ReceiveData(SPI2);
     // Deassert CS
     GPIO_SetBits(MAX_CS);
     if((!retval || (temp & 0x2) != 0))
         return; // Comms error
     if((temp & 0x4)!= 0)
         return; // Open thermocouple
     temp = (temp & 0x7FF8) >> 5;
     // TODO: Add calibration offset (linear)
     // Perform PID calculations
     // Write output to SSR
+}
 enum state {
     STATE_IDLE = 0,
     STATE_SETP,
     STATE_SETI,
     STATE_SETD,
     STATE_PREHEAT_BREW,
     STATE_MAINTAIN_BREW,
     STATE_PREHEAT_STEAM,
     STATE_MAINTAIN_STEAM,
 };
 uint8_t state = STATE_IDLE;
 // State machine
@@ @@ -290,57 +322,57 @@ void TimingDelay_Decrement(void) @@
+  {
     TimingDelay--;
+  }
+}
 void init_spi(void)
+{
     SPI_InitTypeDef  SPI_InitStructure;
     // OLED IC
     SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
     SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
     SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;
     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
     SPI_InitStructure.SPI_CRCPolynomial = 7;
     SPI_Init(SPI1, &SPI_InitStructure);
     SPI_Cmd(SPI1, ENABLE);           /* Enable the SPI  */
     // MAX IC
     SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Rx;
+    //SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Rx;
     SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
     SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
     SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
     SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
     SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
     SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b; // Andysworkshop
     SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; // From andysworkshop
     SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; // same
     // Can be used for CS... SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
     SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;
     SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
     SPI_InitStructure.SPI_CRCPolynomial = 7;
     //SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
     //SPI_InitStructure.SPI_CRCPolynomial = 7;
     SPI_Init(SPI2, &SPI_InitStructure);
     SPI_Cmd(SPI2, ENABLE);           /* Enable the SPI */
+}
 void init_gpio(void) {
  GPIO_InitTypeDef GPIO_InitStruct;
   // Enable SPI clocks
   RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
   RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
   // Enable GPIO clocks
   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC|RCC_AHBPeriph_GPIOB|RCC_AHBPeriph_GPIOA, ENABLE);
   // Enable DMA clocks (Is AHB even the right thing???)
   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); // EMZ TODO get the right ones
   /*Configure GPIO pin : PC */
   GPIO_InitStruct.GPIO_Pin = GPIO_Pin_13;
   GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
   GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
   GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL;
   GPIO_InitStruct.GPIO_Speed = GPIO_Speed_400KHz;

platform_config.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    platform_config.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   Evaluation board specific configuration file.
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 __PLATFORM_CONFIG_H
 #define __PLATFORM_CONFIG_H
 #define STM32L1XX_MD
 /* Includes ------------------------------------------------------------------*/
 #if defined(STM32L1XX_MD) || defined(STM32L1XX_HD)|| defined(STM32L1XX_MD_PLUS)
  #include "stm32l1xx.h"
  #include "evalcompat.h"
 // #if defined (USE_STM32L152_EVAL)
 //  #include "stm32l152_eval.h"
 // #elif defined (USE_STM32L152D_EVAL)
 //  #include "stm32l152d_eval.h"
 // #else
 //  #error "Missing define: USE_STM32L152_EVAL or USE_STM32L152D_EVAL"
 // #endif /* USE_STM32L152_EVAL */
 #elif defined (STM32F10X_MD) || defined (STM32F10X_HD) || defined (STM32F10X_XL)
  #include "stm32f10x.h"
  #if defined (USE_STM3210B_EVAL)
   #include "stm3210b_eval.h"
  #elif defined (USE_STM3210E_EVAL)
   #include "stm3210e_eval.h"
  #else
   #error "Missing define: USE_STM3210B_EVAL or USE_STM3210E_EVAL"
  #endif /* USE_STM3210B_EVAL */
 #elif defined (USE_STM32373C_EVAL)
  #include "stm32f37x.h"
  #include "stm32373c_eval.h"
 #elif defined (USE_STM32303C_EVAL)
  #include "stm32f30x.h"
  #include "stm32303c_eval.h"
 #endif
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Uncomment the line corresponding to the STMicroelectronics evaluation board
    used to run the example */
 #if !defined (USE_STM3210B_EVAL) &&  !defined (USE_STM3210E_EVAL)  && !defined (USE_STM32L152_EVAL) &&  !defined (USE_STM32L152D_EVAL) &&  !defined (USE_STM32373C_EVAL) && !defined (USE_STM32303C_EVAL)
 //#define USE_STM3210B_EVAL
 //#define USE_STM3210E_EVAL
 #define USE_STM32L152_EVAL
 //#define USE_STM32L152D_EVAL
 //#define (USE_STM32373C_EVAL)
 //#define USE_STM32303C_EVAL
 #endif
 /*Unique Devices IDs register set*/
 #if defined(STM32L1XX_MD) || defined(STM32L1XX_HD) || defined(STM32L1XX_MD_PLUS)
 #define         ID1          (0x1FF80050)
 #define         ID2          (0x1FF80054)
 #define         ID3          (0x1FF80064)
 #elif defined (STM32F37X) || defined(STM32F30X)
 #define         ID1          (0x1FFFF7AC)
 #define         ID2          (0x1FFFF7B0)
 #define         ID3          (0x1FFFF7B4)
 #else /*STM32F1x*/
 #define         ID1          (0x1FFFF7E8)
 #define         ID2          (0x1FFFF7EC)
 #define         ID3          (0x1FFFF7F0)
 #endif
 /* Define the STM32F10x hardware depending on the used evaluation board */
 #ifdef USE_STM3210B_EVAL
   #define USB_DISCONNECT                      GPIOD
   #define USB_DISCONNECT_PIN                  GPIO_Pin_9
   #define RCC_APB2Periph_GPIO_DISCONNECT      RCC_APB2Periph_GPIOD
   #define EVAL_COM1_IRQHandler                USART1_IRQHandler
 #elif defined (USE_STM3210E_EVAL)
   #define USB_DISCONNECT                      GPIOB
   #define USB_DISCONNECT_PIN                  GPIO_Pin_14
   #define RCC_APB2Periph_GPIO_DISCONNECT      RCC_APB2Periph_GPIOB
   #define EVAL_COM1_IRQHandler                USART1_IRQHandler
 #elif defined (USE_STM32L152_EVAL) || defined (USE_STM32L152D_EVAL)
  /*
    For STM32L15xx devices it is possible to use the internal USB pullup
    controlled by register SYSCFG_PMC (refer to RM0038 reference manual for
    more details).
    It is also possible to use external pullup (and disable the internal pullup)
    by setting the define USB_USE_EXTERNAL_PULLUP in file platform_config.h
    and configuring the right pin to be used for the external pull up configuration.
    To have more details on how to use an external pull up, please refer to
    STM3210E-EVAL evaluation board manuals.
    */
  /* Uncomment the following define to use an external pull up instead of the
     integrated STM32L15xx internal pull up. In this case make sure to set up
     correctly the external required hardware and the GPIO defines below.*/
 /* #define USB_USE_EXTERNAL_PULLUP */
  #if !defined(USB_USE_EXTERNAL_PULLUP)
   #define STM32L15_USB_CONNECT                SYSCFG_USBPuCmd(ENABLE)
   #define STM32L15_USB_DISCONNECT             SYSCFG_USBPuCmd(DISABLE)
  #elif defined(USB_USE_EXTERNAL_PULLUP)
   /* PA0 is chosen just as illustrating example, you should modify the defines
     below according to your hardware configuration. */
   #define USB_DISCONNECT                      GPIOA
   #define USB_DISCONNECT_PIN                  GPIO_Pin_0
   #define RCC_AHBPeriph_GPIO_DISCONNECT       RCC_AHBPeriph_GPIOA
   #define STM32L15_USB_CONNECT                GPIO_ResetBits(USB_DISCONNECT, USB_DISCONNECT_PIN)
   #define STM32L15_USB_DISCONNECT             GPIO_SetBits(USB_DISCONNECT, USB_DISCONNECT_PIN)
  #endif /* USB_USE_EXTERNAL_PULLUP */
 #elif defined (USE_STM32373C_EVAL)
   #define USB_DISCONNECT                      GPIOC
   #define USB_DISCONNECT_PIN                  GPIO_Pin_5
   #define RCC_AHBPeriph_GPIO_DISCONNECT       RCC_AHBPeriph_GPIOC
 #elif defined (USE_STM32303C_EVAL)
   #define USB_DISCONNECT                      GPIOB
   #define USB_DISCONNECT_PIN                  GPIO_Pin_8
   #define RCC_AHBPeriph_GPIO_DISCONNECT       RCC_AHBPeriph_GPIOB
 #endif /* USE_STM3210B_EVAL */
 #if defined (USE_STM32L152_EVAL) || (USE_STM32373C_EVAL)
  #define EVAL_COM1_IRQHandler                USART2_IRQHandler
 #elif defined (USE_STM32L152D_EVAL) || (USE_STM32303C_EVAL)
  #define EVAL_COM1_IRQHandler              USART1_IRQHandler
 #endif
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 #endif /* __PLATFORM_CONFIG_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

stm32_it.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    stm32_it.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   This file contains the headers of the interrupt handlers.
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 __STM32_IT_H
 #define __STM32_IT_H
 /* Includes ------------------------------------------------------------------*/
 #include "platform_config.h"
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 void NMI_Handler(void);
 void HardFault_Handler(void);
 void MemManage_Handler(void);
 void BusFault_Handler(void);
 void UsageFault_Handler(void);
 void SVC_Handler(void);
 void DebugMon_Handler(void);
 void PendSV_Handler(void);
 void SysTick_Handler(void);
 void USB_LP_CAN1_RX0_IRQHandler(void);
 #if defined (USE_STM32L152_EVAL) || (USE_STM32373C_EVAL)
 void USART2_IRQHandler(void);
 #else
 void USART1_IRQHandler(void);
 #endif /* USE_STM32L152_EVAL */
 #endif /* __STM32_IT_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

system_stm32l1xx.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    system_stm32l1xx.c
   * @author  MCD Application Team
   * @version V1.2.0
   * @date    11-July-2014
   * @brief   CMSIS Cortex-M3 Device Peripheral Access Layer System Source File.
   *          This file contains the system clock configuration for STM32L1xx Ultra
   *          Low power devices, and is generated by the clock configuration
   *          tool  STM32L1xx_Clock_Configuration_V1.2.0.xls
+  *
   * 1.  This file provides two functions and one global variable to be called from
   *     user application:
   *      - SystemInit(): Setups the system clock (System clock source, PLL Multiplier
   *                      and Divider factors, AHB/APBx prescalers and Flash settings),
   *                      depending on the configuration made in the clock xls tool.
   *                      This function is called at startup just after reset and
   *                      before branch to main program. This call is made inside
   *                      the "startup_stm32l1xx_xx.s" file.
+  *
   *      - SystemCoreClock variable: Contains the core clock (HCLK), it can be used
   *                                  by the user application to setup the SysTick
   *                                  timer or configure other parameters.
+  *
   *      - SystemCoreClockUpdate(): Updates the variable SystemCoreClock and must
   *                                 be called whenever the core clock is changed
   *                                 during program execution.
+  *
   * 2. After each device reset the MSI (2.1 MHz Range) is used as system clock source.
   *    Then SystemInit() function is called, in "startup_stm32l1xx_xx.s" file, to
   *    configure the system clock before to branch to main program.
+  *
   * 3. If the system clock source selected by user fails to startup, the SystemInit()
   *    function will do nothing and MSI still used as system clock source. User can
   *    add some code to deal with this issue inside the SetSysClock() function.
+  *
   * 4. The default value of HSE crystal is set to 8MHz, refer to "HSE_VALUE" define
   *    in "stm32l1xx.h" file. When HSE is used as system clock source, directly or
   *    through PLL, and you are using different crystal you have to adapt the HSE
   *    value to your own configuration.
+  *
   * 5. This file configures the system clock as follows:
   *=============================================================================
   *                         System Clock Configuration
   *=============================================================================
   *        System clock source          | HSI
   *-----------------------------------------------------------------------------
   *        SYSCLK                       | 16000000 Hz
   *-----------------------------------------------------------------------------
   *        HCLK                         | 8000000 Hz
   *-----------------------------------------------------------------------------
   *        AHB Prescaler                | 2
   *-----------------------------------------------------------------------------
   *        APB1 Prescaler               | 1
   *-----------------------------------------------------------------------------
   *        APB2 Prescaler               | 1
   *-----------------------------------------------------------------------------
   *        HSE Frequency                | 8000000 Hz
   *-----------------------------------------------------------------------------
   *        PLL DIV                      | Not Used
   *-----------------------------------------------------------------------------
   *        PLL MUL                      | Not Used
   *-----------------------------------------------------------------------------
   *        VDD                          | 3.3 V
   *-----------------------------------------------------------------------------
   *        Vcore                        | 1.5 V (Range 2)
   *-----------------------------------------------------------------------------
   *        Flash Latency                | 0 WS
   *-----------------------------------------------------------------------------
   *        Require 48MHz for USB clock  | Disabled
   *-----------------------------------------------------------------------------
   *=============================================================================
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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.
+  *
   ******************************************************************************
   */
 /** @addtogroup CMSIS
   * @{
   */
 /** @addtogroup stm32l1xx_system
   * @{
   */
 /** @addtogroup STM32L1xx_System_Private_Includes
   * @{
   */
 #include "stm32l1xx.h"
 /**
   * @}
   */
 /** @addtogroup STM32L1xx_System_Private_TypesDefinitions
   * @{
   */
 /**
   * @}
   */
 /** @addtogroup STM32L1xx_System_Private_Defines
   * @{
   */
 /*!< Uncomment the following line if you need to relocate your vector Table in
      Internal SRAM. */
 /* #define VECT_TAB_SRAM */
 #define VECT_TAB_OFFSET  0x0 /*!< Vector Table base offset field.
                                   This value must be a multiple of 0x200. */
 /**
   * @}
   */
 /** @addtogroup STM32L1xx_System_Private_Macros
   * @{
   */
 /**
   * @}
   */
 /** @addtogroup STM32L1xx_System_Private_Variables
   * @{
   */
 uint32_t SystemCoreClock    = 16000000;
 __I uint8_t PLLMulTable[9] = {3, 4, 6, 8, 12, 16, 24, 32, 48};
 __I uint8_t AHBPrescTable[16] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 6, 7, 8, 9};
 /**
   * @}
   */
 /** @addtogroup STM32L1xx_System_Private_FunctionPrototypes
   * @{
   */
 static void SetSysClock(void);
 /**
   * @}
   */
 /** @addtogroup STM32L1xx_System_Private_Functions
   * @{
   */
 /**
   * @brief  Setup the microcontroller system.
   *         Initialize the Embedded Flash Interface, the PLL and update the
   *         SystemCoreClock variable.
   * @param  None
   * @retval None
   */
 void SystemInit (void)
+{
   /*!< Set MSION bit */
   RCC->CR |= (uint32_t)0x00000100;
   /*!< Reset SW[1:0], HPRE[3:0], PPRE1[2:0], PPRE2[2:0], MCOSEL[2:0] and MCOPRE[2:0] bits */
   RCC->CFGR &= (uint32_t)0x88FFC00C;
   /*!< Reset HSION, HSEON, CSSON and PLLON bits */
   RCC->CR &= (uint32_t)0xEEFEFFFE;
   /*!< Reset HSEBYP bit */
   RCC->CR &= (uint32_t)0xFFFBFFFF;
   /*!< Reset PLLSRC, PLLMUL[3:0] and PLLDIV[1:0] bits */
   RCC->CFGR &= (uint32_t)0xFF02FFFF;
   /*!< Disable all interrupts */
   RCC->CIR = 0x00000000;
   /* Configure the System clock frequency, AHB/APBx prescalers and Flash settings */
   SetSysClock();
 #ifdef VECT_TAB_SRAM
   SCB->VTOR = SRAM_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal SRAM. */
 #else
   SCB->VTOR = FLASH_BASE | VECT_TAB_OFFSET; /* Vector Table Relocation in Internal FLASH. */
 #endif
+}
 /**
   * @brief  Update SystemCoreClock according to Clock Register Values
   *         The SystemCoreClock variable contains the core clock (HCLK), it can
   *         be used by the user application to setup the SysTick timer or configure
   *         other parameters.
+  *
   * @note   Each time the core clock (HCLK) changes, this function must be called
   *         to update SystemCoreClock variable value. Otherwise, any configuration
   *         based on this variable will be incorrect.
+  *
   * @note   - The system frequency computed by this function is not the real
   *           frequency in the chip. It is calculated based on the predefined
   *           constant and the selected clock source:
+  *
   *           - If SYSCLK source is MSI, SystemCoreClock will contain the MSI
   *             value as defined by the MSI range.
+  *
   *           - If SYSCLK source is HSI, SystemCoreClock will contain the HSI_VALUE(*)
+  *
   *           - If SYSCLK source is HSE, SystemCoreClock will contain the HSE_VALUE(**)
+  *
   *           - If SYSCLK source is PLL, SystemCoreClock will contain the HSE_VALUE(**)
   *             or HSI_VALUE(*) multiplied/divided by the PLL factors.
+  *
   *         (*) HSI_VALUE is a constant defined in stm32l1xx.h file (default value
   *             16 MHz) but the real value may vary depending on the variations
   *             in voltage and temperature.
+  *
   *         (**) HSE_VALUE is a constant defined in stm32l1xx.h file (default value
   *              8 MHz), user has to ensure that HSE_VALUE is same as the real
   *              frequency of the crystal used. Otherwise, this function may
   *              have wrong result.
+  *
   *         - The result of this function could be not correct when using fractional
   *           value for HSE crystal.
   * @param  None
   * @retval None
   */
 void SystemCoreClockUpdate (void)
+{
   uint32_t tmp = 0, pllmul = 0, plldiv = 0, pllsource = 0, msirange = 0;
   /* Get SYSCLK source -------------------------------------------------------*/
   tmp = RCC->CFGR & RCC_CFGR_SWS;
   switch (tmp)
+  {
     case 0x00:  /* MSI used as system clock */
       msirange = (RCC->ICSCR & RCC_ICSCR_MSIRANGE) >> 13;
       SystemCoreClock = (32768 * (1 << (msirange + 1)));
       break;
     case 0x04:  /* HSI used as system clock */
       SystemCoreClock = HSI_VALUE;
       break;
     case 0x08:  /* HSE used as system clock */
       SystemCoreClock = HSE_VALUE;
       break;
     case 0x0C:  /* PLL used as system clock */
       /* Get PLL clock source and multiplication factor ----------------------*/
       pllmul = RCC->CFGR & RCC_CFGR_PLLMUL;
       plldiv = RCC->CFGR & RCC_CFGR_PLLDIV;
       pllmul = PLLMulTable[(pllmul >> 18)];
       plldiv = (plldiv >> 22) + 1;
       pllsource = RCC->CFGR & RCC_CFGR_PLLSRC;
       if (pllsource == 0x00)
+      {
         /* HSI oscillator clock selected as PLL clock entry */
         SystemCoreClock = (((HSI_VALUE) * pllmul) / plldiv);
+      }
       else
+      {
         /* HSE selected as PLL clock entry */
         SystemCoreClock = (((HSE_VALUE) * pllmul) / plldiv);
+      }
       break;
     default: /* MSI used as system clock */
       msirange = (RCC->ICSCR & RCC_ICSCR_MSIRANGE) >> 13;
       SystemCoreClock = (32768 * (1 << (msirange + 1)));
       break;
+  }
   /* Compute HCLK clock frequency --------------------------------------------*/
   /* Get HCLK prescaler */
   tmp = AHBPrescTable[((RCC->CFGR & RCC_CFGR_HPRE) >> 4)];
   /* HCLK clock frequency */
   SystemCoreClock >>= tmp;
+}
 /**
   * @brief  Configures the System clock frequency, AHB/APBx prescalers and Flash
   *         settings.
   * @note   This function should be called only once the RCC clock configuration
   *         is reset to the default reset state (done in SystemInit() function).
   * @param  None
   * @retval None
   */
 static void SetSysClock(void)
+{
   __IO uint32_t StartUpCounter = 0, HSIStatus = 0;
   /* SYSCLK, HCLK, PCLK2 and PCLK1 configuration ---------------------------*/
   /* Enable HSI */
   RCC->CR |= ((uint32_t)RCC_CR_HSION);
   /* Wait till HSI is ready and if Time out is reached exit */
   do
+  {
     HSIStatus = RCC->CR & RCC_CR_HSIRDY;
   } while((HSIStatus == 0) && (StartUpCounter != HSI_STARTUP_TIMEOUT));
   if ((RCC->CR & RCC_CR_HSIRDY) != RESET)
+  {
     HSIStatus = (uint32_t)0x01;
+  }
   else
+  {
     HSIStatus = (uint32_t)0x00;
+  }
   if (HSIStatus == (uint32_t)0x01)
+  {
     /* Flash 0 wait state */
     FLASH->ACR &= ~FLASH_ACR_LATENCY;
     /* Disable Prefetch Buffer */
     FLASH->ACR &= ~FLASH_ACR_PRFTEN;
     /* Disable 64-bit access */
     FLASH->ACR &= ~FLASH_ACR_ACC64;
     /* Power enable */
     RCC->APB1ENR |= RCC_APB1ENR_PWREN;
     /* Select the Voltage Range 2 (1.5 V) */
     PWR->CR = PWR_CR_VOS_1;
     /* Wait Until the Voltage Regulator is ready */
     while((PWR->CSR & PWR_CSR_VOSF) != RESET)
+    {
+    }
     /* HCLK = SYSCLK /2*/
     RCC->CFGR |= (uint32_t)RCC_CFGR_HPRE_DIV2;
     /* PCLK2 = HCLK /1*/
     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE2_DIV1;
     /* PCLK1 = HCLK /1*/
     RCC->CFGR |= (uint32_t)RCC_CFGR_PPRE1_DIV1;
     /* Select HSI as system clock source */
     RCC->CFGR &= (uint32_t)((uint32_t)~(RCC_CFGR_SW));
     RCC->CFGR |= (uint32_t)RCC_CFGR_SW_HSI;
     /* Wait till HSI is used as system clock source */
     while ((RCC->CFGR & (uint32_t)RCC_CFGR_SWS) != (uint32_t)RCC_CFGR_SWS_HSI)
+    {
+    }
+  }
   else
+  {
     /* If HSI fails to start-up, the application will have wrong clock
        configuration. User can add here some code to deal with this error */
+  }
+}
 /**
   * @}
   */
 /**
   * @}
   */
 /**
   * @}
   */
 /******************* (C) COPYRIGHT 2013 STMicroelectronics *****END OF FILE****/

usb_conf.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_conf.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   Virtual COM Port Demo configuration  header
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 __USB_CONF_H
 #define __USB_CONF_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 /* External variables --------------------------------------------------------*/
 /*-------------------------------------------------------------*/
 /* EP_NUM */
 /* defines how many endpoints are used by the device */
 /*-------------------------------------------------------------*/
 #define EP_NUM                          (4)
 /*-------------------------------------------------------------*/
 /* --------------   Buffer Description Table  -----------------*/
 /*-------------------------------------------------------------*/
 /* buffer table base address */
 /* buffer table base address */
 #define BTABLE_ADDRESS      (0x00)
 /* EP0  */
 /* rx/tx buffer base address */
 #define ENDP0_RXADDR        (0x40)
 #define ENDP0_TXADDR        (0x80)
 /* EP1  */
 /* tx buffer base address */
 #define ENDP1_TXADDR        (0xC0)
 #define ENDP2_TXADDR        (0x100)
 #define ENDP3_RXADDR        (0x110)
 /*-------------------------------------------------------------*/
 /* -------------------   ISTR events  -------------------------*/
 /*-------------------------------------------------------------*/
 /* IMR_MSK */
 /* mask defining which events has to be handled */
 /* by the device application software */
 #define IMR_MSK (CNTR_CTRM  | CNTR_WKUPM | CNTR_SUSPM | CNTR_ERRM  | CNTR_SOFM \
                  | CNTR_ESOFM | CNTR_RESETM )
 /*#define CTR_CALLBACK*/
 /*#define DOVR_CALLBACK*/
 /*#define ERR_CALLBACK*/
 /*#define WKUP_CALLBACK*/
 /*#define SUSP_CALLBACK*/
 /*#define RESET_CALLBACK*/
 /*#define SOF_CALLBACK*/
 /*#define ESOF_CALLBACK*/
 /* CTR service routines */
 /* associated to defined endpoints */
 /*#define  EP1_IN_Callback   NOP_Process*/
 #define  EP2_IN_Callback   NOP_Process
 #define  EP3_IN_Callback   NOP_Process
 #define  EP4_IN_Callback   NOP_Process
 #define  EP5_IN_Callback   NOP_Process
 #define  EP6_IN_Callback   NOP_Process
 #define  EP7_IN_Callback   NOP_Process
 #define  EP1_OUT_Callback   NOP_Process
 #define  EP2_OUT_Callback   NOP_Process
 /*#define  EP3_OUT_Callback   NOP_Process*/
 #define  EP4_OUT_Callback   NOP_Process
 #define  EP5_OUT_Callback   NOP_Process
 #define  EP6_OUT_Callback   NOP_Process
 #define  EP7_OUT_Callback   NOP_Process
 #endif /* __USB_CONF_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_core.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_core.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Standard protocol processing (USB v2.0)
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 "usb_lib.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 #define ValBit(VAR,Place)    (VAR & (1 << Place))
 #define SetBit(VAR,Place)    (VAR |= (1 << Place))
 #define ClrBit(VAR,Place)    (VAR &= ((1 << Place) ^ 255))
 #define Send0LengthData() { _SetEPTxCount(ENDP0, 0); \
     vSetEPTxStatus(EP_TX_VALID); \
+  }
 #define vSetEPRxStatus(st) (SaveRState = st)
 #define vSetEPTxStatus(st) (SaveTState = st)
 #define USB_StatusIn() Send0LengthData()
 #define USB_StatusOut() vSetEPRxStatus(EP_RX_VALID)
 #define StatusInfo0 StatusInfo.bw.bb1 /* Reverse bb0 & bb1 */
 #define StatusInfo1 StatusInfo.bw.bb0
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 uint16_t_uint8_t StatusInfo;
 bool Data_Mul_MaxPacketSize = FALSE;
 /* Private function prototypes -----------------------------------------------*/
 static void DataStageOut(void);
 static void DataStageIn(void);
 static void NoData_Setup0(void);
 static void Data_Setup0(void);
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : Standard_GetConfiguration.
 * Description    : Return the current configuration variable address.
 * Input          : Length - How many bytes are needed.
 * Output         : None.
 * Return         : Return 1 , if the request is invalid when "Length" is 0.
 *                  Return "Buffer" if the "Length" is not 0.
 *******************************************************************************/
 uint8_t *Standard_GetConfiguration(uint16_t Length)
+{
   if (Length == 0)
+  {
     pInformation->Ctrl_Info.Usb_wLength =
       sizeof(pInformation->Current_Configuration);
     return 0;
+  }
   pUser_Standard_Requests->User_GetConfiguration();
   return (uint8_t *)&pInformation->Current_Configuration;
+}
 /*******************************************************************************
 * Function Name  : Standard_SetConfiguration.
 * Description    : This routine is called to set the configuration value
 *                  Then each class should configure device itself.
 * Input          : None.
 * Output         : None.
 * Return         : Return USB_SUCCESS, if the request is performed.
 *                  Return USB_UNSUPPORT, if the request is invalid.
 *******************************************************************************/
 RESULT Standard_SetConfiguration(void)
+{
   if ((pInformation->USBwValue0 <=
       Device_Table.Total_Configuration) && (pInformation->USBwValue1 == 0)
       && (pInformation->USBwIndex == 0)) /*call Back usb spec 2.0*/
+  {
     pInformation->Current_Configuration = pInformation->USBwValue0;
     pUser_Standard_Requests->User_SetConfiguration();
     return USB_SUCCESS;
+  }
   else
+  {
     return USB_UNSUPPORT;
+  }
+}
 /*******************************************************************************
 * Function Name  : Standard_GetInterface.
 * Description    : Return the Alternate Setting of the current interface.
 * Input          : Length - How many bytes are needed.
 * Output         : None.
 * Return         : Return 0, if the request is invalid when "Length" is 0.
 *                  Return "Buffer" if the "Length" is not 0.
 *******************************************************************************/
 uint8_t *Standard_GetInterface(uint16_t Length)
+{
   if (Length == 0)
+  {
     pInformation->Ctrl_Info.Usb_wLength =
       sizeof(pInformation->Current_AlternateSetting);
     return 0;
+  }
   pUser_Standard_Requests->User_GetInterface();
   return (uint8_t *)&pInformation->Current_AlternateSetting;
+}
 /*******************************************************************************
 * Function Name  : Standard_SetInterface.
 * Description    : This routine is called to set the interface.
 *                  Then each class should configure the interface them self.
 * Input          : None.
 * Output         : None.
 * Return         : - Return USB_SUCCESS, if the request is performed.
 *                  - Return USB_UNSUPPORT, if the request is invalid.
 *******************************************************************************/
 RESULT Standard_SetInterface(void)
+{
   RESULT Re;
   /*Test if the specified Interface and Alternate Setting are supported by
     the application Firmware*/
   Re = (*pProperty->Class_Get_Interface_Setting)(pInformation->USBwIndex0, pInformation->USBwValue0);
   if (pInformation->Current_Configuration != 0)
+  {
     if ((Re != USB_SUCCESS) || (pInformation->USBwIndex1 != 0)
         || (pInformation->USBwValue1 != 0))
+    {
       return  USB_UNSUPPORT;
+    }
     else if (Re == USB_SUCCESS)
+    {
       pUser_Standard_Requests->User_SetInterface();
       pInformation->Current_Interface = pInformation->USBwIndex0;
       pInformation->Current_AlternateSetting = pInformation->USBwValue0;
       return USB_SUCCESS;
+    }
+  }
   return USB_UNSUPPORT;
+}
 /*******************************************************************************
 * Function Name  : Standard_GetStatus.
 * Description    : Copy the device request data to "StatusInfo buffer".
 * Input          : - Length - How many bytes are needed.
 * Output         : None.
 * Return         : Return 0, if the request is at end of data block,
 *                  or is invalid when "Length" is 0.
 *******************************************************************************/
 uint8_t *Standard_GetStatus(uint16_t Length)
+{
   if (Length == 0)
+  {
     pInformation->Ctrl_Info.Usb_wLength = 2;
     return 0;
+  }
   /* Reset Status Information */
   StatusInfo.w = 0;
   if (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+  {
     /*Get Device Status */
     uint8_t Feature = pInformation->Current_Feature;
     /* Remote Wakeup enabled */
     if (ValBit(Feature, 5))
+    {
       SetBit(StatusInfo0, 1);
+    }
     else
+    {
       ClrBit(StatusInfo0, 1);
+    }
     /* Bus-powered */
     if (ValBit(Feature, 6))
+    {
       SetBit(StatusInfo0, 0);
+    }
     else /* Self-powered */
+    {
       ClrBit(StatusInfo0, 0);
+    }
+  }
   /*Interface Status*/
   else if (Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT))
+  {
     return (uint8_t *)&StatusInfo;
+  }
   /*Get EndPoint Status*/
   else if (Type_Recipient == (STANDARD_REQUEST | ENDPOINT_RECIPIENT))
+  {
     uint8_t Related_Endpoint;
     uint8_t wIndex0 = pInformation->USBwIndex0;
     Related_Endpoint = (wIndex0 & 0x0f);
     if (ValBit(wIndex0, 7))
+    {
       /* IN endpoint */
       if (_GetTxStallStatus(Related_Endpoint))
+      {
         SetBit(StatusInfo0, 0); /* IN Endpoint stalled */
+      }
+    }
     else
+    {
       /* OUT endpoint */
       if (_GetRxStallStatus(Related_Endpoint))
+      {
         SetBit(StatusInfo0, 0); /* OUT Endpoint stalled */
+      }
+    }
+  }
   else
+  {
     return NULL;
+  }
   pUser_Standard_Requests->User_GetStatus();
   return (uint8_t *)&StatusInfo;
+}
 /*******************************************************************************
 * Function Name  : Standard_ClearFeature.
 * Description    : Clear or disable a specific feature.
 * Input          : None.
 * Output         : None.
 * Return         : - Return USB_SUCCESS, if the request is performed.
 *                  - Return USB_UNSUPPORT, if the request is invalid.
 *******************************************************************************/
 RESULT Standard_ClearFeature(void)
+{
   uint32_t     Type_Rec = Type_Recipient;
   uint32_t     Status;
   if (Type_Rec == (STANDARD_REQUEST | DEVICE_RECIPIENT))
   {/*Device Clear Feature*/
     ClrBit(pInformation->Current_Feature, 5);
     return USB_SUCCESS;
+  }
   else if (Type_Rec == (STANDARD_REQUEST | ENDPOINT_RECIPIENT))
   {/*EndPoint Clear Feature*/
     DEVICE* pDev;
     uint32_t Related_Endpoint;
     uint32_t wIndex0;
     uint32_t rEP;
     if ((pInformation->USBwValue != ENDPOINT_STALL)
         || (pInformation->USBwIndex1 != 0))
+    {
       return USB_UNSUPPORT;
+    }
     pDev = &Device_Table;
     wIndex0 = pInformation->USBwIndex0;
     rEP = wIndex0 & ~0x80;
     Related_Endpoint = ENDP0 + rEP;
     if (ValBit(pInformation->USBwIndex0, 7))
+    {
       /*Get Status of endpoint & stall the request if the related_ENdpoint
       is Disabled*/
       Status = _GetEPTxStatus(Related_Endpoint);
+    }
     else
+    {
       Status = _GetEPRxStatus(Related_Endpoint);
+    }
     if ((rEP >= pDev->Total_Endpoint) || (Status == 0)
         || (pInformation->Current_Configuration == 0))
+    {
       return USB_UNSUPPORT;
+    }
     if (wIndex0 & 0x80)
+    {
       /* IN endpoint */
       if (_GetTxStallStatus(Related_Endpoint ))
+      {
         ClearDTOG_TX(Related_Endpoint);
         SetEPTxStatus(Related_Endpoint, EP_TX_VALID);
+      }
+    }
     else
+    {
       /* OUT endpoint */
       if (_GetRxStallStatus(Related_Endpoint))
+      {
         if (Related_Endpoint == ENDP0)
+        {
           /* After clear the STALL, enable the default endpoint receiver */
           SetEPRxCount(Related_Endpoint, Device_Property.MaxPacketSize);
           _SetEPRxStatus(Related_Endpoint, EP_RX_VALID);
+        }
         else
+        {
           ClearDTOG_RX(Related_Endpoint);
           _SetEPRxStatus(Related_Endpoint, EP_RX_VALID);
+        }
+      }
+    }
     pUser_Standard_Requests->User_ClearFeature();
     return USB_SUCCESS;
+  }
   return USB_UNSUPPORT;
+}
 /*******************************************************************************
 * Function Name  : Standard_SetEndPointFeature
 * Description    : Set or enable a specific feature of EndPoint
 * Input          : None.
 * Output         : None.
 * Return         : - Return USB_SUCCESS, if the request is performed.
 *                  - Return USB_UNSUPPORT, if the request is invalid.
 *******************************************************************************/
 RESULT Standard_SetEndPointFeature(void)
+{
   uint32_t    wIndex0;
   uint32_t    Related_Endpoint;
   uint32_t    rEP;
   uint32_t    Status;
   wIndex0 = pInformation->USBwIndex0;
   rEP = wIndex0 & ~0x80;
   Related_Endpoint = ENDP0 + rEP;
   if (ValBit(pInformation->USBwIndex0, 7))
+  {
     /* get Status of endpoint & stall the request if the related_ENdpoint
     is Disabled*/
     Status = _GetEPTxStatus(Related_Endpoint);
+  }
   else
+  {
     Status = _GetEPRxStatus(Related_Endpoint);
+  }
   if (Related_Endpoint >= Device_Table.Total_Endpoint
       || pInformation->USBwValue != 0 || Status == 0
       || pInformation->Current_Configuration == 0)
+  {
     return USB_UNSUPPORT;
+  }
   else
+  {
     if (wIndex0 & 0x80)
+    {
       /* IN endpoint */
       _SetEPTxStatus(Related_Endpoint, EP_TX_STALL);
+    }
     else
+    {
       /* OUT endpoint */
       _SetEPRxStatus(Related_Endpoint, EP_RX_STALL);
+    }
+  }
   pUser_Standard_Requests->User_SetEndPointFeature();
   return USB_SUCCESS;
+}
 /*******************************************************************************
 * Function Name  : Standard_SetDeviceFeature.
 * Description    : Set or enable a specific feature of Device.
 * Input          : None.
 * Output         : None.
 * Return         : - Return USB_SUCCESS, if the request is performed.
 *                  - Return USB_UNSUPPORT, if the request is invalid.
 *******************************************************************************/
 RESULT Standard_SetDeviceFeature(void)
+{
   SetBit(pInformation->Current_Feature, 5);
   pUser_Standard_Requests->User_SetDeviceFeature();
   return USB_SUCCESS;
+}
 /*******************************************************************************
 * Function Name  : Standard_GetDescriptorData.
 * Description    : Standard_GetDescriptorData is used for descriptors transfer.
 *                : This routine is used for the descriptors resident in Flash
 *                  or RAM
 *                  pDesc can be in either Flash or RAM
 *                  The purpose of this routine is to have a versatile way to
 *                  response descriptors request. It allows user to generate
 *                  certain descriptors with software or read descriptors from
 *                  external storage part by part.
 * Input          : - Length - Length of the data in this transfer.
 *                  - pDesc - A pointer points to descriptor struct.
 *                  The structure gives the initial address of the descriptor and
 *                  its original size.
 * Output         : None.
 * Return         : Address of a part of the descriptor pointed by the Usb_
 *                  wOffset The buffer pointed by this address contains at least
 *                  Length bytes.
 *******************************************************************************/
 uint8_t *Standard_GetDescriptorData(uint16_t Length, ONE_DESCRIPTOR *pDesc)
+{
   uint32_t  wOffset;
   wOffset = pInformation->Ctrl_Info.Usb_wOffset;
   if (Length == 0)
+  {
     pInformation->Ctrl_Info.Usb_wLength = pDesc->Descriptor_Size - wOffset;
     return 0;
+  }
   return pDesc->Descriptor + wOffset;
+}
 /*******************************************************************************
 * Function Name  : DataStageOut.
 * Description    : Data stage of a Control Write Transfer.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void DataStageOut(void)
+{
   ENDPOINT_INFO *pEPinfo = &pInformation->Ctrl_Info;
   uint32_t save_rLength;
   save_rLength = pEPinfo->Usb_rLength;
   if (pEPinfo->CopyData && save_rLength)
+  {
     uint8_t *Buffer;
     uint32_t Length;
     Length = pEPinfo->PacketSize;
     if (Length > save_rLength)
+    {
       Length = save_rLength;
+    }
     Buffer = (*pEPinfo->CopyData)(Length);
     pEPinfo->Usb_rLength -= Length;
     pEPinfo->Usb_rOffset += Length;
     PMAToUserBufferCopy(Buffer, GetEPRxAddr(ENDP0), Length);
+  }
   if (pEPinfo->Usb_rLength != 0)
+  {
     vSetEPRxStatus(EP_RX_VALID);/* re-enable for next data reception */
     SetEPTxCount(ENDP0, 0);
     vSetEPTxStatus(EP_TX_VALID);/* Expect the host to abort the data OUT stage */
+  }
   /* Set the next State*/
   if (pEPinfo->Usb_rLength >= pEPinfo->PacketSize)
+  {
     pInformation->ControlState = OUT_DATA;
+  }
   else
+  {
     if (pEPinfo->Usb_rLength > 0)
+    {
       pInformation->ControlState = LAST_OUT_DATA;
+    }
     else if (pEPinfo->Usb_rLength == 0)
+    {
       pInformation->ControlState = WAIT_STATUS_IN;
       USB_StatusIn();
+    }
+  }
+}
 /*******************************************************************************
 * Function Name  : DataStageIn.
 * Description    : Data stage of a Control Read Transfer.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void DataStageIn(void)
+{
   ENDPOINT_INFO *pEPinfo = &pInformation->Ctrl_Info;
   uint32_t save_wLength = pEPinfo->Usb_wLength;
   uint32_t ControlState = pInformation->ControlState;
   uint8_t *DataBuffer;
   uint32_t Length;
   if ((save_wLength == 0) && (ControlState == LAST_IN_DATA))
+  {
     if(Data_Mul_MaxPacketSize == TRUE)
+    {
       /* No more data to send and empty packet */
       Send0LengthData();
       ControlState = LAST_IN_DATA;
       Data_Mul_MaxPacketSize = FALSE;
+    }
     else
+    {
       /* No more data to send so STALL the TX Status*/
       ControlState = WAIT_STATUS_OUT;
       vSetEPTxStatus(EP_TX_STALL);
+    }
     goto Expect_Status_Out;
+  }
   Length = pEPinfo->PacketSize;
   ControlState = (save_wLength <= Length) ? LAST_IN_DATA : IN_DATA;
   if (Length > save_wLength)
+  {
     Length = save_wLength;
+  }
   DataBuffer = (*pEPinfo->CopyData)(Length);
   UserToPMABufferCopy(DataBuffer, GetEPTxAddr(ENDP0), Length);
   SetEPTxCount(ENDP0, Length);
   pEPinfo->Usb_wLength -= Length;
   pEPinfo->Usb_wOffset += Length;
   vSetEPTxStatus(EP_TX_VALID);
   USB_StatusOut();/* Expect the host to abort the data IN stage */
 Expect_Status_Out:
   pInformation->ControlState = ControlState;
+}
 /*******************************************************************************
 * Function Name  : NoData_Setup0.
 * Description    : Proceed the processing of setup request without data stage.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void NoData_Setup0(void)
+{
   RESULT Result = USB_UNSUPPORT;
   uint32_t RequestNo = pInformation->USBbRequest;
   uint32_t ControlState;
   if (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+  {
     /* Device Request*/
     /* SET_CONFIGURATION*/
     if (RequestNo == SET_CONFIGURATION)
+    {
       Result = Standard_SetConfiguration();
+    }
     /*SET ADDRESS*/
     else if (RequestNo == SET_ADDRESS)
+    {
       if ((pInformation->USBwValue0 > 127) || (pInformation->USBwValue1 != 0)
           || (pInformation->USBwIndex != 0)
           || (pInformation->Current_Configuration != 0))
         /* Device Address should be 127 or less*/
+      {
         ControlState = STALLED;
         goto exit_NoData_Setup0;
+      }
       else
+      {
         Result = USB_SUCCESS;
+      }
+    }
     /*SET FEATURE for Device*/
     else if (RequestNo == SET_FEATURE)
+    {
       if ((pInformation->USBwValue0 == DEVICE_REMOTE_WAKEUP) \
           && (pInformation->USBwIndex == 0))
+      {
         Result = Standard_SetDeviceFeature();
+      }
       else
+      {
         Result = USB_UNSUPPORT;
+      }
+    }
     /*Clear FEATURE for Device */
     else if (RequestNo == CLEAR_FEATURE)
+    {
       if (pInformation->USBwValue0 == DEVICE_REMOTE_WAKEUP
           && pInformation->USBwIndex == 0
           && ValBit(pInformation->Current_Feature, 5))
+      {
         Result = Standard_ClearFeature();
+      }
       else
+      {
         Result = USB_UNSUPPORT;
+      }
+    }
+  }
   /* Interface Request*/
   else if (Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT))
+  {
     /*SET INTERFACE*/
     if (RequestNo == SET_INTERFACE)
+    {
       Result = Standard_SetInterface();
+    }
+  }
   /* EndPoint Request*/
   else if (Type_Recipient == (STANDARD_REQUEST | ENDPOINT_RECIPIENT))
+  {
     /*CLEAR FEATURE for EndPoint*/
     if (RequestNo == CLEAR_FEATURE)
+    {
       Result = Standard_ClearFeature();
+    }
     /* SET FEATURE for EndPoint*/
     else if (RequestNo == SET_FEATURE)
+    {
       Result = Standard_SetEndPointFeature();
+    }
+  }
   else
+  {
     Result = USB_UNSUPPORT;
+  }
   if (Result != USB_SUCCESS)
+  {
     Result = (*pProperty->Class_NoData_Setup)(RequestNo);
     if (Result == USB_NOT_READY)
+    {
       ControlState = PAUSE;
       goto exit_NoData_Setup0;
+    }
+  }
   if (Result != USB_SUCCESS)
+  {
     ControlState = STALLED;
     goto exit_NoData_Setup0;
+  }
   ControlState = WAIT_STATUS_IN;/* After no data stage SETUP */
   USB_StatusIn();
 exit_NoData_Setup0:
   pInformation->ControlState = ControlState;
   return;
+}
 /*******************************************************************************
 * Function Name  : Data_Setup0.
 * Description    : Proceed the processing of setup request with data stage.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Data_Setup0(void)
+{
   uint8_t *(*CopyRoutine)(uint16_t);
   RESULT Result;
   uint32_t Request_No = pInformation->USBbRequest;
   uint32_t Related_Endpoint, Reserved;
   uint32_t wOffset, Status;
   CopyRoutine = NULL;
   wOffset = 0;
   /*GET DESCRIPTOR*/
   if (Request_No == GET_DESCRIPTOR)
+  {
     if (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+    {
       uint8_t wValue1 = pInformation->USBwValue1;
       if (wValue1 == DEVICE_DESCRIPTOR)
+      {
         CopyRoutine = pProperty->GetDeviceDescriptor;
+      }
       else if (wValue1 == CONFIG_DESCRIPTOR)
+      {
         CopyRoutine = pProperty->GetConfigDescriptor;
+      }
       else if (wValue1 == STRING_DESCRIPTOR)
+      {
         CopyRoutine = pProperty->GetStringDescriptor;
       }  /* End of GET_DESCRIPTOR */
+    }
+  }
   /*GET STATUS*/
   else if ((Request_No == GET_STATUS) && (pInformation->USBwValue == 0)
            && (pInformation->USBwLength == 0x0002)
            && (pInformation->USBwIndex1 == 0))
+  {
     /* GET STATUS for Device*/
     if ((Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
         && (pInformation->USBwIndex == 0))
+    {
       CopyRoutine = Standard_GetStatus;
+    }
     /* GET STATUS for Interface*/
     else if (Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT))
+    {
       if (((*pProperty->Class_Get_Interface_Setting)(pInformation->USBwIndex0, 0) == USB_SUCCESS)
           && (pInformation->Current_Configuration != 0))
+      {
         CopyRoutine = Standard_GetStatus;
+      }
+    }
     /* GET STATUS for EndPoint*/
     else if (Type_Recipient == (STANDARD_REQUEST | ENDPOINT_RECIPIENT))
+    {
       Related_Endpoint = (pInformation->USBwIndex0 & 0x0f);
       Reserved = pInformation->USBwIndex0 & 0x70;
       if (ValBit(pInformation->USBwIndex0, 7))
+      {
         /*Get Status of endpoint & stall the request if the related_ENdpoint
         is Disabled*/
         Status = _GetEPTxStatus(Related_Endpoint);
+      }
       else
+      {
         Status = _GetEPRxStatus(Related_Endpoint);
+      }
       if ((Related_Endpoint < Device_Table.Total_Endpoint) && (Reserved == 0)
           && (Status != 0))
+      {
         CopyRoutine = Standard_GetStatus;
+      }
+    }
+  }
   /*GET CONFIGURATION*/
   else if (Request_No == GET_CONFIGURATION)
+  {
     if (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT))
+    {
       CopyRoutine = Standard_GetConfiguration;
+    }
+  }
   /*GET INTERFACE*/
   else if (Request_No == GET_INTERFACE)
+  {
     if ((Type_Recipient == (STANDARD_REQUEST | INTERFACE_RECIPIENT))
         && (pInformation->Current_Configuration != 0) && (pInformation->USBwValue == 0)
         && (pInformation->USBwIndex1 == 0) && (pInformation->USBwLength == 0x0001)
         && ((*pProperty->Class_Get_Interface_Setting)(pInformation->USBwIndex0, 0) == USB_SUCCESS))
+    {
       CopyRoutine = Standard_GetInterface;
+    }
+  }
   if (CopyRoutine)
+  {
     pInformation->Ctrl_Info.Usb_wOffset = wOffset;
     pInformation->Ctrl_Info.CopyData = CopyRoutine;
     /* sb in the original the cast to word was directly */
     /* now the cast is made step by step */
     (*CopyRoutine)(0);
     Result = USB_SUCCESS;
+  }
   else
+  {
     Result = (*pProperty->Class_Data_Setup)(pInformation->USBbRequest);
     if (Result == USB_NOT_READY)
+    {
       pInformation->ControlState = PAUSE;
       return;
+    }
+  }
   if (pInformation->Ctrl_Info.Usb_wLength == 0xFFFF)
+  {
     /* Data is not ready, wait it */
     pInformation->ControlState = PAUSE;
     return;
+  }
   if ((Result == USB_UNSUPPORT) || (pInformation->Ctrl_Info.Usb_wLength == 0))
+  {
     /* Unsupported request */
     pInformation->ControlState = STALLED;
     return;
+  }
   if (ValBit(pInformation->USBbmRequestType, 7))
+  {
     /* Device ==> Host */
     __IO uint32_t wLength = pInformation->USBwLength;
     /* Restrict the data length to be the one host asks for */
     if (pInformation->Ctrl_Info.Usb_wLength > wLength)
+    {
       pInformation->Ctrl_Info.Usb_wLength = wLength;
+    }
     else if (pInformation->Ctrl_Info.Usb_wLength < pInformation->USBwLength)
+    {
       if (pInformation->Ctrl_Info.Usb_wLength < pProperty->MaxPacketSize)
+      {
         Data_Mul_MaxPacketSize = FALSE;
+      }
       else if ((pInformation->Ctrl_Info.Usb_wLength % pProperty->MaxPacketSize) == 0)
+      {
         Data_Mul_MaxPacketSize = TRUE;
+      }
+    }
     pInformation->Ctrl_Info.PacketSize = pProperty->MaxPacketSize;
     DataStageIn();
+  }
   else
+  {
     pInformation->ControlState = OUT_DATA;
     vSetEPRxStatus(EP_RX_VALID); /* enable for next data reception */
+  }
   return;
+}
 /*******************************************************************************
 * Function Name  : Setup0_Process
 * Description    : Get the device request data and dispatch to individual process.
 * Input          : None.
 * Output         : None.
 * Return         : Post0_Process.
 *******************************************************************************/
 uint8_t Setup0_Process(void)
+{
   union
+  {
     uint8_t* b;
     uint16_t* w;
   } pBuf;
   uint16_t offset = 1;
   pBuf.b = PMAAddr + (uint8_t *)(_GetEPRxAddr(ENDP0) * 2); /* *2 for 32 bits addr */
   if (pInformation->ControlState != PAUSE)
+  {
     pInformation->USBbmRequestType = *pBuf.b++; /* bmRequestType */
     pInformation->USBbRequest = *pBuf.b++; /* bRequest */
     pBuf.w += offset;  /* word not accessed because of 32 bits addressing */
     pInformation->USBwValue = ByteSwap(*pBuf.w++); /* wValue */
     pBuf.w += offset;  /* word not accessed because of 32 bits addressing */
     pInformation->USBwIndex  = ByteSwap(*pBuf.w++); /* wIndex */
     pBuf.w += offset;  /* word not accessed because of 32 bits addressing */
     pInformation->USBwLength = *pBuf.w; /* wLength */
+  }
   pInformation->ControlState = SETTING_UP;
   if (pInformation->USBwLength == 0)
+  {
     /* Setup with no data stage */
     NoData_Setup0();
+  }
   else
+  {
     /* Setup with data stage */
     Data_Setup0();
+  }
   return Post0_Process();
+}
 /*******************************************************************************
 * Function Name  : In0_Process
 * Description    : Process the IN token on all default endpoint.
 * Input          : None.
 * Output         : None.
 * Return         : Post0_Process.
 *******************************************************************************/
 uint8_t In0_Process(void)
+{
   uint32_t ControlState = pInformation->ControlState;
   if ((ControlState == IN_DATA) || (ControlState == LAST_IN_DATA))
+  {
     DataStageIn();
     /* ControlState may be changed outside the function */
     ControlState = pInformation->ControlState;
+  }
   else if (ControlState == WAIT_STATUS_IN)
+  {
     if ((pInformation->USBbRequest == SET_ADDRESS) &&
         (Type_Recipient == (STANDARD_REQUEST | DEVICE_RECIPIENT)))
+    {
       SetDeviceAddress(pInformation->USBwValue0);
       pUser_Standard_Requests->User_SetDeviceAddress();
+    }
     (*pProperty->Process_Status_IN)();
     ControlState = STALLED;
+  }
   else
+  {
     ControlState = STALLED;
+  }
   pInformation->ControlState = ControlState;
   return Post0_Process();
+}
 /*******************************************************************************
 * Function Name  : Out0_Process
 * Description    : Process the OUT token on all default endpoint.
 * Input          : None.
 * Output         : None.
 * Return         : Post0_Process.
 *******************************************************************************/
 uint8_t Out0_Process(void)
+{
   uint32_t ControlState = pInformation->ControlState;
   if ((ControlState == IN_DATA) || (ControlState == LAST_IN_DATA))
+  {
     /* host aborts the transfer before finish */
     ControlState = STALLED;
+  }
   else if ((ControlState == OUT_DATA) || (ControlState == LAST_OUT_DATA))
+  {
     DataStageOut();
     ControlState = pInformation->ControlState; /* may be changed outside the function */
+  }
   else if (ControlState == WAIT_STATUS_OUT)
+  {
     (*pProperty->Process_Status_OUT)();
     ControlState = STALLED;
+  }
   /* Unexpect state, STALL the endpoint */
   else
+  {
     ControlState = STALLED;
+  }
   pInformation->ControlState = ControlState;
   return Post0_Process();
+}
 /*******************************************************************************
 * Function Name  : Post0_Process
 * Description    : Stall the Endpoint 0 in case of error.
 * Input          : None.
 * Output         : None.
 * Return         : - 0 if the control State is in PAUSE
 *                  - 1 if not.
 *******************************************************************************/
 uint8_t Post0_Process(void)
+{
   SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
   if (pInformation->ControlState == STALLED)
+  {
     vSetEPRxStatus(EP_RX_STALL);
     vSetEPTxStatus(EP_TX_STALL);
+  }
   return (pInformation->ControlState == PAUSE);
+}
 /*******************************************************************************
 * Function Name  : SetDeviceAddress.
 * Description    : Set the device and all the used Endpoints addresses.
 * Input          : - Val: device address.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetDeviceAddress(uint8_t Val)
+{
   uint32_t i;
   uint32_t nEP = Device_Table.Total_Endpoint;
   /* set address in every used endpoint */
   for (i = 0; i < nEP; i++)
+  {
     _SetEPAddress((uint8_t)i, (uint8_t)i);
   } /* for */
   _SetDADDR(Val | DADDR_EF); /* set device address and enable function */
+}
 /*******************************************************************************
 * Function Name  : NOP_Process
 * Description    : No operation function.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void NOP_Process(void)
+{
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_core.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_core.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Standard protocol processing functions prototypes
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 __USB_CORE_H
 #define __USB_CORE_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 typedef enum _CONTROL_STATE
+{
   WAIT_SETUP,       /* 0 */
   SETTING_UP,       /* 1 */
   IN_DATA,          /* 2 */
   OUT_DATA,         /* 3 */
   LAST_IN_DATA,     /* 4 */
   LAST_OUT_DATA,    /* 5 */
   WAIT_STATUS_IN,   /* 7 */
   WAIT_STATUS_OUT,  /* 8 */
   STALLED,          /* 9 */
   PAUSE             /* 10 */
 } CONTROL_STATE;    /* The state machine states of a control pipe */
 typedef struct OneDescriptor
+{
   uint8_t *Descriptor;
   uint16_t Descriptor_Size;
+}
 ONE_DESCRIPTOR, *PONE_DESCRIPTOR;
 /* All the request process routines return a value of this type
    If the return value is not SUCCESS or NOT_READY,
    the software will STALL the correspond endpoint */
 typedef enum _RESULT
+{
   USB_SUCCESS = 0,    /* Process successfully */
   USB_ERROR,
   USB_UNSUPPORT,
   USB_NOT_READY       /* The process has not been finished, endpoint will be
                          NAK to further request */
 } RESULT;
 /*-*-*-*-*-*-*-*-*-*-* Definitions for endpoint level -*-*-*-*-*-*-*-*-*-*-*-*/
 typedef struct _ENDPOINT_INFO
+{
   /* When send data out of the device,
    CopyData() is used to get data buffer 'Length' bytes data
    if Length is 0,
     CopyData() returns the total length of the data
     if the request is not supported, returns 0
     (NEW Feature )
      if CopyData() returns -1, the calling routine should not proceed
      further and will resume the SETUP process by the class device
    if Length is not 0,
     CopyData() returns a pointer to indicate the data location
    Usb_wLength is the data remain to be sent,
    Usb_wOffset is the Offset of original data
   When receive data from the host,
    CopyData() is used to get user data buffer which is capable
    of Length bytes data to copy data from the endpoint buffer.
    if Length is 0,
     CopyData() returns the available data length,
    if Length is not 0,
     CopyData() returns user buffer address
    Usb_rLength is the data remain to be received,
    Usb_rPointer is the Offset of data buffer
   */
   uint16_t  Usb_wLength;
   uint16_t  Usb_wOffset;
   uint16_t  PacketSize;
   uint8_t   *(*CopyData)(uint16_t Length);
 }ENDPOINT_INFO;
 /*-*-*-*-*-*-*-*-*-*-*-* Definitions for device level -*-*-*-*-*-*-*-*-*-*-*-*/
 typedef struct _DEVICE
+{
   uint8_t Total_Endpoint;     /* Number of endpoints that are used */
   uint8_t Total_Configuration;/* Number of configuration available */
+}
 DEVICE;
 typedef union
+{
   uint16_t w;
   struct BW
+  {
     uint8_t bb1;
     uint8_t bb0;
+  }
   bw;
 } uint16_t_uint8_t;
 typedef struct _DEVICE_INFO
+{
   uint8_t USBbmRequestType;       /* bmRequestType */
   uint8_t USBbRequest;            /* bRequest */
   uint16_t_uint8_t USBwValues;         /* wValue */
   uint16_t_uint8_t USBwIndexs;         /* wIndex */
   uint16_t_uint8_t USBwLengths;        /* wLength */
   uint8_t ControlState;           /* of type CONTROL_STATE */
   uint8_t Current_Feature;
   uint8_t Current_Configuration;   /* Selected configuration */
   uint8_t Current_Interface;       /* Selected interface of current configuration */
   uint8_t Current_AlternateSetting;/* Selected Alternate Setting of current
                                      interface*/
   ENDPOINT_INFO Ctrl_Info;
 }DEVICE_INFO;
 typedef struct _DEVICE_PROP
+{
   void (*Init)(void);        /* Initialize the device */
   void (*Reset)(void);       /* Reset routine of this device */
   /* Device dependent process after the status stage */
   void (*Process_Status_IN)(void);
   void (*Process_Status_OUT)(void);
   /* Procedure of process on setup stage of a class specified request with data stage */
   /* All class specified requests with data stage are processed in Class_Data_Setup
    Class_Data_Setup()
     responses to check all special requests and fills ENDPOINT_INFO
     according to the request
     If IN tokens are expected, then wLength & wOffset will be filled
     with the total transferring bytes and the starting position
     If OUT tokens are expected, then rLength & rOffset will be filled
     with the total expected bytes and the starting position in the buffer
     If the request is valid, Class_Data_Setup returns SUCCESS, else UNSUPPORT
    CAUTION:
     Since GET_CONFIGURATION & GET_INTERFACE are highly related to
     the individual classes, they will be checked and processed here.
   */
   RESULT (*Class_Data_Setup)(uint8_t RequestNo);
   /* Procedure of process on setup stage of a class specified request without data stage */
   /* All class specified requests without data stage are processed in Class_NoData_Setup
    Class_NoData_Setup
     responses to check all special requests and perform the request
    CAUTION:
     Since SET_CONFIGURATION & SET_INTERFACE are highly related to
     the individual classes, they will be checked and processed here.
   */
   RESULT (*Class_NoData_Setup)(uint8_t RequestNo);
   /*Class_Get_Interface_Setting
    This function is used by the file usb_core.c to test if the selected Interface
    and Alternate Setting (uint8_t Interface, uint8_t AlternateSetting) are supported by
    the application.
    This function is writing by user. It should return "SUCCESS" if the Interface
    and Alternate Setting are supported by the application or "UNSUPPORT" if they
    are not supported. */
   RESULT  (*Class_Get_Interface_Setting)(uint8_t Interface, uint8_t AlternateSetting);
   uint8_t* (*GetDeviceDescriptor)(uint16_t Length);
   uint8_t* (*GetConfigDescriptor)(uint16_t Length);
   uint8_t* (*GetStringDescriptor)(uint16_t Length);
   /* This field is not used in current library version. It is kept only for
    compatibility with previous versions */
   void* RxEP_buffer;
   uint8_t MaxPacketSize;
 }DEVICE_PROP;
 typedef struct _USER_STANDARD_REQUESTS
+{
   void (*User_GetConfiguration)(void);       /* Get Configuration */
   void (*User_SetConfiguration)(void);       /* Set Configuration */
   void (*User_GetInterface)(void);           /* Get Interface */
   void (*User_SetInterface)(void);           /* Set Interface */
   void (*User_GetStatus)(void);              /* Get Status */
   void (*User_ClearFeature)(void);           /* Clear Feature */
   void (*User_SetEndPointFeature)(void);     /* Set Endpoint Feature */
   void (*User_SetDeviceFeature)(void);       /* Set Device Feature */
   void (*User_SetDeviceAddress)(void);       /* Set Device Address */
+}
 USER_STANDARD_REQUESTS;
 /* Exported constants --------------------------------------------------------*/
 #define Type_Recipient (pInformation->USBbmRequestType & (REQUEST_TYPE | RECIPIENT))
 #define Usb_rLength Usb_wLength
 #define Usb_rOffset Usb_wOffset
 #define USBwValue USBwValues.w
 #define USBwValue0 USBwValues.bw.bb0
 #define USBwValue1 USBwValues.bw.bb1
 #define USBwIndex USBwIndexs.w
 #define USBwIndex0 USBwIndexs.bw.bb0
 #define USBwIndex1 USBwIndexs.bw.bb1
 #define USBwLength USBwLengths.w
 #define USBwLength0 USBwLengths.bw.bb0
 #define USBwLength1 USBwLengths.bw.bb1
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 uint8_t Setup0_Process(void);
 uint8_t Post0_Process(void);
 uint8_t Out0_Process(void);
 uint8_t In0_Process(void);
 RESULT Standard_SetEndPointFeature(void);
 RESULT Standard_SetDeviceFeature(void);
 uint8_t *Standard_GetConfiguration(uint16_t Length);
 RESULT Standard_SetConfiguration(void);
 uint8_t *Standard_GetInterface(uint16_t Length);
 RESULT Standard_SetInterface(void);
 uint8_t *Standard_GetDescriptorData(uint16_t Length, PONE_DESCRIPTOR pDesc);
 uint8_t *Standard_GetStatus(uint16_t Length);
 RESULT Standard_ClearFeature(void);
 void SetDeviceAddress(uint8_t);
 void NOP_Process(void);
 extern DEVICE_PROP Device_Property;
 extern  USER_STANDARD_REQUESTS User_Standard_Requests;
 extern  DEVICE  Device_Table;
 extern DEVICE_INFO Device_Info;
 /* cells saving status during interrupt servicing */
 extern __IO uint16_t SaveRState;
 extern __IO uint16_t SaveTState;
 #endif /* __USB_CORE_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_def.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_def.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Definitions related to USB Core
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 __USB_DEF_H
 #define __USB_DEF_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 typedef enum _RECIPIENT_TYPE
+{
   DEVICE_RECIPIENT,     /* Recipient device */
   INTERFACE_RECIPIENT,  /* Recipient interface */
   ENDPOINT_RECIPIENT,   /* Recipient endpoint */
   OTHER_RECIPIENT
 } RECIPIENT_TYPE;
 typedef enum _STANDARD_REQUESTS
+{
   GET_STATUS = 0,
   CLEAR_FEATURE,
   RESERVED1,
   SET_FEATURE,
   RESERVED2,
   SET_ADDRESS,
   GET_DESCRIPTOR,
   SET_DESCRIPTOR,
   GET_CONFIGURATION,
   SET_CONFIGURATION,
   GET_INTERFACE,
   SET_INTERFACE,
   TOTAL_sREQUEST,  /* Total number of Standard request */
   SYNCH_FRAME = 12
 } STANDARD_REQUESTS;
 /* Definition of "USBwValue" */
 typedef enum _DESCRIPTOR_TYPE
+{
   DEVICE_DESCRIPTOR = 1,
   CONFIG_DESCRIPTOR,
   STRING_DESCRIPTOR,
   INTERFACE_DESCRIPTOR,
   ENDPOINT_DESCRIPTOR
 } DESCRIPTOR_TYPE;
 /* Feature selector of a SET_FEATURE or CLEAR_FEATURE */
 typedef enum _FEATURE_SELECTOR
+{
   ENDPOINT_STALL,
   DEVICE_REMOTE_WAKEUP
 } FEATURE_SELECTOR;
 /* Exported constants --------------------------------------------------------*/
 /* Definition of "USBbmRequestType" */
 #define REQUEST_TYPE      0x60  /* Mask to get request type */
 #define STANDARD_REQUEST  0x00  /* Standard request */
 #define CLASS_REQUEST     0x20  /* Class request */
 #define VENDOR_REQUEST    0x40  /* Vendor request */
 #define RECIPIENT         0x1F  /* Mask to get recipient */
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 #endif /* __USB_DEF_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_desc.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_desc.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   Descriptors for Virtual Com Port Demo
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 "usb_lib.h"
 #include "usb_desc.h"
 /* USB Standard Device Descriptor */
 const uint8_t Virtual_Com_Port_DeviceDescriptor[] =
+  {
 x12,   /* bLength */
     USB_DEVICE_DESCRIPTOR_TYPE,     /* bDescriptorType */
 x00,
 x02,   /* bcdUSB = 2.00 */
 x02,   /* bDeviceClass: CDC */
 x00,   /* bDeviceSubClass */
 x00,   /* bDeviceProtocol */
 x40,   /* bMaxPacketSize0 */
 x83,
 x04,   /* idVendor = 0x0483 */
 x40,
 x57,   /* idProduct = 0x7540 */
 x00,
 x02,   /* bcdDevice = 2.00 */
 ,              /* Index of string descriptor describing manufacturer */
 ,              /* Index of string descriptor describing product */
 ,              /* Index of string descriptor describing the device's serial number */
 x01    /* bNumConfigurations */
   };
 const uint8_t Virtual_Com_Port_ConfigDescriptor[] =
+  {
     /*Configuration Descriptor*/
 x09,   /* bLength: Configuration Descriptor size */
     USB_CONFIGURATION_DESCRIPTOR_TYPE,      /* bDescriptorType: Configuration */
     VIRTUAL_COM_PORT_SIZ_CONFIG_DESC,       /* wTotalLength:no of returned bytes */
 x00,
 x02,   /* bNumInterfaces: 2 interface */
 x01,   /* bConfigurationValue: Configuration value */
 x00,   /* iConfiguration: Index of string descriptor describing the configuration */
 xC0,   /* bmAttributes: self powered */
 x32,   /* MaxPower 0 mA */
     /*Interface Descriptor*/
 x09,   /* bLength: Interface Descriptor size */
     USB_INTERFACE_DESCRIPTOR_TYPE,  /* bDescriptorType: Interface */
     /* Interface descriptor type */
 x00,   /* bInterfaceNumber: Number of Interface */
 x00,   /* bAlternateSetting: Alternate setting */
 x01,   /* bNumEndpoints: One endpoints used */
 x02,   /* bInterfaceClass: Communication Interface Class */
 x02,   /* bInterfaceSubClass: Abstract Control Model */
 x01,   /* bInterfaceProtocol: Common AT commands */
 x00,   /* iInterface: */
     /*Header Functional Descriptor*/
 x05,   /* bLength: Endpoint Descriptor size */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x00,   /* bDescriptorSubtype: Header Func Desc */
 x10,   /* bcdCDC: spec release number */
 x01,
     /*Call Management Functional Descriptor*/
 x05,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x01,   /* bDescriptorSubtype: Call Management Func Desc */
 x00,   /* bmCapabilities: D0+D1 */
 x01,   /* bDataInterface: 1 */
     /*ACM Functional Descriptor*/
 x04,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x02,   /* bDescriptorSubtype: Abstract Control Management desc */
 x02,   /* bmCapabilities */
     /*Union Functional Descriptor*/
 x05,   /* bFunctionLength */
 x24,   /* bDescriptorType: CS_INTERFACE */
 x06,   /* bDescriptorSubtype: Union func desc */
 x00,   /* bMasterInterface: Communication class interface */
 x01,   /* bSlaveInterface0: Data Class Interface */
     /*Endpoint 2 Descriptor*/
 x07,   /* bLength: Endpoint Descriptor size */
     USB_ENDPOINT_DESCRIPTOR_TYPE,   /* bDescriptorType: Endpoint */
 x82,   /* bEndpointAddress: (IN2) */
 x03,   /* bmAttributes: Interrupt */
     VIRTUAL_COM_PORT_INT_SIZE,      /* wMaxPacketSize: */
 x00,
 xFF,   /* bInterval: */
     /*Data class interface descriptor*/
 x09,   /* bLength: Endpoint Descriptor size */
     USB_INTERFACE_DESCRIPTOR_TYPE,  /* bDescriptorType: */
 x01,   /* bInterfaceNumber: Number of Interface */
 x00,   /* bAlternateSetting: Alternate setting */
 x02,   /* bNumEndpoints: Two endpoints used */
 x0A,   /* bInterfaceClass: CDC */
 x00,   /* bInterfaceSubClass: */
 x00,   /* bInterfaceProtocol: */
 x00,   /* iInterface: */
     /*Endpoint 3 Descriptor*/
 x07,   /* bLength: Endpoint Descriptor size */
     USB_ENDPOINT_DESCRIPTOR_TYPE,   /* bDescriptorType: Endpoint */
 x03,   /* bEndpointAddress: (OUT3) */
 x02,   /* bmAttributes: Bulk */
     VIRTUAL_COM_PORT_DATA_SIZE,             /* wMaxPacketSize: */
 x00,
 x00,   /* bInterval: ignore for Bulk transfer */
     /*Endpoint 1 Descriptor*/
 x07,   /* bLength: Endpoint Descriptor size */
     USB_ENDPOINT_DESCRIPTOR_TYPE,   /* bDescriptorType: Endpoint */
 x81,   /* bEndpointAddress: (IN1) */
 x02,   /* bmAttributes: Bulk */
     VIRTUAL_COM_PORT_DATA_SIZE,             /* wMaxPacketSize: */
 x00,
 x00    /* bInterval */
   };
 /* USB String Descriptors */
 const uint8_t Virtual_Com_Port_StringLangID[VIRTUAL_COM_PORT_SIZ_STRING_LANGID] =
+  {
     VIRTUAL_COM_PORT_SIZ_STRING_LANGID,
     USB_STRING_DESCRIPTOR_TYPE,
 x09,
 x04 /* LangID = 0x0409: U.S. English */
   };
 const uint8_t Virtual_Com_Port_StringVendor[VIRTUAL_COM_PORT_SIZ_STRING_VENDOR] =
+  {
     VIRTUAL_COM_PORT_SIZ_STRING_VENDOR,     /* Size of Vendor string */
     USB_STRING_DESCRIPTOR_TYPE,             /* bDescriptorType*/
     /* Manufacturer: "STMicroelectronics" */
     'S', 0, 'T', 0, 'M', 0, 'i', 0, 'c', 0, 'r', 0, 'o', 0, 'e', 0,
     'l', 0, 'e', 0, 'c', 0, 't', 0, 'r', 0, 'o', 0, 'n', 0, 'i', 0,
     'c', 0, 's', 0
   };
 const uint8_t Virtual_Com_Port_StringProduct[VIRTUAL_COM_PORT_SIZ_STRING_PRODUCT] =
+  {
     VIRTUAL_COM_PORT_SIZ_STRING_PRODUCT,          /* bLength */
     USB_STRING_DESCRIPTOR_TYPE,        /* bDescriptorType */
     /* Product name: "STM32 Virtual COM Port" */
     'S', 0, 'T', 0, 'M', 0, '3', 0, '2', 0, ' ', 0, 'V', 0, 'i', 0,
     'r', 0, 't', 0, 'u', 0, 'a', 0, 'l', 0, ' ', 0, 'C', 0, 'O', 0,
     'M', 0, ' ', 0, 'P', 0, 'o', 0, 'r', 0, 't', 0, ' ', 0, ' ', 0
   };
 uint8_t Virtual_Com_Port_StringSerial[VIRTUAL_COM_PORT_SIZ_STRING_SERIAL] =
+  {
     VIRTUAL_COM_PORT_SIZ_STRING_SERIAL,           /* bLength */
     USB_STRING_DESCRIPTOR_TYPE,                   /* bDescriptorType */
     'S', 0, 'T', 0, 'M', 0, '3', 0, '2', 0
   };
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_desc.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_desc.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   Descriptor Header for Virtual COM Port Device
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 __USB_DESC_H
 #define __USB_DESC_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported define -----------------------------------------------------------*/
 #define USB_DEVICE_DESCRIPTOR_TYPE              0x01
 #define USB_CONFIGURATION_DESCRIPTOR_TYPE       0x02
 #define USB_STRING_DESCRIPTOR_TYPE              0x03
 #define USB_INTERFACE_DESCRIPTOR_TYPE           0x04
 #define USB_ENDPOINT_DESCRIPTOR_TYPE            0x05
 #define VIRTUAL_COM_PORT_DATA_SIZE              64
 #define VIRTUAL_COM_PORT_INT_SIZE               8
 #define VIRTUAL_COM_PORT_SIZ_DEVICE_DESC        18
 #define VIRTUAL_COM_PORT_SIZ_CONFIG_DESC        67
 #define VIRTUAL_COM_PORT_SIZ_STRING_LANGID      4
 #define VIRTUAL_COM_PORT_SIZ_STRING_VENDOR      38
 #define VIRTUAL_COM_PORT_SIZ_STRING_PRODUCT     50
 #define VIRTUAL_COM_PORT_SIZ_STRING_SERIAL      26
 #define STANDARD_ENDPOINT_DESC_SIZE             0x09
 /* Exported functions ------------------------------------------------------- */
 extern const uint8_t Virtual_Com_Port_DeviceDescriptor[VIRTUAL_COM_PORT_SIZ_DEVICE_DESC];
 extern const uint8_t Virtual_Com_Port_ConfigDescriptor[VIRTUAL_COM_PORT_SIZ_CONFIG_DESC];
 extern const uint8_t Virtual_Com_Port_StringLangID[VIRTUAL_COM_PORT_SIZ_STRING_LANGID];
 extern const uint8_t Virtual_Com_Port_StringVendor[VIRTUAL_COM_PORT_SIZ_STRING_VENDOR];
 extern const uint8_t Virtual_Com_Port_StringProduct[VIRTUAL_COM_PORT_SIZ_STRING_PRODUCT];
 extern uint8_t Virtual_Com_Port_StringSerial[VIRTUAL_COM_PORT_SIZ_STRING_SERIAL];
 #endif /* __USB_DESC_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_endp.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_endp.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   Endpoint routines
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 "usb_lib.h"
 #include "usb_desc.h"
 #include "usb_mem.h"
 #include "hw_config.h"
 #include "usb_istr.h"
 #include "usb_pwr.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Interval between sending IN packets in frame number (1 frame = 1ms) */
 #define VCOMPORT_IN_FRAME_INTERVAL             5
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 extern __IO uint8_t Receive_Buffer[64];
 uint32_t Receive_length;
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : EP1_IN_Callback
 * Description    :
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void EP1_IN_Callback (void)
+{
   set_packet_sent();
+}
 /*******************************************************************************
 * Function Name  : EP3_OUT_Callback
 * Description    :
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void EP3_OUT_Callback(void)
+{
   set_packet_receive();
   Receive_length = GetEPRxCount(ENDP3);
   PMAToUserBufferCopy((unsigned char*)Receive_Buffer, ENDP3_RXADDR, Receive_length);
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_init.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_init.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Initialization routines & global variables
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 "usb_lib.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /*  The number of current endpoint, it will be used to specify an endpoint */
  uint8_t	EPindex;
 /*  The number of current device, it is an index to the Device_Table */
 /* uint8_t	Device_no; */
 /*  Points to the DEVICE_INFO structure of current device */
 /*  The purpose of this register is to speed up the execution */
 DEVICE_INFO *pInformation;
 /*  Points to the DEVICE_PROP structure of current device */
 /*  The purpose of this register is to speed up the execution */
 DEVICE_PROP *pProperty;
 /*  Temporary save the state of Rx & Tx status. */
 /*  Whenever the Rx or Tx state is changed, its value is saved */
 /*  in this variable first and will be set to the EPRB or EPRA */
 /*  at the end of interrupt process */
 uint16_t	SaveState ;
 uint16_t  wInterrupt_Mask;
 DEVICE_INFO	Device_Info;
 USER_STANDARD_REQUESTS  *pUser_Standard_Requests;
 /* Extern variables ----------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : USB_Init
 * Description    : USB system initialization
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void USB_Init(void)
+{
   pInformation = &Device_Info;
   pInformation->ControlState = 2;
   pProperty = &Device_Property;
   pUser_Standard_Requests = &User_Standard_Requests;
   /* Initialize devices one by one */
   pProperty->Init();
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_init.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_init.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Initialization routines & global variables
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 __USB_INIT_H
 #define __USB_INIT_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 void USB_Init(void);
 /* External variables --------------------------------------------------------*/
 /*  The number of current endpoint, it will be used to specify an endpoint */
 extern uint8_t	EPindex;
 /*  The number of current device, it is an index to the Device_Table */
 /*extern uint8_t	Device_no; */
 /*  Points to the DEVICE_INFO structure of current device */
 /*  The purpose of this register is to speed up the execution */
 extern DEVICE_INFO*	pInformation;
 /*  Points to the DEVICE_PROP structure of current device */
 /*  The purpose of this register is to speed up the execution */
 extern DEVICE_PROP*	pProperty;
 /*  Temporary save the state of Rx & Tx status. */
 /*  Whenever the Rx or Tx state is changed, its value is saved */
 /*  in this variable first and will be set to the EPRB or EPRA */
 /*  at the end of interrupt process */
 extern USER_STANDARD_REQUESTS *pUser_Standard_Requests;
 extern uint16_t	SaveState ;
 extern uint16_t wInterrupt_Mask;
 #endif /* __USB_INIT_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_int.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_int.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Endpoint CTR (Low and High) interrupt's service routines
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 "usb_lib.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 __IO uint16_t SaveRState;
 __IO uint16_t SaveTState;
 /* Extern variables ----------------------------------------------------------*/
 extern void (*pEpInt_IN[7])(void);    /*  Handles IN  interrupts   */
 extern void (*pEpInt_OUT[7])(void);   /*  Handles OUT interrupts   */
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : CTR_LP.
 * Description    : Low priority Endpoint Correct Transfer interrupt's service
 *                  routine.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void CTR_LP(void)
+{
   __IO uint16_t wEPVal = 0;
   /* stay in loop while pending interrupts */
   while (((wIstr = _GetISTR()) & ISTR_CTR) != 0)
+  {
     /* extract highest priority endpoint number */
     EPindex = (uint8_t)(wIstr & ISTR_EP_ID);
     if (EPindex == 0)
+    {
       /* Decode and service control endpoint interrupt */
       /* calling related service routine */
       /* (Setup0_Process, In0_Process, Out0_Process) */
       /* save RX & TX status */
       /* and set both to NAK */
 	    SaveRState = _GetENDPOINT(ENDP0);
 	    SaveTState = SaveRState & EPTX_STAT;
 	    SaveRState &=  EPRX_STAT;
 	    _SetEPRxTxStatus(ENDP0,EP_RX_NAK,EP_TX_NAK);
       /* DIR bit = origin of the interrupt */
       if ((wIstr & ISTR_DIR) == 0)
+      {
         /* DIR = 0 */
         /* DIR = 0      => IN  int */
         /* DIR = 0 implies that (EP_CTR_TX = 1) always  */
         _ClearEP_CTR_TX(ENDP0);
         In0_Process();
            /* before terminate set Tx & Rx status */
             _SetEPRxTxStatus(ENDP0,SaveRState,SaveTState);
 		  return;
+      }
       else
+      {
         /* DIR = 1 */
         /* DIR = 1 & CTR_RX       => SETUP or OUT int */
         /* DIR = 1 & (CTR_TX | CTR_RX) => 2 int pending */
         wEPVal = _GetENDPOINT(ENDP0);
         if ((wEPVal &EP_SETUP) != 0)
+        {
           _ClearEP_CTR_RX(ENDP0); /* SETUP bit kept frozen while CTR_RX = 1 */
           Setup0_Process();
           /* before terminate set Tx & Rx status */
 		      _SetEPRxTxStatus(ENDP0,SaveRState,SaveTState);
           return;
+        }
         else if ((wEPVal & EP_CTR_RX) != 0)
+        {
           _ClearEP_CTR_RX(ENDP0);
           Out0_Process();
           /* before terminate set Tx & Rx status */
 		     _SetEPRxTxStatus(ENDP0,SaveRState,SaveTState);
           return;
+        }
+      }
     }/* if(EPindex == 0) */
     else
+    {
       /* Decode and service non control endpoints interrupt  */
       /* process related endpoint register */
       wEPVal = _GetENDPOINT(EPindex);
       if ((wEPVal & EP_CTR_RX) != 0)
+      {
         /* clear int flag */
         _ClearEP_CTR_RX(EPindex);
         /* call OUT service function */
         (*pEpInt_OUT[EPindex-1])();
       } /* if((wEPVal & EP_CTR_RX) */
       if ((wEPVal & EP_CTR_TX) != 0)
+      {
         /* clear int flag */
         _ClearEP_CTR_TX(EPindex);
         /* call IN service function */
         (*pEpInt_IN[EPindex-1])();
       } /* if((wEPVal & EP_CTR_TX) != 0) */
     }/* if(EPindex == 0) else */
   }/* while(...) */
+}
 /*******************************************************************************
 * Function Name  : CTR_HP.
 * Description    : High Priority Endpoint Correct Transfer interrupt's service
 *                  routine.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void CTR_HP(void)
+{
   uint32_t wEPVal = 0;
   while (((wIstr = _GetISTR()) & ISTR_CTR) != 0)
+  {
     _SetISTR((uint16_t)CLR_CTR); /* clear CTR flag */
     /* extract highest priority endpoint number */
     EPindex = (uint8_t)(wIstr & ISTR_EP_ID);
     /* process related endpoint register */
     wEPVal = _GetENDPOINT(EPindex);
     if ((wEPVal & EP_CTR_RX) != 0)
+    {
       /* clear int flag */
       _ClearEP_CTR_RX(EPindex);
       /* call OUT service function */
       (*pEpInt_OUT[EPindex-1])();
     } /* if((wEPVal & EP_CTR_RX) */
     else if ((wEPVal & EP_CTR_TX) != 0)
+    {
       /* clear int flag */
       _ClearEP_CTR_TX(EPindex);
       /* call IN service function */
       (*pEpInt_IN[EPindex-1])();
     } /* if((wEPVal & EP_CTR_TX) != 0) */
   }/* while(...) */
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_int.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_int.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Endpoint CTR (Low and High) interrupt's service routines prototypes
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 __USB_INT_H
 #define __USB_INT_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 void CTR_LP(void);
 void CTR_HP(void);
 /* External variables --------------------------------------------------------*/
 #endif /* __USB_INT_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_istr.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_istr.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   ISTR events interrupt service routines
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 "usb_lib.h"
 #include "usb_prop.h"
 #include "usb_pwr.h"
 #include "usb_istr.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 __IO uint16_t wIstr;  /* ISTR register last read value */
 __IO uint8_t bIntPackSOF = 0;  /* SOFs received between 2 consecutive packets */
 __IO uint32_t esof_counter =0; /* expected SOF counter */
 __IO uint32_t wCNTR=0;
 /* Extern variables ----------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /* function pointers to non-control endpoints service routines */
 void (*pEpInt_IN[7])(void) =
+  {
     EP1_IN_Callback,
     EP2_IN_Callback,
     EP3_IN_Callback,
     EP4_IN_Callback,
     EP5_IN_Callback,
     EP6_IN_Callback,
     EP7_IN_Callback,
   };
 void (*pEpInt_OUT[7])(void) =
+  {
     EP1_OUT_Callback,
     EP2_OUT_Callback,
     EP3_OUT_Callback,
     EP4_OUT_Callback,
     EP5_OUT_Callback,
     EP6_OUT_Callback,
     EP7_OUT_Callback,
   };
 /*******************************************************************************
 * Function Name  : USB_Istr
 * Description    : ISTR events interrupt service routine
 * Input          :
 * Output         :
 * Return         :
 *******************************************************************************/
 void USB_Istr(void)
+{
     uint32_t i=0;
  __IO uint32_t EP[8];
   wIstr = _GetISTR();
 #if (IMR_MSK & ISTR_SOF)
   if (wIstr & ISTR_SOF & wInterrupt_Mask)
+  {
     _SetISTR((uint16_t)CLR_SOF);
     bIntPackSOF++;
 #ifdef SOF_CALLBACK
     SOF_Callback();
 #endif
+  }
 #endif
   /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
 #if (IMR_MSK & ISTR_CTR)
   if (wIstr & ISTR_CTR & wInterrupt_Mask)
+  {
     /* servicing of the endpoint correct transfer interrupt */
     /* clear of the CTR flag into the sub */
     CTR_LP();
 #ifdef CTR_CALLBACK
     CTR_Callback();
 #endif
+  }
 #endif
   /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
 #if (IMR_MSK & ISTR_RESET)
   if (wIstr & ISTR_RESET & wInterrupt_Mask)
+  {
     _SetISTR((uint16_t)CLR_RESET);
     Device_Property.Reset();
 #ifdef RESET_CALLBACK
     RESET_Callback();
 #endif
+  }
 #endif
   /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
 #if (IMR_MSK & ISTR_DOVR)
   if (wIstr & ISTR_DOVR & wInterrupt_Mask)
+  {
     _SetISTR((uint16_t)CLR_DOVR);
 #ifdef DOVR_CALLBACK
     DOVR_Callback();
 #endif
+  }
 #endif
   /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
 #if (IMR_MSK & ISTR_ERR)
   if (wIstr & ISTR_ERR & wInterrupt_Mask)
+  {
     _SetISTR((uint16_t)CLR_ERR);
 #ifdef ERR_CALLBACK
     ERR_Callback();
 #endif
+  }
 #endif
   /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
 #if (IMR_MSK & ISTR_WKUP)
   if (wIstr & ISTR_WKUP & wInterrupt_Mask)
+  {
     _SetISTR((uint16_t)CLR_WKUP);
     Resume(RESUME_EXTERNAL);
 #ifdef WKUP_CALLBACK
     WKUP_Callback();
 #endif
+  }
 #endif
   /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
 #if (IMR_MSK & ISTR_SUSP)
   if (wIstr & ISTR_SUSP & wInterrupt_Mask)
+  {
     /* check if SUSPEND is possible */
     if (fSuspendEnabled)
+    {
       Suspend();
+    }
     else
+    {
       /* if not possible then resume after xx ms */
       Resume(RESUME_LATER);
+    }
     /* clear of the ISTR bit must be done after setting of CNTR_FSUSP */
     _SetISTR((uint16_t)CLR_SUSP);
 #ifdef SUSP_CALLBACK
     SUSP_Callback();
 #endif
+  }
 #endif
   /*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*/
 #if (IMR_MSK & ISTR_ESOF)
   if (wIstr & ISTR_ESOF & wInterrupt_Mask)
+  {
     /* clear ESOF flag in ISTR */
     _SetISTR((uint16_t)CLR_ESOF);
     if ((_GetFNR()&FNR_RXDP)!=0)
+    {
       /* increment ESOF counter */
       esof_counter ++;
       /* test if we enter in ESOF more than 3 times with FSUSP =0 and RXDP =1=>> possible missing SUSP flag*/
       if ((esof_counter >3)&&((_GetCNTR()&CNTR_FSUSP)==0))
+      {
         /* this a sequence to apply a force RESET*/
         /*Store CNTR value */
         wCNTR = _GetCNTR();
         /*Store endpoints registers status */
         for (i=0;i<8;i++) EP[i] = _GetENDPOINT(i);
         /*apply FRES */
         wCNTR|=CNTR_FRES;
         _SetCNTR(wCNTR);
         /*clear FRES*/
         wCNTR&=~CNTR_FRES;
         _SetCNTR(wCNTR);
         /*poll for RESET flag in ISTR*/
         while((_GetISTR()&ISTR_RESET) == 0);
         /* clear RESET flag in ISTR */
         _SetISTR((uint16_t)CLR_RESET);
        /*restore Enpoints*/
         for (i=0;i<8;i++)
         _SetENDPOINT(i, EP[i]);
         esof_counter = 0;
+      }
+    }
     else
+    {
         esof_counter = 0;
+    }
     /* resume handling timing is made with ESOFs */
     Resume(RESUME_ESOF); /* request without change of the machine state */
 #ifdef ESOF_CALLBACK
     ESOF_Callback();
 #endif
+  }
 #endif
 } /* USB_Istr */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_istr.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_istr.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   This file includes the peripherals header files in the user application.
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 __USB_ISTR_H
 #define __USB_ISTR_H
 /* Includes ------------------------------------------------------------------*/
 #include "usb_conf.h"
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
  void USB_Istr(void);
 /* function prototypes Automatically built defining related macros */
 void EP1_IN_Callback(void);
 void EP2_IN_Callback(void);
 void EP3_IN_Callback(void);
 void EP4_IN_Callback(void);
 void EP5_IN_Callback(void);
 void EP6_IN_Callback(void);
 void EP7_IN_Callback(void);
 void EP1_OUT_Callback(void);
 void EP2_OUT_Callback(void);
 void EP3_OUT_Callback(void);
 void EP4_OUT_Callback(void);
 void EP5_OUT_Callback(void);
 void EP6_OUT_Callback(void);
 void EP7_OUT_Callback(void);
 #ifdef CTR_CALLBACK
 void CTR_Callback(void);
 #endif
 #ifdef DOVR_CALLBACK
 void DOVR_Callback(void);
 #endif
 #ifdef ERR_CALLBACK
 void ERR_Callback(void);
 #endif
 #ifdef WKUP_CALLBACK
 void WKUP_Callback(void);
 #endif
 #ifdef SUSP_CALLBACK
 void SUSP_Callback(void);
 #endif
 #ifdef RESET_CALLBACK
 void RESET_Callback(void);
 #endif
 #ifdef SOF_CALLBACK
 void SOF_Callback(void);
 #endif
 #ifdef ESOF_CALLBACK
 void ESOF_Callback(void);
 #endif
 #endif /*__USB_ISTR_H*/
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_lib.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_lib.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   USB library include files
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 __USB_LIB_H
 #define __USB_LIB_H
 /* Includes ------------------------------------------------------------------*/
 #include "hw_config.h"
 #include "usb_type.h"
 #include "usb_regs.h"
 #include "usb_def.h"
 #include "usb_core.h"
 #include "usb_init.h"
 #include "usb_sil.h"
 #include "usb_mem.h"
 #include "usb_int.h"
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 /* External variables --------------------------------------------------------*/
 #endif /* __USB_LIB_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_mem.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_mem.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Utility functions for memory transfers to/from PMA
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 "usb_lib.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /* Extern variables ----------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : UserToPMABufferCopy
 * Description    : Copy a buffer from user memory area to packet memory area (PMA)
 * Input          : - pbUsrBuf: pointer to user memory area.
 *                  - wPMABufAddr: address into PMA.
 *                  - wNBytes: no. of bytes to be copied.
 * Output         : None.
 * Return         : None	.
 *******************************************************************************/
 void UserToPMABufferCopy(uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
+{
   uint32_t n = (wNBytes + 1) >> 1;   /* n = (wNBytes + 1) / 2 */
   uint32_t i, temp1, temp2;
   uint16_t *pdwVal;
   pdwVal = (uint16_t *)(wPMABufAddr * 2 + PMAAddr);
   for (i = n; i != 0; i--)
+  {
     temp1 = (uint16_t) * pbUsrBuf;
     pbUsrBuf++;
     temp2 = temp1 | (uint16_t) * pbUsrBuf << 8;
     *pdwVal++ = temp2;
     pdwVal++;
     pbUsrBuf++;
+  }
+}
 /*******************************************************************************
 * Function Name  : PMAToUserBufferCopy
 * Description    : Copy a buffer from user memory area to packet memory area (PMA)
 * Input          : - pbUsrBuf    = pointer to user memory area.
 *                  - wPMABufAddr = address into PMA.
 *                  - wNBytes     = no. of bytes to be copied.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void PMAToUserBufferCopy(uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
+{
   uint32_t n = (wNBytes + 1) >> 1;/* /2*/
   uint32_t i;
   uint32_t *pdwVal;
   pdwVal = (uint32_t *)(wPMABufAddr * 2 + PMAAddr);
   for (i = n; i != 0; i--)
+  {
     *(uint16_t*)pbUsrBuf++ = *pdwVal++;
     pbUsrBuf++;
+  }
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_mem.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_mem.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Utility prototypes functions for memory/PMA transfers
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 __USB_MEM_H
 #define __USB_MEM_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 void UserToPMABufferCopy(uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes);
 void PMAToUserBufferCopy(uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes);
 /* External variables --------------------------------------------------------*/
 #endif  /*__USB_MEM_H*/
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_prop.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_prop.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   All processing related to Virtual Com Port Demo
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 "usb_lib.h"
 #include "usb_conf.h"
 #include "usb_prop.h"
 #include "usb_desc.h"
 #include "usb_pwr.h"
 #include "hw_config.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 uint8_t Request = 0;
 LINE_CODING linecoding =
+  {
 , /* baud rate*/
 x00,   /* stop bits-1*/
 x00,   /* parity - none*/
 x08    /* no. of bits 8*/
   };
 /* -------------------------------------------------------------------------- */
 /*  Structures initializations */
 /* -------------------------------------------------------------------------- */
 DEVICE Device_Table =
+  {
     EP_NUM,
   };
 DEVICE_PROP Device_Property =
+  {
     Virtual_Com_Port_init,
     Virtual_Com_Port_Reset,
     Virtual_Com_Port_Status_In,
     Virtual_Com_Port_Status_Out,
     Virtual_Com_Port_Data_Setup,
     Virtual_Com_Port_NoData_Setup,
     Virtual_Com_Port_Get_Interface_Setting,
     Virtual_Com_Port_GetDeviceDescriptor,
     Virtual_Com_Port_GetConfigDescriptor,
     Virtual_Com_Port_GetStringDescriptor,
 ,
 x40 /*MAX PACKET SIZE*/
   };
 USER_STANDARD_REQUESTS User_Standard_Requests =
+  {
     Virtual_Com_Port_GetConfiguration,
     Virtual_Com_Port_SetConfiguration,
     Virtual_Com_Port_GetInterface,
     Virtual_Com_Port_SetInterface,
     Virtual_Com_Port_GetStatus,
     Virtual_Com_Port_ClearFeature,
     Virtual_Com_Port_SetEndPointFeature,
     Virtual_Com_Port_SetDeviceFeature,
     Virtual_Com_Port_SetDeviceAddress
   };
 ONE_DESCRIPTOR Device_Descriptor =
+  {
     (uint8_t*)Virtual_Com_Port_DeviceDescriptor,
     VIRTUAL_COM_PORT_SIZ_DEVICE_DESC
   };
 ONE_DESCRIPTOR Config_Descriptor =
+  {
     (uint8_t*)Virtual_Com_Port_ConfigDescriptor,
     VIRTUAL_COM_PORT_SIZ_CONFIG_DESC
   };
 ONE_DESCRIPTOR String_Descriptor[4] =
+  {
     {(uint8_t*)Virtual_Com_Port_StringLangID, VIRTUAL_COM_PORT_SIZ_STRING_LANGID},
     {(uint8_t*)Virtual_Com_Port_StringVendor, VIRTUAL_COM_PORT_SIZ_STRING_VENDOR},
     {(uint8_t*)Virtual_Com_Port_StringProduct, VIRTUAL_COM_PORT_SIZ_STRING_PRODUCT},
     {(uint8_t*)Virtual_Com_Port_StringSerial, VIRTUAL_COM_PORT_SIZ_STRING_SERIAL}
   };
 /* Extern variables ----------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /* Extern function prototypes ------------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_init.
 * Description    : Virtual COM Port Mouse init routine.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Virtual_Com_Port_init(void)
+{
   /* Update the serial number string descriptor with the data from the unique
   ID*/
   Get_SerialNum();
   pInformation->Current_Configuration = 0;
   /* Connect the device */
   PowerOn();
   /* Perform basic device initialization operations */
   USB_SIL_Init();
   bDeviceState = UNCONNECTED;
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_Reset
 * Description    : Virtual_Com_Port Mouse reset routine
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Virtual_Com_Port_Reset(void)
+{
   /* Set Virtual_Com_Port DEVICE as not configured */
   pInformation->Current_Configuration = 0;
   /* Current Feature initialization */
   pInformation->Current_Feature = Virtual_Com_Port_ConfigDescriptor[7];
   /* Set Virtual_Com_Port DEVICE with the default Interface*/
   pInformation->Current_Interface = 0;
   SetBTABLE(BTABLE_ADDRESS);
   /* Initialize Endpoint 0 */
   SetEPType(ENDP0, EP_CONTROL);
   SetEPTxStatus(ENDP0, EP_TX_STALL);
   SetEPRxAddr(ENDP0, ENDP0_RXADDR);
   SetEPTxAddr(ENDP0, ENDP0_TXADDR);
   Clear_Status_Out(ENDP0);
   SetEPRxCount(ENDP0, Device_Property.MaxPacketSize);
   SetEPRxValid(ENDP0);
   /* Initialize Endpoint 1 */
   SetEPType(ENDP1, EP_BULK);
   SetEPTxAddr(ENDP1, ENDP1_TXADDR);
   SetEPTxStatus(ENDP1, EP_TX_NAK);
   SetEPRxStatus(ENDP1, EP_RX_DIS);
   /* Initialize Endpoint 2 */
   SetEPType(ENDP2, EP_INTERRUPT);
   SetEPTxAddr(ENDP2, ENDP2_TXADDR);
   SetEPRxStatus(ENDP2, EP_RX_DIS);
   SetEPTxStatus(ENDP2, EP_TX_NAK);
   /* Initialize Endpoint 3 */
   SetEPType(ENDP3, EP_BULK);
   SetEPRxAddr(ENDP3, ENDP3_RXADDR);
   SetEPRxCount(ENDP3, VIRTUAL_COM_PORT_DATA_SIZE);
   SetEPRxStatus(ENDP3, EP_RX_VALID);
   SetEPTxStatus(ENDP3, EP_TX_DIS);
   /* Set this device to response on default address */
   SetDeviceAddress(0);
   bDeviceState = ATTACHED;
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_SetConfiguration.
 * Description    : Update the device state to configured.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Virtual_Com_Port_SetConfiguration(void)
+{
   DEVICE_INFO *pInfo = &Device_Info;
   if (pInfo->Current_Configuration != 0)
+  {
     /* Device configured */
     bDeviceState = CONFIGURED;
+  }
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_SetConfiguration.
 * Description    : Update the device state to addressed.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Virtual_Com_Port_SetDeviceAddress (void)
+{
   bDeviceState = ADDRESSED;
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_Status_In.
 * Description    : Virtual COM Port Status In Routine.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Virtual_Com_Port_Status_In(void)
+{
   if (Request == SET_LINE_CODING)
+  {
     Request = 0;
+  }
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_Status_Out
 * Description    : Virtual COM Port Status OUT Routine.
 * Input          : None.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Virtual_Com_Port_Status_Out(void)
 {}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_Data_Setup
 * Description    : handle the data class specific requests
 * Input          : Request Nb.
 * Output         : None.
 * Return         : USB_UNSUPPORT or USB_SUCCESS.
 *******************************************************************************/
 RESULT Virtual_Com_Port_Data_Setup(uint8_t RequestNo)
+{
   uint8_t    *(*CopyRoutine)(uint16_t);
   CopyRoutine = NULL;
   if (RequestNo == GET_LINE_CODING)
+  {
     if (Type_Recipient == (CLASS_REQUEST | INTERFACE_RECIPIENT))
+    {
       CopyRoutine = Virtual_Com_Port_GetLineCoding;
+    }
+  }
   else if (RequestNo == SET_LINE_CODING)
+  {
     if (Type_Recipient == (CLASS_REQUEST | INTERFACE_RECIPIENT))
+    {
       CopyRoutine = Virtual_Com_Port_SetLineCoding;
+    }
     Request = SET_LINE_CODING;
+  }
   if (CopyRoutine == NULL)
+  {
     return USB_UNSUPPORT;
+  }
   pInformation->Ctrl_Info.CopyData = CopyRoutine;
   pInformation->Ctrl_Info.Usb_wOffset = 0;
   (*CopyRoutine)(0);
   return USB_SUCCESS;
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_NoData_Setup.
 * Description    : handle the no data class specific requests.
 * Input          : Request Nb.
 * Output         : None.
 * Return         : USB_UNSUPPORT or USB_SUCCESS.
 *******************************************************************************/
 RESULT Virtual_Com_Port_NoData_Setup(uint8_t RequestNo)
+{
   if (Type_Recipient == (CLASS_REQUEST | INTERFACE_RECIPIENT))
+  {
     if (RequestNo == SET_COMM_FEATURE)
+    {
       return USB_SUCCESS;
+    }
     else if (RequestNo == SET_CONTROL_LINE_STATE)
+    {
       return USB_SUCCESS;
+    }
+  }
   return USB_UNSUPPORT;
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_GetDeviceDescriptor.
 * Description    : Gets the device descriptor.
 * Input          : Length.
 * Output         : None.
 * Return         : The address of the device descriptor.
 *******************************************************************************/
 uint8_t *Virtual_Com_Port_GetDeviceDescriptor(uint16_t Length)
+{
   return Standard_GetDescriptorData(Length, &Device_Descriptor);
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_GetConfigDescriptor.
 * Description    : get the configuration descriptor.
 * Input          : Length.
 * Output         : None.
 * Return         : The address of the configuration descriptor.
 *******************************************************************************/
 uint8_t *Virtual_Com_Port_GetConfigDescriptor(uint16_t Length)
+{
   return Standard_GetDescriptorData(Length, &Config_Descriptor);
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_GetStringDescriptor
 * Description    : Gets the string descriptors according to the needed index
 * Input          : Length.
 * Output         : None.
 * Return         : The address of the string descriptors.
 *******************************************************************************/
 uint8_t *Virtual_Com_Port_GetStringDescriptor(uint16_t Length)
+{
   uint8_t wValue0 = pInformation->USBwValue0;
   if (wValue0 > 4)
+  {
     return NULL;
+  }
   else
+  {
     return Standard_GetDescriptorData(Length, &String_Descriptor[wValue0]);
+  }
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_Get_Interface_Setting.
 * Description    : test the interface and the alternate setting according to the
 *                  supported one.
 * Input1         : uint8_t: Interface : interface number.
 * Input2         : uint8_t: AlternateSetting : Alternate Setting number.
 * Output         : None.
 * Return         : The address of the string descriptors.
 *******************************************************************************/
 RESULT Virtual_Com_Port_Get_Interface_Setting(uint8_t Interface, uint8_t AlternateSetting)
+{
   if (AlternateSetting > 0)
+  {
     return USB_UNSUPPORT;
+  }
   else if (Interface > 1)
+  {
     return USB_UNSUPPORT;
+  }
   return USB_SUCCESS;
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_GetLineCoding.
 * Description    : send the linecoding structure to the PC host.
 * Input          : Length.
 * Output         : None.
 * Return         : Linecoding structure base address.
 *******************************************************************************/
 uint8_t *Virtual_Com_Port_GetLineCoding(uint16_t Length)
+{
   if (Length == 0)
+  {
     pInformation->Ctrl_Info.Usb_wLength = sizeof(linecoding);
     return NULL;
+  }
   return(uint8_t *)&linecoding;
+}
 /*******************************************************************************
 * Function Name  : Virtual_Com_Port_SetLineCoding.
 * Description    : Set the linecoding structure fields.
 * Input          : Length.
 * Output         : None.
 * Return         : Linecoding structure base address.
 *******************************************************************************/
 uint8_t *Virtual_Com_Port_SetLineCoding(uint16_t Length)
+{
   if (Length == 0)
+  {
     pInformation->Ctrl_Info.Usb_wLength = sizeof(linecoding);
     return NULL;
+  }
   return(uint8_t *)&linecoding;
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_prop.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_prop.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   All processing related to Virtual COM Port Demo (Endpoint 0)
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 __usb_prop_H
 #define __usb_prop_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 typedef struct
+{
   uint32_t bitrate;
   uint8_t format;
   uint8_t paritytype;
   uint8_t datatype;
 }LINE_CODING;
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported define -----------------------------------------------------------*/
 #define Virtual_Com_Port_GetConfiguration          NOP_Process
 //#define Virtual_Com_Port_SetConfiguration          NOP_Process
 #define Virtual_Com_Port_GetInterface              NOP_Process
 #define Virtual_Com_Port_SetInterface              NOP_Process
 #define Virtual_Com_Port_GetStatus                 NOP_Process
 #define Virtual_Com_Port_ClearFeature              NOP_Process
 #define Virtual_Com_Port_SetEndPointFeature        NOP_Process
 #define Virtual_Com_Port_SetDeviceFeature          NOP_Process
 //#define Virtual_Com_Port_SetDeviceAddress          NOP_Process
 #define SEND_ENCAPSULATED_COMMAND   0x00
 #define GET_ENCAPSULATED_RESPONSE   0x01
 #define SET_COMM_FEATURE            0x02
 #define GET_COMM_FEATURE            0x03
 #define CLEAR_COMM_FEATURE          0x04
 #define SET_LINE_CODING             0x20
 #define GET_LINE_CODING             0x21
 #define SET_CONTROL_LINE_STATE      0x22
 #define SEND_BREAK                  0x23
 /* Exported functions ------------------------------------------------------- */
 void Virtual_Com_Port_init(void);
 void Virtual_Com_Port_Reset(void);
 void Virtual_Com_Port_SetConfiguration(void);
 void Virtual_Com_Port_SetDeviceAddress (void);
 void Virtual_Com_Port_Status_In (void);
 void Virtual_Com_Port_Status_Out (void);
 RESULT Virtual_Com_Port_Data_Setup(uint8_t);
 RESULT Virtual_Com_Port_NoData_Setup(uint8_t);
 RESULT Virtual_Com_Port_Get_Interface_Setting(uint8_t Interface, uint8_t AlternateSetting);
 uint8_t *Virtual_Com_Port_GetDeviceDescriptor(uint16_t );
 uint8_t *Virtual_Com_Port_GetConfigDescriptor(uint16_t);
 uint8_t *Virtual_Com_Port_GetStringDescriptor(uint16_t);
 uint8_t *Virtual_Com_Port_GetLineCoding(uint16_t Length);
 uint8_t *Virtual_Com_Port_SetLineCoding(uint16_t Length);
 #endif /* __usb_prop_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_pwr.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_pwr.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   Connection/disconnection & power management
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 "usb_lib.h"
 #include "usb_conf.h"
 #include "usb_pwr.h"
 #include "hw_config.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 __IO uint32_t bDeviceState = UNCONNECTED; /* USB device status */
 __IO bool fSuspendEnabled = TRUE;  /* true when suspend is possible */
 __IO uint32_t EP[8];
 struct
+{
   __IO RESUME_STATE eState;
   __IO uint8_t bESOFcnt;
+}
 ResumeS;
 __IO uint32_t remotewakeupon=0;
 /* Extern variables ----------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /* Extern function prototypes ------------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : PowerOn
 * Description    :
 * Input          : None.
 * Output         : None.
 * Return         : USB_SUCCESS.
 *******************************************************************************/
 RESULT PowerOn(void)
+{
   uint16_t wRegVal;
   /*** cable plugged-in ? ***/
   USB_Cable_Config(ENABLE);
   /*** CNTR_PWDN = 0 ***/
   wRegVal = CNTR_FRES;
   _SetCNTR(wRegVal);
   /*** CNTR_FRES = 0 ***/
   wInterrupt_Mask = 0;
   _SetCNTR(wInterrupt_Mask);
   /*** Clear pending interrupts ***/
   _SetISTR(0);
   /*** Set interrupt mask ***/
   wInterrupt_Mask = CNTR_RESETM | CNTR_SUSPM | CNTR_WKUPM;
   _SetCNTR(wInterrupt_Mask);
   return USB_SUCCESS;
+}
 /*******************************************************************************
 * Function Name  : PowerOff
 * Description    : handles switch-off conditions
 * Input          : None.
 * Output         : None.
 * Return         : USB_SUCCESS.
 *******************************************************************************/
 RESULT PowerOff()
+{
   /* disable all interrupts and force USB reset */
   _SetCNTR(CNTR_FRES);
   /* clear interrupt status register */
   _SetISTR(0);
   /* Disable the Pull-Up*/
   USB_Cable_Config(DISABLE);
   /* switch-off device */
   _SetCNTR(CNTR_FRES + CNTR_PDWN);
   /* sw variables reset */
   /* ... */
   return USB_SUCCESS;
+}
 /*******************************************************************************
 * Function Name  : Suspend
 * Description    : sets suspend mode operating conditions
 * Input          : None.
 * Output         : None.
 * Return         : USB_SUCCESS.
 *******************************************************************************/
 void Suspend(void)
+{
 	uint32_t i =0;
 	uint16_t wCNTR;
 	uint32_t tmpreg = 0;
   __IO uint32_t savePWR_CR=0;
 	/* suspend preparation */
 	/* ... */
 	/*Store CNTR value */
 	wCNTR = _GetCNTR();
     /* This a sequence to apply a force RESET to handle a robustness case */
 	/*Store endpoints registers status */
     for (i=0;i<8;i++) EP[i] = _GetENDPOINT(i);
 	/* unmask RESET flag */
 	wCNTR|=CNTR_RESETM;
 	_SetCNTR(wCNTR);
 	/*apply FRES */
 	wCNTR|=CNTR_FRES;
 	_SetCNTR(wCNTR);
 	/*clear FRES*/
 	wCNTR&=~CNTR_FRES;
 	_SetCNTR(wCNTR);
 	/*poll for RESET flag in ISTR*/
 	while((_GetISTR()&ISTR_RESET) == 0);
 	/* clear RESET flag in ISTR */
 	_SetISTR((uint16_t)CLR_RESET);
 	/*restore Enpoints*/
 	for (i=0;i<8;i++)
 	_SetENDPOINT(i, EP[i]);
 	/* Now it is safe to enter macrocell in suspend mode */
 	wCNTR |= CNTR_FSUSP;
 	_SetCNTR(wCNTR);
 	/* force low-power mode in the macrocell */
 	wCNTR = _GetCNTR();
 	wCNTR |= CNTR_LPMODE;
 	_SetCNTR(wCNTR);
 	/*prepare entry in low power mode (STOP mode)*/
 	/* Select the regulator state in STOP mode*/
 	savePWR_CR = PWR->CR;
 	tmpreg = PWR->CR;
 	/* Clear PDDS and LPDS bits */
 	tmpreg &= ((uint32_t)0xFFFFFFFC);
 	/* Set LPDS bit according to PWR_Regulator value */
 	tmpreg |= PWR_Regulator_LowPower;
 	/* Store the new value */
 	PWR->CR = tmpreg;
 	/* Set SLEEPDEEP bit of Cortex System Control Register */
 #if defined (STM32F30X) || defined (STM32F37X)
         SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
 #else
         SCB->SCR |= SCB_SCR_SLEEPDEEP;
 #endif
 	/* enter system in STOP mode, only when wakeup flag in not set */
 	if((_GetISTR()&ISTR_WKUP)==0)
+	{
 		__WFI();
 		/* Reset SLEEPDEEP bit of Cortex System Control Register */
 #if defined (STM32F30X) || defined (STM32F37X)
                 SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk);
 #else
                 SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP);
 #endif
+	}
 	else
+	{
 		/* Clear Wakeup flag */
 		_SetISTR(CLR_WKUP);
 		/* clear FSUSP to abort entry in suspend mode  */
         wCNTR = _GetCNTR();
         wCNTR&=~CNTR_FSUSP;
         _SetCNTR(wCNTR);
 		/*restore sleep mode configuration */
 		/* restore Power regulator config in sleep mode*/
 		PWR->CR = savePWR_CR;
 		/* Reset SLEEPDEEP bit of Cortex System Control Register */
 #if defined (STM32F30X) || defined (STM32F37X)
                 SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP_Msk);
 #else
                 SCB->SCR &= (uint32_t)~((uint32_t)SCB_SCR_SLEEPDEEP);
 #endif
+    }
+}
 /*******************************************************************************
 * Function Name  : Resume_Init
 * Description    : Handles wake-up restoring normal operations
 * Input          : None.
 * Output         : None.
 * Return         : USB_SUCCESS.
 *******************************************************************************/
 void Resume_Init(void)
+{
   uint16_t wCNTR;
   /* ------------------ ONLY WITH BUS-POWERED DEVICES ---------------------- */
   /* restart the clocks */
   /* ...  */
   /* CNTR_LPMODE = 0 */
   wCNTR = _GetCNTR();
   wCNTR &= (~CNTR_LPMODE);
   _SetCNTR(wCNTR);
   /* restore full power */
   /* ... on connected devices */
   Leave_LowPowerMode();
   /* reset FSUSP bit */
   _SetCNTR(IMR_MSK);
   /* reverse suspend preparation */
   /* ... */
+}
 /*******************************************************************************
 * Function Name  : Resume
 * Description    : This is the state machine handling resume operations and
 *                 timing sequence. The control is based on the Resume structure
 *                 variables and on the ESOF interrupt calling this subroutine
 *                 without changing machine state.
 * Input          : a state machine value (RESUME_STATE)
 *                  RESUME_ESOF doesn't change ResumeS.eState allowing
 *                  decrementing of the ESOF counter in different states.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Resume(RESUME_STATE eResumeSetVal)
+{
   uint16_t wCNTR;
   if (eResumeSetVal != RESUME_ESOF)
     ResumeS.eState = eResumeSetVal;
   switch (ResumeS.eState)
+  {
     case RESUME_EXTERNAL:
       if (remotewakeupon ==0)
+      {
         Resume_Init();
         ResumeS.eState = RESUME_OFF;
+      }
       else /* RESUME detected during the RemoteWAkeup signalling => keep RemoteWakeup handling*/
+      {
         ResumeS.eState = RESUME_ON;
+      }
       break;
     case RESUME_INTERNAL:
       Resume_Init();
       ResumeS.eState = RESUME_START;
       remotewakeupon = 1;
       break;
     case RESUME_LATER:
       ResumeS.bESOFcnt = 2;
       ResumeS.eState = RESUME_WAIT;
       break;
     case RESUME_WAIT:
       ResumeS.bESOFcnt--;
       if (ResumeS.bESOFcnt == 0)
         ResumeS.eState = RESUME_START;
       break;
     case RESUME_START:
       wCNTR = _GetCNTR();
       wCNTR |= CNTR_RESUME;
       _SetCNTR(wCNTR);
       ResumeS.eState = RESUME_ON;
       ResumeS.bESOFcnt = 10;
       break;
     case RESUME_ON:
       ResumeS.bESOFcnt--;
       if (ResumeS.bESOFcnt == 0)
+      {
         wCNTR = _GetCNTR();
         wCNTR &= (~CNTR_RESUME);
         _SetCNTR(wCNTR);
         ResumeS.eState = RESUME_OFF;
         remotewakeupon = 0;
+      }
       break;
     case RESUME_OFF:
     case RESUME_ESOF:
     default:
       ResumeS.eState = RESUME_OFF;
       break;
+  }
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_pwr.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_pwr.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    21-January-2013
   * @brief   Connection/disconnection & power management header
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2013 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 __USB_PWR_H
 #define __USB_PWR_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 typedef enum _RESUME_STATE
+{
   RESUME_EXTERNAL,
   RESUME_INTERNAL,
   RESUME_LATER,
   RESUME_WAIT,
   RESUME_START,
   RESUME_ON,
   RESUME_OFF,
   RESUME_ESOF
 } RESUME_STATE;
 typedef enum _DEVICE_STATE
+{
   UNCONNECTED,
   ATTACHED,
   POWERED,
   SUSPENDED,
   ADDRESSED,
   CONFIGURED
 } DEVICE_STATE;
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 void Suspend(void);
 void Resume_Init(void);
 void Resume(RESUME_STATE eResumeSetVal);
 RESULT PowerOn(void);
 RESULT PowerOff(void);
 /* External variables --------------------------------------------------------*/
 extern  __IO uint32_t bDeviceState; /* USB device status */
 extern __IO bool fSuspendEnabled;  /* true when suspend is possible */
 #endif  /*__USB_PWR_H*/
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_regs.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_regs.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Interface functions to USB cell registers
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 "usb_lib.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /* Extern variables ----------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : SetCNTR.
 * Description    : Set the CNTR register value.
 * Input          : wRegValue: new register value.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetCNTR(uint16_t wRegValue)
+{
   _SetCNTR(wRegValue);
+}
 /*******************************************************************************
 * Function Name  : GetCNTR.
 * Description    : returns the CNTR register value.
 * Input          : None.
 * Output         : None.
 * Return         : CNTR register Value.
 *******************************************************************************/
 uint16_t GetCNTR(void)
+{
   return(_GetCNTR());
+}
 /*******************************************************************************
 * Function Name  : SetISTR.
 * Description    : Set the ISTR register value.
 * Input          : wRegValue: new register value.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetISTR(uint16_t wRegValue)
+{
   _SetISTR(wRegValue);
+}
 /*******************************************************************************
 * Function Name  : GetISTR
 * Description    : Returns the ISTR register value.
 * Input          : None.
 * Output         : None.
 * Return         : ISTR register Value
 *******************************************************************************/
 uint16_t GetISTR(void)
+{
   return(_GetISTR());
+}
 /*******************************************************************************
 * Function Name  : GetFNR
 * Description    : Returns the FNR register value.
 * Input          : None.
 * Output         : None.
 * Return         : FNR register Value
 *******************************************************************************/
 uint16_t GetFNR(void)
+{
   return(_GetFNR());
+}
 /*******************************************************************************
 * Function Name  : SetDADDR
 * Description    : Set the DADDR register value.
 * Input          : wRegValue: new register value.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetDADDR(uint16_t wRegValue)
+{
   _SetDADDR(wRegValue);
+}
 /*******************************************************************************
 * Function Name  : GetDADDR
 * Description    : Returns the DADDR register value.
 * Input          : None.
 * Output         : None.
 * Return         : DADDR register Value
 *******************************************************************************/
 uint16_t GetDADDR(void)
+{
   return(_GetDADDR());
+}
 /*******************************************************************************
 * Function Name  : SetBTABLE
 * Description    : Set the BTABLE.
 * Input          : wRegValue: New register value.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetBTABLE(uint16_t wRegValue)
+{
   _SetBTABLE(wRegValue);
+}
 /*******************************************************************************
 * Function Name  : GetBTABLE.
 * Description    : Returns the BTABLE register value.
 * Input          : None.
 * Output         : None.
 * Return         : BTABLE address.
 *******************************************************************************/
 uint16_t GetBTABLE(void)
+{
   return(_GetBTABLE());
+}
 /*******************************************************************************
 * Function Name  : SetENDPOINT
 * Description    : Set the Endpoint register value.
 * Input          : bEpNum: Endpoint Number.
 *                  wRegValue.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetENDPOINT(uint8_t bEpNum, uint16_t wRegValue)
+{
   _SetENDPOINT(bEpNum, wRegValue);
+}
 /*******************************************************************************
 * Function Name  : GetENDPOINT
 * Description    : Return the Endpoint register value.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Endpoint register value.
 *******************************************************************************/
 uint16_t GetENDPOINT(uint8_t bEpNum)
+{
   return(_GetENDPOINT(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : SetEPType
 * Description    : sets the type in the endpoint register.
 * Input          : bEpNum: Endpoint Number.
 *                  wType: type definition.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPType(uint8_t bEpNum, uint16_t wType)
+{
   _SetEPType(bEpNum, wType);
+}
 /*******************************************************************************
 * Function Name  : GetEPType
 * Description    : Returns the endpoint type.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Endpoint Type
 *******************************************************************************/
 uint16_t GetEPType(uint8_t bEpNum)
+{
   return(_GetEPType(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : SetEPTxStatus
 * Description    : Set the status of Tx endpoint.
 * Input          : bEpNum: Endpoint Number.
 *                  wState: new state.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPTxStatus(uint8_t bEpNum, uint16_t wState)
+{
   _SetEPTxStatus(bEpNum, wState);
+}
 /*******************************************************************************
 * Function Name  : SetEPRxStatus
 * Description    : Set the status of Rx endpoint.
 * Input          : bEpNum: Endpoint Number.
 *                  wState: new state.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPRxStatus(uint8_t bEpNum, uint16_t wState)
+{
   _SetEPRxStatus(bEpNum, wState);
+}
 /*******************************************************************************
 * Function Name  : SetDouBleBuffEPStall
 * Description    : sets the status for Double Buffer Endpoint to STALL
 * Input          : bEpNum: Endpoint Number.
 *                  bDir: Endpoint direction.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetDouBleBuffEPStall(uint8_t bEpNum, uint8_t bDir)
+{
   uint16_t Endpoint_DTOG_Status;
   Endpoint_DTOG_Status = GetENDPOINT(bEpNum);
   if (bDir == EP_DBUF_OUT)
   { /* OUT double buffered endpoint */
     _SetENDPOINT(bEpNum, Endpoint_DTOG_Status & ~EPRX_DTOG1);
+  }
   else if (bDir == EP_DBUF_IN)
   { /* IN double buffered endpoint */
     _SetENDPOINT(bEpNum, Endpoint_DTOG_Status & ~EPTX_DTOG1);
+  }
+}
 /*******************************************************************************
 * Function Name  : GetEPTxStatus
 * Description    : Returns the endpoint Tx status.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Endpoint TX Status
 *******************************************************************************/
 uint16_t GetEPTxStatus(uint8_t bEpNum)
+{
   return(_GetEPTxStatus(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : GetEPRxStatus
 * Description    : Returns the endpoint Rx status.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Endpoint RX Status
 *******************************************************************************/
 uint16_t GetEPRxStatus(uint8_t bEpNum)
+{
   return(_GetEPRxStatus(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : SetEPTxValid
 * Description    : Valid the endpoint Tx Status.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPTxValid(uint8_t bEpNum)
+{
   _SetEPTxStatus(bEpNum, EP_TX_VALID);
+}
 /*******************************************************************************
 * Function Name  : SetEPRxValid
 * Description    : Valid the endpoint Rx Status.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPRxValid(uint8_t bEpNum)
+{
   _SetEPRxStatus(bEpNum, EP_RX_VALID);
+}
 /*******************************************************************************
 * Function Name  : SetEP_KIND
 * Description    : Clear the EP_KIND bit.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEP_KIND(uint8_t bEpNum)
+{
   _SetEP_KIND(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : ClearEP_KIND
 * Description    : set the  EP_KIND bit.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void ClearEP_KIND(uint8_t bEpNum)
+{
   _ClearEP_KIND(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : Clear_Status_Out
 * Description    : Clear the Status Out of the related Endpoint
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Clear_Status_Out(uint8_t bEpNum)
+{
   _ClearEP_KIND(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : Set_Status_Out
 * Description    : Set the Status Out of the related Endpoint
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void Set_Status_Out(uint8_t bEpNum)
+{
   _SetEP_KIND(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : SetEPDoubleBuff
 * Description    : Enable the double buffer feature for the endpoint.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPDoubleBuff(uint8_t bEpNum)
+{
   _SetEP_KIND(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : ClearEPDoubleBuff
 * Description    : Disable the double buffer feature for the endpoint.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void ClearEPDoubleBuff(uint8_t bEpNum)
+{
   _ClearEP_KIND(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : GetTxStallStatus
 * Description    : Returns the Stall status of the Tx endpoint.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Tx Stall status.
 *******************************************************************************/
 uint16_t GetTxStallStatus(uint8_t bEpNum)
+{
   return(_GetTxStallStatus(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : GetRxStallStatus
 * Description    : Returns the Stall status of the Rx endpoint.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Rx Stall status.
 *******************************************************************************/
 uint16_t GetRxStallStatus(uint8_t bEpNum)
+{
   return(_GetRxStallStatus(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : ClearEP_CTR_RX
 * Description    : Clear the CTR_RX bit.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void ClearEP_CTR_RX(uint8_t bEpNum)
+{
   _ClearEP_CTR_RX(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : ClearEP_CTR_TX
 * Description    : Clear the CTR_TX bit.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void ClearEP_CTR_TX(uint8_t bEpNum)
+{
   _ClearEP_CTR_TX(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : ToggleDTOG_RX
 * Description    : Toggle the DTOG_RX bit.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void ToggleDTOG_RX(uint8_t bEpNum)
+{
   _ToggleDTOG_RX(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : ToggleDTOG_TX
 * Description    : Toggle the DTOG_TX bit.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void ToggleDTOG_TX(uint8_t bEpNum)
+{
   _ToggleDTOG_TX(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : ClearDTOG_RX.
 * Description    : Clear the DTOG_RX bit.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void ClearDTOG_RX(uint8_t bEpNum)
+{
   _ClearDTOG_RX(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : ClearDTOG_TX.
 * Description    : Clear the DTOG_TX bit.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void ClearDTOG_TX(uint8_t bEpNum)
+{
   _ClearDTOG_TX(bEpNum);
+}
 /*******************************************************************************
 * Function Name  : SetEPAddress
 * Description    : Set the endpoint address.
 * Input          : bEpNum: Endpoint Number.
 *                  bAddr: New endpoint address.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPAddress(uint8_t bEpNum, uint8_t bAddr)
+{
   _SetEPAddress(bEpNum, bAddr);
+}
 /*******************************************************************************
 * Function Name  : GetEPAddress
 * Description    : Get the endpoint address.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Endpoint address.
 *******************************************************************************/
 uint8_t GetEPAddress(uint8_t bEpNum)
+{
   return(_GetEPAddress(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : SetEPTxAddr
 * Description    : Set the endpoint Tx buffer address.
 * Input          : bEpNum: Endpoint Number.
 *                  wAddr: new address.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPTxAddr(uint8_t bEpNum, uint16_t wAddr)
+{
   _SetEPTxAddr(bEpNum, wAddr);
+}
 /*******************************************************************************
 * Function Name  : SetEPRxAddr
 * Description    : Set the endpoint Rx buffer address.
 * Input          : bEpNum: Endpoint Number.
 *                  wAddr: new address.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPRxAddr(uint8_t bEpNum, uint16_t wAddr)
+{
   _SetEPRxAddr(bEpNum, wAddr);
+}
 /*******************************************************************************
 * Function Name  : GetEPTxAddr
 * Description    : Returns the endpoint Tx buffer address.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Rx buffer address.
 *******************************************************************************/
 uint16_t GetEPTxAddr(uint8_t bEpNum)
+{
   return(_GetEPTxAddr(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : GetEPRxAddr.
 * Description    : Returns the endpoint Rx buffer address.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Rx buffer address.
 *******************************************************************************/
 uint16_t GetEPRxAddr(uint8_t bEpNum)
+{
   return(_GetEPRxAddr(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : SetEPTxCount.
 * Description    : Set the Tx count.
 * Input          : bEpNum: Endpoint Number.
 *                  wCount: new count value.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPTxCount(uint8_t bEpNum, uint16_t wCount)
+{
   _SetEPTxCount(bEpNum, wCount);
+}
 /*******************************************************************************
 * Function Name  : SetEPCountRxReg.
 * Description    : Set the Count Rx Register value.
 * Input          : *pdwReg: point to the register.
 *                  wCount: the new register value.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPCountRxReg(uint32_t *pdwReg, uint16_t wCount)
+{
   _SetEPCountRxReg(dwReg, wCount);
+}
 /*******************************************************************************
 * Function Name  : SetEPRxCount
 * Description    : Set the Rx count.
 * Input          : bEpNum: Endpoint Number.
 *                  wCount: the new count value.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPRxCount(uint8_t bEpNum, uint16_t wCount)
+{
   _SetEPRxCount(bEpNum, wCount);
+}
 /*******************************************************************************
 * Function Name  : GetEPTxCount
 * Description    : Get the Tx count.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None
 * Return         : Tx count value.
 *******************************************************************************/
 uint16_t GetEPTxCount(uint8_t bEpNum)
+{
   return(_GetEPTxCount(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : GetEPRxCount
 * Description    : Get the Rx count.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Rx count value.
 *******************************************************************************/
 uint16_t GetEPRxCount(uint8_t bEpNum)
+{
   return(_GetEPRxCount(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : SetEPDblBuffAddr
 * Description    : Set the addresses of the buffer 0 and 1.
 * Input          : bEpNum: Endpoint Number.
 *                  wBuf0Addr: new address of buffer 0.
 *                  wBuf1Addr: new address of buffer 1.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPDblBuffAddr(uint8_t bEpNum, uint16_t wBuf0Addr, uint16_t wBuf1Addr)
+{
   _SetEPDblBuffAddr(bEpNum, wBuf0Addr, wBuf1Addr);
+}
 /*******************************************************************************
 * Function Name  : SetEPDblBuf0Addr
 * Description    : Set the Buffer 1 address.
 * Input          : bEpNum: Endpoint Number
 *                  wBuf0Addr: new address.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPDblBuf0Addr(uint8_t bEpNum, uint16_t wBuf0Addr)
+{
   _SetEPDblBuf0Addr(bEpNum, wBuf0Addr);
+}
 /*******************************************************************************
 * Function Name  : SetEPDblBuf1Addr
 * Description    : Set the Buffer 1 address.
 * Input          : bEpNum: Endpoint Number
 *                  wBuf1Addr: new address.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPDblBuf1Addr(uint8_t bEpNum, uint16_t wBuf1Addr)
+{
   _SetEPDblBuf1Addr(bEpNum, wBuf1Addr);
+}
 /*******************************************************************************
 * Function Name  : GetEPDblBuf0Addr
 * Description    : Returns the address of the Buffer 0.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 uint16_t GetEPDblBuf0Addr(uint8_t bEpNum)
+{
   return(_GetEPDblBuf0Addr(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : GetEPDblBuf1Addr
 * Description    : Returns the address of the Buffer 1.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Address of the Buffer 1.
 *******************************************************************************/
 uint16_t GetEPDblBuf1Addr(uint8_t bEpNum)
+{
   return(_GetEPDblBuf1Addr(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : SetEPDblBuffCount
 * Description    : Set the number of bytes for a double Buffer
 *                  endpoint.
 * Input          : bEpNum,bDir, wCount
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPDblBuffCount(uint8_t bEpNum, uint8_t bDir, uint16_t wCount)
+{
   _SetEPDblBuffCount(bEpNum, bDir, wCount);
+}
 /*******************************************************************************
 * Function Name  : SetEPDblBuf0Count
 * Description    : Set the number of bytes in the buffer 0 of a double Buffer
 *                  endpoint.
 * Input          : bEpNum, bDir,  wCount
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPDblBuf0Count(uint8_t bEpNum, uint8_t bDir, uint16_t wCount)
+{
   _SetEPDblBuf0Count(bEpNum, bDir, wCount);
+}
 /*******************************************************************************
 * Function Name  : SetEPDblBuf1Count
 * Description    : Set the number of bytes in the buffer 0 of a double Buffer
 *                  endpoint.
 * Input          : bEpNum,  bDir,  wCount
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void SetEPDblBuf1Count(uint8_t bEpNum, uint8_t bDir, uint16_t wCount)
+{
   _SetEPDblBuf1Count(bEpNum, bDir, wCount);
+}
 /*******************************************************************************
 * Function Name  : GetEPDblBuf0Count
 * Description    : Returns the number of byte received in the buffer 0 of a double
 *                  Buffer endpoint.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Endpoint Buffer 0 count
 *******************************************************************************/
 uint16_t GetEPDblBuf0Count(uint8_t bEpNum)
+{
   return(_GetEPDblBuf0Count(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : GetEPDblBuf1Count
 * Description    : Returns the number of data received in the buffer 1 of a double
 *                  Buffer endpoint.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Endpoint Buffer 1 count.
 *******************************************************************************/
 uint16_t GetEPDblBuf1Count(uint8_t bEpNum)
+{
   return(_GetEPDblBuf1Count(bEpNum));
+}
 /*******************************************************************************
 * Function Name  : GetEPDblBufDir
 * Description    : gets direction of the double buffered endpoint
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : EP_DBUF_OUT, EP_DBUF_IN,
 *                  EP_DBUF_ERR if the endpoint counter not yet programmed.
 *******************************************************************************/
 EP_DBUF_DIR GetEPDblBufDir(uint8_t bEpNum)
+{
   if ((uint16_t)(*_pEPRxCount(bEpNum) & 0xFC00) != 0)
     return(EP_DBUF_OUT);
   else if (((uint16_t)(*_pEPTxCount(bEpNum)) & 0x03FF) != 0)
     return(EP_DBUF_IN);
   else
     return(EP_DBUF_ERR);
+}
 /*******************************************************************************
 * Function Name  : FreeUserBuffer
 * Description    : free buffer used from the application realizing it to the line
                    toggles bit SW_BUF in the double buffered endpoint register
 * Input          : bEpNum, bDir
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 void FreeUserBuffer(uint8_t bEpNum, uint8_t bDir)
+{
   if (bDir == EP_DBUF_OUT)
   { /* OUT double buffered endpoint */
     _ToggleDTOG_TX(bEpNum);
+  }
   else if (bDir == EP_DBUF_IN)
   { /* IN double buffered endpoint */
     _ToggleDTOG_RX(bEpNum);
+  }
+}
 /*******************************************************************************
 * Function Name  : ToWord
 * Description    : merge two byte in a word.
 * Input          : bh: byte high, bl: bytes low.
 * Output         : None.
 * Return         : resulted word.
 *******************************************************************************/
 uint16_t ToWord(uint8_t bh, uint8_t bl)
+{
   uint16_t wRet;
   wRet = (uint16_t)bl | ((uint16_t)bh << 8);
   return(wRet);
+}
 /*******************************************************************************
 * Function Name  : ByteSwap
 * Description    : Swap two byte in a word.
 * Input          : wSwW: word to Swap.
 * Output         : None.
 * Return         : resulted word.
 *******************************************************************************/
 uint16_t ByteSwap(uint16_t wSwW)
+{
   uint8_t bTemp;
   uint16_t wRet;
   bTemp = (uint8_t)(wSwW & 0xff);
   wRet =  (wSwW >> 8) | ((uint16_t)bTemp << 8);
   return(wRet);
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_regs.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_regs.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Interface prototype functions to USB cell registers
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 __USB_REGS_H
 #define __USB_REGS_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 typedef enum _EP_DBUF_DIR
+{
   /* double buffered endpoint direction */
   EP_DBUF_ERR,
   EP_DBUF_OUT,
   EP_DBUF_IN
 }EP_DBUF_DIR;
 /* endpoint buffer number */
 enum EP_BUF_NUM
+{
   EP_NOBUF,
   EP_BUF0,
   EP_BUF1
 };
 /* Exported constants --------------------------------------------------------*/
 #define RegBase  (0x40005C00L)  /* USB_IP Peripheral Registers base address */
 #define PMAAddr  (0x40006000L)  /* USB_IP Packet Memory Area base address   */
 /******************************************************************************/
 /*                         General registers                                  */
 /******************************************************************************/
 /* Control register */
 #define CNTR    ((__IO unsigned *)(RegBase + 0x40))
 /* Interrupt status register */
 #define ISTR    ((__IO unsigned *)(RegBase + 0x44))
 /* Frame number register */
 #define FNR     ((__IO unsigned *)(RegBase + 0x48))
 /* Device address register */
 #define DADDR   ((__IO unsigned *)(RegBase + 0x4C))
 /* Buffer Table address register */
 #define BTABLE  ((__IO unsigned *)(RegBase + 0x50))
 /******************************************************************************/
 /*                         Endpoint registers                                 */
 /******************************************************************************/
 #define EP0REG  ((__IO unsigned *)(RegBase)) /* endpoint 0 register address */
 /* Endpoint Addresses (w/direction) */
 #define EP0_OUT     ((uint8_t)0x00)
 #define EP0_IN      ((uint8_t)0x80)
 #define EP1_OUT     ((uint8_t)0x01)
 #define EP1_IN      ((uint8_t)0x81)
 #define EP2_OUT     ((uint8_t)0x02)
 #define EP2_IN      ((uint8_t)0x82)
 #define EP3_OUT     ((uint8_t)0x03)
 #define EP3_IN      ((uint8_t)0x83)
 #define EP4_OUT     ((uint8_t)0x04)
 #define EP4_IN      ((uint8_t)0x84)
 #define EP5_OUT     ((uint8_t)0x05)
 #define EP5_IN      ((uint8_t)0x85)
 #define EP6_OUT     ((uint8_t)0x06)
 #define EP6_IN      ((uint8_t)0x86)
 #define EP7_OUT     ((uint8_t)0x07)
 #define EP7_IN      ((uint8_t)0x87)
 /* endpoints enumeration */
 #define ENDP0       ((uint8_t)0)
 #define ENDP1       ((uint8_t)1)
 #define ENDP2       ((uint8_t)2)
 #define ENDP3       ((uint8_t)3)
 #define ENDP4       ((uint8_t)4)
 #define ENDP5       ((uint8_t)5)
 #define ENDP6       ((uint8_t)6)
 #define ENDP7       ((uint8_t)7)
 /******************************************************************************/
 /*                       ISTR interrupt events                                */
 /******************************************************************************/
 #define ISTR_CTR    (0x8000) /* Correct TRansfer (clear-only bit) */
 #define ISTR_DOVR   (0x4000) /* DMA OVeR/underrun (clear-only bit) */
 #define ISTR_ERR    (0x2000) /* ERRor (clear-only bit) */
 #define ISTR_WKUP   (0x1000) /* WaKe UP (clear-only bit) */
 #define ISTR_SUSP   (0x0800) /* SUSPend (clear-only bit) */
 #define ISTR_RESET  (0x0400) /* RESET (clear-only bit) */
 #define ISTR_SOF    (0x0200) /* Start Of Frame (clear-only bit) */
 #define ISTR_ESOF   (0x0100) /* Expected Start Of Frame (clear-only bit) */
 #define ISTR_DIR    (0x0010)  /* DIRection of transaction (read-only bit)  */
 #define ISTR_EP_ID  (0x000F)  /* EndPoint IDentifier (read-only bit)  */
 #define CLR_CTR    (~ISTR_CTR)   /* clear Correct TRansfer bit */
 #define CLR_DOVR   (~ISTR_DOVR)  /* clear DMA OVeR/underrun bit*/
 #define CLR_ERR    (~ISTR_ERR)   /* clear ERRor bit */
 #define CLR_WKUP   (~ISTR_WKUP)  /* clear WaKe UP bit     */
 #define CLR_SUSP   (~ISTR_SUSP)  /* clear SUSPend bit     */
 #define CLR_RESET  (~ISTR_RESET) /* clear RESET bit      */
 #define CLR_SOF    (~ISTR_SOF)   /* clear Start Of Frame bit   */
 #define CLR_ESOF   (~ISTR_ESOF)  /* clear Expected Start Of Frame bit */
 /******************************************************************************/
 /*             CNTR control register bits definitions                         */
 /******************************************************************************/
 #define CNTR_CTRM   (0x8000) /* Correct TRansfer Mask */
 #define CNTR_DOVRM  (0x4000) /* DMA OVeR/underrun Mask */
 #define CNTR_ERRM   (0x2000) /* ERRor Mask */
 #define CNTR_WKUPM  (0x1000) /* WaKe UP Mask */
 #define CNTR_SUSPM  (0x0800) /* SUSPend Mask */
 #define CNTR_RESETM (0x0400) /* RESET Mask   */
 #define CNTR_SOFM   (0x0200) /* Start Of Frame Mask */
 #define CNTR_ESOFM  (0x0100) /* Expected Start Of Frame Mask */
 #define CNTR_RESUME (0x0010) /* RESUME request */
 #define CNTR_FSUSP  (0x0008) /* Force SUSPend */
 #define CNTR_LPMODE (0x0004) /* Low-power MODE */
 #define CNTR_PDWN   (0x0002) /* Power DoWN */
 #define CNTR_FRES   (0x0001) /* Force USB RESet */
 /******************************************************************************/
 /*                FNR Frame Number Register bit definitions                   */
 /******************************************************************************/
 #define FNR_RXDP (0x8000) /* status of D+ data line */
 #define FNR_RXDM (0x4000) /* status of D- data line */
 #define FNR_LCK  (0x2000) /* LoCKed */
 #define FNR_LSOF (0x1800) /* Lost SOF */
 #define FNR_FN  (0x07FF) /* Frame Number */
 /******************************************************************************/
 /*               DADDR Device ADDRess bit definitions                         */
 /******************************************************************************/
 #define DADDR_EF (0x80)
 #define DADDR_ADD (0x7F)
 /******************************************************************************/
 /*                            Endpoint register                               */
 /******************************************************************************/
 /* bit positions */
 #define EP_CTR_RX      (0x8000) /* EndPoint Correct TRansfer RX */
 #define EP_DTOG_RX     (0x4000) /* EndPoint Data TOGGLE RX */
 #define EPRX_STAT      (0x3000) /* EndPoint RX STATus bit field */
 #define EP_SETUP       (0x0800) /* EndPoint SETUP */
 #define EP_T_FIELD     (0x0600) /* EndPoint TYPE */
 #define EP_KIND        (0x0100) /* EndPoint KIND */
 #define EP_CTR_TX      (0x0080) /* EndPoint Correct TRansfer TX */
 #define EP_DTOG_TX     (0x0040) /* EndPoint Data TOGGLE TX */
 #define EPTX_STAT      (0x0030) /* EndPoint TX STATus bit field */
 #define EPADDR_FIELD   (0x000F) /* EndPoint ADDRess FIELD */
 /* EndPoint REGister MASK (no toggle fields) */
 #define EPREG_MASK     (EP_CTR_RX|EP_SETUP|EP_T_FIELD|EP_KIND|EP_CTR_TX|EPADDR_FIELD)
 /* EP_TYPE[1:0] EndPoint TYPE */
 #define EP_TYPE_MASK   (0x0600) /* EndPoint TYPE Mask */
 #define EP_BULK        (0x0000) /* EndPoint BULK */
 #define EP_CONTROL     (0x0200) /* EndPoint CONTROL */
 #define EP_ISOCHRONOUS (0x0400) /* EndPoint ISOCHRONOUS */
 #define EP_INTERRUPT   (0x0600) /* EndPoint INTERRUPT */
 #define EP_T_MASK      (~EP_T_FIELD & EPREG_MASK)
 /* EP_KIND EndPoint KIND */
 #define EPKIND_MASK    (~EP_KIND & EPREG_MASK)
 /* STAT_TX[1:0] STATus for TX transfer */
 #define EP_TX_DIS      (0x0000) /* EndPoint TX DISabled */
 #define EP_TX_STALL    (0x0010) /* EndPoint TX STALLed */
 #define EP_TX_NAK      (0x0020) /* EndPoint TX NAKed */
 #define EP_TX_VALID    (0x0030) /* EndPoint TX VALID */
 #define EPTX_DTOG1     (0x0010) /* EndPoint TX Data TOGgle bit1 */
 #define EPTX_DTOG2     (0x0020) /* EndPoint TX Data TOGgle bit2 */
 #define EPTX_DTOGMASK  (EPTX_STAT|EPREG_MASK)
 /* STAT_RX[1:0] STATus for RX transfer */
 #define EP_RX_DIS      (0x0000) /* EndPoint RX DISabled */
 #define EP_RX_STALL    (0x1000) /* EndPoint RX STALLed */
 #define EP_RX_NAK      (0x2000) /* EndPoint RX NAKed */
 #define EP_RX_VALID    (0x3000) /* EndPoint RX VALID */
 #define EPRX_DTOG1     (0x1000) /* EndPoint RX Data TOGgle bit1 */
 #define EPRX_DTOG2     (0x2000) /* EndPoint RX Data TOGgle bit1 */
 #define EPRX_DTOGMASK  (EPRX_STAT|EPREG_MASK)
 /* Exported macro ------------------------------------------------------------*/
 /* SetCNTR */
 #define _SetCNTR(wRegValue)  (*CNTR   = (uint16_t)wRegValue)
 /* SetISTR */
 #define _SetISTR(wRegValue)  (*ISTR   = (uint16_t)wRegValue)
 /* SetDADDR */
 #define _SetDADDR(wRegValue) (*DADDR  = (uint16_t)wRegValue)
 /* SetBTABLE */
 #define _SetBTABLE(wRegValue)(*BTABLE = (uint16_t)(wRegValue & 0xFFF8))
 /* GetCNTR */
 #define _GetCNTR()   ((uint16_t) *CNTR)
 /* GetISTR */
 #define _GetISTR()   ((uint16_t) *ISTR)
 /* GetFNR */
 #define _GetFNR()    ((uint16_t) *FNR)
 /* GetDADDR */
 #define _GetDADDR()  ((uint16_t) *DADDR)
 /* GetBTABLE */
 #define _GetBTABLE() ((uint16_t) *BTABLE)
 /* SetENDPOINT */
 #define _SetENDPOINT(bEpNum,wRegValue)  (*(EP0REG + bEpNum)= \
     (uint16_t)wRegValue)
 /* GetENDPOINT */
 #define _GetENDPOINT(bEpNum)        ((uint16_t)(*(EP0REG + bEpNum)))
 /*******************************************************************************
 * Macro Name     : SetEPType
 * Description    : sets the type in the endpoint register(bits EP_TYPE[1:0])
 * Input          : bEpNum: Endpoint Number.
 *                  wType
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPType(bEpNum,wType) (_SetENDPOINT(bEpNum,\
                                   ((_GetENDPOINT(bEpNum) & EP_T_MASK) | wType )))
 /*******************************************************************************
 * Macro Name     : GetEPType
 * Description    : gets the type in the endpoint register(bits EP_TYPE[1:0])
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : Endpoint Type
 *******************************************************************************/
 #define _GetEPType(bEpNum) (_GetENDPOINT(bEpNum) & EP_T_FIELD)
 /*******************************************************************************
 * Macro Name     : SetEPTxStatus
 * Description    : sets the status for tx transfer (bits STAT_TX[1:0]).
 * Input          : bEpNum: Endpoint Number.
 *                  wState: new state
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPTxStatus(bEpNum,wState) {\
     register uint16_t _wRegVal;       \
     _wRegVal = _GetENDPOINT(bEpNum) & EPTX_DTOGMASK;\
     /* toggle first bit ? */     \
     if((EPTX_DTOG1 & wState)!= 0)      \
       _wRegVal ^= EPTX_DTOG1;        \
     /* toggle second bit ?  */         \
     if((EPTX_DTOG2 & wState)!= 0)      \
       _wRegVal ^= EPTX_DTOG2;        \
     _SetENDPOINT(bEpNum, (_wRegVal | EP_CTR_RX|EP_CTR_TX));    \
   } /* _SetEPTxStatus */
 /*******************************************************************************
 * Macro Name     : SetEPRxStatus
 * Description    : sets the status for rx transfer (bits STAT_TX[1:0])
 * Input          : bEpNum: Endpoint Number.
 *                  wState: new state.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPRxStatus(bEpNum,wState) {\
     register uint16_t _wRegVal;   \
+    \
     _wRegVal = _GetENDPOINT(bEpNum) & EPRX_DTOGMASK;\
     /* toggle first bit ? */  \
     if((EPRX_DTOG1 & wState)!= 0) \
       _wRegVal ^= EPRX_DTOG1;  \
     /* toggle second bit ? */  \
     if((EPRX_DTOG2 & wState)!= 0) \
       _wRegVal ^= EPRX_DTOG2;  \
     _SetENDPOINT(bEpNum, (_wRegVal | EP_CTR_RX|EP_CTR_TX)); \
   } /* _SetEPRxStatus */
 /*******************************************************************************
 * Macro Name     : SetEPRxTxStatus
 * Description    : sets the status for rx & tx (bits STAT_TX[1:0] & STAT_RX[1:0])
 * Input          : bEpNum: Endpoint Number.
 *                  wStaterx: new state.
 *                  wStatetx: new state.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPRxTxStatus(bEpNum,wStaterx,wStatetx) {\
     register uint32_t _wRegVal;   \
+    \
     _wRegVal = _GetENDPOINT(bEpNum) & (EPRX_DTOGMASK |EPTX_STAT) ;\
     /* toggle first bit ? */  \
     if((EPRX_DTOG1 & wStaterx)!= 0) \
       _wRegVal ^= EPRX_DTOG1;  \
     /* toggle second bit ? */  \
     if((EPRX_DTOG2 & wStaterx)!= 0) \
       _wRegVal ^= EPRX_DTOG2;  \
     /* toggle first bit ? */     \
     if((EPTX_DTOG1 & wStatetx)!= 0)      \
       _wRegVal ^= EPTX_DTOG1;        \
     /* toggle second bit ?  */         \
     if((EPTX_DTOG2 & wStatetx)!= 0)      \
       _wRegVal ^= EPTX_DTOG2;        \
     _SetENDPOINT(bEpNum, _wRegVal | EP_CTR_RX|EP_CTR_TX);    \
   } /* _SetEPRxTxStatus */
 /*******************************************************************************
 * Macro Name     : GetEPTxStatus / GetEPRxStatus
 * Description    : gets the status for tx/rx transfer (bits STAT_TX[1:0]
 *                  /STAT_RX[1:0])
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : status .
 *******************************************************************************/
 #define _GetEPTxStatus(bEpNum) ((uint16_t)_GetENDPOINT(bEpNum) & EPTX_STAT)
 #define _GetEPRxStatus(bEpNum) ((uint16_t)_GetENDPOINT(bEpNum) & EPRX_STAT)
 /*******************************************************************************
 * Macro Name     : SetEPTxValid / SetEPRxValid
 * Description    : sets directly the VALID tx/rx-status into the enpoint register
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPTxValid(bEpNum)     (_SetEPTxStatus(bEpNum, EP_TX_VALID))
 #define _SetEPRxValid(bEpNum)     (_SetEPRxStatus(bEpNum, EP_RX_VALID))
 /*******************************************************************************
 * Macro Name     : GetTxStallStatus / GetRxStallStatus.
 * Description    : checks stall condition in an endpoint.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : TRUE = endpoint in stall condition.
 *******************************************************************************/
 #define _GetTxStallStatus(bEpNum) (_GetEPTxStatus(bEpNum) \
                                    == EP_TX_STALL)
 #define _GetRxStallStatus(bEpNum) (_GetEPRxStatus(bEpNum) \
                                    == EP_RX_STALL)
 /*******************************************************************************
 * Macro Name     : SetEP_KIND / ClearEP_KIND.
 * Description    : set & clear EP_KIND bit.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEP_KIND(bEpNum)    (_SetENDPOINT(bEpNum, \
                                 (EP_CTR_RX|EP_CTR_TX|((_GetENDPOINT(bEpNum) | EP_KIND) & EPREG_MASK))))
 #define _ClearEP_KIND(bEpNum)  (_SetENDPOINT(bEpNum, \
                                 (EP_CTR_RX|EP_CTR_TX|(_GetENDPOINT(bEpNum) & EPKIND_MASK))))
 /*******************************************************************************
 * Macro Name     : Set_Status_Out / Clear_Status_Out.
 * Description    : Sets/clears directly STATUS_OUT bit in the endpoint register.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _Set_Status_Out(bEpNum)    _SetEP_KIND(bEpNum)
 #define _Clear_Status_Out(bEpNum)  _ClearEP_KIND(bEpNum)
 /*******************************************************************************
 * Macro Name     : SetEPDoubleBuff / ClearEPDoubleBuff.
 * Description    : Sets/clears directly EP_KIND bit in the endpoint register.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPDoubleBuff(bEpNum)   _SetEP_KIND(bEpNum)
 #define _ClearEPDoubleBuff(bEpNum) _ClearEP_KIND(bEpNum)
 /*******************************************************************************
 * Macro Name     : ClearEP_CTR_RX / ClearEP_CTR_TX.
 * Description    : Clears bit CTR_RX / CTR_TX in the endpoint register.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _ClearEP_CTR_RX(bEpNum)   (_SetENDPOINT(bEpNum,\
                                    _GetENDPOINT(bEpNum) & 0x7FFF & EPREG_MASK))
 #define _ClearEP_CTR_TX(bEpNum)   (_SetENDPOINT(bEpNum,\
                                    _GetENDPOINT(bEpNum) & 0xFF7F & EPREG_MASK))
 /*******************************************************************************
 * Macro Name     : ToggleDTOG_RX / ToggleDTOG_TX .
 * Description    : Toggles DTOG_RX / DTOG_TX bit in the endpoint register.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _ToggleDTOG_RX(bEpNum)    (_SetENDPOINT(bEpNum, \
                                    EP_CTR_RX|EP_CTR_TX|EP_DTOG_RX | (_GetENDPOINT(bEpNum) & EPREG_MASK)))
 #define _ToggleDTOG_TX(bEpNum)    (_SetENDPOINT(bEpNum, \
                                    EP_CTR_RX|EP_CTR_TX|EP_DTOG_TX | (_GetENDPOINT(bEpNum) & EPREG_MASK)))
 /*******************************************************************************
 * Macro Name     : ClearDTOG_RX / ClearDTOG_TX.
 * Description    : Clears DTOG_RX / DTOG_TX bit in the endpoint register.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _ClearDTOG_RX(bEpNum)  if((_GetENDPOINT(bEpNum) & EP_DTOG_RX) != 0)\
     _ToggleDTOG_RX(bEpNum)
 #define _ClearDTOG_TX(bEpNum)  if((_GetENDPOINT(bEpNum) & EP_DTOG_TX) != 0)\
     _ToggleDTOG_TX(bEpNum)
 /*******************************************************************************
 * Macro Name     : SetEPAddress.
 * Description    : Sets address in an endpoint register.
 * Input          : bEpNum: Endpoint Number.
 *                  bAddr: Address.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPAddress(bEpNum,bAddr) _SetENDPOINT(bEpNum,\
     EP_CTR_RX|EP_CTR_TX|(_GetENDPOINT(bEpNum) & EPREG_MASK) | bAddr)
 /*******************************************************************************
 * Macro Name     : GetEPAddress.
 * Description    : Gets address in an endpoint register.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _GetEPAddress(bEpNum) ((uint8_t)(_GetENDPOINT(bEpNum) & EPADDR_FIELD))
 #define _pEPTxAddr(bEpNum) ((uint32_t *)((_GetBTABLE()+bEpNum*8  )*2 + PMAAddr))
 #define _pEPTxCount(bEpNum) ((uint32_t *)((_GetBTABLE()+bEpNum*8+2)*2 + PMAAddr))
 #define _pEPRxAddr(bEpNum) ((uint32_t *)((_GetBTABLE()+bEpNum*8+4)*2 + PMAAddr))
 #define _pEPRxCount(bEpNum) ((uint32_t *)((_GetBTABLE()+bEpNum*8+6)*2 + PMAAddr))
 /*******************************************************************************
 * Macro Name     : SetEPTxAddr / SetEPRxAddr.
 * Description    : sets address of the tx/rx buffer.
 * Input          : bEpNum: Endpoint Number.
 *                  wAddr: address to be set (must be word aligned).
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPTxAddr(bEpNum,wAddr) (*_pEPTxAddr(bEpNum) = ((wAddr >> 1) << 1))
 #define _SetEPRxAddr(bEpNum,wAddr) (*_pEPRxAddr(bEpNum) = ((wAddr >> 1) << 1))
 /*******************************************************************************
 * Macro Name     : GetEPTxAddr / GetEPRxAddr.
 * Description    : Gets address of the tx/rx buffer.
 * Input          : bEpNum: Endpoint Number.
 * Output         : None.
 * Return         : address of the buffer.
 *******************************************************************************/
 #define _GetEPTxAddr(bEpNum) ((uint16_t)*_pEPTxAddr(bEpNum))
 #define _GetEPRxAddr(bEpNum) ((uint16_t)*_pEPRxAddr(bEpNum))
 /*******************************************************************************
 * Macro Name     : SetEPCountRxReg.
 * Description    : Sets counter of rx buffer with no. of blocks.
 * Input          : pdwReg: pointer to counter.
 *                  wCount: Counter.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _BlocksOf32(dwReg,wCount,wNBlocks) {\
     wNBlocks = wCount >> 5;\
     if((wCount & 0x1f) == 0)\
       wNBlocks--;\
     *pdwReg = (uint32_t)((wNBlocks << 10) | 0x8000);\
   }/* _BlocksOf32 */
 #define _BlocksOf2(dwReg,wCount,wNBlocks) {\
     wNBlocks = wCount >> 1;\
     if((wCount & 0x1) != 0)\
       wNBlocks++;\
     *pdwReg = (uint32_t)(wNBlocks << 10);\
   }/* _BlocksOf2 */
 #define _SetEPCountRxReg(dwReg,wCount)  {\
     uint16_t wNBlocks;\
     if(wCount > 62){_BlocksOf32(dwReg,wCount,wNBlocks);}\
     else {_BlocksOf2(dwReg,wCount,wNBlocks);}\
   }/* _SetEPCountRxReg */
 #define _SetEPRxDblBuf0Count(bEpNum,wCount) {\
     uint32_t *pdwReg = _pEPTxCount(bEpNum); \
     _SetEPCountRxReg(pdwReg, wCount);\
+  }
 /*******************************************************************************
 * Macro Name     : SetEPTxCount / SetEPRxCount.
 * Description    : sets counter for the tx/rx buffer.
 * Input          : bEpNum: endpoint number.
 *                  wCount: Counter value.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPTxCount(bEpNum,wCount) (*_pEPTxCount(bEpNum) = wCount)
 #define _SetEPRxCount(bEpNum,wCount) {\
     uint32_t *pdwReg = _pEPRxCount(bEpNum); \
     _SetEPCountRxReg(pdwReg, wCount);\
+  }
 /*******************************************************************************
 * Macro Name     : GetEPTxCount / GetEPRxCount.
 * Description    : gets counter of the tx buffer.
 * Input          : bEpNum: endpoint number.
 * Output         : None.
 * Return         : Counter value.
 *******************************************************************************/
 #define _GetEPTxCount(bEpNum)((uint16_t)(*_pEPTxCount(bEpNum)) & 0x3ff)
 #define _GetEPRxCount(bEpNum)((uint16_t)(*_pEPRxCount(bEpNum)) & 0x3ff)
 /*******************************************************************************
 * Macro Name     : SetEPDblBuf0Addr / SetEPDblBuf1Addr.
 * Description    : Sets buffer 0/1 address in a double buffer endpoint.
 * Input          : bEpNum: endpoint number.
 *                : wBuf0Addr: buffer 0 address.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPDblBuf0Addr(bEpNum,wBuf0Addr) {_SetEPTxAddr(bEpNum, wBuf0Addr);}
 #define _SetEPDblBuf1Addr(bEpNum,wBuf1Addr) {_SetEPRxAddr(bEpNum, wBuf1Addr);}
 /*******************************************************************************
 * Macro Name     : SetEPDblBuffAddr.
 * Description    : Sets addresses in a double buffer endpoint.
 * Input          : bEpNum: endpoint number.
 *                : wBuf0Addr: buffer 0 address.
 *                : wBuf1Addr = buffer 1 address.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPDblBuffAddr(bEpNum,wBuf0Addr,wBuf1Addr) { \
     _SetEPDblBuf0Addr(bEpNum, wBuf0Addr);\
     _SetEPDblBuf1Addr(bEpNum, wBuf1Addr);\
   } /* _SetEPDblBuffAddr */
 /*******************************************************************************
 * Macro Name     : GetEPDblBuf0Addr / GetEPDblBuf1Addr.
 * Description    : Gets buffer 0/1 address of a double buffer endpoint.
 * Input          : bEpNum: endpoint number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _GetEPDblBuf0Addr(bEpNum) (_GetEPTxAddr(bEpNum))
 #define _GetEPDblBuf1Addr(bEpNum) (_GetEPRxAddr(bEpNum))
 /*******************************************************************************
 * Macro Name     : SetEPDblBuffCount / SetEPDblBuf0Count / SetEPDblBuf1Count.
 * Description    : Gets buffer 0/1 address of a double buffer endpoint.
 * Input          : bEpNum: endpoint number.
 *                : bDir: endpoint dir  EP_DBUF_OUT = OUT
 *                                      EP_DBUF_IN  = IN
 *                : wCount: Counter value
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _SetEPDblBuf0Count(bEpNum, bDir, wCount)  { \
     if(bDir == EP_DBUF_OUT)\
       /* OUT endpoint */ \
     {_SetEPRxDblBuf0Count(bEpNum,wCount);} \
     else if(bDir == EP_DBUF_IN)\
       /* IN endpoint */ \
       *_pEPTxCount(bEpNum) = (uint32_t)wCount;  \
   } /* SetEPDblBuf0Count*/
 #define _SetEPDblBuf1Count(bEpNum, bDir, wCount)  { \
     if(bDir == EP_DBUF_OUT)\
       /* OUT endpoint */ \
     {_SetEPRxCount(bEpNum,wCount);}\
     else if(bDir == EP_DBUF_IN)\
       /* IN endpoint */\
       *_pEPRxCount(bEpNum) = (uint32_t)wCount; \
   } /* SetEPDblBuf1Count */
 #define _SetEPDblBuffCount(bEpNum, bDir, wCount) {\
     _SetEPDblBuf0Count(bEpNum, bDir, wCount); \
     _SetEPDblBuf1Count(bEpNum, bDir, wCount); \
   } /* _SetEPDblBuffCount  */
 /*******************************************************************************
 * Macro Name     : GetEPDblBuf0Count / GetEPDblBuf1Count.
 * Description    : Gets buffer 0/1 rx/tx counter for double buffering.
 * Input          : bEpNum: endpoint number.
 * Output         : None.
 * Return         : None.
 *******************************************************************************/
 #define _GetEPDblBuf0Count(bEpNum) (_GetEPTxCount(bEpNum))
 #define _GetEPDblBuf1Count(bEpNum) (_GetEPRxCount(bEpNum))
 /* External variables --------------------------------------------------------*/
 extern __IO uint16_t wIstr;  /* ISTR register last read value */
 /* Exported functions ------------------------------------------------------- */
 void SetCNTR(uint16_t /*wRegValue*/);
 void SetISTR(uint16_t /*wRegValue*/);
 void SetDADDR(uint16_t /*wRegValue*/);
 void SetBTABLE(uint16_t /*wRegValue*/);
 void SetBTABLE(uint16_t /*wRegValue*/);
 uint16_t GetCNTR(void);
 uint16_t GetISTR(void);
 uint16_t GetFNR(void);
 uint16_t GetDADDR(void);
 uint16_t GetBTABLE(void);
 void SetENDPOINT(uint8_t /*bEpNum*/, uint16_t /*wRegValue*/);
 uint16_t GetENDPOINT(uint8_t /*bEpNum*/);
 void SetEPType(uint8_t /*bEpNum*/, uint16_t /*wType*/);
 uint16_t GetEPType(uint8_t /*bEpNum*/);
 void SetEPTxStatus(uint8_t /*bEpNum*/, uint16_t /*wState*/);
 void SetEPRxStatus(uint8_t /*bEpNum*/, uint16_t /*wState*/);
 void SetDouBleBuffEPStall(uint8_t /*bEpNum*/, uint8_t bDir);
 uint16_t GetEPTxStatus(uint8_t /*bEpNum*/);
 uint16_t GetEPRxStatus(uint8_t /*bEpNum*/);
 void SetEPTxValid(uint8_t /*bEpNum*/);
 void SetEPRxValid(uint8_t /*bEpNum*/);
 uint16_t GetTxStallStatus(uint8_t /*bEpNum*/);
 uint16_t GetRxStallStatus(uint8_t /*bEpNum*/);
 void SetEP_KIND(uint8_t /*bEpNum*/);
 void ClearEP_KIND(uint8_t /*bEpNum*/);
 void Set_Status_Out(uint8_t /*bEpNum*/);
 void Clear_Status_Out(uint8_t /*bEpNum*/);
 void SetEPDoubleBuff(uint8_t /*bEpNum*/);
 void ClearEPDoubleBuff(uint8_t /*bEpNum*/);
 void ClearEP_CTR_RX(uint8_t /*bEpNum*/);
 void ClearEP_CTR_TX(uint8_t /*bEpNum*/);
 void ToggleDTOG_RX(uint8_t /*bEpNum*/);
 void ToggleDTOG_TX(uint8_t /*bEpNum*/);
 void ClearDTOG_RX(uint8_t /*bEpNum*/);
 void ClearDTOG_TX(uint8_t /*bEpNum*/);
 void SetEPAddress(uint8_t /*bEpNum*/, uint8_t /*bAddr*/);
 uint8_t GetEPAddress(uint8_t /*bEpNum*/);
 void SetEPTxAddr(uint8_t /*bEpNum*/, uint16_t /*wAddr*/);
 void SetEPRxAddr(uint8_t /*bEpNum*/, uint16_t /*wAddr*/);
 uint16_t GetEPTxAddr(uint8_t /*bEpNum*/);
 uint16_t GetEPRxAddr(uint8_t /*bEpNum*/);
 void SetEPCountRxReg(uint32_t * /*pdwReg*/, uint16_t /*wCount*/);
 void SetEPTxCount(uint8_t /*bEpNum*/, uint16_t /*wCount*/);
 void SetEPRxCount(uint8_t /*bEpNum*/, uint16_t /*wCount*/);
 uint16_t GetEPTxCount(uint8_t /*bEpNum*/);
 uint16_t GetEPRxCount(uint8_t /*bEpNum*/);
 void SetEPDblBuf0Addr(uint8_t /*bEpNum*/, uint16_t /*wBuf0Addr*/);
 void SetEPDblBuf1Addr(uint8_t /*bEpNum*/, uint16_t /*wBuf1Addr*/);
 void SetEPDblBuffAddr(uint8_t /*bEpNum*/, uint16_t /*wBuf0Addr*/, uint16_t /*wBuf1Addr*/);
 uint16_t GetEPDblBuf0Addr(uint8_t /*bEpNum*/);
 uint16_t GetEPDblBuf1Addr(uint8_t /*bEpNum*/);
 void SetEPDblBuffCount(uint8_t /*bEpNum*/, uint8_t /*bDir*/, uint16_t /*wCount*/);
 void SetEPDblBuf0Count(uint8_t /*bEpNum*/, uint8_t /*bDir*/, uint16_t /*wCount*/);
 void SetEPDblBuf1Count(uint8_t /*bEpNum*/, uint8_t /*bDir*/, uint16_t /*wCount*/);
 uint16_t GetEPDblBuf0Count(uint8_t /*bEpNum*/);
 uint16_t GetEPDblBuf1Count(uint8_t /*bEpNum*/);
 EP_DBUF_DIR GetEPDblBufDir(uint8_t /*bEpNum*/);
 void FreeUserBuffer(uint8_t bEpNum/*bEpNum*/, uint8_t bDir);
 uint16_t ToWord(uint8_t, uint8_t);
 uint16_t ByteSwap(uint16_t);
 #endif /* __USB_REGS_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_sil.c

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_sil.c
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Simplified Interface Layer for Global Initialization and Endpoint
   *          Rea/Write operations.
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 "usb_lib.h"
 /* Private typedef -----------------------------------------------------------*/
 /* Private define ------------------------------------------------------------*/
 /* Private macro -------------------------------------------------------------*/
 /* Private variables ---------------------------------------------------------*/
 /* Extern variables ----------------------------------------------------------*/
 /* Private function prototypes -----------------------------------------------*/
 /* Private functions ---------------------------------------------------------*/
 /*******************************************************************************
 * Function Name  : USB_SIL_Init
 * Description    : Initialize the USB Device IP and the Endpoint 0.
 * Input          : None.
 * Output         : None.
 * Return         : Status.
 *******************************************************************************/
 uint32_t USB_SIL_Init(void)
+{
   /* USB interrupts initialization */
   /* clear pending interrupts */
   _SetISTR(0);
   wInterrupt_Mask = IMR_MSK;
   /* set interrupts mask */
   _SetCNTR(wInterrupt_Mask);
   return 0;
+}
 /*******************************************************************************
 * Function Name  : USB_SIL_Write
 * Description    : Write a buffer of data to a selected endpoint.
 * Input          : - bEpAddr: The address of the non control endpoint.
 *                  - pBufferPointer: The pointer to the buffer of data to be written
 *                    to the endpoint.
 *                  - wBufferSize: Number of data to be written (in bytes).
 * Output         : None.
 * Return         : Status.
 *******************************************************************************/
 uint32_t USB_SIL_Write(uint8_t bEpAddr, uint8_t* pBufferPointer, uint32_t wBufferSize)
+{
   /* Use the memory interface function to write to the selected endpoint */
   UserToPMABufferCopy(pBufferPointer, GetEPTxAddr(bEpAddr & 0x7F), wBufferSize);
   /* Update the data length in the control register */
   SetEPTxCount((bEpAddr & 0x7F), wBufferSize);
   return 0;
+}
 /*******************************************************************************
 * Function Name  : USB_SIL_Read
 * Description    : Write a buffer of data to a selected endpoint.
 * Input          : - bEpAddr: The address of the non control endpoint.
 *                  - pBufferPointer: The pointer to which will be saved the
 *                     received data buffer.
 * Output         : None.
 * Return         : Number of received data (in Bytes).
 *******************************************************************************/
 uint32_t USB_SIL_Read(uint8_t bEpAddr, uint8_t* pBufferPointer)
+{
   uint32_t DataLength = 0;
   /* Get the number of received data on the selected Endpoint */
   DataLength = GetEPRxCount(bEpAddr & 0x7F);
   /* Use the memory interface function to write to the selected endpoint */
   PMAToUserBufferCopy(pBufferPointer, GetEPRxAddr(bEpAddr & 0x7F), DataLength);
   /* Return the number of received data */
   return DataLength;
+}
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_sil.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_sil.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Simplified Interface Layer function prototypes.
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 __USB_SIL_H
 #define __USB_SIL_H
 /* Includes ------------------------------------------------------------------*/
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 uint32_t USB_SIL_Init(void);
 uint32_t USB_SIL_Write(uint8_t bEpAddr, uint8_t* pBufferPointer, uint32_t wBufferSize);
 uint32_t USB_SIL_Read(uint8_t bEpAddr, uint8_t* pBufferPointer);
 /* External variables --------------------------------------------------------*/
 #endif /* __USB_SIL_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

usb_type.h

➞

Show inline comments

@@ new file 100644 @@
 /**
   ******************************************************************************
   * @file    usb_type.h
   * @author  MCD Application Team
   * @version V4.0.0
   * @date    28-August-2012
   * @brief   Type definitions used by the USB Library
   ******************************************************************************
   * @attention
+  *
   * <h2><center>&copy; COPYRIGHT 2012 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 __USB_TYPE_H
 #define __USB_TYPE_H
 /* Includes ------------------------------------------------------------------*/
 #include "usb_conf.h"
 /* Exported types ------------------------------------------------------------*/
 /* Exported constants --------------------------------------------------------*/
 #ifndef NULL
 #define NULL ((void *)0)
 #endif
 typedef enum
+{
   FALSE = 0, TRUE  = !FALSE
+}
 bool;
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 /* External variables --------------------------------------------------------*/
 #endif /* __USB_TYPE_H */
 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

0 comments (0 inline, 0 general)