USB Low Layer Exported Functions

Modules
	Initialization/de-initialization functions
	Initialization and Configuration functions.

Functions
HAL_StatusTypeDef	USB_CoreInit (USB_OTG_GlobalTypeDef *USBx, USB_OTG_CfgTypeDef cfg)
	Initializes the USB Core. More...
HAL_StatusTypeDef	USB_DevInit (USB_OTG_GlobalTypeDef *USBx, USB_OTG_CfgTypeDef cfg)
	USB_DevInit : Initializes the USB_OTG controller registers for device mode. More...
HAL_StatusTypeDef	USB_EnableGlobalInt (USB_OTG_GlobalTypeDef *USBx)
	USB_EnableGlobalInt Enables the controller's Global Int in the AHB Config reg. More...
HAL_StatusTypeDef	USB_DisableGlobalInt (USB_OTG_GlobalTypeDef *USBx)
	USB_DisableGlobalInt Disable the controller's Global Int in the AHB Config reg. More...
HAL_StatusTypeDef	USB_SetTurnaroundTime (USB_OTG_GlobalTypeDef *USBx, uint32_t hclk, uint8_t speed)
	Set the USB turnaround time. More...
HAL_StatusTypeDef	USB_SetCurrentMode (USB_OTG_GlobalTypeDef *USBx, USB_ModeTypeDef mode)
	USB_SetCurrentMode : Set functional mode. More...
HAL_StatusTypeDef	USB_SetDevSpeed (USB_OTG_GlobalTypeDef *USBx, uint8_t speed)
	USB_SetDevSpeed Initializes the DevSpd field of DCFG register depending the PHY type and the enumeration speed of the device. More...
HAL_StatusTypeDef	USB_FlushRxFifo (USB_OTG_GlobalTypeDef *USBx)
	USB_FlushRxFifo : Flush Rx FIFO. More...
HAL_StatusTypeDef	USB_FlushTxFifo (USB_OTG_GlobalTypeDef *USBx, uint32_t num)
	USB_OTG_FlushTxFifo : Flush a Tx FIFO. More...
HAL_StatusTypeDef	USB_ActivateEndpoint (USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
	Activate and configure an endpoint. More...
HAL_StatusTypeDef	USB_DeactivateEndpoint (USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
	De-activate and de-initialize an endpoint. More...
HAL_StatusTypeDef	USB_ActivateDedicatedEndpoint (USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
	Activate and configure a dedicated endpoint. More...
HAL_StatusTypeDef	USB_DeactivateDedicatedEndpoint (USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
	De-activate and de-initialize a dedicated endpoint. More...
HAL_StatusTypeDef	USB_EPStartXfer (USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
	USB_EPStartXfer : setup and starts a transfer over an EP. More...
HAL_StatusTypeDef	USB_EP0StartXfer (USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
	USB_EP0StartXfer : setup and starts a transfer over the EP 0. More...
HAL_StatusTypeDef	USB_WritePacket (USB_OTG_GlobalTypeDef *USBx, uint8_t *src, uint8_t ch_ep_num, uint16_t len)
	USB_WritePacket : Writes a packet into the Tx FIFO associated with the EP/channel. More...
void *	USB_ReadPacket (USB_OTG_GlobalTypeDef *USBx, uint8_t *dest, uint16_t len)
	USB_ReadPacket : read a packet from the RX FIFO. More...
HAL_StatusTypeDef	USB_EPSetStall (USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
	USB_EPSetStall : set a stall condition over an EP. More...
HAL_StatusTypeDef	USB_EPClearStall (USB_OTG_GlobalTypeDef *USBx, USB_OTG_EPTypeDef *ep)
	USB_EPClearStall : Clear a stall condition over an EP. More...
HAL_StatusTypeDef	USB_SetDevAddress (USB_OTG_GlobalTypeDef *USBx, uint8_t address)
	USB_SetDevAddress : Stop the usb device mode. More...
HAL_StatusTypeDef	USB_DevConnect (USB_OTG_GlobalTypeDef *USBx)
	USB_DevConnect : Connect the USB device by enabling the pull-up/pull-down. More...
HAL_StatusTypeDef	USB_DevDisconnect (USB_OTG_GlobalTypeDef *USBx)
	USB_DevDisconnect : Disconnect the USB device by disabling the pull-up/pull-down. More...
HAL_StatusTypeDef	USB_StopDevice (USB_OTG_GlobalTypeDef *USBx)
	USB_StopDevice : Stop the usb device mode. More...
HAL_StatusTypeDef	USB_ActivateSetup (USB_OTG_GlobalTypeDef *USBx)
	Activate EP0 for Setup transactions. More...
HAL_StatusTypeDef	USB_EP0_OutStart (USB_OTG_GlobalTypeDef *USBx, uint8_t *psetup)
	Prepare the EP0 to start the first control setup. More...
uint8_t	USB_GetDevSpeed (USB_OTG_GlobalTypeDef *USBx)
	USB_GetDevSpeed Return the Dev Speed. More...
uint32_t	USB_GetMode (USB_OTG_GlobalTypeDef *USBx)
	Returns USB core mode. More...
uint32_t	USB_ReadInterrupts (USB_OTG_GlobalTypeDef *USBx)
	USB_ReadInterrupts: return the global USB interrupt status. More...
uint32_t	USB_ReadDevAllOutEpInterrupt (USB_OTG_GlobalTypeDef *USBx)
	USB_ReadDevAllOutEpInterrupt: return the USB device OUT endpoints interrupt status. More...
uint32_t	USB_ReadDevOutEPInterrupt (USB_OTG_GlobalTypeDef *USBx, uint8_t epnum)
	Returns Device OUT EP Interrupt register. More...
uint32_t	USB_ReadDevAllInEpInterrupt (USB_OTG_GlobalTypeDef *USBx)
	USB_ReadDevAllInEpInterrupt: return the USB device IN endpoints interrupt status. More...
uint32_t	USB_ReadDevInEPInterrupt (USB_OTG_GlobalTypeDef *USBx, uint8_t epnum)
	Returns Device IN EP Interrupt register. More...
void	USB_ClearInterrupts (USB_OTG_GlobalTypeDef *USBx, uint32_t interrupt)
	USB_ClearInterrupts: clear a USB interrupt. More...
HAL_StatusTypeDef	USB_HostInit (USB_OTG_GlobalTypeDef *USBx, USB_OTG_CfgTypeDef cfg)
	USB_HostInit : Initializes the USB OTG controller registers for Host mode. More...
HAL_StatusTypeDef	USB_InitFSLSPClkSel (USB_OTG_GlobalTypeDef *USBx, uint8_t freq)
	USB_InitFSLSPClkSel : Initializes the FSLSPClkSel field of the HCFG register on the PHY type and set the right frame interval. More...
HAL_StatusTypeDef	USB_ResetPort (USB_OTG_GlobalTypeDef *USBx)
	USB_OTG_ResetPort : Reset Host Port. More...
HAL_StatusTypeDef	USB_DriveVbus (USB_OTG_GlobalTypeDef *USBx, uint8_t state)
	USB_DriveVbus : activate or de-activate vbus. More...
uint32_t	USB_GetHostSpeed (USB_OTG_GlobalTypeDef *USBx)
	Return Host Core speed. More...
uint32_t	USB_GetCurrentFrame (USB_OTG_GlobalTypeDef *USBx)
	Return Host Current Frame number. More...
HAL_StatusTypeDef	USB_HC_Init (USB_OTG_GlobalTypeDef *USBx, uint8_t ch_num, uint8_t epnum, uint8_t dev_address, uint8_t speed, uint8_t ep_type, uint16_t mps)
	Initialize a host channel. More...
HAL_StatusTypeDef	USB_HC_StartXfer (USB_OTG_GlobalTypeDef *USBx, USB_OTG_HCTypeDef *hc)
	Start a transfer over a host channel. More...
uint32_t	USB_HC_ReadInterrupt (USB_OTG_GlobalTypeDef *USBx)
	Read all host channel interrupts status. More...
HAL_StatusTypeDef	USB_HC_Halt (USB_OTG_GlobalTypeDef *USBx, uint8_t hc_num)
	Halt a host channel. More...
HAL_StatusTypeDef	USB_DoPing (USB_OTG_GlobalTypeDef *USBx, uint8_t ch_num)
	Initiate Do Ping protocol. More...
HAL_StatusTypeDef	USB_StopHost (USB_OTG_GlobalTypeDef *USBx)
	Stop Host Core. More...
HAL_StatusTypeDef	USB_ActivateRemoteWakeup (USB_OTG_GlobalTypeDef *USBx)
	USB_ActivateRemoteWakeup active remote wakeup signalling. More...
HAL_StatusTypeDef	USB_DeActivateRemoteWakeup (USB_OTG_GlobalTypeDef *USBx)
	USB_DeActivateRemoteWakeup de-active remote wakeup signalling. More...
HAL_StatusTypeDef	USB_CoreInit (USB_TypeDef *USBx, USB_CfgTypeDef cfg)
	Initializes the USB Core. More...
HAL_StatusTypeDef	USB_DevInit (USB_TypeDef *USBx, USB_CfgTypeDef cfg)
	USB_DevInit : Initializes the USB controller registers for device mode. More...
HAL_StatusTypeDef	USB_EnableGlobalInt (USB_TypeDef *USBx)
	USB_EnableGlobalInt Enables the controller's Global Int in the AHB Config reg. More...
HAL_StatusTypeDef	USB_DisableGlobalInt (USB_TypeDef *USBx)
	USB_DisableGlobalInt Disable the controller's Global Int in the AHB Config reg. More...
HAL_StatusTypeDef	USB_SetCurrentMode (USB_TypeDef *USBx, USB_ModeTypeDef mode)
	USB_SetCurrentMode : Set functional mode. More...
HAL_StatusTypeDef	USB_SetDevSpeed (USB_TypeDef *USBx, uint8_t speed)
	USB_SetDevSpeed :Initializes the device speed depending on the PHY type and the enumeration speed of the device. More...
HAL_StatusTypeDef	USB_FlushRxFifo (USB_TypeDef *USBx)
	USB_FlushRxFifo : Flush Rx FIFO. More...
HAL_StatusTypeDef	USB_FlushTxFifo (USB_TypeDef *USBx, uint32_t num)
	USB_FlushTxFifo : Flush a Tx FIFO. More...
HAL_StatusTypeDef	USB_ActivateEndpoint (USB_TypeDef *USBx, USB_EPTypeDef *ep)
	Activate and configure an endpoint. More...
HAL_StatusTypeDef	USB_DeactivateEndpoint (USB_TypeDef *USBx, USB_EPTypeDef *ep)
	De-activate and de-initialize an endpoint. More...
HAL_StatusTypeDef	USB_EPStartXfer (USB_TypeDef *USBx, USB_EPTypeDef *ep)
	USB_EPStartXfer : setup and starts a transfer over an EP. More...
HAL_StatusTypeDef	USB_WritePacket (USB_TypeDef *USBx, uint8_t *src, uint8_t ch_ep_num, uint16_t len)
	USB_WritePacket : Writes a packet into the Tx FIFO associated with the EP/channel. More...
void *	USB_ReadPacket (USB_TypeDef *USBx, uint8_t *dest, uint16_t len)
	USB_ReadPacket : read a packet from the Tx FIFO associated with the EP/channel. More...
HAL_StatusTypeDef	USB_EPSetStall (USB_TypeDef *USBx, USB_EPTypeDef *ep)
	USB_EPSetStall : set a stall condition over an EP. More...
HAL_StatusTypeDef	USB_EPClearStall (USB_TypeDef *USBx, USB_EPTypeDef *ep)
	USB_EPClearStall : Clear a stall condition over an EP. More...
HAL_StatusTypeDef	USB_SetDevAddress (USB_TypeDef *USBx, uint8_t address)
	USB_SetDevAddress : Stop the usb device mode. More...
HAL_StatusTypeDef	USB_DevConnect (USB_TypeDef *USBx)
	USB_DevConnect : Connect the USB device by enabling the pull-up/pull-down. More...
HAL_StatusTypeDef	USB_DevDisconnect (USB_TypeDef *USBx)
	USB_DevDisconnect : Disconnect the USB device by disabling the pull-up/pull-down. More...
HAL_StatusTypeDef	USB_StopDevice (USB_TypeDef *USBx)
	USB_StopDevice : Stop the usb device mode. More...
HAL_StatusTypeDef	USB_EP0_OutStart (USB_TypeDef *USBx, uint8_t *psetup)
	Prepare the EP0 to start the first control setup. More...
uint32_t	USB_ReadInterrupts (USB_TypeDef *USBx)
	USB_ReadInterrupts: return the global USB interrupt status. More...
uint32_t	USB_ReadDevAllOutEpInterrupt (USB_TypeDef *USBx)
	USB_ReadDevAllOutEpInterrupt: return the USB device OUT endpoints interrupt status. More...
uint32_t	USB_ReadDevOutEPInterrupt (USB_TypeDef *USBx, uint8_t epnum)
	Returns Device OUT EP Interrupt register. More...
uint32_t	USB_ReadDevAllInEpInterrupt (USB_TypeDef *USBx)
	USB_ReadDevAllInEpInterrupt: return the USB device IN endpoints interrupt status. More...
uint32_t	USB_ReadDevInEPInterrupt (USB_TypeDef *USBx, uint8_t epnum)
	Returns Device IN EP Interrupt register. More...
void	USB_ClearInterrupts (USB_TypeDef *USBx, uint32_t interrupt)
	USB_ClearInterrupts: clear a USB interrupt. More...
HAL_StatusTypeDef	USB_ActivateRemoteWakeup (USB_TypeDef *USBx)
	USB_ActivateRemoteWakeup : active remote wakeup signalling. More...
HAL_StatusTypeDef	USB_DeActivateRemoteWakeup (USB_TypeDef *USBx)
	USB_DeActivateRemoteWakeup : de-active remote wakeup signalling. More...
void	USB_WritePMA (USB_TypeDef *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
	Copy a buffer from user memory area to packet memory area (PMA) More...
void	USB_ReadPMA (USB_TypeDef *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
	Copy a buffer from user memory area to packet memory area (PMA) More...

Detailed Description

Function Documentation

USB_ActivateDedicatedEndpoint()

HAL_StatusTypeDef USB_ActivateDedicatedEndpoint	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_EPTypeDef *	ep
	)

Activate and configure a dedicated endpoint.

Parameters

USBx	Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 530 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t epnum = (uint32_t)ep->num;

  /* Read DEPCTLn register */
  if (ep->is_in == 1U)
  {
    if (((USBx_INEP(epnum)->DIEPCTL) & USB_OTG_DIEPCTL_USBAEP) == 0U)
    {
      USBx_INEP(epnum)->DIEPCTL |= (ep->maxpacket & USB_OTG_DIEPCTL_MPSIZ) |
                                   ((uint32_t)ep->type << 18) | (epnum << 22) |
                                   USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
                                   USB_OTG_DIEPCTL_USBAEP;
    }

    USBx_DEVICE->DEACHMSK |= USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK));
  }
  else
  {
    if (((USBx_OUTEP(epnum)->DOEPCTL) & USB_OTG_DOEPCTL_USBAEP) == 0U)
    {
      USBx_OUTEP(epnum)->DOEPCTL |= (ep->maxpacket & USB_OTG_DOEPCTL_MPSIZ) |
                                    ((uint32_t)ep->type << 18) | (epnum << 22) |
                                    USB_OTG_DOEPCTL_USBAEP;
    }

    USBx_DEVICE->DEACHMSK |= USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16);
  }

  return HAL_OK;
}

USB_ActivateEndpoint() [1/2]

HAL_StatusTypeDef USB_ActivateEndpoint	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_EPTypeDef *	ep
	)

Activate and configure an endpoint.

Parameters

USBx	Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 492 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t epnum = (uint32_t)ep->num;

  if (ep->is_in == 1U)
  {
    USBx_DEVICE->DAINTMSK |= USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK));

    if ((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_USBAEP) == 0U)
    {
      USBx_INEP(epnum)->DIEPCTL |= (ep->maxpacket & USB_OTG_DIEPCTL_MPSIZ) |
                                   ((uint32_t)ep->type << 18) | (epnum << 22) |
                                   USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
                                   USB_OTG_DIEPCTL_USBAEP;
    }
  }
  else
  {
    USBx_DEVICE->DAINTMSK |= USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16);

    if (((USBx_OUTEP(epnum)->DOEPCTL) & USB_OTG_DOEPCTL_USBAEP) == 0U)
    {
      USBx_OUTEP(epnum)->DOEPCTL |= (ep->maxpacket & USB_OTG_DOEPCTL_MPSIZ) |
                                    ((uint32_t)ep->type << 18) |
                                    USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
                                    USB_OTG_DOEPCTL_USBAEP;
    }
  }
  return HAL_OK;
}

USB_ActivateEndpoint() [2/2]

HAL_StatusTypeDef USB_ActivateEndpoint	(	USB_TypeDef *	USBx,
		USB_EPTypeDef *	ep
	)

Activate and configure an endpoint.

Parameters

USBx	: Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 1975 of file stm32l4xx_ll_usb.c.

{
  HAL_StatusTypeDef ret = HAL_OK;
  uint16_t wEpRegVal;

  wEpRegVal = PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_T_MASK;

  /* initialize Endpoint */
  switch (ep->type)
  {
    case EP_TYPE_CTRL:
      wEpRegVal |= USB_EP_CONTROL;
      break;

    case EP_TYPE_BULK:
      wEpRegVal |= USB_EP_BULK;
      break;

    case EP_TYPE_INTR:
      wEpRegVal |= USB_EP_INTERRUPT;
      break;

    case EP_TYPE_ISOC:
      wEpRegVal |= USB_EP_ISOCHRONOUS;
      break;

    default:
      ret = HAL_ERROR;
      break;
  }

  PCD_SET_ENDPOINT(USBx, ep->num, wEpRegVal | USB_EP_CTR_RX | USB_EP_CTR_TX);

  PCD_SET_EP_ADDRESS(USBx, ep->num, ep->num);

  if (ep->doublebuffer == 0U)
  {
    if (ep->is_in != 0U)
    {
      /*Set the endpoint Transmit buffer address */
      PCD_SET_EP_TX_ADDRESS(USBx, ep->num, ep->pmaadress);
      PCD_CLEAR_TX_DTOG(USBx, ep->num);

      if (ep->type != EP_TYPE_ISOC)
      {
        /* Configure NAK status for the Endpoint */
        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
      }
      else
      {
        /* Configure TX Endpoint to disabled state */
        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
      }
    }
    else
    {
      /*Set the endpoint Receive buffer address */
      PCD_SET_EP_RX_ADDRESS(USBx, ep->num, ep->pmaadress);
      /*Set the endpoint Receive buffer counter*/
      PCD_SET_EP_RX_CNT(USBx, ep->num, ep->maxpacket);
      PCD_CLEAR_RX_DTOG(USBx, ep->num);
      /* Configure VALID status for the Endpoint*/
      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
    }
  }
  /*Double Buffer*/
  else
  {
    /* Set the endpoint as double buffered */
    PCD_SET_EP_DBUF(USBx, ep->num);
    /* Set buffer address for double buffered mode */
    PCD_SET_EP_DBUF_ADDR(USBx, ep->num, ep->pmaaddr0, ep->pmaaddr1);

    if (ep->is_in == 0U)
    {
      /* Clear the data toggle bits for the endpoint IN/OUT */
      PCD_CLEAR_RX_DTOG(USBx, ep->num);
      PCD_CLEAR_TX_DTOG(USBx, ep->num);

      /* Reset value of the data toggle bits for the endpoint out */
      PCD_TX_DTOG(USBx, ep->num);

      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
    }
    else
    {
      /* Clear the data toggle bits for the endpoint IN/OUT */
      PCD_CLEAR_RX_DTOG(USBx, ep->num);
      PCD_CLEAR_TX_DTOG(USBx, ep->num);
      PCD_RX_DTOG(USBx, ep->num);

      if (ep->type != EP_TYPE_ISOC)
      {
        /* Configure NAK status for the Endpoint */
        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
      }
      else
      {
        /* Configure TX Endpoint to disabled state */
        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
      }

      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
    }
  }

  return ret;
}

USB_ActivateRemoteWakeup() [1/2]

HAL_StatusTypeDef USB_ActivateRemoteWakeup

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_ActivateRemoteWakeup active remote wakeup signalling.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 1760 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  if ((USBx_DEVICE->DSTS & USB_OTG_DSTS_SUSPSTS) == USB_OTG_DSTS_SUSPSTS)
  {
    /* active Remote wakeup signalling */
    USBx_DEVICE->DCTL |= USB_OTG_DCTL_RWUSIG;
  }

  return HAL_OK;
}

USB_ActivateRemoteWakeup() [2/2]

HAL_StatusTypeDef USB_ActivateRemoteWakeup

(

USB_TypeDef *

USBx

)

USB_ActivateRemoteWakeup : active remote wakeup signalling.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 2505 of file stm32l4xx_ll_usb.c.

{
  USBx->CNTR |= USB_CNTR_RESUME;

  return HAL_OK;
}

USB_ActivateSetup()

HAL_StatusTypeDef USB_ActivateSetup

(

USB_OTG_GlobalTypeDef *

USBx

)

Activate EP0 for Setup transactions.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 1109 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  /* Set the MPS of the IN EP based on the enumeration speed */
  USBx_INEP(0U)->DIEPCTL &= ~USB_OTG_DIEPCTL_MPSIZ;

  if ((USBx_DEVICE->DSTS & USB_OTG_DSTS_ENUMSPD) == DSTS_ENUMSPD_LS_PHY_6MHZ)
  {
    USBx_INEP(0U)->DIEPCTL |= 3U;
  }
  USBx_DEVICE->DCTL |= USB_OTG_DCTL_CGINAK;

  return HAL_OK;
}

USB_ClearInterrupts() [1/2]

void USB_ClearInterrupts	(	USB_OTG_GlobalTypeDef *	USBx,
		uint32_t	interrupt
	)

USB_ClearInterrupts: clear a USB interrupt.

Parameters

USBx	Selected device
interrupt	interrupt flag

Return values

None

Definition at line 1086 of file stm32l4xx_ll_usb.c.

{
  USBx->GINTSTS |= interrupt;
}

USB_ClearInterrupts() [2/2]

void USB_ClearInterrupts	(	USB_TypeDef *	USBx,
		uint32_t	interrupt
	)

USB_ClearInterrupts: clear a USB interrupt.

Parameters

USBx	Selected device
interrupt	interrupt flag

Return values

None

Definition at line 2471 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(interrupt);
  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */
}

USB_CoreInit() [1/2]

HAL_StatusTypeDef USB_CoreInit	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_CfgTypeDef	cfg
	)

Initializes the USB Core.

Parameters

USBx	USB Instance
cfg	pointer to a USB_OTG_CfgTypeDef structure that contains the configuration information for the specified USBx peripheral.

Return values

HAL

status

Definition at line 82 of file stm32l4xx_ll_usb.c.

{
  HAL_StatusTypeDef ret;

  if (cfg.phy_itface == USB_OTG_ULPI_PHY)
  {
    USBx->GCCFG &= ~(USB_OTG_GCCFG_PWRDWN);

    /* Init The ULPI Interface */
    USBx->GUSBCFG &= ~(USB_OTG_GUSBCFG_TSDPS | USB_OTG_GUSBCFG_ULPIFSLS | USB_OTG_GUSBCFG_PHYSEL);

    /* Select vbus source */
    USBx->GUSBCFG &= ~(USB_OTG_GUSBCFG_ULPIEVBUSD | USB_OTG_GUSBCFG_ULPIEVBUSI);
    if (cfg.use_external_vbus == 1U)
    {
      USBx->GUSBCFG |= USB_OTG_GUSBCFG_ULPIEVBUSD;
    }
    /* Reset after a PHY select  */
    ret = USB_CoreReset(USBx);
  }
  else /* FS interface (embedded Phy) */
  {
    /* Select FS Embedded PHY */
    USBx->GUSBCFG |= USB_OTG_GUSBCFG_PHYSEL;

    /* Reset after a PHY select and set Host mode */
    ret = USB_CoreReset(USBx);

    if (cfg.battery_charging_enable == 0U)
    {
      /* Activate the USB Transceiver */
      USBx->GCCFG |= USB_OTG_GCCFG_PWRDWN;
    }
    else
    {
      /* Deactivate the USB Transceiver */
      USBx->GCCFG &= ~(USB_OTG_GCCFG_PWRDWN);
    }
  }

  return ret;
}

USB_CoreInit() [2/2]

HAL_StatusTypeDef USB_CoreInit	(	USB_TypeDef *	USBx,
		USB_CfgTypeDef	cfg
	)

Initializes the USB Core.

Parameters

USBx	USB Instance
cfg	: pointer to a USB_CfgTypeDef structure that contains the configuration information for the specified USBx peripheral.

Return values

HAL

status

Definition at line 1797 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(cfg);

  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */

  return HAL_OK;
}

USB_DeactivateDedicatedEndpoint()

HAL_StatusTypeDef USB_DeactivateDedicatedEndpoint	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_EPTypeDef *	ep
	)

De-activate and de-initialize a dedicated endpoint.

Parameters

USBx	Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 604 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t epnum = (uint32_t)ep->num;

  /* Read DEPCTLn register */
  if (ep->is_in == 1U)
  {
    USBx_INEP(epnum)->DIEPCTL &= ~ USB_OTG_DIEPCTL_USBAEP;
    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK)));
  }
  else
  {
    USBx_OUTEP(epnum)->DOEPCTL &= ~USB_OTG_DOEPCTL_USBAEP;
    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16));
  }

  return HAL_OK;
}

USB_DeactivateEndpoint() [1/2]

HAL_StatusTypeDef USB_DeactivateEndpoint	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_EPTypeDef *	ep
	)

De-activate and de-initialize an endpoint.

Parameters

USBx	Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 569 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t epnum = (uint32_t)ep->num;

  /* Read DEPCTLn register */
  if (ep->is_in == 1U)
  {
    USBx_DEVICE->DEACHMSK &= ~(USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK)));
    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_IEPM & (uint32_t)(1UL << (ep->num & EP_ADDR_MSK)));
    USBx_INEP(epnum)->DIEPCTL &= ~(USB_OTG_DIEPCTL_USBAEP |
                                   USB_OTG_DIEPCTL_MPSIZ |
                                   USB_OTG_DIEPCTL_TXFNUM |
                                   USB_OTG_DIEPCTL_SD0PID_SEVNFRM |
                                   USB_OTG_DIEPCTL_EPTYP);
  }
  else
  {
    USBx_DEVICE->DEACHMSK &= ~(USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16));
    USBx_DEVICE->DAINTMSK &= ~(USB_OTG_DAINTMSK_OEPM & ((uint32_t)(1UL << (ep->num & EP_ADDR_MSK)) << 16));
    USBx_OUTEP(epnum)->DOEPCTL &= ~(USB_OTG_DOEPCTL_USBAEP |
                                    USB_OTG_DOEPCTL_MPSIZ |
                                    USB_OTG_DOEPCTL_SD0PID_SEVNFRM |
                                    USB_OTG_DOEPCTL_EPTYP);
  }

  return HAL_OK;
}

USB_DeactivateEndpoint() [2/2]

HAL_StatusTypeDef USB_DeactivateEndpoint	(	USB_TypeDef *	USBx,
		USB_EPTypeDef *	ep
	)

De-activate and de-initialize an endpoint.

Parameters

USBx	: Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 2091 of file stm32l4xx_ll_usb.c.

{
  if (ep->doublebuffer == 0U)
  {
    if (ep->is_in != 0U)
    {
      PCD_CLEAR_TX_DTOG(USBx, ep->num);
      /* Configure DISABLE status for the Endpoint*/
      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
    }
    else
    {
      PCD_CLEAR_RX_DTOG(USBx, ep->num);
      /* Configure DISABLE status for the Endpoint*/
      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
    }
  }
  /*Double Buffer*/
  else
  {
    if (ep->is_in == 0U)
    {
      /* Clear the data toggle bits for the endpoint IN/OUT*/
      PCD_CLEAR_RX_DTOG(USBx, ep->num);
      PCD_CLEAR_TX_DTOG(USBx, ep->num);

      /* Reset value of the data toggle bits for the endpoint out*/
      PCD_TX_DTOG(USBx, ep->num);

      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
    }
    else
    {
      /* Clear the data toggle bits for the endpoint IN/OUT*/
      PCD_CLEAR_RX_DTOG(USBx, ep->num);
      PCD_CLEAR_TX_DTOG(USBx, ep->num);
      PCD_RX_DTOG(USBx, ep->num);
      /* Configure DISABLE status for the Endpoint*/
      PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
    }
  }

  return HAL_OK;
}

USB_DeActivateRemoteWakeup() [1/2]

HAL_StatusTypeDef USB_DeActivateRemoteWakeup

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_DeActivateRemoteWakeup de-active remote wakeup signalling.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 1778 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  /* active Remote wakeup signalling */
  USBx_DEVICE->DCTL &= ~(USB_OTG_DCTL_RWUSIG);

  return HAL_OK;
}

USB_DeActivateRemoteWakeup() [2/2]

HAL_StatusTypeDef USB_DeActivateRemoteWakeup

(

USB_TypeDef *

USBx

)

USB_DeActivateRemoteWakeup : de-active remote wakeup signalling.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 2517 of file stm32l4xx_ll_usb.c.

{
  USBx->CNTR &= ~(USB_CNTR_RESUME);
  return HAL_OK;
}

USB_DevConnect() [1/2]

HAL_StatusTypeDef USB_DevConnect

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_DevConnect : Connect the USB device by enabling the pull-up/pull-down.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 970 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  USBx_DEVICE->DCTL &= ~USB_OTG_DCTL_SDIS;
  HAL_Delay(3U);

  return HAL_OK;
}

USB_DevConnect() [2/2]

HAL_StatusTypeDef USB_DevConnect

(

USB_TypeDef *

USBx

)

USB_DevConnect : Connect the USB device by enabling the pull-up/pull-down.

Parameters

USBx	: Selected device

Return values

HAL

status

Definition at line 2361 of file stm32l4xx_ll_usb.c.

{
  /* Enabling DP Pull-UP bit to Connect internal PU resistor on USB DP line */
  USBx->BCDR |= USB_BCDR_DPPU;

  return HAL_OK;
}

USB_DevDisconnect() [1/2]

HAL_StatusTypeDef USB_DevDisconnect

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_DevDisconnect : Disconnect the USB device by disabling the pull-up/pull-down.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 985 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  USBx_DEVICE->DCTL |= USB_OTG_DCTL_SDIS;
  HAL_Delay(3U);

  return HAL_OK;
}

USB_DevDisconnect() [2/2]

HAL_StatusTypeDef USB_DevDisconnect

(

USB_TypeDef *

USBx

)

USB_DevDisconnect : Disconnect the USB device by disabling the pull-up/pull-down.

Parameters

USBx	: Selected device

Return values

HAL

status

Definition at line 2374 of file stm32l4xx_ll_usb.c.

{
  /* Disable DP Pull-Up bit to disconnect the Internal PU resistor on USB DP line */
  USBx->BCDR &= (uint16_t)(~(USB_BCDR_DPPU));

  return HAL_OK;
}

USB_DevInit() [1/2]

HAL_StatusTypeDef USB_DevInit	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_CfgTypeDef	cfg
	)

USB_DevInit : Initializes the USB_OTG controller registers for device mode.

Parameters

USBx	Selected device
cfg	pointer to a USB_OTG_CfgTypeDef structure that contains the configuration information for the specified USBx peripheral.

Return values

HAL

status

Definition at line 268 of file stm32l4xx_ll_usb.c.

{
  HAL_StatusTypeDef ret = HAL_OK;
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t i;

  for (i = 0U; i < 15U; i++)
  {
    USBx->DIEPTXF[i] = 0U;
  }

  /* VBUS Sensing setup */
  if (cfg.vbus_sensing_enable == 0U)
  {
    /* Deactivate VBUS Sensing B */
    USBx->GCCFG &= ~USB_OTG_GCCFG_VBDEN;

    /* B-peripheral session valid override enable */
    USBx->GOTGCTL |= USB_OTG_GOTGCTL_BVALOEN;
    USBx->GOTGCTL |= USB_OTG_GOTGCTL_BVALOVAL;
  }
  else
  {
    /* Enable HW VBUS sensing */
    USBx->GCCFG |= USB_OTG_GCCFG_VBDEN;
  }

  /* Restart the Phy Clock */
  USBx_PCGCCTL = 0U;

  /* Device mode configuration */
  USBx_DEVICE->DCFG |= DCFG_FRAME_INTERVAL_80;

  /* Set Core speed to Full speed mode */
  (void)USB_SetDevSpeed(USBx, USB_OTG_SPEED_FULL);

  /* Flush the FIFOs */
  if (USB_FlushTxFifo(USBx, 0x10U) != HAL_OK) /* all Tx FIFOs */
  {
    ret = HAL_ERROR;
  }

  if (USB_FlushRxFifo(USBx) != HAL_OK)
  {
    ret = HAL_ERROR;
  }

  /* Clear all pending Device Interrupts */
  USBx_DEVICE->DIEPMSK = 0U;
  USBx_DEVICE->DOEPMSK = 0U;
  USBx_DEVICE->DAINTMSK = 0U;

  for (i = 0U; i < cfg.dev_endpoints; i++)
  {
    if ((USBx_INEP(i)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == USB_OTG_DIEPCTL_EPENA)
    {
      if (i == 0U)
      {
        USBx_INEP(i)->DIEPCTL = USB_OTG_DIEPCTL_SNAK;
      }
      else
      {
        USBx_INEP(i)->DIEPCTL = USB_OTG_DIEPCTL_EPDIS | USB_OTG_DIEPCTL_SNAK;
      }
    }
    else
    {
      USBx_INEP(i)->DIEPCTL = 0U;
    }

    USBx_INEP(i)->DIEPTSIZ = 0U;
    USBx_INEP(i)->DIEPINT  = 0xFB7FU;
  }

  for (i = 0U; i < cfg.dev_endpoints; i++)
  {
    if ((USBx_OUTEP(i)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
    {
      if (i == 0U)
      {
        USBx_OUTEP(i)->DOEPCTL = USB_OTG_DOEPCTL_SNAK;
      }
      else
      {
        USBx_OUTEP(i)->DOEPCTL = USB_OTG_DOEPCTL_EPDIS | USB_OTG_DOEPCTL_SNAK;
      }
    }
    else
    {
      USBx_OUTEP(i)->DOEPCTL = 0U;
    }

    USBx_OUTEP(i)->DOEPTSIZ = 0U;
    USBx_OUTEP(i)->DOEPINT  = 0xFB7FU;
  }

  USBx_DEVICE->DIEPMSK &= ~(USB_OTG_DIEPMSK_TXFURM);

  /* Disable all interrupts. */
  USBx->GINTMSK = 0U;

  /* Clear any pending interrupts */
  USBx->GINTSTS = 0xBFFFFFFFU;

  /* Enable the common interrupts */
  USBx->GINTMSK |= USB_OTG_GINTMSK_RXFLVLM;

  /* Enable interrupts matching to the Device mode ONLY */
  USBx->GINTMSK |= USB_OTG_GINTMSK_USBSUSPM | USB_OTG_GINTMSK_USBRST |
                   USB_OTG_GINTMSK_ENUMDNEM | USB_OTG_GINTMSK_IEPINT |
                   USB_OTG_GINTMSK_OEPINT   | USB_OTG_GINTMSK_IISOIXFRM |
                   USB_OTG_GINTMSK_PXFRM_IISOOXFRM | USB_OTG_GINTMSK_WUIM;

  if (cfg.Sof_enable != 0U)
  {
    USBx->GINTMSK |= USB_OTG_GINTMSK_SOFM;
  }

  if (cfg.vbus_sensing_enable == 1U)
  {
    USBx->GINTMSK |= (USB_OTG_GINTMSK_SRQIM | USB_OTG_GINTMSK_OTGINT);
  }

  return ret;
}

USB_DevInit() [2/2]

HAL_StatusTypeDef USB_DevInit	(	USB_TypeDef *	USBx,
		USB_CfgTypeDef	cfg
	)

USB_DevInit : Initializes the USB controller registers for device mode.

Parameters

USBx	: Selected device
cfg	: pointer to a USB_CfgTypeDef structure that contains the configuration information for the specified USBx peripheral.

Return values

HAL

status

Definition at line 1884 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(cfg);

  /* Init Device */
  /*CNTR_FRES = 1*/
  USBx->CNTR = USB_CNTR_FRES;

  /*CNTR_FRES = 0*/
  USBx->CNTR = 0;

  /*Clear pending interrupts*/
  USBx->ISTR = 0;

  /*Set Btable Address*/
  USBx->BTABLE = BTABLE_ADDRESS;

  /* Enable USB Device Interrupt mask */
  (void)USB_EnableGlobalInt(USBx);

  return HAL_OK;
}

USB_DisableGlobalInt() [1/2]

HAL_StatusTypeDef USB_DisableGlobalInt

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_DisableGlobalInt Disable the controller's Global Int in the AHB Config reg.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 223 of file stm32l4xx_ll_usb.c.

{
  USBx->GAHBCFG &= ~USB_OTG_GAHBCFG_GINT;
  return HAL_OK;
}

USB_DisableGlobalInt() [2/2]

HAL_StatusTypeDef USB_DisableGlobalInt

(

USB_TypeDef *

USBx

)

USB_DisableGlobalInt Disable the controller's Global Int in the AHB Config reg.

Parameters

USBx	: Selected device

Return values

HAL

status

Definition at line 1839 of file stm32l4xx_ll_usb.c.

{
  uint16_t winterruptmask;

  /* Set winterruptmask variable */
  winterruptmask = USB_CNTR_CTRM  | USB_CNTR_WKUPM |
                   USB_CNTR_SUSPM | USB_CNTR_ERRM |
                   USB_CNTR_SOFM | USB_CNTR_ESOFM |
                   USB_CNTR_RESETM | USB_CNTR_L1REQM;

  /* Clear interrupt mask */
  USBx->CNTR &= ~winterruptmask;

  return HAL_OK;
}

USB_DoPing()

HAL_StatusTypeDef USB_DoPing	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t	ch_num
	)

Initiate Do Ping protocol.

Parameters

USBx	Selected device
hc_num	Host Channel number This parameter can be a value from 1 to 15

Return values

HAL

state

Definition at line 1680 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t chnum = (uint32_t)ch_num;
  uint32_t num_packets = 1U;
  uint32_t tmpreg;

  USBx_HC(chnum)->HCTSIZ = ((num_packets << 19) & USB_OTG_HCTSIZ_PKTCNT) |
                           USB_OTG_HCTSIZ_DOPING;

  /* Set host channel enable */
  tmpreg = USBx_HC(chnum)->HCCHAR;
  tmpreg &= ~USB_OTG_HCCHAR_CHDIS;
  tmpreg |= USB_OTG_HCCHAR_CHENA;
  USBx_HC(chnum)->HCCHAR = tmpreg;

  return HAL_OK;
}

USB_DriveVbus()

HAL_StatusTypeDef USB_DriveVbus	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t	state
	)

USB_DriveVbus : activate or de-activate vbus.

Parameters

state

VBUS state This parameter can be one of these values: 0 : VBUS Active 1 : VBUS Inactive

Return values

HAL

status

Definition at line 1317 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  __IO uint32_t hprt0 = 0U;

  hprt0 = USBx_HPRT0;

  hprt0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |
             USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG);

  if (((hprt0 & USB_OTG_HPRT_PPWR) == 0U) && (state == 1U))
  {
    USBx_HPRT0 = (USB_OTG_HPRT_PPWR | hprt0);
  }
  if (((hprt0 & USB_OTG_HPRT_PPWR) == USB_OTG_HPRT_PPWR) && (state == 0U))
  {
    USBx_HPRT0 = ((~USB_OTG_HPRT_PPWR) & hprt0);
  }
  return HAL_OK;
}

USB_EnableGlobalInt() [1/2]

HAL_StatusTypeDef USB_EnableGlobalInt

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_EnableGlobalInt Enables the controller's Global Int in the AHB Config reg.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 211 of file stm32l4xx_ll_usb.c.

{
  USBx->GAHBCFG |= USB_OTG_GAHBCFG_GINT;
  return HAL_OK;
}

USB_EnableGlobalInt() [2/2]

HAL_StatusTypeDef USB_EnableGlobalInt

(

USB_TypeDef *

USBx

)

USB_EnableGlobalInt Enables the controller's Global Int in the AHB Config reg.

Parameters

USBx	: Selected device

Return values

HAL

status

Definition at line 1817 of file stm32l4xx_ll_usb.c.

{
  uint16_t winterruptmask;

  /* Set winterruptmask variable */
  winterruptmask = USB_CNTR_CTRM  | USB_CNTR_WKUPM |
                   USB_CNTR_SUSPM | USB_CNTR_ERRM |
                   USB_CNTR_SOFM | USB_CNTR_ESOFM |
                   USB_CNTR_RESETM | USB_CNTR_L1REQM;

  /* Set interrupt mask */
  USBx->CNTR |= winterruptmask;

  return HAL_OK;
}

USB_EP0_OutStart() [1/2]

HAL_StatusTypeDef USB_EP0_OutStart	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t *	psetup
	)

Prepare the EP0 to start the first control setup.

Parameters

USBx	Selected device
psetup	pointer to setup packet

Return values

HAL

status

Definition at line 1131 of file stm32l4xx_ll_usb.c.

{
  UNUSED(psetup);
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t gSNPSiD = *(__IO uint32_t *)(&USBx->CID + 0x1U);

  if (gSNPSiD > USB_OTG_CORE_ID_300A)
  {
    if ((USBx_OUTEP(0U)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == USB_OTG_DOEPCTL_EPENA)
    {
      return HAL_OK;
    }
  }

  USBx_OUTEP(0U)->DOEPTSIZ = 0U;
  USBx_OUTEP(0U)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
  USBx_OUTEP(0U)->DOEPTSIZ |= (3U * 8U);
  USBx_OUTEP(0U)->DOEPTSIZ |=  USB_OTG_DOEPTSIZ_STUPCNT;

  return HAL_OK;
}

USB_EP0_OutStart() [2/2]

HAL_StatusTypeDef USB_EP0_OutStart	(	USB_TypeDef *	USBx,
		uint8_t *	psetup
	)

Prepare the EP0 to start the first control setup.

Parameters

USBx	Selected device
psetup	pointer to setup packet

Return values

HAL

status

Definition at line 2488 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(psetup);
  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */
  return HAL_OK;
}

USB_EP0StartXfer()

HAL_StatusTypeDef USB_EP0StartXfer	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_EPTypeDef *	ep
	)

USB_EP0StartXfer : setup and starts a transfer over the EP 0.

Parameters

USBx	Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 734 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t epnum = (uint32_t)ep->num;

  /* IN endpoint */
  if (ep->is_in == 1U)
  {
    /* Zero Length Packet? */
    if (ep->xfer_len == 0U)
    {
      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);
      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT & (1U << 19));
      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
    }
    else
    {
      /* Program the transfer size and packet count
      * as follows: xfersize = N * maxpacket +
      * short_packet pktcnt = N + (short_packet
      * exist ? 1 : 0)
      */
      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);

      if (ep->xfer_len > ep->maxpacket)
      {
        ep->xfer_len = ep->maxpacket;
      }
      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT & (1U << 19));
      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_XFRSIZ & ep->xfer_len);
    }

    /* EP enable, IN data in FIFO */
    USBx_INEP(epnum)->DIEPCTL |= (USB_OTG_DIEPCTL_CNAK | USB_OTG_DIEPCTL_EPENA);

    /* Enable the Tx FIFO Empty Interrupt for this EP */
    if (ep->xfer_len > 0U)
    {
      USBx_DEVICE->DIEPEMPMSK |= 1UL << (ep->num & EP_ADDR_MSK);
    }
  }
  else /* OUT endpoint */
  {
    /* Program the transfer size and packet count as follows:
    * pktcnt = N
    * xfersize = N * maxpacket
    */
    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_XFRSIZ);
    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_PKTCNT);

    if (ep->xfer_len > 0U)
    {
      ep->xfer_len = ep->maxpacket;
    }

    USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
    USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_XFRSIZ & (ep->maxpacket));

    /* EP enable */
    USBx_OUTEP(epnum)->DOEPCTL |= (USB_OTG_DOEPCTL_CNAK | USB_OTG_DOEPCTL_EPENA);
  }

  return HAL_OK;
}

USB_EPClearStall() [1/2]

HAL_StatusTypeDef USB_EPClearStall	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_EPTypeDef *	ep
	)

USB_EPClearStall : Clear a stall condition over an EP.

Parameters

USBx	Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 885 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t epnum = (uint32_t)ep->num;

  if (ep->is_in == 1U)
  {
    USBx_INEP(epnum)->DIEPCTL &= ~USB_OTG_DIEPCTL_STALL;
    if ((ep->type == EP_TYPE_INTR) || (ep->type == EP_TYPE_BULK))
    {
      USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SD0PID_SEVNFRM; /* DATA0 */
    }
  }
  else
  {
    USBx_OUTEP(epnum)->DOEPCTL &= ~USB_OTG_DOEPCTL_STALL;
    if ((ep->type == EP_TYPE_INTR) || (ep->type == EP_TYPE_BULK))
    {
      USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SD0PID_SEVNFRM; /* DATA0 */
    }
  }
  return HAL_OK;
}

USB_EPClearStall() [2/2]

HAL_StatusTypeDef USB_EPClearStall	(	USB_TypeDef *	USBx,
		USB_EPTypeDef *	ep
	)

USB_EPClearStall : Clear a stall condition over an EP.

Parameters

USBx	: Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 2293 of file stm32l4xx_ll_usb.c.

{
  if (ep->doublebuffer == 0U)
  {
    if (ep->is_in != 0U)
    {
      PCD_CLEAR_TX_DTOG(USBx, ep->num);

      if (ep->type != EP_TYPE_ISOC)
      {
        /* Configure NAK status for the Endpoint */
        PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
      }
    }
    else
    {
      PCD_CLEAR_RX_DTOG(USBx, ep->num);

      /* Configure VALID status for the Endpoint*/
      PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
    }
  }

  return HAL_OK;
}

USB_EPSetStall() [1/2]

HAL_StatusTypeDef USB_EPSetStall	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_EPTypeDef *	ep
	)

USB_EPSetStall : set a stall condition over an EP.

Parameters

USBx	Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 854 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t epnum = (uint32_t)ep->num;

  if (ep->is_in == 1U)
  {
    if (((USBx_INEP(epnum)->DIEPCTL & USB_OTG_DIEPCTL_EPENA) == 0U) && (epnum != 0U))
    {
      USBx_INEP(epnum)->DIEPCTL &= ~(USB_OTG_DIEPCTL_EPDIS);
    }
    USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_STALL;
  }
  else
  {
    if (((USBx_OUTEP(epnum)->DOEPCTL & USB_OTG_DOEPCTL_EPENA) == 0U) && (epnum != 0U))
    {
      USBx_OUTEP(epnum)->DOEPCTL &= ~(USB_OTG_DOEPCTL_EPDIS);
    }
    USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_STALL;
  }

  return HAL_OK;
}

USB_EPSetStall() [2/2]

HAL_StatusTypeDef USB_EPSetStall	(	USB_TypeDef *	USBx,
		USB_EPTypeDef *	ep
	)

USB_EPSetStall : set a stall condition over an EP.

Parameters

USBx	: Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 2273 of file stm32l4xx_ll_usb.c.

{
  if (ep->is_in != 0U)
  {
    PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_STALL);
  }
  else
  {
    PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_STALL);
  }

  return HAL_OK;
}

USB_EPStartXfer() [1/2]

HAL_StatusTypeDef USB_EPStartXfer	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_EPTypeDef *	ep
	)

USB_EPStartXfer : setup and starts a transfer over an EP.

Parameters

USBx	Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 630 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t epnum = (uint32_t)ep->num;
  uint16_t pktcnt;

  /* IN endpoint */
  if (ep->is_in == 1U)
  {
    /* Zero Length Packet? */
    if (ep->xfer_len == 0U)
    {
      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);
      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT & (1U << 19));
      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
    }
    else
    {
      /* Program the transfer size and packet count
      * as follows: xfersize = N * maxpacket +
      * short_packet pktcnt = N + (short_packet
      * exist ? 1 : 0)
      */
      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_XFRSIZ);
      USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_PKTCNT);
      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_PKTCNT & (((ep->xfer_len + ep->maxpacket - 1U) / ep->maxpacket) << 19));
      USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_XFRSIZ & ep->xfer_len);

      if (ep->type == EP_TYPE_ISOC)
      {
        USBx_INEP(epnum)->DIEPTSIZ &= ~(USB_OTG_DIEPTSIZ_MULCNT);
        USBx_INEP(epnum)->DIEPTSIZ |= (USB_OTG_DIEPTSIZ_MULCNT & (1U << 29));
      }
    }
    /* EP enable, IN data in FIFO */
    USBx_INEP(epnum)->DIEPCTL |= (USB_OTG_DIEPCTL_CNAK | USB_OTG_DIEPCTL_EPENA);

    if (ep->type != EP_TYPE_ISOC)
    {
      /* Enable the Tx FIFO Empty Interrupt for this EP */
      if (ep->xfer_len > 0U)
      {
        USBx_DEVICE->DIEPEMPMSK |= 1UL << (ep->num & EP_ADDR_MSK);
      }
    }
    else
    {
      if ((USBx_DEVICE->DSTS & (1U << 8)) == 0U)
      {
        USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SODDFRM;
      }
      else
      {
        USBx_INEP(epnum)->DIEPCTL |= USB_OTG_DIEPCTL_SD0PID_SEVNFRM;
      }

      (void)USB_WritePacket(USBx, ep->xfer_buff, ep->num, (uint16_t)ep->xfer_len);
    }
  }
  else /* OUT endpoint */
  {
    /* Program the transfer size and packet count as follows:
    * pktcnt = N
    * xfersize = N * maxpacket
    */
    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_XFRSIZ);
    USBx_OUTEP(epnum)->DOEPTSIZ &= ~(USB_OTG_DOEPTSIZ_PKTCNT);

    if (ep->xfer_len == 0U)
    {
      USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_XFRSIZ & ep->maxpacket);
      USBx_OUTEP(epnum)->DOEPTSIZ |= (USB_OTG_DOEPTSIZ_PKTCNT & (1U << 19));
    }
    else
    {
      pktcnt = (uint16_t)((ep->xfer_len + ep->maxpacket - 1U) / ep->maxpacket);
      USBx_OUTEP(epnum)->DOEPTSIZ |= USB_OTG_DOEPTSIZ_PKTCNT & ((uint32_t)pktcnt << 19);
      USBx_OUTEP(epnum)->DOEPTSIZ |= USB_OTG_DOEPTSIZ_XFRSIZ & (ep->maxpacket * pktcnt);
    }

    if (ep->type == EP_TYPE_ISOC)
    {
      if ((USBx_DEVICE->DSTS & (1U << 8)) == 0U)
      {
        USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SODDFRM;
      }
      else
      {
        USBx_OUTEP(epnum)->DOEPCTL |= USB_OTG_DOEPCTL_SD0PID_SEVNFRM;
      }
    }
    /* EP enable */
    USBx_OUTEP(epnum)->DOEPCTL |= (USB_OTG_DOEPCTL_CNAK | USB_OTG_DOEPCTL_EPENA);
  }

  return HAL_OK;
}

USB_EPStartXfer() [2/2]

HAL_StatusTypeDef USB_EPStartXfer	(	USB_TypeDef *	USBx,
		USB_EPTypeDef *	ep
	)

USB_EPStartXfer : setup and starts a transfer over an EP.

Parameters

USBx	: Selected device
ep	pointer to endpoint structure

Return values

HAL

status

Definition at line 2144 of file stm32l4xx_ll_usb.c.

{
  uint16_t pmabuffer;
  uint32_t len;

  /* IN endpoint */
  if (ep->is_in == 1U)
  {
    /*Multi packet transfer*/
    if (ep->xfer_len > ep->maxpacket)
    {
      len = ep->maxpacket;
      ep->xfer_len -= len;
    }
    else
    {
      len = ep->xfer_len;
      ep->xfer_len = 0U;
    }

    /* configure and validate Tx endpoint */
    if (ep->doublebuffer == 0U)
    {
      USB_WritePMA(USBx, ep->xfer_buff, ep->pmaadress, (uint16_t)len);
      PCD_SET_EP_TX_CNT(USBx, ep->num, len);
    }
    else
    {
      /* Write the data to the USB endpoint */
      if ((PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_DTOG_TX) != 0U)
      {
        /* Set the Double buffer counter for pmabuffer1 */
        PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
        pmabuffer = ep->pmaaddr1;
      }
      else
      {
        /* Set the Double buffer counter for pmabuffer0 */
        PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
        pmabuffer = ep->pmaaddr0;
      }
      USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
      PCD_FreeUserBuffer(USBx, ep->num, ep->is_in);
    }

    PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_VALID);
  }
  else /* OUT endpoint */
  {
    /* Multi packet transfer*/
    if (ep->xfer_len > ep->maxpacket)
    {
      len = ep->maxpacket;
      ep->xfer_len -= len;
    }
    else
    {
      len = ep->xfer_len;
      ep->xfer_len = 0U;
    }

    /* configure and validate Rx endpoint */
    if (ep->doublebuffer == 0U)
    {
      /*Set RX buffer count*/
      PCD_SET_EP_RX_CNT(USBx, ep->num, len);
    }
    else
    {
      /*Set the Double buffer counter*/
      PCD_SET_EP_DBUF_CNT(USBx, ep->num, ep->is_in, len);
    }

    PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
  }

  return HAL_OK;
}

USB_FlushRxFifo() [1/2]

HAL_StatusTypeDef USB_FlushRxFifo

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_FlushRxFifo : Flush Rx FIFO.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 425 of file stm32l4xx_ll_usb.c.

{
  uint32_t count = 0;

  USBx->GRSTCTL = USB_OTG_GRSTCTL_RXFFLSH;

  do
  {
    if (++count > 200000U)
    {
      return HAL_TIMEOUT;
    }
  }
  while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_RXFFLSH) == USB_OTG_GRSTCTL_RXFFLSH);

  return HAL_OK;
}

USB_FlushRxFifo() [2/2]

HAL_StatusTypeDef USB_FlushRxFifo

(

USB_TypeDef *

USBx

)

USB_FlushRxFifo : Flush Rx FIFO.

Parameters

USBx	: Selected device

Return values

HAL

status

Definition at line 1956 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);

  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */

  return HAL_OK;
}

USB_FlushTxFifo() [1/2]

HAL_StatusTypeDef USB_FlushTxFifo	(	USB_OTG_GlobalTypeDef *	USBx,
		uint32_t	num
	)

USB_OTG_FlushTxFifo : Flush a Tx FIFO.

Parameters

USBx	Selected device
num	FIFO number This parameter can be a value from 1 to 15 15 means Flush all Tx FIFOs

Return values

HAL

status

Definition at line 402 of file stm32l4xx_ll_usb.c.

{
  uint32_t count = 0U;

  USBx->GRSTCTL = (USB_OTG_GRSTCTL_TXFFLSH | (num << 6));

  do
  {
    if (++count > 200000U)
    {
      return HAL_TIMEOUT;
    }
  }
  while ((USBx->GRSTCTL & USB_OTG_GRSTCTL_TXFFLSH) == USB_OTG_GRSTCTL_TXFFLSH);

  return HAL_OK;
}

USB_FlushTxFifo() [2/2]

HAL_StatusTypeDef USB_FlushTxFifo	(	USB_TypeDef *	USBx,
		uint32_t	num
	)

USB_FlushTxFifo : Flush a Tx FIFO.

Parameters

USBx	: Selected device
num	: FIFO number This parameter can be a value from 1 to 15 15 means Flush all Tx FIFOs

Return values

HAL

status

Definition at line 1937 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(num);

  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */

  return HAL_OK;
}

USB_GetCurrentFrame()

uint32_t USB_GetCurrentFrame

(

USB_OTG_GlobalTypeDef *

USBx

)

Return Host Current Frame number.

Parameters

USBx	Selected device

Return values

current

frame number

Definition at line 1360 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  return (USBx_HOST->HFNUM & USB_OTG_HFNUM_FRNUM);
}

USB_GetDevSpeed()

uint8_t USB_GetDevSpeed

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_GetDevSpeed Return the Dev Speed.

Parameters

USBx	Selected device

Return values

speed

device speed This parameter can be one of these values: PCD_SPEED_FULL: Full speed mode

Definition at line 467 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint8_t speed;
  uint32_t DevEnumSpeed = USBx_DEVICE->DSTS & USB_OTG_DSTS_ENUMSPD;

  if ((DevEnumSpeed == DSTS_ENUMSPD_FS_PHY_30MHZ_OR_60MHZ) ||
      (DevEnumSpeed == DSTS_ENUMSPD_FS_PHY_48MHZ))
  {
    speed = USBD_FS_SPEED;
  }
  else
  {
    speed = 0xFU;
  }

  return speed;
}

USB_GetHostSpeed()

uint32_t USB_GetHostSpeed

(

USB_OTG_GlobalTypeDef *

USBx

)

Return Host Core speed.

Parameters

USBx	Selected device

Return values

speed

: Host speed This parameter can be one of these values: HCD_SPEED_FULL: Full speed mode HCD_SPEED_LOW: Low speed mode

Definition at line 1346 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  __IO uint32_t hprt0 = 0U;

  hprt0 = USBx_HPRT0;
  return ((hprt0 & USB_OTG_HPRT_PSPD) >> 17);
}

USB_GetMode()

uint32_t USB_GetMode

(

USB_OTG_GlobalTypeDef *

USBx

)

Returns USB core mode.

Parameters

USBx	Selected device

Return values

return

core mode : Host or Device This parameter can be one of these values: 0 : Host 1 : Device

Definition at line 1099 of file stm32l4xx_ll_usb.c.

{
  return ((USBx->GINTSTS) & 0x1U);
}

USB_HC_Halt()

HAL_StatusTypeDef USB_HC_Halt	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t	hc_num
	)

Halt a host channel.

Parameters

USBx	Selected device
hc_num	Host Channel number This parameter can be a value from 1 to 15

Return values

HAL

state

Definition at line 1615 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t hcnum = (uint32_t)hc_num;
  uint32_t count = 0U;
  uint32_t HcEpType = (USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_EPTYP) >> 18;

  /* Check for space in the request queue to issue the halt. */
  if ((HcEpType == HCCHAR_CTRL) || (HcEpType == HCCHAR_BULK))
  {
    USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHDIS;

    if ((USBx->HNPTXSTS & (0xFFU << 16)) == 0U)
    {
      USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_CHENA;
      USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
      USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_EPDIR;
      do
      {
        if (++count > 1000U)
        {
          break;
        }
      }
      while ((USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_CHENA) == USB_OTG_HCCHAR_CHENA);
    }
    else
    {
      USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
    }
  }
  else
  {
    USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHDIS;

    if ((USBx_HOST->HPTXSTS & (0xFFU << 16)) == 0U)
    {
      USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_CHENA;
      USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
      USBx_HC(hcnum)->HCCHAR &= ~USB_OTG_HCCHAR_EPDIR;
      do
      {
        if (++count > 1000U)
        {
          break;
        }
      }
      while ((USBx_HC(hcnum)->HCCHAR & USB_OTG_HCCHAR_CHENA) == USB_OTG_HCCHAR_CHENA);
    }
    else
    {
      USBx_HC(hcnum)->HCCHAR |= USB_OTG_HCCHAR_CHENA;
    }
  }

  return HAL_OK;
}

USB_HC_Init()

HAL_StatusTypeDef USB_HC_Init	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t	ch_num,
		uint8_t	epnum,
		uint8_t	dev_address,
		uint8_t	speed,
		uint8_t	ep_type,
		uint16_t	mps
	)

Initialize a host channel.

Parameters

USBx	Selected device
ch_num	Channel number This parameter can be a value from 1 to 15
epnum	Endpoint number This parameter can be a value from 1 to 15
dev_address	Current device address This parameter can be a value from 0 to 255
speed	Current device speed This parameter can be one of these values: USB_OTG_SPEED_FULL: Full speed mode USB_OTG_SPEED_LOW: Low speed mode
ep_type	Endpoint Type This parameter can be one of these values: EP_TYPE_CTRL: Control type EP_TYPE_ISOC: Isochronous type EP_TYPE_BULK: Bulk type EP_TYPE_INTR: Interrupt type
mps	Max Packet Size This parameter can be a value from 0 to32K

Return values

HAL

state

Definition at line 1390 of file stm32l4xx_ll_usb.c.

{
  HAL_StatusTypeDef ret = HAL_OK;
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t HCcharEpDir, HCcharLowSpeed;

  /* Clear old interrupt conditions for this host channel. */
  USBx_HC((uint32_t)ch_num)->HCINT = 0xFFFFFFFFU;

  /* Enable channel interrupts required for this transfer. */
  switch (ep_type)
  {
    case EP_TYPE_CTRL:
    case EP_TYPE_BULK:
      USBx_HC((uint32_t)ch_num)->HCINTMSK = USB_OTG_HCINTMSK_XFRCM  |
                                            USB_OTG_HCINTMSK_STALLM |
                                            USB_OTG_HCINTMSK_TXERRM |
                                            USB_OTG_HCINTMSK_DTERRM |
                                            USB_OTG_HCINTMSK_AHBERR |
                                            USB_OTG_HCINTMSK_NAKM;

      if ((epnum & 0x80U) == 0x80U)
      {
        USBx_HC((uint32_t)ch_num)->HCINTMSK |= USB_OTG_HCINTMSK_BBERRM;
      }
      break;

    case EP_TYPE_INTR:
      USBx_HC((uint32_t)ch_num)->HCINTMSK = USB_OTG_HCINTMSK_XFRCM  |
                                            USB_OTG_HCINTMSK_STALLM |
                                            USB_OTG_HCINTMSK_TXERRM |
                                            USB_OTG_HCINTMSK_DTERRM |
                                            USB_OTG_HCINTMSK_NAKM   |
                                            USB_OTG_HCINTMSK_AHBERR |
                                            USB_OTG_HCINTMSK_FRMORM;

      if ((epnum & 0x80U) == 0x80U)
      {
        USBx_HC((uint32_t)ch_num)->HCINTMSK |= USB_OTG_HCINTMSK_BBERRM;
      }

      break;

    case EP_TYPE_ISOC:
      USBx_HC((uint32_t)ch_num)->HCINTMSK = USB_OTG_HCINTMSK_XFRCM  |
                                            USB_OTG_HCINTMSK_ACKM   |
                                            USB_OTG_HCINTMSK_AHBERR |
                                            USB_OTG_HCINTMSK_FRMORM;

      if ((epnum & 0x80U) == 0x80U)
      {
        USBx_HC((uint32_t)ch_num)->HCINTMSK |= (USB_OTG_HCINTMSK_TXERRM | USB_OTG_HCINTMSK_BBERRM);
      }
      break;

    default:
      ret = HAL_ERROR;
      break;
  }

  /* Enable the top level host channel interrupt. */
  USBx_HOST->HAINTMSK |= 1UL << (ch_num & 0xFU);

  /* Make sure host channel interrupts are enabled. */
  USBx->GINTMSK |= USB_OTG_GINTMSK_HCIM;

  /* Program the HCCHAR register */
  if ((epnum & 0x80U) == 0x80U)
  {
    HCcharEpDir = (0x1U << 15) & USB_OTG_HCCHAR_EPDIR;
  }
  else
  {
    HCcharEpDir = 0U;
  }

  if (speed == HPRT0_PRTSPD_LOW_SPEED)
  {
    HCcharLowSpeed = (0x1U << 17) & USB_OTG_HCCHAR_LSDEV;
  }
  else
  {
    HCcharLowSpeed = 0U;
  }

  USBx_HC((uint32_t)ch_num)->HCCHAR = (((uint32_t)dev_address << 22) & USB_OTG_HCCHAR_DAD) |
                                      ((((uint32_t)epnum & 0x7FU) << 11) & USB_OTG_HCCHAR_EPNUM) |
                                      (((uint32_t)ep_type << 18) & USB_OTG_HCCHAR_EPTYP) |
                                      ((uint32_t)mps & USB_OTG_HCCHAR_MPSIZ) | HCcharEpDir | HCcharLowSpeed;

  if (ep_type == EP_TYPE_INTR)
  {
    USBx_HC((uint32_t)ch_num)->HCCHAR |= USB_OTG_HCCHAR_ODDFRM ;
  }

  return ret;
}

USB_HC_ReadInterrupt()

uint32_t USB_HC_ReadInterrupt

(

USB_OTG_GlobalTypeDef *

USBx

)

Read all host channel interrupts status.

Parameters

USBx	Selected device

Return values

HAL

state

Definition at line 1601 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  return ((USBx_HOST->HAINT) & 0xFFFFU);
}

USB_HC_StartXfer()

HAL_StatusTypeDef USB_HC_StartXfer	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_HCTypeDef *	hc
	)

Start a transfer over a host channel.

Parameters

USBx	Selected device
hc	pointer to host channel structure

Return values

HAL

state

Definition at line 1500 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t ch_num = (uint32_t)hc->ch_num;
  static __IO uint32_t tmpreg = 0U;
  uint8_t  is_oddframe;
  uint16_t len_words;
  uint16_t num_packets;
  uint16_t max_hc_pkt_count = 256U;

  /* Compute the expected number of packets associated to the transfer */
  if (hc->xfer_len > 0U)
  {
    num_packets = (uint16_t)((hc->xfer_len + hc->max_packet - 1U) / hc->max_packet);

    if (num_packets > max_hc_pkt_count)
    {
      num_packets = max_hc_pkt_count;
      hc->xfer_len = (uint32_t)num_packets * hc->max_packet;
    }
  }
  else
  {
    num_packets = 1U;
  }
  if (hc->ep_is_in != 0U)
  {
    hc->xfer_len = (uint32_t)num_packets * hc->max_packet;
  }

  /* Initialize the HCTSIZn register */
  USBx_HC(ch_num)->HCTSIZ = (hc->xfer_len & USB_OTG_HCTSIZ_XFRSIZ) |
                            (((uint32_t)num_packets << 19) & USB_OTG_HCTSIZ_PKTCNT) |
                            (((uint32_t)hc->data_pid << 29) & USB_OTG_HCTSIZ_DPID);

  is_oddframe = (((uint32_t)USBx_HOST->HFNUM & 0x01U) != 0U) ? 0U : 1U;
  USBx_HC(ch_num)->HCCHAR &= ~USB_OTG_HCCHAR_ODDFRM;
  USBx_HC(ch_num)->HCCHAR |= (uint32_t)is_oddframe << 29;

  /* Set host channel enable */
  tmpreg = USBx_HC(ch_num)->HCCHAR;
  tmpreg &= ~USB_OTG_HCCHAR_CHDIS;

  /* make sure to set the correct ep direction */
  if (hc->ep_is_in != 0U)
  {
    tmpreg |= USB_OTG_HCCHAR_EPDIR;
  }
  else
  {
    tmpreg &= ~USB_OTG_HCCHAR_EPDIR;
  }
  tmpreg |= USB_OTG_HCCHAR_CHENA;
  USBx_HC(ch_num)->HCCHAR = tmpreg;

    if ((hc->ep_is_in == 0U) && (hc->xfer_len > 0U))
    {
      switch (hc->ep_type)
      {
        /* Non periodic transfer */
        case EP_TYPE_CTRL:
        case EP_TYPE_BULK:

          len_words = (uint16_t)((hc->xfer_len + 3U) / 4U);

          /* check if there is enough space in FIFO space */
          if (len_words > (USBx->HNPTXSTS & 0xFFFFU))
          {
            /* need to process data in nptxfempty interrupt */
            USBx->GINTMSK |= USB_OTG_GINTMSK_NPTXFEM;
          }
          break;

        /* Periodic transfer */
        case EP_TYPE_INTR:
        case EP_TYPE_ISOC:
          len_words = (uint16_t)((hc->xfer_len + 3U) / 4U);
          /* check if there is enough space in FIFO space */
          if (len_words > (USBx_HOST->HPTXSTS & 0xFFFFU)) /* split the transfer */
          {
            /* need to process data in ptxfempty interrupt */
            USBx->GINTMSK |= USB_OTG_GINTMSK_PTXFEM;
          }
          break;

        default:
          break;
      }

      /* Write packet into the Tx FIFO. */
      (void)USB_WritePacket(USBx, hc->xfer_buff, hc->ch_num, (uint16_t)hc->xfer_len);
    }

  return HAL_OK;
}

USB_HostInit()

HAL_StatusTypeDef USB_HostInit	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_OTG_CfgTypeDef	cfg
	)

USB_HostInit : Initializes the USB OTG controller registers for Host mode.

Parameters

USBx	Selected device
cfg	pointer to a USB_OTG_CfgTypeDef structure that contains the configuration information for the specified USBx peripheral.

Return values

HAL

status

Definition at line 1196 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t i;

  /* Restart the Phy Clock */
  USBx_PCGCCTL = 0U;

  /* Disable VBUS sensing */
  USBx->GCCFG &= ~(USB_OTG_GCCFG_VBDEN);

  /* Disable Battery chargin detector */
  USBx->GCCFG &= ~(USB_OTG_GCCFG_BCDEN);

  /* Set default Max speed support */
  USBx_HOST->HCFG &= ~(USB_OTG_HCFG_FSLSS);

  /* Make sure the FIFOs are flushed. */
  (void)USB_FlushTxFifo(USBx, 0x10U); /* all Tx FIFOs */
  (void)USB_FlushRxFifo(USBx);

  /* Clear all pending HC Interrupts */
  for (i = 0U; i < cfg.Host_channels; i++)
  {
    USBx_HC(i)->HCINT = 0xFFFFFFFFU;
    USBx_HC(i)->HCINTMSK = 0U;
  }

  /* Enable VBUS driving */
  (void)USB_DriveVbus(USBx, 1U);

  HAL_Delay(200U);

  /* Disable all interrupts. */
  USBx->GINTMSK = 0U;

  /* Clear any pending interrupts */
  USBx->GINTSTS = 0xFFFFFFFFU;

  /* set Rx FIFO size */
  USBx->GRXFSIZ  = 0x80U;
  USBx->DIEPTXF0_HNPTXFSIZ = (uint32_t)(((0x60U << 16) & USB_OTG_NPTXFD) | 0x80U);
  USBx->HPTXFSIZ = (uint32_t)(((0x40U << 16)& USB_OTG_HPTXFSIZ_PTXFD) | 0xE0U);
  /* Enable the common interrupts */
  USBx->GINTMSK |= USB_OTG_GINTMSK_RXFLVLM;

  /* Enable interrupts matching to the Host mode ONLY */
  USBx->GINTMSK |= (USB_OTG_GINTMSK_PRTIM            | USB_OTG_GINTMSK_HCIM | \
                    USB_OTG_GINTMSK_SOFM             | USB_OTG_GINTSTS_DISCINT | \
                    USB_OTG_GINTMSK_PXFRM_IISOOXFRM  | USB_OTG_GINTMSK_WUIM);

  return HAL_OK;
}

USB_InitFSLSPClkSel()

HAL_StatusTypeDef USB_InitFSLSPClkSel	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t	freq
	)

USB_InitFSLSPClkSel : Initializes the FSLSPClkSel field of the HCFG register on the PHY type and set the right frame interval.

Parameters

USBx	Selected device
freq	clock frequency This parameter can be one of these values: HCFG_48_MHZ : Full Speed 48 MHz Clock HCFG_6_MHZ : Low Speed 6 MHz Clock

Return values

HAL

status

Definition at line 1260 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  USBx_HOST->HCFG &= ~(USB_OTG_HCFG_FSLSPCS);
  USBx_HOST->HCFG |= (uint32_t)freq & USB_OTG_HCFG_FSLSPCS;

  if (freq == HCFG_48_MHZ)
  {
    USBx_HOST->HFIR = 48000U;
  }
  else if (freq == HCFG_6_MHZ)
  {
    USBx_HOST->HFIR = 6000U;
  }
  else
  {
    /* ... */
  }

  return HAL_OK;
}

USB_ReadDevAllInEpInterrupt() [1/2]

uint32_t USB_ReadDevAllInEpInterrupt

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_ReadDevAllInEpInterrupt: return the USB device IN endpoints interrupt status.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 1031 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t tmpreg;

  tmpreg  = USBx_DEVICE->DAINT;
  tmpreg &= USBx_DEVICE->DAINTMSK;

  return ((tmpreg & 0xFFFFU));
}

USB_ReadDevAllInEpInterrupt() [2/2]

uint32_t USB_ReadDevAllInEpInterrupt

(

USB_TypeDef *

USBx

)

USB_ReadDevAllInEpInterrupt: return the USB device IN endpoints interrupt status.

Parameters

USBx	: Selected device

Return values

HAL

status

Definition at line 2416 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */
  return (0);
}

USB_ReadDevAllOutEpInterrupt() [1/2]

uint32_t USB_ReadDevAllOutEpInterrupt

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_ReadDevAllOutEpInterrupt: return the USB device OUT endpoints interrupt status.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 1015 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t tmpreg;

  tmpreg  = USBx_DEVICE->DAINT;
  tmpreg &= USBx_DEVICE->DAINTMSK;

  return ((tmpreg & 0xffff0000U) >> 16);
}

USB_ReadDevAllOutEpInterrupt() [2/2]

uint32_t USB_ReadDevAllOutEpInterrupt

(

USB_TypeDef *

USBx

)

USB_ReadDevAllOutEpInterrupt: return the USB device OUT endpoints interrupt status.

Parameters

USBx	: Selected device

Return values

HAL

status

Definition at line 2400 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */
  return (0);
}

USB_ReadDevInEPInterrupt() [1/2]

uint32_t USB_ReadDevInEPInterrupt	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t	epnum
	)

Returns Device IN EP Interrupt register.

Parameters

USBx	Selected device
epnum	endpoint number This parameter can be a value from 0 to 15

Return values

Device

IN EP Interrupt register

Definition at line 1067 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t tmpreg, msk, emp;

  msk = USBx_DEVICE->DIEPMSK;
  emp = USBx_DEVICE->DIEPEMPMSK;
  msk |= ((emp >> (epnum & EP_ADDR_MSK)) & 0x1U) << 7;
  tmpreg = USBx_INEP((uint32_t)epnum)->DIEPINT & msk;

  return tmpreg;
}

USB_ReadDevInEPInterrupt() [2/2]

uint32_t USB_ReadDevInEPInterrupt	(	USB_TypeDef *	USBx,
		uint8_t	epnum
	)

Returns Device IN EP Interrupt register.

Parameters

USBx	: Selected device
epnum	: endpoint number This parameter can be a value from 0 to 15

Return values

Device

IN EP Interrupt register

Definition at line 2453 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(epnum);
  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */
  return (0);
}

USB_ReadDevOutEPInterrupt() [1/2]

uint32_t USB_ReadDevOutEPInterrupt	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t	epnum
	)

Returns Device OUT EP Interrupt register.

Parameters

USBx	Selected device
epnum	endpoint number This parameter can be a value from 0 to 15

Return values

Device

OUT EP Interrupt register

Definition at line 1049 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t tmpreg;

  tmpreg  = USBx_OUTEP((uint32_t)epnum)->DOEPINT;
  tmpreg &= USBx_DEVICE->DOEPMSK;

  return tmpreg;
}

USB_ReadDevOutEPInterrupt() [2/2]

uint32_t USB_ReadDevOutEPInterrupt	(	USB_TypeDef *	USBx,
		uint8_t	epnum
	)

Returns Device OUT EP Interrupt register.

Parameters

USBx	: Selected device
epnum	: endpoint number This parameter can be a value from 0 to 15

Return values

Device

OUT EP Interrupt register

Definition at line 2434 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(epnum);
  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */
  return (0);
}

USB_ReadInterrupts() [1/2]

uint32_t USB_ReadInterrupts

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_ReadInterrupts: return the global USB interrupt status.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 1000 of file stm32l4xx_ll_usb.c.

{
  uint32_t tmpreg;

  tmpreg = USBx->GINTSTS;
  tmpreg &= USBx->GINTMSK;

  return tmpreg;
}

USB_ReadInterrupts() [2/2]

uint32_t USB_ReadInterrupts

(

USB_TypeDef *

USBx

)

USB_ReadInterrupts: return the global USB interrupt status.

Parameters

USBx	: Selected device

Return values

HAL

status

Definition at line 2387 of file stm32l4xx_ll_usb.c.

{
  uint32_t tmpreg;

  tmpreg = USBx->ISTR;
  return tmpreg;
}

USB_ReadPacket() [1/2]

void* USB_ReadPacket	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t *	dest,
		uint16_t	len
	)

USB_ReadPacket : read a packet from the RX FIFO.

Parameters

USBx	Selected device
dest	source pointer
len	Number of bytes to read

Return values

pointer

to destination buffer

Definition at line 832 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t *pDest = (uint32_t *)dest;
  uint32_t i;
  uint32_t count32b = ((uint32_t)len + 3U) / 4U;

  for (i = 0U; i < count32b; i++)
  {
    __UNALIGNED_UINT32_WRITE(pDest, USBx_DFIFO(0U));
    pDest++;
  }

  return ((void *)pDest);
}

USB_ReadPacket() [2/2]

void* USB_ReadPacket	(	USB_TypeDef *	USBx,
		uint8_t *	dest,
		uint16_t	len
	)

USB_ReadPacket : read a packet from the Tx FIFO associated with the EP/channel.

Parameters

USBx	: Selected device
dest	: destination pointer
len	: Number of bytes to read

Return values

pointer

to destination buffer

Definition at line 2254 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(dest);
  UNUSED(len);
  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */
  return ((void *)NULL);
}

USB_ReadPMA()

void USB_ReadPMA	(	USB_TypeDef *	USBx,
		uint8_t *	pbUsrBuf,
		uint16_t	wPMABufAddr,
		uint16_t	wNBytes
	)

Copy a buffer from user memory area to packet memory area (PMA)

Parameters

USBx	USB peripheral instance register address.
pbUsrBuf	pointer to user memory area.
wPMABufAddr	address into PMA.
wNBytes	no. of bytes to be copied.

Return values

None

Definition at line 2565 of file stm32l4xx_ll_usb.c.

{
  uint32_t n = (uint32_t)wNBytes >> 1;
  uint32_t BaseAddr = (uint32_t)USBx;
  uint32_t i, temp;
  uint16_t *pdwVal;
  uint8_t *pBuf = pbUsrBuf;

  pdwVal = (uint16_t *)(BaseAddr + 0x400U + ((uint32_t)wPMABufAddr * PMA_ACCESS));

  for (i = n; i != 0U; i--)
  {
    temp = *pdwVal;
    pdwVal++;
    *pBuf = (uint8_t)((temp >> 0) & 0xFFU);
    pBuf++;
    *pBuf = (uint8_t)((temp >> 8) & 0xFFU);
    pBuf++;

#if PMA_ACCESS > 1U
    pdwVal++;
#endif
  }

  if ((wNBytes % 2U) != 0U)
  {
    temp = *pdwVal;
    *pBuf = (uint8_t)((temp >> 0) & 0xFFU);
  }
}

USB_ResetPort()

HAL_StatusTypeDef USB_ResetPort

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_OTG_ResetPort : Reset Host Port.

Parameters

USBx	Selected device

Return values

HAL

status

Note

(1)The application must wait at least 10 ms before clearing the reset bit.

Definition at line 1290 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  __IO uint32_t hprt0 = 0U;

  hprt0 = USBx_HPRT0;

  hprt0 &= ~(USB_OTG_HPRT_PENA | USB_OTG_HPRT_PCDET |
             USB_OTG_HPRT_PENCHNG | USB_OTG_HPRT_POCCHNG);

  USBx_HPRT0 = (USB_OTG_HPRT_PRST | hprt0);
  HAL_Delay(100U);                                 /* See Note #1 */
  USBx_HPRT0 = ((~USB_OTG_HPRT_PRST) & hprt0);
  HAL_Delay(10U);

  return HAL_OK;
}

USB_SetCurrentMode() [1/2]

HAL_StatusTypeDef USB_SetCurrentMode	(	USB_OTG_GlobalTypeDef *	USBx,
		USB_ModeTypeDef	mode
	)

USB_SetCurrentMode : Set functional mode.

Parameters

USBx	Selected device
mode	current core mode This parameter can be one of these values: USB_DEVICE_MODE: Peripheral mode USB_HOST_MODE: Host mode USB_DRD_MODE: Dual Role Device mode

Return values

HAL

status

Definition at line 239 of file stm32l4xx_ll_usb.c.

{
  USBx->GUSBCFG &= ~(USB_OTG_GUSBCFG_FHMOD | USB_OTG_GUSBCFG_FDMOD);

  if (mode == USB_HOST_MODE)
  {
    USBx->GUSBCFG |= USB_OTG_GUSBCFG_FHMOD;
  }
  else if (mode == USB_DEVICE_MODE)
  {
    USBx->GUSBCFG |= USB_OTG_GUSBCFG_FDMOD;
  }
  else
  {
    return HAL_ERROR;
  }
  HAL_Delay(50U);

  return HAL_OK;
}

USB_SetCurrentMode() [2/2]

HAL_StatusTypeDef USB_SetCurrentMode	(	USB_TypeDef *	USBx,
		USB_ModeTypeDef	mode
	)

USB_SetCurrentMode : Set functional mode.

Parameters

USBx	: Selected device
mode	: current core mode This parameter can be one of the these values: USB_DEVICE_MODE: Peripheral mode mode

Return values

HAL

status

Definition at line 1863 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(mode);

  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */
  return HAL_OK;
}

USB_SetDevAddress() [1/2]

HAL_StatusTypeDef USB_SetDevAddress	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t	address
	)

USB_SetDevAddress : Stop the usb device mode.

Parameters

USBx	Selected device
address	new device address to be assigned This parameter can be a value from 0 to 255

Return values

HAL

status

Definition at line 955 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  USBx_DEVICE->DCFG &= ~(USB_OTG_DCFG_DAD);
  USBx_DEVICE->DCFG |= ((uint32_t)address << 4) & USB_OTG_DCFG_DAD;

  return HAL_OK;
}

USB_SetDevAddress() [2/2]

HAL_StatusTypeDef USB_SetDevAddress	(	USB_TypeDef *	USBx,
		uint8_t	address
	)

USB_SetDevAddress : Stop the usb device mode.

Parameters

USBx	: Selected device
address	: new device address to be assigned This parameter can be a value from 0 to 255

Return values

HAL

status

Definition at line 2345 of file stm32l4xx_ll_usb.c.

{
  if (address == 0U)
  {
    /* set device address and enable function */
    USBx->DADDR = USB_DADDR_EF;
  }

  return HAL_OK;
}

USB_SetDevSpeed() [1/2]

HAL_StatusTypeDef USB_SetDevSpeed	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t	speed
	)

USB_SetDevSpeed Initializes the DevSpd field of DCFG register depending the PHY type and the enumeration speed of the device.

Parameters

USBx	Selected device
speed	device speed This parameter can be one of these values: USB_OTG_SPEED_FULL: Full speed mode

Return values

Hal

status

Definition at line 452 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;

  USBx_DEVICE->DCFG |= speed;
  return HAL_OK;
}

USB_SetDevSpeed() [2/2]

HAL_StatusTypeDef USB_SetDevSpeed	(	USB_TypeDef *	USBx,
		uint8_t	speed
	)

USB_SetDevSpeed :Initializes the device speed depending on the PHY type and the enumeration speed of the device.

Parameters

USBx	Selected device
speed	device speed

Return values

Hal

status

Definition at line 1915 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(speed);

  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */

  return HAL_OK;
}

USB_SetTurnaroundTime()

HAL_StatusTypeDef USB_SetTurnaroundTime	(	USB_OTG_GlobalTypeDef *	USBx,
		uint32_t	hclk,
		uint8_t	speed
	)

Set the USB turnaround time.

Parameters

USBx	USB Instance
hclk	AHB clock frequency

Return values

USB	turnaround time In PHY Clocks number

Definition at line 132 of file stm32l4xx_ll_usb.c.

{
  uint32_t UsbTrd;

  /* The USBTRD is configured according to the tables below, depending on AHB frequency
  used by application. In the low AHB frequency range it is used to stretch enough the USB response
  time to IN tokens, the USB turnaround time, so to compensate for the longer AHB read access
  latency to the Data FIFO */
  if (speed == USBD_FS_SPEED)
  {
    if ((hclk >= 14200000U) && (hclk < 15000000U))
    {
      /* hclk Clock Range between 14.2-15 MHz */
      UsbTrd = 0xFU;
    }
    else if ((hclk >= 15000000U) && (hclk < 16000000U))
    {
      /* hclk Clock Range between 15-16 MHz */
      UsbTrd = 0xEU;
    }
    else if ((hclk >= 16000000U) && (hclk < 17200000U))
    {
      /* hclk Clock Range between 16-17.2 MHz */
      UsbTrd = 0xDU;
    }
    else if ((hclk >= 17200000U) && (hclk < 18500000U))
    {
      /* hclk Clock Range between 17.2-18.5 MHz */
      UsbTrd = 0xCU;
    }
    else if ((hclk >= 18500000U) && (hclk < 20000000U))
    {
      /* hclk Clock Range between 18.5-20 MHz */
      UsbTrd = 0xBU;
    }
    else if ((hclk >= 20000000U) && (hclk < 21800000U))
    {
      /* hclk Clock Range between 20-21.8 MHz */
      UsbTrd = 0xAU;
    }
    else if ((hclk >= 21800000U) && (hclk < 24000000U))
    {
      /* hclk Clock Range between 21.8-24 MHz */
      UsbTrd = 0x9U;
    }
    else if ((hclk >= 24000000U) && (hclk < 27700000U))
    {
      /* hclk Clock Range between 24-27.7 MHz */
      UsbTrd = 0x8U;
    }
    else if ((hclk >= 27700000U) && (hclk < 32000000U))
    {
      /* hclk Clock Range between 27.7-32 MHz */
      UsbTrd = 0x7U;
    }
    else /* if(hclk >= 32000000) */
    {
      /* hclk Clock Range between 32-200 MHz */
      UsbTrd = 0x6U;
    }
  }
  else
  {
    UsbTrd = USBD_DEFAULT_TRDT_VALUE;
  }

  USBx->GUSBCFG &= ~USB_OTG_GUSBCFG_TRDT;
  USBx->GUSBCFG |= (uint32_t)((UsbTrd << 10) & USB_OTG_GUSBCFG_TRDT);

  return HAL_OK;
}

USB_StopDevice() [1/2]

HAL_StatusTypeDef USB_StopDevice

(

USB_OTG_GlobalTypeDef *

USBx

)

USB_StopDevice : Stop the usb device mode.

Parameters

USBx	Selected device

Return values

HAL

status

Definition at line 914 of file stm32l4xx_ll_usb.c.

{
  HAL_StatusTypeDef ret;
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t i;

  /* Clear Pending interrupt */
  for (i = 0U; i < 15U; i++)
  {
    USBx_INEP(i)->DIEPINT = 0xFB7FU;
    USBx_OUTEP(i)->DOEPINT = 0xFB7FU;
  }

  /* Clear interrupt masks */
  USBx_DEVICE->DIEPMSK  = 0U;
  USBx_DEVICE->DOEPMSK  = 0U;
  USBx_DEVICE->DAINTMSK = 0U;

  /* Flush the FIFO */
  ret = USB_FlushRxFifo(USBx);
  if (ret != HAL_OK)
  {
    return ret;
  }

  ret = USB_FlushTxFifo(USBx,  0x10U);
  if (ret != HAL_OK)
  {
    return ret;
  }

  return ret;
}

USB_StopDevice() [2/2]

HAL_StatusTypeDef USB_StopDevice

(

USB_TypeDef *

USBx

)

USB_StopDevice : Stop the usb device mode.

Parameters

USBx	: Selected device

Return values

HAL

status

Definition at line 2324 of file stm32l4xx_ll_usb.c.

{
  /* disable all interrupts and force USB reset */
  USBx->CNTR = USB_CNTR_FRES;

  /* clear interrupt status register */
  USBx->ISTR = 0;

  /* switch-off device */
  USBx->CNTR = (USB_CNTR_FRES | USB_CNTR_PDWN);

  return HAL_OK;
}

USB_StopHost()

HAL_StatusTypeDef USB_StopHost

(

USB_OTG_GlobalTypeDef *

USBx

)

Stop Host Core.

Parameters

USBx	Selected device

Return values

HAL

state

Definition at line 1704 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t count = 0U;
  uint32_t value;
  uint32_t i;


  (void)USB_DisableGlobalInt(USBx);

  /* Flush FIFO */
  (void)USB_FlushTxFifo(USBx, 0x10U);
  (void)USB_FlushRxFifo(USBx);

  /* Flush out any leftover queued requests. */
  for (i = 0U; i <= 15U; i++)
  {
    value = USBx_HC(i)->HCCHAR;
    value |=  USB_OTG_HCCHAR_CHDIS;
    value &= ~USB_OTG_HCCHAR_CHENA;
    value &= ~USB_OTG_HCCHAR_EPDIR;
    USBx_HC(i)->HCCHAR = value;
  }

  /* Halt all channels to put them into a known state. */
  for (i = 0U; i <= 15U; i++)
  {
    value = USBx_HC(i)->HCCHAR;
    value |= USB_OTG_HCCHAR_CHDIS;
    value |= USB_OTG_HCCHAR_CHENA;
    value &= ~USB_OTG_HCCHAR_EPDIR;
    USBx_HC(i)->HCCHAR = value;

    do
    {
      if (++count > 1000U)
      {
        break;
      }
    }
    while ((USBx_HC(i)->HCCHAR & USB_OTG_HCCHAR_CHENA) == USB_OTG_HCCHAR_CHENA);
  }

  /* Clear any pending Host interrupts */
  USBx_HOST->HAINT = 0xFFFFFFFFU;
  USBx->GINTSTS = 0xFFFFFFFFU;
  (void)USB_EnableGlobalInt(USBx);

  return HAL_OK;
}

USB_WritePacket() [1/2]

HAL_StatusTypeDef USB_WritePacket	(	USB_OTG_GlobalTypeDef *	USBx,
		uint8_t *	src,
		uint8_t	ch_ep_num,
		uint16_t	len
	)

USB_WritePacket : Writes a packet into the Tx FIFO associated with the EP/channel.

Parameters

USBx	Selected device
src	pointer to source buffer
ch_ep_num	endpoint or host channel number
len	Number of bytes to write

Return values

HAL

status

Definition at line 809 of file stm32l4xx_ll_usb.c.

{
  uint32_t USBx_BASE = (uint32_t)USBx;
  uint32_t *pSrc = (uint32_t *)src;
  uint32_t count32b, i;

  count32b = ((uint32_t)len + 3U) / 4U;
  for (i = 0U; i < count32b; i++)
  {
    USBx_DFIFO((uint32_t)ch_ep_num) = __UNALIGNED_UINT32_READ(pSrc);
    pSrc++;
  }

  return HAL_OK;
}

USB_WritePacket() [2/2]

HAL_StatusTypeDef USB_WritePacket	(	USB_TypeDef *	USBx,
		uint8_t *	src,
		uint8_t	ch_ep_num,
		uint16_t	len
	)

USB_WritePacket : Writes a packet into the Tx FIFO associated with the EP/channel.

Parameters

USBx	: Selected device
src	: pointer to source buffer
ch_ep_num	: endpoint or host channel number
len	: Number of bytes to write

Return values

HAL

status

Definition at line 2232 of file stm32l4xx_ll_usb.c.

{
  /* Prevent unused argument(s) compilation warning */
  UNUSED(USBx);
  UNUSED(src);
  UNUSED(ch_ep_num);
  UNUSED(len);
  /* NOTE : - This function is not required by USB Device FS peripheral, it is used
              only by USB OTG FS peripheral.
            - This function is added to ensure compatibility across platforms.
   */
  return HAL_OK;
}

USB_WritePMA()

void USB_WritePMA	(	USB_TypeDef *	USBx,
		uint8_t *	pbUsrBuf,
		uint16_t	wPMABufAddr,
		uint16_t	wNBytes
	)

Copy a buffer from user memory area to packet memory area (PMA)

Parameters

USBx	USB peripheral instance register address.
pbUsrBuf	pointer to user memory area.
wPMABufAddr	address into PMA.
wNBytes	no. of bytes to be copied.

Return values

None

Definition at line 2531 of file stm32l4xx_ll_usb.c.

{
  uint32_t n = ((uint32_t)wNBytes + 1U) >> 1;
  uint32_t BaseAddr = (uint32_t)USBx;
  uint32_t i, temp1, temp2;
  uint16_t *pdwVal;
  uint8_t *pBuf = pbUsrBuf;

  pdwVal = (uint16_t *)(BaseAddr + 0x400U + ((uint32_t)wPMABufAddr * PMA_ACCESS));

  for (i = n; i != 0U; i--)
  {
    temp1 = (uint16_t) * pBuf;
    pBuf++;
    temp2 = temp1 | ((uint16_t)((uint16_t) * pBuf << 8));
    *pdwVal = (uint16_t)temp2;
    pdwVal++;

#if PMA_ACCESS > 1U
    pdwVal++;
#endif

    pBuf++;
  }
}