Subversion Repositories DashDisplay

/**

  ******************************************************************************

  * @file    stm32f1xx_hal_pcd.c

  * @author  MCD Application Team

  * @version V1.0.1

  * @date    31-July-2015

  * @brief   PCD HAL module driver.

  *          This file provides firmware functions to manage the following

  *          functionalities of the USB Peripheral Controller:

  *           + Initialization and de-initialization functions

  *           + IO operation functions

  *           + Peripheral Control functions

  *           + Peripheral State functions

  *

  @verbatim

  ==============================================================================

                    ##### How to use this driver #####

  ==============================================================================

    [..]

      The PCD HAL driver can be used as follows:

     (#) Declare a PCD_HandleTypeDef handle structure, for example:

         PCD_HandleTypeDef  hpcd;

     (#) Fill parameters of Init structure in HCD handle

     (#) Call HAL_PCD_Init() API to initialize the HCD peripheral (Core, Device core, ...)

     (#) Initialize the PCD low level resources through the HAL_PCD_MspInit() API:

         (##) Enable the PCD/USB Low Level interface clock using the following macro

              (+++) __HAL_RCC_USB_CLK_ENABLE(); For USB Device FS peripheral available

                    on STM32F102xx and STM32F103xx devices

              (+++) __HAL_RCC_USB_OTG_FS_CLK_ENABLE(); For USB OTG FS peripheral available

                    on STM32F105xx and STM32F107xx devices

         (##) Initialize the related GPIO clocks

         (##) Configure PCD pin-out

         (##) Configure PCD NVIC interrupt

     (#)Associate the Upper USB device stack to the HAL PCD Driver:

         (##) hpcd.pData = pdev;

     (#)Enable HCD transmission and reception:

         (##) HAL_PCD_Start();

  @endverbatim

  ******************************************************************************

  * @attention

  *

  * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>

  *

  * Redistribution and use in source and binary forms, with or without modification,

  * are permitted provided that the following conditions are met:

  *   1. Redistributions of source code must retain the above copyright notice,

  *      this list of conditions and the following disclaimer.

  *   2. Redistributions in binary form must reproduce the above copyright notice,

  *      this list of conditions and the following disclaimer in the documentation

  *      and/or other materials provided with the distribution.

  *   3. Neither the name of STMicroelectronics nor the names of its contributors

  *      may be used to endorse or promote products derived from this software

  *      without specific prior written permission.

  *

  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

  * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

  * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  *

  ******************************************************************************

  */

/* Includes ------------------------------------------------------------------*/

#include "stm32f1xx_hal.h"

/** @addtogroup STM32F1xx_HAL_Driver

  * @{

  */

#ifdef HAL_PCD_MODULE_ENABLED

#if defined(STM32F102x6) || defined(STM32F102xB) || \

    defined(STM32F103x6) || defined(STM32F103xB) || \

    defined(STM32F103xE) || defined(STM32F103xG) || \

    defined(STM32F105xC) || defined(STM32F107xC)

/** @defgroup PCD PCD

  * @brief PCD HAL module driver

  * @{

  */

/* Private types -------------------------------------------------------------*/

/* Private variables ---------------------------------------------------------*/

/* Private constants ---------------------------------------------------------*/

/* Private macros ------------------------------------------------------------*/

/** @defgroup PCD_Private_Macros PCD Private Macros

  * @{

  */

#define PCD_MIN(a, b)  (((a) < (b)) ? (a) : (b))

#define PCD_MAX(a, b)  (((a) > (b)) ? (a) : (b))

/**

  * @}

  */

/* Private functions ---------------------------------------------------------*/

/** @defgroup PCD_Private_Functions PCD Private Functions

  * @{

  */

#if defined (USB_OTG_FS)

static HAL_StatusTypeDef PCD_WriteEmptyTxFifo(PCD_HandleTypeDef *hpcd, uint32_t epnum);

#endif /* USB_OTG_FS */

#if defined (USB)

static HAL_StatusTypeDef PCD_EP_ISR_Handler(PCD_HandleTypeDef *hpcd);

#endif /* USB */

/**

  * @}

  */

/* Exported functions --------------------------------------------------------*/

/** @defgroup PCD_Exported_Functions PCD Exported Functions

  * @{

  */

/** @defgroup PCD_Exported_Functions_Group1 Initialization and de-initialization functions

 *  @brief    Initialization and Configuration functions

 *

@verbatim

 ===============================================================================

            ##### Initialization and de-initialization functions #####

 ===============================================================================

    [..]  This section provides functions allowing to:

@endverbatim

  * @{

  */

/**

  * @brief  Initializes the PCD according to the specified

  *         parameters in the PCD_InitTypeDef and create the associated handle.

  * @param  hpcd: PCD handle

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_PCD_Init(PCD_HandleTypeDef *hpcd)

{

  uint32_t index = 0;

  /* Check the PCD handle allocation */

  if(hpcd == NULL)

  {

    return HAL_ERROR;

  }

  /* Check the parameters */

  assert_param(IS_PCD_ALL_INSTANCE(hpcd->Instance));

  if(hpcd->State == HAL_PCD_STATE_RESET)

  {  

    /* Allocate lock resource and initialize it */

    hpcd->Lock = HAL_UNLOCKED;

    /* Init the low level hardware : GPIO, CLOCK, NVIC... */

    HAL_PCD_MspInit(hpcd);

  }

  hpcd->State = HAL_PCD_STATE_BUSY;

  /* Disable the Interrupts */

  __HAL_PCD_DISABLE(hpcd);

  /*Init the Core (common init.) */

  USB_CoreInit(hpcd->Instance, hpcd->Init);

  /* Force Device Mode*/

  USB_SetCurrentMode(hpcd->Instance , USB_DEVICE_MODE);

  /* Init endpoints structures */

  for (index = 0; index < 15 ; index++)

  {

    /* Init ep structure */

    hpcd->IN_ep[index].is_in = 1;

    hpcd->IN_ep[index].num = index;

    hpcd->IN_ep[index].tx_fifo_num = index;

    /* Control until ep is actvated */

    hpcd->IN_ep[index].type = EP_TYPE_CTRL;

    hpcd->IN_ep[index].maxpacket =  0;

    hpcd->IN_ep[index].xfer_buff = 0;

    hpcd->IN_ep[index].xfer_len = 0;

  }

  for (index = 0; index < 15 ; index++)

  {

    hpcd->OUT_ep[index].is_in = 0;

    hpcd->OUT_ep[index].num = index;

    hpcd->IN_ep[index].tx_fifo_num = index;

    /* Control until ep is activated */

    hpcd->OUT_ep[index].type = EP_TYPE_CTRL;

    hpcd->OUT_ep[index].maxpacket = 0;

    hpcd->OUT_ep[index].xfer_buff = 0;

    hpcd->OUT_ep[index].xfer_len = 0;

  }

  /* Init Device */

  USB_DevInit(hpcd->Instance, hpcd->Init);

  hpcd->USB_Address = 0;

  hpcd->State= HAL_PCD_STATE_READY;

  USB_DevDisconnect (hpcd->Instance);  

  return HAL_OK;

}

/**

  * @brief  DeInitializes the PCD peripheral

  * @param  hpcd: PCD handle

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_PCD_DeInit(PCD_HandleTypeDef *hpcd)

{

  /* Check the PCD handle allocation */

  if(hpcd == NULL)

  {

    return HAL_ERROR;

  }

  hpcd->State = HAL_PCD_STATE_BUSY;

  /* Stop Device */

  HAL_PCD_Stop(hpcd);

  /* DeInit the low level hardware */

  HAL_PCD_MspDeInit(hpcd);

  hpcd->State = HAL_PCD_STATE_RESET;

  return HAL_OK;

}

/**

  * @brief  Initializes the PCD MSP.

  * @param  hpcd: PCD handle

  * @retval None

  */

__weak void HAL_PCD_MspInit(PCD_HandleTypeDef *hpcd)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_MspInit could be implemented in the user file

   */

}

/**

  * @brief  DeInitializes PCD MSP.

  * @param  hpcd: PCD handle

  * @retval None

  */

__weak void HAL_PCD_MspDeInit(PCD_HandleTypeDef *hpcd)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_MspDeInit could be implemented in the user file

   */

}

/**

  * @}

  */

/** @defgroup PCD_Exported_Functions_Group2 IO operation functions

 *  @brief   Data transfers functions

 *

@verbatim

 ===============================================================================

                      ##### IO operation functions #####

 ===============================================================================

    [..]

    This subsection provides a set of functions allowing to manage the PCD data

    transfers.

@endverbatim

  * @{

  */

/**

  * @brief  Start The USB Device.

  * @param  hpcd: PCD handle

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_PCD_Start(PCD_HandleTypeDef *hpcd)

{

  __HAL_LOCK(hpcd);

  HAL_PCDEx_SetConnectionState (hpcd, 1);

  USB_DevConnect (hpcd->Instance);

  __HAL_PCD_ENABLE(hpcd);

  __HAL_UNLOCK(hpcd);

  return HAL_OK;

}

/**

  * @brief  Stop The USB Device.

  * @param  hpcd: PCD handle

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_PCD_Stop(PCD_HandleTypeDef *hpcd)

{  

  __HAL_LOCK(hpcd);

  __HAL_PCD_DISABLE(hpcd);

  USB_StopDevice(hpcd->Instance);

  USB_DevDisconnect (hpcd->Instance);

  __HAL_UNLOCK(hpcd);

  return HAL_OK;

}

#if defined (USB_OTG_FS)

/**

  * @brief  This function handles PCD interrupt request.

  * @param  hpcd: PCD handle

  * @retval HAL status

  */

void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)

{

  USB_OTG_GlobalTypeDef *USBx = hpcd->Instance;

  uint32_t index = 0, ep_intr = 0, epint = 0, epnum = 0;

  uint32_t fifoemptymsk = 0, temp = 0;

  USB_OTG_EPTypeDef *ep = NULL;

  /* ensure that we are in device mode */

  if (USB_GetMode(hpcd->Instance) == USB_OTG_MODE_DEVICE)

  {

    /* avoid spurious interrupt */

    if(__HAL_PCD_IS_INVALID_INTERRUPT(hpcd))

    {

      return;

    }

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_MMIS))

    {

     /* incorrect mode, acknowledge the interrupt */

      __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_MMIS);

    }

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OEPINT))

    {

      epnum = 0;

      /* Read in the device interrupt bits */

      ep_intr = USB_ReadDevAllOutEpInterrupt(hpcd->Instance);

      while ( ep_intr )

      {

        if (ep_intr & 0x1)

        {

          epint = USB_ReadDevOutEPInterrupt(hpcd->Instance, epnum);

          if(( epint & USB_OTG_DOEPINT_XFRC) == USB_OTG_DOEPINT_XFRC)

          {

            CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_XFRC);

            HAL_PCD_DataOutStageCallback(hpcd, epnum);

          }

          if(( epint & USB_OTG_DOEPINT_STUP) == USB_OTG_DOEPINT_STUP)

          {

            /* Inform the upper layer that a setup packet is available */

            HAL_PCD_SetupStageCallback(hpcd);

            CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_STUP);

          }

          if(( epint & USB_OTG_DOEPINT_OTEPDIS) == USB_OTG_DOEPINT_OTEPDIS)

          {

            CLEAR_OUT_EP_INTR(epnum, USB_OTG_DOEPINT_OTEPDIS);

          }

        }

        epnum++;

        ep_intr >>= 1;

      }

    }

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IEPINT))

    {

      /* Read in the device interrupt bits */

      ep_intr = USB_ReadDevAllInEpInterrupt(hpcd->Instance);

      epnum = 0;

      while ( ep_intr )

      {

        if (ep_intr & 0x1) /* In ITR */

        {

          epint = USB_ReadDevInEPInterrupt(hpcd->Instance, epnum);

          if(( epint & USB_OTG_DIEPINT_XFRC) == USB_OTG_DIEPINT_XFRC)

          {

            fifoemptymsk = 0x1 << epnum;

            USBx_DEVICE->DIEPEMPMSK &= ~fifoemptymsk;

            CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_XFRC);

            HAL_PCD_DataInStageCallback(hpcd, epnum);

          }

          if(( epint & USB_OTG_DIEPINT_TOC) == USB_OTG_DIEPINT_TOC)

          {

            CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_TOC);

          }

          if(( epint & USB_OTG_DIEPINT_ITTXFE) == USB_OTG_DIEPINT_ITTXFE)

          {

            CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_ITTXFE);

          }

          if(( epint & USB_OTG_DIEPINT_INEPNE) == USB_OTG_DIEPINT_INEPNE)

          {

            CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_INEPNE);

          }

          if(( epint & USB_OTG_DIEPINT_EPDISD) == USB_OTG_DIEPINT_EPDISD)

          {

            CLEAR_IN_EP_INTR(epnum, USB_OTG_DIEPINT_EPDISD);

          }

          if(( epint & USB_OTG_DIEPINT_TXFE) == USB_OTG_DIEPINT_TXFE)

          {

            PCD_WriteEmptyTxFifo(hpcd , epnum);

          }

        }

        epnum++;

        ep_intr >>= 1;

      }

    }

    /* Handle Resume Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT))

    {

     /* Clear the Remote Wake-up signalling */

      USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;

     HAL_PCD_ResumeCallback(hpcd);

     __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_WKUINT);

    }

    /* Handle Suspend Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP))

    {

      if((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)

      {

        HAL_PCD_SuspendCallback(hpcd);

      }

      __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBSUSP);

    }

    /* Handle Reset Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_USBRST))

    {

      USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_RWUSIG;

      USB_FlushTxFifo(hpcd->Instance ,  0 );

      for (index = 0; index < hpcd->Init.dev_endpoints ; index++)

      {

        USBx_INEP(index)->DIEPINT = 0xFF;

        USBx_OUTEP(index)->DOEPINT = 0xFF;

      }

      USBx_DEVICE->DAINT = 0xFFFFFFFF;

      USBx_DEVICE->DAINTMSK |= 0x10001;

      USBx_DEVICE->DOEPMSK |= (USB_OTG_DOEPMSK_STUPM | USB_OTG_DOEPMSK_XFRCM | USB_OTG_DOEPMSK_EPDM);

      USBx_DEVICE->DIEPMSK |= (USB_OTG_DIEPMSK_TOM | USB_OTG_DIEPMSK_XFRCM | USB_OTG_DIEPMSK_EPDM);

      /* Set Default Address to 0 */

      USBx_DEVICE->DCFG &= ~USB_OTG_DCFG_DAD;

      /* setup EP0 to receive SETUP packets */

      USB_EP0_OutStart(hpcd->Instance, (uint8_t *)hpcd->Setup);

      __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_USBRST);

    }

    /* Handle Enumeration done Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE))

    {

      USB_ActivateSetup(hpcd->Instance);

      hpcd->Instance->GUSBCFG &= ~USB_OTG_GUSBCFG_TRDT;

      hpcd->Init.speed            = USB_OTG_SPEED_FULL;

      hpcd->Init.ep0_mps          = USB_OTG_FS_MAX_PACKET_SIZE ;

      hpcd->Instance->GUSBCFG |= (uint32_t)((USBD_FS_TRDT_VALUE << 10) & USB_OTG_GUSBCFG_TRDT);

      HAL_PCD_ResetCallback(hpcd);

      __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_ENUMDNE);

    }

    /* Handle RxQLevel Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_RXFLVL))

    {

      USB_MASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);

      temp = USBx->GRXSTSP;

      ep = &hpcd->OUT_ep[temp & USB_OTG_GRXSTSP_EPNUM];

      if(((temp & USB_OTG_GRXSTSP_PKTSTS) >> 17) ==  STS_DATA_UPDT)

      {

        if((temp & USB_OTG_GRXSTSP_BCNT) != 0)

        {

          USB_ReadPacket(USBx, ep->xfer_buff, (temp & USB_OTG_GRXSTSP_BCNT) >> 4);

          ep->xfer_buff += (temp & USB_OTG_GRXSTSP_BCNT) >> 4;

          ep->xfer_count += (temp & USB_OTG_GRXSTSP_BCNT) >> 4;

        }

      }

      else if (((temp & USB_OTG_GRXSTSP_PKTSTS) >> 17) ==  STS_SETUP_UPDT)

      {

        USB_ReadPacket(USBx, (uint8_t *)hpcd->Setup, 8);

        ep->xfer_count += (temp & USB_OTG_GRXSTSP_BCNT) >> 4;

      }

      USB_UNMASK_INTERRUPT(hpcd->Instance, USB_OTG_GINTSTS_RXFLVL);

    }

    /* Handle SOF Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SOF))

    {

      HAL_PCD_SOFCallback(hpcd);

      __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SOF);

    }

    /* Handle Incomplete ISO IN Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR))

    {

      HAL_PCD_ISOINIncompleteCallback(hpcd, epnum);

      __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_IISOIXFR);

    }

    /* Handle Incomplete ISO OUT Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT))

    {

      HAL_PCD_ISOOUTIncompleteCallback(hpcd, epnum);

      __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_PXFR_INCOMPISOOUT);

    }

    /* Handle Connection event Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT))

    {

      HAL_PCD_ConnectCallback(hpcd);

      __HAL_PCD_CLEAR_FLAG(hpcd, USB_OTG_GINTSTS_SRQINT);

    }

    /* Handle Disconnection event Interrupt */

    if(__HAL_PCD_GET_FLAG(hpcd, USB_OTG_GINTSTS_OTGINT))

    {

      temp = hpcd->Instance->GOTGINT;

      if((temp & USB_OTG_GOTGINT_SEDET) == USB_OTG_GOTGINT_SEDET)

      {

        HAL_PCD_DisconnectCallback(hpcd);

      }

      hpcd->Instance->GOTGINT |= temp;

    }

  }

}

#endif /* USB_OTG_FS */

#if defined (USB)

/**

  * @brief  This function handles PCD interrupt request.

  * @param  hpcd: PCD handle

  * @retval HAL status

  */

void HAL_PCD_IRQHandler(PCD_HandleTypeDef *hpcd)

{

  uint32_t wInterrupt_Mask = 0;

  if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_CTR))

  {

    /* servicing of the endpoint correct transfer interrupt */

    /* clear of the CTR flag into the sub */

    PCD_EP_ISR_Handler(hpcd);

  }

  if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_RESET))

  {

    __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_RESET);

    HAL_PCD_ResetCallback(hpcd);

    HAL_PCD_SetAddress(hpcd, 0);

  }

  if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_PMAOVR))

  {

    __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_PMAOVR);    

  }

  if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_ERR))

  {

    __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ERR);

  }

  if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_WKUP))

  {  

    hpcd->Instance->CNTR &= ~(USB_CNTR_LP_MODE);

    /*set wInterrupt_Mask global variable*/

    wInterrupt_Mask = USB_CNTR_CTRM  | USB_CNTR_WKUPM | USB_CNTR_SUSPM | USB_CNTR_ERRM \

      | USB_CNTR_ESOFM | USB_CNTR_RESETM;

    /*Set interrupt mask*/

    hpcd->Instance->CNTR = wInterrupt_Mask;

    HAL_PCD_ResumeCallback(hpcd);

    __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_WKUP);    

  }

  if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_SUSP))

  {

    /* clear of the ISTR bit must be done after setting of CNTR_FSUSP */

    __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SUSP);  

    /* Force low-power mode in the macrocell */

    hpcd->Instance->CNTR |= USB_CNTR_FSUSP;

    hpcd->Instance->CNTR |= USB_CNTR_LP_MODE;

    if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_WKUP) == 0)

    {

      HAL_PCD_SuspendCallback(hpcd);

    }

  }

  if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_SOF))

  {

    __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_SOF);

    HAL_PCD_SOFCallback(hpcd);

  }

  if (__HAL_PCD_GET_FLAG (hpcd, USB_ISTR_ESOF))

  {

    /* clear ESOF flag in ISTR */

    __HAL_PCD_CLEAR_FLAG(hpcd, USB_ISTR_ESOF);

  }

}

#endif /* USB */

/**

  * @brief  Data out stage callbacks

  * @param  hpcd: PCD handle

  * @param  epnum: endpoint number

  * @retval None

  */

 __weak void HAL_PCD_DataOutStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_DataOutStageCallback could be implemented in the user file

   */

}

/**

  * @brief  Data IN stage callbacks

  * @param  hpcd: PCD handle

  * @param  epnum: endpoint number

  * @retval None

  */

 __weak void HAL_PCD_DataInStageCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_DataInStageCallback could be implemented in the user file

   */

}

/**

  * @brief  Setup stage callback

  * @param  hpcd: PCD handle

  * @retval None

  */

 __weak void HAL_PCD_SetupStageCallback(PCD_HandleTypeDef *hpcd)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_SetupStageCallback could be implemented in the user file

   */

}

/**

  * @brief  USB Start Of Frame callbacks

  * @param  hpcd: PCD handle

  * @retval None

  */

 __weak void HAL_PCD_SOFCallback(PCD_HandleTypeDef *hpcd)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_SOFCallback could be implemented in the user file

   */

}

/**

  * @brief  USB Reset callbacks

  * @param  hpcd: PCD handle

  * @retval None

  */

 __weak void HAL_PCD_ResetCallback(PCD_HandleTypeDef *hpcd)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_ResetCallback could be implemented in the user file

   */

}

/**

  * @brief  Suspend event callbacks

  * @param  hpcd: PCD handle

  * @retval None

  */

 __weak void HAL_PCD_SuspendCallback(PCD_HandleTypeDef *hpcd)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_SuspendCallback could be implemented in the user file

   */

}

/**

  * @brief  Resume event callbacks

  * @param  hpcd: PCD handle

  * @retval None

  */

 __weak void HAL_PCD_ResumeCallback(PCD_HandleTypeDef *hpcd)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_ResumeCallback could be implemented in the user file

   */

}

/**

  * @brief  Incomplete ISO OUT callbacks

  * @param  hpcd: PCD handle

  * @param  epnum: endpoint number

  * @retval None

  */

 __weak void HAL_PCD_ISOOUTIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_ISOOUTIncompleteCallback could be implemented in the user file

   */

}

/**

  * @brief  Incomplete ISO IN  callbacks

  * @param  hpcd: PCD handle

  * @param  epnum: endpoint number

  * @retval None

  */

 __weak void HAL_PCD_ISOINIncompleteCallback(PCD_HandleTypeDef *hpcd, uint8_t epnum)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_ISOINIncompleteCallback could be implemented in the user file

   */

}

/**

  * @brief  Connection event callbacks

  * @param  hpcd: PCD handle

  * @retval None

  */

 __weak void HAL_PCD_ConnectCallback(PCD_HandleTypeDef *hpcd)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_ConnectCallback could be implemented in the user file

   */

}

/**

  * @brief  Disconnection event callbacks

  * @param  hpcd: PCD handle

  * @retval None

  */

 __weak void HAL_PCD_DisconnectCallback(PCD_HandleTypeDef *hpcd)

{

  /* NOTE : This function should not be modified, when the callback is needed,

            the HAL_PCD_DisconnectCallback could be implemented in the user file

   */

}

/**

  * @}

  */

/** @defgroup PCD_Exported_Functions_Group3 Peripheral Control functions

 *  @brief   management functions

 *

@verbatim

 ===============================================================================

                      ##### Peripheral Control functions #####

 ===============================================================================  

    [..]

    This subsection provides a set of functions allowing to control the PCD data

    transfers.

@endverbatim

  * @{

  */

/**

  * @brief  Connect the USB device

  * @param  hpcd: PCD handle

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_PCD_DevConnect(PCD_HandleTypeDef *hpcd)

{

  __HAL_LOCK(hpcd);

  HAL_PCDEx_SetConnectionState (hpcd, 1);

  USB_DevConnect(hpcd->Instance);

  __HAL_UNLOCK(hpcd);

  return HAL_OK;

}

/**

  * @brief  Disconnect the USB device

  * @param  hpcd: PCD handle

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_PCD_DevDisconnect(PCD_HandleTypeDef *hpcd)

{

  __HAL_LOCK(hpcd);

  HAL_PCDEx_SetConnectionState (hpcd, 0);

  USB_DevDisconnect(hpcd->Instance);

  __HAL_UNLOCK(hpcd);

  return HAL_OK;

}

/**

  * @brief  Set the USB Device address

  * @param  hpcd: PCD handle

  * @param  address: new device address

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_PCD_SetAddress(PCD_HandleTypeDef *hpcd, uint8_t address)

{

  __HAL_LOCK(hpcd);

  hpcd->USB_Address = address;

  USB_SetDevAddress(hpcd->Instance, address);

  __HAL_UNLOCK(hpcd);

  return HAL_OK;

}

/**

  * @brief  Open and configure an endpoint

  * @param  hpcd: PCD handle

  * @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 = NULL;

  if ((ep_addr & 0x80) == 0x80)

  {

    ep = &hpcd->IN_ep[ep_addr & 0x7F];

  }

  else

  {

    ep = &hpcd->OUT_ep[ep_addr & 0x7F];

  }

  ep->num   = ep_addr & 0x7F;

  ep->is_in = (0x80 & ep_addr) != 0;

  ep->maxpacket = ep_mps;

  ep->type = ep_type;

  __HAL_LOCK(hpcd);

  USB_ActivateEndpoint(hpcd->Instance , ep);

  __HAL_UNLOCK(hpcd);

  return ret;

}

/**

  * @brief  Deactivate an endpoint

  * @param  hpcd: PCD handle

  * @param  ep_addr: endpoint address

  * @retval HAL status

  */

HAL_StatusTypeDef HAL_PCD_EP_Close(PCD_HandleTypeDef *hpcd, uint8_t ep_addr)

{  

  PCD_EPTypeDef *ep = NULL;

  if ((ep_addr & 0x80) == 0x80)

  {

    ep = &hpcd->IN_ep[ep_addr & 0x7F];

  }

  else

  {