drivers/serial/usbtty.c

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