drivers/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         /* XXX */
 150         configuration = configuration ? configuration - 1 : 0;
 151
 152         if (configuration >= device->configurations) {
 153                 return NULL;
 154         }
 155         return device->configuration_instance_array + configuration;
 156 }
 157
 158
 159 /* *
 160  * usbd_device_interface_instance
 161  * @device:
 162  * @configuration: index to configuration, 0 - N-1
 163  * @interface: index to interface
 164  *
 165  * Return the specified interface descriptor for the specified device.
 166  */
 167 struct usb_interface_instance *usbd_device_interface_instance (struct usb_device_instance *device, int port, int configuration, int interface)
 168 {
 169         struct usb_configuration_instance *configuration_instance;
 170
 171         if ((configuration_instance = usbd_device_configuration_instance (device, port, configuration)) == NULL) {
 172                 return NULL;
 173         }
 174         if (interface >= configuration_instance->interfaces) {
 175                 return NULL;
 176         }
 177         return configuration_instance->interface_instance_array + interface;
 178 }
 179
 180 /* *
 181  * usbd_device_alternate_descriptor_list
 182  * @device:
 183  * @configuration: index to configuration, 0 - N-1
 184  * @interface: index to interface
 185  * @alternate: alternate setting
 186  *
 187  * Return the specified alternate descriptor for the specified device.
 188  */
 189 struct usb_alternate_instance *usbd_device_alternate_instance (struct usb_device_instance *device, int port, int configuration, int interface, int alternate)
 190 {
 191         struct usb_interface_instance *interface_instance;
 192
 193         if ((interface_instance = usbd_device_interface_instance (device, port, configuration, interface)) == NULL) {
 194                 return NULL;
 195         }
 196
 197         if (alternate >= interface_instance->alternates) {
 198                 return NULL;
 199         }
 200
 201         return interface_instance->alternates_instance_array + alternate;
 202 }
 203
 204
 205 /* *
 206  * usbd_device_device_descriptor
 207  * @device: which device
 208  * @configuration: index to configuration, 0 - N-1
 209  * @port: which port
 210  *
 211  * Return the specified configuration descriptor for the specified device.
 212  */
 213 struct usb_device_descriptor *usbd_device_device_descriptor (struct usb_device_instance *device, int port)
 214 {
 215         return (device->device_descriptor);
 216 }
 217
 218
 219 /**
 220  * usbd_device_configuration_descriptor
 221  * @device: which device
 222  * @port: which port
 223  * @configuration: index to configuration, 0 - N-1
 224  *
 225  * Return the specified configuration descriptor for the specified device.
 226  */
 227 struct usb_configuration_descriptor *usbd_device_configuration_descriptor (struct
 228                                                                            usb_device_instance
 229                                                                            *device, int port, int configuration)
 230 {
 231         struct usb_configuration_instance *configuration_instance;
 232         if (!(configuration_instance = usbd_device_configuration_instance (device, port, configuration))) {
 233                 return NULL;
 234         }
 235         return (configuration_instance->configuration_descriptor);
 236 }
 237
 238
 239 /**
 240  * usbd_device_interface_descriptor
 241  * @device: which device
 242  * @port: which port
 243  * @configuration: index to configuration, 0 - N-1
 244  * @interface: index to interface
 245  * @alternate: alternate setting
 246  *
 247  * Return the specified interface descriptor for the specified device.
 248  */
 249 struct usb_interface_descriptor *usbd_device_interface_descriptor (struct usb_device_instance
 250                                                                    *device, int port, int configuration, int interface, int alternate)
 251 {
 252         struct usb_interface_instance *interface_instance;
 253         if (!(interface_instance = usbd_device_interface_instance (device, port, configuration, interface))) {
 254                 return NULL;
 255         }
 256         if ((alternate < 0) || (alternate >= interface_instance->alternates)) {
 257                 return NULL;
 258         }
 259         return (interface_instance->alternates_instance_array[alternate].interface_descriptor);
 260 }
 261
 262 /**
 263  * usbd_device_endpoint_descriptor_index
 264  * @device: which device
 265  * @port: which port
 266  * @configuration: index to configuration, 0 - N-1
 267  * @interface: index to interface
 268  * @alternate: index setting
 269  * @index: which index
 270  *
 271  * Return the specified endpoint descriptor for the specified device.
 272  */
 273 struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor_index (struct usb_device_instance
 274                                                                        *device, int port, int configuration, int interface, int alternate, int index)
 275 {
 276         struct usb_alternate_instance *alternate_instance;
 277
 278         if (!(alternate_instance = usbd_device_alternate_instance (device, port, configuration, interface, alternate))) {
 279                 return NULL;
 280         }
 281         if (index >= alternate_instance->endpoints) {
 282                 return NULL;
 283         }
 284         return *(alternate_instance->endpoints_descriptor_array + index);
 285 }
 286
 287
 288 /**
 289  * usbd_device_endpoint_transfersize
 290  * @device: which device
 291  * @port: which port
 292  * @configuration: index to configuration, 0 - N-1
 293  * @interface: index to interface
 294  * @index: which index
 295  *
 296  * Return the specified endpoint transfer size;
 297  */
 298 int usbd_device_endpoint_transfersize (struct usb_device_instance *device, int port, int configuration, int interface, int alternate, int index)
 299 {
 300         struct usb_alternate_instance *alternate_instance;
 301
 302         if (!(alternate_instance = usbd_device_alternate_instance (device, port, configuration, interface, alternate))) {
 303                 return 0;
 304         }
 305         if (index >= alternate_instance->endpoints) {
 306                 return 0;
 307         }
 308         return *(alternate_instance->endpoint_transfersize_array + index);
 309 }
 310
 311
 312 /**
 313  * usbd_device_endpoint_descriptor
 314  * @device: which device
 315  * @port: which port
 316  * @configuration: index to configuration, 0 - N-1
 317  * @interface: index to interface
 318  * @alternate: alternate setting
 319  * @endpoint: which endpoint
 320  *
 321  * Return the specified endpoint descriptor for the specified device.
 322  */
 323 struct usb_endpoint_descriptor *usbd_device_endpoint_descriptor (struct usb_device_instance *device, int port, int configuration, int interface, int alternate, int endpoint)
 324 {
 325         struct usb_endpoint_descriptor *endpoint_descriptor;
 326         int i;
 327
 328         for (i = 0; !(endpoint_descriptor = usbd_device_endpoint_descriptor_index (device, port, configuration, interface, alternate, i)); i++) {
 329                 if (endpoint_descriptor->bEndpointAddress == endpoint) {
 330                         return endpoint_descriptor;
 331                 }
 332         }
 333         return NULL;
 334 }
 335
 336 /**
 337  * usbd_endpoint_halted
 338  * @device: point to struct usb_device_instance
 339  * @endpoint: endpoint to check
 340  *
 341  * Return non-zero if endpoint is halted.
 342  */
 343 int usbd_endpoint_halted (struct usb_device_instance *device, int endpoint)
 344 {
 345         return (device->status == USB_STATUS_HALT);
 346 }
 347
 348
 349 /**
 350  * usbd_rcv_complete - complete a receive
 351  * @endpoint:
 352  * @len:
 353  * @urb_bad:
 354  *
 355  * Called from rcv interrupt to complete.
 356  */
 357 void usbd_rcv_complete(struct usb_endpoint_instance *endpoint, int len, int urb_bad)
 358 {
 359         if (endpoint) {
 360                 struct urb *rcv_urb;
 361
 362                 /*usbdbg("len: %d urb: %p\n", len, endpoint->rcv_urb); */
 363
 364                 /* if we had an urb then update actual_length, dispatch if neccessary */
 365                 if ((rcv_urb = endpoint->rcv_urb)) {
 366
 367                         /*usbdbg("actual: %d buffer: %d\n", */
 368                         /*rcv_urb->actual_length, rcv_urb->buffer_length); */
 369
 370                         /* check the urb is ok, are we adding data less than the packetsize */
 371                         if (!urb_bad && (len <= endpoint->rcv_packetSize)) {
 372                           /*usbdbg("updating actual_length by %d\n",len); */
 373
 374                                 /* increment the received data size */
 375                                 rcv_urb->actual_length += len;
 376
 377                         } else {
 378                                 usberr(" RECV_ERROR actual: %d buffer: %d urb_bad: %d\n",
 379                                        rcv_urb->actual_length, rcv_urb->buffer_length, urb_bad);
 380
 381                                 rcv_urb->actual_length = 0;
 382                                 rcv_urb->status = RECV_ERROR;
 383                         }
 384                 } else {
 385                         usberr("no rcv_urb!");
 386                 }
 387         } else {
 388                 usberr("no endpoint!");
 389         }
 390
 391 }
 392
 393 /**
 394  * usbd_tx_complete - complete a transmit
 395  * @endpoint:
 396  * @resetart:
 397  *
 398  * Called from tx interrupt to complete.
 399  */
 400 void usbd_tx_complete (struct usb_endpoint_instance *endpoint)
 401 {
 402         if (endpoint) {
 403                 struct urb *tx_urb;
 404
 405                 /* if we have a tx_urb advance or reset, finish if complete */
 406                 if ((tx_urb = endpoint->tx_urb)) {
 407                         int sent = endpoint->last;
 408                         endpoint->sent += sent;
 409                         endpoint->last -= sent;
 410
 411                         if( (endpoint->tx_urb->actual_length - endpoint->sent) <= 0 ) {
 412                                 tx_urb->actual_length = 0;
 413                                 endpoint->sent = 0;
 414                                 endpoint->last = 0;
 415
 416                                 /* Remove from active, save for re-use */
 417                                 urb_detach(tx_urb);
 418                                 urb_append(&endpoint->done, tx_urb);
 419                                 /*usbdbg("done->next %p, tx_urb %p, done %p", */
 420                                 /*       endpoint->done.next, tx_urb, &endpoint->done); */
 421
 422                                 endpoint->tx_urb = first_urb_detached(&endpoint->tx);
 423                                 if( endpoint->tx_urb ) {
 424                                         endpoint->tx_queue--;
 425                                         usbdbg("got urb from tx list");
 426                                 }
 427                                 if( !endpoint->tx_urb ) {
 428                                         /*usbdbg("taking urb from done list"); */
 429                                         endpoint->tx_urb = first_urb_detached(&endpoint->done);
 430                                 }
 431                                 if( !endpoint->tx_urb ) {
 432                                         usbdbg("allocating new urb for tx_urb");
 433                                         endpoint->tx_urb = usbd_alloc_urb(tx_urb->device, endpoint);
 434                                 }
 435                         }
 436                 }
 437         }
 438 }
 439
 440 /* URB linked list functions ***************************************************** */
 441
 442 /*
 443  * Initialize an urb_link to be a single element list.
 444  * If the urb_link is being used as a distinguished list head
 445  * the list is empty when the head is the only link in the list.
 446  */
 447 void urb_link_init (urb_link * ul)
 448 {
 449         if (ul) {
 450                 ul->prev = ul->next = ul;
 451         }
 452 }
 453
 454 /*
 455  * Detach an urb_link from a list, and set it
 456  * up as a single element list, so no dangling
 457  * pointers can be followed, and so it can be
 458  * joined to another list if so desired.
 459  */
 460 void urb_detach (struct urb *urb)
 461 {
 462         if (urb) {
 463                 urb_link *ul = &urb->link;
 464                 ul->next->prev = ul->prev;
 465                 ul->prev->next = ul->next;
 466                 urb_link_init (ul);
 467         }
 468 }
 469
 470 /*
 471  * Return the first urb_link in a list with a distinguished
 472  * head "hd", or NULL if the list is empty.  This will also
 473  * work as a predicate, returning NULL if empty, and non-NULL
 474  * otherwise.
 475  */
 476 urb_link *first_urb_link (urb_link * hd)
 477 {
 478         urb_link *nx;
 479         if (NULL != hd && NULL != (nx = hd->next) && nx != hd) {
 480                 /* There is at least one element in the list */
 481                 /* (besides the distinguished head). */
 482                 return (nx);
 483         }
 484         /* The list is empty */
 485         return (NULL);
 486 }
 487
 488 /*
 489  * Return the first urb in a list with a distinguished
 490  * head "hd", or NULL if the list is empty.
 491  */
 492 struct urb *first_urb (urb_link * hd)
 493 {
 494         urb_link *nx;
 495         if (NULL == (nx = first_urb_link (hd))) {
 496                 /* The list is empty */
 497                 return (NULL);
 498         }
 499         return (p2surround (struct urb, link, nx));
 500 }
 501
 502 /*
 503  * Detach and return the first urb in a list with a distinguished
 504  * head "hd", or NULL if the list is empty.
 505  *
 506  */
 507 struct urb *first_urb_detached (urb_link * hd)
 508 {
 509         struct urb *urb;
 510         if ((urb = first_urb (hd))) {
 511                 urb_detach (urb);
 512         }
 513         return urb;
 514 }
 515
 516
 517 /*
 518  * Append an urb_link (or a whole list of
 519  * urb_links) to the tail of another list
 520  * of urb_links.
 521  */
 522 void urb_append (urb_link * hd, struct urb *urb)
 523 {
 524         if (hd && urb) {
 525                 urb_link *new = &urb->link;
 526
 527                 /* This allows the new urb to be a list of urbs, */
 528                 /* with new pointing at the first, but the link */
 529                 /* must be initialized. */
 530                 /* Order is important here... */
 531                 urb_link *pul = hd->prev;
 532                 new->prev->next = hd;
 533                 hd->prev = new->prev;
 534                 new->prev = pul;
 535                 pul->next = new;
 536         }
 537 }
 538
 539 /* URB create/destroy functions ***************************************************** */
 540
 541 /**
 542  * usbd_alloc_urb - allocate an URB appropriate for specified endpoint
 543  * @device: device instance
 544  * @endpoint: endpoint
 545  *
 546  * Allocate an urb structure. The usb device urb structure is used to
 547  * contain all data associated with a transfer, including a setup packet for
 548  * control transfers.
 549  *
 550  * NOTE: endpoint_address MUST contain a direction flag.
 551  */
 552 struct urb *usbd_alloc_urb (struct usb_device_instance *device, struct usb_endpoint_instance *endpoint)
 553 {
 554         struct urb *urb;
 555
 556         if( !(urb = (struct urb*)malloc(sizeof(struct urb))) ) {
 557           usberr(" F A T A L:  malloc(%u) FAILED!!!!", sizeof(struct urb));
 558           return NULL;
 559         }
 560
 561         /* Fill in known fields */
 562         memset(urb, 0, sizeof(struct urb));
 563         urb->endpoint = endpoint;
 564         urb->device = device;
 565         urb->buffer = (u8*)urb->buffer_data;
 566         urb->buffer_length = sizeof(urb->buffer_data);
 567
 568         urb_link_init (&urb->link);
 569
 570         return urb;
 571 }
 572
 573 /**
 574  * usbd_dealloc_urb - deallocate an URB and associated buffer
 575  * @urb: pointer to an urb structure
 576  *
 577  * Deallocate an urb structure and associated data.
 578  */
 579 void usbd_dealloc_urb (struct urb *urb)
 580 {
 581         if (urb) {
 582                 free (urb);
 583         }
 584 }
 585
 586 /* Event signaling functions ***************************************************** */
 587
 588 /**
 589  * usbd_device_event - called to respond to various usb events
 590  * @device: pointer to struct device
 591  * @event: event to respond to
 592  *
 593  * Used by a Bus driver to indicate an event.
 594  */
 595 void usbd_device_event_irq (struct usb_device_instance *device, usb_device_event_t event, int data)
 596 {
 597         usb_device_state_t state;
 598
 599         if (!device || !device->bus) {
 600                 usberr("(%p,%d) NULL device or device->bus", device, event);
 601                 return;
 602         }
 603
 604         state = device->device_state;
 605
 606         usbinfo("%s", usbd_device_events[event]);
 607
 608         switch (event) {
 609         case DEVICE_UNKNOWN:
 610                 break;
 611         case DEVICE_INIT:
 612                 device->device_state = STATE_INIT;
 613                 break;
 614
 615         case DEVICE_CREATE:
 616                 device->device_state = STATE_ATTACHED;
 617                 break;
 618
 619         case DEVICE_HUB_CONFIGURED:
 620                 device->device_state = STATE_POWERED;
 621                 break;
 622
 623         case DEVICE_RESET:
 624                 device->device_state = STATE_DEFAULT;
 625                 device->address = 0;
 626                 break;
 627
 628         case DEVICE_ADDRESS_ASSIGNED:
 629                 device->device_state = STATE_ADDRESSED;
 630                 break;
 631
 632         case DEVICE_CONFIGURED:
 633                 device->device_state = STATE_CONFIGURED;
 634                 break;
 635
 636         case DEVICE_DE_CONFIGURED:
 637                 device->device_state = STATE_ADDRESSED;
 638                 break;
 639
 640         case DEVICE_BUS_INACTIVE:
 641                 if (device->status != USBD_CLOSING) {
 642                         device->status = USBD_SUSPENDED;
 643                 }
 644                 break;
 645         case DEVICE_BUS_ACTIVITY:
 646                 if (device->status != USBD_CLOSING) {
 647                         device->status = USBD_OK;
 648                 }
 649                 break;
 650
 651         case DEVICE_SET_INTERFACE:
 652                 break;
 653         case DEVICE_SET_FEATURE:
 654                 break;
 655         case DEVICE_CLEAR_FEATURE:
 656                 break;
 657
 658         case DEVICE_POWER_INTERRUPTION:
 659                 device->device_state = STATE_POWERED;
 660                 break;
 661         case DEVICE_HUB_RESET:
 662                 device->device_state = STATE_ATTACHED;
 663                 break;
 664         case DEVICE_DESTROY:
 665                 device->device_state = STATE_UNKNOWN;
 666                 break;
 667
 668         case DEVICE_FUNCTION_PRIVATE:
 669                 break;
 670
 671         default:
 672                 usbdbg("event %d - not handled",event);
 673                 break;
 674         }
 675         /*usbdbg("%s event: %d oldstate: %d newstate: %d status: %d address: %d",
 676                 device->name, event, state,
 677                 device->device_state, device->status, device->address); */
 678
 679         /* tell the bus interface driver */
 680         if( device->event ) {
 681                 /* usbdbg("calling device->event"); */
 682                 device->event(device, event, data);
 683         }
 684 }