1 /* 2 * (C) Copyright 2003 3 * Gerry Hamel, geh@ti.com, Texas Instruments 4 * 5 * (C) Copyright 2006 6 * Bryan O'Donoghue, bodonoghue@codehermit.ie 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 */ 23 24 #include <common.h> 25 #include <config.h> 26 #include <circbuf.h> 27 #include <stdio_dev.h> 28 #include <asm/unaligned.h> 29 #include "usbtty.h" 30 #include "usb_cdc_acm.h" 31 #include "usbdescriptors.h" 32 33 #ifdef DEBUG 34 #define TTYDBG(fmt,args...)\ 35 serial_printf("[%s] %s %d: "fmt, __FILE__,__FUNCTION__,__LINE__,##args) 36 #else 37 #define TTYDBG(fmt,args...) do{}while(0) 38 #endif 39 40 #if 1 41 #define TTYERR(fmt,args...)\ 42 serial_printf("ERROR![%s] %s %d: "fmt, __FILE__,__FUNCTION__,\ 43 __LINE__,##args) 44 #else 45 #define TTYERR(fmt,args...) do{}while(0) 46 #endif 47 48 /* 49 * Defines 50 */ 51 #define NUM_CONFIGS 1 52 #define MAX_INTERFACES 2 53 #define NUM_ENDPOINTS 3 54 #define ACM_TX_ENDPOINT 3 55 #define ACM_RX_ENDPOINT 2 56 #define GSERIAL_TX_ENDPOINT 2 57 #define GSERIAL_RX_ENDPOINT 1 58 #define NUM_ACM_INTERFACES 2 59 #define NUM_GSERIAL_INTERFACES 1 60 #define CONFIG_USBD_DATA_INTERFACE_STR "Bulk Data Interface" 61 #define CONFIG_USBD_CTRL_INTERFACE_STR "Control Interface" 62 63 /* 64 * Buffers to hold input and output data 65 */ 66 #define USBTTY_BUFFER_SIZE 2048 67 static circbuf_t usbtty_input; 68 static circbuf_t usbtty_output; 69 70 71 /* 72 * Instance variables 73 */ 74 static struct stdio_dev usbttydev; 75 static struct usb_device_instance device_instance[1]; 76 static struct usb_bus_instance bus_instance[1]; 77 static struct usb_configuration_instance config_instance[NUM_CONFIGS]; 78 static struct usb_interface_instance interface_instance[MAX_INTERFACES]; 79 static struct usb_alternate_instance alternate_instance[MAX_INTERFACES]; 80 /* one extra for control endpoint */ 81 static struct usb_endpoint_instance endpoint_instance[NUM_ENDPOINTS+1]; 82 83 /* 84 * Global flag 85 */ 86 int usbtty_configured_flag = 0; 87 88 /* 89 * Serial number 90 */ 91 static char serial_number[16]; 92 93 94 /* 95 * Descriptors, Strings, Local variables. 96 */ 97 98 /* defined and used by gadget/ep0.c */ 99 extern struct usb_string_descriptor **usb_strings; 100 101 /* Indicies, References */ 102 static unsigned short rx_endpoint = 0; 103 static unsigned short tx_endpoint = 0; 104 static unsigned short interface_count = 0; 105 static struct usb_string_descriptor *usbtty_string_table[STR_COUNT]; 106 107 /* USB Descriptor Strings */ 108 static u8 wstrLang[4] = {4,USB_DT_STRING,0x9,0x4}; 109 static u8 wstrManufacturer[2 + 2*(sizeof(CONFIG_USBD_MANUFACTURER)-1)]; 110 static u8 wstrProduct[2 + 2*(sizeof(CONFIG_USBD_PRODUCT_NAME)-1)]; 111 static u8 wstrSerial[2 + 2*(sizeof(serial_number) - 1)]; 112 static u8 wstrConfiguration[2 + 2*(sizeof(CONFIG_USBD_CONFIGURATION_STR)-1)]; 113 static u8 wstrDataInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)]; 114 static u8 wstrCtrlInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)]; 115 116 /* Standard USB Data Structures */ 117 static struct usb_interface_descriptor interface_descriptors[MAX_INTERFACES]; 118 static struct usb_endpoint_descriptor *ep_descriptor_ptrs[NUM_ENDPOINTS]; 119 static struct usb_configuration_descriptor *configuration_descriptor = 0; 120 static struct usb_device_descriptor device_descriptor = { 121 .bLength = sizeof(struct usb_device_descriptor), 122 .bDescriptorType = USB_DT_DEVICE, 123 .bcdUSB = cpu_to_le16(USB_BCD_VERSION), 124 .bDeviceSubClass = 0x00, 125 .bDeviceProtocol = 0x00, 126 .bMaxPacketSize0 = EP0_MAX_PACKET_SIZE, 127 .idVendor = cpu_to_le16(CONFIG_USBD_VENDORID), 128 .bcdDevice = cpu_to_le16(USBTTY_BCD_DEVICE), 129 .iManufacturer = STR_MANUFACTURER, 130 .iProduct = STR_PRODUCT, 131 .iSerialNumber = STR_SERIAL, 132 .bNumConfigurations = NUM_CONFIGS 133 }; 134 135 136 #if defined(CONFIG_USBD_HS) 137 static struct usb_qualifier_descriptor qualifier_descriptor = { 138 .bLength = sizeof(struct usb_qualifier_descriptor), 139 .bDescriptorType = USB_DT_QUAL, 140 .bcdUSB = cpu_to_le16(USB_BCD_VERSION), 141 .bDeviceClass = COMMUNICATIONS_DEVICE_CLASS, 142 .bDeviceSubClass = 0x00, 143 .bDeviceProtocol = 0x00, 144 .bMaxPacketSize0 = EP0_MAX_PACKET_SIZE, 145 .bNumConfigurations = NUM_CONFIGS 146 }; 147 #endif 148 149 /* 150 * Static CDC ACM specific descriptors 151 */ 152 153 struct acm_config_desc { 154 struct usb_configuration_descriptor configuration_desc; 155 156 /* Master Interface */ 157 struct usb_interface_descriptor interface_desc; 158 159 struct usb_class_header_function_descriptor usb_class_header; 160 struct usb_class_call_management_descriptor usb_class_call_mgt; 161 struct usb_class_abstract_control_descriptor usb_class_acm; 162 struct usb_class_union_function_descriptor usb_class_union; 163 struct usb_endpoint_descriptor notification_endpoint; 164 165 /* Slave Interface */ 166 struct usb_interface_descriptor data_class_interface; 167 struct usb_endpoint_descriptor data_endpoints[NUM_ENDPOINTS-1]; 168 } __attribute__((packed)); 169 170 static struct acm_config_desc acm_configuration_descriptors[NUM_CONFIGS] = { 171 { 172 .configuration_desc ={ 173 .bLength = 174 sizeof(struct usb_configuration_descriptor), 175 .bDescriptorType = USB_DT_CONFIG, 176 .wTotalLength = 177 cpu_to_le16(sizeof(struct acm_config_desc)), 178 .bNumInterfaces = NUM_ACM_INTERFACES, 179 .bConfigurationValue = 1, 180 .iConfiguration = STR_CONFIG, 181 .bmAttributes = 182 BMATTRIBUTE_SELF_POWERED|BMATTRIBUTE_RESERVED, 183 .bMaxPower = USBTTY_MAXPOWER 184 }, 185 /* Interface 1 */ 186 .interface_desc = { 187 .bLength = sizeof(struct usb_interface_descriptor), 188 .bDescriptorType = USB_DT_INTERFACE, 189 .bInterfaceNumber = 0, 190 .bAlternateSetting = 0, 191 .bNumEndpoints = 0x01, 192 .bInterfaceClass = 193 COMMUNICATIONS_INTERFACE_CLASS_CONTROL, 194 .bInterfaceSubClass = COMMUNICATIONS_ACM_SUBCLASS, 195 .bInterfaceProtocol = COMMUNICATIONS_V25TER_PROTOCOL, 196 .iInterface = STR_CTRL_INTERFACE, 197 }, 198 .usb_class_header = { 199 .bFunctionLength = 200 sizeof(struct usb_class_header_function_descriptor), 201 .bDescriptorType = CS_INTERFACE, 202 .bDescriptorSubtype = USB_ST_HEADER, 203 .bcdCDC = cpu_to_le16(110), 204 }, 205 .usb_class_call_mgt = { 206 .bFunctionLength = 207 sizeof(struct usb_class_call_management_descriptor), 208 .bDescriptorType = CS_INTERFACE, 209 .bDescriptorSubtype = USB_ST_CMF, 210 .bmCapabilities = 0x00, 211 .bDataInterface = 0x01, 212 }, 213 .usb_class_acm = { 214 .bFunctionLength = 215 sizeof(struct usb_class_abstract_control_descriptor), 216 .bDescriptorType = CS_INTERFACE, 217 .bDescriptorSubtype = USB_ST_ACMF, 218 .bmCapabilities = 0x00, 219 }, 220 .usb_class_union = { 221 .bFunctionLength = 222 sizeof(struct usb_class_union_function_descriptor), 223 .bDescriptorType = CS_INTERFACE, 224 .bDescriptorSubtype = USB_ST_UF, 225 .bMasterInterface = 0x00, 226 .bSlaveInterface0 = 0x01, 227 }, 228 .notification_endpoint = { 229 .bLength = 230 sizeof(struct usb_endpoint_descriptor), 231 .bDescriptorType = USB_DT_ENDPOINT, 232 .bEndpointAddress = UDC_INT_ENDPOINT | USB_DIR_IN, 233 .bmAttributes = USB_ENDPOINT_XFER_INT, 234 .wMaxPacketSize 235 = cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE), 236 .bInterval = 0xFF, 237 }, 238 239 /* Interface 2 */ 240 .data_class_interface = { 241 .bLength = 242 sizeof(struct usb_interface_descriptor), 243 .bDescriptorType = USB_DT_INTERFACE, 244 .bInterfaceNumber = 0x01, 245 .bAlternateSetting = 0x00, 246 .bNumEndpoints = 0x02, 247 .bInterfaceClass = 248 COMMUNICATIONS_INTERFACE_CLASS_DATA, 249 .bInterfaceSubClass = DATA_INTERFACE_SUBCLASS_NONE, 250 .bInterfaceProtocol = DATA_INTERFACE_PROTOCOL_NONE, 251 .iInterface = STR_DATA_INTERFACE, 252 }, 253 .data_endpoints = { 254 { 255 .bLength = 256 sizeof(struct usb_endpoint_descriptor), 257 .bDescriptorType = USB_DT_ENDPOINT, 258 .bEndpointAddress = UDC_OUT_ENDPOINT | USB_DIR_OUT, 259 .bmAttributes = 260 USB_ENDPOINT_XFER_BULK, 261 .wMaxPacketSize = 262 cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE), 263 .bInterval = 0xFF, 264 }, 265 { 266 .bLength = 267 sizeof(struct usb_endpoint_descriptor), 268 .bDescriptorType = USB_DT_ENDPOINT, 269 .bEndpointAddress = UDC_IN_ENDPOINT | USB_DIR_IN, 270 .bmAttributes = 271 USB_ENDPOINT_XFER_BULK, 272 .wMaxPacketSize = 273 cpu_to_le16(CONFIG_USBD_SERIAL_BULK_PKTSIZE), 274 .bInterval = 0xFF, 275 }, 276 }, 277 }, 278 }; 279 280 static struct rs232_emu rs232_desc={ 281 .dter = 115200, 282 .stop_bits = 0x00, 283 .parity = 0x00, 284 .data_bits = 0x08 285 }; 286 287 288 /* 289 * Static Generic Serial specific data 290 */ 291 292 293 struct gserial_config_desc { 294 295 struct usb_configuration_descriptor configuration_desc; 296 struct usb_interface_descriptor interface_desc[NUM_GSERIAL_INTERFACES]; 297 struct usb_endpoint_descriptor data_endpoints[NUM_ENDPOINTS]; 298 299 } __attribute__((packed)); 300 301 static struct gserial_config_desc 302 gserial_configuration_descriptors[NUM_CONFIGS] ={ 303 { 304 .configuration_desc ={ 305 .bLength = sizeof(struct usb_configuration_descriptor), 306 .bDescriptorType = USB_DT_CONFIG, 307 .wTotalLength = 308 cpu_to_le16(sizeof(struct gserial_config_desc)), 309 .bNumInterfaces = NUM_GSERIAL_INTERFACES, 310 .bConfigurationValue = 1, 311 .iConfiguration = STR_CONFIG, 312 .bmAttributes = 313 BMATTRIBUTE_SELF_POWERED|BMATTRIBUTE_RESERVED, 314 .bMaxPower = USBTTY_MAXPOWER 315 }, 316 .interface_desc = { 317 { 318 .bLength = 319 sizeof(struct usb_interface_descriptor), 320 .bDescriptorType = USB_DT_INTERFACE, 321 .bInterfaceNumber = 0, 322 .bAlternateSetting = 0, 323 .bNumEndpoints = NUM_ENDPOINTS, 324 .bInterfaceClass = 325 COMMUNICATIONS_INTERFACE_CLASS_VENDOR, 326 .bInterfaceSubClass = 327 COMMUNICATIONS_NO_SUBCLASS, 328 .bInterfaceProtocol = 329 COMMUNICATIONS_NO_PROTOCOL, 330 .iInterface = STR_DATA_INTERFACE 331 }, 332 }, 333 .data_endpoints = { 334 { 335 .bLength = 336 sizeof(struct usb_endpoint_descriptor), 337 .bDescriptorType = USB_DT_ENDPOINT, 338 .bEndpointAddress = UDC_OUT_ENDPOINT | USB_DIR_OUT, 339 .bmAttributes = USB_ENDPOINT_XFER_BULK, 340 .wMaxPacketSize = 341 cpu_to_le16(CONFIG_USBD_SERIAL_OUT_PKTSIZE), 342 .bInterval= 0xFF, 343 }, 344 { 345 .bLength = 346 sizeof(struct usb_endpoint_descriptor), 347 .bDescriptorType = USB_DT_ENDPOINT, 348 .bEndpointAddress = UDC_IN_ENDPOINT | USB_DIR_IN, 349 .bmAttributes = USB_ENDPOINT_XFER_BULK, 350 .wMaxPacketSize = 351 cpu_to_le16(CONFIG_USBD_SERIAL_IN_PKTSIZE), 352 .bInterval = 0xFF, 353 }, 354 { 355 .bLength = 356 sizeof(struct usb_endpoint_descriptor), 357 .bDescriptorType = USB_DT_ENDPOINT, 358 .bEndpointAddress = UDC_INT_ENDPOINT | USB_DIR_IN, 359 .bmAttributes = USB_ENDPOINT_XFER_INT, 360 .wMaxPacketSize = 361 cpu_to_le16(CONFIG_USBD_SERIAL_INT_PKTSIZE), 362 .bInterval = 0xFF, 363 }, 364 }, 365 }, 366 }; 367 368 /* 369 * Static Function Prototypes 370 */ 371 372 static void usbtty_init_strings (void); 373 static void usbtty_init_instances (void); 374 static void usbtty_init_endpoints (void); 375 static void usbtty_init_terminal_type(short type); 376 static void usbtty_event_handler (struct usb_device_instance *device, 377 usb_device_event_t event, int data); 378 static int usbtty_cdc_setup(struct usb_device_request *request, 379 struct urb *urb); 380 static int usbtty_configured (void); 381 static int write_buffer (circbuf_t * buf); 382 static int fill_buffer (circbuf_t * buf); 383 384 void usbtty_poll (void); 385 386 /* utility function for converting char* to wide string used by USB */ 387 static void str2wide (char *str, u16 * wide) 388 { 389 int i; 390 for (i = 0; i < strlen (str) && str[i]; i++){ 391 #if defined(__LITTLE_ENDIAN) 392 wide[i] = (u16) str[i]; 393 #elif defined(__BIG_ENDIAN) 394 wide[i] = ((u16)(str[i])<<8); 395 #else 396 #error "__LITTLE_ENDIAN or __BIG_ENDIAN undefined" 397 #endif 398 } 399 } 400 401 /* 402 * Test whether a character is in the RX buffer 403 */ 404 405 int usbtty_tstc (void) 406 { 407 struct usb_endpoint_instance *endpoint = 408 &endpoint_instance[rx_endpoint]; 409 410 /* If no input data exists, allow more RX to be accepted */ 411 if(usbtty_input.size <= 0){ 412 udc_unset_nak(endpoint->endpoint_address&0x03); 413 } 414 415 usbtty_poll (); 416 return (usbtty_input.size > 0); 417 } 418 419 /* 420 * Read a single byte from the usb client port. Returns 1 on success, 0 421 * otherwise. When the function is succesfull, the character read is 422 * written into its argument c. 423 */ 424 425 int usbtty_getc (void) 426 { 427 char c; 428 struct usb_endpoint_instance *endpoint = 429 &endpoint_instance[rx_endpoint]; 430 431 while (usbtty_input.size <= 0) { 432 udc_unset_nak(endpoint->endpoint_address&0x03); 433 usbtty_poll (); 434 } 435 436 buf_pop (&usbtty_input, &c, 1); 437 udc_set_nak(endpoint->endpoint_address&0x03); 438 439 return c; 440 } 441 442 /* 443 * Output a single byte to the usb client port. 444 */ 445 void usbtty_putc (const char c) 446 { 447 if (!usbtty_configured ()) 448 return; 449 450 buf_push (&usbtty_output, &c, 1); 451 /* If \n, also do \r */ 452 if (c == '\n') 453 buf_push (&usbtty_output, "\r", 1); 454 455 /* Poll at end to handle new data... */ 456 if ((usbtty_output.size + 2) >= usbtty_output.totalsize) { 457 usbtty_poll (); 458 } 459 } 460 461 /* usbtty_puts() helper function for finding the next '\n' in a string */ 462 static int next_nl_pos (const char *s) 463 { 464 int i; 465 466 for (i = 0; s[i] != '\0'; i++) { 467 if (s[i] == '\n') 468 return i; 469 } 470 return i; 471 } 472 473 /* 474 * Output a string to the usb client port - implementing flow control 475 */ 476 477 static void __usbtty_puts (const char *str, int len) 478 { 479 int maxlen = usbtty_output.totalsize; 480 int space, n; 481 482 /* break str into chunks < buffer size, if needed */ 483 while (len > 0) { 484 usbtty_poll (); 485 486 space = maxlen - usbtty_output.size; 487 /* Empty buffer here, if needed, to ensure space... */ 488 if (space) { 489 write_buffer (&usbtty_output); 490 491 n = MIN (space, MIN (len, maxlen)); 492 buf_push (&usbtty_output, str, n); 493 494 str += n; 495 len -= n; 496 } 497 } 498 } 499 500 void usbtty_puts (const char *str) 501 { 502 int n; 503 int len; 504 505 if (!usbtty_configured ()) 506 return; 507 508 len = strlen (str); 509 /* add '\r' for each '\n' */ 510 while (len > 0) { 511 n = next_nl_pos (str); 512 513 if (str[n] == '\n') { 514 __usbtty_puts (str, n + 1); 515 __usbtty_puts ("\r", 1); 516 str += (n + 1); 517 len -= (n + 1); 518 } else { 519 /* No \n found. All done. */ 520 __usbtty_puts (str, n); 521 break; 522 } 523 } 524 525 /* Poll at end to handle new data... */ 526 usbtty_poll (); 527 } 528 529 /* 530 * Initialize the usb client port. 531 * 532 */ 533 int drv_usbtty_init (void) 534 { 535 int rc; 536 char * sn; 537 char * tt; 538 int snlen; 539 540 /* Ger seiral number */ 541 if (!(sn = getenv("serial#"))) { 542 sn = "000000000000"; 543 } 544 snlen = strlen(sn); 545 if (snlen > sizeof(serial_number) - 1) { 546 printf ("Warning: serial number %s is too long (%d > %lu)\n", 547 sn, snlen, (ulong)(sizeof(serial_number) - 1)); 548 snlen = sizeof(serial_number) - 1; 549 } 550 memcpy (serial_number, sn, snlen); 551 serial_number[snlen] = '\0'; 552 553 /* Decide on which type of UDC device to be. 554 */ 555 556 if(!(tt = getenv("usbtty"))) { 557 tt = "generic"; 558 } 559 usbtty_init_terminal_type(strcmp(tt,"cdc_acm")); 560 561 /* prepare buffers... */ 562 buf_init (&usbtty_input, USBTTY_BUFFER_SIZE); 563 buf_init (&usbtty_output, USBTTY_BUFFER_SIZE); 564 565 /* Now, set up USB controller and infrastructure */ 566 udc_init (); /* Basic USB initialization */ 567 568 usbtty_init_strings (); 569 usbtty_init_instances (); 570 571 usbtty_init_endpoints (); 572 573 udc_startup_events (device_instance);/* Enable dev, init udc pointers */ 574 udc_connect (); /* Enable pullup for host detection */ 575 576 /* Device initialization */ 577 memset (&usbttydev, 0, sizeof (usbttydev)); 578 579 strcpy (usbttydev.name, "usbtty"); 580 usbttydev.ext = 0; /* No extensions */ 581 usbttydev.flags = DEV_FLAGS_INPUT | DEV_FLAGS_OUTPUT; 582 usbttydev.tstc = usbtty_tstc; /* 'tstc' function */ 583 usbttydev.getc = usbtty_getc; /* 'getc' function */ 584 usbttydev.putc = usbtty_putc; /* 'putc' function */ 585 usbttydev.puts = usbtty_puts; /* 'puts' function */ 586 587 rc = stdio_register (&usbttydev); 588 589 return (rc == 0) ? 1 : rc; 590 } 591 592 static void usbtty_init_strings (void) 593 { 594 struct usb_string_descriptor *string; 595 596 usbtty_string_table[STR_LANG] = 597 (struct usb_string_descriptor*)wstrLang; 598 599 string = (struct usb_string_descriptor *) wstrManufacturer; 600 string->bLength = sizeof(wstrManufacturer); 601 string->bDescriptorType = USB_DT_STRING; 602 str2wide (CONFIG_USBD_MANUFACTURER, string->wData); 603 usbtty_string_table[STR_MANUFACTURER]=string; 604 605 606 string = (struct usb_string_descriptor *) wstrProduct; 607 string->bLength = sizeof(wstrProduct); 608 string->bDescriptorType = USB_DT_STRING; 609 str2wide (CONFIG_USBD_PRODUCT_NAME, string->wData); 610 usbtty_string_table[STR_PRODUCT]=string; 611 612 613 string = (struct usb_string_descriptor *) wstrSerial; 614 string->bLength = sizeof(serial_number); 615 string->bDescriptorType = USB_DT_STRING; 616 str2wide (serial_number, string->wData); 617 usbtty_string_table[STR_SERIAL]=string; 618 619 620 string = (struct usb_string_descriptor *) wstrConfiguration; 621 string->bLength = sizeof(wstrConfiguration); 622 string->bDescriptorType = USB_DT_STRING; 623 str2wide (CONFIG_USBD_CONFIGURATION_STR, string->wData); 624 usbtty_string_table[STR_CONFIG]=string; 625 626 627 string = (struct usb_string_descriptor *) wstrDataInterface; 628 string->bLength = sizeof(wstrDataInterface); 629 string->bDescriptorType = USB_DT_STRING; 630 str2wide (CONFIG_USBD_DATA_INTERFACE_STR, string->wData); 631 usbtty_string_table[STR_DATA_INTERFACE]=string; 632 633 string = (struct usb_string_descriptor *) wstrCtrlInterface; 634 string->bLength = sizeof(wstrCtrlInterface); 635 string->bDescriptorType = USB_DT_STRING; 636 str2wide (CONFIG_USBD_CTRL_INTERFACE_STR, string->wData); 637 usbtty_string_table[STR_CTRL_INTERFACE]=string; 638 639 /* Now, initialize the string table for ep0 handling */ 640 usb_strings = usbtty_string_table; 641 } 642 643 #define init_wMaxPacketSize(x) le16_to_cpu(get_unaligned(\ 644 &ep_descriptor_ptrs[(x) - 1]->wMaxPacketSize)); 645 646 static void usbtty_init_instances (void) 647 { 648 int i; 649 650 /* initialize device instance */ 651 memset (device_instance, 0, sizeof (struct usb_device_instance)); 652 device_instance->device_state = STATE_INIT; 653 device_instance->device_descriptor = &device_descriptor; 654 #if defined(CONFIG_USBD_HS) 655 device_instance->qualifier_descriptor = &qualifier_descriptor; 656 #endif 657 device_instance->event = usbtty_event_handler; 658 device_instance->cdc_recv_setup = usbtty_cdc_setup; 659 device_instance->bus = bus_instance; 660 device_instance->configurations = NUM_CONFIGS; 661 device_instance->configuration_instance_array = config_instance; 662 663 /* initialize bus instance */ 664 memset (bus_instance, 0, sizeof (struct usb_bus_instance)); 665 bus_instance->device = device_instance; 666 bus_instance->endpoint_array = endpoint_instance; 667 bus_instance->max_endpoints = 1; 668 bus_instance->maxpacketsize = 64; 669 bus_instance->serial_number_str = serial_number; 670 671 /* configuration instance */ 672 memset (config_instance, 0, 673 sizeof (struct usb_configuration_instance)); 674 config_instance->interfaces = interface_count; 675 config_instance->configuration_descriptor = configuration_descriptor; 676 config_instance->interface_instance_array = interface_instance; 677 678 /* interface instance */ 679 memset (interface_instance, 0, 680 sizeof (struct usb_interface_instance)); 681 interface_instance->alternates = 1; 682 interface_instance->alternates_instance_array = alternate_instance; 683 684 /* alternates instance */ 685 memset (alternate_instance, 0, 686 sizeof (struct usb_alternate_instance)); 687 alternate_instance->interface_descriptor = interface_descriptors; 688 alternate_instance->endpoints = NUM_ENDPOINTS; 689 alternate_instance->endpoints_descriptor_array = ep_descriptor_ptrs; 690 691 /* endpoint instances */ 692 memset (&endpoint_instance[0], 0, 693 sizeof (struct usb_endpoint_instance)); 694 endpoint_instance[0].endpoint_address = 0; 695 endpoint_instance[0].rcv_packetSize = EP0_MAX_PACKET_SIZE; 696 endpoint_instance[0].rcv_attributes = USB_ENDPOINT_XFER_CONTROL; 697 endpoint_instance[0].tx_packetSize = EP0_MAX_PACKET_SIZE; 698 endpoint_instance[0].tx_attributes = USB_ENDPOINT_XFER_CONTROL; 699 udc_setup_ep (device_instance, 0, &endpoint_instance[0]); 700 701 for (i = 1; i <= NUM_ENDPOINTS; i++) { 702 memset (&endpoint_instance[i], 0, 703 sizeof (struct usb_endpoint_instance)); 704 705 endpoint_instance[i].endpoint_address = 706 ep_descriptor_ptrs[i - 1]->bEndpointAddress; 707 708 endpoint_instance[i].rcv_attributes = 709 ep_descriptor_ptrs[i - 1]->bmAttributes; 710 711 endpoint_instance[i].rcv_packetSize = init_wMaxPacketSize(i); 712 713 endpoint_instance[i].tx_attributes = 714 ep_descriptor_ptrs[i - 1]->bmAttributes; 715 716 endpoint_instance[i].tx_packetSize = init_wMaxPacketSize(i); 717 718 endpoint_instance[i].tx_attributes = 719 ep_descriptor_ptrs[i - 1]->bmAttributes; 720 721 urb_link_init (&endpoint_instance[i].rcv); 722 urb_link_init (&endpoint_instance[i].rdy); 723 urb_link_init (&endpoint_instance[i].tx); 724 urb_link_init (&endpoint_instance[i].done); 725 726 if (endpoint_instance[i].endpoint_address & USB_DIR_IN) 727 endpoint_instance[i].tx_urb = 728 usbd_alloc_urb (device_instance, 729 &endpoint_instance[i]); 730 else 731 endpoint_instance[i].rcv_urb = 732 usbd_alloc_urb (device_instance, 733 &endpoint_instance[i]); 734 } 735 } 736 737 static void usbtty_init_endpoints (void) 738 { 739 int i; 740 741 bus_instance->max_endpoints = NUM_ENDPOINTS + 1; 742 for (i = 1; i <= NUM_ENDPOINTS; i++) { 743 udc_setup_ep (device_instance, i, &endpoint_instance[i]); 744 } 745 } 746 747 /* usbtty_init_terminal_type 748 * 749 * Do some late binding for our device type. 750 */ 751 static void usbtty_init_terminal_type(short type) 752 { 753 switch(type){ 754 /* CDC ACM */ 755 case 0: 756 /* Assign endpoint descriptors */ 757 ep_descriptor_ptrs[0] = 758 &acm_configuration_descriptors[0].notification_endpoint; 759 ep_descriptor_ptrs[1] = 760 &acm_configuration_descriptors[0].data_endpoints[0]; 761 ep_descriptor_ptrs[2] = 762 &acm_configuration_descriptors[0].data_endpoints[1]; 763 764 /* Enumerate Device Descriptor */ 765 device_descriptor.bDeviceClass = 766 COMMUNICATIONS_DEVICE_CLASS; 767 device_descriptor.idProduct = 768 cpu_to_le16(CONFIG_USBD_PRODUCTID_CDCACM); 769 770 #if defined(CONFIG_USBD_HS) 771 qualifier_descriptor.bDeviceClass = 772 COMMUNICATIONS_DEVICE_CLASS; 773 #endif 774 /* Assign endpoint indices */ 775 tx_endpoint = ACM_TX_ENDPOINT; 776 rx_endpoint = ACM_RX_ENDPOINT; 777 778 /* Configuration Descriptor */ 779 configuration_descriptor = 780 (struct usb_configuration_descriptor*) 781 &acm_configuration_descriptors; 782 783 /* Interface count */ 784 interface_count = NUM_ACM_INTERFACES; 785 break; 786 787 /* BULK IN/OUT & Default */ 788 case 1: 789 default: 790 /* Assign endpoint descriptors */ 791 ep_descriptor_ptrs[0] = 792 &gserial_configuration_descriptors[0].data_endpoints[0]; 793 ep_descriptor_ptrs[1] = 794 &gserial_configuration_descriptors[0].data_endpoints[1]; 795 ep_descriptor_ptrs[2] = 796 &gserial_configuration_descriptors[0].data_endpoints[2]; 797 798 /* Enumerate Device Descriptor */ 799 device_descriptor.bDeviceClass = 0xFF; 800 device_descriptor.idProduct = 801 cpu_to_le16(CONFIG_USBD_PRODUCTID_GSERIAL); 802 #if defined(CONFIG_USBD_HS) 803 qualifier_descriptor.bDeviceClass = 0xFF; 804 #endif 805 /* Assign endpoint indices */ 806 tx_endpoint = GSERIAL_TX_ENDPOINT; 807 rx_endpoint = GSERIAL_RX_ENDPOINT; 808 809 /* Configuration Descriptor */ 810 configuration_descriptor = 811 (struct usb_configuration_descriptor*) 812 &gserial_configuration_descriptors; 813 814 /* Interface count */ 815 interface_count = NUM_GSERIAL_INTERFACES; 816 break; 817 } 818 } 819 820 /******************************************************************************/ 821 822 static struct urb *next_urb (struct usb_device_instance *device, 823 struct usb_endpoint_instance *endpoint) 824 { 825 struct urb *current_urb = NULL; 826 int space; 827 828 /* If there's a queue, then we should add to the last urb */ 829 if (!endpoint->tx_queue) { 830 current_urb = endpoint->tx_urb; 831 } else { 832 /* Last urb from tx chain */ 833 current_urb = 834 p2surround (struct urb, link, endpoint->tx.prev); 835 } 836 837 /* Make sure this one has enough room */ 838 space = current_urb->buffer_length - current_urb->actual_length; 839 if (space > 0) { 840 return current_urb; 841 } else { /* No space here */ 842 /* First look at done list */ 843 current_urb = first_urb_detached (&endpoint->done); 844 if (!current_urb) { 845 current_urb = usbd_alloc_urb (device, endpoint); 846 } 847 848 urb_append (&endpoint->tx, current_urb); 849 endpoint->tx_queue++; 850 } 851 return current_urb; 852 } 853 854 static int write_buffer (circbuf_t * buf) 855 { 856 if (!usbtty_configured ()) { 857 return 0; 858 } 859 860 struct usb_endpoint_instance *endpoint = 861 &endpoint_instance[tx_endpoint]; 862 struct urb *current_urb = NULL; 863 864 current_urb = next_urb (device_instance, endpoint); 865 /* TX data still exists - send it now 866 */ 867 if(endpoint->sent < current_urb->actual_length){ 868 if(udc_endpoint_write (endpoint)){ 869 /* Write pre-empted by RX */ 870 return -1; 871 } 872 } 873 874 if (buf->size) { 875 char *dest; 876 877 int space_avail; 878 int popnum, popped; 879 int total = 0; 880 881 /* Break buffer into urb sized pieces, 882 * and link each to the endpoint 883 */ 884 while (buf->size > 0) { 885 886 if (!current_urb) { 887 TTYERR ("current_urb is NULL, buf->size %d\n", 888 buf->size); 889 return total; 890 } 891 892 dest = (char*)current_urb->buffer + 893 current_urb->actual_length; 894 895 space_avail = 896 current_urb->buffer_length - 897 current_urb->actual_length; 898 popnum = MIN (space_avail, buf->size); 899 if (popnum == 0) 900 break; 901 902 popped = buf_pop (buf, dest, popnum); 903 if (popped == 0) 904 break; 905 current_urb->actual_length += popped; 906 total += popped; 907 908 /* If endpoint->last == 0, then transfers have 909 * not started on this endpoint 910 */ 911 if (endpoint->last == 0) { 912 if(udc_endpoint_write (endpoint)){ 913 /* Write pre-empted by RX */ 914 return -1; 915 } 916 } 917 918 }/* end while */ 919 return total; 920 } 921 922 return 0; 923 } 924 925 static int fill_buffer (circbuf_t * buf) 926 { 927 struct usb_endpoint_instance *endpoint = 928 &endpoint_instance[rx_endpoint]; 929 930 if (endpoint->rcv_urb && endpoint->rcv_urb->actual_length) { 931 unsigned int nb = 0; 932 char *src = (char *) endpoint->rcv_urb->buffer; 933 unsigned int rx_avail = buf->totalsize - buf->size; 934 935 if(rx_avail >= endpoint->rcv_urb->actual_length){ 936 937 nb = endpoint->rcv_urb->actual_length; 938 buf_push (buf, src, nb); 939 endpoint->rcv_urb->actual_length = 0; 940 941 } 942 return nb; 943 } 944 return 0; 945 } 946 947 static int usbtty_configured (void) 948 { 949 return usbtty_configured_flag; 950 } 951 952 /******************************************************************************/ 953 954 static void usbtty_event_handler (struct usb_device_instance *device, 955 usb_device_event_t event, int data) 956 { 957 #if defined(CONFIG_USBD_HS) 958 int i; 959 #endif 960 switch (event) { 961 case DEVICE_RESET: 962 case DEVICE_BUS_INACTIVE: 963 usbtty_configured_flag = 0; 964 break; 965 case DEVICE_CONFIGURED: 966 usbtty_configured_flag = 1; 967 break; 968 969 case DEVICE_ADDRESS_ASSIGNED: 970 #if defined(CONFIG_USBD_HS) 971 /* 972 * is_usbd_high_speed routine needs to be defined by 973 * specific gadget driver 974 * It returns true if device enumerates at High speed 975 * Retuns false otherwise 976 */ 977 for (i = 0; i < NUM_ENDPOINTS; i++) { 978 if (((ep_descriptor_ptrs[i]->bmAttributes & 979 USB_ENDPOINT_XFERTYPE_MASK) == 980 USB_ENDPOINT_XFER_BULK) 981 && is_usbd_high_speed()) { 982 983 ep_descriptor_ptrs[i]->wMaxPacketSize = 984 CONFIG_USBD_SERIAL_BULK_HS_PKTSIZE; 985 } 986 987 endpoint_instance[i + 1].tx_packetSize = 988 ep_descriptor_ptrs[i]->wMaxPacketSize; 989 endpoint_instance[i + 1].rcv_packetSize = 990 ep_descriptor_ptrs[i]->wMaxPacketSize; 991 } 992 #endif 993 usbtty_init_endpoints (); 994 995 default: 996 break; 997 } 998 } 999 1000 /******************************************************************************/ 1001 1002 int usbtty_cdc_setup(struct usb_device_request *request, struct urb *urb) 1003 { 1004 switch (request->bRequest){ 1005 1006 case ACM_SET_CONTROL_LINE_STATE: /* Implies DTE ready */ 1007 break; 1008 case ACM_SEND_ENCAPSULATED_COMMAND : /* Required */ 1009 break; 1010 case ACM_SET_LINE_ENCODING : /* DTE stop/parity bits 1011 * per character */ 1012 break; 1013 case ACM_GET_ENCAPSULATED_RESPONSE : /* request response */ 1014 break; 1015 case ACM_GET_LINE_ENCODING : /* request DTE rate, 1016 * stop/parity bits */ 1017 memcpy (urb->buffer , &rs232_desc, sizeof(rs232_desc)); 1018 urb->actual_length = sizeof(rs232_desc); 1019 1020 break; 1021 default: 1022 return 1; 1023 } 1024 return 0; 1025 } 1026 1027 /******************************************************************************/ 1028 1029 /* 1030 * Since interrupt handling has not yet been implemented, we use this function 1031 * to handle polling. This is called by the tstc,getc,putc,puts routines to 1032 * update the USB state. 1033 */ 1034 void usbtty_poll (void) 1035 { 1036 /* New interrupts? */ 1037 udc_irq(); 1038 1039 /* Write any output data to host buffer 1040 * (do this before checking interrupts to avoid missing one) 1041 */ 1042 if (usbtty_configured ()) { 1043 write_buffer (&usbtty_output); 1044 } 1045 1046 /* New interrupts? */ 1047 udc_irq(); 1048 1049 /* Check for new data from host.. 1050 * (do this after checking interrupts to get latest data) 1051 */ 1052 if (usbtty_configured ()) { 1053 fill_buffer (&usbtty_input); 1054 } 1055 1056 /* New interrupts? */ 1057 udc_irq(); 1058 1059 } 1060