WebSVN – LedShow – Blame – /trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_hcd.c

Rev	Author	Line No.	Line
2	mjames	1	/**
		2	******************************************************************************
		3	* @file stm32f1xx_hal_hcd.c
		4	* @author MCD Application Team
		5	* @brief HCD HAL module driver.
9	mjames	6	* This file provides firmware functions to manage the following
2	mjames	7	* functionalities of the USB Peripheral Controller:
		8	* + Initialization and de-initialization functions
		9	* + IO operation functions
9	mjames	10	* + Peripheral Control functions
2	mjames	11	* + Peripheral State functions
		12	*
		13	@verbatim
		14	==============================================================================
		15	##### How to use this driver #####
		16	==============================================================================
		17	[..]
		18	(#)Declare a HCD_HandleTypeDef handle structure, for example:
		19	HCD_HandleTypeDef hhcd;
9	mjames	20
2	mjames	21	(#)Fill parameters of Init structure in HCD handle
		22
		23	(#)Call HAL_HCD_Init() API to initialize the HCD peripheral (Core, Host core, ...)
		24
		25	(#)Initialize the HCD low level resources through the HAL_HCD_MspInit() API:
9	mjames	26	(##) Enable the HCD/USB Low Level interface clock using the following macros
		27	(+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE();
2	mjames	28	(##) Initialize the related GPIO clocks
		29	(##) Configure HCD pin-out
		30	(##) Configure HCD NVIC interrupt
		31
		32	(#)Associate the Upper USB Host stack to the HAL HCD Driver:
		33	(##) hhcd.pData = phost;
		34
		35	(#)Enable HCD transmission and reception:
		36	(##) HAL_HCD_Start();
		37
		38	@endverbatim
		39	******************************************************************************
		40	* @attention
		41	*
9	mjames	42	* <h2><center>© Copyright (c) 2016 STMicroelectronics.
		43	* All rights reserved.</center></h2>
2	mjames	44	*
9	mjames	45	* This software component is licensed by ST under BSD 3-Clause license,
		46	* the "License"; You may not use this file except in compliance with the
		47	* License. You may obtain a copy of the License at:
		48	* opensource.org/licenses/BSD-3-Clause
2	mjames	49	*
		50	******************************************************************************
		51	*/
		52
		53	/* Includes ------------------------------------------------------------------*/
		54	#include "stm32f1xx_hal.h"
9	mjames	55
2	mjames	56	/** @addtogroup STM32F1xx_HAL_Driver
		57	* @{
		58	*/
		59
		60	#ifdef HAL_HCD_MODULE_ENABLED
		61
9	mjames	62	#if defined (USB_OTG_FS)
2	mjames	63
9	mjames	64	/** @defgroup HCD HCD
2	mjames	65	* @brief HCD HAL module driver
		66	* @{
		67	*/
		68
9	mjames	69	/* Private typedef -----------------------------------------------------------*/
		70	/* Private define ------------------------------------------------------------*/
		71	/* Private macro -------------------------------------------------------------*/
2	mjames	72	/* Private variables ---------------------------------------------------------*/
9	mjames	73	/* Private function prototypes -----------------------------------------------*/
2	mjames	74	/** @defgroup HCD_Private_Functions HCD Private Functions
		75	* @{
		76	*/
		77	static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum);
		78	static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum);
		79	static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd);
		80	static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd);
		81	/**
		82	* @}
		83	*/
		84
		85	/* Exported functions --------------------------------------------------------*/
		86	/** @defgroup HCD_Exported_Functions HCD Exported Functions
		87	* @{
		88	*/
		89
9	mjames	90	/** @defgroup HCD_Exported_Functions_Group1 Initialization and de-initialization functions
		91	* @brief Initialization and Configuration functions
		92	*
2	mjames	93	@verbatim
		94	===============================================================================
		95	##### Initialization and de-initialization functions #####
		96	===============================================================================
		97	[..] This section provides functions allowing to:
9	mjames	98
2	mjames	99	@endverbatim
		100	* @{
		101	*/
		102
		103	/**
9	mjames	104	* @brief Initialize the host driver.
		105	* @param hhcd HCD handle
2	mjames	106	* @retval HAL status
		107	*/
		108	HAL_StatusTypeDef HAL_HCD_Init(HCD_HandleTypeDef *hhcd)
9	mjames	109	{
		110	USB_OTG_GlobalTypeDef *USBx;
		111
2	mjames	112	/* Check the HCD handle allocation */
9	mjames	113	if (hhcd == NULL)
2	mjames	114	{
		115	return HAL_ERROR;
		116	}
9	mjames	117
2	mjames	118	/* Check the parameters */
		119	assert_param(IS_HCD_ALL_INSTANCE(hhcd->Instance));
9	mjames	120
		121	USBx = hhcd->Instance;
		122
		123	if (hhcd->State == HAL_HCD_STATE_RESET)
		124	{
2	mjames	125	/* Allocate lock resource and initialize it */
		126	hhcd->Lock = HAL_UNLOCKED;
		127
9	mjames	128	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
		129	hhcd->SOFCallback = HAL_HCD_SOF_Callback;
		130	hhcd->ConnectCallback = HAL_HCD_Connect_Callback;
		131	hhcd->DisconnectCallback = HAL_HCD_Disconnect_Callback;
		132	hhcd->PortEnabledCallback = HAL_HCD_PortEnabled_Callback;
		133	hhcd->PortDisabledCallback = HAL_HCD_PortDisabled_Callback;
		134	hhcd->HC_NotifyURBChangeCallback = HAL_HCD_HC_NotifyURBChange_Callback;
		135
		136	if (hhcd->MspInitCallback == NULL)
		137	{
		138	hhcd->MspInitCallback = HAL_HCD_MspInit;
		139	}
		140
		141	/* Init the low level hardware */
		142	hhcd->MspInitCallback(hhcd);
		143	#else
2	mjames	144	/* Init the low level hardware : GPIO, CLOCK, NVIC... */
		145	HAL_HCD_MspInit(hhcd);
9	mjames	146	#endif /* (USE_HAL_HCD_REGISTER_CALLBACKS) */
2	mjames	147	}
		148
		149	hhcd->State = HAL_HCD_STATE_BUSY;
9	mjames	150
		151	/* Disable DMA mode for FS instance */
		152	if ((USBx->CID & (0x1U << 8)) == 0U)
		153	{
		154	hhcd->Init.dma_enable = 0U;
		155	}
		156
2	mjames	157	/* Disable the Interrupts */
		158	__HAL_HCD_DISABLE(hhcd);
9	mjames	159
2	mjames	160	/* Init the Core (common init.) */
9	mjames	161	(void)USB_CoreInit(hhcd->Instance, hhcd->Init);
		162
2	mjames	163	/* Force Host Mode*/
9	mjames	164	(void)USB_SetCurrentMode(hhcd->Instance, USB_HOST_MODE);
		165
2	mjames	166	/* Init Host */
9	mjames	167	(void)USB_HostInit(hhcd->Instance, hhcd->Init);
		168
		169	hhcd->State = HAL_HCD_STATE_READY;
		170
2	mjames	171	return HAL_OK;
		172	}
		173
		174	/**
9	mjames	175	* @brief Initialize a host channel.
		176	* @param hhcd HCD handle
		177	* @param ch_num Channel number.
2	mjames	178	* This parameter can be a value from 1 to 15
9	mjames	179	* @param epnum Endpoint number.
2	mjames	180	* This parameter can be a value from 1 to 15
9	mjames	181	* @param dev_address Current device address
2	mjames	182	* This parameter can be a value from 0 to 255
9	mjames	183	* @param speed Current device speed.
2	mjames	184	* This parameter can be one of these values:
		185	* HCD_SPEED_FULL: Full speed mode,
		186	* HCD_SPEED_LOW: Low speed mode
9	mjames	187	* @param ep_type Endpoint Type.
2	mjames	188	* This parameter can be one of these values:
		189	* EP_TYPE_CTRL: Control type,
		190	* EP_TYPE_ISOC: Isochronous type,
		191	* EP_TYPE_BULK: Bulk type,
		192	* EP_TYPE_INTR: Interrupt type
9	mjames	193	* @param mps Max Packet Size.
2	mjames	194	* This parameter can be a value from 0 to32K
		195	* @retval HAL status
		196	*/
		197	HAL_StatusTypeDef HAL_HCD_HC_Init(HCD_HandleTypeDef *hhcd,
		198	uint8_t ch_num,
		199	uint8_t epnum,
		200	uint8_t dev_address,
		201	uint8_t speed,
		202	uint8_t ep_type,
		203	uint16_t mps)
		204	{
9	mjames	205	HAL_StatusTypeDef status;
		206
2	mjames	207	__HAL_LOCK(hhcd);
9	mjames	208	hhcd->hc[ch_num].do_ping = 0U;
2	mjames	209	hhcd->hc[ch_num].dev_addr = dev_address;
		210	hhcd->hc[ch_num].max_packet = mps;
		211	hhcd->hc[ch_num].ch_num = ch_num;
		212	hhcd->hc[ch_num].ep_type = ep_type;
		213	hhcd->hc[ch_num].ep_num = epnum & 0x7FU;
9	mjames	214
		215	if ((epnum & 0x80U) == 0x80U)
		216	{
		217	hhcd->hc[ch_num].ep_is_in = 1U;
		218	}
		219	else
		220	{
		221	hhcd->hc[ch_num].ep_is_in = 0U;
		222	}
		223
2	mjames	224	hhcd->hc[ch_num].speed = speed;
9	mjames	225
2	mjames	226	status = USB_HC_Init(hhcd->Instance,
		227	ch_num,
		228	epnum,
		229	dev_address,
		230	speed,
		231	ep_type,
		232	mps);
		233	__HAL_UNLOCK(hhcd);
9	mjames	234
2	mjames	235	return status;
		236	}
		237
		238	/**
9	mjames	239	* @brief Halt a host channel.
		240	* @param hhcd HCD handle
		241	* @param ch_num Channel number.
2	mjames	242	* This parameter can be a value from 1 to 15
		243	* @retval HAL status
		244	*/
9	mjames	245	HAL_StatusTypeDef HAL_HCD_HC_Halt(HCD_HandleTypeDef *hhcd, uint8_t ch_num)
2	mjames	246	{
9	mjames	247	HAL_StatusTypeDef status = HAL_OK;
		248
2	mjames	249	__HAL_LOCK(hhcd);
9	mjames	250	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
2	mjames	251	__HAL_UNLOCK(hhcd);
9	mjames	252
		253	return status;
2	mjames	254	}
		255
		256	/**
9	mjames	257	* @brief DeInitialize the host driver.
		258	* @param hhcd HCD handle
2	mjames	259	* @retval HAL status
		260	*/
		261	HAL_StatusTypeDef HAL_HCD_DeInit(HCD_HandleTypeDef *hhcd)
		262	{
		263	/* Check the HCD handle allocation */
9	mjames	264	if (hhcd == NULL)
2	mjames	265	{
		266	return HAL_ERROR;
		267	}
9	mjames	268
2	mjames	269	hhcd->State = HAL_HCD_STATE_BUSY;
9	mjames	270
		271	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
		272	if (hhcd->MspDeInitCallback == NULL)
		273	{
		274	hhcd->MspDeInitCallback = HAL_HCD_MspDeInit; /* Legacy weak MspDeInit */
		275	}
		276
2	mjames	277	/* DeInit the low level hardware */
9	mjames	278	hhcd->MspDeInitCallback(hhcd);
		279	#else
		280	/* DeInit the low level hardware: CLOCK, NVIC.*/
2	mjames	281	HAL_HCD_MspDeInit(hhcd);
9	mjames	282	#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
		283
2	mjames	284	__HAL_HCD_DISABLE(hhcd);
9	mjames	285
2	mjames	286	hhcd->State = HAL_HCD_STATE_RESET;
9	mjames	287
2	mjames	288	return HAL_OK;
		289	}
		290
		291	/**
9	mjames	292	* @brief Initialize the HCD MSP.
		293	* @param hhcd HCD handle
2	mjames	294	* @retval None
		295	*/
		296	__weak void HAL_HCD_MspInit(HCD_HandleTypeDef *hhcd)
		297	{
		298	/* Prevent unused argument(s) compilation warning */
		299	UNUSED(hhcd);
9	mjames	300
		301	/* NOTE : This function should not be modified, when the callback is needed,
2	mjames	302	the HAL_HCD_MspInit could be implemented in the user file
		303	*/
		304	}
		305
		306	/**
9	mjames	307	* @brief DeInitialize the HCD MSP.
		308	* @param hhcd HCD handle
2	mjames	309	* @retval None
		310	*/
		311	__weak void HAL_HCD_MspDeInit(HCD_HandleTypeDef *hhcd)
		312	{
		313	/* Prevent unused argument(s) compilation warning */
		314	UNUSED(hhcd);
9	mjames	315
		316	/* NOTE : This function should not be modified, when the callback is needed,
2	mjames	317	the HAL_HCD_MspDeInit could be implemented in the user file
		318	*/
		319	}
		320
		321	/**
		322	* @}
		323	*/
		324
9	mjames	325	/** @defgroup HCD_Exported_Functions_Group2 Input and Output operation functions
2	mjames	326	* @brief HCD IO operation functions
		327	*
		328	@verbatim
		329	===============================================================================
		330	##### IO operation functions #####
		331	===============================================================================
9	mjames	332	[..] This subsection provides a set of functions allowing to manage the USB Host Data
2	mjames	333	Transfer
9	mjames	334
2	mjames	335	@endverbatim
		336	* @{
		337	*/
		338
9	mjames	339	/**
		340	* @brief Submit a new URB for processing.
		341	* @param hhcd HCD handle
		342	* @param ch_num Channel number.
2	mjames	343	* This parameter can be a value from 1 to 15
9	mjames	344	* @param direction Channel number.
2	mjames	345	* This parameter can be one of these values:
		346	* 0 : Output / 1 : Input
9	mjames	347	* @param ep_type Endpoint Type.
2	mjames	348	* This parameter can be one of these values:
		349	* EP_TYPE_CTRL: Control type/
		350	* EP_TYPE_ISOC: Isochronous type/
		351	* EP_TYPE_BULK: Bulk type/
		352	* EP_TYPE_INTR: Interrupt type/
9	mjames	353	* @param token Endpoint Type.
2	mjames	354	* This parameter can be one of these values:
		355	* 0: HC_PID_SETUP / 1: HC_PID_DATA1
9	mjames	356	* @param pbuff pointer to URB data
		357	* @param length Length of URB data
		358	* @param do_ping activate do ping protocol (for high speed only).
2	mjames	359	* This parameter can be one of these values:
9	mjames	360	* 0 : do ping inactive / 1 : do ping active
2	mjames	361	* @retval HAL status
		362	*/
		363	HAL_StatusTypeDef HAL_HCD_HC_SubmitRequest(HCD_HandleTypeDef *hhcd,
9	mjames	364	uint8_t ch_num,
2	mjames	365	uint8_t direction,
9	mjames	366	uint8_t ep_type,
		367	uint8_t token,
		368	uint8_t *pbuff,
2	mjames	369	uint16_t length,
9	mjames	370	uint8_t do_ping)
2	mjames	371	{
		372	hhcd->hc[ch_num].ep_is_in = direction;
9	mjames	373	hhcd->hc[ch_num].ep_type = ep_type;
		374
		375	if (token == 0U)
2	mjames	376	{
		377	hhcd->hc[ch_num].data_pid = HC_PID_SETUP;
9	mjames	378	hhcd->hc[ch_num].do_ping = do_ping;
2	mjames	379	}
		380	else
		381	{
		382	hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
		383	}
9	mjames	384
2	mjames	385	/* Manage Data Toggle */
9	mjames	386	switch (ep_type)
2	mjames	387	{
9	mjames	388	case EP_TYPE_CTRL:
		389	if ((token == 1U) && (direction == 0U)) /send data /
2	mjames	390	{
9	mjames	391	if (length == 0U)
		392	{
		393	/* For Status OUT stage, Length==0, Status Out PID = 1 */
		394	hhcd->hc[ch_num].toggle_out = 1U;
		395	}
		396
		397	/* Set the Data Toggle bit as per the Flag */
		398	if (hhcd->hc[ch_num].toggle_out == 0U)
		399	{
		400	/* Put the PID 0 */
		401	hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
		402	}
		403	else
		404	{
		405	/* Put the PID 1 */
		406	hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
		407	}
2	mjames	408	}
9	mjames	409	break;
		410
		411	case EP_TYPE_BULK:
		412	if (direction == 0U)
2	mjames	413	{
9	mjames	414	/* Set the Data Toggle bit as per the Flag */
		415	if (hhcd->hc[ch_num].toggle_out == 0U)
		416	{
		417	/* Put the PID 0 */
		418	hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
		419	}
		420	else
		421	{
		422	/* Put the PID 1 */
		423	hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
		424	}
2	mjames	425	}
		426	else
		427	{
9	mjames	428	if (hhcd->hc[ch_num].toggle_in == 0U)
		429	{
		430	hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
		431	}
		432	else
		433	{
		434	hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
		435	}
2	mjames	436	}
9	mjames	437
		438	break;
		439	case EP_TYPE_INTR:
		440	if (direction == 0U)
2	mjames	441	{
9	mjames	442	/* Set the Data Toggle bit as per the Flag */
		443	if (hhcd->hc[ch_num].toggle_out == 0U)
		444	{
		445	/* Put the PID 0 */
		446	hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
		447	}
		448	else
		449	{
		450	/* Put the PID 1 */
		451	hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
		452	}
2	mjames	453	}
		454	else
		455	{
9	mjames	456	if (hhcd->hc[ch_num].toggle_in == 0U)
		457	{
		458	hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
		459	}
		460	else
		461	{
		462	hhcd->hc[ch_num].data_pid = HC_PID_DATA1;
		463	}
2	mjames	464	}
9	mjames	465	break;
		466
		467	case EP_TYPE_ISOC:
		468	hhcd->hc[ch_num].data_pid = HC_PID_DATA0;
		469	break;
		470
		471	default:
		472	break;
2	mjames	473	}
9	mjames	474
2	mjames	475	hhcd->hc[ch_num].xfer_buff = pbuff;
		476	hhcd->hc[ch_num].xfer_len = length;
		477	hhcd->hc[ch_num].urb_state = URB_IDLE;
		478	hhcd->hc[ch_num].xfer_count = 0U;
		479	hhcd->hc[ch_num].ch_num = ch_num;
		480	hhcd->hc[ch_num].state = HC_IDLE;
9	mjames	481
		482	return USB_HC_StartXfer(hhcd->Instance, &hhcd->hc[ch_num]);
2	mjames	483	}
		484
		485	/**
9	mjames	486	* @brief Handle HCD interrupt request.
		487	* @param hhcd HCD handle
2	mjames	488	* @retval None
		489	*/
		490	void HAL_HCD_IRQHandler(HCD_HandleTypeDef *hhcd)
		491	{
		492	USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
9	mjames	493	uint32_t USBx_BASE = (uint32_t)USBx;
		494	uint32_t i, interrupt;
2	mjames	495
9	mjames	496	/* Ensure that we are in device mode */
2	mjames	497	if (USB_GetMode(hhcd->Instance) == USB_OTG_MODE_HOST)
		498	{
		499	/* Avoid spurious interrupt */
9	mjames	500	if (__HAL_HCD_IS_INVALID_INTERRUPT(hhcd))
2	mjames	501	{
		502	return;
		503	}
9	mjames	504
		505	if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))
2	mjames	506	{
9	mjames	507	/* Incorrect mode, acknowledge the interrupt */
2	mjames	508	__HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);
		509	}
9	mjames	510
		511	if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR))
2	mjames	512	{
9	mjames	513	/* Incorrect mode, acknowledge the interrupt */
2	mjames	514	__HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_IISOIXFR);
		515	}
9	mjames	516
		517	if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE))
2	mjames	518	{
9	mjames	519	/* Incorrect mode, acknowledge the interrupt */
2	mjames	520	__HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_PTXFE);
		521	}
9	mjames	522
		523	if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_MMIS))
2	mjames	524	{
9	mjames	525	/* Incorrect mode, acknowledge the interrupt */
2	mjames	526	__HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_MMIS);
		527	}
9	mjames	528
2	mjames	529	/* Handle Host Disconnect Interrupts */
9	mjames	530	if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT))
2	mjames	531	{
		532	__HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_DISCINT);
9	mjames	533
		534	if ((USBx_HPRT0 & USB_OTG_HPRT_PCSTS) == 0U)
		535	{
		536	/* Handle Host Port Disconnect Interrupt */
		537	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
		538	hhcd->DisconnectCallback(hhcd);
		539	#else
		540	HAL_HCD_Disconnect_Callback(hhcd);
		541	#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
		542
		543	(void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_48_MHZ);
		544	}
2	mjames	545	}
9	mjames	546
2	mjames	547	/* Handle Host Port Interrupts */
9	mjames	548	if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HPRTINT))
2	mjames	549	{
9	mjames	550	HCD_Port_IRQHandler(hhcd);
2	mjames	551	}
9	mjames	552
		553	/* Handle Host SOF Interrupt */
		554	if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_SOF))
2	mjames	555	{
9	mjames	556	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
		557	hhcd->SOFCallback(hhcd);
		558	#else
2	mjames	559	HAL_HCD_SOF_Callback(hhcd);
9	mjames	560	#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
		561
2	mjames	562	__HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_SOF);
		563	}
9	mjames	564
		565	/* Handle Host channel Interrupt */
		566	if (__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_HCINT))
2	mjames	567	{
		568	interrupt = USB_HC_ReadInterrupt(hhcd->Instance);
9	mjames	569	for (i = 0U; i < hhcd->Init.Host_channels; i++)
2	mjames	570	{
9	mjames	571	if ((interrupt & (1UL << (i & 0xFU))) != 0U)
2	mjames	572	{
9	mjames	573	if ((USBx_HC(i)->HCCHAR & USB_OTG_HCCHAR_EPDIR) == USB_OTG_HCCHAR_EPDIR)
2	mjames	574	{
9	mjames	575	HCD_HC_IN_IRQHandler(hhcd, (uint8_t)i);
2	mjames	576	}
		577	else
		578	{
9	mjames	579	HCD_HC_OUT_IRQHandler(hhcd, (uint8_t)i);
2	mjames	580	}
		581	}
		582	}
		583	__HAL_HCD_CLEAR_FLAG(hhcd, USB_OTG_GINTSTS_HCINT);
9	mjames	584	}
		585
2	mjames	586	/* Handle Rx Queue Level Interrupts */
9	mjames	587	if ((__HAL_HCD_GET_FLAG(hhcd, USB_OTG_GINTSTS_RXFLVL)) != 0U)
2	mjames	588	{
		589	USB_MASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
9	mjames	590
		591	HCD_RXQLVL_IRQHandler(hhcd);
		592
2	mjames	593	USB_UNMASK_INTERRUPT(hhcd->Instance, USB_OTG_GINTSTS_RXFLVL);
		594	}
		595	}
		596	}
		597
9	mjames	598
2	mjames	599	/**
9	mjames	600	* @brief Handles HCD Wakeup interrupt request.
		601	* @param hhcd HCD handle
		602	* @retval HAL status
		603	*/
		604	void HAL_HCD_WKUP_IRQHandler(HCD_HandleTypeDef *hhcd)
		605	{
		606	UNUSED(hhcd);
		607	}
		608
		609
		610	/**
2	mjames	611	* @brief SOF callback.
9	mjames	612	* @param hhcd HCD handle
2	mjames	613	* @retval None
		614	*/
		615	__weak void HAL_HCD_SOF_Callback(HCD_HandleTypeDef *hhcd)
		616	{
		617	/* Prevent unused argument(s) compilation warning */
		618	UNUSED(hhcd);
9	mjames	619
		620	/* NOTE : This function should not be modified, when the callback is needed,
2	mjames	621	the HAL_HCD_SOF_Callback could be implemented in the user file
		622	*/
		623	}
		624
		625	/**
9	mjames	626	* @brief Connection Event callback.
		627	* @param hhcd HCD handle
2	mjames	628	* @retval None
		629	*/
		630	__weak void HAL_HCD_Connect_Callback(HCD_HandleTypeDef *hhcd)
		631	{
		632	/* Prevent unused argument(s) compilation warning */
		633	UNUSED(hhcd);
9	mjames	634
		635	/* NOTE : This function should not be modified, when the callback is needed,
2	mjames	636	the HAL_HCD_Connect_Callback could be implemented in the user file
		637	*/
		638	}
		639
		640	/**
9	mjames	641	* @brief Disconnection Event callback.
		642	* @param hhcd HCD handle
2	mjames	643	* @retval None
		644	*/
		645	__weak void HAL_HCD_Disconnect_Callback(HCD_HandleTypeDef *hhcd)
		646	{
		647	/* Prevent unused argument(s) compilation warning */
		648	UNUSED(hhcd);
9	mjames	649
		650	/* NOTE : This function should not be modified, when the callback is needed,
2	mjames	651	the HAL_HCD_Disconnect_Callback could be implemented in the user file
		652	*/
9	mjames	653	}
2	mjames	654
		655	/**
9	mjames	656	* @brief Port Enabled Event callback.
		657	* @param hhcd HCD handle
		658	* @retval None
		659	*/
		660	__weak void HAL_HCD_PortEnabled_Callback(HCD_HandleTypeDef *hhcd)
		661	{
		662	/* Prevent unused argument(s) compilation warning */
		663	UNUSED(hhcd);
		664
		665	/* NOTE : This function should not be modified, when the callback is needed,
		666	the HAL_HCD_Disconnect_Callback could be implemented in the user file
		667	*/
		668	}
		669
		670	/**
		671	* @brief Port Disabled Event callback.
		672	* @param hhcd HCD handle
		673	* @retval None
		674	*/
		675	__weak void HAL_HCD_PortDisabled_Callback(HCD_HandleTypeDef *hhcd)
		676	{
		677	/* Prevent unused argument(s) compilation warning */
		678	UNUSED(hhcd);
		679
		680	/* NOTE : This function should not be modified, when the callback is needed,
		681	the HAL_HCD_Disconnect_Callback could be implemented in the user file
		682	*/
		683	}
		684
		685	/**
2	mjames	686	* @brief Notify URB state change callback.
9	mjames	687	* @param hhcd HCD handle
		688	* @param chnum Channel number.
2	mjames	689	* This parameter can be a value from 1 to 15
		690	* @param urb_state:
		691	* This parameter can be one of these values:
		692	* URB_IDLE/
		693	* URB_DONE/
		694	* URB_NOTREADY/
9	mjames	695	* URB_NYET/
		696	* URB_ERROR/
2	mjames	697	* URB_STALL/
		698	* @retval None
		699	*/
		700	__weak void HAL_HCD_HC_NotifyURBChange_Callback(HCD_HandleTypeDef *hhcd, uint8_t chnum, HCD_URBStateTypeDef urb_state)
		701	{
		702	/* Prevent unused argument(s) compilation warning */
		703	UNUSED(hhcd);
		704	UNUSED(chnum);
		705	UNUSED(urb_state);
9	mjames	706
		707	/* NOTE : This function should not be modified, when the callback is needed,
2	mjames	708	the HAL_HCD_HC_NotifyURBChange_Callback could be implemented in the user file
		709	*/
		710	}
		711
9	mjames	712	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
2	mjames	713	/**
9	mjames	714	* @brief Register a User USB HCD Callback
		715	* To be used instead of the weak predefined callback
		716	* @param hhcd USB HCD handle
		717	* @param CallbackID ID of the callback to be registered
		718	* This parameter can be one of the following values:
		719	* @arg @ref HAL_HCD_SOF_CB_ID USB HCD SOF callback ID
		720	* @arg @ref HAL_HCD_CONNECT_CB_ID USB HCD Connect callback ID
		721	* @arg @ref HAL_HCD_DISCONNECT_CB_ID OTG HCD Disconnect callback ID
		722	* @arg @ref HAL_HCD_PORT_ENABLED_CB_ID USB HCD Port Enable callback ID
		723	* @arg @ref HAL_HCD_PORT_DISABLED_CB_ID USB HCD Port Disable callback ID
		724	* @arg @ref HAL_HCD_MSPINIT_CB_ID MspDeInit callback ID
		725	* @arg @ref HAL_HCD_MSPDEINIT_CB_ID MspDeInit callback ID
		726	* @param pCallback pointer to the Callback function
		727	* @retval HAL status
		728	*/
		729	HAL_StatusTypeDef HAL_HCD_RegisterCallback(HCD_HandleTypeDef *hhcd,
		730	HAL_HCD_CallbackIDTypeDef CallbackID,
		731	pHCD_CallbackTypeDef pCallback)
		732	{
		733	HAL_StatusTypeDef status = HAL_OK;
		734
		735	if (pCallback == NULL)
		736	{
		737	/* Update the error code */
		738	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		739	return HAL_ERROR;
		740	}
		741	/* Process locked */
		742	__HAL_LOCK(hhcd);
		743
		744	if (hhcd->State == HAL_HCD_STATE_READY)
		745	{
		746	switch (CallbackID)
		747	{
		748	case HAL_HCD_SOF_CB_ID :
		749	hhcd->SOFCallback = pCallback;
		750	break;
		751
		752	case HAL_HCD_CONNECT_CB_ID :
		753	hhcd->ConnectCallback = pCallback;
		754	break;
		755
		756	case HAL_HCD_DISCONNECT_CB_ID :
		757	hhcd->DisconnectCallback = pCallback;
		758	break;
		759
		760	case HAL_HCD_PORT_ENABLED_CB_ID :
		761	hhcd->PortEnabledCallback = pCallback;
		762	break;
		763
		764	case HAL_HCD_PORT_DISABLED_CB_ID :
		765	hhcd->PortDisabledCallback = pCallback;
		766	break;
		767
		768	case HAL_HCD_MSPINIT_CB_ID :
		769	hhcd->MspInitCallback = pCallback;
		770	break;
		771
		772	case HAL_HCD_MSPDEINIT_CB_ID :
		773	hhcd->MspDeInitCallback = pCallback;
		774	break;
		775
		776	default :
		777	/* Update the error code */
		778	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		779	/* Return error status */
		780	status = HAL_ERROR;
		781	break;
		782	}
		783	}
		784	else if (hhcd->State == HAL_HCD_STATE_RESET)
		785	{
		786	switch (CallbackID)
		787	{
		788	case HAL_HCD_MSPINIT_CB_ID :
		789	hhcd->MspInitCallback = pCallback;
		790	break;
		791
		792	case HAL_HCD_MSPDEINIT_CB_ID :
		793	hhcd->MspDeInitCallback = pCallback;
		794	break;
		795
		796	default :
		797	/* Update the error code */
		798	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		799	/* Return error status */
		800	status = HAL_ERROR;
		801	break;
		802	}
		803	}
		804	else
		805	{
		806	/* Update the error code */
		807	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		808	/* Return error status */
		809	status = HAL_ERROR;
		810	}
		811
		812	/* Release Lock */
		813	__HAL_UNLOCK(hhcd);
		814	return status;
		815	}
		816
		817	/**
		818	* @brief Unregister an USB HCD Callback
		819	* USB HCD callback is redirected to the weak predefined callback
		820	* @param hhcd USB HCD handle
		821	* @param CallbackID ID of the callback to be unregistered
		822	* This parameter can be one of the following values:
		823	* @arg @ref HAL_HCD_SOF_CB_ID USB HCD SOF callback ID
		824	* @arg @ref HAL_HCD_CONNECT_CB_ID USB HCD Connect callback ID
		825	* @arg @ref HAL_HCD_DISCONNECT_CB_ID OTG HCD Disconnect callback ID
		826	* @arg @ref HAL_HCD_PORT_ENABLED_CB_ID USB HCD Port Enabled callback ID
		827	* @arg @ref HAL_HCD_PORT_DISABLED_CB_ID USB HCD Port Disabled callback ID
		828	* @arg @ref HAL_HCD_MSPINIT_CB_ID MspDeInit callback ID
		829	* @arg @ref HAL_HCD_MSPDEINIT_CB_ID MspDeInit callback ID
		830	* @retval HAL status
		831	*/
		832	HAL_StatusTypeDef HAL_HCD_UnRegisterCallback(HCD_HandleTypeDef *hhcd, HAL_HCD_CallbackIDTypeDef CallbackID)
		833	{
		834	HAL_StatusTypeDef status = HAL_OK;
		835
		836	/* Process locked */
		837	__HAL_LOCK(hhcd);
		838
		839	/* Setup Legacy weak Callbacks */
		840	if (hhcd->State == HAL_HCD_STATE_READY)
		841	{
		842	switch (CallbackID)
		843	{
		844	case HAL_HCD_SOF_CB_ID :
		845	hhcd->SOFCallback = HAL_HCD_SOF_Callback;
		846	break;
		847
		848	case HAL_HCD_CONNECT_CB_ID :
		849	hhcd->ConnectCallback = HAL_HCD_Connect_Callback;
		850	break;
		851
		852	case HAL_HCD_DISCONNECT_CB_ID :
		853	hhcd->DisconnectCallback = HAL_HCD_Disconnect_Callback;
		854	break;
		855
		856	case HAL_HCD_PORT_ENABLED_CB_ID :
		857	hhcd->PortEnabledCallback = HAL_HCD_PortEnabled_Callback;
		858	break;
		859
		860	case HAL_HCD_PORT_DISABLED_CB_ID :
		861	hhcd->PortDisabledCallback = HAL_HCD_PortDisabled_Callback;
		862	break;
		863
		864	case HAL_HCD_MSPINIT_CB_ID :
		865	hhcd->MspInitCallback = HAL_HCD_MspInit;
		866	break;
		867
		868	case HAL_HCD_MSPDEINIT_CB_ID :
		869	hhcd->MspDeInitCallback = HAL_HCD_MspDeInit;
		870	break;
		871
		872	default :
		873	/* Update the error code */
		874	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		875
		876	/* Return error status */
		877	status = HAL_ERROR;
		878	break;
		879	}
		880	}
		881	else if (hhcd->State == HAL_HCD_STATE_RESET)
		882	{
		883	switch (CallbackID)
		884	{
		885	case HAL_HCD_MSPINIT_CB_ID :
		886	hhcd->MspInitCallback = HAL_HCD_MspInit;
		887	break;
		888
		889	case HAL_HCD_MSPDEINIT_CB_ID :
		890	hhcd->MspDeInitCallback = HAL_HCD_MspDeInit;
		891	break;
		892
		893	default :
		894	/* Update the error code */
		895	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		896
		897	/* Return error status */
		898	status = HAL_ERROR;
		899	break;
		900	}
		901	}
		902	else
		903	{
		904	/* Update the error code */
		905	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		906
		907	/* Return error status */
		908	status = HAL_ERROR;
		909	}
		910
		911	/* Release Lock */
		912	__HAL_UNLOCK(hhcd);
		913	return status;
		914	}
		915
		916	/**
		917	* @brief Register USB HCD Host Channel Notify URB Change Callback
		918	* To be used instead of the weak HAL_HCD_HC_NotifyURBChange_Callback() predefined callback
		919	* @param hhcd HCD handle
		920	* @param pCallback pointer to the USB HCD Host Channel Notify URB Change Callback function
		921	* @retval HAL status
		922	*/
		923	HAL_StatusTypeDef HAL_HCD_RegisterHC_NotifyURBChangeCallback(HCD_HandleTypeDef *hhcd,
		924	pHCD_HC_NotifyURBChangeCallbackTypeDef pCallback)
		925	{
		926	HAL_StatusTypeDef status = HAL_OK;
		927
		928	if (pCallback == NULL)
		929	{
		930	/* Update the error code */
		931	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		932
		933	return HAL_ERROR;
		934	}
		935
		936	/* Process locked */
		937	__HAL_LOCK(hhcd);
		938
		939	if (hhcd->State == HAL_HCD_STATE_READY)
		940	{
		941	hhcd->HC_NotifyURBChangeCallback = pCallback;
		942	}
		943	else
		944	{
		945	/* Update the error code */
		946	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		947
		948	/* Return error status */
		949	status = HAL_ERROR;
		950	}
		951
		952	/* Release Lock */
		953	__HAL_UNLOCK(hhcd);
		954
		955	return status;
		956	}
		957
		958	/**
		959	* @brief Unregister the USB HCD Host Channel Notify URB Change Callback
		960	* USB HCD Host Channel Notify URB Change Callback is redirected to the weak HAL_HCD_HC_NotifyURBChange_Callback() predefined callback
		961	* @param hhcd HCD handle
		962	* @retval HAL status
		963	*/
		964	HAL_StatusTypeDef HAL_HCD_UnRegisterHC_NotifyURBChangeCallback(HCD_HandleTypeDef *hhcd)
		965	{
		966	HAL_StatusTypeDef status = HAL_OK;
		967
		968	/* Process locked */
		969	__HAL_LOCK(hhcd);
		970
		971	if (hhcd->State == HAL_HCD_STATE_READY)
		972	{
		973	hhcd->HC_NotifyURBChangeCallback = HAL_HCD_HC_NotifyURBChange_Callback; /* Legacy weak DataOutStageCallback */
		974	}
		975	else
		976	{
		977	/* Update the error code */
		978	hhcd->ErrorCode \|= HAL_HCD_ERROR_INVALID_CALLBACK;
		979
		980	/* Return error status */
		981	status = HAL_ERROR;
		982	}
		983
		984	/* Release Lock */
		985	__HAL_UNLOCK(hhcd);
		986
		987	return status;
		988	}
		989	#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
		990
		991	/**
2	mjames	992	* @}
		993	*/
		994
		995	/** @defgroup HCD_Exported_Functions_Group3 Peripheral Control functions
9	mjames	996	* @brief Management functions
		997	*
2	mjames	998	@verbatim
		999	===============================================================================
		1000	##### Peripheral Control functions #####
		1001	===============================================================================
		1002	[..]
		1003	This subsection provides a set of functions allowing to control the HCD data
		1004	transfers.
		1005
		1006	@endverbatim
		1007	* @{
		1008	*/
		1009
		1010	/**
9	mjames	1011	* @brief Start the host driver.
		1012	* @param hhcd HCD handle
2	mjames	1013	* @retval HAL status
		1014	*/
		1015	HAL_StatusTypeDef HAL_HCD_Start(HCD_HandleTypeDef *hhcd)
		1016	{
		1017	__HAL_LOCK(hhcd);
		1018	__HAL_HCD_ENABLE(hhcd);
9	mjames	1019	(void)USB_DriveVbus(hhcd->Instance, 1U);
		1020	__HAL_UNLOCK(hhcd);
		1021
2	mjames	1022	return HAL_OK;
		1023	}
		1024
		1025	/**
9	mjames	1026	* @brief Stop the host driver.
		1027	* @param hhcd HCD handle
2	mjames	1028	* @retval HAL status
		1029	*/
		1030
		1031	HAL_StatusTypeDef HAL_HCD_Stop(HCD_HandleTypeDef *hhcd)
		1032	{
9	mjames	1033	__HAL_LOCK(hhcd);
		1034	(void)USB_StopHost(hhcd->Instance);
		1035	__HAL_UNLOCK(hhcd);
		1036
2	mjames	1037	return HAL_OK;
		1038	}
		1039
		1040	/**
9	mjames	1041	* @brief Reset the host port.
		1042	* @param hhcd HCD handle
2	mjames	1043	* @retval HAL status
		1044	*/
		1045	HAL_StatusTypeDef HAL_HCD_ResetPort(HCD_HandleTypeDef *hhcd)
		1046	{
		1047	return (USB_ResetPort(hhcd->Instance));
		1048	}
		1049
		1050	/**
		1051	* @}
		1052	*/
		1053
		1054	/** @defgroup HCD_Exported_Functions_Group4 Peripheral State functions
9	mjames	1055	* @brief Peripheral State functions
		1056	*
2	mjames	1057	@verbatim
		1058	===============================================================================
		1059	##### Peripheral State functions #####
		1060	===============================================================================
		1061	[..]
9	mjames	1062	This subsection permits to get in run-time the status of the peripheral
2	mjames	1063	and the data flow.
		1064
		1065	@endverbatim
		1066	* @{
		1067	*/
		1068
		1069	/**
9	mjames	1070	* @brief Return the HCD handle state.
		1071	* @param hhcd HCD handle
2	mjames	1072	* @retval HAL state
		1073	*/
		1074	HCD_StateTypeDef HAL_HCD_GetState(HCD_HandleTypeDef *hhcd)
		1075	{
		1076	return hhcd->State;
		1077	}
		1078
		1079	/**
9	mjames	1080	* @brief Return URB state for a channel.
		1081	* @param hhcd HCD handle
		1082	* @param chnum Channel number.
2	mjames	1083	* This parameter can be a value from 1 to 15
		1084	* @retval URB state.
		1085	* This parameter can be one of these values:
		1086	* URB_IDLE/
		1087	* URB_DONE/
		1088	* URB_NOTREADY/
9	mjames	1089	* URB_NYET/
2	mjames	1090	* URB_ERROR/
9	mjames	1091	* URB_STALL
2	mjames	1092	*/
		1093	HCD_URBStateTypeDef HAL_HCD_HC_GetURBState(HCD_HandleTypeDef *hhcd, uint8_t chnum)
		1094	{
		1095	return hhcd->hc[chnum].urb_state;
		1096	}
		1097
		1098
		1099	/**
9	mjames	1100	* @brief Return the last host transfer size.
		1101	* @param hhcd HCD handle
		1102	* @param chnum Channel number.
2	mjames	1103	* This parameter can be a value from 1 to 15
		1104	* @retval last transfer size in byte
		1105	*/
		1106	uint32_t HAL_HCD_HC_GetXferCount(HCD_HandleTypeDef *hhcd, uint8_t chnum)
		1107	{
		1108	return hhcd->hc[chnum].xfer_count;
		1109	}
		1110
		1111	/**
9	mjames	1112	* @brief Return the Host Channel state.
		1113	* @param hhcd HCD handle
		1114	* @param chnum Channel number.
2	mjames	1115	* This parameter can be a value from 1 to 15
		1116	* @retval Host channel state
9	mjames	1117	* This parameter can be one of these values:
2	mjames	1118	* HC_IDLE/
		1119	* HC_XFRC/
		1120	* HC_HALTED/
		1121	* HC_NYET/
		1122	* HC_NAK/
		1123	* HC_STALL/
		1124	* HC_XACTERR/
		1125	* HC_BBLERR/
9	mjames	1126	* HC_DATATGLERR
2	mjames	1127	*/
		1128	HCD_HCStateTypeDef HAL_HCD_HC_GetState(HCD_HandleTypeDef *hhcd, uint8_t chnum)
		1129	{
		1130	return hhcd->hc[chnum].state;
		1131	}
		1132
		1133	/**
9	mjames	1134	* @brief Return the current Host frame number.
		1135	* @param hhcd HCD handle
2	mjames	1136	* @retval Current Host frame number
		1137	*/
		1138	uint32_t HAL_HCD_GetCurrentFrame(HCD_HandleTypeDef *hhcd)
		1139	{
		1140	return (USB_GetCurrentFrame(hhcd->Instance));
		1141	}
		1142
		1143	/**
9	mjames	1144	* @brief Return the Host enumeration speed.
		1145	* @param hhcd HCD handle
2	mjames	1146	* @retval Enumeration speed
		1147	*/
		1148	uint32_t HAL_HCD_GetCurrentSpeed(HCD_HandleTypeDef *hhcd)
		1149	{
		1150	return (USB_GetHostSpeed(hhcd->Instance));
		1151	}
		1152
		1153	/**
		1154	* @}
		1155	*/
9	mjames	1156
2	mjames	1157	/**
		1158	* @}
		1159	*/
		1160
		1161	/** @addtogroup HCD_Private_Functions
		1162	* @{
		1163	*/
		1164	/**
9	mjames	1165	* @brief Handle Host Channel IN interrupt requests.
		1166	* @param hhcd HCD handle
		1167	* @param chnum Channel number.
2	mjames	1168	* This parameter can be a value from 1 to 15
		1169	* @retval none
		1170	*/
9	mjames	1171	static void HCD_HC_IN_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum)
2	mjames	1172	{
		1173	USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
9	mjames	1174	uint32_t USBx_BASE = (uint32_t)USBx;
		1175	uint32_t ch_num = (uint32_t)chnum;
		1176
		1177	uint32_t tmpreg;
		1178
		1179	if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
2	mjames	1180	{
9	mjames	1181	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);
		1182	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1183	}
		1184	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_BBERR) == USB_OTG_HCINT_BBERR)
2	mjames	1185	{
9	mjames	1186	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_BBERR);
		1187	hhcd->hc[ch_num].state = HC_BBLERR;
		1188	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1189	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
2	mjames	1190	}
9	mjames	1191	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
2	mjames	1192	{
9	mjames	1193	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);
2	mjames	1194	}
9	mjames	1195	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
2	mjames	1196	{
9	mjames	1197	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1198	hhcd->hc[ch_num].state = HC_STALL;
		1199	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
		1200	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);
		1201	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
2	mjames	1202	}
9	mjames	1203	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
2	mjames	1204	{
9	mjames	1205	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1206	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1207	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
		1208	hhcd->hc[ch_num].state = HC_DATATGLERR;
		1209	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_DTERR);
2	mjames	1210	}
9	mjames	1211	else
2	mjames	1212	{
9	mjames	1213	/* ... */
		1214	}
		1215
		1216	if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
		1217	{
		1218	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1219	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1220	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);
		1221	}
		1222	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
		1223	{
		1224	hhcd->hc[ch_num].state = HC_XFRC;
		1225	hhcd->hc[ch_num].ErrCnt = 0U;
		1226	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_XFRC);
		1227
		1228	if ((hhcd->hc[ch_num].ep_type == EP_TYPE_CTRL) \|\|
		1229	(hhcd->hc[ch_num].ep_type == EP_TYPE_BULK))
2	mjames	1230	{
9	mjames	1231	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1232	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1233	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
2	mjames	1234	}
9	mjames	1235	else if (hhcd->hc[ch_num].ep_type == EP_TYPE_INTR)
2	mjames	1236	{
9	mjames	1237	USBx_HC(ch_num)->HCCHAR \|= USB_OTG_HCCHAR_ODDFRM;
		1238	hhcd->hc[ch_num].urb_state = URB_DONE;
		1239
		1240	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
		1241	hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
		1242	#else
		1243	HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
		1244	#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
2	mjames	1245	}
9	mjames	1246	else if (hhcd->hc[ch_num].ep_type == EP_TYPE_ISOC)
		1247	{
		1248	hhcd->hc[ch_num].urb_state = URB_DONE;
		1249	hhcd->hc[ch_num].toggle_in ^= 1U;
		1250
		1251	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
		1252	hhcd->HC_NotifyURBChangeCallback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
		1253	#else
		1254	HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
		1255	#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
		1256	}
		1257	else
		1258	{
		1259	/* ... */
		1260	}
		1261	hhcd->hc[ch_num].toggle_in ^= 1U;
		1262
2	mjames	1263	}
9	mjames	1264	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
2	mjames	1265	{
9	mjames	1266	__HAL_HCD_MASK_HALT_HC_INT(ch_num);
		1267
		1268	if (hhcd->hc[ch_num].state == HC_XFRC)
2	mjames	1269	{
9	mjames	1270	hhcd->hc[ch_num].urb_state = URB_DONE;
2	mjames	1271	}
9	mjames	1272	else if (hhcd->hc[ch_num].state == HC_STALL)
2	mjames	1273	{
9	mjames	1274	hhcd->hc[ch_num].urb_state = URB_STALL;
2	mjames	1275	}
9	mjames	1276	else if ((hhcd->hc[ch_num].state == HC_XACTERR) \|\|
		1277	(hhcd->hc[ch_num].state == HC_DATATGLERR))
2	mjames	1278	{
9	mjames	1279	hhcd->hc[ch_num].ErrCnt++;
		1280	if (hhcd->hc[ch_num].ErrCnt > 3U)
2	mjames	1281	{
9	mjames	1282	hhcd->hc[ch_num].ErrCnt = 0U;
		1283	hhcd->hc[ch_num].urb_state = URB_ERROR;
2	mjames	1284	}
		1285	else
		1286	{
9	mjames	1287	hhcd->hc[ch_num].urb_state = URB_NOTREADY;
2	mjames	1288	}
9	mjames	1289
2	mjames	1290	/* re-activate the channel */
9	mjames	1291	tmpreg = USBx_HC(ch_num)->HCCHAR;
2	mjames	1292	tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
		1293	tmpreg \|= USB_OTG_HCCHAR_CHENA;
9	mjames	1294	USBx_HC(ch_num)->HCCHAR = tmpreg;
2	mjames	1295	}
9	mjames	1296	else if (hhcd->hc[ch_num].state == HC_NAK)
		1297	{
		1298	hhcd->hc[ch_num].urb_state = URB_NOTREADY;
		1299	/* re-activate the channel */
		1300	tmpreg = USBx_HC(ch_num)->HCCHAR;
		1301	tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
		1302	tmpreg \|= USB_OTG_HCCHAR_CHENA;
		1303	USBx_HC(ch_num)->HCCHAR = tmpreg;
		1304	}
		1305	else if (hhcd->hc[ch_num].state == HC_BBLERR)
		1306	{
		1307	hhcd->hc[ch_num].ErrCnt++;
		1308	hhcd->hc[ch_num].urb_state = URB_ERROR;
		1309	}
		1310	else
		1311	{
		1312	/* ... */
		1313	}
		1314	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_CHH);
		1315	HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
2	mjames	1316	}
9	mjames	1317	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
2	mjames	1318	{
9	mjames	1319	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1320	hhcd->hc[ch_num].ErrCnt++;
		1321	hhcd->hc[ch_num].state = HC_XACTERR;
		1322	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1323	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);
2	mjames	1324	}
9	mjames	1325	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
2	mjames	1326	{
9	mjames	1327	if (hhcd->hc[ch_num].ep_type == EP_TYPE_INTR)
2	mjames	1328	{
9	mjames	1329	hhcd->hc[ch_num].ErrCnt = 0U;
		1330	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1331	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
2	mjames	1332	}
9	mjames	1333	else if ((hhcd->hc[ch_num].ep_type == EP_TYPE_CTRL) \|\|
		1334	(hhcd->hc[ch_num].ep_type == EP_TYPE_BULK))
2	mjames	1335	{
9	mjames	1336	hhcd->hc[ch_num].ErrCnt = 0U;
		1337	hhcd->hc[ch_num].state = HC_NAK;
		1338	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1339	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
2	mjames	1340	}
9	mjames	1341	else
		1342	{
		1343	/* ... */
		1344	}
		1345	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
2	mjames	1346	}
9	mjames	1347	else
		1348	{
		1349	/* ... */
		1350	}
2	mjames	1351	}
		1352
		1353	/**
9	mjames	1354	* @brief Handle Host Channel OUT interrupt requests.
		1355	* @param hhcd HCD handle
		1356	* @param chnum Channel number.
2	mjames	1357	* This parameter can be a value from 1 to 15
		1358	* @retval none
		1359	*/
9	mjames	1360	static void HCD_HC_OUT_IRQHandler(HCD_HandleTypeDef *hhcd, uint8_t chnum)
2	mjames	1361	{
		1362	USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
9	mjames	1363	uint32_t USBx_BASE = (uint32_t)USBx;
		1364	uint32_t ch_num = (uint32_t)chnum;
		1365	uint32_t tmpreg;
		1366
		1367	if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_AHBERR) == USB_OTG_HCINT_AHBERR)
2	mjames	1368	{
9	mjames	1369	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_AHBERR);
		1370	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
2	mjames	1371	}
9	mjames	1372	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_ACK) == USB_OTG_HCINT_ACK)
2	mjames	1373	{
9	mjames	1374	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_ACK);
		1375
		1376	if (hhcd->hc[ch_num].do_ping == 1U)
2	mjames	1377	{
9	mjames	1378	hhcd->hc[ch_num].do_ping = 0U;
		1379	hhcd->hc[ch_num].urb_state = URB_NOTREADY;
		1380	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1381	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
2	mjames	1382	}
		1383	}
9	mjames	1384	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NYET) == USB_OTG_HCINT_NYET)
2	mjames	1385	{
9	mjames	1386	hhcd->hc[ch_num].state = HC_NYET;
		1387	hhcd->hc[ch_num].do_ping = 1U;
		1388	hhcd->hc[ch_num].ErrCnt = 0U;
		1389	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1390	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1391	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NYET);
2	mjames	1392	}
9	mjames	1393	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_FRMOR) == USB_OTG_HCINT_FRMOR)
2	mjames	1394	{
9	mjames	1395	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1396	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1397	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_FRMOR);
2	mjames	1398	}
9	mjames	1399	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_XFRC) == USB_OTG_HCINT_XFRC)
2	mjames	1400	{
9	mjames	1401	hhcd->hc[ch_num].ErrCnt = 0U;
		1402	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1403	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1404	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_XFRC);
		1405	hhcd->hc[ch_num].state = HC_XFRC;
2	mjames	1406	}
9	mjames	1407	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_STALL) == USB_OTG_HCINT_STALL)
2	mjames	1408	{
9	mjames	1409	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_STALL);
		1410	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1411	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1412	hhcd->hc[ch_num].state = HC_STALL;
2	mjames	1413	}
9	mjames	1414	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_NAK) == USB_OTG_HCINT_NAK)
2	mjames	1415	{
9	mjames	1416	hhcd->hc[ch_num].ErrCnt = 0U;
		1417	hhcd->hc[ch_num].state = HC_NAK;
		1418
		1419	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1420	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1421	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
2	mjames	1422	}
9	mjames	1423	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_TXERR) == USB_OTG_HCINT_TXERR)
2	mjames	1424	{
9	mjames	1425	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1426	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1427	hhcd->hc[ch_num].state = HC_XACTERR;
		1428	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_TXERR);
2	mjames	1429	}
9	mjames	1430	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_DTERR) == USB_OTG_HCINT_DTERR)
2	mjames	1431	{
9	mjames	1432	__HAL_HCD_UNMASK_HALT_HC_INT(ch_num);
		1433	(void)USB_HC_Halt(hhcd->Instance, (uint8_t)ch_num);
		1434	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_NAK);
		1435	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_DTERR);
		1436	hhcd->hc[ch_num].state = HC_DATATGLERR;
2	mjames	1437	}
9	mjames	1438	else if ((USBx_HC(ch_num)->HCINT & USB_OTG_HCINT_CHH) == USB_OTG_HCINT_CHH)
2	mjames	1439	{
9	mjames	1440	__HAL_HCD_MASK_HALT_HC_INT(ch_num);
		1441
		1442	if (hhcd->hc[ch_num].state == HC_XFRC)
2	mjames	1443	{
9	mjames	1444	hhcd->hc[ch_num].urb_state = URB_DONE;
		1445	if ((hhcd->hc[ch_num].ep_type == EP_TYPE_BULK) \|\|
		1446	(hhcd->hc[ch_num].ep_type == EP_TYPE_INTR))
2	mjames	1447	{
9	mjames	1448	hhcd->hc[ch_num].toggle_out ^= 1U;
2	mjames	1449	}
		1450	}
9	mjames	1451	else if (hhcd->hc[ch_num].state == HC_NAK)
2	mjames	1452	{
9	mjames	1453	hhcd->hc[ch_num].urb_state = URB_NOTREADY;
2	mjames	1454	}
9	mjames	1455	else if (hhcd->hc[ch_num].state == HC_NYET)
2	mjames	1456	{
9	mjames	1457	hhcd->hc[ch_num].urb_state = URB_NOTREADY;
2	mjames	1458	}
9	mjames	1459	else if (hhcd->hc[ch_num].state == HC_STALL)
2	mjames	1460	{
9	mjames	1461	hhcd->hc[ch_num].urb_state = URB_STALL;
2	mjames	1462	}
9	mjames	1463	else if ((hhcd->hc[ch_num].state == HC_XACTERR) \|\|
		1464	(hhcd->hc[ch_num].state == HC_DATATGLERR))
2	mjames	1465	{
9	mjames	1466	hhcd->hc[ch_num].ErrCnt++;
		1467	if (hhcd->hc[ch_num].ErrCnt > 3U)
2	mjames	1468	{
9	mjames	1469	hhcd->hc[ch_num].ErrCnt = 0U;
		1470	hhcd->hc[ch_num].urb_state = URB_ERROR;
2	mjames	1471	}
		1472	else
		1473	{
9	mjames	1474	hhcd->hc[ch_num].urb_state = URB_NOTREADY;
2	mjames	1475	}
9	mjames	1476
2	mjames	1477	/* re-activate the channel */
9	mjames	1478	tmpreg = USBx_HC(ch_num)->HCCHAR;
2	mjames	1479	tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
		1480	tmpreg \|= USB_OTG_HCCHAR_CHENA;
9	mjames	1481	USBx_HC(ch_num)->HCCHAR = tmpreg;
2	mjames	1482	}
9	mjames	1483	else
		1484	{
		1485	/* ... */
		1486	}
		1487
		1488	__HAL_HCD_CLEAR_HC_INT(ch_num, USB_OTG_HCINT_CHH);
		1489	HAL_HCD_HC_NotifyURBChange_Callback(hhcd, (uint8_t)ch_num, hhcd->hc[ch_num].urb_state);
2	mjames	1490	}
9	mjames	1491	else
		1492	{
		1493	/* ... */
		1494	}
2	mjames	1495	}
		1496
		1497	/**
9	mjames	1498	* @brief Handle Rx Queue Level interrupt requests.
		1499	* @param hhcd HCD handle
2	mjames	1500	* @retval none
		1501	*/
9	mjames	1502	static void HCD_RXQLVL_IRQHandler(HCD_HandleTypeDef *hhcd)
2	mjames	1503	{
		1504	USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
9	mjames	1505	uint32_t USBx_BASE = (uint32_t)USBx;
		1506	uint32_t pktsts;
		1507	uint32_t pktcnt;
		1508	uint32_t temp;
		1509	uint32_t tmpreg;
		1510	uint32_t ch_num;
		1511
2	mjames	1512	temp = hhcd->Instance->GRXSTSP;
9	mjames	1513	ch_num = temp & USB_OTG_GRXSTSP_EPNUM;
		1514	pktsts = (temp & USB_OTG_GRXSTSP_PKTSTS) >> 17;
		1515	pktcnt = (temp & USB_OTG_GRXSTSP_BCNT) >> 4;
		1516
2	mjames	1517	switch (pktsts)
		1518	{
9	mjames	1519	case GRXSTS_PKTSTS_IN:
		1520	/* Read the data into the host buffer. */
		1521	if ((pktcnt > 0U) && (hhcd->hc[ch_num].xfer_buff != (void *)0))
2	mjames	1522	{
9	mjames	1523	(void)USB_ReadPacket(hhcd->Instance, hhcd->hc[ch_num].xfer_buff, (uint16_t)pktcnt);
		1524
		1525	/manage multiple Xfer /
		1526	hhcd->hc[ch_num].xfer_buff += pktcnt;
		1527	hhcd->hc[ch_num].xfer_count += pktcnt;
		1528
		1529	if ((USBx_HC(ch_num)->HCTSIZ & USB_OTG_HCTSIZ_PKTCNT) > 0U)
		1530	{
		1531	/* re-activate the channel when more packets are expected */
		1532	tmpreg = USBx_HC(ch_num)->HCCHAR;
		1533	tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
		1534	tmpreg \|= USB_OTG_HCCHAR_CHENA;
		1535	USBx_HC(ch_num)->HCCHAR = tmpreg;
		1536	hhcd->hc[ch_num].toggle_in ^= 1U;
		1537	}
2	mjames	1538	}
9	mjames	1539	break;
		1540
		1541	case GRXSTS_PKTSTS_DATA_TOGGLE_ERR:
		1542	break;
		1543
		1544	case GRXSTS_PKTSTS_IN_XFER_COMP:
		1545	case GRXSTS_PKTSTS_CH_HALTED:
		1546	default:
		1547	break;
2	mjames	1548	}
		1549	}
		1550
		1551	/**
9	mjames	1552	* @brief Handle Host Port interrupt requests.
		1553	* @param hhcd HCD handle
2	mjames	1554	* @retval None
		1555	*/
9	mjames	1556	static void HCD_Port_IRQHandler(HCD_HandleTypeDef *hhcd)
2	mjames	1557	{
9	mjames	1558	USB_OTG_GlobalTypeDef *USBx = hhcd->Instance;
		1559	uint32_t USBx_BASE = (uint32_t)USBx;
		1560	__IO uint32_t hprt0, hprt0_dup;
		1561
2	mjames	1562	/* Handle Host Port Interrupts */
		1563	hprt0 = USBx_HPRT0;
		1564	hprt0_dup = USBx_HPRT0;
9	mjames	1565
		1566	hprt0_dup &= ~(USB_OTG_HPRT_PENA \| USB_OTG_HPRT_PCDET \| \
		1567	USB_OTG_HPRT_PENCHNG \| USB_OTG_HPRT_POCCHNG);
		1568
		1569	/* Check whether Port Connect detected */
		1570	if ((hprt0 & USB_OTG_HPRT_PCDET) == USB_OTG_HPRT_PCDET)
2	mjames	1571	{
9	mjames	1572	if ((hprt0 & USB_OTG_HPRT_PCSTS) == USB_OTG_HPRT_PCSTS)
2	mjames	1573	{
9	mjames	1574	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
		1575	hhcd->ConnectCallback(hhcd);
		1576	#else
2	mjames	1577	HAL_HCD_Connect_Callback(hhcd);
9	mjames	1578	#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
2	mjames	1579	}
		1580	hprt0_dup \|= USB_OTG_HPRT_PCDET;
		1581	}
9	mjames	1582
2	mjames	1583	/* Check whether Port Enable Changed */
9	mjames	1584	if ((hprt0 & USB_OTG_HPRT_PENCHNG) == USB_OTG_HPRT_PENCHNG)
2	mjames	1585	{
		1586	hprt0_dup \|= USB_OTG_HPRT_PENCHNG;
9	mjames	1587
		1588	if ((hprt0 & USB_OTG_HPRT_PENA) == USB_OTG_HPRT_PENA)
2	mjames	1589	{
9	mjames	1590	if (hhcd->Init.phy_itface == USB_OTG_EMBEDDED_PHY)
2	mjames	1591	{
9	mjames	1592	if ((hprt0 & USB_OTG_HPRT_PSPD) == (HPRT0_PRTSPD_LOW_SPEED << 17))
		1593	{
		1594	(void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_6_MHZ);
		1595	}
		1596	else
		1597	{
		1598	(void)USB_InitFSLSPClkSel(hhcd->Instance, HCFG_48_MHZ);
		1599	}
2	mjames	1600	}
		1601	else
		1602	{
9	mjames	1603	if (hhcd->Init.speed == HCD_SPEED_FULL)
		1604	{
		1605	USBx_HOST->HFIR = 60000U;
		1606	}
2	mjames	1607	}
9	mjames	1608	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
		1609	hhcd->PortEnabledCallback(hhcd);
		1610	#else
		1611	HAL_HCD_PortEnabled_Callback(hhcd);
		1612	#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
		1613
2	mjames	1614	}
		1615	else
		1616	{
9	mjames	1617	#if (USE_HAL_HCD_REGISTER_CALLBACKS == 1U)
		1618	hhcd->PortDisabledCallback(hhcd);
		1619	#else
		1620	HAL_HCD_PortDisabled_Callback(hhcd);
		1621	#endif /* USE_HAL_HCD_REGISTER_CALLBACKS */
2	mjames	1622	}
		1623	}
9	mjames	1624
		1625	/* Check for an overcurrent */
		1626	if ((hprt0 & USB_OTG_HPRT_POCCHNG) == USB_OTG_HPRT_POCCHNG)
2	mjames	1627	{
		1628	hprt0_dup \|= USB_OTG_HPRT_POCCHNG;
		1629	}
9	mjames	1630
2	mjames	1631	/* Clear Port Interrupts */
		1632	USBx_HPRT0 = hprt0_dup;
		1633	}
		1634
		1635	/**
		1636	* @}
		1637	*/
		1638
		1639	/**
		1640	* @}
		1641	*/
		1642
9	mjames	1643	#endif /* defined (USB_OTG_FS) */
2	mjames	1644	#endif /* HAL_HCD_MODULE_ENABLED */
		1645
		1646	/**
		1647	* @}
		1648	*/
		1649
9	mjames	1650	/**
		1651	* @}
		1652	*/
		1653
2	mjames	1654	/********************** (C) COPYRIGHT STMicroelectronics *END OF FILE**/

Subversion Repositories LedShow

(root)/trunk/Drivers/STM32F1xx_HAL_Driver/Src/stm32f1xx_hal_hcd.c – Rev 9