uboot/drivers/serial/usbtty.c
<<
>>
Prefs
   1/*
   2 * (C) Copyright 2003
   3 * Gerry Hamel, geh@ti.com, Texas Instruments
   4 *
   5 * (C) Copyright 2006
   6 * Bryan O'Donoghue, bodonoghue@codehermit.ie
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License as published by
  10 * the Free Software Foundation; either version 2 of the License, or
  11 * (at your option) any later version.
  12 *
  13 * This program is distributed in the hope that it will be useful,
  14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 * GNU General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public License
  19 * along with this program; if not, write to the Free Software
  20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 *
  22 */
  23
  24#include <common.h>
  25#include <config.h>
  26#include <circbuf.h>
  27#include <stdio_dev.h>
  28#include "usbtty.h"
  29#include "usb_cdc_acm.h"
  30#include "usbdescriptors.h"
  31
  32#ifdef DEBUG
  33#define TTYDBG(fmt,args...)\
  34        serial_printf("[%s] %s %d: "fmt, __FILE__,__FUNCTION__,__LINE__,##args)
  35#else
  36#define TTYDBG(fmt,args...) do{}while(0)
  37#endif
  38
  39#if 1
  40#define TTYERR(fmt,args...)\
  41        serial_printf("ERROR![%s] %s %d: "fmt, __FILE__,__FUNCTION__,\
  42        __LINE__,##args)
  43#else
  44#define TTYERR(fmt,args...) do{}while(0)
  45#endif
  46
  47/*
  48 * Defines
  49 */
  50#define NUM_CONFIGS    1
  51#define MAX_INTERFACES 2
  52#define NUM_ENDPOINTS  3
  53#define ACM_TX_ENDPOINT 3
  54#define ACM_RX_ENDPOINT 2
  55#define GSERIAL_TX_ENDPOINT 2
  56#define GSERIAL_RX_ENDPOINT 1
  57#define NUM_ACM_INTERFACES 2
  58#define NUM_GSERIAL_INTERFACES 1
  59#define CONFIG_USBD_DATA_INTERFACE_STR "Bulk Data Interface"
  60#define CONFIG_USBD_CTRL_INTERFACE_STR "Control Interface"
  61
  62/*
  63 * Buffers to hold input and output data
  64 */
  65#define USBTTY_BUFFER_SIZE 256
  66static circbuf_t usbtty_input;
  67static circbuf_t usbtty_output;
  68
  69
  70/*
  71 * Instance variables
  72 */
  73static struct stdio_dev usbttydev;
  74static struct usb_device_instance device_instance[1];
  75static struct usb_bus_instance bus_instance[1];
  76static struct usb_configuration_instance config_instance[NUM_CONFIGS];
  77static struct usb_interface_instance interface_instance[MAX_INTERFACES];
  78static struct usb_alternate_instance alternate_instance[MAX_INTERFACES];
  79/* one extra for control endpoint */
  80static struct usb_endpoint_instance endpoint_instance[NUM_ENDPOINTS+1];
  81
  82/*
  83 * Global flag
  84 */
  85int usbtty_configured_flag = 0;
  86
  87/*
  88 * Serial number
  89 */
  90static char serial_number[16];
  91
  92
  93/*
  94 * Descriptors, Strings, Local variables.
  95 */
  96
  97/* defined and used by gadget/ep0.c */
  98extern struct usb_string_descriptor **usb_strings;
  99
 100/* Indicies, References */
 101static unsigned short rx_endpoint = 0;
 102static unsigned short tx_endpoint = 0;
 103static unsigned short interface_count = 0;
 104static struct usb_string_descriptor *usbtty_string_table[STR_COUNT];
 105
 106/* USB Descriptor Strings */
 107static u8 wstrLang[4] = {4,USB_DT_STRING,0x9,0x4};
 108static u8 wstrManufacturer[2 + 2*(sizeof(CONFIG_USBD_MANUFACTURER)-1)];
 109static u8 wstrProduct[2 + 2*(sizeof(CONFIG_USBD_PRODUCT_NAME)-1)];
 110static u8 wstrSerial[2 + 2*(sizeof(serial_number) - 1)];
 111static u8 wstrConfiguration[2 + 2*(sizeof(CONFIG_USBD_CONFIGURATION_STR)-1)];
 112static u8 wstrDataInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
 113static u8 wstrCtrlInterface[2 + 2*(sizeof(CONFIG_USBD_DATA_INTERFACE_STR)-1)];
 114
 115/* Standard USB Data Structures */
 116static struct usb_interface_descriptor interface_descriptors[MAX_INTERFACES];
 117static struct usb_endpoint_descriptor *ep_descriptor_ptrs[NUM_ENDPOINTS];
 118static struct usb_configuration_descriptor      *configuration_descriptor = 0;
 119static struct usb_device_descriptor device_descriptor = {
 120        .bLength = sizeof(struct usb_device_descriptor),
 121        .bDescriptorType =      USB_DT_DEVICE,
 122        .bcdUSB =               cpu_to_le16(USB_BCD_VERSION),
 123        .bDeviceSubClass =      0x00,
 124        .bDeviceProtocol =      0x00,
 125        .bMaxPacketSize0 =      EP0_MAX_PACKET_SIZE,
 126        .idVendor =             cpu_to_le16(CONFIG_USBD_VENDORID),
 127        .bcdDevice =            cpu_to_le16(USBTTY_BCD_DEVICE),
 128        .iManufacturer =        STR_MANUFACTURER,
 129        .iProduct =             STR_PRODUCT,
 130        .iSerialNumber =        STR_SERIAL,
 131        .bNumConfigurations =   NUM_CONFIGS
 132};
 133
 134
 135/*
 136 * Static CDC ACM specific descriptors
 137 */
 138
 139struct 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
 156static 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
 266static 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
 279struct 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
 287static struct gserial_config_desc
 288gserial_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
 358static void usbtty_init_strings (void);
 359static void usbtty_init_instances (void);
 360static void usbtty_init_endpoints (void);
 361static void usbtty_init_terminal_type(short type);
 362static void usbtty_event_handler (struct usb_device_instance *device,
 363                                usb_device_event_t event, int data);
 364static int usbtty_cdc_setup(struct usb_device_request *request,
 365                                struct urb *urb);
 366static int usbtty_configured (void);
 367static int write_buffer (circbuf_t * buf);
 368static int fill_buffer (circbuf_t * buf);
 369
 370void usbtty_poll (void);
 371
 372/* utility function for converting char* to wide string used by USB */
 373static 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
 391int usbtty_tstc (void)
 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
 411int usbtty_getc (void)
 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 */
 431void usbtty_putc (const char c)
 432{
 433        if (!usbtty_configured ())
 434                return;
 435
 436        buf_push (&usbtty_output, &c, 1);
 437        /* If \n, also do \r */
 438        if (c == '\n')
 439                buf_push (&usbtty_output, "\r", 1);
 440
 441        /* Poll at end to handle new data... */
 442        if ((usbtty_output.size + 2) >= usbtty_output.totalsize) {
 443                usbtty_poll ();
 444        }
 445}
 446
 447/* usbtty_puts() helper function for finding the next '\n' in a string */
 448static int next_nl_pos (const char *s)
 449{
 450        int i;
 451
 452        for (i = 0; s[i] != '\0'; i++) {
 453                if (s[i] == '\n')
 454                        return i;
 455        }
 456        return i;
 457}
 458
 459/*
 460 * Output a string to the usb client port - implementing flow control
 461 */
 462
 463static void __usbtty_puts (const char *str, int len)
 464{
 465        int maxlen = usbtty_output.totalsize;
 466        int space, n;
 467
 468        /* break str into chunks < buffer size, if needed */
 469        while (len > 0) {
 470                usbtty_poll ();
 471
 472                space = maxlen - usbtty_output.size;
 473                /* Empty buffer here, if needed, to ensure space... */
 474                if (space) {
 475                        write_buffer (&usbtty_output);
 476
 477                        n = MIN (space, MIN (len, maxlen));
 478                        buf_push (&usbtty_output, str, n);
 479
 480                        str += n;
 481                        len -= n;
 482                }
 483        }
 484}
 485
 486void usbtty_puts (const char *str)
 487{
 488        int n;
 489        int len;
 490
 491        if (!usbtty_configured ())
 492                return;
 493
 494        len = strlen (str);
 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 */
 519int 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 > %lu)\n",
 533                        sn, snlen, (ulong)(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 = stdio_register (&usbttydev);
 574
 575        return (rc == 0) ? 1 : rc;
 576}
 577
 578static 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
 629static 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
 719static 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 */
 733static 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
 798static 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
 830static 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
 901static 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
 923static int usbtty_configured (void)
 924{
 925        return usbtty_configured_flag;
 926}
 927
 928/******************************************************************************/
 929
 930static 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
 952int 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 */
 984void 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