qemu/roms/u-boot/drivers/usb/gadget/core.c

   1 /*
   2  * (C) Copyright 2003
   3  * Gerry Hamel, geh@ti.com, Texas Instruments
   4  *
   5  * Based on
   6  * linux/drivers/usbd/usbd.c.c - USB Device Core Layer
   7  *
   8  * Copyright (c) 2000, 2001, 2002 Lineo
   9  * Copyright (c) 2001 Hewlett Packard
  10  *
  11  * By:
  12  *      Stuart Lynne <sl@lineo.com>,
  13  *      Tom Rushworth <tbr@lineo.com>,
  14  *      Bruce Balden <balden@lineo.com>
  15  *
  16  * SPDX-License-Identifier:     GPL-2.0+
  17  */
  18
  19 #include <malloc.h>
  20 #include <usbdevice.h>
  21
  22 #define MAX_INTERFACES 2
  23
  24
  25 int maxstrings = 20;
  26
  27 /* Global variables ************************************************************************** */
  28
  29 struct usb_string_descriptor **usb_strings;
  30
  31 int usb_devices;
  32
  33 extern struct usb_function_driver ep0_driver;
  34
  35 int registered_functions;
  36 int registered_devices;
  37
  38 char *usbd_device_events[] = {
  39         "DEVICE_UNKNOWN",
  40         "DEVICE_INIT",
  41         "DEVICE_CREATE",
  42         "DEVICE_HUB_CONFIGURED",
  43         "DEVICE_RESET",
  44         "DEVICE_ADDRESS_ASSIGNED",
  45         "DEVICE_CONFIGURED",
  46         "DEVICE_SET_INTERFACE",
  47         "DEVICE_SET_FEATURE",
  48         "DEVICE_CLEAR_FEATURE",
  49         "DEVICE_DE_CONFIGURED",
  50         "DEVICE_BUS_INACTIVE",
  51         "DEVICE_BUS_ACTIVITY",
  52         "DEVICE_POWER_INTERRUPTION",
  53         "DEVICE_HUB_RESET",
  54         "DEVICE_DESTROY",
  55         "DEVICE_FUNCTION_PRIVATE",
  56 };
  57
  58 char *usbd_device_states[] = {
  59         "STATE_INIT",
  60         "STATE_CREATED",
  61         "STATE_ATTACHED",
  62         "STATE_POWERED",
  63         "STATE_DEFAULT",
  64         "STATE_ADDRESSED",
  65         "STATE_CONFIGURED",
  66         "STATE_UNKNOWN",
  67 };
  68
  69 char *usbd_device_requests[] = {
  70         "GET STATUS",           /* 0 */
  71         "CLEAR FEATURE",        /* 1 */
  72         "RESERVED",             /* 2 */
  73         "SET FEATURE",          /* 3 */
  74         "RESERVED",             /* 4 */
  75         "SET ADDRESS",          /* 5 */
  76         "GET DESCRIPTOR",       /* 6 */
  77         "SET DESCRIPTOR",       /* 7 */
  78         "GET CONFIGURATION",    /* 8 */
  79         "SET CONFIGURATION",    /* 9 */
  80         "GET INTERFACE",        /* 10 */
  81         "SET INTERFACE",        /* 11 */
  82         "SYNC FRAME",           /* 12 */
  83 };
  84
  85 char *usbd_device_descriptors[] = {
  86         "UNKNOWN",              /* 0 */
  87         "DEVICE",               /* 1 */
  88         "CONFIG",               /* 2 */
  89         "STRING",               /* 3 */
  90         "INTERFACE",            /* 4 */
  91         "ENDPOINT",             /* 5 */
  92         "DEVICE QUALIFIER",     /* 6 */
  93         "OTHER SPEED",          /* 7 */
  94         "INTERFACE POWER",      /* 8 */
  95 };
  96
  97 char *usbd_device_status[] = {
  98         "USBD_OPENING",
  99         "USBD_OK",
 100         "USBD_SUSPENDED",
 101         "USBD_CLOSING",
 102 };
 103
 104
 105 /* Descriptor support functions ************************************************************** */
 106
 107
 108 /**
 109  * usbd_get_string - find and return a string descriptor
 110  * @index: string index to return
 111  *
 112  * Find an indexed string and return a pointer to a it.
 113  */
 114 struct usb_string_descriptor *usbd_get_string (__u8 index)
 115 {
 116         if (index >= maxstrings) {
 117                 return NULL;
 118         }
 119         return usb_strings[index];
 120 }
 121
 122
 123 /* Access to device descriptor functions ***************************************************** */
 124
 125
 126 /* *
 127  * usbd_device_configuration_instance - find a configuration instance for this device
 128  * @device:
 129  * @configuration: index to configuration, 0 - N-1
 130  *
 131  * Get specifed device configuration. Index should be bConfigurationValue-1.
 132  */
 133 static struct usb_configuration_instance *usbd_device_configuration_instance (struct usb_device_instance *device,
 134                 unsigned int port, unsigned int configuration)
 135 {
 136         if (configuration >= device->configurations)
 137                 return NULL;
 138
 139         return device->configuration_instance_array + configuration;
 140 }
 141
 142
 143 /* *
 144  * usbd_device_interface_instance
 145  * @device:
 146  * @configuration: index to configuration, 0 - N-1
 147  * @interface: index to interface
 148  *
 149  * Return the specified interface descriptor for the specified device.
 150  */
 151 struct usb_interface_instance *usbd_device_interface_instance (struct usb_device_instance *device, int port, int configuration, int interface)
 152 {
 153         struct usb_configuration_instance *configuration_instance;
 154
 155         if ((configuration_instance = usbd_device_configuration_instance (device, port, configuration)) == NULL) {
 156                 return NULL;
 157         }
 158         if (interface >= configuration_instance->interfaces) {
 159                 return NULL;
 160         }
 161         return configuration_instance->interface_instance_array + interface;
 162 }
 163
 164 /* *
 165  * usbd_device_alternate_descriptor_list
 166  * @device:
 167  * @configuration: index to configuration, 0 - N-1
 168  * @interface: index to interface
 169  * @alternate: alternate setting
 170  *
 171  * Return the specified alternate descriptor for the specified device.
 172  */
 173 struct usb_alternate_instance *usbd_device_alternate_instance (struct usb_device_instance *device, int port, int configuration, int interface, int alternate)
 174 {
 175         struct usb_interface_instance *interface_instance;
 176
 177         if ((interface_instance = usbd_device_interface_instance (device, port, configuration, interface)) == NULL) {
 178                 return NULL;
 179         }
 180
 181         if (alternate >= interface_instance->alternates) {
 182                 return NULL;
 183         }
 184
 185         return interface_instance->alternates_instance_array + alternate;
 186 }
 187
 188
 189 /* *
 190  * usbd_device_device_descriptor
 191  * @device: which device
 192  * @configuration: index to configuration, 0 - N-1
 193  * @port: which port
 194  *
 195  * Return the specified configuration descriptor for the specified device.
 196  */
 197 struct usb_device_descriptor *usbd_device_device_descriptor (struct usb_device_instance *device, int port)
 198 {
 199         return (device->device_descriptor);
 200 }
 201
 202 /**
 203  * usbd_device_configuration_descriptor
 204  * @device: which device
 205  * @port: which port
 206  * @configuration: index to configuration, 0 - N-1
 207  *
 208  * Return the specified configuration descriptor for the specified device.
 209  */
 210 struct usb_configuration_descriptor *usbd_device_configuration_descriptor (struct
 211                                                                            usb_device_instance
 212                                                                            *device, int port, int configuration)
 213 {
 214         struct usb_configuration_instance *configuration_instance;
 215         if (!(configuration_instance = usbd_device_configuration_instance (device, port, configuration))) {
 216                 return NULL;
 217         }
 218         return (configuration_instance->configuration_descriptor);
 219 }
 220
 221
 222 /**
 223  * usbd_device_interface_descriptor
 224  * @device: which device
 225  * @port: which port
 226  * @configuration: index to configuration, 0 - N-1
 227  * @interface: index to interface
 228  * @alternate: alternate setting
 229  *
 230  * Return the specified interface descriptor for the specified device.
 231  */
 232 struct usb_interface_descriptor *usbd_device_interface_descriptor (struct usb_device_instance
 233                                                                    *device, int port, int configuration, int interface, int alternate)
 234 {
 235         struct usb_interface_instance *interface_instance;
 236         if (!(interface_instance = usbd_device_interface_instance (device, port, configuration, interface))) {
 237                 return NULL;
 238         }
 239         if ((alternate < 0) || (alternate >= interface_instance->alternates)) {
 240                 return NULL;
 241         }
 242         return (interface_instance->alternates_instance_array[alternate].interface_descriptor);
 243 }
 244
 245 /**
 246  * usbd_device_endpoint_descriptor_index
 247  * @device: which device
 248  * @port: which port
 249  * @configuration: index to configuration, 0 - N-1
 250  * @interface: index to interface
 251  * @alternate: index setting
 252  * @index: which index
 253  *
 254  * Return the specified endpoint descriptor for the specified device.
 255  */
 256 struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor_index (struct usb_device_instance
 257                                                                        *device, int port, int configuration, int interface, int alternate, int index)
 258 {
 259         struct usb_alternate_instance *alternate_instance;
 260
 261         if (!(alternate_instance = usbd_device_alternate_instance (device, port, configuration, interface, alternate))) {
 262                 return NULL;
 263         }
 264         if (index >= alternate_instance->endpoints) {
 265                 return NULL;
 266         }
 267         return *(alternate_instance->endpoints_descriptor_array + index);
 268 }
 269
 270
 271 /**
 272  * usbd_device_endpoint_transfersize
 273  * @device: which device
 274  * @port: which port
 275  * @configuration: index to configuration, 0 - N-1
 276  * @interface: index to interface
 277  * @index: which index
 278  *
 279  * Return the specified endpoint transfer size;
 280  */
 281 int usbd_device_endpoint_transfersize (struct usb_device_instance *device, int port, int configuration, int interface, int alternate, int index)
 282 {
 283         struct usb_alternate_instance *alternate_instance;
 284
 285         if (!(alternate_instance = usbd_device_alternate_instance (device, port, configuration, interface, alternate))) {
 286                 return 0;
 287         }
 288         if (index >= alternate_instance->endpoints) {
 289                 return 0;
 290         }
 291         return *(alternate_instance->endpoint_transfersize_array + index);
 292 }
 293
 294
 295 /**
 296  * usbd_device_endpoint_descriptor
 297  * @device: which device
 298  * @port: which port
 299  * @configuration: index to configuration, 0 - N-1
 300  * @interface: index to interface
 301  * @alternate: alternate setting
 302  * @endpoint: which endpoint
 303  *
 304  * Return the specified endpoint descriptor for the specified device.
 305  */
 306 struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor (struct usb_device_instance *device, int port, int configuration, int interface, int alternate, int endpoint)
 307 {
 308         struct usb_endpoint_descriptor *endpoint_descriptor;
 309         int i;
 310
 311         for (i = 0; !(endpoint_descriptor = usbd_device_endpoint_descriptor_index (device, port, configuration, interface, alternate, i)); i++) {
 312                 if (endpoint_descriptor->bEndpointAddress == endpoint) {
 313                         return endpoint_descriptor;
 314                 }
 315         }
 316         return NULL;
 317 }
 318
 319 /**
 320  * usbd_endpoint_halted
 321  * @device: point to struct usb_device_instance
 322  * @endpoint: endpoint to check
 323  *
 324  * Return non-zero if endpoint is halted.
 325  */
 326 int usbd_endpoint_halted (struct usb_device_instance *device, int endpoint)
 327 {
 328         return (device->status == USB_STATUS_HALT);
 329 }
 330
 331
 332 /**
 333  * usbd_rcv_complete - complete a receive
 334  * @endpoint:
 335  * @len:
 336  * @urb_bad:
 337  *
 338  * Called from rcv interrupt to complete.
 339  */
 340 void usbd_rcv_complete(struct usb_endpoint_instance *endpoint, int len, int urb_bad)
 341 {
 342         if (endpoint) {
 343                 struct urb *rcv_urb;
 344
 345                 /*usbdbg("len: %d urb: %p\n", len, endpoint->rcv_urb); */
 346
 347                 /* if we had an urb then update actual_length, dispatch if neccessary */
 348                 if ((rcv_urb = endpoint->rcv_urb)) {
 349
 350                         /*usbdbg("actual: %d buffer: %d\n", */
 351                         /*rcv_urb->actual_length, rcv_urb->buffer_length); */
 352
 353                         /* check the urb is ok, are we adding data less than the packetsize */
 354                         if (!urb_bad && (len <= endpoint->rcv_packetSize)) {
 355                           /*usbdbg("updating actual_length by %d\n",len); */
 356
 357                                 /* increment the received data size */
 358                                 rcv_urb->actual_length += len;
 359
 360                         } else {
 361                                 usberr(" RECV_ERROR actual: %d buffer: %d urb_bad: %d\n",
 362                                        rcv_urb->actual_length, rcv_urb->buffer_length, urb_bad);
 363
 364                                 rcv_urb->actual_length = 0;
 365                                 rcv_urb->status = RECV_ERROR;
 366                         }
 367                 } else {
 368                         usberr("no rcv_urb!");
 369                 }
 370         } else {
 371                 usberr("no endpoint!");
 372         }
 373
 374 }
 375
 376 /**
 377  * usbd_tx_complete - complete a transmit
 378  * @endpoint:
 379  * @resetart:
 380  *
 381  * Called from tx interrupt to complete.
 382  */
 383 void usbd_tx_complete (struct usb_endpoint_instance *endpoint)
 384 {
 385         if (endpoint) {
 386                 struct urb *tx_urb;
 387
 388                 /* if we have a tx_urb advance or reset, finish if complete */
 389                 if ((tx_urb = endpoint->tx_urb)) {
 390                         int sent = endpoint->last;
 391                         endpoint->sent += sent;
 392                         endpoint->last -= sent;
 393
 394                         if( (endpoint->tx_urb->actual_length - endpoint->sent) <= 0 ) {
 395                                 tx_urb->actual_length = 0;
 396                                 endpoint->sent = 0;
 397                                 endpoint->last = 0;
 398
 399                                 /* Remove from active, save for re-use */
 400                                 urb_detach(tx_urb);
 401                                 urb_append(&endpoint->done, tx_urb);
 402                                 /*usbdbg("done->next %p, tx_urb %p, done %p", */
 403                                 /*       endpoint->done.next, tx_urb, &endpoint->done); */
 404
 405                                 endpoint->tx_urb = first_urb_detached(&endpoint->tx);
 406                                 if( endpoint->tx_urb ) {
 407                                         endpoint->tx_queue--;
 408                                         usbdbg("got urb from tx list");
 409                                 }
 410                                 if( !endpoint->tx_urb ) {
 411                                         /*usbdbg("taking urb from done list"); */
 412                                         endpoint->tx_urb = first_urb_detached(&endpoint->done);
 413                                 }
 414                                 if( !endpoint->tx_urb ) {
 415                                         usbdbg("allocating new urb for tx_urb");
 416                                         endpoint->tx_urb = usbd_alloc_urb(tx_urb->device, endpoint);
 417                                 }
 418                         }
 419                 }
 420         }
 421 }
 422
 423 /* URB linked list functions ***************************************************** */
 424
 425 /*
 426  * Initialize an urb_link to be a single element list.
 427  * If the urb_link is being used as a distinguished list head
 428  * the list is empty when the head is the only link in the list.
 429  */
 430 void urb_link_init (urb_link * ul)
 431 {
 432         if (ul) {
 433                 ul->prev = ul->next = ul;
 434         }
 435 }
 436
 437 /*
 438  * Detach an urb_link from a list, and set it
 439  * up as a single element list, so no dangling
 440  * pointers can be followed, and so it can be
 441  * joined to another list if so desired.
 442  */
 443 void urb_detach (struct urb *urb)
 444 {
 445         if (urb) {
 446                 urb_link *ul = &urb->link;
 447                 ul->next->prev = ul->prev;
 448                 ul->prev->next = ul->next;
 449                 urb_link_init (ul);
 450         }
 451 }
 452
 453 /*
 454  * Return the first urb_link in a list with a distinguished
 455  * head "hd", or NULL if the list is empty.  This will also
 456  * work as a predicate, returning NULL if empty, and non-NULL
 457  * otherwise.
 458  */
 459 urb_link *first_urb_link (urb_link * hd)
 460 {
 461         urb_link *nx;
 462         if (NULL != hd && NULL != (nx = hd->next) && nx != hd) {
 463                 /* There is at least one element in the list */
 464                 /* (besides the distinguished head). */
 465                 return (nx);
 466         }
 467         /* The list is empty */
 468         return (NULL);
 469 }
 470
 471 /*
 472  * Return the first urb in a list with a distinguished
 473  * head "hd", or NULL if the list is empty.
 474  */
 475 struct urb *first_urb (urb_link * hd)
 476 {
 477         urb_link *nx;
 478         if (NULL == (nx = first_urb_link (hd))) {
 479                 /* The list is empty */
 480                 return (NULL);
 481         }
 482         return (p2surround (struct urb, link, nx));
 483 }
 484
 485 /*
 486  * Detach and return the first urb in a list with a distinguished
 487  * head "hd", or NULL if the list is empty.
 488  *
 489  */
 490 struct urb *first_urb_detached (urb_link * hd)
 491 {
 492         struct urb *urb;
 493         if ((urb = first_urb (hd))) {
 494                 urb_detach (urb);
 495         }
 496         return urb;
 497 }
 498
 499
 500 /*
 501  * Append an urb_link (or a whole list of
 502  * urb_links) to the tail of another list
 503  * of urb_links.
 504  */
 505 void urb_append (urb_link * hd, struct urb *urb)
 506 {
 507         if (hd && urb) {
 508                 urb_link *new = &urb->link;
 509
 510                 /* This allows the new urb to be a list of urbs, */
 511                 /* with new pointing at the first, but the link */
 512                 /* must be initialized. */
 513                 /* Order is important here... */
 514                 urb_link *pul = hd->prev;
 515                 new->prev->next = hd;
 516                 hd->prev = new->prev;
 517                 new->prev = pul;
 518                 pul->next = new;
 519         }
 520 }
 521
 522 /* URB create/destroy functions ***************************************************** */
 523
 524 /**
 525  * usbd_alloc_urb - allocate an URB appropriate for specified endpoint
 526  * @device: device instance
 527  * @endpoint: endpoint
 528  *
 529  * Allocate an urb structure. The usb device urb structure is used to
 530  * contain all data associated with a transfer, including a setup packet for
 531  * control transfers.
 532  *
 533  * NOTE: endpoint_address MUST contain a direction flag.
 534  */
 535 struct urb *usbd_alloc_urb (struct usb_device_instance *device,
 536                             struct usb_endpoint_instance *endpoint)
 537 {
 538         struct urb *urb;
 539
 540         if (!(urb = (struct urb *) malloc (sizeof (struct urb)))) {
 541                 usberr (" F A T A L:  malloc(%zu) FAILED!!!!",
 542                         sizeof (struct urb));
 543                 return NULL;
 544         }
 545
 546         /* Fill in known fields */
 547         memset (urb, 0, sizeof (struct urb));
 548         urb->endpoint = endpoint;
 549         urb->device = device;
 550         urb->buffer = (u8 *) urb->buffer_data;
 551         urb->buffer_length = sizeof (urb->buffer_data);
 552
 553         urb_link_init (&urb->link);
 554
 555         return urb;
 556 }
 557
 558 /**
 559  * usbd_dealloc_urb - deallocate an URB and associated buffer
 560  * @urb: pointer to an urb structure
 561  *
 562  * Deallocate an urb structure and associated data.
 563  */
 564 void usbd_dealloc_urb (struct urb *urb)
 565 {
 566         if (urb) {
 567                 free (urb);
 568         }
 569 }
 570
 571 /* Event signaling functions ***************************************************** */
 572
 573 /**
 574  * usbd_device_event - called to respond to various usb events
 575  * @device: pointer to struct device
 576  * @event: event to respond to
 577  *
 578  * Used by a Bus driver to indicate an event.
 579  */
 580 void usbd_device_event_irq (struct usb_device_instance *device, usb_device_event_t event, int data)
 581 {
 582         usb_device_state_t state;
 583
 584         if (!device || !device->bus) {
 585                 usberr("(%p,%d) NULL device or device->bus", device, event);
 586                 return;
 587         }
 588
 589         state = device->device_state;
 590
 591         usbinfo("%s", usbd_device_events[event]);
 592
 593         switch (event) {
 594         case DEVICE_UNKNOWN:
 595                 break;
 596         case DEVICE_INIT:
 597                 device->device_state = STATE_INIT;
 598                 break;
 599
 600         case DEVICE_CREATE:
 601                 device->device_state = STATE_ATTACHED;
 602                 break;
 603
 604         case DEVICE_HUB_CONFIGURED:
 605                 device->device_state = STATE_POWERED;
 606                 break;
 607
 608         case DEVICE_RESET:
 609                 device->device_state = STATE_DEFAULT;
 610                 device->address = 0;
 611                 break;
 612
 613         case DEVICE_ADDRESS_ASSIGNED:
 614                 device->device_state = STATE_ADDRESSED;
 615                 break;
 616
 617         case DEVICE_CONFIGURED:
 618                 device->device_state = STATE_CONFIGURED;
 619                 break;
 620
 621         case DEVICE_DE_CONFIGURED:
 622                 device->device_state = STATE_ADDRESSED;
 623                 break;
 624
 625         case DEVICE_BUS_INACTIVE:
 626                 if (device->status != USBD_CLOSING) {
 627                         device->status = USBD_SUSPENDED;
 628                 }
 629                 break;
 630         case DEVICE_BUS_ACTIVITY:
 631                 if (device->status != USBD_CLOSING) {
 632                         device->status = USBD_OK;
 633                 }
 634                 break;
 635
 636         case DEVICE_SET_INTERFACE:
 637                 break;
 638         case DEVICE_SET_FEATURE:
 639                 break;
 640         case DEVICE_CLEAR_FEATURE:
 641                 break;
 642
 643         case DEVICE_POWER_INTERRUPTION:
 644                 device->device_state = STATE_POWERED;
 645                 break;
 646         case DEVICE_HUB_RESET:
 647                 device->device_state = STATE_ATTACHED;
 648                 break;
 649         case DEVICE_DESTROY:
 650                 device->device_state = STATE_UNKNOWN;
 651                 break;
 652
 653         case DEVICE_FUNCTION_PRIVATE:
 654                 break;
 655
 656         default:
 657                 usbdbg("event %d - not handled",event);
 658                 break;
 659         }
 660         debug("%s event: %d oldstate: %d newstate: %d status: %d address: %d",
 661                 device->name, event, state,
 662                 device->device_state, device->status, device->address);
 663
 664         /* tell the bus interface driver */
 665         if( device->event ) {
 666                 /* usbdbg("calling device->event"); */
 667                 device->event(device, event, data);
 668         }
 669 }