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