git.sur5r.net Git - armstart-ibdap/blob - inc/usbd/usbd_hw.h

   1 /***********************************************************************\r
   2 * $Id:: mw_usbd_hw.h 331 2012-08-09 18:54:34Z usb10131                        $\r
   3 *\r
   4 * Project: USB device ROM Stack\r
   5 *\r
   6 * Description:\r
   7 *     USB Hardware Function prototypes.\r
   8 *\r
   9 ***********************************************************************\r
  10 *   Copyright(C) 2011, NXP Semiconductor\r
  11 *   All rights reserved.\r
  12 *\r
  13 * Software that is described herein is for illustrative purposes only\r
  14 * which provides customers with programming information regarding the\r
  15 * products. This software is supplied "AS IS" without any warranties.\r
  16 * NXP Semiconductors assumes no responsibility or liability for the\r
  17 * use of the software, conveys no license or title under any patent,\r
  18 * copyright, or mask work right to the product. NXP Semiconductors\r
  19 * reserves the right to make changes in the software without\r
  20 * notification. NXP Semiconductors also make no representation or\r
  21 * warranty that such application will be suitable for the specified\r
  22 * use without further testing or modification.\r
  23 **********************************************************************/\r
  24 #ifndef __USBHW_H__\r
  25 #define __USBHW_H__\r
  26 \r
  27 #include "error.h"\r
  28 #include "usbd.h"\r
  29 #include "usbd_core.h"\r
  30 \r
  31 /** \file\r
  32  *  \brief USB Hardware Function prototypes.\r
  33  *\r
  34  *  Definition of functions exported by ROM based Device Controller Driver (DCD).\r
  35  *\r
  36  */\r
  37 \r
  38 /** \ingroup Group_USBD\r
  39  *  @defgroup USBD_HW USB Device Controller Driver \r
  40  *  \section Sec_HWModDescription Module Description\r
  41  *  The Device Controller Driver Layer implements the routines to deal directly with the hardware. \r
  42  */\r
  43 \r
  44 /** \ingroup USBD_HW\r
  45 *  USB Endpoint/class handler Callback Events. \r
  46 * \r
  47 */\r
  48 enum USBD_EVENT_T {\r
  49   USB_EVT_SETUP =1,    /**< 1   Setup Packet received */\r
  50   USB_EVT_OUT,         /**< 2   OUT Packet received */\r
  51   USB_EVT_IN,          /**< 3    IN Packet sent */\r
  52   USB_EVT_OUT_NAK,     /**< 4   OUT Packet - Not Acknowledged */\r
  53   USB_EVT_IN_NAK,      /**< 5    IN Packet - Not Acknowledged */\r
  54   USB_EVT_OUT_STALL,   /**< 6   OUT Packet - Stalled */\r
  55   USB_EVT_IN_STALL,    /**< 7    IN Packet - Stalled */\r
  56   USB_EVT_OUT_DMA_EOT, /**< 8   DMA OUT EP - End of Transfer */\r
  57   USB_EVT_IN_DMA_EOT,  /**< 9   DMA  IN EP - End of Transfer */\r
  58   USB_EVT_OUT_DMA_NDR, /**< 10  DMA OUT EP - New Descriptor Request */\r
  59   USB_EVT_IN_DMA_NDR,  /**< 11  DMA  IN EP - New Descriptor Request */\r
  60   USB_EVT_OUT_DMA_ERR, /**< 12  DMA OUT EP - Error */\r
  61   USB_EVT_IN_DMA_ERR,  /**< 13  DMA  IN EP - Error */\r
  62   USB_EVT_RESET,       /**< 14  Reset event recieved */\r
  63   USB_EVT_SOF,         /**< 15  Start of Frame event */\r
  64   USB_EVT_DEV_STATE,   /**< 16  Device status events */\r
  65   USB_EVT_DEV_ERROR   /**< 17  Device error events */\r
  66 };\r
  67 \r
  68 /** \r
  69  *  \brief Hardware API functions structure.\r
  70  *  \ingroup USBD_HW\r
  71  *\r
  72  *  This module exposes functions which interact directly with USB device controller hardware.\r
  73  *\r
  74  */\r
  75 typedef struct USBD_HW_API\r
  76 {\r
  77   /** \fn uint32_t GetMemSize(USBD_API_INIT_PARAM_T* param)\r
  78    *  Function to determine the memory required by the USB device stack's DCD and core layers.\r
  79    * \r
  80    *  This function is called by application layer before calling pUsbApi->hw->Init(), to allocate memory used\r
  81    *  by DCD and core layers. The application should allocate the memory which is accessible by USB\r
  82    *  controller/DMA controller. \r
  83    *  \note Some memory areas are not accessible by all bus masters.\r
  84    *\r
  85    *  \param[in] param Structure containing USB device stack initialization parameters.\r
  86    *  \return Returns the required memory size in bytes.\r
  87    */\r
  88   uint32_t (*GetMemSize)(USBD_API_INIT_PARAM_T* param);\r
  89   \r
  90   /** \fn ErrorCode_t Init(USBD_HANDLE_T* phUsb, USB_CORE_DESCS_T* pDesc, USBD_API_INIT_PARAM_T* param)\r
  91    *  Function to initialize USB device stack's DCD and core layers.\r
  92    * \r
  93    *  This function is called by application layer to initialize USB hardware and core layers. \r
  94    *  On successful initialization the function returns a handle to USB device stack which should\r
  95    *  be passed to the rest of the functions.  \r
  96    *\r
  97    *  \param[in,out] phUsb Pointer to the USB device stack handle of type USBD_HANDLE_T. \r
  98    *  \param[in]  pDesc Structure containing pointers to various descriptor arrays needed by the stack.\r
  99    *                    These descriptors are reported to USB host as part of enumerations process.\r
 100    *  \param[in]  param Structure containing USB device stack initialization parameters.\r
 101    *  \return Returns \ref ErrorCode_t type to indicate success or error condition.\r
 102    *          \retval LPC_OK(0) On success\r
 103    *          \retval ERR_USBD_BAD_MEM_BUF(0x0004000b) When insufficient memory buffer is passed or memory\r
 104    *                                             is not aligned on 2048 boundary.\r
 105    */\r
 106   ErrorCode_t (*Init)(USBD_HANDLE_T* phUsb, USB_CORE_DESCS_T* pDesc, USBD_API_INIT_PARAM_T* param);\r
 107   \r
 108   /** \fn void Connect(USBD_HANDLE_T hUsb, uint32_t con)\r
 109    *  Function to make USB device visible/invisible on the USB bus.\r
 110    *\r
 111    *  This function is called after the USB initialization. This function uses the soft connect\r
 112    *  feature to make the device visible on the USB bus. This function is called only after the\r
 113    *  application is ready to handle the USB data. The enumeration process is started by the\r
 114    *  host after the device detection. The driver handles the enumeration process according to\r
 115    *  the USB descriptors passed in the USB initialization function.\r
 116    *  \r
 117    *  \param[in] hUsb Handle to the USB device stack. \r
 118    *  \param[in] con  States whether to connect (1) or to disconnect (0).\r
 119    *  \return Nothing.\r
 120    */\r
 121   void (*Connect)(USBD_HANDLE_T hUsb, uint32_t con);\r
 122   \r
 123   /** \fn void ISR(USBD_HANDLE_T hUsb)\r
 124    *  Function to USB device controller interrupt events.\r
 125    *  \r
 126    *  When the user application is active the interrupt handlers are mapped in the user flash\r
 127    *  space. The user application must provide an interrupt handler for the USB interrupt and\r
 128    *  call this function in the interrupt handler routine. The driver interrupt handler takes\r
 129    *  appropriate action according to the data received on the USB bus. \r
 130    *  \r
 131    *  \param[in]  hUsb Handle to the USB device stack. \r
 132    *  \return Nothing.\r
 133    */\r
 134   void (*ISR)(USBD_HANDLE_T hUsb);\r
 135 \r
 136   /** \fn void Reset(USBD_HANDLE_T hUsb)\r
 137    *  Function to Reset USB device stack and hardware controller.\r
 138    *  \r
 139    *  Reset USB device stack and hardware controller. Disables all endpoints except EP0.\r
 140    *  Clears all pending interrupts and resets endpoint transfer queues.\r
 141    *  This function is called internally by pUsbApi->hw->init() and from reset event.\r
 142    *  \r
 143    *  \param[in]  hUsb Handle to the USB device stack. \r
 144    *  \return Nothing.\r
 145    */\r
 146   void  (*Reset)(USBD_HANDLE_T hUsb);\r
 147   \r
 148   /** \fn void ForceFullSpeed(USBD_HANDLE_T hUsb, uint32_t cfg)\r
 149    *  Function to force high speed USB device to operate in full speed mode.\r
 150    *\r
 151    *  This function is useful for testing the behavior of current device when connected\r
 152    *  to a full speed only hosts.\r
 153    *  \r
 154    *  \param[in] hUsb Handle to the USB device stack. \r
 155    *  \param[in] cfg  When 1 - set force full-speed or \r
 156    *                       0 - clear force full-speed.\r
 157    *  \return Nothing.\r
 158    */\r
 159   void  (*ForceFullSpeed )(USBD_HANDLE_T hUsb, uint32_t cfg);\r
 160   \r
 161   /** \fn void WakeUpCfg(USBD_HANDLE_T hUsb, uint32_t cfg)\r
 162    *  Function to configure USB device controller to wake-up host on remote events.\r
 163    *\r
 164    *  This function is called by application layer to configure the USB device controller \r
 165    *  to wakeup on remote events. It is recommended to call this function from users's \r
 166    *  USB_WakeUpCfg() callback routine registered with stack. \r
 167    *  \note User's USB_WakeUpCfg() is registered with stack by setting the USB_WakeUpCfg member \r
 168    *  of USBD_API_INIT_PARAM_T structure before calling pUsbApi->hw->Init() routine.\r
 169    *  Certain USB device controllers needed to keep some clocks always on to generate \r
 170    *  resume signaling through pUsbApi->hw->WakeUp(). This hook is provided to support \r
 171    *  such controllers. In most controllers cases this is an empty routine.\r
 172    *  \r
 173    *  \param[in] hUsb Handle to the USB device stack. \r
 174    *  \param[in] cfg  When 1 - Configure controller to wake on remote events or \r
 175    *                       0 - Configure controller not to wake on remote events.\r
 176    *  \return Nothing.\r
 177    */\r
 178   void  (*WakeUpCfg)(USBD_HANDLE_T hUsb, uint32_t  cfg);\r
 179   \r
 180   /** \fn void SetAddress(USBD_HANDLE_T hUsb, uint32_t adr)\r
 181    *  Function to set USB address assigned by host in device controller hardware.\r
 182    *\r
 183    *  This function is called automatically when USB_REQUEST_SET_ADDRESS request is received  \r
 184    *  by the stack from USB host.\r
 185    *  This interface is provided to users to invoke this function in other scenarios which are not \r
 186    *  handle by current stack. In most user applications this function is not called directly.\r
 187    *  Also this function can be used by users who are selectively modifying the USB device stack's \r
 188    *  standard handlers through callback interface exposed by the stack. \r
 189    *  \r
 190    *  \param[in] hUsb Handle to the USB device stack. \r
 191    *  \param[in] adr  USB bus Address to which the device controller should respond. Usually \r
 192    *                  assigned by the USB host.\r
 193    *  \return Nothing.\r
 194    */\r
 195   void  (*SetAddress)(USBD_HANDLE_T hUsb, uint32_t adr);\r
 196 \r
 197   /** \fn void Configure(USBD_HANDLE_T hUsb, uint32_t cfg)\r
 198    *  Function to configure device controller hardware with selected configuration.\r
 199    *\r
 200    *  This function is called automatically when USB_REQUEST_SET_CONFIGURATION request is received  \r
 201    *  by the stack from USB host.\r
 202    *  This interface is provided to users to invoke this function in other scenarios which are not \r
 203    *  handle by current stack. In most user applications this function is not called directly.\r
 204    *  Also this function can be used by users who are selectively modifying the USB device stack's \r
 205    *  standard handlers through callback interface exposed by the stack. \r
 206    *  \r
 207    *  \param[in] hUsb Handle to the USB device stack. \r
 208    *  \param[in] cfg  Configuration index. \r
 209    *  \return Nothing.\r
 210    */\r
 211   void  (*Configure)(USBD_HANDLE_T hUsb, uint32_t  cfg);\r
 212 \r
 213   /** \fn void ConfigEP(USBD_HANDLE_T hUsb, USB_ENDPOINT_DESCRIPTOR *pEPD)\r
 214    *  Function to configure USB Endpoint according to descriptor.\r
 215    *\r
 216    *  This function is called automatically when USB_REQUEST_SET_CONFIGURATION request is received  \r
 217    *  by the stack from USB host. All the endpoints associated with the selected configuration\r
 218    *  are configured.\r
 219    *  This interface is provided to users to invoke this function in other scenarios which are not \r
 220    *  handle by current stack. In most user applications this function is not called directly.\r
 221    *  Also this function can be used by users who are selectively modifying the USB device stack's \r
 222    *  standard handlers through callback interface exposed by the stack. \r
 223    *  \r
 224    *  \param[in] hUsb Handle to the USB device stack. \r
 225    *  \param[in] pEPD Endpoint descriptor structure defined in USB 2.0 specification.\r
 226    *  \return Nothing.\r
 227    */\r
 228   void  (*ConfigEP)(USBD_HANDLE_T hUsb, USB_ENDPOINT_DESCRIPTOR *pEPD);\r
 229 \r
 230   /** \fn void DirCtrlEP(USBD_HANDLE_T hUsb, uint32_t dir)\r
 231    *  Function to set direction for USB control endpoint EP0.\r
 232    *\r
 233    *  This function is called automatically by the stack on need basis.\r
 234    *  This interface is provided to users to invoke this function in other scenarios which are not \r
 235    *  handle by current stack. In most user applications this function is not called directly.\r
 236    *  Also this function can be used by users who are selectively modifying the USB device stack's \r
 237    *  standard handlers through callback interface exposed by the stack. \r
 238    *  \r
 239    *  \param[in] hUsb Handle to the USB device stack. \r
 240    *  \param[in] cfg  When 1 - Set EP0 in IN transfer mode \r
 241    *                       0 - Set EP0 in OUT transfer mode\r
 242    *  \return Nothing.\r
 243    */\r
 244   void  (*DirCtrlEP)(USBD_HANDLE_T hUsb, uint32_t dir);\r
 245 \r
 246   /** \fn void EnableEP(USBD_HANDLE_T hUsb, uint32_t EPNum)\r
 247    *  Function to enable selected USB endpoint.\r
 248    *\r
 249    *  This function enables interrupts on selected endpoint.\r
 250    *  \r
 251    *  \param[in] hUsb Handle to the USB device stack. \r
 252    *  \param[in] EPNum  Endpoint number as per USB specification. \r
 253    *                    ie. An EP1_IN is represented by 0x81 number.\r
 254    *  \return Nothing.\r
 255    */\r
 256   void  (*EnableEP)(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 257 \r
 258   /** \fn void DisableEP(USBD_HANDLE_T hUsb, uint32_t EPNum)\r
 259    *  Function to disable selected USB endpoint.\r
 260    *\r
 261    *  This function disables interrupts on selected endpoint.\r
 262    *  \r
 263    *  \param[in] hUsb Handle to the USB device stack. \r
 264    *  \param[in] EPNum  Endpoint number as per USB specification. \r
 265    *                    ie. An EP1_IN is represented by 0x81 number.\r
 266    *  \return Nothing.\r
 267    */\r
 268   void  (*DisableEP)(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 269 \r
 270   /** \fn void ResetEP(USBD_HANDLE_T hUsb, uint32_t EPNum)\r
 271    *  Function to reset selected USB endpoint.\r
 272    *\r
 273    *  This function flushes the endpoint buffers and resets data toggle logic.\r
 274    *  \r
 275    *  \param[in] hUsb Handle to the USB device stack. \r
 276    *  \param[in] EPNum  Endpoint number as per USB specification. \r
 277    *                    ie. An EP1_IN is represented by 0x81 number.\r
 278    *  \return Nothing.\r
 279   */\r
 280   void  (*ResetEP)(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 281 \r
 282   /** \fn void SetStallEP(USBD_HANDLE_T hUsb, uint32_t EPNum)\r
 283    *  Function to STALL selected USB endpoint.\r
 284    *\r
 285    *  Generates STALL signaling for requested endpoint.\r
 286    *  \r
 287    *  \param[in] hUsb Handle to the USB device stack. \r
 288    *  \param[in] EPNum  Endpoint number as per USB specification. \r
 289    *                    ie. An EP1_IN is represented by 0x81 number.\r
 290    *  \return Nothing.\r
 291    */\r
 292   void  (*SetStallEP)(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 293 \r
 294   /** \fn void ClrStallEP(USBD_HANDLE_T hUsb, uint32_t EPNum)\r
 295    *  Function to clear STALL state for the requested endpoint.\r
 296    *\r
 297    *  This function clears STALL state for the requested endpoint.\r
 298    *  \r
 299    *  \param[in] hUsb Handle to the USB device stack. \r
 300    *  \param[in] EPNum  Endpoint number as per USB specification. \r
 301    *                    ie. An EP1_IN is represented by 0x81 number.\r
 302    *  \return Nothing.\r
 303    */\r
 304   void  (*ClrStallEP)(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 305 \r
 306   /** \fn ErrorCode_t SetTestMode(USBD_HANDLE_T hUsb, uint8_t mode)\r
 307    *  Function to set high speed USB device controller in requested test mode.\r
 308    *\r
 309    *  USB-IF requires the high speed device to be put in various test modes\r
 310    *  for electrical testing. This USB device stack calls this function whenever\r
 311    *  it receives USB_REQUEST_CLEAR_FEATURE request for USB_FEATURE_TEST_MODE. \r
 312    *  Users can put the device in test mode by directly calling this function.\r
 313    *  Returns ERR_USBD_INVALID_REQ when device controller is full-speed only.\r
 314    *  \r
 315    *  \param[in] hUsb Handle to the USB device stack. \r
 316    *  \param[in] mode  Test mode defined in USB 2.0 electrical testing specification.\r
 317    *  \return Returns \ref ErrorCode_t type to indicate success or error condition.\r
 318    *          \retval LPC_OK(0) - On success\r
 319    *          \retval ERR_USBD_INVALID_REQ(0x00040001) - Invalid test mode or \r
 320    *                                             Device controller is full-speed only.\r
 321    */\r
 322   ErrorCode_t (*SetTestMode)(USBD_HANDLE_T hUsb, uint8_t mode); \r
 323 \r
 324   /** \fn uint32_t ReadEP(USBD_HANDLE_T hUsb, uint32_t EPNum, uint8_t *pData)\r
 325    *  Function to read data received on the requested endpoint.\r
 326    *\r
 327    *  This function is called by USB stack and the application layer to read the data\r
 328    *  received on the requested endpoint.\r
 329    *  \r
 330    *  \param[in] hUsb Handle to the USB device stack. \r
 331    *  \param[in] EPNum  Endpoint number as per USB specification. \r
 332    *                    ie. An EP1_IN is represented by 0x81 number.\r
 333    *  \param[in,out] pData Pointer to the data buffer where data is to be copied. \r
 334    *  \return Returns the number of bytes copied to the buffer.\r
 335    */\r
 336   uint32_t (*ReadEP)(USBD_HANDLE_T hUsb, uint32_t EPNum, uint8_t *pData);\r
 337 \r
 338   /** \fn uint32_t ReadReqEP(USBD_HANDLE_T hUsb, uint32_t EPNum, uint8_t *pData, uint32_t len)\r
 339    *  Function to queue read request on the specified endpoint.\r
 340    *\r
 341    *  This function is called by USB stack and the application layer to queue a read request\r
 342    *  on the specified endpoint.\r
 343    *  \r
 344    *  \param[in] hUsb Handle to the USB device stack. \r
 345    *  \param[in] EPNum  Endpoint number as per USB specification. \r
 346    *                    ie. An EP1_IN is represented by 0x81 number.\r
 347    *  \param[in,out] pData Pointer to the data buffer where data is to be copied. This buffer\r
 348    *                       address should be accessible by USB DMA master.\r
 349    *  \param[in] len  Length of the buffer passed. \r
 350    *  \return Returns the length of the requested buffer.\r
 351    */\r
 352   uint32_t (*ReadReqEP)(USBD_HANDLE_T hUsb, uint32_t EPNum, uint8_t *pData, uint32_t len);\r
 353 \r
 354   /** \fn uint32_t ReadSetupPkt(USBD_HANDLE_T hUsb, uint32_t EPNum, uint32_t *pData)\r
 355    *  Function to read setup packet data received on the requested endpoint.\r
 356    *\r
 357    *  This function is called by USB stack and the application layer to read setup packet data\r
 358    *  received on the requested endpoint.\r
 359    *  \r
 360    *  \param[in] hUsb Handle to the USB device stack. \r
 361    *  \param[in] EPNum  Endpoint number as per USB specification. \r
 362    *                    ie. An EP0_IN is represented by 0x80 number.\r
 363    *  \param[in,out] pData Pointer to the data buffer where data is to be copied. \r
 364    *  \return Returns the number of bytes copied to the buffer.\r
 365    */\r
 366   uint32_t (*ReadSetupPkt)(USBD_HANDLE_T hUsb, uint32_t EPNum, uint32_t *pData);\r
 367 \r
 368   /** \fn uint32_t WriteEP(USBD_HANDLE_T hUsb, uint32_t EPNum, uint8_t *pData, uint32_t cnt)\r
 369    *  Function to write data to be sent on the requested endpoint.\r
 370    *\r
 371    *  This function is called by USB stack and the application layer to send data\r
 372    *  on the requested endpoint.\r
 373    *  \r
 374    *  \param[in] hUsb Handle to the USB device stack. \r
 375    *  \param[in] EPNum  Endpoint number as per USB specification. \r
 376    *                    ie. An EP1_IN is represented by 0x81 number.\r
 377    *  \param[in] pData Pointer to the data buffer from where data is to be copied. \r
 378    *  \param[in] cnt  Number of bytes to write. \r
 379    *  \return Returns the number of bytes written.\r
 380    */\r
 381   uint32_t (*WriteEP)(USBD_HANDLE_T hUsb, uint32_t EPNum, uint8_t *pData, uint32_t cnt);\r
 382 \r
 383   /** \fn void WakeUp(USBD_HANDLE_T hUsb)\r
 384    *  Function to generate resume signaling on bus for remote host wakeup.\r
 385    *\r
 386    *  This function is called by application layer to remotely wakeup host controller \r
 387    *  when system is in suspend state. Application should indicate this remote wakeup\r
 388    *  capability by setting USB_CONFIG_REMOTE_WAKEUP in bmAttributes of Configuration \r
 389    *  Descriptor. Also this routine will generate resume signalling only if host\r
 390    *  enables USB_FEATURE_REMOTE_WAKEUP by sending SET_FEATURE request before suspending\r
 391    *  the bus.\r
 392    *  \r
 393    *  \param[in] hUsb Handle to the USB device stack. \r
 394    *  \return Nothing.\r
 395    */\r
 396   void  (*WakeUp)(USBD_HANDLE_T hUsb);\r
 397 \r
 398   /** \fn void EnableEvent(USBD_HANDLE_T hUsb, uint32_t EPNum, uint32_t event_type, uint32_t enable)\r
 399    *  Function to enable/disable selected USB event.\r
 400    *\r
 401    *  This function enables interrupts on selected endpoint.\r
 402    *  \r
 403    *  \param[in] hUsb Handle to the USB device stack. \r
 404    *  \param[in] EPNum  Endpoint number corresponding to the event.\r
 405    *                    ie. An EP1_IN is represented by 0x81 number. For device events \r
 406    *                    set this param to 0x0. \r
 407    *  \param[in] event_type  Type of endpoint event. See \ref USBD_EVENT_T for more details.\r
 408    *  \param[in] enable  1 - enable event, 0 - disable event.\r
 409    *  \return Returns \ref ErrorCode_t type to indicate success or error condition.\r
 410    *          \retval LPC_OK(0) - On success\r
 411    *          \retval ERR_USBD_INVALID_REQ(0x00040001) - Invalid event type.\r
 412    */\r
 413   ErrorCode_t  (*EnableEvent)(USBD_HANDLE_T hUsb, uint32_t EPNum, uint32_t event_type, uint32_t enable);\r
 414 \r
 415 } USBD_HW_API_T;\r
 416 \r
 417 /*-----------------------------------------------------------------------------\r
 418  *  Private functions & structures prototypes used by stack internally\r
 419  *-----------------------------------------------------------------------------*/\r
 420 /** @cond  DIRECT_API */\r
 421 \r
 422 /* Driver functions */\r
 423 uint32_t hwUSB_GetMemSize(USBD_API_INIT_PARAM_T* param);\r
 424 ErrorCode_t hwUSB_Init(USBD_HANDLE_T* phUsb, USB_CORE_DESCS_T* pDesc, USBD_API_INIT_PARAM_T* param);\r
 425 void hwUSB_Connect(USBD_HANDLE_T hUsb, uint32_t con);\r
 426 void hwUSB_ISR(USBD_HANDLE_T hUsb);\r
 427 \r
 428 /* USB Hardware Functions */\r
 429 extern void  hwUSB_Reset(USBD_HANDLE_T hUsb);\r
 430 extern void  hwUSB_ForceFullSpeed (USBD_HANDLE_T hUsb, uint32_t con);\r
 431 extern void  hwUSB_WakeUpCfg(USBD_HANDLE_T hUsb, uint32_t  cfg);\r
 432 extern void  hwUSB_SetAddress(USBD_HANDLE_T hUsb, uint32_t adr);\r
 433 extern void  hwUSB_Configure(USBD_HANDLE_T hUsb, uint32_t  cfg);\r
 434 extern void  hwUSB_ConfigEP(USBD_HANDLE_T hUsb, USB_ENDPOINT_DESCRIPTOR *pEPD);\r
 435 extern void  hwUSB_DirCtrlEP(USBD_HANDLE_T hUsb, uint32_t dir);\r
 436 extern void  hwUSB_EnableEP(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 437 extern void  hwUSB_DisableEP(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 438 extern void  hwUSB_ResetEP(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 439 extern void  hwUSB_SetStallEP(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 440 extern void  hwUSB_ClrStallEP(USBD_HANDLE_T hUsb, uint32_t EPNum);\r
 441 extern ErrorCode_t hwUSB_SetTestMode(USBD_HANDLE_T hUsb, uint8_t mode); /* for FS only devices return ERR_USBD_INVALID_REQ */\r
 442 extern uint32_t hwUSB_ReadEP(USBD_HANDLE_T hUsb, uint32_t EPNum, uint8_t *pData);\r
 443 extern uint32_t hwUSB_ReadReqEP(USBD_HANDLE_T hUsb, uint32_t EPNum, uint8_t *pData, uint32_t len);\r
 444 extern uint32_t hwUSB_ReadSetupPkt(USBD_HANDLE_T hUsb, uint32_t, uint32_t *);\r
 445 extern uint32_t hwUSB_WriteEP(USBD_HANDLE_T hUsb, uint32_t EPNum, uint8_t *pData, uint32_t cnt);\r
 446 \r
 447 /* generate resume signaling on the bus */\r
 448 extern void  hwUSB_WakeUp(USBD_HANDLE_T hUsb);\r
 449 extern ErrorCode_t  hwUSB_EnableEvent(USBD_HANDLE_T hUsb, uint32_t EPNum, uint32_t event_type, uint32_t enable);\r
 450 /* TODO implement following routines\r
 451 - function to program TD and queue them to ep Qh\r
 452 */\r
 453 \r
 454 /** @endcond */\r
 455 \r
 456 \r
 457 #endif  /* __USBHW_H__ */\r