payloads/libpayload/drivers/udc/udc.c

   1 /*
   2  *
   3  * Copyright (C) 2015 Google Inc.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   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 AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <libpayload.h>
  30 #include <arch/cache.h>
  31 #include <assert.h>
  32 #include <endian.h>
  33 #include <queue.h>
  34 #include <stdio.h>
  35 #include <stdint.h>
  36 #include <stdlib.h>
  37 #include <usb/usb.h>
  38
  39 #include <udc/udc.h>
  40
  41 #ifdef DEBUG
  42 #define debug(x...) printf(x)
  43 #else
  44 #define debug(x...) do {} while (0)
  45 #endif
  46
  47 #define min(a, b) (((a) < (b)) ? (a) : (b))
  48
  49 static unsigned short strings_lang_id = 0;
  50 static unsigned char strings_count = 0;
  51 static const char **strings;
  52
  53 void udc_add_strings(unsigned short lang_id, unsigned char count,
  54         const char **str)
  55 {
  56         strings_lang_id = lang_id;
  57         strings_count = count;
  58         strings = str;
  59 }
  60
  61 /* determine if an additional zero length packet is necessary for
  62  * a transfer */
  63 static unsigned int zlp(struct usbdev_ctrl *this, const int epnum,
  64         const int len, const int explen)
  65 {
  66         const unsigned int mps = this->ep_mps[epnum][1];
  67
  68         /* zero length transfers are handled explicitly */
  69         if (len == 0)
  70                 return 0;
  71         /* host expects exactly the right amount, so no zlp necessary */
  72         if (len == explen)
  73                 return 0;
  74         /* last packet will be short -> host knows that transfer is over */
  75         if ((len % mps) != 0)
  76                 return 0;
  77
  78         /* otherwise we need an extra zero length packet */
  79         return 1;
  80 }
  81
  82 static struct usbdev_configuration *fetch_config(struct usbdev_ctrl *this,
  83         int id)
  84 {
  85         struct usbdev_configuration *config;
  86         SLIST_FOREACH(config, &this->configs, list) {
  87                 debug("checking descriptor %d\n",
  88                         config->descriptor.bConfigurationValue);
  89                 if (config->descriptor.bConfigurationValue == id)
  90                         return config;
  91         }
  92         return NULL;
  93 }
  94
  95 static void cease_operation(struct usbdev_ctrl *this)
  96 {
  97         int i;
  98         for (i = 1; i < 16; i++) {
  99                 /* disable endpoints */
 100                 this->halt_ep(this, i, 0);
 101                 this->halt_ep(this, i, 1);
 102         }
 103
 104 }
 105
 106 static void enable_interface(struct usbdev_ctrl *this, int iface_num)
 107 {
 108         struct usbdev_configuration *config = this->current_config;
 109         struct usbdev_interface *iface = &config->interfaces[iface_num];
 110
 111         /* first: shut down all endpoints except EP0 */
 112         cease_operation(this);
 113
 114         /* now enable all configured endpoints */
 115         int epcount = iface->descriptor.bNumEndpoints;
 116         int i;
 117         for (i = 0; i < epcount; i++) {
 118                 int ep = iface->eps[i].bEndpointAddress;
 119                 int mps = iface->eps[i].wMaxPacketSize;
 120                 int in_dir = 0;
 121                 if (ep & 0x80) {
 122                         in_dir = 1;
 123                         ep &= 0x7f;
 124                 }
 125                 int ep_type = iface->eps[i].bmAttributes & 0x3;
 126                 this->start_ep(this, ep, in_dir, ep_type, mps);
 127         }
 128
 129         this->current_iface = iface;
 130
 131         // gadget specific configuration
 132         if (iface->init)
 133                 iface->init(this);
 134 }
 135
 136 /**
 137  * handle default control transfers on EP 0
 138  *
 139  * returns 1 if transfer was handled
 140  */
 141 static int setup_ep0(struct usbdev_ctrl *this, dev_req_t *dr)
 142 {
 143         if ((dr->bmRequestType == 0x00) &&
 144             (dr->bRequest == SET_ADDRESS)) {
 145                 this->set_address(this, dr->wValue & 0x7f);
 146
 147                 /* status phase IN */
 148                 this->enqueue_packet(this, 0, 1, NULL, 0, 0, 0);
 149                 return 1;
 150         } else
 151         if ((dr->bmRequestType == 0x00) &&
 152             (dr->bRequest == SET_CONFIGURATION)) {
 153                 struct usbdev_configuration *config =
 154                         fetch_config(this, dr->wValue);
 155
 156                 if (dr->wValue == 0)
 157                         cease_operation(this);
 158
 159                 if (config == NULL) {
 160                         this->stall(this, 0, 0, 1);
 161                         this->stall(this, 0, 1, 1);
 162                         return 1;
 163                 }
 164
 165                 /* status phase IN */
 166                 this->enqueue_packet(this, 0, 1, NULL, 0, 0, 0);
 167
 168                 this->current_config = config;
 169                 this->current_config_id = dr->wValue;
 170
 171                 /* activate first interface */
 172                 enable_interface(this, 0);
 173                 this->initialized = 1;
 174                 return 1;
 175         } else
 176         if ((dr->bmRequestType == 0x80) &&
 177             (dr->bRequest == GET_CONFIGURATION)) {
 178                 unsigned char *res = dma_malloc(1);
 179                 res[0] = this->current_config_id;
 180
 181                 /* data phase IN */
 182                 this->enqueue_packet(this, 0, 1, res, min(1, dr->wLength),
 183                         0, 1);
 184
 185                 /* status phase OUT */
 186                 this->enqueue_packet(this, 0, 0, NULL, 0, 0, 0);
 187                 return 1;
 188         } else
 189         // ENDPOINT_HALT
 190         if ((dr->bmRequestType == 0x02) && // endpoint
 191             (dr->bRequest == CLEAR_FEATURE) &&
 192             (dr->wValue == 0)) {
 193                 int ep = dr->wIndex;
 194                 /* clear STALL */
 195                 this->stall(this, ep & 0xf, ep & 0x80, 0);
 196
 197                 /* status phase IN */
 198                 this->enqueue_packet(this, 0, 1, NULL, 0, 0, 0);
 199                 return 1;
 200         } else
 201         // ENDPOINT_HALT
 202         if ((dr->bmRequestType == 0x02) && // endpoint
 203             (dr->bRequest == SET_FEATURE) &&
 204             (dr->wValue == 0)) {
 205                 int ep = dr->wIndex;
 206                 /* set STALL */
 207                 this->stall(this, ep & 0xf, ep & 0x80, 1);
 208
 209                 /* status phase IN */
 210                 this->enqueue_packet(this, 0, 1, NULL, 0, 0, 0);
 211                 return 1;
 212         } else
 213         // DEVICE_REMOTE_WAKEUP
 214         if ((dr->bmRequestType == 0x00) &&
 215             (dr->bRequest == CLEAR_FEATURE) &&
 216             (dr->wValue == 1)) {
 217                 this->remote_wakeup = 0;
 218
 219                 /* status phase IN */
 220                 this->enqueue_packet(this, 0, 1, NULL, 0, 0, 0);
 221                 return 1;
 222         } else
 223         // DEVICE_REMOTE_WAKEUP
 224         if ((dr->bmRequestType == 0x00) &&
 225             (dr->bRequest == SET_FEATURE) &&
 226             (dr->wValue == 1)) {
 227                 this->remote_wakeup = 1;
 228
 229                 /* status phase IN */
 230                 this->enqueue_packet(this, 0, 1, NULL, 0, 0, 0);
 231                 return 1;
 232         } else
 233         if ((dr->bmRequestType == 0x82) && // endpoint
 234             (dr->bRequest == GET_STATUS)) {
 235                 unsigned char *res = dma_malloc(2);
 236                 int ep = dr->wIndex;
 237                 /* is EP halted? */
 238                 res[0] = this->ep_halted[ep & 0xf][(ep & 0x80) ? 1 : 0];
 239                 res[1] = 0;
 240
 241                 /* data phase IN */
 242                 this->enqueue_packet(this, 0, 1, res,
 243                         min(2, dr->wLength), 0, 1);
 244
 245                 // status phase OUT
 246                 this->enqueue_packet(this, 0, 0, NULL, 0, 0, 0);
 247                 return 1;
 248         } else
 249         if ((dr->bmRequestType == 0x80) &&
 250             (dr->bRequest == GET_STATUS)) {
 251                 unsigned char *res = dma_malloc(2);
 252                 res[0] = 1; // self powered
 253                 if (this->remote_wakeup)
 254                         res[0] |= 2;
 255
 256                 res[1] = 0;
 257
 258                 /* data phase IN */
 259                 this->enqueue_packet(this, 0, 1, res,
 260                         min(2, dr->wLength), 0, 1);
 261
 262                 // status phase OUT
 263                 this->enqueue_packet(this, 0, 0, NULL, 0, 0, 0);
 264                 return 1;
 265         } else
 266         if ((dr->bmRequestType == 0x80) &&
 267             (dr->bRequest == GET_DESCRIPTOR) &&
 268             ((dr->wValue & 0xff00) == 0x0200)) {
 269                 int i, j;
 270                 /* config descriptor #id
 271                  * since config = 0 is undefined, but descriptors
 272                  * should start at 0, add 1 to have them match up.
 273                  */
 274                 int id = (dr->wValue & 0xff) + 1;
 275                 struct usbdev_configuration *config = fetch_config(this, id);
 276                 if (config == NULL) {
 277                         this->stall(this, 0, 0, 1);
 278                         this->stall(this, 0, 1, 1);
 279                         return 1;
 280                 }
 281                 debug("descriptor found, should be %d bytes\n",
 282                         config->descriptor.wTotalLength);
 283
 284                 uint8_t *data = dma_malloc(config->descriptor.wTotalLength);
 285                 uint8_t *head = data;
 286
 287                 memcpy(head, &config->descriptor,
 288                         sizeof(configuration_descriptor_t));
 289                 head += sizeof(configuration_descriptor_t);
 290
 291                 for (i = 0; i < config->descriptor.bNumInterfaces; i++) {
 292                         memcpy(head, &config->interfaces[i].descriptor,
 293                                 sizeof(interface_descriptor_t));
 294                         head += sizeof(interface_descriptor_t);
 295                         for (j = 0;
 296                              j < config->interfaces[i].descriptor.bNumEndpoints;
 297                              j++) {
 298                                 memcpy(head, &config->interfaces[i].eps[j],
 299                                         sizeof(endpoint_descriptor_t));
 300                                 head += sizeof(endpoint_descriptor_t);
 301                         }
 302                 }
 303                 int size = config->descriptor.wTotalLength;
 304                 assert((head - data) == config->descriptor.wTotalLength);
 305
 306                 /* data phase IN */
 307                 this->enqueue_packet(this, 0, 1, data,
 308                         min(size, dr->wLength),
 309                         zlp(this, 0, size, dr->wLength), 1);
 310
 311                 /* status phase OUT */
 312                 this->enqueue_packet(this, 0, 0, NULL, 0, 0, 0);
 313                 return 1;
 314         } else
 315         if ((dr->bmRequestType == 0x80) &&
 316             (dr->bRequest == GET_DESCRIPTOR) &&
 317             ((dr->wValue & 0xff00) == 0x0300)) {
 318                 int id = (dr->wValue & 0xff);
 319                 if (id == 0) {
 320                         if (strings_lang_id == 0)
 321                                 return 0;
 322
 323                         uint8_t *data = dma_malloc(4);
 324                         data[0] = 0x04; // length
 325                         data[1] = 0x03; // string descriptor
 326                         data[2] = strings_lang_id & 0xff;
 327                         data[3] = strings_lang_id >> 8;
 328                         /* data phase IN */
 329                         this->enqueue_packet(this, 0, 1,
 330                                 data,
 331                                 min(data[0], dr->wLength),
 332                                 zlp(this, 0, data[0], dr->wLength),
 333                                 1);
 334
 335                         /* status phase OUT */
 336                         this->enqueue_packet(this, 0, 0, NULL, 0, 0, 0);
 337                 } else {
 338                         if (strings_lang_id == 0)
 339                                 return 0;
 340
 341                         int lang = dr->wIndex;
 342                         if (lang != strings_lang_id)
 343                                 return 0;
 344
 345                         if (id > strings_count)
 346                                 return 0;
 347
 348                         int s_len = strlen(strings[id]);
 349                         int d_len = s_len * 2;
 350
 351                         uint8_t *data = dma_malloc(d_len + 2);
 352                         memset(data, 0, d_len + 2);
 353                         data[0] = d_len + 2; // length
 354                         data[1] = 0x03; // string descriptor
 355                         int i;
 356                         for (i = 0; i < s_len; i++)
 357                                 data[i * 2 + 2] = strings[id][i];
 358
 359                         /* data phase IN */
 360                         this->enqueue_packet(this, 0, 1,
 361                                 data,
 362                                 min(d_len + 2, dr->wLength),
 363                                 zlp(this, 0, d_len + 2, dr->wLength),
 364                                 1);
 365
 366                         /* status phase OUT */
 367                         this->enqueue_packet(this, 0, 0, NULL, 0, 0, 0);
 368                 }
 369                 return 1;
 370         } else
 371         if ((dr->bmRequestType == 0x80) &&
 372             (dr->bRequest == GET_DESCRIPTOR) &&
 373             ((dr->wValue & 0xff00) == 0x0100)) {
 374                 device_descriptor_t *dd = dma_malloc(sizeof(*dd));
 375                 memcpy(dd, &this->device_descriptor, sizeof(*dd));
 376                 dd->bNumConfigurations = this->config_count;
 377
 378                 /* data phase IN */
 379                 this->enqueue_packet(this, 0, 1, (void *)dd,
 380                         min(sizeof(*dd), dr->wLength),
 381                         zlp(this, 0, sizeof(*dd), dr->wLength), 1);
 382
 383                 /* status phase OUT */
 384                 this->enqueue_packet(this, 0, 0, NULL, 0, 0, 0);
 385                 return 1;
 386         }
 387         return 0;
 388 }
 389
 390 void udc_add_gadget(struct usbdev_ctrl *this,
 391         struct usbdev_configuration *config)
 392 {
 393         int i, size;
 394         SLIST_INSERT_HEAD(&this->configs, config, list);
 395
 396         size = sizeof(configuration_descriptor_t);
 397
 398         for (i = 0; i < config->descriptor.bNumInterfaces; i++) {
 399                 size += sizeof(config->interfaces[i].descriptor);
 400                 size += config->interfaces[i].descriptor.bNumEndpoints *
 401                         sizeof(endpoint_descriptor_t);
 402         }
 403         config->descriptor.wTotalLength = size;
 404         config->descriptor.bConfigurationValue = ++this->config_count;
 405 }
 406
 407 void udc_handle_setup(struct usbdev_ctrl *this, int ep, dev_req_t *dr)
 408 {
 409         if ((ep == 0) && setup_ep0(this, dr))
 410                 return;
 411
 412         if (this->current_config &&
 413             this->current_config->interfaces[0].handle_setup &&
 414             this->current_config->interfaces[0].handle_setup(this, ep, dr))
 415                 return;
 416
 417         /* no successful SETUP transfer should end up here, report error */
 418         this->halt_ep(this, ep, 0);
 419         this->halt_ep(this, ep, 1);
 420 }