git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_LPC1768_GCC_Rowley/LPCUSB/usbcontrol.c

   1 /*
   2         LPCUSB, an USB device driver for LPC microcontrollers
   3         Copyright (C) 2006 Bertrik Sikken (bertrik@sikken.nl)
   4
   5         Redistribution and use in source and binary forms, with or without
   6         modification, are permitted provided that the following conditions are met:
   7
   8         1. Redistributions of source code must retain the above copyright
   9            notice, this list of conditions and the following disclaimer.
  10         2. Redistributions in binary form must reproduce the above copyright
  11            notice, this list of conditions and the following disclaimer in the
  12            documentation and/or other materials provided with the distribution.
  13         3. The name of the author may not be used to endorse or promote products
  14            derived from this software without specific prior written permission.
  15
  16         THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17         IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18         OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19         IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20         INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21         NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22         DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23         THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24         (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25         THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28
  29 /** @file
  30         Control transfer handler.
  31
  32         This module handles control transfers and is normally installed on the
  33         endpoint 0 callback.
  34
  35         Control transfers can be of the following type:
  36         0 Standard;
  37         1 Class;
  38         2 Vendor;
  39         3 Reserved.
  40
  41         A callback can be installed for each of these control transfers using
  42         USBRegisterRequestHandler.
  43         When an OUT request arrives, data is collected in the data store provided
  44         with the USBRegisterRequestHandler call. When the transfer is done, the
  45         callback is called.
  46         When an IN request arrives, the callback is called immediately to either
  47         put the control transfer data in the data store, or to get a pointer to
  48         control transfer data. The data is then packetised and sent to the host.
  49 */
  50
  51 #include "usbdebug.h"
  52
  53 #include "usbstruct.h"
  54 #include "usbapi.h"
  55
  56
  57
  58 #define MAX_CONTROL_SIZE        128     /**< maximum total size of control transfer data */
  59 #define MAX_REQ_HANDLERS        4       /**< standard, class, vendor, reserved */
  60
  61 static TSetupPacket             Setup;  /**< setup packet */
  62
  63 static unsigned char                            *pbData;        /**< pointer to data buffer */
  64 static int                              iResidue;       /**< remaining bytes in buffer */
  65 static int                              iLen;           /**< total length of control transfer */
  66
  67 /** Array of installed request handler callbacks */
  68 static TFnHandleRequest *apfnReqHandlers[4] = {NULL, NULL, NULL, NULL};
  69 /** Array of installed request data pointers */
  70 static unsigned char                            *apbDataStore[4] = {NULL, NULL, NULL, NULL};
  71
  72 /**
  73         Local function to handle a request by calling one of the installed
  74         request handlers.
  75
  76         In case of data going from host to device, the data is at *ppbData.
  77         In case of data going from device to host, the handler can either
  78         choose to write its data at *ppbData or update the data pointer.
  79
  80         @param [in]             pSetup          The setup packet
  81         @param [in,out] *piLen          Pointer to data length
  82         @param [in,out] ppbData         Data buffer.
  83
  84         @return TRUE if the request was handles successfully
  85  */
  86 static BOOL _HandleRequest(TSetupPacket *pSetup, int *piLen, unsigned char **ppbData)
  87 {
  88         TFnHandleRequest *pfnHandler;
  89         int iType;
  90
  91         iType = REQTYPE_GET_TYPE(pSetup->bmRequestType);
  92         pfnHandler = apfnReqHandlers[iType];
  93         if (pfnHandler == NULL) {
  94                 DBG("No handler for reqtype %d\n", iType);
  95                 return FALSE;
  96         }
  97
  98         return pfnHandler(pSetup, piLen, ppbData);
  99 }
 100
 101
 102 /**
 103         Local function to stall the control endpoint
 104
 105         @param [in]     bEPStat Endpoint status
 106  */
 107 static void StallControlPipe(unsigned char bEPStat)
 108 {
 109         unsigned char   *pb;
 110         int     i;
 111
 112         ( void ) bEPStat;
 113         USBHwEPStall(0x80, TRUE);
 114
 115 // dump setup packet
 116         DBG("STALL on [");
 117         pb = (unsigned char *)&Setup;
 118         for (i = 0; i < 8; i++) {
 119                 DBG(" %02x", *pb++);
 120         }
 121         DBG("] stat=%x\n", bEPStat);
 122 }
 123
 124
 125 /**
 126         Sends next chunk of data (possibly 0 bytes) to host
 127  */
 128 static void DataIn(void)
 129 {
 130         int iChunk;
 131
 132         if( MAX_PACKET_SIZE0 < iResidue )
 133         {
 134                 iChunk = MAX_PACKET_SIZE0;
 135         }
 136         else
 137         {
 138                 iChunk = iResidue;
 139         }
 140
 141         USBHwEPWrite(0x80, pbData, iChunk);
 142         pbData += iChunk;
 143         iResidue -= iChunk;
 144 }
 145
 146
 147 /**
 148  *      Handles IN/OUT transfers on EP0
 149  *
 150  *      @param [in]     bEP             Endpoint address
 151  *      @param [in]     bEPStat Endpoint status
 152  */
 153 void USBHandleControlTransfer(unsigned char bEP, unsigned char bEPStat)
 154 {
 155         int iChunk, iType;
 156
 157         if (bEP == 0x00) {
 158                 // OUT transfer
 159                 if (bEPStat & EP_STATUS_SETUP) {
 160                         // setup packet, reset request message state machine
 161                         USBHwEPRead(0x00, (unsigned char *)&Setup, sizeof(Setup));
 162                         DBG("S%x", Setup.bRequest);
 163
 164                         // defaults for data pointer and residue
 165                         iType = REQTYPE_GET_TYPE(Setup.bmRequestType);
 166                         pbData = apbDataStore[iType];
 167                         iResidue = Setup.wLength;
 168                         iLen = Setup.wLength;
 169
 170                         if ((Setup.wLength == 0) ||
 171                                 (REQTYPE_GET_DIR(Setup.bmRequestType) == REQTYPE_DIR_TO_HOST)) {
 172                                 // ask installed handler to process request
 173                                 if (!_HandleRequest(&Setup, &iLen, &pbData)) {
 174                                         DBG("_HandleRequest1 failed\n");
 175                                         StallControlPipe(bEPStat);
 176                                         return;
 177                                 }
 178                                 // send smallest of requested and offered length
 179                                 if( iLen < Setup.wLength )
 180                                 {
 181                                         iResidue = iLen;
 182                                 }
 183                                 else
 184                                 {
 185                                         iResidue = Setup.wLength;
 186                                 }
 187
 188                                 // send first part (possibly a zero-length status message)
 189                                 DataIn();
 190                         }
 191                 }
 192                 else {
 193                         if (iResidue > 0) {
 194                                 // store data
 195                                 iChunk = USBHwEPRead(0x00, pbData, iResidue);
 196                                 if (iChunk < 0) {
 197                                         StallControlPipe(bEPStat);
 198                                         return;
 199                                 }
 200                                 pbData += iChunk;
 201                                 iResidue -= iChunk;
 202                                 if (iResidue == 0) {
 203                                         // received all, send data to handler
 204                                         iType = REQTYPE_GET_TYPE(Setup.bmRequestType);
 205                                         pbData = apbDataStore[iType];
 206                                         if (!_HandleRequest(&Setup, &iLen, &pbData)) {
 207                                                 DBG("_HandleRequest2 failed\n");
 208                                                 StallControlPipe(bEPStat);
 209                                                 return;
 210                                         }
 211                                         // send status to host
 212                                         DataIn();
 213                                 }
 214                         }
 215                         else {
 216                                 // absorb zero-length status message
 217                                 iChunk = USBHwEPRead(0x00, NULL, 0);
 218                                 DBG(iChunk > 0 ? "?" : "");
 219                         }
 220                 }
 221         }
 222         else if (bEP == 0x80) {
 223                 // IN transfer
 224                 // send more data if available (possibly a 0-length packet)
 225                 DataIn();
 226         }
 227         else {
 228                 ASSERT(FALSE);
 229         }
 230 }
 231
 232
 233 /**
 234         Registers a callback for handling requests
 235
 236         @param [in]     iType                   Type of request, e.g. REQTYPE_TYPE_STANDARD
 237         @param [in]     *pfnHandler             Callback function pointer
 238         @param [in]     *pbDataStore    Data storage area for this type of request
 239  */
 240 void USBRegisterRequestHandler(int iType, TFnHandleRequest *pfnHandler, unsigned char *pbDataStore)
 241 {
 242         ASSERT(iType >= 0);
 243         ASSERT(iType < 4);
 244         apfnReqHandlers[iType] = pfnHandler;
 245         apbDataStore[iType] = pbDataStore;
 246 }
 247