drivers/usb/gadget/serial.c

   1 /*
   2  * g_serial.c -- USB gadget serial driver
   3  *
   4  * Copyright 2003 (C) Al Borchers (alborchers@steinerpoint.com)
   5  *
   6  * This code is based in part on the Gadget Zero driver, which
   7  * is Copyright (C) 2003 by David Brownell, all rights reserved.
   8  *
   9  * This code also borrows from usbserial.c, which is
  10  * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
  11  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
  12  * Copyright (C) 2000 Al Borchers (alborchers@steinerpoint.com)
  13  *
  14  * This software is distributed under the terms of the GNU General
  15  * Public License ("GPL") as published by the Free Software Foundation,
  16  * either version 2 of that License or (at your option) any later version.
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/utsname.h>
  21 #include <linux/device.h>
  22 #include <linux/tty.h>
  23 #include <linux/tty_flip.h>
  24
  25 #include <linux/usb/ch9.h>
  26 #include <linux/usb/cdc.h>
  27 #include <linux/usb/gadget.h>
  28
  29 #include "gadget_chips.h"
  30
  31
  32 /* Defines */
  33
  34 #define GS_VERSION_STR                  "v2.2"
  35 #define GS_VERSION_NUM                  0x0202
  36
  37 #define GS_LONG_NAME                    "Gadget Serial"
  38 #define GS_SHORT_NAME                   "g_serial"
  39
  40 #define GS_MAJOR                        127
  41 #define GS_MINOR_START                  0
  42
  43 /* REVISIT only one port is supported for now;
  44  * see gs_{send,recv}_packet() ... no multiplexing,
  45  * and no support for multiple ACM devices.
  46  */
  47 #define GS_NUM_PORTS                    1
  48
  49 #define GS_NUM_CONFIGS                  1
  50 #define GS_NO_CONFIG_ID                 0
  51 #define GS_BULK_CONFIG_ID               1
  52 #define GS_ACM_CONFIG_ID                2
  53
  54 #define GS_MAX_NUM_INTERFACES           2
  55 #define GS_BULK_INTERFACE_ID            0
  56 #define GS_CONTROL_INTERFACE_ID         0
  57 #define GS_DATA_INTERFACE_ID            1
  58
  59 #define GS_MAX_DESC_LEN                 256
  60
  61 #define GS_DEFAULT_READ_Q_SIZE          32
  62 #define GS_DEFAULT_WRITE_Q_SIZE         32
  63
  64 #define GS_DEFAULT_WRITE_BUF_SIZE       8192
  65 #define GS_TMP_BUF_SIZE                 8192
  66
  67 #define GS_CLOSE_TIMEOUT                15
  68
  69 #define GS_DEFAULT_USE_ACM              0
  70
  71 /* 9600-8-N-1 ... matches init_termios.c_cflag and defaults
  72  * expected by "usbser.sys" on MS-Windows.
  73  */
  74 #define GS_DEFAULT_DTE_RATE             9600
  75 #define GS_DEFAULT_DATA_BITS            8
  76 #define GS_DEFAULT_PARITY               USB_CDC_NO_PARITY
  77 #define GS_DEFAULT_CHAR_FORMAT          USB_CDC_1_STOP_BITS
  78
  79 /* maxpacket and other transfer characteristics vary by speed. */
  80 static inline struct usb_endpoint_descriptor *
  81 choose_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
  82                 struct usb_endpoint_descriptor *fs)
  83 {
  84         if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
  85                 return hs;
  86         return fs;
  87 }
  88
  89
  90 /* debug settings */
  91 #ifdef DEBUG
  92 static int debug = 1;
  93 #else
  94 #define debug 0
  95 #endif
  96
  97 #define gs_debug(format, arg...) \
  98         do { if (debug) pr_debug(format, ## arg); } while (0)
  99 #define gs_debug_level(level, format, arg...) \
 100         do { if (debug >= level) pr_debug(format, ## arg); } while (0)
 101
 102
 103 /* Thanks to NetChip Technologies for donating this product ID.
 104  *
 105  * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
 106  * Instead:  allocate your own, using normal USB-IF procedures.
 107  */
 108 #define GS_VENDOR_ID                    0x0525  /* NetChip */
 109 #define GS_PRODUCT_ID                   0xa4a6  /* Linux-USB Serial Gadget */
 110 #define GS_CDC_PRODUCT_ID               0xa4a7  /* ... as CDC-ACM */
 111
 112 #define GS_LOG2_NOTIFY_INTERVAL         5       /* 1 << 5 == 32 msec */
 113 #define GS_NOTIFY_MAXPACKET             8
 114
 115
 116 /* circular buffer */
 117 struct gs_buf {
 118         unsigned int            buf_size;
 119         char                    *buf_buf;
 120         char                    *buf_get;
 121         char                    *buf_put;
 122 };
 123
 124 /* the port structure holds info for each port, one for each minor number */
 125 struct gs_port {
 126         struct gs_dev           *port_dev;      /* pointer to device struct */
 127         struct tty_struct       *port_tty;      /* pointer to tty struct */
 128         spinlock_t              port_lock;
 129         int                     port_num;
 130         int                     port_open_count;
 131         int                     port_in_use;    /* open/close in progress */
 132         wait_queue_head_t       port_write_wait;/* waiting to write */
 133         struct gs_buf           *port_write_buf;
 134         struct usb_cdc_line_coding port_line_coding;    /* 8-N-1 etc */
 135         u16                     port_handshake_bits;
 136 #define RS232_RTS       (1 << 1)
 137 #define RS232_DTE       (1 << 0)
 138 };
 139
 140 /* the device structure holds info for the USB device */
 141 struct gs_dev {
 142         struct usb_gadget       *dev_gadget;    /* gadget device pointer */
 143         spinlock_t              dev_lock;       /* lock for set/reset config */
 144         int                     dev_config;     /* configuration number */
 145         struct usb_ep           *dev_notify_ep; /* address of notify endpoint */
 146         struct usb_ep           *dev_in_ep;     /* address of in endpoint */
 147         struct usb_ep           *dev_out_ep;    /* address of out endpoint */
 148         struct usb_endpoint_descriptor          /* descriptor of notify ep */
 149                                 *dev_notify_ep_desc;
 150         struct usb_endpoint_descriptor          /* descriptor of in endpoint */
 151                                 *dev_in_ep_desc;
 152         struct usb_endpoint_descriptor          /* descriptor of out endpoint */
 153                                 *dev_out_ep_desc;
 154         struct usb_request      *dev_ctrl_req;  /* control request */
 155         struct list_head        dev_req_list;   /* list of write requests */
 156         int                     dev_sched_port; /* round robin port scheduled */
 157         struct gs_port          *dev_port[GS_NUM_PORTS]; /* the ports */
 158 };
 159
 160
 161 /* Functions */
 162
 163 /* tty driver internals */
 164 static int gs_send(struct gs_dev *dev);
 165 static int gs_send_packet(struct gs_dev *dev, char *packet,
 166         unsigned int size);
 167 static int gs_recv_packet(struct gs_dev *dev, char *packet,
 168         unsigned int size);
 169 static void gs_read_complete(struct usb_ep *ep, struct usb_request *req);
 170 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req);
 171
 172 /* gadget driver internals */
 173 static int gs_set_config(struct gs_dev *dev, unsigned config);
 174 static void gs_reset_config(struct gs_dev *dev);
 175 static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
 176                 u8 type, unsigned int index, int is_otg);
 177
 178 static struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned int len,
 179         gfp_t kmalloc_flags);
 180 static void gs_free_req(struct usb_ep *ep, struct usb_request *req);
 181
 182 static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags);
 183 static void gs_free_ports(struct gs_dev *dev);
 184
 185 /* circular buffer */
 186 static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags);
 187 static void gs_buf_free(struct gs_buf *gb);
 188 static void gs_buf_clear(struct gs_buf *gb);
 189 static unsigned int gs_buf_data_avail(struct gs_buf *gb);
 190 static unsigned int gs_buf_space_avail(struct gs_buf *gb);
 191 static unsigned int gs_buf_put(struct gs_buf *gb, const char *buf,
 192         unsigned int count);
 193 static unsigned int gs_buf_get(struct gs_buf *gb, char *buf,
 194         unsigned int count);
 195
 196
 197 /* Globals */
 198
 199 static struct gs_dev *gs_device;
 200
 201 static const char *EP_IN_NAME;
 202 static const char *EP_OUT_NAME;
 203 static const char *EP_NOTIFY_NAME;
 204
 205 static struct mutex gs_open_close_lock[GS_NUM_PORTS];
 206
 207
 208 /*-------------------------------------------------------------------------*/
 209
 210 /* USB descriptors */
 211
 212 #define GS_MANUFACTURER_STR_ID  1
 213 #define GS_PRODUCT_STR_ID       2
 214 #define GS_SERIAL_STR_ID        3
 215 #define GS_BULK_CONFIG_STR_ID   4
 216 #define GS_ACM_CONFIG_STR_ID    5
 217 #define GS_CONTROL_STR_ID       6
 218 #define GS_DATA_STR_ID          7
 219
 220 /* static strings, in UTF-8 */
 221 static char manufacturer[50];
 222 static struct usb_string gs_strings[] = {
 223         { GS_MANUFACTURER_STR_ID, manufacturer },
 224         { GS_PRODUCT_STR_ID, GS_LONG_NAME },
 225         { GS_SERIAL_STR_ID, "0" },
 226         { GS_BULK_CONFIG_STR_ID, "Gadget Serial Bulk" },
 227         { GS_ACM_CONFIG_STR_ID, "Gadget Serial CDC ACM" },
 228         { GS_CONTROL_STR_ID, "Gadget Serial Control" },
 229         { GS_DATA_STR_ID, "Gadget Serial Data" },
 230         {  } /* end of list */
 231 };
 232
 233 static struct usb_gadget_strings gs_string_table = {
 234         .language =             0x0409, /* en-us */
 235         .strings =              gs_strings,
 236 };
 237
 238 static struct usb_device_descriptor gs_device_desc = {
 239         .bLength =              USB_DT_DEVICE_SIZE,
 240         .bDescriptorType =      USB_DT_DEVICE,
 241         .bcdUSB =               __constant_cpu_to_le16(0x0200),
 242         .bDeviceSubClass =      0,
 243         .bDeviceProtocol =      0,
 244         .idVendor =             __constant_cpu_to_le16(GS_VENDOR_ID),
 245         .idProduct =            __constant_cpu_to_le16(GS_PRODUCT_ID),
 246         .iManufacturer =        GS_MANUFACTURER_STR_ID,
 247         .iProduct =             GS_PRODUCT_STR_ID,
 248         .iSerialNumber =        GS_SERIAL_STR_ID,
 249         .bNumConfigurations =   GS_NUM_CONFIGS,
 250 };
 251
 252 static struct usb_otg_descriptor gs_otg_descriptor = {
 253         .bLength =              sizeof(gs_otg_descriptor),
 254         .bDescriptorType =      USB_DT_OTG,
 255         .bmAttributes =         USB_OTG_SRP,
 256 };
 257
 258 static struct usb_config_descriptor gs_bulk_config_desc = {
 259         .bLength =              USB_DT_CONFIG_SIZE,
 260         .bDescriptorType =      USB_DT_CONFIG,
 261         /* .wTotalLength computed dynamically */
 262         .bNumInterfaces =       1,
 263         .bConfigurationValue =  GS_BULK_CONFIG_ID,
 264         .iConfiguration =       GS_BULK_CONFIG_STR_ID,
 265         .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 266         .bMaxPower =            1,
 267 };
 268
 269 static struct usb_config_descriptor gs_acm_config_desc = {
 270         .bLength =              USB_DT_CONFIG_SIZE,
 271         .bDescriptorType =      USB_DT_CONFIG,
 272         /* .wTotalLength computed dynamically */
 273         .bNumInterfaces =       2,
 274         .bConfigurationValue =  GS_ACM_CONFIG_ID,
 275         .iConfiguration =       GS_ACM_CONFIG_STR_ID,
 276         .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 277         .bMaxPower =            1,
 278 };
 279
 280 static const struct usb_interface_descriptor gs_bulk_interface_desc = {
 281         .bLength =              USB_DT_INTERFACE_SIZE,
 282         .bDescriptorType =      USB_DT_INTERFACE,
 283         .bInterfaceNumber =     GS_BULK_INTERFACE_ID,
 284         .bNumEndpoints =        2,
 285         .bInterfaceClass =      USB_CLASS_CDC_DATA,
 286         .bInterfaceSubClass =   0,
 287         .bInterfaceProtocol =   0,
 288         .iInterface =           GS_DATA_STR_ID,
 289 };
 290
 291 static const struct usb_interface_descriptor gs_control_interface_desc = {
 292         .bLength =              USB_DT_INTERFACE_SIZE,
 293         .bDescriptorType =      USB_DT_INTERFACE,
 294         .bInterfaceNumber =     GS_CONTROL_INTERFACE_ID,
 295         .bNumEndpoints =        1,
 296         .bInterfaceClass =      USB_CLASS_COMM,
 297         .bInterfaceSubClass =   USB_CDC_SUBCLASS_ACM,
 298         .bInterfaceProtocol =   USB_CDC_ACM_PROTO_AT_V25TER,
 299         .iInterface =           GS_CONTROL_STR_ID,
 300 };
 301
 302 static const struct usb_interface_descriptor gs_data_interface_desc = {
 303         .bLength =              USB_DT_INTERFACE_SIZE,
 304         .bDescriptorType =      USB_DT_INTERFACE,
 305         .bInterfaceNumber =     GS_DATA_INTERFACE_ID,
 306         .bNumEndpoints =        2,
 307         .bInterfaceClass =      USB_CLASS_CDC_DATA,
 308         .bInterfaceSubClass =   0,
 309         .bInterfaceProtocol =   0,
 310         .iInterface =           GS_DATA_STR_ID,
 311 };
 312
 313 static const struct usb_cdc_header_desc gs_header_desc = {
 314         .bLength =              sizeof(gs_header_desc),
 315         .bDescriptorType =      USB_DT_CS_INTERFACE,
 316         .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
 317         .bcdCDC =               __constant_cpu_to_le16(0x0110),
 318 };
 319
 320 static const struct usb_cdc_call_mgmt_descriptor gs_call_mgmt_descriptor = {
 321         .bLength =              sizeof(gs_call_mgmt_descriptor),
 322         .bDescriptorType =      USB_DT_CS_INTERFACE,
 323         .bDescriptorSubType =   USB_CDC_CALL_MANAGEMENT_TYPE,
 324         .bmCapabilities =       0,
 325         .bDataInterface =       1,      /* index of data interface */
 326 };
 327
 328 static struct usb_cdc_acm_descriptor gs_acm_descriptor = {
 329         .bLength =              sizeof(gs_acm_descriptor),
 330         .bDescriptorType =      USB_DT_CS_INTERFACE,
 331         .bDescriptorSubType =   USB_CDC_ACM_TYPE,
 332         .bmCapabilities =       (1 << 1),
 333 };
 334
 335 static const struct usb_cdc_union_desc gs_union_desc = {
 336         .bLength =              sizeof(gs_union_desc),
 337         .bDescriptorType =      USB_DT_CS_INTERFACE,
 338         .bDescriptorSubType =   USB_CDC_UNION_TYPE,
 339         .bMasterInterface0 =    0,      /* index of control interface */
 340         .bSlaveInterface0 =     1,      /* index of data interface */
 341 };
 342
 343 static struct usb_endpoint_descriptor gs_fullspeed_notify_desc = {
 344         .bLength =              USB_DT_ENDPOINT_SIZE,
 345         .bDescriptorType =      USB_DT_ENDPOINT,
 346         .bEndpointAddress =     USB_DIR_IN,
 347         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 348         .wMaxPacketSize =       __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
 349         .bInterval =            1 << GS_LOG2_NOTIFY_INTERVAL,
 350 };
 351
 352 static struct usb_endpoint_descriptor gs_fullspeed_in_desc = {
 353         .bLength =              USB_DT_ENDPOINT_SIZE,
 354         .bDescriptorType =      USB_DT_ENDPOINT,
 355         .bEndpointAddress =     USB_DIR_IN,
 356         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 357 };
 358
 359 static struct usb_endpoint_descriptor gs_fullspeed_out_desc = {
 360         .bLength =              USB_DT_ENDPOINT_SIZE,
 361         .bDescriptorType =      USB_DT_ENDPOINT,
 362         .bEndpointAddress =     USB_DIR_OUT,
 363         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 364 };
 365
 366 static const struct usb_descriptor_header *gs_bulk_fullspeed_function[] = {
 367         (struct usb_descriptor_header *) &gs_otg_descriptor,
 368         (struct usb_descriptor_header *) &gs_bulk_interface_desc,
 369         (struct usb_descriptor_header *) &gs_fullspeed_in_desc,
 370         (struct usb_descriptor_header *) &gs_fullspeed_out_desc,
 371         NULL,
 372 };
 373
 374 static const struct usb_descriptor_header *gs_acm_fullspeed_function[] = {
 375         (struct usb_descriptor_header *) &gs_otg_descriptor,
 376         (struct usb_descriptor_header *) &gs_control_interface_desc,
 377         (struct usb_descriptor_header *) &gs_header_desc,
 378         (struct usb_descriptor_header *) &gs_call_mgmt_descriptor,
 379         (struct usb_descriptor_header *) &gs_acm_descriptor,
 380         (struct usb_descriptor_header *) &gs_union_desc,
 381         (struct usb_descriptor_header *) &gs_fullspeed_notify_desc,
 382         (struct usb_descriptor_header *) &gs_data_interface_desc,
 383         (struct usb_descriptor_header *) &gs_fullspeed_in_desc,
 384         (struct usb_descriptor_header *) &gs_fullspeed_out_desc,
 385         NULL,
 386 };
 387
 388 static struct usb_endpoint_descriptor gs_highspeed_notify_desc = {
 389         .bLength =              USB_DT_ENDPOINT_SIZE,
 390         .bDescriptorType =      USB_DT_ENDPOINT,
 391         .bEndpointAddress =     USB_DIR_IN,
 392         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 393         .wMaxPacketSize =       __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
 394         .bInterval =            GS_LOG2_NOTIFY_INTERVAL+4,
 395 };
 396
 397 static struct usb_endpoint_descriptor gs_highspeed_in_desc = {
 398         .bLength =              USB_DT_ENDPOINT_SIZE,
 399         .bDescriptorType =      USB_DT_ENDPOINT,
 400         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 401         .wMaxPacketSize =       __constant_cpu_to_le16(512),
 402 };
 403
 404 static struct usb_endpoint_descriptor gs_highspeed_out_desc = {
 405         .bLength =              USB_DT_ENDPOINT_SIZE,
 406         .bDescriptorType =      USB_DT_ENDPOINT,
 407         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 408         .wMaxPacketSize =       __constant_cpu_to_le16(512),
 409 };
 410
 411 static struct usb_qualifier_descriptor gs_qualifier_desc = {
 412         .bLength =              sizeof(struct usb_qualifier_descriptor),
 413         .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
 414         .bcdUSB =               __constant_cpu_to_le16 (0x0200),
 415         /* assumes ep0 uses the same value for both speeds ... */
 416         .bNumConfigurations =   GS_NUM_CONFIGS,
 417 };
 418
 419 static const struct usb_descriptor_header *gs_bulk_highspeed_function[] = {
 420         (struct usb_descriptor_header *) &gs_otg_descriptor,
 421         (struct usb_descriptor_header *) &gs_bulk_interface_desc,
 422         (struct usb_descriptor_header *) &gs_highspeed_in_desc,
 423         (struct usb_descriptor_header *) &gs_highspeed_out_desc,
 424         NULL,
 425 };
 426
 427 static const struct usb_descriptor_header *gs_acm_highspeed_function[] = {
 428         (struct usb_descriptor_header *) &gs_otg_descriptor,
 429         (struct usb_descriptor_header *) &gs_control_interface_desc,
 430         (struct usb_descriptor_header *) &gs_header_desc,
 431         (struct usb_descriptor_header *) &gs_call_mgmt_descriptor,
 432         (struct usb_descriptor_header *) &gs_acm_descriptor,
 433         (struct usb_descriptor_header *) &gs_union_desc,
 434         (struct usb_descriptor_header *) &gs_highspeed_notify_desc,
 435         (struct usb_descriptor_header *) &gs_data_interface_desc,
 436         (struct usb_descriptor_header *) &gs_highspeed_in_desc,
 437         (struct usb_descriptor_header *) &gs_highspeed_out_desc,
 438         NULL,
 439 };
 440
 441
 442 /*-------------------------------------------------------------------------*/
 443
 444 /* Module */
 445 MODULE_DESCRIPTION(GS_LONG_NAME);
 446 MODULE_AUTHOR("Al Borchers");
 447 MODULE_LICENSE("GPL");
 448
 449 #ifdef DEBUG
 450 module_param(debug, int, S_IRUGO|S_IWUSR);
 451 MODULE_PARM_DESC(debug, "Enable debugging, 0=off, 1=on");
 452 #endif
 453
 454 static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE;
 455 module_param(read_q_size, uint, S_IRUGO);
 456 MODULE_PARM_DESC(read_q_size, "Read request queue size, default=32");
 457
 458 static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE;
 459 module_param(write_q_size, uint, S_IRUGO);
 460 MODULE_PARM_DESC(write_q_size, "Write request queue size, default=32");
 461
 462 static unsigned int write_buf_size = GS_DEFAULT_WRITE_BUF_SIZE;
 463 module_param(write_buf_size, uint, S_IRUGO);
 464 MODULE_PARM_DESC(write_buf_size, "Write buffer size, default=8192");
 465
 466 static unsigned int use_acm = GS_DEFAULT_USE_ACM;
 467 module_param(use_acm, uint, S_IRUGO);
 468 MODULE_PARM_DESC(use_acm, "Use CDC ACM, 0=no, 1=yes, default=no");
 469
 470 /*-------------------------------------------------------------------------*/
 471
 472 /* TTY Driver */
 473
 474 /*
 475  * gs_open
 476  */
 477 static int gs_open(struct tty_struct *tty, struct file *file)
 478 {
 479         int port_num;
 480         unsigned long flags;
 481         struct gs_port *port;
 482         struct gs_dev *dev;
 483         struct gs_buf *buf;
 484         struct mutex *mtx;
 485         int ret;
 486
 487         port_num = tty->index;
 488
 489         gs_debug("gs_open: (%d,%p,%p)\n", port_num, tty, file);
 490
 491         if (port_num < 0 || port_num >= GS_NUM_PORTS) {
 492                 pr_err("gs_open: (%d,%p,%p) invalid port number\n",
 493                         port_num, tty, file);
 494                 return -ENODEV;
 495         }
 496
 497         dev = gs_device;
 498
 499         if (dev == NULL) {
 500                 pr_err("gs_open: (%d,%p,%p) NULL device pointer\n",
 501                         port_num, tty, file);
 502                 return -ENODEV;
 503         }
 504
 505         mtx = &gs_open_close_lock[port_num];
 506         if (mutex_lock_interruptible(mtx)) {
 507                 pr_err("gs_open: (%d,%p,%p) interrupted waiting for mutex\n",
 508                         port_num, tty, file);
 509                 return -ERESTARTSYS;
 510         }
 511
 512         spin_lock_irqsave(&dev->dev_lock, flags);
 513
 514         if (dev->dev_config == GS_NO_CONFIG_ID) {
 515                 pr_err("gs_open: (%d,%p,%p) device is not connected\n",
 516                         port_num, tty, file);
 517                 ret = -ENODEV;
 518                 goto exit_unlock_dev;
 519         }
 520
 521         port = dev->dev_port[port_num];
 522
 523         if (port == NULL) {
 524                 pr_err("gs_open: (%d,%p,%p) NULL port pointer\n",
 525                         port_num, tty, file);
 526                 ret = -ENODEV;
 527                 goto exit_unlock_dev;
 528         }
 529
 530         spin_lock(&port->port_lock);
 531         spin_unlock(&dev->dev_lock);
 532
 533         if (port->port_dev == NULL) {
 534                 pr_err("gs_open: (%d,%p,%p) port disconnected (1)\n",
 535                         port_num, tty, file);
 536                 ret = -EIO;
 537                 goto exit_unlock_port;
 538         }
 539
 540         if (port->port_open_count > 0) {
 541                 ++port->port_open_count;
 542                 gs_debug("gs_open: (%d,%p,%p) already open\n",
 543                         port_num, tty, file);
 544                 ret = 0;
 545                 goto exit_unlock_port;
 546         }
 547
 548         tty->driver_data = NULL;
 549
 550         /* mark port as in use, we can drop port lock and sleep if necessary */
 551         port->port_in_use = 1;
 552
 553         /* allocate write buffer on first open */
 554         if (port->port_write_buf == NULL) {
 555                 spin_unlock_irqrestore(&port->port_lock, flags);
 556                 buf = gs_buf_alloc(write_buf_size, GFP_KERNEL);
 557                 spin_lock_irqsave(&port->port_lock, flags);
 558
 559                 /* might have been disconnected while asleep, check */
 560                 if (port->port_dev == NULL) {
 561                         pr_err("gs_open: (%d,%p,%p) port disconnected (2)\n",
 562                                 port_num, tty, file);
 563                         port->port_in_use = 0;
 564                         ret = -EIO;
 565                         goto exit_unlock_port;
 566                 }
 567
 568                 if ((port->port_write_buf=buf) == NULL) {
 569                         pr_err("gs_open: (%d,%p,%p) cannot allocate "
 570                                 "port write buffer\n",
 571                                 port_num, tty, file);
 572                         port->port_in_use = 0;
 573                         ret = -ENOMEM;
 574                         goto exit_unlock_port;
 575                 }
 576
 577         }
 578
 579         /* wait for carrier detect (not implemented) */
 580
 581         /* might have been disconnected while asleep, check */
 582         if (port->port_dev == NULL) {
 583                 pr_err("gs_open: (%d,%p,%p) port disconnected (3)\n",
 584                         port_num, tty, file);
 585                 port->port_in_use = 0;
 586                 ret = -EIO;
 587                 goto exit_unlock_port;
 588         }
 589
 590         tty->driver_data = port;
 591         port->port_tty = tty;
 592         port->port_open_count = 1;
 593         port->port_in_use = 0;
 594
 595         gs_debug("gs_open: (%d,%p,%p) completed\n", port_num, tty, file);
 596
 597         ret = 0;
 598
 599 exit_unlock_port:
 600         spin_unlock_irqrestore(&port->port_lock, flags);
 601         mutex_unlock(mtx);
 602         return ret;
 603
 604 exit_unlock_dev:
 605         spin_unlock_irqrestore(&dev->dev_lock, flags);
 606         mutex_unlock(mtx);
 607         return ret;
 608
 609 }
 610
 611 /*
 612  * gs_close
 613  */
 614
 615 static int gs_write_finished_event_safely(struct gs_port *p)
 616 {
 617         int cond;
 618
 619         spin_lock_irq(&(p)->port_lock);
 620         cond = !(p)->port_dev || !gs_buf_data_avail((p)->port_write_buf);
 621         spin_unlock_irq(&(p)->port_lock);
 622         return cond;
 623 }
 624
 625 static void gs_close(struct tty_struct *tty, struct file *file)
 626 {
 627         struct gs_port *port = tty->driver_data;
 628         struct mutex *mtx;
 629
 630         if (port == NULL) {
 631                 pr_err("gs_close: NULL port pointer\n");
 632                 return;
 633         }
 634
 635         gs_debug("gs_close: (%d,%p,%p)\n", port->port_num, tty, file);
 636
 637         mtx = &gs_open_close_lock[port->port_num];
 638         mutex_lock(mtx);
 639
 640         spin_lock_irq(&port->port_lock);
 641
 642         if (port->port_open_count == 0) {
 643                 pr_err("gs_close: (%d,%p,%p) port is already closed\n",
 644                         port->port_num, tty, file);
 645                 goto exit;
 646         }
 647
 648         if (port->port_open_count > 1) {
 649                 --port->port_open_count;
 650                 goto exit;
 651         }
 652
 653         /* free disconnected port on final close */
 654         if (port->port_dev == NULL) {
 655                 kfree(port);
 656                 goto exit;
 657         }
 658
 659         /* mark port as closed but in use, we can drop port lock */
 660         /* and sleep if necessary */
 661         port->port_in_use = 1;
 662         port->port_open_count = 0;
 663
 664         /* wait for write buffer to drain, or */
 665         /* at most GS_CLOSE_TIMEOUT seconds */
 666         if (gs_buf_data_avail(port->port_write_buf) > 0) {
 667                 spin_unlock_irq(&port->port_lock);
 668                 wait_event_interruptible_timeout(port->port_write_wait,
 669                                         gs_write_finished_event_safely(port),
 670                                         GS_CLOSE_TIMEOUT * HZ);
 671                 spin_lock_irq(&port->port_lock);
 672         }
 673
 674         /* free disconnected port on final close */
 675         /* (might have happened during the above sleep) */
 676         if (port->port_dev == NULL) {
 677                 kfree(port);
 678                 goto exit;
 679         }
 680
 681         gs_buf_clear(port->port_write_buf);
 682
 683         tty->driver_data = NULL;
 684         port->port_tty = NULL;
 685         port->port_in_use = 0;
 686
 687         gs_debug("gs_close: (%d,%p,%p) completed\n",
 688                 port->port_num, tty, file);
 689
 690 exit:
 691         spin_unlock_irq(&port->port_lock);
 692         mutex_unlock(mtx);
 693 }
 694
 695 /*
 696  * gs_write
 697  */
 698 static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
 699 {
 700         unsigned long flags;
 701         struct gs_port *port = tty->driver_data;
 702         int ret;
 703
 704         if (port == NULL) {
 705                 pr_err("gs_write: NULL port pointer\n");
 706                 return -EIO;
 707         }
 708
 709         gs_debug("gs_write: (%d,%p) writing %d bytes\n", port->port_num, tty,
 710                 count);
 711
 712         if (count == 0)
 713                 return 0;
 714
 715         spin_lock_irqsave(&port->port_lock, flags);
 716
 717         if (port->port_dev == NULL) {
 718                 pr_err("gs_write: (%d,%p) port is not connected\n",
 719                         port->port_num, tty);
 720                 ret = -EIO;
 721                 goto exit;
 722         }
 723
 724         if (port->port_open_count == 0) {
 725                 pr_err("gs_write: (%d,%p) port is closed\n",
 726                         port->port_num, tty);
 727                 ret = -EBADF;
 728                 goto exit;
 729         }
 730
 731         count = gs_buf_put(port->port_write_buf, buf, count);
 732
 733         spin_unlock_irqrestore(&port->port_lock, flags);
 734
 735         gs_send(gs_device);
 736
 737         gs_debug("gs_write: (%d,%p) wrote %d bytes\n", port->port_num, tty,
 738                 count);
 739
 740         return count;
 741
 742 exit:
 743         spin_unlock_irqrestore(&port->port_lock, flags);
 744         return ret;
 745 }
 746
 747 /*
 748  * gs_put_char
 749  */
 750 static int gs_put_char(struct tty_struct *tty, unsigned char ch)
 751 {
 752         unsigned long flags;
 753         struct gs_port *port = tty->driver_data;
 754         int ret = 0;
 755
 756         if (port == NULL) {
 757                 pr_err("gs_put_char: NULL port pointer\n");
 758                 return 0;
 759         }
 760
 761         gs_debug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
 762                 port->port_num, tty, ch, __builtin_return_address(0));
 763
 764         spin_lock_irqsave(&port->port_lock, flags);
 765
 766         if (port->port_dev == NULL) {
 767                 pr_err("gs_put_char: (%d,%p) port is not connected\n",
 768                         port->port_num, tty);
 769                 goto exit;
 770         }
 771
 772         if (port->port_open_count == 0) {
 773                 pr_err("gs_put_char: (%d,%p) port is closed\n",
 774                         port->port_num, tty);
 775                 goto exit;
 776         }
 777
 778         ret = gs_buf_put(port->port_write_buf, &ch, 1);
 779
 780 exit:
 781         spin_unlock_irqrestore(&port->port_lock, flags);
 782         return ret;
 783 }
 784
 785 /*
 786  * gs_flush_chars
 787  */
 788 static void gs_flush_chars(struct tty_struct *tty)
 789 {
 790         unsigned long flags;
 791         struct gs_port *port = tty->driver_data;
 792
 793         if (port == NULL) {
 794                 pr_err("gs_flush_chars: NULL port pointer\n");
 795                 return;
 796         }
 797
 798         gs_debug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
 799
 800         spin_lock_irqsave(&port->port_lock, flags);
 801
 802         if (port->port_dev == NULL) {
 803                 pr_err("gs_flush_chars: (%d,%p) port is not connected\n",
 804                         port->port_num, tty);
 805                 goto exit;
 806         }
 807
 808         if (port->port_open_count == 0) {
 809                 pr_err("gs_flush_chars: (%d,%p) port is closed\n",
 810                         port->port_num, tty);
 811                 goto exit;
 812         }
 813
 814         spin_unlock_irqrestore(&port->port_lock, flags);
 815
 816         gs_send(gs_device);
 817
 818         return;
 819
 820 exit:
 821         spin_unlock_irqrestore(&port->port_lock, flags);
 822 }
 823
 824 /*
 825  * gs_write_room
 826  */
 827 static int gs_write_room(struct tty_struct *tty)
 828 {
 829
 830         int room = 0;
 831         unsigned long flags;
 832         struct gs_port *port = tty->driver_data;
 833
 834
 835         if (port == NULL)
 836                 return 0;
 837
 838         spin_lock_irqsave(&port->port_lock, flags);
 839
 840         if (port->port_dev != NULL && port->port_open_count > 0
 841         && port->port_write_buf != NULL)
 842                 room = gs_buf_space_avail(port->port_write_buf);
 843
 844         spin_unlock_irqrestore(&port->port_lock, flags);
 845
 846         gs_debug("gs_write_room: (%d,%p) room=%d\n",
 847                 port->port_num, tty, room);
 848
 849         return room;
 850 }
 851
 852 /*
 853  * gs_chars_in_buffer
 854  */
 855 static int gs_chars_in_buffer(struct tty_struct *tty)
 856 {
 857         int chars = 0;
 858         unsigned long flags;
 859         struct gs_port *port = tty->driver_data;
 860
 861         if (port == NULL)
 862                 return 0;
 863
 864         spin_lock_irqsave(&port->port_lock, flags);
 865
 866         if (port->port_dev != NULL && port->port_open_count > 0
 867         && port->port_write_buf != NULL)
 868                 chars = gs_buf_data_avail(port->port_write_buf);
 869
 870         spin_unlock_irqrestore(&port->port_lock, flags);
 871
 872         gs_debug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
 873                 port->port_num, tty, chars);
 874
 875         return chars;
 876 }
 877
 878 /*
 879  * gs_throttle
 880  */
 881 static void gs_throttle(struct tty_struct *tty)
 882 {
 883 }
 884
 885 /*
 886  * gs_unthrottle
 887  */
 888 static void gs_unthrottle(struct tty_struct *tty)
 889 {
 890 }
 891
 892 /*
 893  * gs_break
 894  */
 895 static void gs_break(struct tty_struct *tty, int break_state)
 896 {
 897 }
 898
 899 /*
 900  * gs_ioctl
 901  */
 902 static int gs_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
 903 {
 904         struct gs_port *port = tty->driver_data;
 905
 906         if (port == NULL) {
 907                 pr_err("gs_ioctl: NULL port pointer\n");
 908                 return -EIO;
 909         }
 910
 911         gs_debug("gs_ioctl: (%d,%p,%p) cmd=0x%4.4x, arg=%lu\n",
 912                 port->port_num, tty, file, cmd, arg);
 913
 914         /* handle ioctls */
 915
 916         /* could not handle ioctl */
 917         return -ENOIOCTLCMD;
 918 }
 919
 920 /*
 921  * gs_set_termios
 922  */
 923 static void gs_set_termios(struct tty_struct *tty, struct ktermios *old)
 924 {
 925 }
 926
 927 static const struct tty_operations gs_tty_ops = {
 928         .open =                 gs_open,
 929         .close =                gs_close,
 930         .write =                gs_write,
 931         .put_char =             gs_put_char,
 932         .flush_chars =          gs_flush_chars,
 933         .write_room =           gs_write_room,
 934         .ioctl =                gs_ioctl,
 935         .set_termios =          gs_set_termios,
 936         .throttle =             gs_throttle,
 937         .unthrottle =           gs_unthrottle,
 938         .break_ctl =            gs_break,
 939         .chars_in_buffer =      gs_chars_in_buffer,
 940 };
 941
 942 /*-------------------------------------------------------------------------*/
 943
 944 /*
 945 * gs_send
 946 *
 947 * This function finds available write requests, calls
 948 * gs_send_packet to fill these packets with data, and
 949 * continues until either there are no more write requests
 950 * available or no more data to send.  This function is
 951 * run whenever data arrives or write requests are available.
 952 */
 953 static int gs_send(struct gs_dev *dev)
 954 {
 955         int ret,len;
 956         unsigned long flags;
 957         struct usb_ep *ep;
 958         struct usb_request *req;
 959
 960         if (dev == NULL) {
 961                 pr_err("gs_send: NULL device pointer\n");
 962                 return -ENODEV;
 963         }
 964
 965         spin_lock_irqsave(&dev->dev_lock, flags);
 966
 967         ep = dev->dev_in_ep;
 968
 969         while(!list_empty(&dev->dev_req_list)) {
 970
 971                 req = list_entry(dev->dev_req_list.next,
 972                                 struct usb_request, list);
 973
 974                 len = gs_send_packet(dev, req->buf, ep->maxpacket);
 975
 976                 if (len > 0) {
 977                         gs_debug_level(3, "gs_send: len=%d, 0x%2.2x "
 978                                         "0x%2.2x 0x%2.2x ...\n", len,
 979                                         *((unsigned char *)req->buf),
 980                                         *((unsigned char *)req->buf+1),
 981                                         *((unsigned char *)req->buf+2));
 982                         list_del(&req->list);
 983                         req->length = len;
 984                         spin_unlock_irqrestore(&dev->dev_lock, flags);
 985                         if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
 986                                 pr_err(
 987                                 "gs_send: cannot queue read request, ret=%d\n",
 988                                         ret);
 989                                 spin_lock_irqsave(&dev->dev_lock, flags);
 990                                 break;
 991                         }
 992                         spin_lock_irqsave(&dev->dev_lock, flags);
 993                 } else {
 994                         break;
 995                 }
 996
 997         }
 998
 999         spin_unlock_irqrestore(&dev->dev_lock, flags);
1000
1001         return 0;
1002 }
1003
1004 /*
1005  * gs_send_packet
1006  *
1007  * If there is data to send, a packet is built in the given
1008  * buffer and the size is returned.  If there is no data to
1009  * send, 0 is returned.  If there is any error a negative
1010  * error number is returned.
1011  *
1012  * Called during USB completion routine, on interrupt time.
1013  *
1014  * We assume that disconnect will not happen until all completion
1015  * routines have completed, so we can assume that the dev_port
1016  * array does not change during the lifetime of this function.
1017  */
1018 static int gs_send_packet(struct gs_dev *dev, char *packet, unsigned int size)
1019 {
1020         unsigned int len;
1021         struct gs_port *port;
1022
1023         /* TEMPORARY -- only port 0 is supported right now */
1024         port = dev->dev_port[0];
1025
1026         if (port == NULL) {
1027                 pr_err("gs_send_packet: port=%d, NULL port pointer\n", 0);
1028                 return -EIO;
1029         }
1030
1031         spin_lock(&port->port_lock);
1032
1033         len = gs_buf_data_avail(port->port_write_buf);
1034         if (len < size)
1035                 size = len;
1036
1037         if (size == 0)
1038                 goto exit;
1039
1040         size = gs_buf_get(port->port_write_buf, packet, size);
1041
1042         if (port->port_tty)
1043                 wake_up_interruptible(&port->port_tty->write_wait);
1044
1045 exit:
1046         spin_unlock(&port->port_lock);
1047         return size;
1048 }
1049
1050 /*
1051  * gs_recv_packet
1052  *
1053  * Called for each USB packet received.  Reads the packet
1054  * header and stuffs the data in the appropriate tty buffer.
1055  * Returns 0 if successful, or a negative error number.
1056  *
1057  * Called during USB completion routine, on interrupt time.
1058  *
1059  * We assume that disconnect will not happen until all completion
1060  * routines have completed, so we can assume that the dev_port
1061  * array does not change during the lifetime of this function.
1062  */
1063 static int gs_recv_packet(struct gs_dev *dev, char *packet, unsigned int size)
1064 {
1065         unsigned int len;
1066         struct gs_port *port;
1067         int ret;
1068         struct tty_struct *tty;
1069
1070         /* TEMPORARY -- only port 0 is supported right now */
1071         port = dev->dev_port[0];
1072
1073         if (port == NULL) {
1074                 pr_err("gs_recv_packet: port=%d, NULL port pointer\n",
1075                         port->port_num);
1076                 return -EIO;
1077         }
1078
1079         spin_lock(&port->port_lock);
1080
1081         if (port->port_open_count == 0) {
1082                 pr_err("gs_recv_packet: port=%d, port is closed\n",
1083                         port->port_num);
1084                 ret = -EIO;
1085                 goto exit;
1086         }
1087
1088
1089         tty = port->port_tty;
1090
1091         if (tty == NULL) {
1092                 pr_err("gs_recv_packet: port=%d, NULL tty pointer\n",
1093                         port->port_num);
1094                 ret = -EIO;
1095                 goto exit;
1096         }
1097
1098         if (port->port_tty->magic != TTY_MAGIC) {
1099                 pr_err("gs_recv_packet: port=%d, bad tty magic\n",
1100                         port->port_num);
1101                 ret = -EIO;
1102                 goto exit;
1103         }
1104
1105         len = tty_buffer_request_room(tty, size);
1106         if (len > 0) {
1107                 tty_insert_flip_string(tty, packet, len);
1108                 tty_flip_buffer_push(port->port_tty);
1109                 wake_up_interruptible(&port->port_tty->read_wait);
1110         }
1111         ret = 0;
1112 exit:
1113         spin_unlock(&port->port_lock);
1114         return ret;
1115 }
1116
1117 /*
1118 * gs_read_complete
1119 */
1120 static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
1121 {
1122         int ret;
1123         struct gs_dev *dev = ep->driver_data;
1124
1125         if (dev == NULL) {
1126                 pr_err("gs_read_complete: NULL device pointer\n");
1127                 return;
1128         }
1129
1130         switch(req->status) {
1131         case 0:
1132                 /* normal completion */
1133                 gs_recv_packet(dev, req->buf, req->actual);
1134 requeue:
1135                 req->length = ep->maxpacket;
1136                 if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
1137                         pr_err(
1138                         "gs_read_complete: cannot queue read request, ret=%d\n",
1139                                 ret);
1140                 }
1141                 break;
1142
1143         case -ESHUTDOWN:
1144                 /* disconnect */
1145                 gs_debug("gs_read_complete: shutdown\n");
1146                 gs_free_req(ep, req);
1147                 break;
1148
1149         default:
1150                 /* unexpected */
1151                 pr_err(
1152                 "gs_read_complete: unexpected status error, status=%d\n",
1153                         req->status);
1154                 goto requeue;
1155                 break;
1156         }
1157 }
1158
1159 /*
1160 * gs_write_complete
1161 */
1162 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
1163 {
1164         struct gs_dev *dev = ep->driver_data;
1165
1166         if (dev == NULL) {
1167                 pr_err("gs_write_complete: NULL device pointer\n");
1168                 return;
1169         }
1170
1171         switch(req->status) {
1172         case 0:
1173                 /* normal completion */
1174 requeue:
1175                 spin_lock(&dev->dev_lock);
1176                 list_add(&req->list, &dev->dev_req_list);
1177                 spin_unlock(&dev->dev_lock);
1178
1179                 gs_send(dev);
1180
1181                 break;
1182
1183         case -ESHUTDOWN:
1184                 /* disconnect */
1185                 gs_debug("gs_write_complete: shutdown\n");
1186                 gs_free_req(ep, req);
1187                 break;
1188
1189         default:
1190                 pr_err(
1191                 "gs_write_complete: unexpected status error, status=%d\n",
1192                         req->status);
1193                 goto requeue;
1194                 break;
1195         }
1196 }
1197
1198 /*-------------------------------------------------------------------------*/
1199
1200 /* Gadget Driver */
1201
1202 /*
1203  * gs_unbind
1204  *
1205  * Called on module unload.  Frees the control request and device
1206  * structure.
1207  */
1208 static void /* __init_or_exit */ gs_unbind(struct usb_gadget *gadget)
1209 {
1210         struct gs_dev *dev = get_gadget_data(gadget);
1211
1212         gs_device = NULL;
1213
1214         /* read/write requests already freed, only control request remains */
1215         if (dev != NULL) {
1216                 if (dev->dev_ctrl_req != NULL) {
1217                         gs_free_req(gadget->ep0, dev->dev_ctrl_req);
1218                         dev->dev_ctrl_req = NULL;
1219                 }
1220                 gs_free_ports(dev);
1221                 if (dev->dev_notify_ep)
1222                         usb_ep_disable(dev->dev_notify_ep);
1223                 if (dev->dev_in_ep)
1224                         usb_ep_disable(dev->dev_in_ep);
1225                 if (dev->dev_out_ep)
1226                         usb_ep_disable(dev->dev_out_ep);
1227                 kfree(dev);
1228                 set_gadget_data(gadget, NULL);
1229         }
1230
1231         pr_info("gs_unbind: %s %s unbound\n", GS_LONG_NAME,
1232                 GS_VERSION_STR);
1233 }
1234
1235 /*
1236  * gs_bind
1237  *
1238  * Called on module load.  Allocates and initializes the device
1239  * structure and a control request.
1240  */
1241 static int __init gs_bind(struct usb_gadget *gadget)
1242 {
1243         int ret;
1244         struct usb_ep *ep;
1245         struct gs_dev *dev;
1246         int gcnum;
1247
1248         /* Some controllers can't support CDC ACM:
1249          * - sh doesn't support multiple interfaces or configs;
1250          * - sa1100 doesn't have a third interrupt endpoint
1251          */
1252         if (gadget_is_sh(gadget) || gadget_is_sa1100(gadget))
1253                 use_acm = 0;
1254
1255         gcnum = usb_gadget_controller_number(gadget);
1256         if (gcnum >= 0)
1257                 gs_device_desc.bcdDevice =
1258                                 cpu_to_le16(GS_VERSION_NUM | gcnum);
1259         else {
1260                 pr_warning("gs_bind: controller '%s' not recognized\n",
1261                         gadget->name);
1262                 /* unrecognized, but safe unless bulk is REALLY quirky */
1263                 gs_device_desc.bcdDevice =
1264                         __constant_cpu_to_le16(GS_VERSION_NUM|0x0099);
1265         }
1266
1267         usb_ep_autoconfig_reset(gadget);
1268
1269         ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc);
1270         if (!ep)
1271                 goto autoconf_fail;
1272         EP_IN_NAME = ep->name;
1273         ep->driver_data = ep;   /* claim the endpoint */
1274
1275         ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc);
1276         if (!ep)
1277                 goto autoconf_fail;
1278         EP_OUT_NAME = ep->name;
1279         ep->driver_data = ep;   /* claim the endpoint */
1280
1281         if (use_acm) {
1282                 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_notify_desc);
1283                 if (!ep) {
1284                         pr_err("gs_bind: cannot run ACM on %s\n", gadget->name);
1285                         goto autoconf_fail;
1286                 }
1287                 gs_device_desc.idProduct = __constant_cpu_to_le16(
1288                                                 GS_CDC_PRODUCT_ID),
1289                 EP_NOTIFY_NAME = ep->name;
1290                 ep->driver_data = ep;   /* claim the endpoint */
1291         }
1292
1293         gs_device_desc.bDeviceClass = use_acm
1294                 ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
1295         gs_device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1296
1297         if (gadget_is_dualspeed(gadget)) {
1298                 gs_qualifier_desc.bDeviceClass = use_acm
1299                         ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
1300                 /* assume ep0 uses the same packet size for both speeds */
1301                 gs_qualifier_desc.bMaxPacketSize0 =
1302                         gs_device_desc.bMaxPacketSize0;
1303                 /* assume endpoints are dual-speed */
1304                 gs_highspeed_notify_desc.bEndpointAddress =
1305                         gs_fullspeed_notify_desc.bEndpointAddress;
1306                 gs_highspeed_in_desc.bEndpointAddress =
1307                         gs_fullspeed_in_desc.bEndpointAddress;
1308                 gs_highspeed_out_desc.bEndpointAddress =
1309                         gs_fullspeed_out_desc.bEndpointAddress;
1310         }
1311
1312         usb_gadget_set_selfpowered(gadget);
1313
1314         if (gadget_is_otg(gadget)) {
1315                 gs_otg_descriptor.bmAttributes |= USB_OTG_HNP,
1316                 gs_bulk_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1317                 gs_acm_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1318         }
1319
1320         gs_device = dev = kzalloc(sizeof(struct gs_dev), GFP_KERNEL);
1321         if (dev == NULL)
1322                 return -ENOMEM;
1323
1324         snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
1325                 init_utsname()->sysname, init_utsname()->release,
1326                 gadget->name);
1327
1328         dev->dev_gadget = gadget;
1329         spin_lock_init(&dev->dev_lock);
1330         INIT_LIST_HEAD(&dev->dev_req_list);
1331         set_gadget_data(gadget, dev);
1332
1333         if ((ret=gs_alloc_ports(dev, GFP_KERNEL)) != 0) {
1334                 pr_err("gs_bind: cannot allocate ports\n");
1335                 gs_unbind(gadget);
1336                 return ret;
1337         }
1338
1339         /* preallocate control response and buffer */
1340         dev->dev_ctrl_req = gs_alloc_req(gadget->ep0, GS_MAX_DESC_LEN,
1341                 GFP_KERNEL);
1342         if (dev->dev_ctrl_req == NULL) {
1343                 gs_unbind(gadget);
1344                 return -ENOMEM;
1345         }
1346         gadget->ep0->driver_data = dev;
1347
1348         pr_info("gs_bind: %s %s bound\n",
1349                 GS_LONG_NAME, GS_VERSION_STR);
1350
1351         return 0;
1352
1353 autoconf_fail:
1354         pr_err("gs_bind: cannot autoconfigure on %s\n", gadget->name);
1355         return -ENODEV;
1356 }
1357
1358 static int gs_setup_standard(struct usb_gadget *gadget,
1359         const struct usb_ctrlrequest *ctrl)
1360 {
1361         int ret = -EOPNOTSUPP;
1362         struct gs_dev *dev = get_gadget_data(gadget);
1363         struct usb_request *req = dev->dev_ctrl_req;
1364         u16 wIndex = le16_to_cpu(ctrl->wIndex);
1365         u16 wValue = le16_to_cpu(ctrl->wValue);
1366         u16 wLength = le16_to_cpu(ctrl->wLength);
1367
1368         switch (ctrl->bRequest) {
1369         case USB_REQ_GET_DESCRIPTOR:
1370                 if (ctrl->bRequestType != USB_DIR_IN)
1371                         break;
1372
1373                 switch (wValue >> 8) {
1374                 case USB_DT_DEVICE:
1375                         ret = min(wLength,
1376                                 (u16)sizeof(struct usb_device_descriptor));
1377                         memcpy(req->buf, &gs_device_desc, ret);
1378                         break;
1379
1380                 case USB_DT_DEVICE_QUALIFIER:
1381                         if (!gadget_is_dualspeed(gadget))
1382                                 break;
1383                         ret = min(wLength,
1384                                 (u16)sizeof(struct usb_qualifier_descriptor));
1385                         memcpy(req->buf, &gs_qualifier_desc, ret);
1386                         break;
1387
1388                 case USB_DT_OTHER_SPEED_CONFIG:
1389                         if (!gadget_is_dualspeed(gadget))
1390                                 break;
1391                         /* fall through */
1392                 case USB_DT_CONFIG:
1393                         ret = gs_build_config_buf(req->buf, gadget,
1394                                 wValue >> 8, wValue & 0xff,
1395                                 gadget_is_otg(gadget));
1396                         if (ret >= 0)
1397                                 ret = min(wLength, (u16)ret);
1398                         break;
1399
1400                 case USB_DT_STRING:
1401                         /* wIndex == language code. */
1402                         ret = usb_gadget_get_string(&gs_string_table,
1403                                 wValue & 0xff, req->buf);
1404                         if (ret >= 0)
1405                                 ret = min(wLength, (u16)ret);
1406                         break;
1407                 }
1408                 break;
1409
1410         case USB_REQ_SET_CONFIGURATION:
1411                 if (ctrl->bRequestType != 0)
1412                         break;
1413                 spin_lock(&dev->dev_lock);
1414                 ret = gs_set_config(dev, wValue);
1415                 spin_unlock(&dev->dev_lock);
1416                 break;
1417
1418         case USB_REQ_GET_CONFIGURATION:
1419                 if (ctrl->bRequestType != USB_DIR_IN)
1420                         break;
1421                 *(u8 *)req->buf = dev->dev_config;
1422                 ret = min(wLength, (u16)1);
1423                 break;
1424
1425         case USB_REQ_SET_INTERFACE:
1426                 if (ctrl->bRequestType != USB_RECIP_INTERFACE
1427                                 || !dev->dev_config
1428                                 || wIndex >= GS_MAX_NUM_INTERFACES)
1429                         break;
1430                 if (dev->dev_config == GS_BULK_CONFIG_ID
1431                                 && wIndex != GS_BULK_INTERFACE_ID)
1432                         break;
1433                 /* no alternate interface settings */
1434                 if (wValue != 0)
1435                         break;
1436                 spin_lock(&dev->dev_lock);
1437                 /* PXA hardware partially handles SET_INTERFACE;
1438                  * we need to kluge around that interference.  */
1439                 if (gadget_is_pxa(gadget)) {
1440                         ret = gs_set_config(dev, use_acm ?
1441                                 GS_ACM_CONFIG_ID : GS_BULK_CONFIG_ID);
1442                         goto set_interface_done;
1443                 }
1444                 if (dev->dev_config != GS_BULK_CONFIG_ID
1445                                 && wIndex == GS_CONTROL_INTERFACE_ID) {
1446                         if (dev->dev_notify_ep) {
1447                                 usb_ep_disable(dev->dev_notify_ep);
1448                                 usb_ep_enable(dev->dev_notify_ep, dev->dev_notify_ep_desc);
1449                         }
1450                 } else {
1451                         usb_ep_disable(dev->dev_in_ep);
1452                         usb_ep_disable(dev->dev_out_ep);
1453                         usb_ep_enable(dev->dev_in_ep, dev->dev_in_ep_desc);
1454                         usb_ep_enable(dev->dev_out_ep, dev->dev_out_ep_desc);
1455                 }
1456                 ret = 0;
1457 set_interface_done:
1458                 spin_unlock(&dev->dev_lock);
1459                 break;
1460
1461         case USB_REQ_GET_INTERFACE:
1462                 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
1463                 || dev->dev_config == GS_NO_CONFIG_ID)
1464                         break;
1465                 if (wIndex >= GS_MAX_NUM_INTERFACES
1466                                 || (dev->dev_config == GS_BULK_CONFIG_ID
1467                                 && wIndex != GS_BULK_INTERFACE_ID)) {
1468                         ret = -EDOM;
1469                         break;
1470                 }
1471                 /* no alternate interface settings */
1472                 *(u8 *)req->buf = 0;
1473                 ret = min(wLength, (u16)1);
1474                 break;
1475
1476         default:
1477                 pr_err("gs_setup: unknown standard request, type=%02x, "
1478                         "request=%02x, value=%04x, index=%04x, length=%d\n",
1479                         ctrl->bRequestType, ctrl->bRequest,
1480                         wValue, wIndex, wLength);
1481                 break;
1482         }
1483
1484         return ret;
1485 }
1486
1487 static void gs_setup_complete_set_line_coding(struct usb_ep *ep,
1488                 struct usb_request *req)
1489 {
1490         struct gs_dev *dev = ep->driver_data;
1491         struct gs_port *port = dev->dev_port[0]; /* ACM only has one port */
1492
1493         switch (req->status) {
1494         case 0:
1495                 /* normal completion */
1496                 if (req->actual != sizeof(port->port_line_coding))
1497                         usb_ep_set_halt(ep);
1498                 else if (port) {
1499                         struct usb_cdc_line_coding      *value = req->buf;
1500
1501                         /* REVISIT:  we currently just remember this data.
1502                          * If we change that, (a) validate it first, then
1503                          * (b) update whatever hardware needs updating.
1504                          */
1505                         spin_lock(&port->port_lock);
1506                         port->port_line_coding = *value;
1507                         spin_unlock(&port->port_lock);
1508                 }
1509                 break;
1510
1511         case -ESHUTDOWN:
1512                 /* disconnect */
1513                 gs_free_req(ep, req);
1514                 break;
1515
1516         default:
1517                 /* unexpected */
1518                 break;
1519         }
1520         return;
1521 }
1522
1523 static int gs_setup_class(struct usb_gadget *gadget,
1524         const struct usb_ctrlrequest *ctrl)
1525 {
1526         int ret = -EOPNOTSUPP;
1527         struct gs_dev *dev = get_gadget_data(gadget);
1528         struct gs_port *port = dev->dev_port[0];        /* ACM only has one port */
1529         struct usb_request *req = dev->dev_ctrl_req;
1530         u16 wIndex = le16_to_cpu(ctrl->wIndex);
1531         u16 wValue = le16_to_cpu(ctrl->wValue);
1532         u16 wLength = le16_to_cpu(ctrl->wLength);
1533
1534         switch (ctrl->bRequest) {
1535         case USB_CDC_REQ_SET_LINE_CODING:
1536                 if (wLength != sizeof(struct usb_cdc_line_coding))
1537                         break;
1538                 ret = wLength;
1539                 req->complete = gs_setup_complete_set_line_coding;
1540                 break;
1541
1542         case USB_CDC_REQ_GET_LINE_CODING:
1543                 ret = min_t(int, wLength, sizeof(struct usb_cdc_line_coding));
1544                 if (port) {
1545                         spin_lock(&port->port_lock);
1546                         memcpy(req->buf, &port->port_line_coding, ret);
1547                         spin_unlock(&port->port_lock);
1548                 }
1549                 break;
1550
1551         case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
1552                 if (wLength != 0)
1553                         break;
1554                 ret = 0;
1555                 if (port) {
1556                         /* REVISIT:  we currently just remember this data.
1557                          * If we change that, update whatever hardware needs
1558                          * updating.
1559                          */
1560                         spin_lock(&port->port_lock);
1561                         port->port_handshake_bits = wValue;
1562                         spin_unlock(&port->port_lock);
1563                 }
1564                 break;
1565
1566         default:
1567                 /* NOTE:  strictly speaking, we should accept AT-commands
1568                  * using SEND_ENCPSULATED_COMMAND/GET_ENCAPSULATED_RESPONSE.
1569                  * But our call management descriptor says we don't handle
1570                  * call management, so we should be able to get by without
1571                  * handling those "required" commands (except by stalling).
1572                  */
1573                 pr_err("gs_setup: unknown class request, "
1574                                 "type=%02x, request=%02x, value=%04x, "
1575                                 "index=%04x, length=%d\n",
1576                         ctrl->bRequestType, ctrl->bRequest,
1577                         wValue, wIndex, wLength);
1578                 break;
1579         }
1580
1581         return ret;
1582 }
1583
1584 /*
1585  * gs_setup_complete
1586  */
1587 static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req)
1588 {
1589         if (req->status || req->actual != req->length) {
1590                 pr_err("gs_setup_complete: status error, status=%d, "
1591                         "actual=%d, length=%d\n",
1592                         req->status, req->actual, req->length);
1593         }
1594 }
1595
1596 /*
1597  * gs_setup
1598  *
1599  * Implements all the control endpoint functionality that's not
1600  * handled in hardware or the hardware driver.
1601  *
1602  * Returns the size of the data sent to the host, or a negative
1603  * error number.
1604  */
1605 static int gs_setup(struct usb_gadget *gadget,
1606         const struct usb_ctrlrequest *ctrl)
1607 {
1608         int             ret = -EOPNOTSUPP;
1609         struct gs_dev   *dev = get_gadget_data(gadget);
1610         struct usb_request *req = dev->dev_ctrl_req;
1611         u16             wIndex = le16_to_cpu(ctrl->wIndex);
1612         u16             wValue = le16_to_cpu(ctrl->wValue);
1613         u16             wLength = le16_to_cpu(ctrl->wLength);
1614
1615         req->complete = gs_setup_complete;
1616
1617         switch (ctrl->bRequestType & USB_TYPE_MASK) {
1618         case USB_TYPE_STANDARD:
1619                 ret = gs_setup_standard(gadget, ctrl);
1620                 break;
1621
1622         case USB_TYPE_CLASS:
1623                 ret = gs_setup_class(gadget, ctrl);
1624                 break;
1625
1626         default:
1627                 pr_err("gs_setup: unknown request, type=%02x, request=%02x, "
1628                         "value=%04x, index=%04x, length=%d\n",
1629                         ctrl->bRequestType, ctrl->bRequest,
1630                         wValue, wIndex, wLength);
1631                 break;
1632         }
1633
1634         /* respond with data transfer before status phase? */
1635         if (ret >= 0) {
1636                 req->length = ret;
1637                 req->zero = ret < wLength
1638                                 && (ret % gadget->ep0->maxpacket) == 0;
1639                 ret = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1640                 if (ret < 0) {
1641                         pr_err("gs_setup: cannot queue response, ret=%d\n",
1642                                 ret);
1643                         req->status = 0;
1644                         gs_setup_complete(gadget->ep0, req);
1645                 }
1646         }
1647
1648         /* device either stalls (ret < 0) or reports success */
1649         return ret;
1650 }
1651
1652 /*
1653  * gs_disconnect
1654  *
1655  * Called when the device is disconnected.  Frees the closed
1656  * ports and disconnects open ports.  Open ports will be freed
1657  * on close.  Then reallocates the ports for the next connection.
1658  */
1659 static void gs_disconnect(struct usb_gadget *gadget)
1660 {
1661         unsigned long flags;
1662         struct gs_dev *dev = get_gadget_data(gadget);
1663
1664         spin_lock_irqsave(&dev->dev_lock, flags);
1665
1666         gs_reset_config(dev);
1667
1668         /* free closed ports and disconnect open ports */
1669         /* (open ports will be freed when closed) */
1670         gs_free_ports(dev);
1671
1672         /* re-allocate ports for the next connection */
1673         if (gs_alloc_ports(dev, GFP_ATOMIC) != 0)
1674                 pr_err("gs_disconnect: cannot re-allocate ports\n");
1675
1676         spin_unlock_irqrestore(&dev->dev_lock, flags);
1677
1678         pr_info("gs_disconnect: %s disconnected\n", GS_LONG_NAME);
1679 }
1680
1681 static struct usb_gadget_driver gs_gadget_driver = {
1682 #ifdef CONFIG_USB_GADGET_DUALSPEED
1683         .speed =                USB_SPEED_HIGH,
1684 #else
1685         .speed =                USB_SPEED_FULL,
1686 #endif /* CONFIG_USB_GADGET_DUALSPEED */
1687         .function =             GS_LONG_NAME,
1688         .bind =                 gs_bind,
1689         .unbind =               gs_unbind,
1690         .setup =                gs_setup,
1691         .disconnect =           gs_disconnect,
1692         .driver = {
1693                 .name =         GS_SHORT_NAME,
1694                 .owner =        THIS_MODULE,
1695         },
1696 };
1697
1698 /*
1699  * gs_set_config
1700  *
1701  * Configures the device by enabling device specific
1702  * optimizations, setting up the endpoints, allocating
1703  * read and write requests and queuing read requests.
1704  *
1705  * The device lock must be held when calling this function.
1706  */
1707 static int gs_set_config(struct gs_dev *dev, unsigned config)
1708 {
1709         int i;
1710         int ret = 0;
1711         struct usb_gadget *gadget = dev->dev_gadget;
1712         struct usb_ep *ep;
1713         struct usb_endpoint_descriptor *ep_desc;
1714         struct usb_request *req;
1715
1716         if (dev == NULL) {
1717                 pr_err("gs_set_config: NULL device pointer\n");
1718                 return 0;
1719         }
1720
1721         if (config == dev->dev_config)
1722                 return 0;
1723
1724         gs_reset_config(dev);
1725
1726         switch (config) {
1727         case GS_NO_CONFIG_ID:
1728                 return 0;
1729         case GS_BULK_CONFIG_ID:
1730                 if (use_acm)
1731                         return -EINVAL;
1732                 break;
1733         case GS_ACM_CONFIG_ID:
1734                 if (!use_acm)
1735                         return -EINVAL;
1736                 break;
1737         default:
1738                 return -EINVAL;
1739         }
1740
1741         dev->dev_config = config;
1742
1743         gadget_for_each_ep(ep, gadget) {
1744
1745                 if (EP_NOTIFY_NAME
1746                 && strcmp(ep->name, EP_NOTIFY_NAME) == 0) {
1747                         ep_desc = choose_ep_desc(gadget,
1748                                 &gs_highspeed_notify_desc,
1749                                 &gs_fullspeed_notify_desc);
1750                         ret = usb_ep_enable(ep,ep_desc);
1751                         if (ret == 0) {
1752                                 ep->driver_data = dev;
1753                                 dev->dev_notify_ep = ep;
1754                                 dev->dev_notify_ep_desc = ep_desc;
1755                         } else {
1756                                 pr_err("gs_set_config: cannot enable NOTIFY "
1757                                         "endpoint %s, ret=%d\n",
1758                                         ep->name, ret);
1759                                 goto exit_reset_config;
1760                         }
1761                 }
1762
1763                 else if (strcmp(ep->name, EP_IN_NAME) == 0) {
1764                         ep_desc = choose_ep_desc(gadget,
1765                                 &gs_highspeed_in_desc,
1766                                 &gs_fullspeed_in_desc);
1767                         ret = usb_ep_enable(ep,ep_desc);
1768                         if (ret == 0) {
1769                                 ep->driver_data = dev;
1770                                 dev->dev_in_ep = ep;
1771                                 dev->dev_in_ep_desc = ep_desc;
1772                         } else {
1773                                 pr_err("gs_set_config: cannot enable IN "
1774                                         "endpoint %s, ret=%d\n",
1775                                         ep->name, ret);
1776                                 goto exit_reset_config;
1777                         }
1778                 }
1779
1780                 else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
1781                         ep_desc = choose_ep_desc(gadget,
1782                                 &gs_highspeed_out_desc,
1783                                 &gs_fullspeed_out_desc);
1784                         ret = usb_ep_enable(ep,ep_desc);
1785                         if (ret == 0) {
1786                                 ep->driver_data = dev;
1787                                 dev->dev_out_ep = ep;
1788                                 dev->dev_out_ep_desc = ep_desc;
1789                         } else {
1790                                 pr_err("gs_set_config: cannot enable OUT "
1791                                         "endpoint %s, ret=%d\n",
1792                                         ep->name, ret);
1793                                 goto exit_reset_config;
1794                         }
1795                 }
1796
1797         }
1798
1799         if (dev->dev_in_ep == NULL || dev->dev_out_ep == NULL
1800         || (config != GS_BULK_CONFIG_ID && dev->dev_notify_ep == NULL)) {
1801                 pr_err("gs_set_config: cannot find endpoints\n");
1802                 ret = -ENODEV;
1803                 goto exit_reset_config;
1804         }
1805
1806         /* allocate and queue read requests */
1807         ep = dev->dev_out_ep;
1808         for (i=0; i<read_q_size && ret == 0; i++) {
1809                 if ((req=gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC))) {
1810                         req->complete = gs_read_complete;
1811                         if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
1812                                 pr_err("gs_set_config: cannot queue read "
1813                                         "request, ret=%d\n", ret);
1814                         }
1815                 } else {
1816                         pr_err("gs_set_config: cannot allocate "
1817                                         "read requests\n");
1818                         ret = -ENOMEM;
1819                         goto exit_reset_config;
1820                 }
1821         }
1822
1823         /* allocate write requests, and put on free list */
1824         ep = dev->dev_in_ep;
1825         for (i=0; i<write_q_size; i++) {
1826                 req = gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC);
1827                 if (req) {
1828                         req->complete = gs_write_complete;
1829                         list_add(&req->list, &dev->dev_req_list);
1830                 } else {
1831                         pr_err("gs_set_config: cannot allocate "
1832                                         "write requests\n");
1833                         ret = -ENOMEM;
1834                         goto exit_reset_config;
1835                 }
1836         }
1837
1838         /* REVISIT the ACM mode should be able to actually *issue* some
1839          * notifications, for at least serial state change events if
1840          * not also for network connection; say so in bmCapabilities.
1841          */
1842
1843         pr_info("gs_set_config: %s configured, %s speed %s config\n",
1844                 GS_LONG_NAME,
1845                 gadget->speed == USB_SPEED_HIGH ? "high" : "full",
1846                 config == GS_BULK_CONFIG_ID ? "BULK" : "CDC-ACM");
1847
1848         return 0;
1849
1850 exit_reset_config:
1851         gs_reset_config(dev);
1852         return ret;
1853 }
1854
1855 /*
1856  * gs_reset_config
1857  *
1858  * Mark the device as not configured, disable all endpoints,
1859  * which forces completion of pending I/O and frees queued
1860  * requests, and free the remaining write requests on the
1861  * free list.
1862  *
1863  * The device lock must be held when calling this function.
1864  */
1865 static void gs_reset_config(struct gs_dev *dev)
1866 {
1867         struct usb_request *req;
1868
1869         if (dev == NULL) {
1870                 pr_err("gs_reset_config: NULL device pointer\n");
1871                 return;
1872         }
1873
1874         if (dev->dev_config == GS_NO_CONFIG_ID)
1875                 return;
1876
1877         dev->dev_config = GS_NO_CONFIG_ID;
1878
1879         /* free write requests on the free list */
1880         while(!list_empty(&dev->dev_req_list)) {
1881                 req = list_entry(dev->dev_req_list.next,
1882                                 struct usb_request, list);
1883                 list_del(&req->list);
1884                 gs_free_req(dev->dev_in_ep, req);
1885         }
1886
1887         /* disable endpoints, forcing completion of pending i/o; */
1888         /* completion handlers free their requests in this case */
1889         if (dev->dev_notify_ep) {
1890                 usb_ep_disable(dev->dev_notify_ep);
1891                 dev->dev_notify_ep = NULL;
1892         }
1893         if (dev->dev_in_ep) {
1894                 usb_ep_disable(dev->dev_in_ep);
1895                 dev->dev_in_ep = NULL;
1896         }
1897         if (dev->dev_out_ep) {
1898                 usb_ep_disable(dev->dev_out_ep);
1899                 dev->dev_out_ep = NULL;
1900         }
1901 }
1902
1903 /*
1904  * gs_build_config_buf
1905  *
1906  * Builds the config descriptors in the given buffer and returns the
1907  * length, or a negative error number.
1908  */
1909 static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
1910         u8 type, unsigned int index, int is_otg)
1911 {
1912         int len;
1913         int high_speed = 0;
1914         const struct usb_config_descriptor *config_desc;
1915         const struct usb_descriptor_header **function;
1916
1917         if (index >= gs_device_desc.bNumConfigurations)
1918                 return -EINVAL;
1919
1920         /* other speed switches high and full speed */
1921         if (gadget_is_dualspeed(g)) {
1922                 high_speed = (g->speed == USB_SPEED_HIGH);
1923                 if (type == USB_DT_OTHER_SPEED_CONFIG)
1924                         high_speed = !high_speed;
1925         }
1926
1927         if (use_acm) {
1928                 config_desc = &gs_acm_config_desc;
1929                 function = high_speed
1930                         ? gs_acm_highspeed_function
1931                         : gs_acm_fullspeed_function;
1932         } else {
1933                 config_desc = &gs_bulk_config_desc;
1934                 function = high_speed
1935                         ? gs_bulk_highspeed_function
1936                         : gs_bulk_fullspeed_function;
1937         }
1938
1939         /* for now, don't advertise srp-only devices */
1940         if (!is_otg)
1941                 function++;
1942
1943         len = usb_gadget_config_buf(config_desc, buf, GS_MAX_DESC_LEN, function);
1944         if (len < 0)
1945                 return len;
1946
1947         ((struct usb_config_descriptor *)buf)->bDescriptorType = type;
1948
1949         return len;
1950 }
1951
1952 /*
1953  * gs_alloc_req
1954  *
1955  * Allocate a usb_request and its buffer.  Returns a pointer to the
1956  * usb_request or NULL if there is an error.
1957  */
1958 static struct usb_request *
1959 gs_alloc_req(struct usb_ep *ep, unsigned int len, gfp_t kmalloc_flags)
1960 {
1961         struct usb_request *req;
1962
1963         if (ep == NULL)
1964                 return NULL;
1965
1966         req = usb_ep_alloc_request(ep, kmalloc_flags);
1967
1968         if (req != NULL) {
1969                 req->length = len;
1970                 req->buf = kmalloc(len, kmalloc_flags);
1971                 if (req->buf == NULL) {
1972                         usb_ep_free_request(ep, req);
1973                         return NULL;
1974                 }
1975         }
1976
1977         return req;
1978 }
1979
1980 /*
1981  * gs_free_req
1982  *
1983  * Free a usb_request and its buffer.
1984  */
1985 static void gs_free_req(struct usb_ep *ep, struct usb_request *req)
1986 {
1987         if (ep != NULL && req != NULL) {
1988                 kfree(req->buf);
1989                 usb_ep_free_request(ep, req);
1990         }
1991 }
1992
1993 /*
1994  * gs_alloc_ports
1995  *
1996  * Allocate all ports and set the gs_dev struct to point to them.
1997  * Return 0 if successful, or a negative error number.
1998  *
1999  * The device lock is normally held when calling this function.
2000  */
2001 static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags)
2002 {
2003         int i;
2004         struct gs_port *port;
2005
2006         if (dev == NULL)
2007                 return -EIO;
2008
2009         for (i=0; i<GS_NUM_PORTS; i++) {
2010                 if ((port=kzalloc(sizeof(struct gs_port), kmalloc_flags)) == NULL)
2011                         return -ENOMEM;
2012
2013                 port->port_dev = dev;
2014                 port->port_num = i;
2015                 port->port_line_coding.dwDTERate = cpu_to_le32(GS_DEFAULT_DTE_RATE);
2016                 port->port_line_coding.bCharFormat = GS_DEFAULT_CHAR_FORMAT;
2017                 port->port_line_coding.bParityType = GS_DEFAULT_PARITY;
2018                 port->port_line_coding.bDataBits = GS_DEFAULT_DATA_BITS;
2019                 spin_lock_init(&port->port_lock);
2020                 init_waitqueue_head(&port->port_write_wait);
2021
2022                 dev->dev_port[i] = port;
2023         }
2024
2025         return 0;
2026 }
2027
2028 /*
2029  * gs_free_ports
2030  *
2031  * Free all closed ports.  Open ports are disconnected by
2032  * freeing their write buffers, setting their device pointers
2033  * and the pointers to them in the device to NULL.  These
2034  * ports will be freed when closed.
2035  *
2036  * The device lock is normally held when calling this function.
2037  */
2038 static void gs_free_ports(struct gs_dev *dev)
2039 {
2040         int i;
2041         unsigned long flags;
2042         struct gs_port *port;
2043
2044         if (dev == NULL)
2045                 return;
2046
2047         for (i=0; i<GS_NUM_PORTS; i++) {
2048                 if ((port=dev->dev_port[i]) != NULL) {
2049                         dev->dev_port[i] = NULL;
2050
2051                         spin_lock_irqsave(&port->port_lock, flags);
2052
2053                         if (port->port_write_buf != NULL) {
2054                                 gs_buf_free(port->port_write_buf);
2055                                 port->port_write_buf = NULL;
2056                         }
2057
2058                         if (port->port_open_count > 0 || port->port_in_use) {
2059                                 port->port_dev = NULL;
2060                                 wake_up_interruptible(&port->port_write_wait);
2061                                 if (port->port_tty) {
2062                                         tty_hangup(port->port_tty);
2063                                 }
2064                                 spin_unlock_irqrestore(&port->port_lock, flags);
2065                         } else {
2066                                 spin_unlock_irqrestore(&port->port_lock, flags);
2067                                 kfree(port);
2068                         }
2069
2070                 }
2071         }
2072 }
2073
2074 /*-------------------------------------------------------------------------*/
2075
2076 /* Circular Buffer */
2077
2078 /*
2079  * gs_buf_alloc
2080  *
2081  * Allocate a circular buffer and all associated memory.
2082  */
2083 static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags)
2084 {
2085         struct gs_buf *gb;
2086
2087         if (size == 0)
2088                 return NULL;
2089
2090         gb = kmalloc(sizeof(struct gs_buf), kmalloc_flags);
2091         if (gb == NULL)
2092                 return NULL;
2093
2094         gb->buf_buf = kmalloc(size, kmalloc_flags);
2095         if (gb->buf_buf == NULL) {
2096                 kfree(gb);
2097                 return NULL;
2098         }
2099
2100         gb->buf_size = size;
2101         gb->buf_get = gb->buf_put = gb->buf_buf;
2102
2103         return gb;
2104 }
2105
2106 /*
2107  * gs_buf_free
2108  *
2109  * Free the buffer and all associated memory.
2110  */
2111 static void gs_buf_free(struct gs_buf *gb)
2112 {
2113         if (gb) {
2114                 kfree(gb->buf_buf);
2115                 kfree(gb);
2116         }
2117 }
2118
2119 /*
2120  * gs_buf_clear
2121  *
2122  * Clear out all data in the circular buffer.
2123  */
2124 static void gs_buf_clear(struct gs_buf *gb)
2125 {
2126         if (gb != NULL)
2127                 gb->buf_get = gb->buf_put;
2128                 /* equivalent to a get of all data available */
2129 }
2130
2131 /*
2132  * gs_buf_data_avail
2133  *
2134  * Return the number of bytes of data available in the circular
2135  * buffer.
2136  */
2137 static unsigned int gs_buf_data_avail(struct gs_buf *gb)
2138 {
2139         if (gb != NULL)
2140                 return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
2141         else
2142                 return 0;
2143 }
2144
2145 /*
2146  * gs_buf_space_avail
2147  *
2148  * Return the number of bytes of space available in the circular
2149  * buffer.
2150  */
2151 static unsigned int gs_buf_space_avail(struct gs_buf *gb)
2152 {
2153         if (gb != NULL)
2154                 return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
2155         else
2156                 return 0;
2157 }
2158
2159 /*
2160  * gs_buf_put
2161  *
2162  * Copy data data from a user buffer and put it into the circular buffer.
2163  * Restrict to the amount of space available.
2164  *
2165  * Return the number of bytes copied.
2166  */
2167 static unsigned int
2168 gs_buf_put(struct gs_buf *gb, const char *buf, unsigned int count)
2169 {
2170         unsigned int len;
2171
2172         if (gb == NULL)
2173                 return 0;
2174
2175         len  = gs_buf_space_avail(gb);
2176         if (count > len)
2177                 count = len;
2178
2179         if (count == 0)
2180                 return 0;
2181
2182         len = gb->buf_buf + gb->buf_size - gb->buf_put;
2183         if (count > len) {
2184                 memcpy(gb->buf_put, buf, len);
2185                 memcpy(gb->buf_buf, buf+len, count - len);
2186                 gb->buf_put = gb->buf_buf + count - len;
2187         } else {
2188                 memcpy(gb->buf_put, buf, count);
2189                 if (count < len)
2190                         gb->buf_put += count;
2191                 else /* count == len */
2192                         gb->buf_put = gb->buf_buf;
2193         }
2194
2195         return count;
2196 }
2197
2198 /*
2199  * gs_buf_get
2200  *
2201  * Get data from the circular buffer and copy to the given buffer.
2202  * Restrict to the amount of data available.
2203  *
2204  * Return the number of bytes copied.
2205  */
2206 static unsigned int
2207 gs_buf_get(struct gs_buf *gb, char *buf, unsigned int count)
2208 {
2209         unsigned int len;
2210
2211         if (gb == NULL)
2212                 return 0;
2213
2214         len = gs_buf_data_avail(gb);
2215         if (count > len)
2216                 count = len;
2217
2218         if (count == 0)
2219                 return 0;
2220
2221         len = gb->buf_buf + gb->buf_size - gb->buf_get;
2222         if (count > len) {
2223                 memcpy(buf, gb->buf_get, len);
2224                 memcpy(buf+len, gb->buf_buf, count - len);
2225                 gb->buf_get = gb->buf_buf + count - len;
2226         } else {
2227                 memcpy(buf, gb->buf_get, count);
2228                 if (count < len)
2229                         gb->buf_get += count;
2230                 else /* count == len */
2231                         gb->buf_get = gb->buf_buf;
2232         }
2233
2234         return count;
2235 }
2236
2237 /*-------------------------------------------------------------------------*/
2238
2239 static struct tty_driver *gs_tty_driver;
2240
2241 /*
2242  *  gs_module_init
2243  *
2244  *  Register as a USB gadget driver and a tty driver.
2245  */
2246 static int __init gs_module_init(void)
2247 {
2248         int i;
2249         int retval;
2250
2251         retval = usb_gadget_register_driver(&gs_gadget_driver);
2252         if (retval) {
2253                 pr_err("gs_module_init: cannot register gadget driver, "
2254                         "ret=%d\n", retval);
2255                 return retval;
2256         }
2257
2258         gs_tty_driver = alloc_tty_driver(GS_NUM_PORTS);
2259         if (!gs_tty_driver)
2260                 return -ENOMEM;
2261         gs_tty_driver->owner = THIS_MODULE;
2262         gs_tty_driver->driver_name = GS_SHORT_NAME;
2263         gs_tty_driver->name = "ttygs";
2264         gs_tty_driver->major = GS_MAJOR;
2265         gs_tty_driver->minor_start = GS_MINOR_START;
2266         gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
2267         gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
2268         gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
2269         gs_tty_driver->init_termios = tty_std_termios;
2270         /* must match GS_DEFAULT_DTE_RATE and friends */
2271         gs_tty_driver->init_termios.c_cflag =
2272                 B9600 | CS8 | CREAD | HUPCL | CLOCAL;
2273         gs_tty_driver->init_termios.c_ispeed = GS_DEFAULT_DTE_RATE;
2274         gs_tty_driver->init_termios.c_ospeed = GS_DEFAULT_DTE_RATE;
2275         tty_set_operations(gs_tty_driver, &gs_tty_ops);
2276
2277         for (i = 0; i < GS_NUM_PORTS; i++)
2278                 mutex_init(&gs_open_close_lock[i]);
2279
2280         retval = tty_register_driver(gs_tty_driver);
2281         if (retval) {
2282                 usb_gadget_unregister_driver(&gs_gadget_driver);
2283                 put_tty_driver(gs_tty_driver);
2284                 pr_err("gs_module_init: cannot register tty driver, "
2285                                 "ret=%d\n", retval);
2286                 return retval;
2287         }
2288
2289         pr_info("gs_module_init: %s %s loaded\n",
2290                         GS_LONG_NAME, GS_VERSION_STR);
2291         return 0;
2292 }
2293 module_init(gs_module_init);
2294
2295 /*
2296  * gs_module_exit
2297  *
2298  * Unregister as a tty driver and a USB gadget driver.
2299  */
2300 static void __exit gs_module_exit(void)
2301 {
2302         tty_unregister_driver(gs_tty_driver);
2303         put_tty_driver(gs_tty_driver);
2304         usb_gadget_unregister_driver(&gs_gadget_driver);
2305
2306         pr_info("gs_module_exit: %s %s unloaded\n",
2307                         GS_LONG_NAME, GS_VERSION_STR);
2308 }
2309 module_exit(gs_module_exit);