mbed-dev - mbed library sources. Supersedes mbed-src.

Users » TuxLeon » Code » mbed-dev

mbed library sources. Supersedes mbed-src.

targets/TARGET_STM/TARGET_STM32L4/device/stm32l4xx_hal_pcd.c@167:e84263d55307, 2017-06-21 (annotated)

Committer:: AnnaBridge
Date:: Wed Jun 21 17:46:44 2017 +0100
Revision:: 167:e84263d55307
Parent:: 153:fa9ff456f731

This updates the lib to the mbed lib v 145

Who changed what in which revision?

User	Revision	Line number	New contents of line
<>	144:ef7eb2e8f9f7	1	/**
<>	144:ef7eb2e8f9f7	2	******************************************************************************
<>	144:ef7eb2e8f9f7	3	* @file stm32l4xx_hal_pcd.c
<>	144:ef7eb2e8f9f7	4	* @author MCD Application Team
AnnaBridge	167:e84263d55307	5	* @version V1.7.1
AnnaBridge	167:e84263d55307	6	* @date 21-April-2017
<>	144:ef7eb2e8f9f7	7	* @brief PCD HAL module driver.
<>	144:ef7eb2e8f9f7	8	* This file provides firmware functions to manage the following
<>	144:ef7eb2e8f9f7	9	* functionalities of the USB Peripheral Controller:
<>	144:ef7eb2e8f9f7	10	* + Initialization and de-initialization functions
<>	144:ef7eb2e8f9f7	11	* + IO operation functions
<>	144:ef7eb2e8f9f7	12	* + Peripheral Control functions
<>	144:ef7eb2e8f9f7	13	* + Peripheral State functions
<>	144:ef7eb2e8f9f7	14	*
<>	144:ef7eb2e8f9f7	15	@verbatim
<>	144:ef7eb2e8f9f7	16	==============================================================================
<>	144:ef7eb2e8f9f7	17	##### How to use this driver #####
<>	144:ef7eb2e8f9f7	18	==============================================================================
<>	144:ef7eb2e8f9f7	19	[..]
<>	144:ef7eb2e8f9f7	20	The PCD HAL driver can be used as follows:
<>	144:ef7eb2e8f9f7	21
<>	144:ef7eb2e8f9f7	22	(#) Declare a PCD_HandleTypeDef handle structure, for example:
<>	144:ef7eb2e8f9f7	23	PCD_HandleTypeDef hpcd;
<>	144:ef7eb2e8f9f7	24
<>	144:ef7eb2e8f9f7	25	(#) Fill parameters of Init structure in HCD handle
<>	144:ef7eb2e8f9f7	26
<>	144:ef7eb2e8f9f7	27	(#) Call HAL_PCD_Init() API to initialize the PCD peripheral (Core, Device core, ...)
<>	144:ef7eb2e8f9f7	28
<>	144:ef7eb2e8f9f7	29	(#) Initialize the PCD low level resources through the HAL_PCD_MspInit() API:
<>	144:ef7eb2e8f9f7	30	(##) Enable the PCD/USB Low Level interface clock using
<>	144:ef7eb2e8f9f7	31	(+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
<>	144:ef7eb2e8f9f7	32	(##) Initialize the related GPIO clocks
<>	144:ef7eb2e8f9f7	33	(##) Configure PCD pin-out
<>	144:ef7eb2e8f9f7	34	(##) Configure PCD NVIC interrupt
<>	144:ef7eb2e8f9f7	35
<>	144:ef7eb2e8f9f7	36	(#)Associate the Upper USB device stack to the HAL PCD Driver:
<>	144:ef7eb2e8f9f7	37	(##) hpcd.pData = pdev;
<>	144:ef7eb2e8f9f7	38
<>	144:ef7eb2e8f9f7	39	(#)Enable PCD transmission and reception:
<>	144:ef7eb2e8f9f7	40	(##) HAL_PCD_Start();
<>	144:ef7eb2e8f9f7	41
<>	144:ef7eb2e8f9f7	42	@endverbatim
<>	144:ef7eb2e8f9f7	43	******************************************************************************
<>	144:ef7eb2e8f9f7	44	* @attention
<>	144:ef7eb2e8f9f7	45	*
AnnaBridge	167:e84263d55307	46	* <h2><center>© COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
<>	144:ef7eb2e8f9f7	47	*
<>	144:ef7eb2e8f9f7	48	* Redistribution and use in source and binary forms, with or without modification,
<>	144:ef7eb2e8f9f7	49	* are permitted provided that the following conditions are met:
<>	144:ef7eb2e8f9f7	50	* 1. Redistributions of source code must retain the above copyright notice,
<>	144:ef7eb2e8f9f7	51	* this list of conditions and the following disclaimer.
<>	144:ef7eb2e8f9f7	52	* 2. Redistributions in binary form must reproduce the above copyright notice,
<>	144:ef7eb2e8f9f7	53	* this list of conditions and the following disclaimer in the documentation
<>	144:ef7eb2e8f9f7	54	* and/or other materials provided with the distribution.
<>	144:ef7eb2e8f9f7	55	* 3. Neither the name of STMicroelectronics nor the names of its contributors
<>	144:ef7eb2e8f9f7	56	* may be used to endorse or promote products derived from this software
<>	144:ef7eb2e8f9f7	57	* without specific prior written permission.
<>	144:ef7eb2e8f9f7	58	*
<>	144:ef7eb2e8f9f7	59	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<>	144:ef7eb2e8f9f7	60	* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<>	144:ef7eb2e8f9f7	61	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<>	144:ef7eb2e8f9f7	62	* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<>	144:ef7eb2e8f9f7	63	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<>	144:ef7eb2e8f9f7	64	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<>	144:ef7eb2e8f9f7	65	* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<>	144:ef7eb2e8f9f7	66	* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<>	144:ef7eb2e8f9f7	67	* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<>	144:ef7eb2e8f9f7	68	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<>	144:ef7eb2e8f9f7	69	*
<>	144:ef7eb2e8f9f7	70	******************************************************************************
<>	144:ef7eb2e8f9f7	71	*/
<>	144:ef7eb2e8f9f7	72
<>	144:ef7eb2e8f9f7	73	/* Includes ------------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	74	#include "stm32l4xx_hal.h"
<>	144:ef7eb2e8f9f7	75
<>	144:ef7eb2e8f9f7	76	/** @addtogroup STM32L4xx_HAL_Driver
<>	144:ef7eb2e8f9f7	77	* @{
<>	144:ef7eb2e8f9f7	78	*/
<>	144:ef7eb2e8f9f7	79
<>	144:ef7eb2e8f9f7	80	/** @defgroup PCD PCD
<>	144:ef7eb2e8f9f7	81	* @brief PCD HAL module driver
<>	144:ef7eb2e8f9f7	82	* @{
<>	144:ef7eb2e8f9f7	83	*/
<>	144:ef7eb2e8f9f7	84
<>	144:ef7eb2e8f9f7	85	#ifdef HAL_PCD_MODULE_ENABLED
<>	144:ef7eb2e8f9f7	86
AnnaBridge	167:e84263d55307	87	#if defined(STM32L432xx) \|\| defined(STM32L433xx) \|\| defined(STM32L442xx) \|\| defined(STM32L443xx) \|\| \
AnnaBridge	167:e84263d55307	88	defined(STM32L452xx) \|\| defined(STM32L462xx) \|\| \
AnnaBridge	167:e84263d55307	89	defined(STM32L475xx) \|\| defined(STM32L476xx) \|\| defined(STM32L485xx) \|\| defined(STM32L486xx) \|\| \
AnnaBridge	167:e84263d55307	90	defined(STM32L496xx) \|\| defined(STM32L4A6xx)
AnnaBridge	167:e84263d55307	91
<>	144:ef7eb2e8f9f7	92	/* Private types -------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	93	/* Private variables ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	94	/* Private constants ---------------------------------------------------------*/
AnnaBridge	167:e84263d55307	95	/**
AnnaBridge	167:e84263d55307	96	* USB_OTG_CORE VERSION ID
AnnaBridge	167:e84263d55307	97	*/
AnnaBridge	167:e84263d55307	98	#define USB_OTG_CORE_ID_310A 0x4F54310A
AnnaBridge	167:e84263d55307	99	#define USB_OTG_CORE_ID_320A 0x4F54320A
AnnaBridge	167:e84263d55307	100
<>	144:ef7eb2e8f9f7	101	/* Private macros ------------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	102	/** @defgroup PCD_Private_Macros PCD Private Macros
<>	144:ef7eb2e8f9f7	103	* @{
<>	144:ef7eb2e8f9f7	104	*/
<>	144:ef7eb2e8f9f7	105	#define PCD_MIN(a, b) (((a) < (b)) ? (a) : (b))
<>	144:ef7eb2e8f9f7	106	#define PCD_MAX(a, b) (((a) > (b)) ? (a) : (b))
<>	144:ef7eb2e8f9f7	107	/**
<>	144:ef7eb2e8f9f7	108	* @}
<>	144:ef7eb2e8f9f7	109	*/
<>	144:ef7eb2e8f9f7	110
<>	144:ef7eb2e8f9f7	111	/* Private functions prototypes ----------------------------------------------*/
<>	144:ef7eb2e8f9f7	112	/** @defgroup PCD_Private_Functions PCD Private Functions
<>	144:ef7eb2e8f9f7	113	* @{
<>	144:ef7eb2e8f9f7	114	*/
<>	144:ef7eb2e8f9f7	115	#if defined (USB_OTG_FS)
<>	144:ef7eb2e8f9f7	116	static HAL_StatusTypeDef PCD_WriteEmptyTxFifo(PCD_HandleTypeDef *hpcd, uint32_t epnum);
<>	144:ef7eb2e8f9f7	117	#endif /* USB_OTG_FS */
<>	144:ef7eb2e8f9f7	118	#if defined (USB)
<>	144:ef7eb2e8f9f7	119	static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd);
<>	144:ef7eb2e8f9f7	120	#endif /* USB */
<>	144:ef7eb2e8f9f7	121	/**
<>	144:ef7eb2e8f9f7	122	* @}
<>	144:ef7eb2e8f9f7	123	*/
<>	144:ef7eb2e8f9f7	124
<>	144:ef7eb2e8f9f7	125	/* Exported functions --------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	126	/** @defgroup PCD_Exported_Functions PCD Exported Functions
<>	144:ef7eb2e8f9f7	127	* @{
<>	144:ef7eb2e8f9f7	128	*/
<>	144:ef7eb2e8f9f7	129
<>	144:ef7eb2e8f9f7	130	/** @defgroup PCD_Exported_Functions_Group1 Initialization and de-initialization functions
<>	144:ef7eb2e8f9f7	131	* @brief Initialization and Configuration functions
<>	144:ef7eb2e8f9f7	132	*
<>	144:ef7eb2e8f9f7	133	@verbatim
<>	144:ef7eb2e8f9f7	134	===============================================================================
<>	144:ef7eb2e8f9f7	135	##### Initialization and de-initialization functions #####
<>	144:ef7eb2e8f9f7	136	===============================================================================
<>	144:ef7eb2e8f9f7	137	[..] This section provides functions allowing to:
<>	144:ef7eb2e8f9f7	138
<>	144:ef7eb2e8f9f7	139	@endverbatim
<>	144:ef7eb2e8f9f7	140	* @{
<>	144:ef7eb2e8f9f7	141	*/
<>	144:ef7eb2e8f9f7	142
<>	144:ef7eb2e8f9f7	143	/**
<>	144:ef7eb2e8f9f7	144	* @brief Initializes the PCD according to the specified
<>	144:ef7eb2e8f9f7	145	* parameters in the PCD_InitTypeDef and initialize the associated handle.
<>	144:ef7eb2e8f9f7	146	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	147	* @retval HAL status
<>	144:ef7eb2e8f9f7	148	*/
<>	144:ef7eb2e8f9f7	149	HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	150	{
AnnaBridge	167:e84263d55307	151	uint32_t index = 0U;
<>	144:ef7eb2e8f9f7	152
<>	144:ef7eb2e8f9f7	153	/* Check the PCD handle allocation */
<>	144:ef7eb2e8f9f7	154	if(hpcd == NULL)
<>	144:ef7eb2e8f9f7	155	{
<>	144:ef7eb2e8f9f7	156	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	157	}
<>	144:ef7eb2e8f9f7	158
<>	144:ef7eb2e8f9f7	159	/* Check the parameters */
<>	144:ef7eb2e8f9f7	160	assert_param(IS_PCD_ALL_INSTANCE(hpcd->Instance));
<>	144:ef7eb2e8f9f7	161
<>	144:ef7eb2e8f9f7	162	if(hpcd->State == HAL_PCD_STATE_RESET)
<>	144:ef7eb2e8f9f7	163	{
<>	144:ef7eb2e8f9f7	164	/* Allocate lock resource and initialize it */
<>	144:ef7eb2e8f9f7	165	hpcd->Lock = HAL_UNLOCKED;
<>	153:fa9ff456f731	166	for (index = 0; index < hpcd->Init.dev_endpoints ; index++)
<>	153:fa9ff456f731	167	hpcd->EPLock[index].Lock = HAL_UNLOCKED;
<>	144:ef7eb2e8f9f7	168	/* Init the low level hardware : GPIO, CLOCK, NVIC... */
<>	144:ef7eb2e8f9f7	169	HAL_PCD_MspInit(hpcd);
<>	144:ef7eb2e8f9f7	170	}
<>	144:ef7eb2e8f9f7	171
<>	144:ef7eb2e8f9f7	172	hpcd->State = HAL_PCD_STATE_BUSY;
<>	144:ef7eb2e8f9f7	173
<>	144:ef7eb2e8f9f7	174	/* Disable the Interrupts */
<>	144:ef7eb2e8f9f7	175	__HAL_PCD_DISABLE(hpcd);
<>	144:ef7eb2e8f9f7	176
<>	144:ef7eb2e8f9f7	177	/Init the Core (common init.) /
<>	144:ef7eb2e8f9f7	178	USB_CoreInit(hpcd->Instance, hpcd->Init);
<>	144:ef7eb2e8f9f7	179
<>	144:ef7eb2e8f9f7	180	/* Force Device Mode*/
<>	144:ef7eb2e8f9f7	181	USB_SetCurrentMode(hpcd->Instance , USB_DEVICE_MODE);
<>	144:ef7eb2e8f9f7	182
<>	144:ef7eb2e8f9f7	183	/* Init endpoints structures */
<>	144:ef7eb2e8f9f7	184	for (index = 0; index < hpcd->Init.dev_endpoints ; index++)
<>	144:ef7eb2e8f9f7	185	{
<>	144:ef7eb2e8f9f7	186	/* Init ep structure */
<>	144:ef7eb2e8f9f7	187	hpcd->IN_ep[index].is_in = 1;
<>	144:ef7eb2e8f9f7	188	hpcd->IN_ep[index].num = index;
<>	144:ef7eb2e8f9f7	189	hpcd->IN_ep[index].tx_fifo_num = index;
<>	144:ef7eb2e8f9f7	190	/* Control until ep is activated */
<>	144:ef7eb2e8f9f7	191	hpcd->IN_ep[index].type = EP_TYPE_CTRL;
<>	144:ef7eb2e8f9f7	192	hpcd->IN_ep[index].maxpacket = 0;
<>	144:ef7eb2e8f9f7	193	hpcd->IN_ep[index].xfer_buff = 0;
<>	144:ef7eb2e8f9f7	194	hpcd->IN_ep[index].xfer_len = 0;
<>	144:ef7eb2e8f9f7	195	}
<>	144:ef7eb2e8f9f7	196
<>	144:ef7eb2e8f9f7	197	for (index = 0; index < 15 ; index++)
<>	144:ef7eb2e8f9f7	198	{
<>	144:ef7eb2e8f9f7	199	hpcd->OUT_ep[index].is_in = 0;
<>	144:ef7eb2e8f9f7	200	hpcd->OUT_ep[index].num = index;
<>	144:ef7eb2e8f9f7	201	hpcd->IN_ep[index].tx_fifo_num = index;
<>	144:ef7eb2e8f9f7	202	/* Control until ep is activated */
<>	144:ef7eb2e8f9f7	203	hpcd->OUT_ep[index].type = EP_TYPE_CTRL;
<>	144:ef7eb2e8f9f7	204	hpcd->OUT_ep[index].maxpacket = 0;
<>	144:ef7eb2e8f9f7	205	hpcd->OUT_ep[index].xfer_buff = 0;
<>	144:ef7eb2e8f9f7	206	hpcd->OUT_ep[index].xfer_len = 0;
<>	144:ef7eb2e8f9f7	207	}
AnnaBridge	167:e84263d55307	208
<>	144:ef7eb2e8f9f7	209	/* Init Device */
<>	144:ef7eb2e8f9f7	210	USB_DevInit(hpcd->Instance, hpcd->Init);
<>	144:ef7eb2e8f9f7	211
<>	144:ef7eb2e8f9f7	212	hpcd->USB_Address = 0;
<>	144:ef7eb2e8f9f7	213
<>	144:ef7eb2e8f9f7	214	hpcd->State= HAL_PCD_STATE_READY;
<>	144:ef7eb2e8f9f7	215
<>	144:ef7eb2e8f9f7	216	/* Activate LPM */
<>	144:ef7eb2e8f9f7	217	if (hpcd->Init.lpm_enable ==1)
<>	144:ef7eb2e8f9f7	218	{
<>	144:ef7eb2e8f9f7	219	HAL_PCDEx_ActivateLPM(hpcd);
<>	144:ef7eb2e8f9f7	220	}
<>	144:ef7eb2e8f9f7	221	/* Activate Battery charging */
<>	144:ef7eb2e8f9f7	222	if (hpcd->Init.battery_charging_enable ==1)
<>	144:ef7eb2e8f9f7	223	{
<>	144:ef7eb2e8f9f7	224	HAL_PCDEx_ActivateBCD(hpcd);
<>	144:ef7eb2e8f9f7	225	}
<>	144:ef7eb2e8f9f7	226	USB_DevDisconnect (hpcd->Instance);
<>	144:ef7eb2e8f9f7	227	return HAL_OK;
<>	144:ef7eb2e8f9f7	228	}
<>	144:ef7eb2e8f9f7	229
<>	144:ef7eb2e8f9f7	230	/**
<>	144:ef7eb2e8f9f7	231	* @brief DeInitializes the PCD peripheral.
<>	144:ef7eb2e8f9f7	232	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	233	* @retval HAL status
<>	144:ef7eb2e8f9f7	234	*/
<>	144:ef7eb2e8f9f7	235	HAL_StatusTypeDef HAL_PCD_DeInit(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	236	{
<>	144:ef7eb2e8f9f7	237	/* Check the PCD handle allocation */
<>	144:ef7eb2e8f9f7	238	if(hpcd == NULL)
<>	144:ef7eb2e8f9f7	239	{
<>	144:ef7eb2e8f9f7	240	return HAL_ERROR;
<>	144:ef7eb2e8f9f7	241	}
<>	144:ef7eb2e8f9f7	242
<>	144:ef7eb2e8f9f7	243	hpcd->State = HAL_PCD_STATE_BUSY;
<>	144:ef7eb2e8f9f7	244
<>	144:ef7eb2e8f9f7	245	/* Stop Device */
<>	144:ef7eb2e8f9f7	246	HAL_PCD_Stop(hpcd);
<>	144:ef7eb2e8f9f7	247
<>	144:ef7eb2e8f9f7	248	/* DeInit the low level hardware */
<>	144:ef7eb2e8f9f7	249	HAL_PCD_MspDeInit(hpcd);
<>	144:ef7eb2e8f9f7	250
<>	144:ef7eb2e8f9f7	251	hpcd->State = HAL_PCD_STATE_RESET;
<>	144:ef7eb2e8f9f7	252
<>	144:ef7eb2e8f9f7	253	return HAL_OK;
<>	144:ef7eb2e8f9f7	254	}
<>	144:ef7eb2e8f9f7	255
<>	144:ef7eb2e8f9f7	256	/**
<>	144:ef7eb2e8f9f7	257	* @brief Initializes the PCD MSP.
<>	144:ef7eb2e8f9f7	258	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	259	* @retval None
<>	144:ef7eb2e8f9f7	260	*/
<>	144:ef7eb2e8f9f7	261	__weak void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	262	{
<>	144:ef7eb2e8f9f7	263	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	264	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	265
<>	144:ef7eb2e8f9f7	266	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	267	the HAL_PCD_MspInit could be implemented in the user file
<>	144:ef7eb2e8f9f7	268	*/
<>	144:ef7eb2e8f9f7	269	}
<>	144:ef7eb2e8f9f7	270
<>	144:ef7eb2e8f9f7	271	/**
<>	144:ef7eb2e8f9f7	272	* @brief DeInitializes PCD MSP.
<>	144:ef7eb2e8f9f7	273	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	274	* @retval None
<>	144:ef7eb2e8f9f7	275	*/
<>	144:ef7eb2e8f9f7	276	__weak void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	277	{
<>	144:ef7eb2e8f9f7	278	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	279	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	280
<>	144:ef7eb2e8f9f7	281	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	282	the HAL_PCD_MspDeInit could be implemented in the user file
<>	144:ef7eb2e8f9f7	283	*/
<>	144:ef7eb2e8f9f7	284	}
<>	144:ef7eb2e8f9f7	285
<>	144:ef7eb2e8f9f7	286	/**
<>	144:ef7eb2e8f9f7	287	* @}
<>	144:ef7eb2e8f9f7	288	*/
<>	144:ef7eb2e8f9f7	289
<>	144:ef7eb2e8f9f7	290	/** @defgroup PCD_Exported_Functions_Group2 Input and Output operation functions
<>	144:ef7eb2e8f9f7	291	* @brief Data transfers functions
<>	144:ef7eb2e8f9f7	292	*
<>	144:ef7eb2e8f9f7	293	@verbatim
<>	144:ef7eb2e8f9f7	294	===============================================================================
<>	144:ef7eb2e8f9f7	295	##### IO operation functions #####
<>	144:ef7eb2e8f9f7	296	===============================================================================
<>	144:ef7eb2e8f9f7	297	[..]
<>	144:ef7eb2e8f9f7	298	This subsection provides a set of functions allowing to manage the PCD data
<>	144:ef7eb2e8f9f7	299	transfers.
<>	144:ef7eb2e8f9f7	300
<>	144:ef7eb2e8f9f7	301	@endverbatim
<>	144:ef7eb2e8f9f7	302	* @{
<>	144:ef7eb2e8f9f7	303	*/
<>	144:ef7eb2e8f9f7	304
<>	144:ef7eb2e8f9f7	305	/**
<>	144:ef7eb2e8f9f7	306	* @brief Start The USB OTG Device.
<>	144:ef7eb2e8f9f7	307	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	308	* @retval HAL status
<>	144:ef7eb2e8f9f7	309	*/
<>	144:ef7eb2e8f9f7	310	HAL_StatusTypeDef HAL_PCD_Start(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	311	{
<>	144:ef7eb2e8f9f7	312	__HAL_LOCK(hpcd);
<>	144:ef7eb2e8f9f7	313	USB_DevConnect (hpcd->Instance);
<>	144:ef7eb2e8f9f7	314	__HAL_PCD_ENABLE(hpcd);
<>	144:ef7eb2e8f9f7	315	__HAL_UNLOCK(hpcd);
<>	144:ef7eb2e8f9f7	316	return HAL_OK;
<>	144:ef7eb2e8f9f7	317	}
<>	144:ef7eb2e8f9f7	318
<>	144:ef7eb2e8f9f7	319	/**
<>	144:ef7eb2e8f9f7	320	* @brief Stop The USB OTG Device.
<>	144:ef7eb2e8f9f7	321	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	322	* @retval HAL status
<>	144:ef7eb2e8f9f7	323	*/
<>	144:ef7eb2e8f9f7	324	HAL_StatusTypeDef HAL_PCD_Stop(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	325	{
<>	144:ef7eb2e8f9f7	326	__HAL_LOCK(hpcd);
<>	144:ef7eb2e8f9f7	327	__HAL_PCD_DISABLE(hpcd);
<>	144:ef7eb2e8f9f7	328	USB_StopDevice(hpcd->Instance);
<>	144:ef7eb2e8f9f7	329	USB_DevDisconnect (hpcd->Instance);
<>	144:ef7eb2e8f9f7	330	__HAL_UNLOCK(hpcd);
<>	144:ef7eb2e8f9f7	331	return HAL_OK;
<>	144:ef7eb2e8f9f7	332	}
<>	144:ef7eb2e8f9f7	333	#if defined (USB_OTG_FS)
<>	144:ef7eb2e8f9f7	334	/**
<>	144:ef7eb2e8f9f7	335	* @brief Handles PCD interrupt request.
<>	144:ef7eb2e8f9f7	336	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	337	* @retval HAL status
<>	144:ef7eb2e8f9f7	338	*/
<>	144:ef7eb2e8f9f7	339	void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	340	{
<>	144:ef7eb2e8f9f7	341	USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
AnnaBridge	167:e84263d55307	342	uint32_t index = 0U, ep_intr = 0U, epint = 0U, epnum = 0U;
AnnaBridge	167:e84263d55307	343	uint32_t fifoemptymsk = 0U, temp = 0U;
<>	144:ef7eb2e8f9f7	344	USB_OTG_EPTypeDef *ep = NULL;
<>	144:ef7eb2e8f9f7	345	uint32_t hclk = 80000000;
<>	144:ef7eb2e8f9f7	346
<>	144:ef7eb2e8f9f7	347	/* ensure that we are in device mode */
<>	144:ef7eb2e8f9f7	348	if (USB_GetMode(hpcd->Instance) == USB_OTG_MODE_DEVICE)
<>	144:ef7eb2e8f9f7	349	{
<>	144:ef7eb2e8f9f7	350	/* avoid spurious interrupt */
<>	144:ef7eb2e8f9f7	351	if(__HAL_PCD_IS_INVALID_INTERRUPT(hpcd))
<>	144:ef7eb2e8f9f7	352	{
<>	144:ef7eb2e8f9f7	353	return;
<>	144:ef7eb2e8f9f7	354	}
<>	144:ef7eb2e8f9f7	355
<>	144:ef7eb2e8f9f7	356	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_MMIS))
<>	144:ef7eb2e8f9f7	357	{
<>	144:ef7eb2e8f9f7	358	/* incorrect mode, acknowledge the interrupt */
<>	144:ef7eb2e8f9f7	359	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_MMIS);
<>	144:ef7eb2e8f9f7	360	}
<>	144:ef7eb2e8f9f7	361
<>	144:ef7eb2e8f9f7	362	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OEPINT))
<>	144:ef7eb2e8f9f7	363	{
<>	144:ef7eb2e8f9f7	364	epnum = 0;
<>	144:ef7eb2e8f9f7	365
<>	144:ef7eb2e8f9f7	366	/* Read in the device interrupt bits */
<>	144:ef7eb2e8f9f7	367	ep_intr = USB_ReadDevAllOutEpInterrupt(hpcd->Instance);
<>	144:ef7eb2e8f9f7	368
AnnaBridge	167:e84263d55307	369	while (ep_intr)
<>	144:ef7eb2e8f9f7	370	{
<>	144:ef7eb2e8f9f7	371	if (ep_intr & 0x1)
<>	144:ef7eb2e8f9f7	372	{
<>	144:ef7eb2e8f9f7	373	epint = USB_ReadDevOutEPInterrupt(hpcd->Instance, epnum);
<>	144:ef7eb2e8f9f7	374
AnnaBridge	167:e84263d55307	375	if (( epint & USB_OTG_DOEPINT_XFRC) == USB_OTG_DOEPINT_XFRC)
<>	144:ef7eb2e8f9f7	376	{
<>	144:ef7eb2e8f9f7	377	CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_XFRC);
AnnaBridge	167:e84263d55307	378
AnnaBridge	167:e84263d55307	379	/* setup/out transaction management for Core ID 310A */
AnnaBridge	167:e84263d55307	380	if (USBx->GSNPSID == USB_OTG_CORE_ID_310A)
<>	144:ef7eb2e8f9f7	381	{
AnnaBridge	167:e84263d55307	382	if (!(USBx_OUTEP(0)->DOEPINT & (0x1 << 15)))
AnnaBridge	167:e84263d55307	383	{
AnnaBridge	167:e84263d55307	384	if (hpcd->Init.dma_enable == 1)
AnnaBridge	167:e84263d55307	385	{
AnnaBridge	167:e84263d55307	386	hpcd->OUT_ep[epnum].xfer_count =
AnnaBridge	167:e84263d55307	387	hpcd->OUT_ep[epnum].maxpacket -
AnnaBridge	167:e84263d55307	388	(USBx_OUTEP(epnum)->DOEPTSIZ & USB_OTG_DOEPTSIZ_XFRSIZ);
AnnaBridge	167:e84263d55307	389
AnnaBridge	167:e84263d55307	390	hpcd->OUT_ep[epnum].xfer_buff +=
AnnaBridge	167:e84263d55307	391	hpcd->OUT_ep[epnum].maxpacket;
AnnaBridge	167:e84263d55307	392	}
AnnaBridge	167:e84263d55307	393
AnnaBridge	167:e84263d55307	394	HAL_PCD_DataOutStageCallback(hpcd, epnum);
AnnaBridge	167:e84263d55307	395
AnnaBridge	167:e84263d55307	396	if (hpcd->Init.dma_enable == 1)
AnnaBridge	167:e84263d55307	397	{
AnnaBridge	167:e84263d55307	398	if (!epnum && !hpcd->OUT_ep[epnum].xfer_len)
AnnaBridge	167:e84263d55307	399	{
AnnaBridge	167:e84263d55307	400	/* this is ZLP, so prepare EP0 for next setup */
AnnaBridge	167:e84263d55307	401	USB_EP0_OutStart(hpcd->Instance, 1, (uint8_t *)hpcd->Setup);
AnnaBridge	167:e84263d55307	402	}
AnnaBridge	167:e84263d55307	403	}
AnnaBridge	167:e84263d55307	404	}
AnnaBridge	167:e84263d55307	405
AnnaBridge	167:e84263d55307	406	/* Clear the SetPktRcvd flag*/
AnnaBridge	167:e84263d55307	407	USBx_OUTEP(0)->DOEPINT \|= (0x1 << 15) \| (0x1 << 5);
AnnaBridge	167:e84263d55307	408	}
AnnaBridge	167:e84263d55307	409	else
AnnaBridge	167:e84263d55307	410	{
AnnaBridge	167:e84263d55307	411	if (hpcd->Init.dma_enable == 1)
<>	144:ef7eb2e8f9f7	412	{
AnnaBridge	167:e84263d55307	413	hpcd->OUT_ep[epnum].xfer_count =
AnnaBridge	167:e84263d55307	414	hpcd->OUT_ep[epnum].maxpacket -
AnnaBridge	167:e84263d55307	415	(USBx_OUTEP(epnum)->DOEPTSIZ & USB_OTG_DOEPTSIZ_XFRSIZ);
AnnaBridge	167:e84263d55307	416	hpcd->OUT_ep[epnum].xfer_buff += hpcd->OUT_ep[epnum].maxpacket;
<>	144:ef7eb2e8f9f7	417	}
AnnaBridge	167:e84263d55307	418
<>	144:ef7eb2e8f9f7	419	HAL_PCD_DataOutStageCallback(hpcd, epnum);
AnnaBridge	167:e84263d55307	420
AnnaBridge	167:e84263d55307	421	if (hpcd->Init.dma_enable == 1)
<>	144:ef7eb2e8f9f7	422	{
AnnaBridge	167:e84263d55307	423	if (!epnum && !hpcd->OUT_ep[epnum].xfer_len)
<>	144:ef7eb2e8f9f7	424	{
<>	144:ef7eb2e8f9f7	425	/* this is ZLP, so prepare EP0 for next setup */
<>	144:ef7eb2e8f9f7	426	USB_EP0_OutStart(hpcd->Instance, 1, (uint8_t *)hpcd->Setup);
AnnaBridge	167:e84263d55307	427	}
<>	144:ef7eb2e8f9f7	428	}
<>	144:ef7eb2e8f9f7	429	}
<>	144:ef7eb2e8f9f7	430	}
AnnaBridge	167:e84263d55307	431
<>	144:ef7eb2e8f9f7	432	if(( epint & USB_OTG_DOEPINT_STUP) == USB_OTG_DOEPINT_STUP)
<>	144:ef7eb2e8f9f7	433	{
<>	144:ef7eb2e8f9f7	434	/* Inform the upper layer that a setup packet is available */
<>	144:ef7eb2e8f9f7	435	HAL_PCD_SetupStageCallback(hpcd);
<>	144:ef7eb2e8f9f7	436	CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_STUP);
<>	144:ef7eb2e8f9f7	437	}
<>	144:ef7eb2e8f9f7	438
<>	144:ef7eb2e8f9f7	439	if(( epint & USB_OTG_DOEPINT_OTEPDIS) == USB_OTG_DOEPINT_OTEPDIS)
<>	144:ef7eb2e8f9f7	440	{
<>	144:ef7eb2e8f9f7	441	CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPDIS);
<>	144:ef7eb2e8f9f7	442	}
AnnaBridge	167:e84263d55307	443
AnnaBridge	167:e84263d55307	444	#ifdef USB_OTG_DOEPINT_OTEPSPR
AnnaBridge	167:e84263d55307	445	/* Clear Status Phase Received interrupt */
AnnaBridge	167:e84263d55307	446	if(( epint & USB_OTG_DOEPINT_OTEPSPR) == USB_OTG_DOEPINT_OTEPSPR)
AnnaBridge	167:e84263d55307	447	{
AnnaBridge	167:e84263d55307	448	CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPSPR);
AnnaBridge	167:e84263d55307	449	}
AnnaBridge	167:e84263d55307	450	#endif /* USB_OTG_DOEPINT_OTEPSPR */
<>	144:ef7eb2e8f9f7	451	}
<>	144:ef7eb2e8f9f7	452	epnum++;
<>	144:ef7eb2e8f9f7	453	ep_intr >>= 1;
<>	144:ef7eb2e8f9f7	454	}
<>	144:ef7eb2e8f9f7	455	}
<>	144:ef7eb2e8f9f7	456
<>	144:ef7eb2e8f9f7	457	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IEPINT))
<>	144:ef7eb2e8f9f7	458	{
<>	144:ef7eb2e8f9f7	459	/* Read in the device interrupt bits */
<>	144:ef7eb2e8f9f7	460	ep_intr = USB_ReadDevAllInEpInterrupt(hpcd->Instance);
<>	144:ef7eb2e8f9f7	461
<>	144:ef7eb2e8f9f7	462	epnum = 0;
<>	144:ef7eb2e8f9f7	463
<>	144:ef7eb2e8f9f7	464	while ( ep_intr )
<>	144:ef7eb2e8f9f7	465	{
<>	144:ef7eb2e8f9f7	466	if (ep_intr & 0x1) /* In ITR */
<>	144:ef7eb2e8f9f7	467	{
<>	144:ef7eb2e8f9f7	468	epint = USB_ReadDevInEPInterrupt(hpcd->Instance, epnum);
<>	144:ef7eb2e8f9f7	469
<>	144:ef7eb2e8f9f7	470	if(( epint & USB_OTG_DIEPINT_XFRC) == USB_OTG_DIEPINT_XFRC)
<>	144:ef7eb2e8f9f7	471	{
<>	144:ef7eb2e8f9f7	472	fifoemptymsk = 0x1 << epnum;
<>	153:fa9ff456f731	473	atomic_clr_u32(&USBx_DEVICE->DIEPEMPMSK, fifoemptymsk);
<>	144:ef7eb2e8f9f7	474
<>	144:ef7eb2e8f9f7	475	CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_XFRC);
<>	144:ef7eb2e8f9f7	476
<>	144:ef7eb2e8f9f7	477	if (hpcd->Init.dma_enable == 1)
<>	144:ef7eb2e8f9f7	478	{
<>	144:ef7eb2e8f9f7	479	hpcd->IN_ep[epnum].xfer_buff += hpcd->IN_ep[epnum].maxpacket;
<>	144:ef7eb2e8f9f7	480	}
<>	144:ef7eb2e8f9f7	481
<>	144:ef7eb2e8f9f7	482	HAL_PCD_DataInStageCallback(hpcd, epnum);
<>	144:ef7eb2e8f9f7	483
<>	144:ef7eb2e8f9f7	484	if (hpcd->Init.dma_enable == 1)
<>	144:ef7eb2e8f9f7	485	{
<>	144:ef7eb2e8f9f7	486	/* this is ZLP, so prepare EP0 for next setup */
<>	144:ef7eb2e8f9f7	487	if((epnum == 0) && (hpcd->IN_ep[epnum].xfer_len == 0))
<>	144:ef7eb2e8f9f7	488	{
<>	144:ef7eb2e8f9f7	489	/* prepare to rx more setup packets */
<>	144:ef7eb2e8f9f7	490	USB_EP0_OutStart(hpcd->Instance, 1, (uint8_t *)hpcd->Setup);
<>	144:ef7eb2e8f9f7	491	}
<>	144:ef7eb2e8f9f7	492	}
<>	144:ef7eb2e8f9f7	493	}
<>	144:ef7eb2e8f9f7	494	if(( epint & USB_OTG_DIEPINT_TOC) == USB_OTG_DIEPINT_TOC)
<>	144:ef7eb2e8f9f7	495	{
<>	144:ef7eb2e8f9f7	496	CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_TOC);
<>	144:ef7eb2e8f9f7	497	}
<>	144:ef7eb2e8f9f7	498	if(( epint & USB_OTG_DIEPINT_ITTXFE) == USB_OTG_DIEPINT_ITTXFE)
<>	144:ef7eb2e8f9f7	499	{
<>	144:ef7eb2e8f9f7	500	CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_ITTXFE);
<>	144:ef7eb2e8f9f7	501	}
<>	144:ef7eb2e8f9f7	502	if(( epint & USB_OTG_DIEPINT_INEPNE) == USB_OTG_DIEPINT_INEPNE)
<>	144:ef7eb2e8f9f7	503	{
<>	144:ef7eb2e8f9f7	504	CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_INEPNE);
<>	144:ef7eb2e8f9f7	505	}
<>	144:ef7eb2e8f9f7	506	if(( epint & USB_OTG_DIEPINT_EPDISD) == USB_OTG_DIEPINT_EPDISD)
<>	144:ef7eb2e8f9f7	507	{
<>	144:ef7eb2e8f9f7	508	CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_EPDISD);
<>	144:ef7eb2e8f9f7	509	}
<>	144:ef7eb2e8f9f7	510	if(( epint & USB_OTG_DIEPINT_TXFE) == USB_OTG_DIEPINT_TXFE)
<>	144:ef7eb2e8f9f7	511	{
<>	144:ef7eb2e8f9f7	512	PCD_WriteEmptyTxFifo(hpcd , epnum);
<>	144:ef7eb2e8f9f7	513	}
<>	144:ef7eb2e8f9f7	514	}
<>	144:ef7eb2e8f9f7	515	epnum++;
<>	144:ef7eb2e8f9f7	516	ep_intr >>= 1;
<>	144:ef7eb2e8f9f7	517	}
<>	144:ef7eb2e8f9f7	518	}
<>	144:ef7eb2e8f9f7	519
<>	144:ef7eb2e8f9f7	520	/* Handle Resume Interrupt */
<>	144:ef7eb2e8f9f7	521	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT))
<>	144:ef7eb2e8f9f7	522	{
<>	144:ef7eb2e8f9f7	523	/* Clear the Remote Wake-up Signaling */
<>	144:ef7eb2e8f9f7	524	USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
<>	144:ef7eb2e8f9f7	525
<>	144:ef7eb2e8f9f7	526	if(hpcd->LPM_State == LPM_L1)
<>	144:ef7eb2e8f9f7	527	{
<>	144:ef7eb2e8f9f7	528	hpcd->LPM_State = LPM_L0;
<>	144:ef7eb2e8f9f7	529	HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L0_ACTIVE);
<>	144:ef7eb2e8f9f7	530	}
<>	144:ef7eb2e8f9f7	531	else
<>	144:ef7eb2e8f9f7	532	{
<>	144:ef7eb2e8f9f7	533	HAL_PCD_ResumeCallback(hpcd);
<>	144:ef7eb2e8f9f7	534	}
<>	144:ef7eb2e8f9f7	535
<>	144:ef7eb2e8f9f7	536	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT);
<>	144:ef7eb2e8f9f7	537	}
<>	144:ef7eb2e8f9f7	538
<>	144:ef7eb2e8f9f7	539	/* Handle Suspend Interrupt */
<>	144:ef7eb2e8f9f7	540	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP))
<>	144:ef7eb2e8f9f7	541	{
<>	144:ef7eb2e8f9f7	542	if((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)
<>	144:ef7eb2e8f9f7	543	{
<>	144:ef7eb2e8f9f7	544
<>	144:ef7eb2e8f9f7	545	HAL_PCD_SuspendCallback(hpcd);
<>	144:ef7eb2e8f9f7	546	}
<>	144:ef7eb2e8f9f7	547	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP);
<>	144:ef7eb2e8f9f7	548	}
<>	144:ef7eb2e8f9f7	549
<>	144:ef7eb2e8f9f7	550	/* Handle LPM Interrupt */
<>	144:ef7eb2e8f9f7	551	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_LPMINT))
<>	144:ef7eb2e8f9f7	552	{
<>	144:ef7eb2e8f9f7	553	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_LPMINT);
<>	144:ef7eb2e8f9f7	554	if( hpcd->LPM_State == LPM_L0)
<>	144:ef7eb2e8f9f7	555	{
<>	144:ef7eb2e8f9f7	556	hpcd->LPM_State = LPM_L1;
<>	144:ef7eb2e8f9f7	557	hpcd->BESL = (hpcd->Instance->GLPMCFG & USB_OTG_GLPMCFG_BESL) >>2 ;
<>	144:ef7eb2e8f9f7	558	HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L1_ACTIVE);
<>	144:ef7eb2e8f9f7	559	}
<>	144:ef7eb2e8f9f7	560	else
<>	144:ef7eb2e8f9f7	561	{
<>	144:ef7eb2e8f9f7	562	HAL_PCD_SuspendCallback(hpcd);
<>	144:ef7eb2e8f9f7	563	}
<>	144:ef7eb2e8f9f7	564	}
<>	144:ef7eb2e8f9f7	565
<>	144:ef7eb2e8f9f7	566	/* Handle Reset Interrupt */
<>	144:ef7eb2e8f9f7	567	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBRST))
<>	144:ef7eb2e8f9f7	568	{
<>	144:ef7eb2e8f9f7	569	USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;
AnnaBridge	167:e84263d55307	570	USB_FlushTxFifo(hpcd->Instance , 0x10);
<>	144:ef7eb2e8f9f7	571
<>	144:ef7eb2e8f9f7	572	for (index = 0; index < hpcd->Init.dev_endpoints ; index++)
<>	144:ef7eb2e8f9f7	573	{
<>	144:ef7eb2e8f9f7	574	USBx_INEP(index)->DIEPINT = 0xFF;
<>	144:ef7eb2e8f9f7	575	USBx_OUTEP(index)->DOEPINT = 0xFF;
<>	144:ef7eb2e8f9f7	576	}
<>	144:ef7eb2e8f9f7	577	USBx_DEVICE->DAINT = 0xFFFFFFFF;
<>	144:ef7eb2e8f9f7	578	USBx_DEVICE->DAINTMSK \|= 0x10001;
<>	144:ef7eb2e8f9f7	579
<>	144:ef7eb2e8f9f7	580	if(hpcd->Init.use_dedicated_ep1)
<>	144:ef7eb2e8f9f7	581	{
<>	144:ef7eb2e8f9f7	582	USBx_DEVICE->DOUTEP1MSK \|= (USB_OTG_DOEPMSK_STUPM \| USB_OTG_DOEPMSK_XFRCM \| USB_OTG_DOEPMSK_EPDM);
<>	144:ef7eb2e8f9f7	583	USBx_DEVICE->DINEP1MSK \|= (USB_OTG_DIEPMSK_TOM \| USB_OTG_DIEPMSK_XFRCM \| USB_OTG_DIEPMSK_EPDM);
<>	144:ef7eb2e8f9f7	584	}
<>	144:ef7eb2e8f9f7	585	else
<>	144:ef7eb2e8f9f7	586	{
AnnaBridge	167:e84263d55307	587	#ifdef USB_OTG_DOEPINT_OTEPSPR
AnnaBridge	167:e84263d55307	588	USBx_DEVICE->DOEPMSK \|= (USB_OTG_DOEPMSK_STUPM \| USB_OTG_DOEPMSK_XFRCM \| USB_OTG_DOEPMSK_EPDM \| USB_OTG_DOEPMSK_OTEPSPRM);
AnnaBridge	167:e84263d55307	589	#else
<>	144:ef7eb2e8f9f7	590	USBx_DEVICE->DOEPMSK \|= (USB_OTG_DOEPMSK_STUPM \| USB_OTG_DOEPMSK_XFRCM \| USB_OTG_DOEPMSK_EPDM);
AnnaBridge	167:e84263d55307	591	#endif /* USB_OTG_DOEPINT_OTEPSPR */
<>	144:ef7eb2e8f9f7	592	USBx_DEVICE->DIEPMSK \|= (USB_OTG_DIEPMSK_TOM \| USB_OTG_DIEPMSK_XFRCM \| USB_OTG_DIEPMSK_EPDM);
<>	144:ef7eb2e8f9f7	593	}
<>	144:ef7eb2e8f9f7	594
<>	144:ef7eb2e8f9f7	595	/* Set Default Address to 0 */
<>	144:ef7eb2e8f9f7	596	USBx_DEVICE->DCFG &= ~USB_OTG_DCFG_DAD;
<>	144:ef7eb2e8f9f7	597
<>	144:ef7eb2e8f9f7	598	/* setup EP0 to receive SETUP packets */
<>	144:ef7eb2e8f9f7	599	USB_EP0_OutStart(hpcd->Instance, hpcd->Init.dma_enable, (uint8_t *)hpcd->Setup);
<>	144:ef7eb2e8f9f7	600
<>	144:ef7eb2e8f9f7	601	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBRST);
<>	144:ef7eb2e8f9f7	602	}
<>	144:ef7eb2e8f9f7	603
<>	144:ef7eb2e8f9f7	604	/* Handle Enumeration done Interrupt */
<>	144:ef7eb2e8f9f7	605	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE))
<>	144:ef7eb2e8f9f7	606	{
<>	144:ef7eb2e8f9f7	607	USB_ActivateSetup(hpcd->Instance);
<>	144:ef7eb2e8f9f7	608	hpcd->Instance->GUSBCFG &= ~USB_OTG_GUSBCFG_TRDT;
<>	144:ef7eb2e8f9f7	609
<>	144:ef7eb2e8f9f7	610	hpcd->Init.speed = USB_OTG_SPEED_FULL;
<>	144:ef7eb2e8f9f7	611	hpcd->Init.ep0_mps = USB_OTG_FS_MAX_PACKET_SIZE ;
<>	144:ef7eb2e8f9f7	612
<>	144:ef7eb2e8f9f7	613	/* The USBTRD is configured according to the tables below, depending on AHB frequency
<>	144:ef7eb2e8f9f7	614	used by application. In the low AHB frequency range it is used to stretch enough the USB response
<>	144:ef7eb2e8f9f7	615	time to IN tokens, the USB turnaround time, so to compensate for the longer AHB read access
<>	144:ef7eb2e8f9f7	616	latency to the Data FIFO */
<>	144:ef7eb2e8f9f7	617
<>	144:ef7eb2e8f9f7	618	/* Get hclk frequency value */
<>	144:ef7eb2e8f9f7	619	hclk = HAL_RCC_GetHCLKFreq();
<>	144:ef7eb2e8f9f7	620
<>	144:ef7eb2e8f9f7	621	if((hclk >= 14200000)&&(hclk < 15000000))
<>	144:ef7eb2e8f9f7	622	{
<>	144:ef7eb2e8f9f7	623	/* hclk Clock Range between 14.2-15 MHz */
<>	144:ef7eb2e8f9f7	624	hpcd->Instance->GUSBCFG \|= (uint32_t)((0xF << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	625	}
<>	144:ef7eb2e8f9f7	626
<>	144:ef7eb2e8f9f7	627	else if((hclk >= 15000000)&&(hclk < 16000000))
<>	144:ef7eb2e8f9f7	628	{
<>	144:ef7eb2e8f9f7	629	/* hclk Clock Range between 15-16 MHz */
<>	144:ef7eb2e8f9f7	630	hpcd->Instance->GUSBCFG \|= (uint32_t)((0xE << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	631	}
<>	144:ef7eb2e8f9f7	632
<>	144:ef7eb2e8f9f7	633	else if((hclk >= 16000000)&&(hclk < 17200000))
<>	144:ef7eb2e8f9f7	634	{
<>	144:ef7eb2e8f9f7	635	/* hclk Clock Range between 16-17.2 MHz */
<>	144:ef7eb2e8f9f7	636	hpcd->Instance->GUSBCFG \|= (uint32_t)((0xD << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	637	}
<>	144:ef7eb2e8f9f7	638
<>	144:ef7eb2e8f9f7	639	else if((hclk >= 17200000)&&(hclk < 18500000))
<>	144:ef7eb2e8f9f7	640	{
<>	144:ef7eb2e8f9f7	641	/* hclk Clock Range between 17.2-18.5 MHz */
<>	144:ef7eb2e8f9f7	642	hpcd->Instance->GUSBCFG \|= (uint32_t)((0xC << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	643	}
<>	144:ef7eb2e8f9f7	644
<>	144:ef7eb2e8f9f7	645	else if((hclk >= 18500000)&&(hclk < 20000000))
<>	144:ef7eb2e8f9f7	646	{
<>	144:ef7eb2e8f9f7	647	/* hclk Clock Range between 18.5-20 MHz */
<>	144:ef7eb2e8f9f7	648	hpcd->Instance->GUSBCFG \|= (uint32_t)((0xB << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	649	}
<>	144:ef7eb2e8f9f7	650
<>	144:ef7eb2e8f9f7	651	else if((hclk >= 20000000)&&(hclk < 21800000))
<>	144:ef7eb2e8f9f7	652	{
<>	144:ef7eb2e8f9f7	653	/* hclk Clock Range between 20-21.8 MHz */
<>	144:ef7eb2e8f9f7	654	hpcd->Instance->GUSBCFG \|= (uint32_t)((0xA << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	655	}
<>	144:ef7eb2e8f9f7	656
<>	144:ef7eb2e8f9f7	657	else if((hclk >= 21800000)&&(hclk < 24000000))
<>	144:ef7eb2e8f9f7	658	{
<>	144:ef7eb2e8f9f7	659	/* hclk Clock Range between 21.8-24 MHz */
<>	144:ef7eb2e8f9f7	660	hpcd->Instance->GUSBCFG \|= (uint32_t)((0x9 << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	661	}
<>	144:ef7eb2e8f9f7	662
<>	144:ef7eb2e8f9f7	663	else if((hclk >= 24000000)&&(hclk < 27700000))
<>	144:ef7eb2e8f9f7	664	{
<>	144:ef7eb2e8f9f7	665	/* hclk Clock Range between 24-27.7 MHz */
<>	144:ef7eb2e8f9f7	666	hpcd->Instance->GUSBCFG \|= (uint32_t)((0x8 << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	667	}
<>	144:ef7eb2e8f9f7	668
<>	144:ef7eb2e8f9f7	669	else if((hclk >= 27700000)&&(hclk < 32000000))
<>	144:ef7eb2e8f9f7	670	{
<>	144:ef7eb2e8f9f7	671	/* hclk Clock Range between 27.7-32 MHz */
<>	144:ef7eb2e8f9f7	672	hpcd->Instance->GUSBCFG \|= (uint32_t)((0x7 << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	673	}
<>	144:ef7eb2e8f9f7	674
<>	144:ef7eb2e8f9f7	675	else /* if(hclk >= 32000000) */
<>	144:ef7eb2e8f9f7	676	{
<>	144:ef7eb2e8f9f7	677	/* hclk Clock Range between 32-80 MHz */
<>	144:ef7eb2e8f9f7	678	hpcd->Instance->GUSBCFG \|= (uint32_t)((0x6 << 10) & USB_OTG_GUSBCFG_TRDT);
<>	144:ef7eb2e8f9f7	679	}
<>	144:ef7eb2e8f9f7	680
<>	144:ef7eb2e8f9f7	681	HAL_PCD_ResetCallback(hpcd);
<>	144:ef7eb2e8f9f7	682
<>	144:ef7eb2e8f9f7	683	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE);
<>	144:ef7eb2e8f9f7	684	}
<>	144:ef7eb2e8f9f7	685
<>	144:ef7eb2e8f9f7	686	/* Handle RxQLevel Interrupt */
<>	144:ef7eb2e8f9f7	687	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_RXFLVL))
<>	144:ef7eb2e8f9f7	688	{
<>	144:ef7eb2e8f9f7	689	USB_MASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
<>	144:ef7eb2e8f9f7	690
<>	144:ef7eb2e8f9f7	691	temp = USBx->GRXSTSP;
<>	144:ef7eb2e8f9f7	692
<>	144:ef7eb2e8f9f7	693	ep = &hpcd->OUT_ep[temp & USB_OTG_GRXSTSP_EPNUM];
<>	144:ef7eb2e8f9f7	694
<>	144:ef7eb2e8f9f7	695	if(((temp & USB_OTG_GRXSTSP_PKTSTS) >> 17) == STS_DATA_UPDT)
<>	144:ef7eb2e8f9f7	696	{
<>	144:ef7eb2e8f9f7	697	if((temp & USB_OTG_GRXSTSP_BCNT) != 0)
<>	144:ef7eb2e8f9f7	698	{
<>	144:ef7eb2e8f9f7	699	USB_ReadPacket(USBx, ep->xfer_buff, (temp & USB_OTG_GRXSTSP_BCNT) >> 4);
<>	144:ef7eb2e8f9f7	700	ep->xfer_buff += (temp & USB_OTG_GRXSTSP_BCNT) >> 4;
<>	144:ef7eb2e8f9f7	701	ep->xfer_count += (temp & USB_OTG_GRXSTSP_BCNT) >> 4;
<>	144:ef7eb2e8f9f7	702	}
<>	144:ef7eb2e8f9f7	703	}
<>	144:ef7eb2e8f9f7	704	else if (((temp & USB_OTG_GRXSTSP_PKTSTS) >> 17) == STS_SETUP_UPDT)
<>	144:ef7eb2e8f9f7	705	{
<>	144:ef7eb2e8f9f7	706	USB_ReadPacket(USBx, (uint8_t *)hpcd->Setup, 8);
<>	144:ef7eb2e8f9f7	707	ep->xfer_count += (temp & USB_OTG_GRXSTSP_BCNT) >> 4;
<>	144:ef7eb2e8f9f7	708	}
<>	144:ef7eb2e8f9f7	709	USB_UNMASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);
<>	144:ef7eb2e8f9f7	710	}
<>	144:ef7eb2e8f9f7	711
<>	144:ef7eb2e8f9f7	712	/* Handle SOF Interrupt */
<>	144:ef7eb2e8f9f7	713	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SOF))
<>	144:ef7eb2e8f9f7	714	{
<>	144:ef7eb2e8f9f7	715	HAL_PCD_SOFCallback(hpcd);
<>	144:ef7eb2e8f9f7	716	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SOF);
<>	144:ef7eb2e8f9f7	717	}
<>	144:ef7eb2e8f9f7	718
<>	144:ef7eb2e8f9f7	719	/* Handle Incomplete ISO IN Interrupt */
<>	144:ef7eb2e8f9f7	720	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR))
<>	144:ef7eb2e8f9f7	721	{
<>	144:ef7eb2e8f9f7	722	HAL_PCD_ISOINIncompleteCallback(hpcd, epnum);
<>	144:ef7eb2e8f9f7	723	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR);
<>	144:ef7eb2e8f9f7	724	}
<>	144:ef7eb2e8f9f7	725
<>	144:ef7eb2e8f9f7	726	/* Handle Incomplete ISO OUT Interrupt */
<>	144:ef7eb2e8f9f7	727	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
<>	144:ef7eb2e8f9f7	728	{
<>	144:ef7eb2e8f9f7	729	HAL_PCD_ISOOUTIncompleteCallback(hpcd, epnum);
<>	144:ef7eb2e8f9f7	730	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
<>	144:ef7eb2e8f9f7	731	}
<>	144:ef7eb2e8f9f7	732
<>	144:ef7eb2e8f9f7	733	/* Handle Connection event Interrupt */
<>	144:ef7eb2e8f9f7	734	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT))
<>	144:ef7eb2e8f9f7	735	{
<>	144:ef7eb2e8f9f7	736	HAL_PCD_ConnectCallback(hpcd);
<>	144:ef7eb2e8f9f7	737	__HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT);
<>	144:ef7eb2e8f9f7	738	}
<>	144:ef7eb2e8f9f7	739
<>	144:ef7eb2e8f9f7	740	/* Handle Disconnection event Interrupt */
<>	144:ef7eb2e8f9f7	741	if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OTGINT))
<>	144:ef7eb2e8f9f7	742	{
<>	144:ef7eb2e8f9f7	743	temp = hpcd->Instance->GOTGINT;
<>	144:ef7eb2e8f9f7	744
<>	144:ef7eb2e8f9f7	745	if((temp & USB_OTG_GOTGINT_SEDET) == USB_OTG_GOTGINT_SEDET)
<>	144:ef7eb2e8f9f7	746	{
<>	144:ef7eb2e8f9f7	747	HAL_PCD_DisconnectCallback(hpcd);
<>	144:ef7eb2e8f9f7	748	}
<>	144:ef7eb2e8f9f7	749	hpcd->Instance->GOTGINT \|= temp;
<>	144:ef7eb2e8f9f7	750	}
<>	144:ef7eb2e8f9f7	751	}
<>	144:ef7eb2e8f9f7	752	}
<>	144:ef7eb2e8f9f7	753
<>	144:ef7eb2e8f9f7	754	#endif /* USB_OTG_FS */
<>	144:ef7eb2e8f9f7	755
<>	144:ef7eb2e8f9f7	756	#if defined (USB)
<>	144:ef7eb2e8f9f7	757	/**
<>	144:ef7eb2e8f9f7	758	* @brief This function handles PCD interrupt request.
<>	144:ef7eb2e8f9f7	759	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	760	* @retval HAL status
<>	144:ef7eb2e8f9f7	761	*/
<>	144:ef7eb2e8f9f7	762	void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	763	{
<>	144:ef7eb2e8f9f7	764	uint32_t wInterrupt_Mask = 0;
<>	144:ef7eb2e8f9f7	765
<>	144:ef7eb2e8f9f7	766	if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_CTR))
<>	144:ef7eb2e8f9f7	767	{
<>	144:ef7eb2e8f9f7	768	/* servicing of the endpoint correct transfer interrupt */
<>	144:ef7eb2e8f9f7	769	/* clear of the CTR flag into the sub */
<>	144:ef7eb2e8f9f7	770	PCD_EP_ISR_Handler(hpcd);
<>	144:ef7eb2e8f9f7	771	}
<>	144:ef7eb2e8f9f7	772
<>	144:ef7eb2e8f9f7	773	if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_RESET))
<>	144:ef7eb2e8f9f7	774	{
<>	144:ef7eb2e8f9f7	775	__HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_RESET);
<>	144:ef7eb2e8f9f7	776	HAL_PCD_ResetCallback(hpcd);
<>	144:ef7eb2e8f9f7	777	HAL_PCD_SetAddress(hpcd, 0);
<>	144:ef7eb2e8f9f7	778	}
<>	144:ef7eb2e8f9f7	779
<>	144:ef7eb2e8f9f7	780	if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_PMAOVR))
<>	144:ef7eb2e8f9f7	781	{
<>	144:ef7eb2e8f9f7	782	__HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_PMAOVR);
<>	144:ef7eb2e8f9f7	783	}
<>	144:ef7eb2e8f9f7	784
<>	144:ef7eb2e8f9f7	785	if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_ERR))
<>	144:ef7eb2e8f9f7	786	{
<>	144:ef7eb2e8f9f7	787	__HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ERR);
<>	144:ef7eb2e8f9f7	788	}
<>	144:ef7eb2e8f9f7	789
<>	144:ef7eb2e8f9f7	790	if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_WKUP))
<>	144:ef7eb2e8f9f7	791	{
<>	144:ef7eb2e8f9f7	792
<>	144:ef7eb2e8f9f7	793	hpcd->Instance->CNTR &= ~(USB_CNTR_LPMODE);
<>	144:ef7eb2e8f9f7	794
<>	144:ef7eb2e8f9f7	795	/set wInterrupt_Mask global variable/
<>	144:ef7eb2e8f9f7	796	wInterrupt_Mask = USB_CNTR_CTRM \| USB_CNTR_WKUPM \| USB_CNTR_SUSPM \| USB_CNTR_ERRM \
<>	144:ef7eb2e8f9f7	797	\| USB_CNTR_SOFM \| USB_CNTR_ESOFM \| USB_CNTR_RESETM;
<>	144:ef7eb2e8f9f7	798
<>	144:ef7eb2e8f9f7	799	/Set interrupt mask/
<>	144:ef7eb2e8f9f7	800	hpcd->Instance->CNTR = wInterrupt_Mask;
<>	144:ef7eb2e8f9f7	801
<>	144:ef7eb2e8f9f7	802	/* enable L1REQ interrupt */
<>	144:ef7eb2e8f9f7	803	if (hpcd->Init.lpm_enable ==1)
<>	144:ef7eb2e8f9f7	804	{
<>	144:ef7eb2e8f9f7	805	wInterrupt_Mask \|= USB_CNTR_L1REQM;
<>	144:ef7eb2e8f9f7	806
<>	144:ef7eb2e8f9f7	807	/* Enable LPM support and enable ACK answer to LPM request*/
<>	144:ef7eb2e8f9f7	808	USB_TypeDef *USBx = hpcd->Instance;
<>	144:ef7eb2e8f9f7	809	hpcd->lpm_active = ENABLE;
<>	144:ef7eb2e8f9f7	810	hpcd->LPM_State = LPM_L0;
<>	144:ef7eb2e8f9f7	811
<>	144:ef7eb2e8f9f7	812	USBx->LPMCSR \|= (USB_LPMCSR_LMPEN);
<>	144:ef7eb2e8f9f7	813	USBx->LPMCSR \|= (USB_LPMCSR_LPMACK);
<>	144:ef7eb2e8f9f7	814	}
<>	144:ef7eb2e8f9f7	815
<>	144:ef7eb2e8f9f7	816	if(hpcd->LPM_State == LPM_L1)
<>	144:ef7eb2e8f9f7	817	{
<>	144:ef7eb2e8f9f7	818	hpcd->LPM_State = LPM_L0;
<>	144:ef7eb2e8f9f7	819	HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L0_ACTIVE);
<>	144:ef7eb2e8f9f7	820	}
<>	144:ef7eb2e8f9f7	821
<>	144:ef7eb2e8f9f7	822	HAL_PCD_ResumeCallback(hpcd);
<>	144:ef7eb2e8f9f7	823
<>	144:ef7eb2e8f9f7	824	__HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_WKUP);
<>	144:ef7eb2e8f9f7	825	}
<>	144:ef7eb2e8f9f7	826
<>	144:ef7eb2e8f9f7	827	if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_SUSP))
<>	144:ef7eb2e8f9f7	828	{
<>	144:ef7eb2e8f9f7	829	/* clear of the ISTR bit must be done after setting of CNTR_FSUSP */
<>	144:ef7eb2e8f9f7	830	__HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SUSP);
<>	144:ef7eb2e8f9f7	831
<>	144:ef7eb2e8f9f7	832	/* Force low-power mode in the macrocell */
<>	144:ef7eb2e8f9f7	833	hpcd->Instance->CNTR \|= USB_CNTR_FSUSP;
<>	144:ef7eb2e8f9f7	834	hpcd->Instance->CNTR \|= USB_CNTR_LPMODE;
<>	144:ef7eb2e8f9f7	835
<>	144:ef7eb2e8f9f7	836	if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_WKUP) == 0)
<>	144:ef7eb2e8f9f7	837	{
<>	144:ef7eb2e8f9f7	838	HAL_PCD_SuspendCallback(hpcd);
<>	144:ef7eb2e8f9f7	839	}
<>	144:ef7eb2e8f9f7	840	}
<>	144:ef7eb2e8f9f7	841
<>	144:ef7eb2e8f9f7	842	/* Handle LPM Interrupt */
<>	144:ef7eb2e8f9f7	843	if(__HAL_PCD_GET_FLAG(hpcd, USB_ISTR_L1REQ))
<>	144:ef7eb2e8f9f7	844	{
<>	144:ef7eb2e8f9f7	845	__HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_L1REQ);
<>	144:ef7eb2e8f9f7	846	if( hpcd->LPM_State == LPM_L0)
<>	144:ef7eb2e8f9f7	847	{
<>	144:ef7eb2e8f9f7	848	/* Force suspend and low-power mode before going to L1 state*/
<>	144:ef7eb2e8f9f7	849	hpcd->Instance->CNTR \|= USB_CNTR_LPMODE;
<>	144:ef7eb2e8f9f7	850	hpcd->Instance->CNTR \|= USB_CNTR_FSUSP;
<>	144:ef7eb2e8f9f7	851
<>	144:ef7eb2e8f9f7	852	hpcd->LPM_State = LPM_L1;
<>	144:ef7eb2e8f9f7	853	hpcd->BESL = (hpcd->Instance->LPMCSR & USB_LPMCSR_BESL) >>2 ;
<>	144:ef7eb2e8f9f7	854	HAL_PCDEx_LPM_Callback(hpcd, PCD_LPM_L1_ACTIVE);
<>	144:ef7eb2e8f9f7	855	}
<>	144:ef7eb2e8f9f7	856	else
<>	144:ef7eb2e8f9f7	857	{
<>	144:ef7eb2e8f9f7	858	HAL_PCD_SuspendCallback(hpcd);
<>	144:ef7eb2e8f9f7	859	}
<>	144:ef7eb2e8f9f7	860	}
<>	144:ef7eb2e8f9f7	861
<>	144:ef7eb2e8f9f7	862	if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_SOF))
<>	144:ef7eb2e8f9f7	863	{
<>	144:ef7eb2e8f9f7	864	__HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SOF);
<>	144:ef7eb2e8f9f7	865	HAL_PCD_SOFCallback(hpcd);
<>	144:ef7eb2e8f9f7	866	}
<>	144:ef7eb2e8f9f7	867
<>	144:ef7eb2e8f9f7	868	if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_ESOF))
<>	144:ef7eb2e8f9f7	869	{
<>	144:ef7eb2e8f9f7	870	/* clear ESOF flag in ISTR */
<>	144:ef7eb2e8f9f7	871	__HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ESOF);
<>	144:ef7eb2e8f9f7	872	}
<>	144:ef7eb2e8f9f7	873	}
<>	144:ef7eb2e8f9f7	874	#endif /* USB */
<>	144:ef7eb2e8f9f7	875
<>	144:ef7eb2e8f9f7	876	/**
<>	144:ef7eb2e8f9f7	877	* @brief Data OUT stage callback.
<>	144:ef7eb2e8f9f7	878	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	879	* @param epnum: endpoint number
<>	144:ef7eb2e8f9f7	880	* @retval None
<>	144:ef7eb2e8f9f7	881	*/
<>	144:ef7eb2e8f9f7	882	__weak void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<>	144:ef7eb2e8f9f7	883	{
<>	144:ef7eb2e8f9f7	884	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	885	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	886	UNUSED(epnum);
<>	144:ef7eb2e8f9f7	887
<>	144:ef7eb2e8f9f7	888	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	889	the HAL_PCD_DataOutStageCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	890	*/
<>	144:ef7eb2e8f9f7	891	}
<>	144:ef7eb2e8f9f7	892
<>	144:ef7eb2e8f9f7	893	/**
<>	144:ef7eb2e8f9f7	894	* @brief Data IN stage callback.
<>	144:ef7eb2e8f9f7	895	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	896	* @param epnum: endpoint number
<>	144:ef7eb2e8f9f7	897	* @retval None
<>	144:ef7eb2e8f9f7	898	*/
<>	144:ef7eb2e8f9f7	899	__weak void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<>	144:ef7eb2e8f9f7	900	{
<>	144:ef7eb2e8f9f7	901	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	902	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	903	UNUSED(epnum);
<>	144:ef7eb2e8f9f7	904
<>	144:ef7eb2e8f9f7	905	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	906	the HAL_PCD_DataInStageCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	907	*/
<>	144:ef7eb2e8f9f7	908	}
<>	144:ef7eb2e8f9f7	909	/**
<>	144:ef7eb2e8f9f7	910	* @brief Setup stage callback.
<>	144:ef7eb2e8f9f7	911	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	912	* @retval None
<>	144:ef7eb2e8f9f7	913	*/
<>	144:ef7eb2e8f9f7	914	__weak void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	915	{
<>	144:ef7eb2e8f9f7	916	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	917	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	918
<>	144:ef7eb2e8f9f7	919	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	920	the HAL_PCD_SetupStageCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	921	*/
<>	144:ef7eb2e8f9f7	922	}
<>	144:ef7eb2e8f9f7	923
<>	144:ef7eb2e8f9f7	924	/**
<>	144:ef7eb2e8f9f7	925	* @brief USB Start Of Frame callback.
<>	144:ef7eb2e8f9f7	926	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	927	* @retval None
<>	144:ef7eb2e8f9f7	928	*/
<>	144:ef7eb2e8f9f7	929	__weak void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	930	{
<>	144:ef7eb2e8f9f7	931	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	932	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	933
<>	144:ef7eb2e8f9f7	934	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	935	the HAL_PCD_SOFCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	936	*/
<>	144:ef7eb2e8f9f7	937	}
<>	144:ef7eb2e8f9f7	938
<>	144:ef7eb2e8f9f7	939	/**
<>	144:ef7eb2e8f9f7	940	* @brief USB Reset callback.
<>	144:ef7eb2e8f9f7	941	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	942	* @retval None
<>	144:ef7eb2e8f9f7	943	*/
<>	144:ef7eb2e8f9f7	944	__weak void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	945	{
<>	144:ef7eb2e8f9f7	946	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	947	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	948
<>	144:ef7eb2e8f9f7	949	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	950	the HAL_PCD_ResetCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	951	*/
<>	144:ef7eb2e8f9f7	952	}
<>	144:ef7eb2e8f9f7	953
<>	144:ef7eb2e8f9f7	954	/**
<>	144:ef7eb2e8f9f7	955	* @brief Suspend event callback.
<>	144:ef7eb2e8f9f7	956	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	957	* @retval None
<>	144:ef7eb2e8f9f7	958	*/
<>	144:ef7eb2e8f9f7	959	__weak void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	960	{
<>	144:ef7eb2e8f9f7	961	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	962	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	963
<>	144:ef7eb2e8f9f7	964	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	965	the HAL_PCD_SuspendCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	966	*/
<>	144:ef7eb2e8f9f7	967	}
<>	144:ef7eb2e8f9f7	968
<>	144:ef7eb2e8f9f7	969	/**
<>	144:ef7eb2e8f9f7	970	* @brief Resume event callback.
<>	144:ef7eb2e8f9f7	971	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	972	* @retval None
<>	144:ef7eb2e8f9f7	973	*/
<>	144:ef7eb2e8f9f7	974	__weak void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	975	{
<>	144:ef7eb2e8f9f7	976	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	977	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	978
<>	144:ef7eb2e8f9f7	979	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	980	the HAL_PCD_ResumeCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	981	*/
<>	144:ef7eb2e8f9f7	982	}
<>	144:ef7eb2e8f9f7	983
<>	144:ef7eb2e8f9f7	984	/**
<>	144:ef7eb2e8f9f7	985	* @brief Incomplete ISO OUT callback.
<>	144:ef7eb2e8f9f7	986	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	987	* @param epnum: endpoint number
<>	144:ef7eb2e8f9f7	988	* @retval None
<>	144:ef7eb2e8f9f7	989	*/
<>	144:ef7eb2e8f9f7	990	__weak void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<>	144:ef7eb2e8f9f7	991	{
<>	144:ef7eb2e8f9f7	992	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	993	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	994	UNUSED(epnum);
<>	144:ef7eb2e8f9f7	995
<>	144:ef7eb2e8f9f7	996	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	997	the HAL_PCD_ISOOUTIncompleteCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	998	*/
<>	144:ef7eb2e8f9f7	999	}
<>	144:ef7eb2e8f9f7	1000
<>	144:ef7eb2e8f9f7	1001	/**
<>	144:ef7eb2e8f9f7	1002	* @brief Incomplete ISO IN callback.
<>	144:ef7eb2e8f9f7	1003	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1004	* @param epnum: endpoint number
<>	144:ef7eb2e8f9f7	1005	* @retval None
<>	144:ef7eb2e8f9f7	1006	*/
<>	144:ef7eb2e8f9f7	1007	__weak void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)
<>	144:ef7eb2e8f9f7	1008	{
<>	144:ef7eb2e8f9f7	1009	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1010	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	1011	UNUSED(epnum);
<>	144:ef7eb2e8f9f7	1012
<>	144:ef7eb2e8f9f7	1013	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1014	the HAL_PCD_ISOINIncompleteCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1015	*/
<>	144:ef7eb2e8f9f7	1016	}
<>	144:ef7eb2e8f9f7	1017
<>	144:ef7eb2e8f9f7	1018	/**
<>	144:ef7eb2e8f9f7	1019	* @brief Connection event callback.
<>	144:ef7eb2e8f9f7	1020	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1021	* @retval None
<>	144:ef7eb2e8f9f7	1022	*/
<>	144:ef7eb2e8f9f7	1023	__weak void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	1024	{
<>	144:ef7eb2e8f9f7	1025	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1026	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	1027
<>	144:ef7eb2e8f9f7	1028	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1029	the HAL_PCD_ConnectCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1030	*/
<>	144:ef7eb2e8f9f7	1031	}
<>	144:ef7eb2e8f9f7	1032
<>	144:ef7eb2e8f9f7	1033	/**
<>	144:ef7eb2e8f9f7	1034	* @brief Disconnection event callback.
<>	144:ef7eb2e8f9f7	1035	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1036	* @retval None
<>	144:ef7eb2e8f9f7	1037	*/
<>	144:ef7eb2e8f9f7	1038	__weak void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	1039	{
<>	144:ef7eb2e8f9f7	1040	/* Prevent unused argument(s) compilation warning */
<>	144:ef7eb2e8f9f7	1041	UNUSED(hpcd);
<>	144:ef7eb2e8f9f7	1042
<>	144:ef7eb2e8f9f7	1043	/* NOTE : This function should not be modified, when the callback is needed,
<>	144:ef7eb2e8f9f7	1044	the HAL_PCD_DisconnectCallback could be implemented in the user file
<>	144:ef7eb2e8f9f7	1045	*/
<>	144:ef7eb2e8f9f7	1046	}
<>	144:ef7eb2e8f9f7	1047
<>	144:ef7eb2e8f9f7	1048	/**
<>	144:ef7eb2e8f9f7	1049	* @}
<>	144:ef7eb2e8f9f7	1050	*/
<>	144:ef7eb2e8f9f7	1051
<>	144:ef7eb2e8f9f7	1052	/** @defgroup PCD_Exported_Functions_Group3 Peripheral Control functions
<>	144:ef7eb2e8f9f7	1053	* @brief management functions
<>	144:ef7eb2e8f9f7	1054	*
<>	144:ef7eb2e8f9f7	1055	@verbatim
<>	144:ef7eb2e8f9f7	1056	===============================================================================
<>	144:ef7eb2e8f9f7	1057	##### Peripheral Control functions #####
<>	144:ef7eb2e8f9f7	1058	===============================================================================
<>	144:ef7eb2e8f9f7	1059	[..]
<>	144:ef7eb2e8f9f7	1060	This subsection provides a set of functions allowing to control the PCD data
<>	144:ef7eb2e8f9f7	1061	transfers.
<>	144:ef7eb2e8f9f7	1062
<>	144:ef7eb2e8f9f7	1063	@endverbatim
<>	144:ef7eb2e8f9f7	1064	* @{
<>	144:ef7eb2e8f9f7	1065	*/
<>	144:ef7eb2e8f9f7	1066
<>	144:ef7eb2e8f9f7	1067	/**
<>	144:ef7eb2e8f9f7	1068	* @brief Connect the USB device.
<>	144:ef7eb2e8f9f7	1069	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1070	* @retval HAL status
<>	144:ef7eb2e8f9f7	1071	*/
<>	144:ef7eb2e8f9f7	1072	HAL_StatusTypeDef HAL_PCD_DevConnect(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	1073	{
<>	144:ef7eb2e8f9f7	1074	__HAL_LOCK(hpcd);
<>	144:ef7eb2e8f9f7	1075	USB_DevConnect(hpcd->Instance);
<>	144:ef7eb2e8f9f7	1076	__HAL_UNLOCK(hpcd);
<>	144:ef7eb2e8f9f7	1077	return HAL_OK;
<>	144:ef7eb2e8f9f7	1078	}
<>	144:ef7eb2e8f9f7	1079
<>	144:ef7eb2e8f9f7	1080	/**
<>	144:ef7eb2e8f9f7	1081	* @brief Disconnect the USB device.
<>	144:ef7eb2e8f9f7	1082	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1083	* @retval HAL status
<>	144:ef7eb2e8f9f7	1084	*/
<>	144:ef7eb2e8f9f7	1085	HAL_StatusTypeDef HAL_PCD_DevDisconnect(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	1086	{
<>	144:ef7eb2e8f9f7	1087	__HAL_LOCK(hpcd);
<>	144:ef7eb2e8f9f7	1088	USB_DevDisconnect(hpcd->Instance);
<>	144:ef7eb2e8f9f7	1089	__HAL_UNLOCK(hpcd);
<>	144:ef7eb2e8f9f7	1090	return HAL_OK;
<>	144:ef7eb2e8f9f7	1091	}
<>	144:ef7eb2e8f9f7	1092
<>	144:ef7eb2e8f9f7	1093	/**
<>	144:ef7eb2e8f9f7	1094	* @brief Set the USB Device address.
<>	144:ef7eb2e8f9f7	1095	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1096	* @param address: new device address
<>	144:ef7eb2e8f9f7	1097	* @retval HAL status
<>	144:ef7eb2e8f9f7	1098	*/
<>	144:ef7eb2e8f9f7	1099	HAL_StatusTypeDef HAL_PCD_SetAddress(PCD_HandleTypeDef *hpcd, uint8_t address)
<>	144:ef7eb2e8f9f7	1100	{
<>	144:ef7eb2e8f9f7	1101	__HAL_LOCK(hpcd);
<>	144:ef7eb2e8f9f7	1102	hpcd->USB_Address = address;
<>	144:ef7eb2e8f9f7	1103	USB_SetDevAddress(hpcd->Instance, address);
<>	144:ef7eb2e8f9f7	1104	__HAL_UNLOCK(hpcd);
<>	144:ef7eb2e8f9f7	1105	return HAL_OK;
<>	144:ef7eb2e8f9f7	1106	}
<>	144:ef7eb2e8f9f7	1107	/**
<>	144:ef7eb2e8f9f7	1108	* @brief Open and configure an endpoint.
<>	144:ef7eb2e8f9f7	1109	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1110	* @param ep_addr: endpoint address
<>	144:ef7eb2e8f9f7	1111	* @param ep_mps: endpoint max packet size
<>	144:ef7eb2e8f9f7	1112	* @param ep_type: endpoint type
<>	144:ef7eb2e8f9f7	1113	* @retval HAL status
<>	144:ef7eb2e8f9f7	1114	*/
<>	144:ef7eb2e8f9f7	1115	HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint16_t ep_mps, uint8_t ep_type)
<>	144:ef7eb2e8f9f7	1116	{
<>	144:ef7eb2e8f9f7	1117	HAL_StatusTypeDef ret = HAL_OK;
<>	144:ef7eb2e8f9f7	1118	PCD_EPTypeDef *ep = NULL;
<>	144:ef7eb2e8f9f7	1119
<>	144:ef7eb2e8f9f7	1120	if ((ep_addr & 0x80) == 0x80)
<>	144:ef7eb2e8f9f7	1121	{
<>	144:ef7eb2e8f9f7	1122	ep = &hpcd->IN_ep[ep_addr & 0x7F];
<>	144:ef7eb2e8f9f7	1123	}
<>	144:ef7eb2e8f9f7	1124	else
<>	144:ef7eb2e8f9f7	1125	{
<>	144:ef7eb2e8f9f7	1126	ep = &hpcd->OUT_ep[ep_addr & 0x7F];
<>	144:ef7eb2e8f9f7	1127	}
<>	144:ef7eb2e8f9f7	1128	ep->num = ep_addr & 0x7F;
<>	144:ef7eb2e8f9f7	1129
<>	144:ef7eb2e8f9f7	1130	ep->is_in = (0x80 & ep_addr) != 0;
<>	144:ef7eb2e8f9f7	1131	ep->maxpacket = ep_mps;
<>	144:ef7eb2e8f9f7	1132	ep->type = ep_type;
<>	144:ef7eb2e8f9f7	1133
<>	144:ef7eb2e8f9f7	1134	__HAL_LOCK(hpcd);
<>	144:ef7eb2e8f9f7	1135	USB_ActivateEndpoint(hpcd->Instance , ep);
<>	144:ef7eb2e8f9f7	1136	__HAL_UNLOCK(hpcd);
<>	144:ef7eb2e8f9f7	1137	return ret;
<>	144:ef7eb2e8f9f7	1138
<>	144:ef7eb2e8f9f7	1139	}
<>	144:ef7eb2e8f9f7	1140
<>	144:ef7eb2e8f9f7	1141
<>	144:ef7eb2e8f9f7	1142	/**
<>	144:ef7eb2e8f9f7	1143	* @brief Deactivate an endpoint.
<>	144:ef7eb2e8f9f7	1144	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1145	* @param ep_addr: endpoint address
<>	144:ef7eb2e8f9f7	1146	* @retval HAL status
<>	144:ef7eb2e8f9f7	1147	*/
<>	144:ef7eb2e8f9f7	1148	HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<>	144:ef7eb2e8f9f7	1149	{
<>	144:ef7eb2e8f9f7	1150	PCD_EPTypeDef *ep = NULL;
<>	144:ef7eb2e8f9f7	1151
<>	144:ef7eb2e8f9f7	1152	if ((ep_addr & 0x80) == 0x80)
<>	144:ef7eb2e8f9f7	1153	{
<>	144:ef7eb2e8f9f7	1154	ep = &hpcd->IN_ep[ep_addr & 0x7F];
<>	144:ef7eb2e8f9f7	1155	}
<>	144:ef7eb2e8f9f7	1156	else
<>	144:ef7eb2e8f9f7	1157	{
<>	144:ef7eb2e8f9f7	1158	ep = &hpcd->OUT_ep[ep_addr & 0x7F];
<>	144:ef7eb2e8f9f7	1159	}
<>	144:ef7eb2e8f9f7	1160	ep->num = ep_addr & 0x7F;
<>	144:ef7eb2e8f9f7	1161
<>	144:ef7eb2e8f9f7	1162	ep->is_in = (0x80 & ep_addr) != 0;
<>	144:ef7eb2e8f9f7	1163
<>	144:ef7eb2e8f9f7	1164	__HAL_LOCK(hpcd);
<>	144:ef7eb2e8f9f7	1165	USB_DeactivateEndpoint(hpcd->Instance , ep);
<>	144:ef7eb2e8f9f7	1166	__HAL_UNLOCK(hpcd);
<>	144:ef7eb2e8f9f7	1167	return HAL_OK;
<>	144:ef7eb2e8f9f7	1168	}
<>	144:ef7eb2e8f9f7	1169
<>	144:ef7eb2e8f9f7	1170
<>	144:ef7eb2e8f9f7	1171	/**
<>	144:ef7eb2e8f9f7	1172	* @brief Receive an amount of data.
<>	144:ef7eb2e8f9f7	1173	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1174	* @param ep_addr: endpoint address
<>	144:ef7eb2e8f9f7	1175	* @param pBuf: pointer to the reception buffer
<>	144:ef7eb2e8f9f7	1176	* @param len: amount of data to be received
<>	144:ef7eb2e8f9f7	1177	* @retval HAL status
<>	144:ef7eb2e8f9f7	1178	*/
<>	144:ef7eb2e8f9f7	1179	HAL_StatusTypeDef HAL_PCD_EP_Receive(PCD_HandleTypeDef hpcd, uint8_t ep_addr, uint8_t pBuf, uint32_t len)
<>	144:ef7eb2e8f9f7	1180	{
<>	144:ef7eb2e8f9f7	1181	PCD_EPTypeDef *ep = NULL;
<>	144:ef7eb2e8f9f7	1182
<>	144:ef7eb2e8f9f7	1183	ep = &hpcd->OUT_ep[ep_addr & 0x7F];
<>	144:ef7eb2e8f9f7	1184
<>	144:ef7eb2e8f9f7	1185	/setup and start the Xfer /
<>	144:ef7eb2e8f9f7	1186	ep->xfer_buff = pBuf;
<>	144:ef7eb2e8f9f7	1187	ep->xfer_len = len;
<>	144:ef7eb2e8f9f7	1188	ep->xfer_count = 0;
<>	144:ef7eb2e8f9f7	1189	ep->is_in = 0;
<>	144:ef7eb2e8f9f7	1190	ep->num = ep_addr & 0x7F;
<>	144:ef7eb2e8f9f7	1191
<>	153:fa9ff456f731	1192	__HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1193
<>	144:ef7eb2e8f9f7	1194	if ((ep_addr & 0x7F) == 0 )
<>	144:ef7eb2e8f9f7	1195	{
<>	144:ef7eb2e8f9f7	1196	USB_EP0StartXfer(hpcd->Instance, ep, hpcd->Init.dma_enable);
<>	144:ef7eb2e8f9f7	1197	}
<>	144:ef7eb2e8f9f7	1198	else
<>	144:ef7eb2e8f9f7	1199	{
<>	144:ef7eb2e8f9f7	1200	USB_EPStartXfer(hpcd->Instance, ep, hpcd->Init.dma_enable);
<>	144:ef7eb2e8f9f7	1201	}
<>	153:fa9ff456f731	1202	__HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1203
<>	144:ef7eb2e8f9f7	1204	return HAL_OK;
<>	144:ef7eb2e8f9f7	1205	}
<>	144:ef7eb2e8f9f7	1206
<>	144:ef7eb2e8f9f7	1207	/**
<>	144:ef7eb2e8f9f7	1208	* @brief Get Received Data Size.
<>	144:ef7eb2e8f9f7	1209	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1210	* @param ep_addr: endpoint address
<>	144:ef7eb2e8f9f7	1211	* @retval Data Size
<>	144:ef7eb2e8f9f7	1212	*/
<>	144:ef7eb2e8f9f7	1213	uint16_t HAL_PCD_EP_GetRxCount(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<>	144:ef7eb2e8f9f7	1214	{
<>	144:ef7eb2e8f9f7	1215	return hpcd->OUT_ep[ep_addr & 0x7F].xfer_count;
<>	144:ef7eb2e8f9f7	1216	}
<>	144:ef7eb2e8f9f7	1217	/**
<>	144:ef7eb2e8f9f7	1218	* @brief Send an amount of data.
<>	144:ef7eb2e8f9f7	1219	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1220	* @param ep_addr: endpoint address
<>	144:ef7eb2e8f9f7	1221	* @param pBuf: pointer to the transmission buffer
<>	144:ef7eb2e8f9f7	1222	* @param len: amount of data to be sent
<>	144:ef7eb2e8f9f7	1223	* @retval HAL status
<>	144:ef7eb2e8f9f7	1224	*/
<>	144:ef7eb2e8f9f7	1225	HAL_StatusTypeDef HAL_PCD_EP_Transmit(PCD_HandleTypeDef hpcd, uint8_t ep_addr, uint8_t pBuf, uint32_t len)
<>	144:ef7eb2e8f9f7	1226	{
<>	144:ef7eb2e8f9f7	1227	PCD_EPTypeDef *ep = NULL;
<>	144:ef7eb2e8f9f7	1228
<>	144:ef7eb2e8f9f7	1229	ep = &hpcd->IN_ep[ep_addr & 0x7F];
<>	144:ef7eb2e8f9f7	1230
<>	144:ef7eb2e8f9f7	1231	/setup and start the Xfer /
<>	144:ef7eb2e8f9f7	1232	ep->xfer_buff = pBuf;
<>	144:ef7eb2e8f9f7	1233	ep->xfer_len = len;
<>	144:ef7eb2e8f9f7	1234	ep->xfer_count = 0;
<>	144:ef7eb2e8f9f7	1235	ep->is_in = 1;
<>	144:ef7eb2e8f9f7	1236	ep->num = ep_addr & 0x7F;
<>	144:ef7eb2e8f9f7	1237
<>	153:fa9ff456f731	1238	__HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1239
<>	144:ef7eb2e8f9f7	1240	if ((ep_addr & 0x7F) == 0 )
<>	144:ef7eb2e8f9f7	1241	{
<>	144:ef7eb2e8f9f7	1242	USB_EP0StartXfer(hpcd->Instance,ep, hpcd->Init.dma_enable);
<>	144:ef7eb2e8f9f7	1243	}
<>	144:ef7eb2e8f9f7	1244	else
<>	144:ef7eb2e8f9f7	1245	{
<>	144:ef7eb2e8f9f7	1246	USB_EPStartXfer(hpcd->Instance, ep, hpcd->Init.dma_enable);
<>	144:ef7eb2e8f9f7	1247	}
<>	144:ef7eb2e8f9f7	1248
<>	153:fa9ff456f731	1249	__HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1250
<>	144:ef7eb2e8f9f7	1251	return HAL_OK;
<>	144:ef7eb2e8f9f7	1252	}
<>	144:ef7eb2e8f9f7	1253
<>	144:ef7eb2e8f9f7	1254	/**
<>	144:ef7eb2e8f9f7	1255	* @brief Set a STALL condition over an endpoint.
<>	144:ef7eb2e8f9f7	1256	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1257	* @param ep_addr: endpoint address
<>	144:ef7eb2e8f9f7	1258	* @retval HAL status
<>	144:ef7eb2e8f9f7	1259	*/
<>	144:ef7eb2e8f9f7	1260	HAL_StatusTypeDef HAL_PCD_EP_SetStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<>	144:ef7eb2e8f9f7	1261	{
<>	144:ef7eb2e8f9f7	1262	PCD_EPTypeDef *ep = NULL;
<>	144:ef7eb2e8f9f7	1263
<>	144:ef7eb2e8f9f7	1264	if ((0x80 & ep_addr) == 0x80)
<>	144:ef7eb2e8f9f7	1265	{
<>	144:ef7eb2e8f9f7	1266	ep = &hpcd->IN_ep[ep_addr & 0x7F];
<>	144:ef7eb2e8f9f7	1267	}
<>	144:ef7eb2e8f9f7	1268	else
<>	144:ef7eb2e8f9f7	1269	{
<>	144:ef7eb2e8f9f7	1270	ep = &hpcd->OUT_ep[ep_addr];
<>	144:ef7eb2e8f9f7	1271	}
<>	144:ef7eb2e8f9f7	1272
<>	144:ef7eb2e8f9f7	1273	ep->is_stall = 1;
<>	144:ef7eb2e8f9f7	1274	ep->num = ep_addr & 0x7F;
<>	144:ef7eb2e8f9f7	1275	ep->is_in = ((ep_addr & 0x80) == 0x80);
<>	144:ef7eb2e8f9f7	1276
<>	153:fa9ff456f731	1277	__HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1278	USB_EPSetStall(hpcd->Instance , ep);
<>	144:ef7eb2e8f9f7	1279	if((ep_addr & 0x7F) == 0)
<>	144:ef7eb2e8f9f7	1280	{
<>	144:ef7eb2e8f9f7	1281	USB_EP0_OutStart(hpcd->Instance, hpcd->Init.dma_enable, (uint8_t *)hpcd->Setup);
<>	144:ef7eb2e8f9f7	1282	}
<>	153:fa9ff456f731	1283	__HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1284
<>	144:ef7eb2e8f9f7	1285	return HAL_OK;
<>	144:ef7eb2e8f9f7	1286	}
<>	144:ef7eb2e8f9f7	1287
<>	144:ef7eb2e8f9f7	1288	/**
<>	144:ef7eb2e8f9f7	1289	* @brief Clear a STALL condition over in an endpoint.
<>	144:ef7eb2e8f9f7	1290	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1291	* @param ep_addr: endpoint address
<>	144:ef7eb2e8f9f7	1292	* @retval HAL status
<>	144:ef7eb2e8f9f7	1293	*/
<>	144:ef7eb2e8f9f7	1294	HAL_StatusTypeDef HAL_PCD_EP_ClrStall(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<>	144:ef7eb2e8f9f7	1295	{
<>	144:ef7eb2e8f9f7	1296	PCD_EPTypeDef *ep = NULL;
<>	144:ef7eb2e8f9f7	1297
<>	144:ef7eb2e8f9f7	1298	if ((0x80 & ep_addr) == 0x80)
<>	144:ef7eb2e8f9f7	1299	{
<>	144:ef7eb2e8f9f7	1300	ep = &hpcd->IN_ep[ep_addr & 0x7F];
<>	144:ef7eb2e8f9f7	1301	}
<>	144:ef7eb2e8f9f7	1302	else
<>	144:ef7eb2e8f9f7	1303	{
<>	144:ef7eb2e8f9f7	1304	ep = &hpcd->OUT_ep[ep_addr];
<>	144:ef7eb2e8f9f7	1305	}
<>	144:ef7eb2e8f9f7	1306
<>	144:ef7eb2e8f9f7	1307	ep->is_stall = 0;
<>	144:ef7eb2e8f9f7	1308	ep->num = ep_addr & 0x7F;
<>	144:ef7eb2e8f9f7	1309	ep->is_in = ((ep_addr & 0x80) == 0x80);
<>	144:ef7eb2e8f9f7	1310
<>	153:fa9ff456f731	1311	__HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1312	USB_EPClearStall(hpcd->Instance , ep);
<>	153:fa9ff456f731	1313	__HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1314
<>	144:ef7eb2e8f9f7	1315	return HAL_OK;
<>	144:ef7eb2e8f9f7	1316	}
<>	144:ef7eb2e8f9f7	1317
<>	144:ef7eb2e8f9f7	1318	/**
<>	144:ef7eb2e8f9f7	1319	* @brief Flush an endpoint.
<>	144:ef7eb2e8f9f7	1320	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1321	* @param ep_addr: endpoint address
<>	144:ef7eb2e8f9f7	1322	* @retval HAL status
<>	144:ef7eb2e8f9f7	1323	*/
<>	144:ef7eb2e8f9f7	1324	HAL_StatusTypeDef HAL_PCD_EP_Flush(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)
<>	144:ef7eb2e8f9f7	1325	{
<>	153:fa9ff456f731	1326	__HAL_LOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1327	if ((ep_addr & 0x80) == 0x80)
<>	144:ef7eb2e8f9f7	1328	{
<>	144:ef7eb2e8f9f7	1329	USB_FlushTxFifo(hpcd->Instance, ep_addr & 0x7F);
<>	144:ef7eb2e8f9f7	1330	}
<>	144:ef7eb2e8f9f7	1331	else
<>	144:ef7eb2e8f9f7	1332	{
<>	144:ef7eb2e8f9f7	1333	USB_FlushRxFifo(hpcd->Instance);
<>	144:ef7eb2e8f9f7	1334	}
<>	144:ef7eb2e8f9f7	1335
<>	153:fa9ff456f731	1336	__HAL_UNLOCK(&hpcd->EPLock[ep_addr & 0x7F]);
<>	144:ef7eb2e8f9f7	1337
<>	144:ef7eb2e8f9f7	1338	return HAL_OK;
<>	144:ef7eb2e8f9f7	1339	}
<>	144:ef7eb2e8f9f7	1340
<>	144:ef7eb2e8f9f7	1341	/**
<>	144:ef7eb2e8f9f7	1342	* @brief Activate remote wakeup signalling.
<>	144:ef7eb2e8f9f7	1343	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1344	* @retval HAL status
<>	144:ef7eb2e8f9f7	1345	*/
<>	144:ef7eb2e8f9f7	1346	HAL_StatusTypeDef HAL_PCD_ActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	1347	{
<>	144:ef7eb2e8f9f7	1348	return(USB_ActivateRemoteWakeup(hpcd->Instance));
<>	144:ef7eb2e8f9f7	1349	}
<>	144:ef7eb2e8f9f7	1350
<>	144:ef7eb2e8f9f7	1351	/**
<>	144:ef7eb2e8f9f7	1352	* @brief De-activate remote wakeup signalling.
<>	144:ef7eb2e8f9f7	1353	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1354	* @retval HAL status
<>	144:ef7eb2e8f9f7	1355	*/
<>	144:ef7eb2e8f9f7	1356	HAL_StatusTypeDef HAL_PCD_DeActivateRemoteWakeup(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	1357	{
<>	144:ef7eb2e8f9f7	1358	return(USB_DeActivateRemoteWakeup(hpcd->Instance));
<>	144:ef7eb2e8f9f7	1359	}
<>	144:ef7eb2e8f9f7	1360	/**
<>	144:ef7eb2e8f9f7	1361	* @}
<>	144:ef7eb2e8f9f7	1362	*/
<>	144:ef7eb2e8f9f7	1363
<>	144:ef7eb2e8f9f7	1364	/** @defgroup PCD_Exported_Functions_Group4 Peripheral State functions
<>	144:ef7eb2e8f9f7	1365	* @brief Peripheral State functions
<>	144:ef7eb2e8f9f7	1366	*
<>	144:ef7eb2e8f9f7	1367	@verbatim
<>	144:ef7eb2e8f9f7	1368	===============================================================================
<>	144:ef7eb2e8f9f7	1369	##### Peripheral State functions #####
<>	144:ef7eb2e8f9f7	1370	===============================================================================
<>	144:ef7eb2e8f9f7	1371	[..]
<>	144:ef7eb2e8f9f7	1372	This subsection permits to get in run-time the status of the peripheral
<>	144:ef7eb2e8f9f7	1373	and the data flow.
<>	144:ef7eb2e8f9f7	1374
<>	144:ef7eb2e8f9f7	1375	@endverbatim
<>	144:ef7eb2e8f9f7	1376	* @{
<>	144:ef7eb2e8f9f7	1377	*/
<>	144:ef7eb2e8f9f7	1378
<>	144:ef7eb2e8f9f7	1379	/**
<>	144:ef7eb2e8f9f7	1380	* @brief Return the PCD handle state.
<>	144:ef7eb2e8f9f7	1381	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1382	* @retval HAL state
<>	144:ef7eb2e8f9f7	1383	*/
<>	144:ef7eb2e8f9f7	1384	PCD_StateTypeDef HAL_PCD_GetState(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	1385	{
<>	144:ef7eb2e8f9f7	1386	return hpcd->State;
<>	144:ef7eb2e8f9f7	1387	}
<>	144:ef7eb2e8f9f7	1388	/**
<>	144:ef7eb2e8f9f7	1389	* @}
<>	144:ef7eb2e8f9f7	1390	*/
<>	144:ef7eb2e8f9f7	1391
<>	144:ef7eb2e8f9f7	1392	/**
<>	144:ef7eb2e8f9f7	1393	* @}
<>	144:ef7eb2e8f9f7	1394	*/
<>	144:ef7eb2e8f9f7	1395
<>	144:ef7eb2e8f9f7	1396	/* Private functions ---------------------------------------------------------*/
<>	144:ef7eb2e8f9f7	1397	/** @addtogroup PCD_Private_Functions
<>	144:ef7eb2e8f9f7	1398	* @{
<>	144:ef7eb2e8f9f7	1399	*/
<>	144:ef7eb2e8f9f7	1400	#if defined (USB_OTG_FS)
<>	144:ef7eb2e8f9f7	1401	/**
<>	144:ef7eb2e8f9f7	1402	* @brief Check FIFO for the next packet to be loaded.
<>	144:ef7eb2e8f9f7	1403	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1404	* @param epnum: endpoint number
<>	144:ef7eb2e8f9f7	1405	* @retval HAL status
<>	144:ef7eb2e8f9f7	1406	*/
<>	144:ef7eb2e8f9f7	1407	static HAL_StatusTypeDef PCD_WriteEmptyTxFifo(PCD_HandleTypeDef *hpcd, uint32_t epnum)
<>	144:ef7eb2e8f9f7	1408	{
<>	144:ef7eb2e8f9f7	1409	USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;
<>	144:ef7eb2e8f9f7	1410	USB_OTG_EPTypeDef *ep = NULL;
AnnaBridge	167:e84263d55307	1411	int32_t len = 0U;
<>	144:ef7eb2e8f9f7	1412	uint32_t len32b = 0;
<>	144:ef7eb2e8f9f7	1413	uint32_t fifoemptymsk = 0;
<>	144:ef7eb2e8f9f7	1414
<>	144:ef7eb2e8f9f7	1415	ep = &hpcd->IN_ep[epnum];
<>	144:ef7eb2e8f9f7	1416	len = ep->xfer_len - ep->xfer_count;
<>	144:ef7eb2e8f9f7	1417
<>	144:ef7eb2e8f9f7	1418	if (len > ep->maxpacket)
<>	144:ef7eb2e8f9f7	1419	{
<>	144:ef7eb2e8f9f7	1420	len = ep->maxpacket;
<>	144:ef7eb2e8f9f7	1421	}
<>	144:ef7eb2e8f9f7	1422
<>	144:ef7eb2e8f9f7	1423
<>	144:ef7eb2e8f9f7	1424	len32b = (len + 3) / 4;
<>	144:ef7eb2e8f9f7	1425
<>	144:ef7eb2e8f9f7	1426	while ( (USBx_INEP(epnum)->DTXFSTS & USB_OTG_DTXFSTS_INEPTFSAV) > len32b &&
<>	144:ef7eb2e8f9f7	1427	ep->xfer_count < ep->xfer_len &&
<>	144:ef7eb2e8f9f7	1428	ep->xfer_len != 0)
<>	144:ef7eb2e8f9f7	1429	{
<>	144:ef7eb2e8f9f7	1430	/* Write the FIFO */
<>	144:ef7eb2e8f9f7	1431	len = ep->xfer_len - ep->xfer_count;
<>	144:ef7eb2e8f9f7	1432
<>	144:ef7eb2e8f9f7	1433	if (len > ep->maxpacket)
<>	144:ef7eb2e8f9f7	1434	{
<>	144:ef7eb2e8f9f7	1435	len = ep->maxpacket;
<>	144:ef7eb2e8f9f7	1436	}
<>	144:ef7eb2e8f9f7	1437	len32b = (len + 3) / 4;
<>	144:ef7eb2e8f9f7	1438
<>	144:ef7eb2e8f9f7	1439	USB_WritePacket(USBx, ep->xfer_buff, epnum, len, hpcd->Init.dma_enable);
<>	144:ef7eb2e8f9f7	1440
<>	144:ef7eb2e8f9f7	1441	ep->xfer_buff += len;
<>	144:ef7eb2e8f9f7	1442	ep->xfer_count += len;
<>	144:ef7eb2e8f9f7	1443	}
<>	144:ef7eb2e8f9f7	1444
<>	144:ef7eb2e8f9f7	1445	if(len <= 0)
<>	144:ef7eb2e8f9f7	1446	{
<>	144:ef7eb2e8f9f7	1447	fifoemptymsk = 0x1 << epnum;
<>	153:fa9ff456f731	1448	atomic_clr_u32(&USBx_DEVICE->DIEPEMPMSK, fifoemptymsk);
<>	144:ef7eb2e8f9f7	1449
<>	144:ef7eb2e8f9f7	1450	}
<>	144:ef7eb2e8f9f7	1451
<>	144:ef7eb2e8f9f7	1452	return HAL_OK;
<>	144:ef7eb2e8f9f7	1453	}
<>	144:ef7eb2e8f9f7	1454	#endif /* USB_OTG_FS */
<>	144:ef7eb2e8f9f7	1455
<>	144:ef7eb2e8f9f7	1456	#if defined (USB)
<>	144:ef7eb2e8f9f7	1457	/**
<>	144:ef7eb2e8f9f7	1458	* @brief This function handles PCD Endpoint interrupt request.
<>	144:ef7eb2e8f9f7	1459	* @param hpcd: PCD handle
<>	144:ef7eb2e8f9f7	1460	* @retval HAL status
<>	144:ef7eb2e8f9f7	1461	*/
<>	144:ef7eb2e8f9f7	1462	static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd)
<>	144:ef7eb2e8f9f7	1463	{
<>	144:ef7eb2e8f9f7	1464	PCD_EPTypeDef *ep = NULL;
<>	144:ef7eb2e8f9f7	1465	uint16_t count = 0;
<>	144:ef7eb2e8f9f7	1466	uint8_t epindex = 0;
<>	144:ef7eb2e8f9f7	1467	__IO uint16_t wIstr = 0;
<>	144:ef7eb2e8f9f7	1468	__IO uint16_t wEPVal = 0;
<>	144:ef7eb2e8f9f7	1469
<>	144:ef7eb2e8f9f7	1470	/* stay in loop while pending interrupts */
<>	144:ef7eb2e8f9f7	1471	while (((wIstr = hpcd->Instance->ISTR) & USB_ISTR_CTR) != 0)
<>	144:ef7eb2e8f9f7	1472	{
<>	144:ef7eb2e8f9f7	1473	/* extract highest priority endpoint number */
<>	144:ef7eb2e8f9f7	1474	epindex = (uint8_t)(wIstr & USB_ISTR_EP_ID);
<>	144:ef7eb2e8f9f7	1475
<>	144:ef7eb2e8f9f7	1476	if (epindex == 0)
<>	144:ef7eb2e8f9f7	1477	{
<>	144:ef7eb2e8f9f7	1478	/* Decode and service control endpoint interrupt */
<>	144:ef7eb2e8f9f7	1479
<>	144:ef7eb2e8f9f7	1480	/* DIR bit = origin of the interrupt */
<>	144:ef7eb2e8f9f7	1481	if ((wIstr & USB_ISTR_DIR) == 0)
<>	144:ef7eb2e8f9f7	1482	{
<>	144:ef7eb2e8f9f7	1483	/* DIR = 0 */
<>	144:ef7eb2e8f9f7	1484
<>	144:ef7eb2e8f9f7	1485	/* DIR = 0 => IN int */
<>	144:ef7eb2e8f9f7	1486	/* DIR = 0 implies that (EP_CTR_TX = 1) always */
<>	144:ef7eb2e8f9f7	1487	PCD_CLEAR_TX_EP_CTR(hpcd->Instance, PCD_ENDP0);
<>	144:ef7eb2e8f9f7	1488	ep = &hpcd->IN_ep[0];
<>	144:ef7eb2e8f9f7	1489
<>	144:ef7eb2e8f9f7	1490	ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1491	ep->xfer_buff += ep->xfer_count;
<>	144:ef7eb2e8f9f7	1492
<>	144:ef7eb2e8f9f7	1493	/* TX COMPLETE */
<>	144:ef7eb2e8f9f7	1494	HAL_PCD_DataInStageCallback(hpcd, 0);
<>	144:ef7eb2e8f9f7	1495
<>	144:ef7eb2e8f9f7	1496
<>	144:ef7eb2e8f9f7	1497	if((hpcd->USB_Address > 0)&& ( ep->xfer_len == 0))
<>	144:ef7eb2e8f9f7	1498	{
<>	144:ef7eb2e8f9f7	1499	hpcd->Instance->DADDR = (hpcd->USB_Address \| USB_DADDR_EF);
<>	144:ef7eb2e8f9f7	1500	hpcd->USB_Address = 0;
<>	144:ef7eb2e8f9f7	1501	}
<>	144:ef7eb2e8f9f7	1502
<>	144:ef7eb2e8f9f7	1503	}
<>	144:ef7eb2e8f9f7	1504	else
<>	144:ef7eb2e8f9f7	1505	{
<>	144:ef7eb2e8f9f7	1506	/* DIR = 1 */
<>	144:ef7eb2e8f9f7	1507
<>	144:ef7eb2e8f9f7	1508	/* DIR = 1 & CTR_RX => SETUP or OUT int */
<>	144:ef7eb2e8f9f7	1509	/* DIR = 1 & (CTR_TX \| CTR_RX) => 2 int pending */
<>	144:ef7eb2e8f9f7	1510	ep = &hpcd->OUT_ep[0];
<>	144:ef7eb2e8f9f7	1511	wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, PCD_ENDP0);
<>	144:ef7eb2e8f9f7	1512
<>	144:ef7eb2e8f9f7	1513	if ((wEPVal & USB_EP_SETUP) != 0)
<>	144:ef7eb2e8f9f7	1514	{
<>	144:ef7eb2e8f9f7	1515	/* Get SETUP Packet*/
<>	144:ef7eb2e8f9f7	1516	ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1517	USB_ReadPMA(hpcd->Instance, (uint8_t*)hpcd->Setup ,ep->pmaadress , ep->xfer_count);
<>	144:ef7eb2e8f9f7	1518	/* SETUP bit kept frozen while CTR_RX = 1*/
<>	144:ef7eb2e8f9f7	1519	PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
<>	144:ef7eb2e8f9f7	1520
<>	144:ef7eb2e8f9f7	1521	/* Process SETUP Packet*/
<>	144:ef7eb2e8f9f7	1522	HAL_PCD_SetupStageCallback(hpcd);
<>	144:ef7eb2e8f9f7	1523	}
<>	144:ef7eb2e8f9f7	1524
<>	144:ef7eb2e8f9f7	1525	else if ((wEPVal & USB_EP_CTR_RX) != 0)
<>	144:ef7eb2e8f9f7	1526	{
<>	144:ef7eb2e8f9f7	1527	PCD_CLEAR_RX_EP_CTR(hpcd->Instance, PCD_ENDP0);
<>	144:ef7eb2e8f9f7	1528	/* Get Control Data OUT Packet*/
<>	144:ef7eb2e8f9f7	1529	ep->xfer_count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1530
<>	144:ef7eb2e8f9f7	1531	if (ep->xfer_count != 0)
<>	144:ef7eb2e8f9f7	1532	{
<>	144:ef7eb2e8f9f7	1533	USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, ep->xfer_count);
<>	144:ef7eb2e8f9f7	1534	ep->xfer_buff+=ep->xfer_count;
<>	144:ef7eb2e8f9f7	1535	}
<>	144:ef7eb2e8f9f7	1536
<>	144:ef7eb2e8f9f7	1537	/* Process Control Data OUT Packet*/
<>	144:ef7eb2e8f9f7	1538	HAL_PCD_DataOutStageCallback(hpcd, 0);
<>	144:ef7eb2e8f9f7	1539
<>	144:ef7eb2e8f9f7	1540	PCD_SET_EP_RX_CNT(hpcd->Instance, PCD_ENDP0, ep->maxpacket);
<>	144:ef7eb2e8f9f7	1541	PCD_SET_EP_RX_STATUS(hpcd->Instance, PCD_ENDP0, USB_EP_RX_VALID);
<>	144:ef7eb2e8f9f7	1542	}
<>	144:ef7eb2e8f9f7	1543	}
<>	144:ef7eb2e8f9f7	1544	}
<>	144:ef7eb2e8f9f7	1545	else
<>	144:ef7eb2e8f9f7	1546	{
<>	144:ef7eb2e8f9f7	1547	/* Decode and service non control endpoints interrupt */
<>	144:ef7eb2e8f9f7	1548
<>	144:ef7eb2e8f9f7	1549	/* process related endpoint register */
<>	144:ef7eb2e8f9f7	1550	wEPVal = PCD_GET_ENDPOINT(hpcd->Instance, epindex);
<>	144:ef7eb2e8f9f7	1551	if ((wEPVal & USB_EP_CTR_RX) != 0)
<>	144:ef7eb2e8f9f7	1552	{
<>	144:ef7eb2e8f9f7	1553	/* clear int flag */
<>	144:ef7eb2e8f9f7	1554	PCD_CLEAR_RX_EP_CTR(hpcd->Instance, epindex);
<>	144:ef7eb2e8f9f7	1555	ep = &hpcd->OUT_ep[epindex];
<>	144:ef7eb2e8f9f7	1556
<>	144:ef7eb2e8f9f7	1557	/* OUT double Buffering*/
<>	144:ef7eb2e8f9f7	1558	if (ep->doublebuffer == 0)
<>	144:ef7eb2e8f9f7	1559	{
<>	144:ef7eb2e8f9f7	1560	count = PCD_GET_EP_RX_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1561	if (count != 0)
<>	144:ef7eb2e8f9f7	1562	{
<>	144:ef7eb2e8f9f7	1563	USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, count);
<>	144:ef7eb2e8f9f7	1564	}
<>	144:ef7eb2e8f9f7	1565	}
<>	144:ef7eb2e8f9f7	1566	else
<>	144:ef7eb2e8f9f7	1567	{
<>	144:ef7eb2e8f9f7	1568	if (PCD_GET_ENDPOINT(hpcd->Instance, ep->num) & USB_EP_DTOG_RX)
<>	144:ef7eb2e8f9f7	1569	{
<>	144:ef7eb2e8f9f7	1570	/read from endpoint BUF0Addr buffer/
<>	144:ef7eb2e8f9f7	1571	count = PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1572	if (count != 0)
<>	144:ef7eb2e8f9f7	1573	{
<>	144:ef7eb2e8f9f7	1574	USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, count);
<>	144:ef7eb2e8f9f7	1575	}
<>	144:ef7eb2e8f9f7	1576	}
<>	144:ef7eb2e8f9f7	1577	else
<>	144:ef7eb2e8f9f7	1578	{
<>	144:ef7eb2e8f9f7	1579	/read from endpoint BUF1Addr buffer/
<>	144:ef7eb2e8f9f7	1580	count = PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1581	if (count != 0)
<>	144:ef7eb2e8f9f7	1582	{
<>	144:ef7eb2e8f9f7	1583	USB_ReadPMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, count);
<>	144:ef7eb2e8f9f7	1584	}
<>	144:ef7eb2e8f9f7	1585	}
<>	144:ef7eb2e8f9f7	1586	PCD_FreeUserBuffer(hpcd->Instance, ep->num, PCD_EP_DBUF_OUT);
<>	144:ef7eb2e8f9f7	1587	}
<>	144:ef7eb2e8f9f7	1588	/multi-packet on the NON control OUT endpoint/
<>	144:ef7eb2e8f9f7	1589	ep->xfer_count+=count;
<>	144:ef7eb2e8f9f7	1590	ep->xfer_buff+=count;
<>	144:ef7eb2e8f9f7	1591
<>	144:ef7eb2e8f9f7	1592	if ((ep->xfer_len == 0) \|\| (count < ep->maxpacket))
<>	144:ef7eb2e8f9f7	1593	{
<>	144:ef7eb2e8f9f7	1594	/* RX COMPLETE */
<>	144:ef7eb2e8f9f7	1595	HAL_PCD_DataOutStageCallback(hpcd, ep->num);
<>	144:ef7eb2e8f9f7	1596	}
<>	144:ef7eb2e8f9f7	1597	else
<>	144:ef7eb2e8f9f7	1598	{
<>	144:ef7eb2e8f9f7	1599	HAL_PCD_EP_Receive(hpcd, ep->num, ep->xfer_buff, ep->xfer_len);
<>	144:ef7eb2e8f9f7	1600	}
<>	144:ef7eb2e8f9f7	1601
<>	144:ef7eb2e8f9f7	1602	} /* if((wEPVal & EP_CTR_RX) */
<>	144:ef7eb2e8f9f7	1603
<>	144:ef7eb2e8f9f7	1604	if ((wEPVal & USB_EP_CTR_TX) != 0)
<>	144:ef7eb2e8f9f7	1605	{
<>	144:ef7eb2e8f9f7	1606	ep = &hpcd->IN_ep[epindex];
<>	144:ef7eb2e8f9f7	1607
<>	144:ef7eb2e8f9f7	1608	/* clear int flag */
<>	144:ef7eb2e8f9f7	1609	PCD_CLEAR_TX_EP_CTR(hpcd->Instance, epindex);
<>	144:ef7eb2e8f9f7	1610
<>	144:ef7eb2e8f9f7	1611	/* IN double Buffering*/
<>	144:ef7eb2e8f9f7	1612	if (ep->doublebuffer == 0)
<>	144:ef7eb2e8f9f7	1613	{
<>	144:ef7eb2e8f9f7	1614	ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1615	if (ep->xfer_count != 0)
<>	144:ef7eb2e8f9f7	1616	{
<>	144:ef7eb2e8f9f7	1617	USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaadress, ep->xfer_count);
<>	144:ef7eb2e8f9f7	1618	}
<>	144:ef7eb2e8f9f7	1619	}
<>	144:ef7eb2e8f9f7	1620	else
<>	144:ef7eb2e8f9f7	1621	{
<>	144:ef7eb2e8f9f7	1622	if (PCD_GET_ENDPOINT(hpcd->Instance, ep->num) & USB_EP_DTOG_TX)
<>	144:ef7eb2e8f9f7	1623	{
<>	144:ef7eb2e8f9f7	1624	/read from endpoint BUF0Addr buffer/
<>	144:ef7eb2e8f9f7	1625	ep->xfer_count = PCD_GET_EP_DBUF0_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1626	if (ep->xfer_count != 0)
<>	144:ef7eb2e8f9f7	1627	{
<>	144:ef7eb2e8f9f7	1628	USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr0, ep->xfer_count);
<>	144:ef7eb2e8f9f7	1629	}
<>	144:ef7eb2e8f9f7	1630	}
<>	144:ef7eb2e8f9f7	1631	else
<>	144:ef7eb2e8f9f7	1632	{
<>	144:ef7eb2e8f9f7	1633	/read from endpoint BUF1Addr buffer/
<>	144:ef7eb2e8f9f7	1634	ep->xfer_count = PCD_GET_EP_DBUF1_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1635	if (ep->xfer_count != 0)
<>	144:ef7eb2e8f9f7	1636	{
<>	144:ef7eb2e8f9f7	1637	USB_WritePMA(hpcd->Instance, ep->xfer_buff, ep->pmaaddr1, ep->xfer_count);
<>	144:ef7eb2e8f9f7	1638	}
<>	144:ef7eb2e8f9f7	1639	}
<>	144:ef7eb2e8f9f7	1640	PCD_FreeUserBuffer(hpcd->Instance, ep->num, PCD_EP_DBUF_IN);
<>	144:ef7eb2e8f9f7	1641	}
<>	144:ef7eb2e8f9f7	1642	/multi-packet on the NON control IN endpoint/
<>	144:ef7eb2e8f9f7	1643	ep->xfer_count = PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
<>	144:ef7eb2e8f9f7	1644	ep->xfer_buff+=ep->xfer_count;
<>	144:ef7eb2e8f9f7	1645
<>	144:ef7eb2e8f9f7	1646	/* Zero Length Packet? */
<>	144:ef7eb2e8f9f7	1647	if (ep->xfer_len == 0)
<>	144:ef7eb2e8f9f7	1648	{
<>	144:ef7eb2e8f9f7	1649	/* TX COMPLETE */
<>	144:ef7eb2e8f9f7	1650	HAL_PCD_DataInStageCallback(hpcd, ep->num);
<>	144:ef7eb2e8f9f7	1651	}
<>	144:ef7eb2e8f9f7	1652	else
<>	144:ef7eb2e8f9f7	1653	{
<>	144:ef7eb2e8f9f7	1654	HAL_PCD_EP_Transmit(hpcd, ep->num, ep->xfer_buff, ep->xfer_len);
<>	144:ef7eb2e8f9f7	1655	}
<>	144:ef7eb2e8f9f7	1656	}
<>	144:ef7eb2e8f9f7	1657	}
<>	144:ef7eb2e8f9f7	1658	}
<>	144:ef7eb2e8f9f7	1659	return HAL_OK;
<>	144:ef7eb2e8f9f7	1660	}
<>	144:ef7eb2e8f9f7	1661	#endif /* USB */
<>	144:ef7eb2e8f9f7	1662
<>	144:ef7eb2e8f9f7	1663	/**
<>	144:ef7eb2e8f9f7	1664	* @}
<>	144:ef7eb2e8f9f7	1665	*/
<>	144:ef7eb2e8f9f7	1666
AnnaBridge	167:e84263d55307	1667	#endif /* STM32L432xx \|\| STM32L433xx \|\| STM32L442xx \|\| STM32L443xx \|\| */
AnnaBridge	167:e84263d55307	1668	/* STM32L452xx \|\| STM32L462xx \|\| */
AnnaBridge	167:e84263d55307	1669	/* STM32L475xx \|\| STM32L476xx \|\| STM32L485xx \|\| STM32L486xx \|\| */
AnnaBridge	167:e84263d55307	1670	/* STM32L496xx \|\| STM32L4A6xx */
AnnaBridge	167:e84263d55307	1671
AnnaBridge	167:e84263d55307	1672	#endif /* HAL_PCD_MODULE_ENABLED */
AnnaBridge	167:e84263d55307	1673
<>	144:ef7eb2e8f9f7	1674	/**
<>	144:ef7eb2e8f9f7	1675	* @}
<>	144:ef7eb2e8f9f7	1676	*/
<>	144:ef7eb2e8f9f7	1677
<>	144:ef7eb2e8f9f7	1678	/**
<>	144:ef7eb2e8f9f7	1679	* @}
<>	144:ef7eb2e8f9f7	1680	*/
<>	144:ef7eb2e8f9f7	1681
<>	144:ef7eb2e8f9f7	1682	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

Repository toolbox

Export to desktop IDE

Repository details

Type:	Library
Created:	11 Feb 2018
Imports:	0
Forks:	0
Commits:	182
Dependents:	0
Dependencies:	0
Followers:	1

targets/TARGET_STM/TARGET_STM32L4/device/stm32l4xx_hal_pcd.c@167:e84263d55307, 2017-06-21 (annotated)

Who changed what in which revision?

Repository toolbox

Repository details

Important Information for this Arm website

Access Warning