lib/main/STM32G4/Drivers/STM32G4xx_HAL_Driver/Src/stm32g4xx_ll_usb.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32g4xx_ll_usb.c
   4   * @author  MCD Application Team
   5   * @brief   USB Low Layer HAL module driver.
   6   *
   7   *          This file provides firmware functions to manage the following
   8   *          functionalities of the USB Peripheral Controller:
   9   *           + Initialization/de-initialization functions
  10   *           + I/O operation functions
  11   *           + Peripheral Control functions
  12   *           + Peripheral State functions
  13   *
  14   @verbatim
  15   ==============================================================================
  16                     ##### How to use this driver #####
  17   ==============================================================================
  18     [..]
  19       (#) Fill parameters of Init structure in USB_OTG_CfgTypeDef structure.
  20
  21       (#) Call USB_CoreInit() API to initialize the USB Core peripheral.
  22
  23       (#) The upper HAL HCD/PCD driver will call the right routines for its internal processes.
  24
  25   @endverbatim
  26   ******************************************************************************
  27   * @attention
  28   *
  29   * <h2><center>&copy; Copyright (c) 2017 STMicroelectronics.
  30   * All rights reserved.</center></h2>
  31   *
  32   * This software component is licensed by ST under BSD 3-Clause license,
  33   * the "License"; You may not use this file except in compliance with the
  34   * License. You may obtain a copy of the License at:
  35   *                        opensource.org/licenses/BSD-3-Clause
  36   *
  37   ******************************************************************************
  38   */
  39
  40 /* Includes ------------------------------------------------------------------*/
  41 #include "stm32g4xx_hal.h"
  42
  43 /** @addtogroup STM32G4xx_LL_USB_DRIVER
  44   * @{
  45   */
  46
  47 #if defined (HAL_PCD_MODULE_ENABLED) || defined (HAL_HCD_MODULE_ENABLED)
  48 #if defined (USB)
  49 /* Private typedef -----------------------------------------------------------*/
  50 /* Private define ------------------------------------------------------------*/
  51 /* Private macro -------------------------------------------------------------*/
  52 /* Private variables ---------------------------------------------------------*/
  53 /* Private function prototypes -----------------------------------------------*/
  54 /* Private functions ---------------------------------------------------------*/
  55
  56
  57 /**
  58   * @brief  Initializes the USB Core
  59   * @param  USBx: USB Instance
  60   * @param  cfg : pointer to a USB_CfgTypeDef structure that contains
  61   *         the configuration information for the specified USBx peripheral.
  62   * @retval HAL status
  63   */
  64 HAL_StatusTypeDef USB_CoreInit(USB_TypeDef *USBx, USB_CfgTypeDef cfg)
  65 {
  66   /* Prevent unused argument(s) compilation warning */
  67   UNUSED(USBx);
  68   UNUSED(cfg);
  69
  70   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
  71               only by USB OTG FS peripheral.
  72             - This function is added to ensure compatibility across platforms.
  73    */
  74
  75   return HAL_OK;
  76 }
  77
  78 /**
  79   * @brief  USB_EnableGlobalInt
  80   *         Enables the controller's Global Int in the AHB Config reg
  81   * @param  USBx : Selected device
  82   * @retval HAL status
  83   */
  84 HAL_StatusTypeDef USB_EnableGlobalInt(USB_TypeDef *USBx)
  85 {
  86   uint16_t winterruptmask;
  87
  88   /* Set winterruptmask variable */
  89   winterruptmask = USB_CNTR_CTRM  | USB_CNTR_WKUPM |
  90                    USB_CNTR_SUSPM | USB_CNTR_ERRM |
  91                    USB_CNTR_SOFM | USB_CNTR_ESOFM |
  92                    USB_CNTR_RESETM | USB_CNTR_L1REQM;
  93
  94   /* Set interrupt mask */
  95   USBx->CNTR |= winterruptmask;
  96
  97   return HAL_OK;
  98 }
  99
 100 /**
 101   * @brief  USB_DisableGlobalInt
 102   *         Disable the controller's Global Int in the AHB Config reg
 103   * @param  USBx : Selected device
 104   * @retval HAL status
 105 */
 106 HAL_StatusTypeDef USB_DisableGlobalInt(USB_TypeDef *USBx)
 107 {
 108   uint16_t winterruptmask;
 109
 110   /* Set winterruptmask variable */
 111   winterruptmask = USB_CNTR_CTRM  | USB_CNTR_WKUPM |
 112                    USB_CNTR_SUSPM | USB_CNTR_ERRM |
 113                    USB_CNTR_SOFM | USB_CNTR_ESOFM |
 114                    USB_CNTR_RESETM | USB_CNTR_L1REQM;
 115
 116   /* Clear interrupt mask */
 117   USBx->CNTR &= ~winterruptmask;
 118
 119   return HAL_OK;
 120 }
 121
 122 /**
 123   * @brief  USB_SetCurrentMode : Set functional mode
 124   * @param  USBx : Selected device
 125   * @param  mode :  current core mode
 126   *          This parameter can be one of the these values:
 127   *            @arg USB_DEVICE_MODE: Peripheral mode mode
 128   * @retval HAL status
 129   */
 130 HAL_StatusTypeDef USB_SetCurrentMode(USB_TypeDef *USBx, USB_ModeTypeDef mode)
 131 {
 132   /* Prevent unused argument(s) compilation warning */
 133   UNUSED(USBx);
 134   UNUSED(mode);
 135
 136   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 137               only by USB OTG FS peripheral.
 138             - This function is added to ensure compatibility across platforms.
 139    */
 140   return HAL_OK;
 141 }
 142
 143 /**
 144   * @brief  USB_DevInit : Initializes the USB controller registers
 145   *         for device mode
 146   * @param  USBx : Selected device
 147   * @param  cfg  : pointer to a USB_CfgTypeDef structure that contains
 148   *         the configuration information for the specified USBx peripheral.
 149   * @retval HAL status
 150   */
 151 HAL_StatusTypeDef USB_DevInit(USB_TypeDef *USBx, USB_CfgTypeDef cfg)
 152 {
 153   /* Prevent unused argument(s) compilation warning */
 154   UNUSED(cfg);
 155
 156   /* Init Device */
 157   /*CNTR_FRES = 1*/
 158   USBx->CNTR = USB_CNTR_FRES;
 159
 160   /*CNTR_FRES = 0*/
 161   USBx->CNTR = 0;
 162
 163   /*Clear pending interrupts*/
 164   USBx->ISTR = 0;
 165
 166   /*Set Btable Address*/
 167   USBx->BTABLE = BTABLE_ADDRESS;
 168
 169   /* Enable USB Device Interrupt mask */
 170   (void)USB_EnableGlobalInt(USBx);
 171
 172   return HAL_OK;
 173 }
 174
 175 /**
 176   * @brief  USB_SetDevSpeed :Initializes the device speed
 177   *         depending on the PHY type and the enumeration speed of the device.
 178   * @param  USBx  Selected device
 179   * @param  speed  device speed
 180   * @retval  Hal status
 181   */
 182 HAL_StatusTypeDef USB_SetDevSpeed(USB_TypeDef *USBx, uint8_t speed)
 183 {
 184   /* Prevent unused argument(s) compilation warning */
 185   UNUSED(USBx);
 186   UNUSED(speed);
 187
 188   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 189               only by USB OTG FS peripheral.
 190             - This function is added to ensure compatibility across platforms.
 191    */
 192
 193   return HAL_OK;
 194 }
 195
 196 /**
 197   * @brief  USB_FlushTxFifo : Flush a Tx FIFO
 198   * @param  USBx : Selected device
 199   * @param  num : FIFO number
 200   *         This parameter can be a value from 1 to 15
 201             15 means Flush all Tx FIFOs
 202   * @retval HAL status
 203   */
 204 HAL_StatusTypeDef USB_FlushTxFifo(USB_TypeDef *USBx, uint32_t num)
 205 {
 206   /* Prevent unused argument(s) compilation warning */
 207   UNUSED(USBx);
 208   UNUSED(num);
 209
 210   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 211               only by USB OTG FS peripheral.
 212             - This function is added to ensure compatibility across platforms.
 213    */
 214
 215   return HAL_OK;
 216 }
 217
 218 /**
 219   * @brief  USB_FlushRxFifo : Flush Rx FIFO
 220   * @param  USBx : Selected device
 221   * @retval HAL status
 222   */
 223 HAL_StatusTypeDef USB_FlushRxFifo(USB_TypeDef *USBx)
 224 {
 225   /* Prevent unused argument(s) compilation warning */
 226   UNUSED(USBx);
 227
 228   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 229               only by USB OTG FS peripheral.
 230             - This function is added to ensure compatibility across platforms.
 231    */
 232
 233   return HAL_OK;
 234 }
 235
 236 /**
 237   * @brief  Activate and configure an endpoint
 238   * @param  USBx : Selected device
 239   * @param  ep: pointer to endpoint structure
 240   * @retval HAL status
 241   */
 242 HAL_StatusTypeDef USB_ActivateEndpoint(USB_TypeDef *USBx, USB_EPTypeDef *ep)
 243 {
 244   HAL_StatusTypeDef ret = HAL_OK;
 245   uint16_t wEpRegVal;
 246
 247   wEpRegVal = PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_T_MASK;
 248
 249   /* initialize Endpoint */
 250   switch (ep->type)
 251   {
 252     case EP_TYPE_CTRL:
 253       wEpRegVal |= USB_EP_CONTROL;
 254       break;
 255
 256     case EP_TYPE_BULK:
 257       wEpRegVal |= USB_EP_BULK;
 258       break;
 259
 260     case EP_TYPE_INTR:
 261       wEpRegVal |= USB_EP_INTERRUPT;
 262       break;
 263
 264     case EP_TYPE_ISOC:
 265       wEpRegVal |= USB_EP_ISOCHRONOUS;
 266       break;
 267
 268     default:
 269       ret = HAL_ERROR;
 270       break;
 271   }
 272
 273   PCD_SET_ENDPOINT(USBx, ep->num, wEpRegVal | USB_EP_CTR_RX | USB_EP_CTR_TX);
 274
 275   PCD_SET_EP_ADDRESS(USBx, ep->num, ep->num);
 276
 277   if (ep->doublebuffer == 0U)
 278   {
 279     if (ep->is_in != 0U)
 280     {
 281       /*Set the endpoint Transmit buffer address */
 282       PCD_SET_EP_TX_ADDRESS(USBx, ep->num, ep->pmaadress);
 283       PCD_CLEAR_TX_DTOG(USBx, ep->num);
 284
 285       if (ep->type != EP_TYPE_ISOC)
 286       {
 287         /* Configure NAK status for the Endpoint */
 288         PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
 289       }
 290       else
 291       {
 292         /* Configure TX Endpoint to disabled state */
 293         PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
 294       }
 295     }
 296     else
 297     {
 298       /*Set the endpoint Receive buffer address */
 299       PCD_SET_EP_RX_ADDRESS(USBx, ep->num, ep->pmaadress);
 300       /*Set the endpoint Receive buffer counter*/
 301       PCD_SET_EP_RX_CNT(USBx, ep->num, ep->maxpacket);
 302       PCD_CLEAR_RX_DTOG(USBx, ep->num);
 303       /* Configure VALID status for the Endpoint*/
 304       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
 305     }
 306   }
 307   /*Double Buffer*/
 308   else
 309   {
 310     /* Set the endpoint as double buffered */
 311     PCD_SET_EP_DBUF(USBx, ep->num);
 312     /* Set buffer address for double buffered mode */
 313     PCD_SET_EP_DBUF_ADDR(USBx, ep->num, ep->pmaaddr0, ep->pmaaddr1);
 314
 315     if (ep->is_in == 0U)
 316     {
 317       /* Clear the data toggle bits for the endpoint IN/OUT */
 318       PCD_CLEAR_RX_DTOG(USBx, ep->num);
 319       PCD_CLEAR_TX_DTOG(USBx, ep->num);
 320
 321       /* Reset value of the data toggle bits for the endpoint out */
 322       PCD_TX_DTOG(USBx, ep->num);
 323
 324       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
 325       PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
 326     }
 327     else
 328     {
 329       /* Clear the data toggle bits for the endpoint IN/OUT */
 330       PCD_CLEAR_RX_DTOG(USBx, ep->num);
 331       PCD_CLEAR_TX_DTOG(USBx, ep->num);
 332       PCD_RX_DTOG(USBx, ep->num);
 333
 334       if (ep->type != EP_TYPE_ISOC)
 335       {
 336         /* Configure NAK status for the Endpoint */
 337         PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
 338       }
 339       else
 340       {
 341         /* Configure TX Endpoint to disabled state */
 342         PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
 343       }
 344
 345       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
 346     }
 347   }
 348
 349   return ret;
 350 }
 351
 352 /**
 353   * @brief  De-activate and de-initialize an endpoint
 354   * @param  USBx : Selected device
 355   * @param  ep: pointer to endpoint structure
 356   * @retval HAL status
 357   */
 358 HAL_StatusTypeDef USB_DeactivateEndpoint(USB_TypeDef *USBx, USB_EPTypeDef *ep)
 359 {
 360   if (ep->doublebuffer == 0U)
 361   {
 362     if (ep->is_in != 0U)
 363     {
 364       PCD_CLEAR_TX_DTOG(USBx, ep->num);
 365       /* Configure DISABLE status for the Endpoint*/
 366       PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
 367     }
 368     else
 369     {
 370       PCD_CLEAR_RX_DTOG(USBx, ep->num);
 371       /* Configure DISABLE status for the Endpoint*/
 372       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
 373     }
 374   }
 375   /*Double Buffer*/
 376   else
 377   {
 378     if (ep->is_in == 0U)
 379     {
 380       /* Clear the data toggle bits for the endpoint IN/OUT*/
 381       PCD_CLEAR_RX_DTOG(USBx, ep->num);
 382       PCD_CLEAR_TX_DTOG(USBx, ep->num);
 383
 384       /* Reset value of the data toggle bits for the endpoint out*/
 385       PCD_TX_DTOG(USBx, ep->num);
 386
 387       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
 388       PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
 389     }
 390     else
 391     {
 392       /* Clear the data toggle bits for the endpoint IN/OUT*/
 393       PCD_CLEAR_RX_DTOG(USBx, ep->num);
 394       PCD_CLEAR_TX_DTOG(USBx, ep->num);
 395       PCD_RX_DTOG(USBx, ep->num);
 396       /* Configure DISABLE status for the Endpoint*/
 397       PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_DIS);
 398       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_DIS);
 399     }
 400   }
 401
 402   return HAL_OK;
 403 }
 404
 405 /**
 406   * @brief  USB_EPStartXfer : setup and starts a transfer over an EP
 407   * @param  USBx : Selected device
 408   * @param  ep: pointer to endpoint structure
 409   * @retval HAL status
 410   */
 411 HAL_StatusTypeDef USB_EPStartXfer(USB_TypeDef *USBx, USB_EPTypeDef *ep)
 412 {
 413   uint16_t pmabuffer;
 414   uint32_t len;
 415
 416   /* IN endpoint */
 417   if (ep->is_in == 1U)
 418   {
 419     /*Multi packet transfer*/
 420     if (ep->xfer_len > ep->maxpacket)
 421     {
 422       len = ep->maxpacket;
 423       ep->xfer_len -= len;
 424     }
 425     else
 426     {
 427       len = ep->xfer_len;
 428       ep->xfer_len = 0U;
 429     }
 430
 431     /* configure and validate Tx endpoint */
 432     if (ep->doublebuffer == 0U)
 433     {
 434       USB_WritePMA(USBx, ep->xfer_buff, ep->pmaadress, (uint16_t)len);
 435       PCD_SET_EP_TX_CNT(USBx, ep->num, len);
 436     }
 437     else
 438     {
 439       /* Write the data to the USB endpoint */
 440       if ((PCD_GET_ENDPOINT(USBx, ep->num) & USB_EP_DTOG_TX) != 0U)
 441       {
 442         /* Set the Double buffer counter for pmabuffer1 */
 443         PCD_SET_EP_DBUF1_CNT(USBx, ep->num, ep->is_in, len);
 444         pmabuffer = ep->pmaaddr1;
 445       }
 446       else
 447       {
 448         /* Set the Double buffer counter for pmabuffer0 */
 449         PCD_SET_EP_DBUF0_CNT(USBx, ep->num, ep->is_in, len);
 450         pmabuffer = ep->pmaaddr0;
 451       }
 452       USB_WritePMA(USBx, ep->xfer_buff, pmabuffer, (uint16_t)len);
 453       PCD_FreeUserBuffer(USBx, ep->num, ep->is_in);
 454     }
 455
 456     PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_VALID);
 457   }
 458   else /* OUT endpoint */
 459   {
 460     /* Multi packet transfer*/
 461     if (ep->xfer_len > ep->maxpacket)
 462     {
 463       len = ep->maxpacket;
 464       ep->xfer_len -= len;
 465     }
 466     else
 467     {
 468       len = ep->xfer_len;
 469       ep->xfer_len = 0U;
 470     }
 471
 472     /* configure and validate Rx endpoint */
 473     if (ep->doublebuffer == 0U)
 474     {
 475       /*Set RX buffer count*/
 476       PCD_SET_EP_RX_CNT(USBx, ep->num, len);
 477     }
 478     else
 479     {
 480       /*Set the Double buffer counter*/
 481       PCD_SET_EP_DBUF_CNT(USBx, ep->num, ep->is_in, len);
 482     }
 483
 484     PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
 485   }
 486
 487   return HAL_OK;
 488 }
 489
 490 /**
 491   * @brief  USB_WritePacket : Writes a packet into the Tx FIFO associated
 492   *         with the EP/channel
 493   * @param  USBx : Selected device
 494   * @param  src :  pointer to source buffer
 495   * @param  ch_ep_num : endpoint or host channel number
 496   * @param  len : Number of bytes to write
 497   * @retval HAL status
 498   */
 499 HAL_StatusTypeDef USB_WritePacket(USB_TypeDef *USBx, uint8_t *src, uint8_t ch_ep_num, uint16_t len)
 500 {
 501   /* Prevent unused argument(s) compilation warning */
 502   UNUSED(USBx);
 503   UNUSED(src);
 504   UNUSED(ch_ep_num);
 505   UNUSED(len);
 506   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 507               only by USB OTG FS peripheral.
 508             - This function is added to ensure compatibility across platforms.
 509    */
 510   return HAL_OK;
 511 }
 512
 513 /**
 514   * @brief  USB_ReadPacket : read a packet from the Tx FIFO associated
 515   *         with the EP/channel
 516   * @param  USBx : Selected device
 517   * @param  dest : destination pointer
 518   * @param  len : Number of bytes to read
 519   * @retval pointer to destination buffer
 520   */
 521 void *USB_ReadPacket(USB_TypeDef *USBx, uint8_t *dest, uint16_t len)
 522 {
 523   /* Prevent unused argument(s) compilation warning */
 524   UNUSED(USBx);
 525   UNUSED(dest);
 526   UNUSED(len);
 527   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 528               only by USB OTG FS peripheral.
 529             - This function is added to ensure compatibility across platforms.
 530    */
 531   return ((void *)NULL);
 532 }
 533
 534 /**
 535   * @brief  USB_EPSetStall : set a stall condition over an EP
 536   * @param  USBx : Selected device
 537   * @param  ep: pointer to endpoint structure
 538   * @retval HAL status
 539   */
 540 HAL_StatusTypeDef USB_EPSetStall(USB_TypeDef *USBx, USB_EPTypeDef *ep)
 541 {
 542   if (ep->is_in != 0U)
 543   {
 544     PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_STALL);
 545   }
 546   else
 547   {
 548     PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_STALL);
 549   }
 550
 551   return HAL_OK;
 552 }
 553
 554 /**
 555   * @brief  USB_EPClearStall : Clear a stall condition over an EP
 556   * @param  USBx : Selected device
 557   * @param  ep: pointer to endpoint structure
 558   * @retval HAL status
 559   */
 560 HAL_StatusTypeDef USB_EPClearStall(USB_TypeDef *USBx, USB_EPTypeDef *ep)
 561 {
 562   if (ep->doublebuffer == 0U)
 563   {
 564     if (ep->is_in != 0U)
 565     {
 566       PCD_CLEAR_TX_DTOG(USBx, ep->num);
 567
 568       if (ep->type != EP_TYPE_ISOC)
 569       {
 570         /* Configure NAK status for the Endpoint */
 571         PCD_SET_EP_TX_STATUS(USBx, ep->num, USB_EP_TX_NAK);
 572       }
 573     }
 574     else
 575     {
 576       PCD_CLEAR_RX_DTOG(USBx, ep->num);
 577
 578       /* Configure VALID status for the Endpoint*/
 579       PCD_SET_EP_RX_STATUS(USBx, ep->num, USB_EP_RX_VALID);
 580     }
 581   }
 582
 583   return HAL_OK;
 584 }
 585
 586 /**
 587   * @brief  USB_StopDevice : Stop the usb device mode
 588   * @param  USBx : Selected device
 589   * @retval HAL status
 590   */
 591 HAL_StatusTypeDef USB_StopDevice(USB_TypeDef *USBx)
 592 {
 593   /* disable all interrupts and force USB reset */
 594   USBx->CNTR = USB_CNTR_FRES;
 595
 596   /* clear interrupt status register */
 597   USBx->ISTR = 0;
 598
 599   /* switch-off device */
 600   USBx->CNTR = (USB_CNTR_FRES | USB_CNTR_PDWN);
 601
 602   return HAL_OK;
 603 }
 604
 605 /**
 606   * @brief  USB_SetDevAddress : Stop the usb device mode
 607   * @param  USBx : Selected device
 608   * @param  address : new device address to be assigned
 609   *          This parameter can be a value from 0 to 255
 610   * @retval HAL status
 611   */
 612 HAL_StatusTypeDef  USB_SetDevAddress(USB_TypeDef *USBx, uint8_t address)
 613 {
 614   if (address == 0U)
 615   {
 616     /* set device address and enable function */
 617     USBx->DADDR = USB_DADDR_EF;
 618   }
 619
 620   return HAL_OK;
 621 }
 622
 623 /**
 624   * @brief  USB_DevConnect : Connect the USB device by enabling the pull-up/pull-down
 625   * @param  USBx : Selected device
 626   * @retval HAL status
 627   */
 628 HAL_StatusTypeDef  USB_DevConnect(USB_TypeDef *USBx)
 629 {
 630   /* Enabling DP Pull-UP bit to Connect internal PU resistor on USB DP line */
 631   USBx->BCDR |= USB_BCDR_DPPU;
 632
 633   return HAL_OK;
 634 }
 635
 636 /**
 637   * @brief  USB_DevDisconnect : Disconnect the USB device by disabling the pull-up/pull-down
 638   * @param  USBx : Selected device
 639   * @retval HAL status
 640   */
 641 HAL_StatusTypeDef  USB_DevDisconnect(USB_TypeDef *USBx)
 642 {
 643   /* Disable DP Pull-Up bit to disconnect the Internal PU resistor on USB DP line */
 644   USBx->BCDR &= (uint16_t)(~(USB_BCDR_DPPU));
 645
 646   return HAL_OK;
 647 }
 648
 649 /**
 650   * @brief  USB_ReadInterrupts: return the global USB interrupt status
 651   * @param  USBx : Selected device
 652   * @retval HAL status
 653   */
 654 uint32_t  USB_ReadInterrupts(USB_TypeDef *USBx)
 655 {
 656   uint32_t tmpreg;
 657
 658   tmpreg = USBx->ISTR;
 659   return tmpreg;
 660 }
 661
 662 /**
 663   * @brief  USB_ReadDevAllOutEpInterrupt: return the USB device OUT endpoints interrupt status
 664   * @param  USBx : Selected device
 665   * @retval HAL status
 666   */
 667 uint32_t USB_ReadDevAllOutEpInterrupt(USB_TypeDef *USBx)
 668 {
 669   /* Prevent unused argument(s) compilation warning */
 670   UNUSED(USBx);
 671   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 672               only by USB OTG FS peripheral.
 673             - This function is added to ensure compatibility across platforms.
 674    */
 675   return (0);
 676 }
 677
 678 /**
 679   * @brief  USB_ReadDevAllInEpInterrupt: return the USB device IN endpoints interrupt status
 680   * @param  USBx : Selected device
 681   * @retval HAL status
 682   */
 683 uint32_t USB_ReadDevAllInEpInterrupt(USB_TypeDef *USBx)
 684 {
 685   /* Prevent unused argument(s) compilation warning */
 686   UNUSED(USBx);
 687   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 688               only by USB OTG FS peripheral.
 689             - This function is added to ensure compatibility across platforms.
 690    */
 691   return (0);
 692 }
 693
 694 /**
 695   * @brief  Returns Device OUT EP Interrupt register
 696   * @param  USBx : Selected device
 697   * @param  epnum : endpoint number
 698   *          This parameter can be a value from 0 to 15
 699   * @retval Device OUT EP Interrupt register
 700   */
 701 uint32_t USB_ReadDevOutEPInterrupt(USB_TypeDef *USBx, uint8_t epnum)
 702 {
 703   /* Prevent unused argument(s) compilation warning */
 704   UNUSED(USBx);
 705   UNUSED(epnum);
 706   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 707               only by USB OTG FS peripheral.
 708             - This function is added to ensure compatibility across platforms.
 709    */
 710   return (0);
 711 }
 712
 713 /**
 714   * @brief  Returns Device IN EP Interrupt register
 715   * @param  USBx : Selected device
 716   * @param  epnum : endpoint number
 717   *          This parameter can be a value from 0 to 15
 718   * @retval Device IN EP Interrupt register
 719   */
 720 uint32_t USB_ReadDevInEPInterrupt(USB_TypeDef *USBx, uint8_t epnum)
 721 {
 722   /* Prevent unused argument(s) compilation warning */
 723   UNUSED(USBx);
 724   UNUSED(epnum);
 725   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 726               only by USB OTG FS peripheral.
 727             - This function is added to ensure compatibility across platforms.
 728    */
 729   return (0);
 730 }
 731
 732 /**
 733   * @brief  USB_ClearInterrupts: clear a USB interrupt
 734   * @param  USBx  Selected device
 735   * @param  interrupt  interrupt flag
 736   * @retval None
 737   */
 738 void  USB_ClearInterrupts(USB_TypeDef *USBx, uint32_t interrupt)
 739 {
 740   /* Prevent unused argument(s) compilation warning */
 741   UNUSED(USBx);
 742   UNUSED(interrupt);
 743   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 744               only by USB OTG FS peripheral.
 745             - This function is added to ensure compatibility across platforms.
 746    */
 747 }
 748
 749 /**
 750   * @brief  Prepare the EP0 to start the first control setup
 751   * @param  USBx  Selected device
 752   * @param  psetup  pointer to setup packet
 753   * @retval HAL status
 754   */
 755 HAL_StatusTypeDef USB_EP0_OutStart(USB_TypeDef *USBx, uint8_t *psetup)
 756 {
 757   /* Prevent unused argument(s) compilation warning */
 758   UNUSED(USBx);
 759   UNUSED(psetup);
 760   /* NOTE : - This function is not required by USB Device FS peripheral, it is used
 761               only by USB OTG FS peripheral.
 762             - This function is added to ensure compatibility across platforms.
 763    */
 764   return HAL_OK;
 765 }
 766
 767 /**
 768   * @brief  USB_ActivateRemoteWakeup : active remote wakeup signalling
 769   * @param  USBx  Selected device
 770   * @retval HAL status
 771   */
 772 HAL_StatusTypeDef USB_ActivateRemoteWakeup(USB_TypeDef *USBx)
 773 {
 774   USBx->CNTR |= USB_CNTR_RESUME;
 775
 776   return HAL_OK;
 777 }
 778
 779 /**
 780   * @brief  USB_DeActivateRemoteWakeup : de-active remote wakeup signalling
 781   * @param  USBx  Selected device
 782   * @retval HAL status
 783   */
 784 HAL_StatusTypeDef USB_DeActivateRemoteWakeup(USB_TypeDef *USBx)
 785 {
 786   USBx->CNTR &= ~(USB_CNTR_RESUME);
 787   return HAL_OK;
 788 }
 789
 790 /**
 791   * @brief Copy a buffer from user memory area to packet memory area (PMA)
 792   * @param   USBx USB peripheral instance register address.
 793   * @param   pbUsrBuf pointer to user memory area.
 794   * @param   wPMABufAddr address into PMA.
 795   * @param   wNBytes: no. of bytes to be copied.
 796   * @retval None
 797   */
 798 void USB_WritePMA(USB_TypeDef *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
 799 {
 800   uint32_t n = ((uint32_t)wNBytes + 1U) >> 1;
 801   uint32_t BaseAddr = (uint32_t)USBx;
 802   uint32_t i, temp1, temp2;
 803   uint16_t *pdwVal;
 804   uint8_t *pBuf = pbUsrBuf;
 805
 806   pdwVal = (uint16_t *)(BaseAddr + 0x400U + ((uint32_t)wPMABufAddr * PMA_ACCESS));
 807
 808   for (i = n; i != 0U; i--)
 809   {
 810     temp1 = (uint16_t) * pBuf;
 811     pBuf++;
 812     temp2 = temp1 | ((uint16_t)((uint16_t) * pBuf << 8));
 813     *pdwVal = (uint16_t)temp2;
 814     pdwVal++;
 815
 816 #if PMA_ACCESS > 1U
 817     pdwVal++;
 818 #endif
 819
 820     pBuf++;
 821   }
 822 }
 823
 824 /**
 825   * @brief Copy a buffer from user memory area to packet memory area (PMA)
 826   * @param   USBx: USB peripheral instance register address.
 827   * @param   pbUsrBuf pointer to user memory area.
 828   * @param   wPMABufAddr address into PMA.
 829   * @param   wNBytes: no. of bytes to be copied.
 830   * @retval None
 831   */
 832 void USB_ReadPMA(USB_TypeDef *USBx, uint8_t *pbUsrBuf, uint16_t wPMABufAddr, uint16_t wNBytes)
 833 {
 834   uint32_t n = (uint32_t)wNBytes >> 1;
 835   uint32_t BaseAddr = (uint32_t)USBx;
 836   uint32_t i, temp;
 837   uint16_t *pdwVal;
 838   uint8_t *pBuf = pbUsrBuf;
 839
 840   pdwVal = (uint16_t *)(BaseAddr + 0x400U + ((uint32_t)wPMABufAddr * PMA_ACCESS));
 841
 842   for (i = n; i != 0U; i--)
 843   {
 844     temp = *pdwVal;
 845     pdwVal++;
 846     *pBuf = (uint8_t)((temp >> 0) & 0xFFU);
 847     pBuf++;
 848     *pBuf = (uint8_t)((temp >> 8) & 0xFFU);
 849     pBuf++;
 850
 851 #if PMA_ACCESS > 1U
 852     pdwVal++;
 853 #endif
 854   }
 855
 856   if ((wNBytes % 2U) != 0U)
 857   {
 858     temp = *pdwVal;
 859     *pBuf = (uint8_t)((temp >> 0) & 0xFFU);
 860   }
 861 }
 862
 863
 864 /**
 865   * @}
 866   */
 867
 868 /**
 869   * @}
 870   */
 871 #endif /* defined (USB) */
 872 #endif /* defined (HAL_PCD_MODULE_ENABLED) || defined (HAL_HCD_MODULE_ENABLED) */
 873
 874 /**
 875   * @}
 876   */
 877
 878 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/