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