projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
usb gadget: split out serial core
[deliverable/linux.git] / drivers / usb / gadget / serial.c
CommitLineData
1da177e4
LT		 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.
1da177e4
LT		 17 */
18
1da177e4 19#include <linux/kernel.h>
1da177e4 20#include <linux/utsname.h>
1da177e4
LT		 21#include <linux/device.h>
22#include <linux/tty.h>
23#include <linux/tty_flip.h>
1da177e4 24
5f848137 25#include <linux/usb/ch9.h>
a8c28f23 26#include <linux/usb/cdc.h>
9454a57a 27#include <linux/usb/gadget.h>
1da177e4
LT		 28
29#include "gadget_chips.h"
30
31
1da177e4
LT		 32/* Defines */
33
ca094f11 34#define GS_VERSION_STR "v2.2"
b9370332 35#define GS_VERSION_NUM 0x2200
1da177e4
LT		 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
9079e91b
DB		 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
1da177e4
LT		 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
9079e91b
DB		 71/* 9600-8-N-1 ... matches init_termios.c_cflag and defaults
72 * expected by "usbser.sys" on MS-Windows.
73 */
1da177e4
LT		 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
51a0e85c
DB		 79/* maxpacket and other transfer characteristics vary by speed. */
80static inline struct usb_endpoint_descriptor *
81choose_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
1da177e4
LT		 89
90/* debug settings */
51a0e85c 91#ifdef DEBUG
1da177e4 92static int debug = 1;
51a0e85c
DB		 93#else
94#define debug 0
95#endif
1da177e4
LT		 96
97#define gs_debug(format, arg...) \
00274921 98 do { if (debug) pr_debug(format, ## arg); } while (0)
1da177e4 99#define gs_debug_level(level, format, arg...) \
00274921 100 do { if (debug >= level) pr_debug(format, ## arg); } while (0)
1da177e4 101
1da177e4
LT		 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
1da177e4
LT		 116/* circular buffer */
117struct gs_buf {
118 unsigned int buf_size;
119 char *buf_buf;
120 char *buf_get;
121 char *buf_put;
122};
123
1da177e4
LT		 124/* the port structure holds info for each port, one for each minor number */
125struct gs_port {
51a0e85c 126 struct gs_dev *port_dev; /* pointer to device struct */
1da177e4
LT		 127 struct tty_struct *port_tty; /* pointer to tty struct */
128 spinlock_t port_lock;
51a0e85c 129 int port_num;
1da177e4
LT		 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;
f371e750
DB		 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)
1da177e4
LT		 138};
139
140/* the device structure holds info for the USB device */
141struct 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 */
093cf723 148 struct usb_endpoint_descriptor /* descriptor of notify ep */
1da177e4
LT		 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
9079e91b 163/* tty driver internals */
1da177e4
LT		 164static int gs_send(struct gs_dev *dev);
165static int gs_send_packet(struct gs_dev *dev, char *packet,
166 unsigned int size);
167static int gs_recv_packet(struct gs_dev *dev, char *packet,
168 unsigned int size);
169static void gs_read_complete(struct usb_ep *ep, struct usb_request *req);
170static void gs_write_complete(struct usb_ep *ep, struct usb_request *req);
171
9079e91b 172/* gadget driver internals */
1da177e4
LT		 173static int gs_set_config(struct gs_dev *dev, unsigned config);
174static void gs_reset_config(struct gs_dev *dev);
51a0e85c 175static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
1da177e4
LT		 176 u8 type, unsigned int index, int is_otg);
177
178static struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned int len,
55016f10 179 gfp_t kmalloc_flags);
1da177e4
LT		 180static void gs_free_req(struct usb_ep *ep, struct usb_request *req);
181
55016f10 182static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags);
1da177e4
LT		 183static void gs_free_ports(struct gs_dev *dev);
184
185/* circular buffer */
55016f10 186static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags);
1da177e4
LT		 187static void gs_buf_free(struct gs_buf *gb);
188static void gs_buf_clear(struct gs_buf *gb);
189static unsigned int gs_buf_data_avail(struct gs_buf *gb);
190static unsigned int gs_buf_space_avail(struct gs_buf *gb);
191static unsigned int gs_buf_put(struct gs_buf *gb, const char *buf,
192 unsigned int count);
193static unsigned int gs_buf_get(struct gs_buf *gb, char *buf,
194 unsigned int count);
195
1da177e4
LT		 196
197/* Globals */
198
199static struct gs_dev *gs_device;
200
831c70fc 201static struct mutex gs_open_close_lock[GS_NUM_PORTS];
1da177e4 202
1da177e4 203
9079e91b 204/*-------------------------------------------------------------------------*/
1da177e4
LT		 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 */
217static char manufacturer[50];
218static struct usb_string gs_strings[] = {
219 { GS_MANUFACTURER_STR_ID, manufacturer },
220 { GS_PRODUCT_STR_ID, GS_LONG_NAME },
1da177e4
LT		 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
228static struct usb_gadget_strings gs_string_table = {
229 .language = 0x0409, /* en-us */
230 .strings = gs_strings,
231};
232
233static 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,
1da177e4
LT		 243 .bNumConfigurations = GS_NUM_CONFIGS,
244};
245
246static 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
252static 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
263static 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
274static 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,
b9370332 279 .bInterfaceClass = USB_CLASS_VENDOR_SPEC,
1da177e4
LT		 280 .bInterfaceSubClass = 0,
281 .bInterfaceProtocol = 0,
282 .iInterface = GS_DATA_STR_ID,
283};
284
285static 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
296static 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
307static 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
314static const struct usb_cdc_call_mgmt_descriptor gs_call_mgmt_descriptor = {
51a0e85c
DB		 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 */
1da177e4
LT		 320};
321
322static struct usb_cdc_acm_descriptor gs_acm_descriptor = {
51a0e85c
DB		 323 .bLength = sizeof(gs_acm_descriptor),
324 .bDescriptorType = USB_DT_CS_INTERFACE,
325 .bDescriptorSubType = USB_CDC_ACM_TYPE,
f371e750 326 .bmCapabilities = (1 << 1),
1da177e4
LT		 327};
328
329static 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};
51a0e85c 336
1da177e4
LT		 337static 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
346static 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
353static 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
360static 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
368static 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
1da177e4
LT		 382static 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
391static 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
398static 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
405static 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
413static 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
421static 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
1da177e4 435
9079e91b
DB		 436/*-------------------------------------------------------------------------*/
437
1da177e4
LT		 438/* Module */
439MODULE_DESCRIPTION(GS_LONG_NAME);
440MODULE_AUTHOR("Al Borchers");
441MODULE_LICENSE("GPL");
442
51a0e85c 443#ifdef DEBUG
1da177e4
LT		 444module_param(debug, int, S_IRUGO|S_IWUSR);
445MODULE_PARM_DESC(debug, "Enable debugging, 0=off, 1=on");
446#endif
447
9079e91b 448static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE;
1da177e4
LT		 449module_param(read_q_size, uint, S_IRUGO);
450MODULE_PARM_DESC(read_q_size, "Read request queue size, default=32");
451
9079e91b 452static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE;
1da177e4
LT		 453module_param(write_q_size, uint, S_IRUGO);
454MODULE_PARM_DESC(write_q_size, "Write request queue size, default=32");
455
9079e91b 456static unsigned int write_buf_size = GS_DEFAULT_WRITE_BUF_SIZE;
1da177e4
LT		 457module_param(write_buf_size, uint, S_IRUGO);
458MODULE_PARM_DESC(write_buf_size, "Write buffer size, default=8192");
459
9079e91b 460static unsigned int use_acm = GS_DEFAULT_USE_ACM;
1da177e4
LT		 461module_param(use_acm, uint, S_IRUGO);
462MODULE_PARM_DESC(use_acm, "Use CDC ACM, 0=no, 1=yes, default=no");
463
9079e91b 464/*-------------------------------------------------------------------------*/
1da177e4
LT		 465
466/* TTY Driver */
467
468/*
469 * gs_open
470 */
471static 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;
831c70fc 478 struct mutex *mtx;
1da177e4
LT		 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) {
00274921 486 pr_err("gs_open: (%d,%p,%p) invalid port number\n",
1da177e4
LT		 487 port_num, tty, file);
488 return -ENODEV;
489 }
490
491 dev = gs_device;
492
493 if (dev == NULL) {
00274921 494 pr_err("gs_open: (%d,%p,%p) NULL device pointer\n",
1da177e4
LT		 495 port_num, tty, file);
496 return -ENODEV;
497 }
498
831c70fc
MK		 499 mtx = &gs_open_close_lock[port_num];
500 if (mutex_lock_interruptible(mtx)) {
00274921 501 pr_err("gs_open: (%d,%p,%p) interrupted waiting for mutex\n",
1da177e4
LT		 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) {
00274921 509 pr_err("gs_open: (%d,%p,%p) device is not connected\n",
1da177e4
LT		 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) {
00274921 518 pr_err("gs_open: (%d,%p,%p) NULL port pointer\n",
1da177e4
LT		 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) {
00274921 528 pr_err("gs_open: (%d,%p,%p) port disconnected (1)\n",
1da177e4
LT		 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) {
00274921 555 pr_err("gs_open: (%d,%p,%p) port disconnected (2)\n",
1da177e4
LT		 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) {
00274921
DB		 563 pr_err("gs_open: (%d,%p,%p) cannot allocate "
564 "port write buffer\n",
1da177e4
LT		 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) {
00274921 577 pr_err("gs_open: (%d,%p,%p) port disconnected (3)\n",
1da177e4
LT		 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
593exit_unlock_port:
594 spin_unlock_irqrestore(&port->port_lock, flags);
831c70fc 595 mutex_unlock(mtx);
1da177e4
LT		 596 return ret;
597
598exit_unlock_dev:
599 spin_unlock_irqrestore(&dev->dev_lock, flags);
831c70fc 600 mutex_unlock(mtx);
1da177e4
LT		 601 return ret;
602
603}
604
605/*
606 * gs_close
607 */
943e1b4d 608
9079e91b
DB		 609static 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}
943e1b4d 618
1da177e4
LT		 619static void gs_close(struct tty_struct *tty, struct file *file)
620{
1da177e4 621 struct gs_port *port = tty->driver_data;
831c70fc 622 struct mutex *mtx;
1da177e4
LT		 623
624 if (port == NULL) {
00274921 625 pr_err("gs_close: NULL port pointer\n");
1da177e4
LT		 626 return;
627 }
628
629 gs_debug("gs_close: (%d,%p,%p)\n", port->port_num, tty, file);
630
831c70fc
MK		 631 mtx = &gs_open_close_lock[port->port_num];
632 mutex_lock(mtx);
1da177e4 633
ca094f11 634 spin_lock_irq(&port->port_lock);
1da177e4
LT		 635
636 if (port->port_open_count == 0) {
00274921 637 pr_err("gs_close: (%d,%p,%p) port is already closed\n",
1da177e4
LT		 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) {
ca094f11 661 spin_unlock_irq(&port->port_lock);
943e1b4d 662 wait_event_interruptible_timeout(port->port_write_wait,
9079e91b 663 gs_write_finished_event_safely(port),
943e1b4d 664 GS_CLOSE_TIMEOUT * HZ);
ca094f11 665 spin_lock_irq(&port->port_lock);
1da177e4
LT		 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
684exit:
ca094f11 685 spin_unlock_irq(&port->port_lock);
831c70fc 686 mutex_unlock(mtx);
1da177e4
LT		 687}
688
689/*
690 * gs_write
691 */
692static 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) {
00274921 699 pr_err("gs_write: NULL port pointer\n");
1da177e4
LT		 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) {
00274921 712 pr_err("gs_write: (%d,%p) port is not connected\n",
1da177e4
LT		 713 port->port_num, tty);
714 ret = -EIO;
715 goto exit;
716 }
717
718 if (port->port_open_count == 0) {
00274921 719 pr_err("gs_write: (%d,%p) port is closed\n",
1da177e4
LT		 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
736exit:
737 spin_unlock_irqrestore(&port->port_lock, flags);
738 return ret;
739}
740
741/*
742 * gs_put_char
743 */
4cd55ab1 744static int gs_put_char(struct tty_struct *tty, unsigned char ch)
1da177e4
LT		 745{
746 unsigned long flags;
747 struct gs_port *port = tty->driver_data;
4cd55ab1 748 int ret = 0;
1da177e4
LT		 749
750 if (port == NULL) {
00274921 751 pr_err("gs_put_char: NULL port pointer\n");
4cd55ab1 752 return 0;
1da177e4
LT		 753 }
754
51a0e85c
DB		 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));
1da177e4
LT		 757
758 spin_lock_irqsave(&port->port_lock, flags);
759
760 if (port->port_dev == NULL) {
00274921 761 pr_err("gs_put_char: (%d,%p) port is not connected\n",
1da177e4
LT		 762 port->port_num, tty);
763 goto exit;
764 }
765
766 if (port->port_open_count == 0) {
00274921 767 pr_err("gs_put_char: (%d,%p) port is closed\n",
1da177e4
LT		 768 port->port_num, tty);
769 goto exit;
770 }
771
4cd55ab1 772 ret = gs_buf_put(port->port_write_buf, &ch, 1);
1da177e4
LT		 773
774exit:
775 spin_unlock_irqrestore(&port->port_lock, flags);
4cd55ab1 776 return ret;
1da177e4
LT		 777}
778
779/*
780 * gs_flush_chars
781 */
782static 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) {
00274921 788 pr_err("gs_flush_chars: NULL port pointer\n");
1da177e4
LT		 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) {
00274921 797 pr_err("gs_flush_chars: (%d,%p) port is not connected\n",
1da177e4
LT		 798 port->port_num, tty);
799 goto exit;
800 }
801
802 if (port->port_open_count == 0) {
00274921 803 pr_err("gs_flush_chars: (%d,%p) port is closed\n",
1da177e4
LT		 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
814exit:
815 spin_unlock_irqrestore(&port->port_lock, flags);
816}
817
818/*
819 * gs_write_room
820 */
821static 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 */
849static 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 */
875static void gs_throttle(struct tty_struct *tty)
876{
877}
878
879/*
880 * gs_unthrottle
881 */
882static void gs_unthrottle(struct tty_struct *tty)
883{
884}
885
886/*
887 * gs_break
888 */
889static void gs_break(struct tty_struct *tty, int break_state)
890{
891}
892
893/*
894 * gs_ioctl
895 */
896static 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) {
00274921 901 pr_err("gs_ioctl: NULL port pointer\n");
1da177e4
LT		 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 */
606d099c 917static void gs_set_termios(struct tty_struct *tty, struct ktermios *old)
1da177e4
LT		 918{
919}
920
9079e91b
DB		 921static 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
1da177e4
LT		 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*/
947static 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;
1da177e4
LT		 953
954 if (dev == NULL) {
00274921 955 pr_err("gs_send: NULL device pointer\n");
1da177e4
LT		 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
2c2d28a0
DB		 965 req = list_entry(dev->dev_req_list.next,
966 struct usb_request, list);
1da177e4
LT		 967
968 len = gs_send_packet(dev, req->buf, ep->maxpacket);
969
970 if (len > 0) {
51a0e85c
DB		 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));
2c2d28a0 976 list_del(&req->list);
1da177e4 977 req->length = len;
80f8af0c 978 spin_unlock_irqrestore(&dev->dev_lock, flags);
1da177e4 979 if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
00274921 980 pr_err(
1da177e4
LT		 981 "gs_send: cannot queue read request, ret=%d\n",
982 ret);
80f8af0c 983 spin_lock_irqsave(&dev->dev_lock, flags);
1da177e4
LT		 984 break;
985 }
80f8af0c 986 spin_lock_irqsave(&dev->dev_lock, flags);
1da177e4
LT		 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 */
1012static 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) {
00274921 1021 pr_err("gs_send_packet: port=%d, NULL port pointer\n", 0);
1da177e4
LT		 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
1039exit:
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 */
1057static 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;
33f0f88f 1062 struct tty_struct *tty;
1da177e4
LT		 1063
1064 /* TEMPORARY -- only port 0 is supported right now */
1065 port = dev->dev_port[0];
1066
1067 if (port == NULL) {
00274921 1068 pr_err("gs_recv_packet: port=%d, NULL port pointer\n",
1da177e4
LT		 1069 port->port_num);
1070 return -EIO;
1071 }
1072
1073 spin_lock(&port->port_lock);
1074
1075 if (port->port_open_count == 0) {
00274921 1076 pr_err("gs_recv_packet: port=%d, port is closed\n",
1da177e4
LT		 1077 port->port_num);
1078 ret = -EIO;
1079 goto exit;
1080 }
1081
33f0f88f
AC		 1082
1083 tty = port->port_tty;
1084
1085 if (tty == NULL) {
00274921 1086 pr_err("gs_recv_packet: port=%d, NULL tty pointer\n",
1da177e4
LT		 1087 port->port_num);
1088 ret = -EIO;
1089 goto exit;
1090 }
1091
1092 if (port->port_tty->magic != TTY_MAGIC) {
00274921 1093 pr_err("gs_recv_packet: port=%d, bad tty magic\n",
1da177e4
LT		 1094 port->port_num);
1095 ret = -EIO;
1096 goto exit;
1097 }
1098
33f0f88f
AC		 1099 len = tty_buffer_request_room(tty, size);
1100 if (len > 0) {
1101 tty_insert_flip_string(tty, packet, len);
1da177e4
LT		 1102 tty_flip_buffer_push(port->port_tty);
1103 wake_up_interruptible(&port->port_tty->read_wait);
1104 }
1da177e4 1105 ret = 0;
1da177e4
LT		 1106exit:
1107 spin_unlock(&port->port_lock);
1108 return ret;
1109}
1110
1111/*
1112* gs_read_complete
1113*/
1114static 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) {
00274921 1120 pr_err("gs_read_complete: NULL device pointer\n");
1da177e4
LT		 1121 return;
1122 }
1123
1124 switch(req->status) {
1125 case 0:
51a0e85c 1126 /* normal completion */
1da177e4
LT		 1127 gs_recv_packet(dev, req->buf, req->actual);
1128requeue:
1129 req->length = ep->maxpacket;
1130 if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
00274921 1131 pr_err(
1da177e4
LT		 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 */
00274921 1145 pr_err(
1da177e4
LT		 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*/
1156static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
1157{
1158 struct gs_dev *dev = ep->driver_data;
1da177e4
LT		 1159
1160 if (dev == NULL) {
00274921 1161 pr_err("gs_write_complete: NULL device pointer\n");
1da177e4
LT		 1162 return;
1163 }
1164
1165 switch(req->status) {
1166 case 0:
1167 /* normal completion */
1168requeue:
1da177e4 1169 spin_lock(&dev->dev_lock);
2c2d28a0 1170 list_add(&req->list, &dev->dev_req_list);
1da177e4
LT		 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:
00274921 1184 pr_err(
1da177e4
LT		 1185 "gs_write_complete: unexpected status error, status=%d\n",
1186 req->status);
1187 goto requeue;
1188 break;
1189 }
1190}
1191
9079e91b
DB		 1192/*-------------------------------------------------------------------------*/
1193
1da177e4
LT		 1194/* Gadget Driver */
1195
9079e91b
DB		 1196/*
1197 * gs_unbind
1198 *
1199 * Called on module unload. Frees the control request and device
1200 * structure.
1201 */
1202static 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 }
734d37c6 1214 gs_reset_config(dev);
9079e91b 1215 gs_free_ports(dev);
9079e91b
DB		 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
1da177e4
LT		 1224/*
1225 * gs_bind
1226 *
1227 * Called on module load. Allocates and initializes the device
1228 * structure and a control request.
1229 */
329af28b 1230static int __init gs_bind(struct usb_gadget *gadget)
1da177e4
LT		 1231{
1232 int ret;
1233 struct usb_ep *ep;
1234 struct gs_dev *dev;
91e79c91 1235 int gcnum;
1da177e4 1236
91e79c91
DB		 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))
1da177e4 1242 use_acm = 0;
91e79c91
DB		 1243
1244 gcnum = usb_gadget_controller_number(gadget);
1245 if (gcnum >= 0)
1da177e4 1246 gs_device_desc.bcdDevice =
91e79c91
DB		 1247 cpu_to_le16(GS_VERSION_NUM | gcnum);
1248 else {
00274921 1249 pr_warning("gs_bind: controller '%s' not recognized\n",
1da177e4
LT		 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
734d37c6
DB		 1256 dev = kzalloc(sizeof(struct gs_dev), GFP_KERNEL);
1257 if (dev == NULL)
1258 return -ENOMEM;
1259
1da177e4
LT		 1260 usb_ep_autoconfig_reset(gadget);
1261
1262 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc);
1263 if (!ep)
1264 goto autoconf_fail;
734d37c6
DB		 1265 dev->dev_in_ep = ep;
1266 ep->driver_data = dev; /* claim the endpoint */
1da177e4
LT		 1267
1268 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc);
1269 if (!ep)
1270 goto autoconf_fail;
734d37c6
DB		 1271 dev->dev_out_ep = ep;
1272 ep->driver_data = dev; /* claim the endpoint */
1da177e4
LT		 1273
1274 if (use_acm) {
1275 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_notify_desc);
1276 if (!ep) {
00274921 1277 pr_err("gs_bind: cannot run ACM on %s\n", gadget->name);
1da177e4
LT		 1278 goto autoconf_fail;
1279 }
1280 gs_device_desc.idProduct = __constant_cpu_to_le16(
1281 GS_CDC_PRODUCT_ID),
734d37c6
DB		 1282 dev->dev_notify_ep = ep;
1283 ep->driver_data = dev; /* claim the endpoint */
1da177e4
LT		 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
51a0e85c
DB		 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 }
1da177e4
LT		 1304
1305 usb_gadget_set_selfpowered(gadget);
1306
51a0e85c 1307 if (gadget_is_otg(gadget)) {
1da177e4
LT		 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
734d37c6 1313 gs_device = dev;
1da177e4
LT		 1314
1315 snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
96b644bd 1316 init_utsname()->sysname, init_utsname()->release,
1da177e4
LT		 1317 gadget->name);
1318
1da177e4
LT		 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) {
00274921 1325 pr_err("gs_bind: cannot allocate ports\n");
1da177e4
LT		 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 }
1da177e4
LT		 1337 gadget->ep0->driver_data = dev;
1338
00274921 1339 pr_info("gs_bind: %s %s bound\n",
1da177e4
LT		 1340 GS_LONG_NAME, GS_VERSION_STR);
1341
1342 return 0;
1343
1344autoconf_fail:
734d37c6 1345 kfree(dev);
00274921 1346 pr_err("gs_bind: cannot autoconfigure on %s\n", gadget->name);
1da177e4
LT		 1347 return -ENODEV;
1348}
1349
1da177e4
LT		 1350static 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;
1bbc1696
DB		 1356 u16 wIndex = le16_to_cpu(ctrl->wIndex);
1357 u16 wValue = le16_to_cpu(ctrl->wValue);
1358 u16 wLength = le16_to_cpu(ctrl->wLength);
1da177e4
LT		 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
1da177e4 1372 case USB_DT_DEVICE_QUALIFIER:
51a0e85c 1373 if (!gadget_is_dualspeed(gadget))
1da177e4
LT		 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:
51a0e85c 1381 if (!gadget_is_dualspeed(gadget))
1da177e4
LT		 1382 break;
1383 /* fall through */
1da177e4 1384 case USB_DT_CONFIG:
51a0e85c 1385 ret = gs_build_config_buf(req->buf, gadget,
1da177e4 1386 wValue >> 8, wValue & 0xff,
51a0e85c 1387 gadget_is_otg(gadget));
1da177e4
LT		 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;
1449set_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:
00274921
DB		 1469 pr_err("gs_setup: unknown standard request, type=%02x, "
1470 "request=%02x, value=%04x, index=%04x, length=%d\n",
1da177e4
LT		 1471 ctrl->bRequestType, ctrl->bRequest,
1472 wValue, wIndex, wLength);
1473 break;
1474 }
1475
1476 return ret;
1477}
1478
9079e91b
DB		 1479static 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
1da177e4
LT		 1515static 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;
1bbc1696
DB		 1522 u16 wIndex = le16_to_cpu(ctrl->wIndex);
1523 u16 wValue = le16_to_cpu(ctrl->wValue);
1524 u16 wLength = le16_to_cpu(ctrl->wLength);
1da177e4
LT		 1525
1526 switch (ctrl->bRequest) {
1527 case USB_CDC_REQ_SET_LINE_CODING:
f371e750
DB		 1528 if (wLength != sizeof(struct usb_cdc_line_coding))
1529 break;
1530 ret = wLength;
1531 req->complete = gs_setup_complete_set_line_coding;
1da177e4
LT		 1532 break;
1533
1534 case USB_CDC_REQ_GET_LINE_CODING:
f371e750 1535 ret = min_t(int, wLength, sizeof(struct usb_cdc_line_coding));
1da177e4
LT		 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:
f371e750
DB		 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 }
1da177e4
LT		 1556 break;
1557
1558 default:
f371e750
DB		 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 */
00274921 1565 pr_err("gs_setup: unknown class request, "
49b4f902
DB		 1566 "type=%02x, request=%02x, value=%04x, "
1567 "index=%04x, length=%d\n",
1da177e4
LT		 1568 ctrl->bRequestType, ctrl->bRequest,
1569 wValue, wIndex, wLength);
1570 break;
1571 }
1572
1573 return ret;
1574}
1575
9079e91b
DB		 1576/*
1577 * gs_setup_complete
1578 */
1579static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req)
f371e750 1580{
9079e91b
DB		 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}
f371e750 1587
9079e91b
DB		 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 */
1597static 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);
f371e750 1606
9079e91b
DB		 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);
f371e750
DB		 1612 break;
1613
9079e91b
DB		 1614 case USB_TYPE_CLASS:
1615 ret = gs_setup_class(gadget, ctrl);
f371e750
DB		 1616 break;
1617
1618 default:
9079e91b
DB		 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);
f371e750
DB		 1623 break;
1624 }
f371e750 1625
9079e91b
DB		 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 }
1da177e4 1638 }
9079e91b
DB		 1639
1640 /* device either stalls (ret < 0) or reports success */
1641 return ret;
1da177e4
LT		 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 */
1651static 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)
00274921 1666 pr_err("gs_disconnect: cannot re-allocate ports\n");
1da177e4
LT		 1667
1668 spin_unlock_irqrestore(&dev->dev_lock, flags);
1669
00274921 1670 pr_info("gs_disconnect: %s disconnected\n", GS_LONG_NAME);
1da177e4
LT		 1671}
1672
9079e91b
DB		 1673static 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
1da177e4
LT		 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 */
1699static 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;
734d37c6 1705 struct usb_endpoint_descriptor *out, *in, *notify;
1da177e4 1706 struct usb_request *req;
1da177e4
LT		 1707
1708 if (dev == NULL) {
00274921 1709 pr_err("gs_set_config: NULL device pointer\n");
1da177e4
LT		 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;
1da177e4
LT		 1724 break;
1725 case GS_ACM_CONFIG_ID:
1726 if (!use_acm)
1727 return -EINVAL;
1da177e4
LT		 1728 break;
1729 default:
1730 return -EINVAL;
1731 }
1732
734d37c6
DB		 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,
1da177e4 1741 &gs_highspeed_notify_desc,
734d37c6
DB		 1742 &gs_fullspeed_notify_desc)
1743 : NULL;
1da177e4 1744
734d37c6
DB		 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 }
1da177e4 1753
734d37c6
DB		 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);
1760fail0:
1761 usb_ep_disable(dev->dev_in_ep);
1762 return ret;
1da177e4
LT		 1763 }
1764
734d37c6
DB		 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 }
1da177e4
LT		 1776 }
1777
734d37c6
DB		 1778 dev->dev_config = config;
1779
1da177e4
LT		 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))) {
00274921
DB		 1786 pr_err("gs_set_config: cannot queue read "
1787 "request, ret=%d\n", ret);
1da177e4
LT		 1788 }
1789 } else {
00274921
DB		 1790 pr_err("gs_set_config: cannot allocate "
1791 "read requests\n");
1da177e4
LT		 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++) {
2c2d28a0
DB		 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);
1da177e4 1804 } else {
00274921
DB		 1805 pr_err("gs_set_config: cannot allocate "
1806 "write requests\n");
1da177e4
LT		 1807 ret = -ENOMEM;
1808 goto exit_reset_config;
1809 }
1810 }
1811
f371e750
DB		 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
00274921 1817 pr_info("gs_set_config: %s configured, %s speed %s config\n",
1da177e4
LT		 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
1824exit_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 */
1839static void gs_reset_config(struct gs_dev *dev)
1840{
2c2d28a0 1841 struct usb_request *req;
1da177e4
LT		 1842
1843 if (dev == NULL) {
00274921 1844 pr_err("gs_reset_config: NULL device pointer\n");
1da177e4
LT		 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)) {
2c2d28a0
DB		 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);
1da177e4
LT		 1859 }
1860
1861 /* disable endpoints, forcing completion of pending i/o; */
1862 /* completion handlers free their requests in this case */
734d37c6 1863 if (dev->dev_notify_ep)
1da177e4 1864 usb_ep_disable(dev->dev_notify_ep);
734d37c6
DB		 1865 usb_ep_disable(dev->dev_in_ep);
1866 usb_ep_disable(dev->dev_out_ep);
1da177e4
LT		 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 */
51a0e85c 1875static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
1da177e4
LT		 1876 u8 type, unsigned int index, int is_otg)
1877{
1878 int len;
51a0e85c 1879 int high_speed = 0;
1da177e4
LT		 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 */
51a0e85c
DB		 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 }
1da177e4
LT		 1892
1893 if (use_acm) {
1894 config_desc = &gs_acm_config_desc;
51a0e85c
DB		 1895 function = high_speed
1896 ? gs_acm_highspeed_function
1897 : gs_acm_fullspeed_function;
1da177e4
LT		 1898 } else {
1899 config_desc = &gs_bulk_config_desc;
51a0e85c
DB		 1900 function = high_speed
1901 ? gs_bulk_highspeed_function
1902 : gs_bulk_fullspeed_function;
1da177e4
LT		 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 */
1bbc1696 1924static struct usb_request *
55016f10 1925gs_alloc_req(struct usb_ep *ep, unsigned int len, gfp_t kmalloc_flags)
1da177e4
LT		 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 */
1951static 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
1da177e4
LT		 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 */
55016f10 1967static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags)
1da177e4
LT		 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++) {
7039f422 1976 if ((port=kzalloc(sizeof(struct gs_port), kmalloc_flags)) == NULL)
1da177e4
LT		 1977 return -ENOMEM;
1978
1da177e4
LT		 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 */
2004static 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) {
4208978e 2028 tty_hangup(port->port_tty);
1da177e4
LT		 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
9079e91b
DB		 2040/*-------------------------------------------------------------------------*/
2041
1da177e4
LT		 2042/* Circular Buffer */
2043
2044/*
2045 * gs_buf_alloc
2046 *
2047 * Allocate a circular buffer and all associated memory.
2048 */
55016f10 2049static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags)
1da177e4
LT		 2050{
2051 struct gs_buf *gb;
2052
2053 if (size == 0)
2054 return NULL;
2055
5cbded58 2056 gb = kmalloc(sizeof(struct gs_buf), kmalloc_flags);
1da177e4
LT		 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 */
b29dbbd8 2077static void gs_buf_free(struct gs_buf *gb)
1da177e4 2078{
1bc3c9e1
JJ		 2079 if (gb) {
2080 kfree(gb->buf_buf);
1da177e4
LT		 2081 kfree(gb);
2082 }
2083}
2084
2085/*
2086 * gs_buf_clear
2087 *
2088 * Clear out all data in the circular buffer.
2089 */
b29dbbd8 2090static void gs_buf_clear(struct gs_buf *gb)
1da177e4
LT		 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 */
b29dbbd8 2103static unsigned int gs_buf_data_avail(struct gs_buf *gb)
1da177e4
LT		 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 */
b29dbbd8 2117static unsigned int gs_buf_space_avail(struct gs_buf *gb)
1da177e4
LT		 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 */
b29dbbd8
DB		 2133static unsigned int
2134gs_buf_put(struct gs_buf *gb, const char *buf, unsigned int count)
1da177e4
LT		 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 */
b29dbbd8
DB		 2172static unsigned int
2173gs_buf_get(struct gs_buf *gb, char *buf, unsigned int count)
1da177e4
LT		 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}
9079e91b
DB		 2202
2203/*-------------------------------------------------------------------------*/
2204
2205static 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 */
2212static 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}
2259module_init(gs_module_init);
2260
2261/*
2262 * gs_module_exit
2263 *
2264 * Unregister as a tty driver and a USB gadget driver.
2265 */
2266static 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}
2275module_exit(gs_module_exit);
Linux kernel - Deliverables
This page took 0.863334 seconds and 5 git commands to generate.