WebSVN – DashDisplay – Diff – /branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_pcd.c



  *          @arg @ref HAL_PCD_MSPINIT_CB_ID MspDeInit callback ID
  *          @arg @ref HAL_PCD_MSPDEINIT_CB_ID MspDeInit callback ID
  * @param  pCallback pointer to the Callback function
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_PCD_RegisterCallback(PCD_HandleTypeDef *hpcd,
                                           HAL_PCD_CallbackIDTypeDef CallbackID,
                                           pPCD_CallbackTypeDef pCallback)
{
  HAL_StatusTypeDef status = HAL_OK;
 
  if (pCallback == NULL)
  {

  *         To be used instead of the weak HAL_PCD_DataOutStageCallback() predefined callback
  * @param  hpcd PCD handle
  * @param  pCallback pointer to the USB PCD Data OUT Stage Callback function
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_PCD_RegisterDataOutStageCallback(PCD_HandleTypeDef *hpcd,
                                                       pPCD_DataOutStageCallbackTypeDef pCallback)
{
  HAL_StatusTypeDef status = HAL_OK;
 
  if (pCallback == NULL)
  {

  *         To be used instead of the weak HAL_PCD_DataInStageCallback() predefined callback
  * @param  hpcd PCD handle
  * @param  pCallback pointer to the USB PCD Data IN Stage Callback function
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_PCD_RegisterDataInStageCallback(PCD_HandleTypeDef *hpcd,
                                                      pPCD_DataInStageCallbackTypeDef pCallback)
{
  HAL_StatusTypeDef status = HAL_OK;
 
  if (pCallback == NULL)
  {

  *         To be used instead of the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
  * @param  hpcd PCD handle
  * @param  pCallback pointer to the USB PCD Iso OUT incomplete Callback function
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_PCD_RegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd,
                                                       pPCD_IsoOutIncpltCallbackTypeDef pCallback)
{
  HAL_StatusTypeDef status = HAL_OK;
 
  if (pCallback == NULL)
  {

  return status;
}
 
/**
  * @brief  Unregister the USB PCD Iso OUT incomplete Callback
  *         USB PCD Iso OUT incomplete Callback is redirected
  *         to the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
  * @param  hpcd PCD handle
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_PCD_UnRegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd)
{

  *         To be used instead of the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
  * @param  hpcd PCD handle
  * @param  pCallback pointer to the USB PCD Iso IN incomplete Callback function
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_PCD_RegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd,
                                                      pPCD_IsoInIncpltCallbackTypeDef pCallback)
{
  HAL_StatusTypeDef status = HAL_OK;
 
  if (pCallback == NULL)
  {

  return status;
}
 
/**
  * @brief  Unregister the USB PCD Iso IN incomplete Callback
  *         USB PCD Iso IN incomplete Callback is redirected
  *         to the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
  * @param  hpcd PCD handle
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_PCD_UnRegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd)
{

  * @param  ep_addr endpoint address
  * @param  ep_mps endpoint max packet size
  * @param  ep_type endpoint type
  * @retval HAL status
  */
HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr,
                                  uint16_t ep_mps, uint8_t ep_type)
{
  HAL_StatusTypeDef  ret = HAL_OK;
  PCD_EPTypeDef *ep;
 
  if ((ep_addr & 0x80U) == 0x80U)

  ep->num = ep_addr & EP_ADDR_MSK;
 
  __HAL_LOCK(hpcd);
 
  (void)USB_EPSetStall(hpcd->Instance, ep);
 
 
 
 
  __HAL_UNLOCK(hpcd);
 
  return HAL_OK;
}
 

 
  /* stay in loop while pending interrupts */
  while ((hpcd->Instance->ISTR & USB_ISTR_CTR) != 0U)
  {
    wIstr = hpcd->Instance->ISTR;
 
    /* extract highest priority endpoint number */
    epindex = (uint8_t)(wIstr & USB_ISTR_EP_ID);
 
    if (epindex == 0U)
    {

#else
            HAL_PCD_DataOutStageCallback(hpcd, 0U);
#endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
          }
 
          if ((PCD_GET_ENDPOINT(hpcd->Instance, PCD_ENDP0) & USB_EP_SETUP) == 0U)
          {
            PCD_SET_EP_RX_CNT(hpcd->Instance, PCD_ENDP0, ep->maxpacket);
            PCD_SET_EP_RX_STATUS(hpcd->Instance, PCD_ENDP0, USB_EP_RX_VALID);
          }
        }
      }
    }
    else
    {

        ep = &hpcd->IN_ep[epindex];
 
        /* clear int flag */
        PCD_CLEAR_TX_EP_CTR(hpcd->Instance, epindex);
 
        /* Manage all non bulk/isoc transaction Bulk Single Buffer Transaction */
        if ((ep->type == EP_TYPE_INTR) || (ep->type == EP_TYPE_CTRL) ||
           ((ep->type == EP_TYPE_BULK) && ((wEPVal & USB_EP_KIND) == 0U)))
        {
          /* multi-packet on the NON control IN endpoint */
          TxByteNbre = (uint16_t)PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
 
          if (ep->xfer_len > TxByteNbre)

            ep->xfer_buff += TxByteNbre;
            ep->xfer_count += TxByteNbre;
            (void)USB_EPStartXfer(hpcd->Instance, ep);
          }
        }
        /* Double Buffer Iso/bulk IN (bulk transfer Len > Ep_Mps) */
        else
        {
          (void)HAL_PCD_EP_DB_Transmit(hpcd, ep, wEPVal);
        }
      }

      ep->xfer_len = 0U;
    }
    /* Transfer is completed */
    if (ep->xfer_len == 0U)
    {
      PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
      PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
 
      /* TX COMPLETE */
#if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
      hpcd->DataInStageCallback(hpcd, ep->num);
#else
      HAL_PCD_DataInStageCallback(hpcd, ep->num);

    }
 
    /* Transfer is completed */
    if (ep->xfer_len == 0U)
    {
      PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
      PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
 
      /* TX COMPLETE */
#if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
      hpcd->DataInStageCallback(hpcd, ep->num);
#else
      HAL_PCD_DataInStageCallback(hpcd, ep->num);
#endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
 
      /* need to Free USB Buff */
      if ((wEPVal & USB_EP_DTOG_RX) == 0U)
      {
        PCD_FreeUserBuffer(hpcd->Instance, ep->num, 1U);
      }
    }

Rev 56	Rev 61
Line 287...	Line 287...
287	* @arg @ref HAL_PCD_MSPINIT_CB_ID MspDeInit callback ID	287	* @arg @ref HAL_PCD_MSPINIT_CB_ID MspDeInit callback ID
288	* @arg @ref HAL_PCD_MSPDEINIT_CB_ID MspDeInit callback ID	288	* @arg @ref HAL_PCD_MSPDEINIT_CB_ID MspDeInit callback ID
289	* @param pCallback pointer to the Callback function	289	* @param pCallback pointer to the Callback function
290	* @retval HAL status	290	* @retval HAL status
291	*/	291	*/
292	HAL_StatusTypeDef HAL_PCD_RegisterCallback(PCD_HandleTypeDef *hpcd, HAL_PCD_CallbackIDTypeDef CallbackID, pPCD_CallbackTypeDef pCallback)	292	HAL_StatusTypeDef HAL_PCD_RegisterCallback(PCD_HandleTypeDef *hpcd,
-		293	HAL_PCD_CallbackIDTypeDef CallbackID,
-		294	pPCD_CallbackTypeDef pCallback)
293	{	295	{
294	HAL_StatusTypeDef status = HAL_OK;	296	HAL_StatusTypeDef status = HAL_OK;
295		297
296	if (pCallback == NULL)	298	if (pCallback == NULL)
297	{	299	{
Line 497...	Line 499...
497	* To be used instead of the weak HAL_PCD_DataOutStageCallback() predefined callback	499	* To be used instead of the weak HAL_PCD_DataOutStageCallback() predefined callback
498	* @param hpcd PCD handle	500	* @param hpcd PCD handle
499	* @param pCallback pointer to the USB PCD Data OUT Stage Callback function	501	* @param pCallback pointer to the USB PCD Data OUT Stage Callback function
500	* @retval HAL status	502	* @retval HAL status
501	*/	503	*/
502	HAL_StatusTypeDef HAL_PCD_RegisterDataOutStageCallback(PCD_HandleTypeDef *hpcd, pPCD_DataOutStageCallbackTypeDef pCallback)	504	HAL_StatusTypeDef HAL_PCD_RegisterDataOutStageCallback(PCD_HandleTypeDef *hpcd,
-		505	pPCD_DataOutStageCallbackTypeDef pCallback)
503	{	506	{
504	HAL_StatusTypeDef status = HAL_OK;	507	HAL_StatusTypeDef status = HAL_OK;
505		508
506	if (pCallback == NULL)	509	if (pCallback == NULL)
507	{	510	{
Line 570...	Line 573...
570	* To be used instead of the weak HAL_PCD_DataInStageCallback() predefined callback	573	* To be used instead of the weak HAL_PCD_DataInStageCallback() predefined callback
571	* @param hpcd PCD handle	574	* @param hpcd PCD handle
572	* @param pCallback pointer to the USB PCD Data IN Stage Callback function	575	* @param pCallback pointer to the USB PCD Data IN Stage Callback function
573	* @retval HAL status	576	* @retval HAL status
574	*/	577	*/
575	HAL_StatusTypeDef HAL_PCD_RegisterDataInStageCallback(PCD_HandleTypeDef *hpcd, pPCD_DataInStageCallbackTypeDef pCallback)	578	HAL_StatusTypeDef HAL_PCD_RegisterDataInStageCallback(PCD_HandleTypeDef *hpcd,
-		579	pPCD_DataInStageCallbackTypeDef pCallback)
576	{	580	{
577	HAL_StatusTypeDef status = HAL_OK;	581	HAL_StatusTypeDef status = HAL_OK;
578		582
579	if (pCallback == NULL)	583	if (pCallback == NULL)
580	{	584	{
Line 643...	Line 647...
643	* To be used instead of the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback	647	* To be used instead of the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
644	* @param hpcd PCD handle	648	* @param hpcd PCD handle
645	* @param pCallback pointer to the USB PCD Iso OUT incomplete Callback function	649	* @param pCallback pointer to the USB PCD Iso OUT incomplete Callback function
646	* @retval HAL status	650	* @retval HAL status
647	*/	651	*/
648	HAL_StatusTypeDef HAL_PCD_RegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd, pPCD_IsoOutIncpltCallbackTypeDef pCallback)	652	HAL_StatusTypeDef HAL_PCD_RegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd,
-		653	pPCD_IsoOutIncpltCallbackTypeDef pCallback)
649	{	654	{
650	HAL_StatusTypeDef status = HAL_OK;	655	HAL_StatusTypeDef status = HAL_OK;
651		656
652	if (pCallback == NULL)	657	if (pCallback == NULL)
653	{	658	{
Line 679...	Line 684...
679	return status;	684	return status;
680	}	685	}
681		686
682	/**	687	/**
683	* @brief Unregister the USB PCD Iso OUT incomplete Callback	688	* @brief Unregister the USB PCD Iso OUT incomplete Callback
-		689	* USB PCD Iso OUT incomplete Callback is redirected
684	* USB PCD Iso OUT incomplete Callback is redirected to the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback	690	* to the weak HAL_PCD_ISOOUTIncompleteCallback() predefined callback
685	* @param hpcd PCD handle	691	* @param hpcd PCD handle
686	* @retval HAL status	692	* @retval HAL status
687	*/	693	*/
688	HAL_StatusTypeDef HAL_PCD_UnRegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd)	694	HAL_StatusTypeDef HAL_PCD_UnRegisterIsoOutIncpltCallback(PCD_HandleTypeDef *hpcd)
689	{	695	{
Line 716...	Line 722...
716	* To be used instead of the weak HAL_PCD_ISOINIncompleteCallback() predefined callback	722	* To be used instead of the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
717	* @param hpcd PCD handle	723	* @param hpcd PCD handle
718	* @param pCallback pointer to the USB PCD Iso IN incomplete Callback function	724	* @param pCallback pointer to the USB PCD Iso IN incomplete Callback function
719	* @retval HAL status	725	* @retval HAL status
720	*/	726	*/
721	HAL_StatusTypeDef HAL_PCD_RegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd, pPCD_IsoInIncpltCallbackTypeDef pCallback)	727	HAL_StatusTypeDef HAL_PCD_RegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd,
-		728	pPCD_IsoInIncpltCallbackTypeDef pCallback)
722	{	729	{
723	HAL_StatusTypeDef status = HAL_OK;	730	HAL_StatusTypeDef status = HAL_OK;
724		731
725	if (pCallback == NULL)	732	if (pCallback == NULL)
726	{	733	{
Line 752...	Line 759...
752	return status;	759	return status;
753	}	760	}
754		761
755	/**	762	/**
756	* @brief Unregister the USB PCD Iso IN incomplete Callback	763	* @brief Unregister the USB PCD Iso IN incomplete Callback
-		764	* USB PCD Iso IN incomplete Callback is redirected
757	* USB PCD Iso IN incomplete Callback is redirected to the weak HAL_PCD_ISOINIncompleteCallback() predefined callback	765	* to the weak HAL_PCD_ISOINIncompleteCallback() predefined callback
758	* @param hpcd PCD handle	766	* @param hpcd PCD handle
759	* @retval HAL status	767	* @retval HAL status
760	*/	768	*/
761	HAL_StatusTypeDef HAL_PCD_UnRegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd)	769	HAL_StatusTypeDef HAL_PCD_UnRegisterIsoInIncpltCallback(PCD_HandleTypeDef *hpcd)
762	{	770	{
Line 1187...	Line 1195...
1187	* @param ep_addr endpoint address	1195	* @param ep_addr endpoint address
1188	* @param ep_mps endpoint max packet size	1196	* @param ep_mps endpoint max packet size
1189	* @param ep_type endpoint type	1197	* @param ep_type endpoint type
1190	* @retval HAL status	1198	* @retval HAL status
1191	*/	1199	*/
1192	HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr, uint16_t ep_mps, uint8_t ep_type)	1200	HAL_StatusTypeDef HAL_PCD_EP_Open(PCD_HandleTypeDef *hpcd, uint8_t ep_addr,
-		1201	uint16_t ep_mps, uint8_t ep_type)
1193	{	1202	{
1194	HAL_StatusTypeDef ret = HAL_OK;	1203	HAL_StatusTypeDef ret = HAL_OK;
1195	PCD_EPTypeDef *ep;	1204	PCD_EPTypeDef *ep;
1196		1205
1197	if ((ep_addr & 0x80U) == 0x80U)	1206	if ((ep_addr & 0x80U) == 0x80U)
Line 1364...	Line 1373...
1364	ep->num = ep_addr & EP_ADDR_MSK;	1373	ep->num = ep_addr & EP_ADDR_MSK;
1365		1374
1366	__HAL_LOCK(hpcd);	1375	__HAL_LOCK(hpcd);
1367		1376
1368	(void)USB_EPSetStall(hpcd->Instance, ep);	1377	(void)USB_EPSetStall(hpcd->Instance, ep);
1369	if ((ep_addr & EP_ADDR_MSK) == 0U)	-
1370	{	-
1371	(void)USB_EP0_OutStart(hpcd->Instance, (uint8_t *)hpcd->Setup);	-
1372	}	1378
1373	__HAL_UNLOCK(hpcd);	1379	__HAL_UNLOCK(hpcd);
1374		1380
1375	return HAL_OK;	1381	return HAL_OK;
1376	}	1382	}
1377		1383
Line 1502...	Line 1508...
1502		1508
1503	/* stay in loop while pending interrupts */	1509	/* stay in loop while pending interrupts */
1504	while ((hpcd->Instance->ISTR & USB_ISTR_CTR) != 0U)	1510	while ((hpcd->Instance->ISTR & USB_ISTR_CTR) != 0U)
1505	{	1511	{
1506	wIstr = hpcd->Instance->ISTR;	1512	wIstr = hpcd->Instance->ISTR;
-		1513
1507	/* extract highest priority endpoint number */	1514	/* extract highest priority endpoint number */
1508	epindex = (uint8_t)(wIstr & USB_ISTR_EP_ID);	1515	epindex = (uint8_t)(wIstr & USB_ISTR_EP_ID);
1509		1516
1510	if (epindex == 0U)	1517	if (epindex == 0U)
1511	{	1518	{
Line 1584...	Line 1591...
1584	#else	1591	#else
1585	HAL_PCD_DataOutStageCallback(hpcd, 0U);	1592	HAL_PCD_DataOutStageCallback(hpcd, 0U);
1586	#endif /* USE_HAL_PCD_REGISTER_CALLBACKS */	1593	#endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1587	}	1594	}
1588		1595
-		1596	if ((PCD_GET_ENDPOINT(hpcd->Instance, PCD_ENDP0) & USB_EP_SETUP) == 0U)
-		1597	{
1589	PCD_SET_EP_RX_CNT(hpcd->Instance, PCD_ENDP0, ep->maxpacket);	1598	PCD_SET_EP_RX_CNT(hpcd->Instance, PCD_ENDP0, ep->maxpacket);
1590	PCD_SET_EP_RX_STATUS(hpcd->Instance, PCD_ENDP0, USB_EP_RX_VALID);	1599	PCD_SET_EP_RX_STATUS(hpcd->Instance, PCD_ENDP0, USB_EP_RX_VALID);
-		1600	}
1591	}	1601	}
1592	}	1602	}
1593	}	1603	}
1594	else	1604	else
1595	{	1605	{
Line 1672...	Line 1682...
1672	ep = &hpcd->IN_ep[epindex];	1682	ep = &hpcd->IN_ep[epindex];
1673		1683
1674	/* clear int flag */	1684	/* clear int flag */
1675	PCD_CLEAR_TX_EP_CTR(hpcd->Instance, epindex);	1685	PCD_CLEAR_TX_EP_CTR(hpcd->Instance, epindex);
1676		1686
1677	/* Manage all non bulk transaction or Bulk Single Buffer Transaction */	1687	/* Manage all non bulk/isoc transaction Bulk Single Buffer Transaction */
1678	if ((ep->type != EP_TYPE_BULK) \|\|	1688	if ((ep->type == EP_TYPE_INTR) \|\| (ep->type == EP_TYPE_CTRL) \|\|
1679	((ep->type == EP_TYPE_BULK) && ((wEPVal & USB_EP_KIND) == 0U)))	1689	((ep->type == EP_TYPE_BULK) && ((wEPVal & USB_EP_KIND) == 0U)))
1680	{	1690	{
1681	/* multi-packet on the NON control IN endpoint */	1691	/* multi-packet on the NON control IN endpoint */
1682	TxByteNbre = (uint16_t)PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);	1692	TxByteNbre = (uint16_t)PCD_GET_EP_TX_CNT(hpcd->Instance, ep->num);
1683		1693
1684	if (ep->xfer_len > TxByteNbre)	1694	if (ep->xfer_len > TxByteNbre)
Line 1706...	Line 1716...
1706	ep->xfer_buff += TxByteNbre;	1716	ep->xfer_buff += TxByteNbre;
1707	ep->xfer_count += TxByteNbre;	1717	ep->xfer_count += TxByteNbre;
1708	(void)USB_EPStartXfer(hpcd->Instance, ep);	1718	(void)USB_EPStartXfer(hpcd->Instance, ep);
1709	}	1719	}
1710	}	1720	}
1711	/* bulk in double buffer enable in case of transferLen> Ep_Mps */	1721	/* Double Buffer Iso/bulk IN (bulk transfer Len > Ep_Mps) */
1712	else	1722	else
1713	{	1723	{
1714	(void)HAL_PCD_EP_DB_Transmit(hpcd, ep, wEPVal);	1724	(void)HAL_PCD_EP_DB_Transmit(hpcd, ep, wEPVal);
1715	}	1725	}
1716	}	1726	}
Line 1830...	Line 1840...
1830	ep->xfer_len = 0U;	1840	ep->xfer_len = 0U;
1831	}	1841	}
1832	/* Transfer is completed */	1842	/* Transfer is completed */
1833	if (ep->xfer_len == 0U)	1843	if (ep->xfer_len == 0U)
1834	{	1844	{
-		1845	PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
-		1846	PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
-		1847
1835	/* TX COMPLETE */	1848	/* TX COMPLETE */
1836	#if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)	1849	#if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1837	hpcd->DataInStageCallback(hpcd, ep->num);	1850	hpcd->DataInStageCallback(hpcd, ep->num);
1838	#else	1851	#else
1839	HAL_PCD_DataInStageCallback(hpcd, ep->num);	1852	HAL_PCD_DataInStageCallback(hpcd, ep->num);
Line 1900...	Line 1913...
1900	}	1913	}
1901		1914
1902	/* Transfer is completed */	1915	/* Transfer is completed */
1903	if (ep->xfer_len == 0U)	1916	if (ep->xfer_len == 0U)
1904	{	1917	{
-		1918	PCD_SET_EP_DBUF0_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
-		1919	PCD_SET_EP_DBUF1_CNT(hpcd->Instance, ep->num, ep->is_in, 0U);
-		1920
1905	/* TX COMPLETE */	1921	/* TX COMPLETE */
1906	#if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)	1922	#if (USE_HAL_PCD_REGISTER_CALLBACKS == 1U)
1907	hpcd->DataInStageCallback(hpcd, ep->num);	1923	hpcd->DataInStageCallback(hpcd, ep->num);
1908	#else	1924	#else
1909	HAL_PCD_DataInStageCallback(hpcd, ep->num);	1925	HAL_PCD_DataInStageCallback(hpcd, ep->num);
1910	#endif /* USE_HAL_PCD_REGISTER_CALLBACKS */	1926	#endif /* USE_HAL_PCD_REGISTER_CALLBACKS */
1911		1927
1912	/need to Free USB Buff/	1928	/* need to Free USB Buff */
1913	if ((wEPVal & USB_EP_DTOG_RX) == 0U)	1929	if ((wEPVal & USB_EP_DTOG_RX) == 0U)
1914	{	1930	{
1915	PCD_FreeUserBuffer(hpcd->Instance, ep->num, 1U);	1931	PCD_FreeUserBuffer(hpcd->Instance, ep->num, 1U);
1916	}	1932	}
1917	}	1933	}

Subversion Repositories DashDisplay

(root)/branches/Dashboard_L152_v2/Drivers/STM32L1xx_HAL_Driver/Src/stm32l1xx_hal_pcd.c – Rev 56 → 61