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