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 <usbdevice.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, 550 struct usb_endpoint_instance *endpoint) 551 { 552 struct urb *urb; 553 554 if (!(urb = (struct urb *) malloc (sizeof (struct urb)))) { 555 usberr (" F A T A L: malloc(%zu) FAILED!!!!", 556 sizeof (struct urb)); 557 return NULL; 558 } 559 560 /* Fill in known fields */ 561 memset (urb, 0, sizeof (struct urb)); 562 urb->endpoint = endpoint; 563 urb->device = device; 564 urb->buffer = (u8 *) urb->buffer_data; 565 urb->buffer_length = sizeof (urb->buffer_data); 566 567 urb_link_init (&urb->link); 568 569 return urb; 570 } 571 572 /** 573 * usbd_dealloc_urb - deallocate an URB and associated buffer 574 * @urb: pointer to an urb structure 575 * 576 * Deallocate an urb structure and associated data. 577 */ 578 void usbd_dealloc_urb (struct urb *urb) 579 { 580 if (urb) { 581 free (urb); 582 } 583 } 584 585 /* Event signaling functions ***************************************************** */ 586 587 /** 588 * usbd_device_event - called to respond to various usb events 589 * @device: pointer to struct device 590 * @event: event to respond to 591 * 592 * Used by a Bus driver to indicate an event. 593 */ 594 void usbd_device_event_irq (struct usb_device_instance *device, usb_device_event_t event, int data) 595 { 596 usb_device_state_t state; 597 598 if (!device || !device->bus) { 599 usberr("(%p,%d) NULL device or device->bus", device, event); 600 return; 601 } 602 603 state = device->device_state; 604 605 usbinfo("%s", usbd_device_events[event]); 606 607 switch (event) { 608 case DEVICE_UNKNOWN: 609 break; 610 case DEVICE_INIT: 611 device->device_state = STATE_INIT; 612 break; 613 614 case DEVICE_CREATE: 615 device->device_state = STATE_ATTACHED; 616 break; 617 618 case DEVICE_HUB_CONFIGURED: 619 device->device_state = STATE_POWERED; 620 break; 621 622 case DEVICE_RESET: 623 device->device_state = STATE_DEFAULT; 624 device->address = 0; 625 break; 626 627 case DEVICE_ADDRESS_ASSIGNED: 628 device->device_state = STATE_ADDRESSED; 629 break; 630 631 case DEVICE_CONFIGURED: 632 device->device_state = STATE_CONFIGURED; 633 break; 634 635 case DEVICE_DE_CONFIGURED: 636 device->device_state = STATE_ADDRESSED; 637 break; 638 639 case DEVICE_BUS_INACTIVE: 640 if (device->status != USBD_CLOSING) { 641 device->status = USBD_SUSPENDED; 642 } 643 break; 644 case DEVICE_BUS_ACTIVITY: 645 if (device->status != USBD_CLOSING) { 646 device->status = USBD_OK; 647 } 648 break; 649 650 case DEVICE_SET_INTERFACE: 651 break; 652 case DEVICE_SET_FEATURE: 653 break; 654 case DEVICE_CLEAR_FEATURE: 655 break; 656 657 case DEVICE_POWER_INTERRUPTION: 658 device->device_state = STATE_POWERED; 659 break; 660 case DEVICE_HUB_RESET: 661 device->device_state = STATE_ATTACHED; 662 break; 663 case DEVICE_DESTROY: 664 device->device_state = STATE_UNKNOWN; 665 break; 666 667 case DEVICE_FUNCTION_PRIVATE: 668 break; 669 670 default: 671 usbdbg("event %d - not handled",event); 672 break; 673 } 674 debug("%s event: %d oldstate: %d newstate: %d status: %d address: %d", 675 device->name, event, state, 676 device->device_state, device->status, device->address); 677 678 /* tell the bus interface driver */ 679 if( device->event ) { 680 /* usbdbg("calling device->event"); */ 681 device->event(device, event, data); 682 } 683 } 684