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