git.sur5r.net Git - u-boot/blob - drivers/serial/usbtty.c

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