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