2 * g_serial.c -- USB gadget serial driver
4 * Copyright 2003 (C) Al Borchers (alborchers@steinerpoint.com)
6 * This code is based in part on the Gadget Zero driver, which
7 * is Copyright (C) 2003 by David Brownell, all rights reserved.
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)
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.
20 #include <linux/module.h>
21 #include <linux/kernel.h>
22 #include <linux/delay.h>
23 #include <linux/ioport.h>
24 #include <linux/slab.h>
25 #include <linux/errno.h>
26 #include <linux/init.h>
27 #include <linux/timer.h>
28 #include <linux/list.h>
29 #include <linux/interrupt.h>
30 #include <linux/utsname.h>
31 #include <linux/wait.h>
32 #include <linux/proc_fs.h>
33 #include <linux/device.h>
34 #include <linux/tty.h>
35 #include <linux/tty_flip.h>
37 #include <asm/byteorder.h>
40 #include <asm/system.h>
41 #include <asm/unaligned.h>
42 #include <asm/uaccess.h>
44 #include <linux/usb/ch9.h>
45 #include <linux/usb/cdc.h>
46 #include <linux/usb_gadget.h>
48 #include "gadget_chips.h"
53 #define GS_VERSION_STR "v2.2"
54 #define GS_VERSION_NUM 0x0202
56 #define GS_LONG_NAME "Gadget Serial"
57 #define GS_SHORT_NAME "g_serial"
60 #define GS_MINOR_START 0
62 #define GS_NUM_PORTS 16
64 #define GS_NUM_CONFIGS 1
65 #define GS_NO_CONFIG_ID 0
66 #define GS_BULK_CONFIG_ID 1
67 #define GS_ACM_CONFIG_ID 2
69 #define GS_MAX_NUM_INTERFACES 2
70 #define GS_BULK_INTERFACE_ID 0
71 #define GS_CONTROL_INTERFACE_ID 0
72 #define GS_DATA_INTERFACE_ID 1
74 #define GS_MAX_DESC_LEN 256
76 #define GS_DEFAULT_READ_Q_SIZE 32
77 #define GS_DEFAULT_WRITE_Q_SIZE 32
79 #define GS_DEFAULT_WRITE_BUF_SIZE 8192
80 #define GS_TMP_BUF_SIZE 8192
82 #define GS_CLOSE_TIMEOUT 15
84 #define GS_DEFAULT_USE_ACM 0
86 #define GS_DEFAULT_DTE_RATE 9600
87 #define GS_DEFAULT_DATA_BITS 8
88 #define GS_DEFAULT_PARITY USB_CDC_NO_PARITY
89 #define GS_DEFAULT_CHAR_FORMAT USB_CDC_1_STOP_BITS
91 /* select highspeed/fullspeed, hiding highspeed if not configured */
92 #ifdef CONFIG_USB_GADGET_DUALSPEED
93 #define GS_SPEED_SELECT(is_hs,hs,fs) ((is_hs) ? (hs) : (fs))
95 #define GS_SPEED_SELECT(is_hs,hs,fs) (fs)
96 #endif /* CONFIG_USB_GADGET_DUALSPEED */
100 static int debug
= 1;
102 #define gs_debug(format, arg...) \
103 do { if (debug) printk(KERN_DEBUG format, ## arg); } while(0)
104 #define gs_debug_level(level, format, arg...) \
105 do { if (debug>=level) printk(KERN_DEBUG format, ## arg); } while(0)
109 #define gs_debug(format, arg...) \
111 #define gs_debug_level(level, format, arg...) \
114 #endif /* GS_DEBUG */
116 /* Thanks to NetChip Technologies for donating this product ID.
118 * DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
119 * Instead: allocate your own, using normal USB-IF procedures.
121 #define GS_VENDOR_ID 0x0525 /* NetChip */
122 #define GS_PRODUCT_ID 0xa4a6 /* Linux-USB Serial Gadget */
123 #define GS_CDC_PRODUCT_ID 0xa4a7 /* ... as CDC-ACM */
125 #define GS_LOG2_NOTIFY_INTERVAL 5 /* 1 << 5 == 32 msec */
126 #define GS_NOTIFY_MAXPACKET 8
133 /* circular buffer */
135 unsigned int buf_size
;
141 /* list of requests */
142 struct gs_req_entry
{
143 struct list_head re_entry
;
144 struct usb_request
*re_req
;
147 /* the port structure holds info for each port, one for each minor number */
149 struct gs_dev
*port_dev
; /* pointer to device struct */
150 struct tty_struct
*port_tty
; /* pointer to tty struct */
151 spinlock_t port_lock
;
154 int port_in_use
; /* open/close in progress */
155 wait_queue_head_t port_write_wait
;/* waiting to write */
156 struct gs_buf
*port_write_buf
;
157 struct usb_cdc_line_coding port_line_coding
;
160 /* the device structure holds info for the USB device */
162 struct usb_gadget
*dev_gadget
; /* gadget device pointer */
163 spinlock_t dev_lock
; /* lock for set/reset config */
164 int dev_config
; /* configuration number */
165 struct usb_ep
*dev_notify_ep
; /* address of notify endpoint */
166 struct usb_ep
*dev_in_ep
; /* address of in endpoint */
167 struct usb_ep
*dev_out_ep
; /* address of out endpoint */
168 struct usb_endpoint_descriptor
/* descriptor of notify ep */
170 struct usb_endpoint_descriptor
/* descriptor of in endpoint */
172 struct usb_endpoint_descriptor
/* descriptor of out endpoint */
174 struct usb_request
*dev_ctrl_req
; /* control request */
175 struct list_head dev_req_list
; /* list of write requests */
176 int dev_sched_port
; /* round robin port scheduled */
177 struct gs_port
*dev_port
[GS_NUM_PORTS
]; /* the ports */
184 static int __init
gs_module_init(void);
185 static void __exit
gs_module_exit(void);
188 static int gs_open(struct tty_struct
*tty
, struct file
*file
);
189 static void gs_close(struct tty_struct
*tty
, struct file
*file
);
190 static int gs_write(struct tty_struct
*tty
,
191 const unsigned char *buf
, int count
);
192 static void gs_put_char(struct tty_struct
*tty
, unsigned char ch
);
193 static void gs_flush_chars(struct tty_struct
*tty
);
194 static int gs_write_room(struct tty_struct
*tty
);
195 static int gs_chars_in_buffer(struct tty_struct
*tty
);
196 static void gs_throttle(struct tty_struct
* tty
);
197 static void gs_unthrottle(struct tty_struct
* tty
);
198 static void gs_break(struct tty_struct
*tty
, int break_state
);
199 static int gs_ioctl(struct tty_struct
*tty
, struct file
*file
,
200 unsigned int cmd
, unsigned long arg
);
201 static void gs_set_termios(struct tty_struct
*tty
, struct ktermios
*old
);
203 static int gs_send(struct gs_dev
*dev
);
204 static int gs_send_packet(struct gs_dev
*dev
, char *packet
,
206 static int gs_recv_packet(struct gs_dev
*dev
, char *packet
,
208 static void gs_read_complete(struct usb_ep
*ep
, struct usb_request
*req
);
209 static void gs_write_complete(struct usb_ep
*ep
, struct usb_request
*req
);
212 static int gs_bind(struct usb_gadget
*gadget
);
213 static void gs_unbind(struct usb_gadget
*gadget
);
214 static int gs_setup(struct usb_gadget
*gadget
,
215 const struct usb_ctrlrequest
*ctrl
);
216 static int gs_setup_standard(struct usb_gadget
*gadget
,
217 const struct usb_ctrlrequest
*ctrl
);
218 static int gs_setup_class(struct usb_gadget
*gadget
,
219 const struct usb_ctrlrequest
*ctrl
);
220 static void gs_setup_complete(struct usb_ep
*ep
, struct usb_request
*req
);
221 static void gs_disconnect(struct usb_gadget
*gadget
);
222 static int gs_set_config(struct gs_dev
*dev
, unsigned config
);
223 static void gs_reset_config(struct gs_dev
*dev
);
224 static int gs_build_config_buf(u8
*buf
, enum usb_device_speed speed
,
225 u8 type
, unsigned int index
, int is_otg
);
227 static struct usb_request
*gs_alloc_req(struct usb_ep
*ep
, unsigned int len
,
228 gfp_t kmalloc_flags
);
229 static void gs_free_req(struct usb_ep
*ep
, struct usb_request
*req
);
231 static struct gs_req_entry
*gs_alloc_req_entry(struct usb_ep
*ep
, unsigned len
,
232 gfp_t kmalloc_flags
);
233 static void gs_free_req_entry(struct usb_ep
*ep
, struct gs_req_entry
*req
);
235 static int gs_alloc_ports(struct gs_dev
*dev
, gfp_t kmalloc_flags
);
236 static void gs_free_ports(struct gs_dev
*dev
);
238 /* circular buffer */
239 static struct gs_buf
*gs_buf_alloc(unsigned int size
, gfp_t kmalloc_flags
);
240 static void gs_buf_free(struct gs_buf
*gb
);
241 static void gs_buf_clear(struct gs_buf
*gb
);
242 static unsigned int gs_buf_data_avail(struct gs_buf
*gb
);
243 static unsigned int gs_buf_space_avail(struct gs_buf
*gb
);
244 static unsigned int gs_buf_put(struct gs_buf
*gb
, const char *buf
,
246 static unsigned int gs_buf_get(struct gs_buf
*gb
, char *buf
,
249 /* external functions */
250 extern int net2280_set_fifo_mode(struct usb_gadget
*gadget
, int mode
);
255 static struct gs_dev
*gs_device
;
257 static const char *EP_IN_NAME
;
258 static const char *EP_OUT_NAME
;
259 static const char *EP_NOTIFY_NAME
;
261 static struct semaphore gs_open_close_sem
[GS_NUM_PORTS
];
263 static unsigned int read_q_size
= GS_DEFAULT_READ_Q_SIZE
;
264 static unsigned int write_q_size
= GS_DEFAULT_WRITE_Q_SIZE
;
266 static unsigned int write_buf_size
= GS_DEFAULT_WRITE_BUF_SIZE
;
268 static unsigned int use_acm
= GS_DEFAULT_USE_ACM
;
271 /* tty driver struct */
272 static const struct tty_operations gs_tty_ops
= {
276 .put_char
= gs_put_char
,
277 .flush_chars
= gs_flush_chars
,
278 .write_room
= gs_write_room
,
280 .set_termios
= gs_set_termios
,
281 .throttle
= gs_throttle
,
282 .unthrottle
= gs_unthrottle
,
283 .break_ctl
= gs_break
,
284 .chars_in_buffer
= gs_chars_in_buffer
,
286 static struct tty_driver
*gs_tty_driver
;
288 /* gadget driver struct */
289 static struct usb_gadget_driver gs_gadget_driver
= {
290 #ifdef CONFIG_USB_GADGET_DUALSPEED
291 .speed
= USB_SPEED_HIGH
,
293 .speed
= USB_SPEED_FULL
,
294 #endif /* CONFIG_USB_GADGET_DUALSPEED */
295 .function
= GS_LONG_NAME
,
299 .disconnect
= gs_disconnect
,
301 .name
= GS_SHORT_NAME
,
306 /* USB descriptors */
308 #define GS_MANUFACTURER_STR_ID 1
309 #define GS_PRODUCT_STR_ID 2
310 #define GS_SERIAL_STR_ID 3
311 #define GS_BULK_CONFIG_STR_ID 4
312 #define GS_ACM_CONFIG_STR_ID 5
313 #define GS_CONTROL_STR_ID 6
314 #define GS_DATA_STR_ID 7
316 /* static strings, in UTF-8 */
317 static char manufacturer
[50];
318 static struct usb_string gs_strings
[] = {
319 { GS_MANUFACTURER_STR_ID
, manufacturer
},
320 { GS_PRODUCT_STR_ID
, GS_LONG_NAME
},
321 { GS_SERIAL_STR_ID
, "0" },
322 { GS_BULK_CONFIG_STR_ID
, "Gadget Serial Bulk" },
323 { GS_ACM_CONFIG_STR_ID
, "Gadget Serial CDC ACM" },
324 { GS_CONTROL_STR_ID
, "Gadget Serial Control" },
325 { GS_DATA_STR_ID
, "Gadget Serial Data" },
326 { } /* end of list */
329 static struct usb_gadget_strings gs_string_table
= {
330 .language
= 0x0409, /* en-us */
331 .strings
= gs_strings
,
334 static struct usb_device_descriptor gs_device_desc
= {
335 .bLength
= USB_DT_DEVICE_SIZE
,
336 .bDescriptorType
= USB_DT_DEVICE
,
337 .bcdUSB
= __constant_cpu_to_le16(0x0200),
338 .bDeviceSubClass
= 0,
339 .bDeviceProtocol
= 0,
340 .idVendor
= __constant_cpu_to_le16(GS_VENDOR_ID
),
341 .idProduct
= __constant_cpu_to_le16(GS_PRODUCT_ID
),
342 .iManufacturer
= GS_MANUFACTURER_STR_ID
,
343 .iProduct
= GS_PRODUCT_STR_ID
,
344 .iSerialNumber
= GS_SERIAL_STR_ID
,
345 .bNumConfigurations
= GS_NUM_CONFIGS
,
348 static struct usb_otg_descriptor gs_otg_descriptor
= {
349 .bLength
= sizeof(gs_otg_descriptor
),
350 .bDescriptorType
= USB_DT_OTG
,
351 .bmAttributes
= USB_OTG_SRP
,
354 static struct usb_config_descriptor gs_bulk_config_desc
= {
355 .bLength
= USB_DT_CONFIG_SIZE
,
356 .bDescriptorType
= USB_DT_CONFIG
,
357 /* .wTotalLength computed dynamically */
359 .bConfigurationValue
= GS_BULK_CONFIG_ID
,
360 .iConfiguration
= GS_BULK_CONFIG_STR_ID
,
361 .bmAttributes
= USB_CONFIG_ATT_ONE
| USB_CONFIG_ATT_SELFPOWER
,
365 static struct usb_config_descriptor gs_acm_config_desc
= {
366 .bLength
= USB_DT_CONFIG_SIZE
,
367 .bDescriptorType
= USB_DT_CONFIG
,
368 /* .wTotalLength computed dynamically */
370 .bConfigurationValue
= GS_ACM_CONFIG_ID
,
371 .iConfiguration
= GS_ACM_CONFIG_STR_ID
,
372 .bmAttributes
= USB_CONFIG_ATT_ONE
| USB_CONFIG_ATT_SELFPOWER
,
376 static const struct usb_interface_descriptor gs_bulk_interface_desc
= {
377 .bLength
= USB_DT_INTERFACE_SIZE
,
378 .bDescriptorType
= USB_DT_INTERFACE
,
379 .bInterfaceNumber
= GS_BULK_INTERFACE_ID
,
381 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
382 .bInterfaceSubClass
= 0,
383 .bInterfaceProtocol
= 0,
384 .iInterface
= GS_DATA_STR_ID
,
387 static const struct usb_interface_descriptor gs_control_interface_desc
= {
388 .bLength
= USB_DT_INTERFACE_SIZE
,
389 .bDescriptorType
= USB_DT_INTERFACE
,
390 .bInterfaceNumber
= GS_CONTROL_INTERFACE_ID
,
392 .bInterfaceClass
= USB_CLASS_COMM
,
393 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ACM
,
394 .bInterfaceProtocol
= USB_CDC_ACM_PROTO_AT_V25TER
,
395 .iInterface
= GS_CONTROL_STR_ID
,
398 static const struct usb_interface_descriptor gs_data_interface_desc
= {
399 .bLength
= USB_DT_INTERFACE_SIZE
,
400 .bDescriptorType
= USB_DT_INTERFACE
,
401 .bInterfaceNumber
= GS_DATA_INTERFACE_ID
,
403 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
404 .bInterfaceSubClass
= 0,
405 .bInterfaceProtocol
= 0,
406 .iInterface
= GS_DATA_STR_ID
,
409 static const struct usb_cdc_header_desc gs_header_desc
= {
410 .bLength
= sizeof(gs_header_desc
),
411 .bDescriptorType
= USB_DT_CS_INTERFACE
,
412 .bDescriptorSubType
= USB_CDC_HEADER_TYPE
,
413 .bcdCDC
= __constant_cpu_to_le16(0x0110),
416 static const struct usb_cdc_call_mgmt_descriptor gs_call_mgmt_descriptor
= {
417 .bLength
= sizeof(gs_call_mgmt_descriptor
),
418 .bDescriptorType
= USB_DT_CS_INTERFACE
,
419 .bDescriptorSubType
= USB_CDC_CALL_MANAGEMENT_TYPE
,
421 .bDataInterface
= 1, /* index of data interface */
424 static struct usb_cdc_acm_descriptor gs_acm_descriptor
= {
425 .bLength
= sizeof(gs_acm_descriptor
),
426 .bDescriptorType
= USB_DT_CS_INTERFACE
,
427 .bDescriptorSubType
= USB_CDC_ACM_TYPE
,
431 static const struct usb_cdc_union_desc gs_union_desc
= {
432 .bLength
= sizeof(gs_union_desc
),
433 .bDescriptorType
= USB_DT_CS_INTERFACE
,
434 .bDescriptorSubType
= USB_CDC_UNION_TYPE
,
435 .bMasterInterface0
= 0, /* index of control interface */
436 .bSlaveInterface0
= 1, /* index of data interface */
439 static struct usb_endpoint_descriptor gs_fullspeed_notify_desc
= {
440 .bLength
= USB_DT_ENDPOINT_SIZE
,
441 .bDescriptorType
= USB_DT_ENDPOINT
,
442 .bEndpointAddress
= USB_DIR_IN
,
443 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
444 .wMaxPacketSize
= __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET
),
445 .bInterval
= 1 << GS_LOG2_NOTIFY_INTERVAL
,
448 static struct usb_endpoint_descriptor gs_fullspeed_in_desc
= {
449 .bLength
= USB_DT_ENDPOINT_SIZE
,
450 .bDescriptorType
= USB_DT_ENDPOINT
,
451 .bEndpointAddress
= USB_DIR_IN
,
452 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
455 static struct usb_endpoint_descriptor gs_fullspeed_out_desc
= {
456 .bLength
= USB_DT_ENDPOINT_SIZE
,
457 .bDescriptorType
= USB_DT_ENDPOINT
,
458 .bEndpointAddress
= USB_DIR_OUT
,
459 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
462 static const struct usb_descriptor_header
*gs_bulk_fullspeed_function
[] = {
463 (struct usb_descriptor_header
*) &gs_otg_descriptor
,
464 (struct usb_descriptor_header
*) &gs_bulk_interface_desc
,
465 (struct usb_descriptor_header
*) &gs_fullspeed_in_desc
,
466 (struct usb_descriptor_header
*) &gs_fullspeed_out_desc
,
470 static const struct usb_descriptor_header
*gs_acm_fullspeed_function
[] = {
471 (struct usb_descriptor_header
*) &gs_otg_descriptor
,
472 (struct usb_descriptor_header
*) &gs_control_interface_desc
,
473 (struct usb_descriptor_header
*) &gs_header_desc
,
474 (struct usb_descriptor_header
*) &gs_call_mgmt_descriptor
,
475 (struct usb_descriptor_header
*) &gs_acm_descriptor
,
476 (struct usb_descriptor_header
*) &gs_union_desc
,
477 (struct usb_descriptor_header
*) &gs_fullspeed_notify_desc
,
478 (struct usb_descriptor_header
*) &gs_data_interface_desc
,
479 (struct usb_descriptor_header
*) &gs_fullspeed_in_desc
,
480 (struct usb_descriptor_header
*) &gs_fullspeed_out_desc
,
484 #ifdef CONFIG_USB_GADGET_DUALSPEED
485 static struct usb_endpoint_descriptor gs_highspeed_notify_desc
= {
486 .bLength
= USB_DT_ENDPOINT_SIZE
,
487 .bDescriptorType
= USB_DT_ENDPOINT
,
488 .bEndpointAddress
= USB_DIR_IN
,
489 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
490 .wMaxPacketSize
= __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET
),
491 .bInterval
= GS_LOG2_NOTIFY_INTERVAL
+4,
494 static struct usb_endpoint_descriptor gs_highspeed_in_desc
= {
495 .bLength
= USB_DT_ENDPOINT_SIZE
,
496 .bDescriptorType
= USB_DT_ENDPOINT
,
497 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
498 .wMaxPacketSize
= __constant_cpu_to_le16(512),
501 static struct usb_endpoint_descriptor gs_highspeed_out_desc
= {
502 .bLength
= USB_DT_ENDPOINT_SIZE
,
503 .bDescriptorType
= USB_DT_ENDPOINT
,
504 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
505 .wMaxPacketSize
= __constant_cpu_to_le16(512),
508 static struct usb_qualifier_descriptor gs_qualifier_desc
= {
509 .bLength
= sizeof(struct usb_qualifier_descriptor
),
510 .bDescriptorType
= USB_DT_DEVICE_QUALIFIER
,
511 .bcdUSB
= __constant_cpu_to_le16 (0x0200),
512 /* assumes ep0 uses the same value for both speeds ... */
513 .bNumConfigurations
= GS_NUM_CONFIGS
,
516 static const struct usb_descriptor_header
*gs_bulk_highspeed_function
[] = {
517 (struct usb_descriptor_header
*) &gs_otg_descriptor
,
518 (struct usb_descriptor_header
*) &gs_bulk_interface_desc
,
519 (struct usb_descriptor_header
*) &gs_highspeed_in_desc
,
520 (struct usb_descriptor_header
*) &gs_highspeed_out_desc
,
524 static const struct usb_descriptor_header
*gs_acm_highspeed_function
[] = {
525 (struct usb_descriptor_header
*) &gs_otg_descriptor
,
526 (struct usb_descriptor_header
*) &gs_control_interface_desc
,
527 (struct usb_descriptor_header
*) &gs_header_desc
,
528 (struct usb_descriptor_header
*) &gs_call_mgmt_descriptor
,
529 (struct usb_descriptor_header
*) &gs_acm_descriptor
,
530 (struct usb_descriptor_header
*) &gs_union_desc
,
531 (struct usb_descriptor_header
*) &gs_highspeed_notify_desc
,
532 (struct usb_descriptor_header
*) &gs_data_interface_desc
,
533 (struct usb_descriptor_header
*) &gs_highspeed_in_desc
,
534 (struct usb_descriptor_header
*) &gs_highspeed_out_desc
,
538 #endif /* CONFIG_USB_GADGET_DUALSPEED */
542 MODULE_DESCRIPTION(GS_LONG_NAME
);
543 MODULE_AUTHOR("Al Borchers");
544 MODULE_LICENSE("GPL");
547 module_param(debug
, int, S_IRUGO
|S_IWUSR
);
548 MODULE_PARM_DESC(debug
, "Enable debugging, 0=off, 1=on");
551 module_param(read_q_size
, uint
, S_IRUGO
);
552 MODULE_PARM_DESC(read_q_size
, "Read request queue size, default=32");
554 module_param(write_q_size
, uint
, S_IRUGO
);
555 MODULE_PARM_DESC(write_q_size
, "Write request queue size, default=32");
557 module_param(write_buf_size
, uint
, S_IRUGO
);
558 MODULE_PARM_DESC(write_buf_size
, "Write buffer size, default=8192");
560 module_param(use_acm
, uint
, S_IRUGO
);
561 MODULE_PARM_DESC(use_acm
, "Use CDC ACM, 0=no, 1=yes, default=no");
563 module_init(gs_module_init
);
564 module_exit(gs_module_exit
);
569 * Register as a USB gadget driver and a tty driver.
571 static int __init
gs_module_init(void)
576 retval
= usb_gadget_register_driver(&gs_gadget_driver
);
578 printk(KERN_ERR
"gs_module_init: cannot register gadget driver, ret=%d\n", retval
);
582 gs_tty_driver
= alloc_tty_driver(GS_NUM_PORTS
);
585 gs_tty_driver
->owner
= THIS_MODULE
;
586 gs_tty_driver
->driver_name
= GS_SHORT_NAME
;
587 gs_tty_driver
->name
= "ttygs";
588 gs_tty_driver
->major
= GS_MAJOR
;
589 gs_tty_driver
->minor_start
= GS_MINOR_START
;
590 gs_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
591 gs_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
592 gs_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
593 gs_tty_driver
->init_termios
= tty_std_termios
;
594 gs_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
595 tty_set_operations(gs_tty_driver
, &gs_tty_ops
);
597 for (i
=0; i
< GS_NUM_PORTS
; i
++)
598 sema_init(&gs_open_close_sem
[i
], 1);
600 retval
= tty_register_driver(gs_tty_driver
);
602 usb_gadget_unregister_driver(&gs_gadget_driver
);
603 put_tty_driver(gs_tty_driver
);
604 printk(KERN_ERR
"gs_module_init: cannot register tty driver, ret=%d\n", retval
);
608 printk(KERN_INFO
"gs_module_init: %s %s loaded\n", GS_LONG_NAME
, GS_VERSION_STR
);
615 * Unregister as a tty driver and a USB gadget driver.
617 static void __exit
gs_module_exit(void)
619 tty_unregister_driver(gs_tty_driver
);
620 put_tty_driver(gs_tty_driver
);
621 usb_gadget_unregister_driver(&gs_gadget_driver
);
623 printk(KERN_INFO
"gs_module_exit: %s %s unloaded\n", GS_LONG_NAME
, GS_VERSION_STR
);
631 static int gs_open(struct tty_struct
*tty
, struct file
*file
)
635 struct gs_port
*port
;
638 struct semaphore
*sem
;
641 port_num
= tty
->index
;
643 gs_debug("gs_open: (%d,%p,%p)\n", port_num
, tty
, file
);
645 if (port_num
< 0 || port_num
>= GS_NUM_PORTS
) {
646 printk(KERN_ERR
"gs_open: (%d,%p,%p) invalid port number\n",
647 port_num
, tty
, file
);
654 printk(KERN_ERR
"gs_open: (%d,%p,%p) NULL device pointer\n",
655 port_num
, tty
, file
);
659 sem
= &gs_open_close_sem
[port_num
];
660 if (down_interruptible(sem
)) {
662 "gs_open: (%d,%p,%p) interrupted waiting for semaphore\n",
663 port_num
, tty
, file
);
667 spin_lock_irqsave(&dev
->dev_lock
, flags
);
669 if (dev
->dev_config
== GS_NO_CONFIG_ID
) {
671 "gs_open: (%d,%p,%p) device is not connected\n",
672 port_num
, tty
, file
);
674 goto exit_unlock_dev
;
677 port
= dev
->dev_port
[port_num
];
680 printk(KERN_ERR
"gs_open: (%d,%p,%p) NULL port pointer\n",
681 port_num
, tty
, file
);
683 goto exit_unlock_dev
;
686 spin_lock(&port
->port_lock
);
687 spin_unlock(&dev
->dev_lock
);
689 if (port
->port_dev
== NULL
) {
690 printk(KERN_ERR
"gs_open: (%d,%p,%p) port disconnected (1)\n",
691 port_num
, tty
, file
);
693 goto exit_unlock_port
;
696 if (port
->port_open_count
> 0) {
697 ++port
->port_open_count
;
698 gs_debug("gs_open: (%d,%p,%p) already open\n",
699 port_num
, tty
, file
);
701 goto exit_unlock_port
;
704 tty
->driver_data
= NULL
;
706 /* mark port as in use, we can drop port lock and sleep if necessary */
707 port
->port_in_use
= 1;
709 /* allocate write buffer on first open */
710 if (port
->port_write_buf
== NULL
) {
711 spin_unlock_irqrestore(&port
->port_lock
, flags
);
712 buf
= gs_buf_alloc(write_buf_size
, GFP_KERNEL
);
713 spin_lock_irqsave(&port
->port_lock
, flags
);
715 /* might have been disconnected while asleep, check */
716 if (port
->port_dev
== NULL
) {
718 "gs_open: (%d,%p,%p) port disconnected (2)\n",
719 port_num
, tty
, file
);
720 port
->port_in_use
= 0;
722 goto exit_unlock_port
;
725 if ((port
->port_write_buf
=buf
) == NULL
) {
726 printk(KERN_ERR
"gs_open: (%d,%p,%p) cannot allocate port write buffer\n",
727 port_num
, tty
, file
);
728 port
->port_in_use
= 0;
730 goto exit_unlock_port
;
735 /* wait for carrier detect (not implemented) */
737 /* might have been disconnected while asleep, check */
738 if (port
->port_dev
== NULL
) {
739 printk(KERN_ERR
"gs_open: (%d,%p,%p) port disconnected (3)\n",
740 port_num
, tty
, file
);
741 port
->port_in_use
= 0;
743 goto exit_unlock_port
;
746 tty
->driver_data
= port
;
747 port
->port_tty
= tty
;
748 port
->port_open_count
= 1;
749 port
->port_in_use
= 0;
751 gs_debug("gs_open: (%d,%p,%p) completed\n", port_num
, tty
, file
);
756 spin_unlock_irqrestore(&port
->port_lock
, flags
);
761 spin_unlock_irqrestore(&dev
->dev_lock
, flags
);
771 #define GS_WRITE_FINISHED_EVENT_SAFELY(p) \
775 spin_lock_irq(&(p)->port_lock); \
776 cond = !(p)->port_dev || !gs_buf_data_avail((p)->port_write_buf); \
777 spin_unlock_irq(&(p)->port_lock); \
781 static void gs_close(struct tty_struct
*tty
, struct file
*file
)
783 struct gs_port
*port
= tty
->driver_data
;
784 struct semaphore
*sem
;
787 printk(KERN_ERR
"gs_close: NULL port pointer\n");
791 gs_debug("gs_close: (%d,%p,%p)\n", port
->port_num
, tty
, file
);
793 sem
= &gs_open_close_sem
[port
->port_num
];
796 spin_lock_irq(&port
->port_lock
);
798 if (port
->port_open_count
== 0) {
800 "gs_close: (%d,%p,%p) port is already closed\n",
801 port
->port_num
, tty
, file
);
805 if (port
->port_open_count
> 1) {
806 --port
->port_open_count
;
810 /* free disconnected port on final close */
811 if (port
->port_dev
== NULL
) {
816 /* mark port as closed but in use, we can drop port lock */
817 /* and sleep if necessary */
818 port
->port_in_use
= 1;
819 port
->port_open_count
= 0;
821 /* wait for write buffer to drain, or */
822 /* at most GS_CLOSE_TIMEOUT seconds */
823 if (gs_buf_data_avail(port
->port_write_buf
) > 0) {
824 spin_unlock_irq(&port
->port_lock
);
825 wait_event_interruptible_timeout(port
->port_write_wait
,
826 GS_WRITE_FINISHED_EVENT_SAFELY(port
),
827 GS_CLOSE_TIMEOUT
* HZ
);
828 spin_lock_irq(&port
->port_lock
);
831 /* free disconnected port on final close */
832 /* (might have happened during the above sleep) */
833 if (port
->port_dev
== NULL
) {
838 gs_buf_clear(port
->port_write_buf
);
840 tty
->driver_data
= NULL
;
841 port
->port_tty
= NULL
;
842 port
->port_in_use
= 0;
844 gs_debug("gs_close: (%d,%p,%p) completed\n",
845 port
->port_num
, tty
, file
);
848 spin_unlock_irq(&port
->port_lock
);
855 static int gs_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
858 struct gs_port
*port
= tty
->driver_data
;
862 printk(KERN_ERR
"gs_write: NULL port pointer\n");
866 gs_debug("gs_write: (%d,%p) writing %d bytes\n", port
->port_num
, tty
,
872 spin_lock_irqsave(&port
->port_lock
, flags
);
874 if (port
->port_dev
== NULL
) {
875 printk(KERN_ERR
"gs_write: (%d,%p) port is not connected\n",
876 port
->port_num
, tty
);
881 if (port
->port_open_count
== 0) {
882 printk(KERN_ERR
"gs_write: (%d,%p) port is closed\n",
883 port
->port_num
, tty
);
888 count
= gs_buf_put(port
->port_write_buf
, buf
, count
);
890 spin_unlock_irqrestore(&port
->port_lock
, flags
);
894 gs_debug("gs_write: (%d,%p) wrote %d bytes\n", port
->port_num
, tty
,
900 spin_unlock_irqrestore(&port
->port_lock
, flags
);
907 static void gs_put_char(struct tty_struct
*tty
, unsigned char ch
)
910 struct gs_port
*port
= tty
->driver_data
;
913 printk(KERN_ERR
"gs_put_char: NULL port pointer\n");
917 gs_debug("gs_put_char: (%d,%p) char=0x%x, called from %p, %p, %p\n", port
->port_num
, tty
, ch
, __builtin_return_address(0), __builtin_return_address(1), __builtin_return_address(2));
919 spin_lock_irqsave(&port
->port_lock
, flags
);
921 if (port
->port_dev
== NULL
) {
922 printk(KERN_ERR
"gs_put_char: (%d,%p) port is not connected\n",
923 port
->port_num
, tty
);
927 if (port
->port_open_count
== 0) {
928 printk(KERN_ERR
"gs_put_char: (%d,%p) port is closed\n",
929 port
->port_num
, tty
);
933 gs_buf_put(port
->port_write_buf
, &ch
, 1);
936 spin_unlock_irqrestore(&port
->port_lock
, flags
);
942 static void gs_flush_chars(struct tty_struct
*tty
)
945 struct gs_port
*port
= tty
->driver_data
;
948 printk(KERN_ERR
"gs_flush_chars: NULL port pointer\n");
952 gs_debug("gs_flush_chars: (%d,%p)\n", port
->port_num
, tty
);
954 spin_lock_irqsave(&port
->port_lock
, flags
);
956 if (port
->port_dev
== NULL
) {
958 "gs_flush_chars: (%d,%p) port is not connected\n",
959 port
->port_num
, tty
);
963 if (port
->port_open_count
== 0) {
964 printk(KERN_ERR
"gs_flush_chars: (%d,%p) port is closed\n",
965 port
->port_num
, tty
);
969 spin_unlock_irqrestore(&port
->port_lock
, flags
);
976 spin_unlock_irqrestore(&port
->port_lock
, flags
);
982 static int gs_write_room(struct tty_struct
*tty
)
987 struct gs_port
*port
= tty
->driver_data
;
993 spin_lock_irqsave(&port
->port_lock
, flags
);
995 if (port
->port_dev
!= NULL
&& port
->port_open_count
> 0
996 && port
->port_write_buf
!= NULL
)
997 room
= gs_buf_space_avail(port
->port_write_buf
);
999 spin_unlock_irqrestore(&port
->port_lock
, flags
);
1001 gs_debug("gs_write_room: (%d,%p) room=%d\n",
1002 port
->port_num
, tty
, room
);
1008 * gs_chars_in_buffer
1010 static int gs_chars_in_buffer(struct tty_struct
*tty
)
1013 unsigned long flags
;
1014 struct gs_port
*port
= tty
->driver_data
;
1019 spin_lock_irqsave(&port
->port_lock
, flags
);
1021 if (port
->port_dev
!= NULL
&& port
->port_open_count
> 0
1022 && port
->port_write_buf
!= NULL
)
1023 chars
= gs_buf_data_avail(port
->port_write_buf
);
1025 spin_unlock_irqrestore(&port
->port_lock
, flags
);
1027 gs_debug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
1028 port
->port_num
, tty
, chars
);
1036 static void gs_throttle(struct tty_struct
*tty
)
1043 static void gs_unthrottle(struct tty_struct
*tty
)
1050 static void gs_break(struct tty_struct
*tty
, int break_state
)
1057 static int gs_ioctl(struct tty_struct
*tty
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1059 struct gs_port
*port
= tty
->driver_data
;
1062 printk(KERN_ERR
"gs_ioctl: NULL port pointer\n");
1066 gs_debug("gs_ioctl: (%d,%p,%p) cmd=0x%4.4x, arg=%lu\n",
1067 port
->port_num
, tty
, file
, cmd
, arg
);
1071 /* could not handle ioctl */
1072 return -ENOIOCTLCMD
;
1078 static void gs_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
1085 * This function finds available write requests, calls
1086 * gs_send_packet to fill these packets with data, and
1087 * continues until either there are no more write requests
1088 * available or no more data to send. This function is
1089 * run whenever data arrives or write requests are available.
1091 static int gs_send(struct gs_dev
*dev
)
1094 unsigned long flags
;
1096 struct usb_request
*req
;
1097 struct gs_req_entry
*req_entry
;
1100 printk(KERN_ERR
"gs_send: NULL device pointer\n");
1104 spin_lock_irqsave(&dev
->dev_lock
, flags
);
1106 ep
= dev
->dev_in_ep
;
1108 while(!list_empty(&dev
->dev_req_list
)) {
1110 req_entry
= list_entry(dev
->dev_req_list
.next
,
1111 struct gs_req_entry
, re_entry
);
1113 req
= req_entry
->re_req
;
1115 len
= gs_send_packet(dev
, req
->buf
, ep
->maxpacket
);
1118 gs_debug_level(3, "gs_send: len=%d, 0x%2.2x 0x%2.2x 0x%2.2x ...\n", len
, *((unsigned char *)req
->buf
), *((unsigned char *)req
->buf
+1), *((unsigned char *)req
->buf
+2));
1119 list_del(&req_entry
->re_entry
);
1121 spin_unlock_irqrestore(&dev
->dev_lock
, flags
);
1122 if ((ret
=usb_ep_queue(ep
, req
, GFP_ATOMIC
))) {
1124 "gs_send: cannot queue read request, ret=%d\n",
1126 spin_lock_irqsave(&dev
->dev_lock
, flags
);
1129 spin_lock_irqsave(&dev
->dev_lock
, flags
);
1136 spin_unlock_irqrestore(&dev
->dev_lock
, flags
);
1144 * If there is data to send, a packet is built in the given
1145 * buffer and the size is returned. If there is no data to
1146 * send, 0 is returned. If there is any error a negative
1147 * error number is returned.
1149 * Called during USB completion routine, on interrupt time.
1151 * We assume that disconnect will not happen until all completion
1152 * routines have completed, so we can assume that the dev_port
1153 * array does not change during the lifetime of this function.
1155 static int gs_send_packet(struct gs_dev
*dev
, char *packet
, unsigned int size
)
1158 struct gs_port
*port
;
1160 /* TEMPORARY -- only port 0 is supported right now */
1161 port
= dev
->dev_port
[0];
1165 "gs_send_packet: port=%d, NULL port pointer\n",
1170 spin_lock(&port
->port_lock
);
1172 len
= gs_buf_data_avail(port
->port_write_buf
);
1179 size
= gs_buf_get(port
->port_write_buf
, packet
, size
);
1182 wake_up_interruptible(&port
->port_tty
->write_wait
);
1185 spin_unlock(&port
->port_lock
);
1192 * Called for each USB packet received. Reads the packet
1193 * header and stuffs the data in the appropriate tty buffer.
1194 * Returns 0 if successful, or a negative error number.
1196 * Called during USB completion routine, on interrupt time.
1198 * We assume that disconnect will not happen until all completion
1199 * routines have completed, so we can assume that the dev_port
1200 * array does not change during the lifetime of this function.
1202 static int gs_recv_packet(struct gs_dev
*dev
, char *packet
, unsigned int size
)
1205 struct gs_port
*port
;
1207 struct tty_struct
*tty
;
1209 /* TEMPORARY -- only port 0 is supported right now */
1210 port
= dev
->dev_port
[0];
1213 printk(KERN_ERR
"gs_recv_packet: port=%d, NULL port pointer\n",
1218 spin_lock(&port
->port_lock
);
1220 if (port
->port_open_count
== 0) {
1221 printk(KERN_ERR
"gs_recv_packet: port=%d, port is closed\n",
1228 tty
= port
->port_tty
;
1231 printk(KERN_ERR
"gs_recv_packet: port=%d, NULL tty pointer\n",
1237 if (port
->port_tty
->magic
!= TTY_MAGIC
) {
1238 printk(KERN_ERR
"gs_recv_packet: port=%d, bad tty magic\n",
1244 len
= tty_buffer_request_room(tty
, size
);
1246 tty_insert_flip_string(tty
, packet
, len
);
1247 tty_flip_buffer_push(port
->port_tty
);
1248 wake_up_interruptible(&port
->port_tty
->read_wait
);
1252 spin_unlock(&port
->port_lock
);
1259 static void gs_read_complete(struct usb_ep
*ep
, struct usb_request
*req
)
1262 struct gs_dev
*dev
= ep
->driver_data
;
1265 printk(KERN_ERR
"gs_read_complete: NULL device pointer\n");
1269 switch(req
->status
) {
1271 /* normal completion */
1272 gs_recv_packet(dev
, req
->buf
, req
->actual
);
1274 req
->length
= ep
->maxpacket
;
1275 if ((ret
=usb_ep_queue(ep
, req
, GFP_ATOMIC
))) {
1277 "gs_read_complete: cannot queue read request, ret=%d\n",
1284 gs_debug("gs_read_complete: shutdown\n");
1285 gs_free_req(ep
, req
);
1291 "gs_read_complete: unexpected status error, status=%d\n",
1301 static void gs_write_complete(struct usb_ep
*ep
, struct usb_request
*req
)
1303 struct gs_dev
*dev
= ep
->driver_data
;
1304 struct gs_req_entry
*gs_req
= req
->context
;
1307 printk(KERN_ERR
"gs_write_complete: NULL device pointer\n");
1311 switch(req
->status
) {
1313 /* normal completion */
1315 if (gs_req
== NULL
) {
1317 "gs_write_complete: NULL request pointer\n");
1321 spin_lock(&dev
->dev_lock
);
1322 list_add(&gs_req
->re_entry
, &dev
->dev_req_list
);
1323 spin_unlock(&dev
->dev_lock
);
1331 gs_debug("gs_write_complete: shutdown\n");
1332 gs_free_req(ep
, req
);
1337 "gs_write_complete: unexpected status error, status=%d\n",
1349 * Called on module load. Allocates and initializes the device
1350 * structure and a control request.
1352 static int __init
gs_bind(struct usb_gadget
*gadget
)
1359 /* Some controllers can't support CDC ACM:
1360 * - sh doesn't support multiple interfaces or configs;
1361 * - sa1100 doesn't have a third interrupt endpoint
1363 if (gadget_is_sh(gadget
) || gadget_is_sa1100(gadget
))
1366 gcnum
= usb_gadget_controller_number(gadget
);
1368 gs_device_desc
.bcdDevice
=
1369 cpu_to_le16(GS_VERSION_NUM
| gcnum
);
1371 printk(KERN_WARNING
"gs_bind: controller '%s' not recognized\n",
1373 /* unrecognized, but safe unless bulk is REALLY quirky */
1374 gs_device_desc
.bcdDevice
=
1375 __constant_cpu_to_le16(GS_VERSION_NUM
|0x0099);
1378 usb_ep_autoconfig_reset(gadget
);
1380 ep
= usb_ep_autoconfig(gadget
, &gs_fullspeed_in_desc
);
1383 EP_IN_NAME
= ep
->name
;
1384 ep
->driver_data
= ep
; /* claim the endpoint */
1386 ep
= usb_ep_autoconfig(gadget
, &gs_fullspeed_out_desc
);
1389 EP_OUT_NAME
= ep
->name
;
1390 ep
->driver_data
= ep
; /* claim the endpoint */
1393 ep
= usb_ep_autoconfig(gadget
, &gs_fullspeed_notify_desc
);
1395 printk(KERN_ERR
"gs_bind: cannot run ACM on %s\n", gadget
->name
);
1398 gs_device_desc
.idProduct
= __constant_cpu_to_le16(
1400 EP_NOTIFY_NAME
= ep
->name
;
1401 ep
->driver_data
= ep
; /* claim the endpoint */
1404 gs_device_desc
.bDeviceClass
= use_acm
1405 ? USB_CLASS_COMM
: USB_CLASS_VENDOR_SPEC
;
1406 gs_device_desc
.bMaxPacketSize0
= gadget
->ep0
->maxpacket
;
1408 #ifdef CONFIG_USB_GADGET_DUALSPEED
1409 gs_qualifier_desc
.bDeviceClass
= use_acm
1410 ? USB_CLASS_COMM
: USB_CLASS_VENDOR_SPEC
;
1411 /* assume ep0 uses the same packet size for both speeds */
1412 gs_qualifier_desc
.bMaxPacketSize0
= gs_device_desc
.bMaxPacketSize0
;
1413 /* assume endpoints are dual-speed */
1414 gs_highspeed_notify_desc
.bEndpointAddress
=
1415 gs_fullspeed_notify_desc
.bEndpointAddress
;
1416 gs_highspeed_in_desc
.bEndpointAddress
=
1417 gs_fullspeed_in_desc
.bEndpointAddress
;
1418 gs_highspeed_out_desc
.bEndpointAddress
=
1419 gs_fullspeed_out_desc
.bEndpointAddress
;
1420 #endif /* CONFIG_USB_GADGET_DUALSPEED */
1422 usb_gadget_set_selfpowered(gadget
);
1424 if (gadget
->is_otg
) {
1425 gs_otg_descriptor
.bmAttributes
|= USB_OTG_HNP
,
1426 gs_bulk_config_desc
.bmAttributes
|= USB_CONFIG_ATT_WAKEUP
;
1427 gs_acm_config_desc
.bmAttributes
|= USB_CONFIG_ATT_WAKEUP
;
1430 gs_device
= dev
= kmalloc(sizeof(struct gs_dev
), GFP_KERNEL
);
1434 snprintf(manufacturer
, sizeof(manufacturer
), "%s %s with %s",
1435 init_utsname()->sysname
, init_utsname()->release
,
1438 memset(dev
, 0, sizeof(struct gs_dev
));
1439 dev
->dev_gadget
= gadget
;
1440 spin_lock_init(&dev
->dev_lock
);
1441 INIT_LIST_HEAD(&dev
->dev_req_list
);
1442 set_gadget_data(gadget
, dev
);
1444 if ((ret
=gs_alloc_ports(dev
, GFP_KERNEL
)) != 0) {
1445 printk(KERN_ERR
"gs_bind: cannot allocate ports\n");
1450 /* preallocate control response and buffer */
1451 dev
->dev_ctrl_req
= gs_alloc_req(gadget
->ep0
, GS_MAX_DESC_LEN
,
1453 if (dev
->dev_ctrl_req
== NULL
) {
1457 dev
->dev_ctrl_req
->complete
= gs_setup_complete
;
1459 gadget
->ep0
->driver_data
= dev
;
1461 printk(KERN_INFO
"gs_bind: %s %s bound\n",
1462 GS_LONG_NAME
, GS_VERSION_STR
);
1467 printk(KERN_ERR
"gs_bind: cannot autoconfigure on %s\n", gadget
->name
);
1474 * Called on module unload. Frees the control request and device
1477 static void /* __init_or_exit */ gs_unbind(struct usb_gadget
*gadget
)
1479 struct gs_dev
*dev
= get_gadget_data(gadget
);
1483 /* read/write requests already freed, only control request remains */
1485 if (dev
->dev_ctrl_req
!= NULL
) {
1486 gs_free_req(gadget
->ep0
, dev
->dev_ctrl_req
);
1487 dev
->dev_ctrl_req
= NULL
;
1491 set_gadget_data(gadget
, NULL
);
1494 printk(KERN_INFO
"gs_unbind: %s %s unbound\n", GS_LONG_NAME
,
1501 * Implements all the control endpoint functionality that's not
1502 * handled in hardware or the hardware driver.
1504 * Returns the size of the data sent to the host, or a negative
1507 static int gs_setup(struct usb_gadget
*gadget
,
1508 const struct usb_ctrlrequest
*ctrl
)
1510 int ret
= -EOPNOTSUPP
;
1511 struct gs_dev
*dev
= get_gadget_data(gadget
);
1512 struct usb_request
*req
= dev
->dev_ctrl_req
;
1513 u16 wIndex
= le16_to_cpu(ctrl
->wIndex
);
1514 u16 wValue
= le16_to_cpu(ctrl
->wValue
);
1515 u16 wLength
= le16_to_cpu(ctrl
->wLength
);
1517 switch (ctrl
->bRequestType
& USB_TYPE_MASK
) {
1518 case USB_TYPE_STANDARD
:
1519 ret
= gs_setup_standard(gadget
,ctrl
);
1522 case USB_TYPE_CLASS
:
1523 ret
= gs_setup_class(gadget
,ctrl
);
1527 printk(KERN_ERR
"gs_setup: unknown request, type=%02x, request=%02x, value=%04x, index=%04x, length=%d\n",
1528 ctrl
->bRequestType
, ctrl
->bRequest
,
1529 wValue
, wIndex
, wLength
);
1533 /* respond with data transfer before status phase? */
1536 req
->zero
= ret
< wLength
1537 && (ret
% gadget
->ep0
->maxpacket
) == 0;
1538 ret
= usb_ep_queue(gadget
->ep0
, req
, GFP_ATOMIC
);
1540 printk(KERN_ERR
"gs_setup: cannot queue response, ret=%d\n",
1543 gs_setup_complete(gadget
->ep0
, req
);
1547 /* device either stalls (ret < 0) or reports success */
1551 static int gs_setup_standard(struct usb_gadget
*gadget
,
1552 const struct usb_ctrlrequest
*ctrl
)
1554 int ret
= -EOPNOTSUPP
;
1555 struct gs_dev
*dev
= get_gadget_data(gadget
);
1556 struct usb_request
*req
= dev
->dev_ctrl_req
;
1557 u16 wIndex
= le16_to_cpu(ctrl
->wIndex
);
1558 u16 wValue
= le16_to_cpu(ctrl
->wValue
);
1559 u16 wLength
= le16_to_cpu(ctrl
->wLength
);
1561 switch (ctrl
->bRequest
) {
1562 case USB_REQ_GET_DESCRIPTOR
:
1563 if (ctrl
->bRequestType
!= USB_DIR_IN
)
1566 switch (wValue
>> 8) {
1569 (u16
)sizeof(struct usb_device_descriptor
));
1570 memcpy(req
->buf
, &gs_device_desc
, ret
);
1573 #ifdef CONFIG_USB_GADGET_DUALSPEED
1574 case USB_DT_DEVICE_QUALIFIER
:
1575 if (!gadget
->is_dualspeed
)
1578 (u16
)sizeof(struct usb_qualifier_descriptor
));
1579 memcpy(req
->buf
, &gs_qualifier_desc
, ret
);
1582 case USB_DT_OTHER_SPEED_CONFIG
:
1583 if (!gadget
->is_dualspeed
)
1586 #endif /* CONFIG_USB_GADGET_DUALSPEED */
1588 ret
= gs_build_config_buf(req
->buf
, gadget
->speed
,
1589 wValue
>> 8, wValue
& 0xff,
1592 ret
= min(wLength
, (u16
)ret
);
1596 /* wIndex == language code. */
1597 ret
= usb_gadget_get_string(&gs_string_table
,
1598 wValue
& 0xff, req
->buf
);
1600 ret
= min(wLength
, (u16
)ret
);
1605 case USB_REQ_SET_CONFIGURATION
:
1606 if (ctrl
->bRequestType
!= 0)
1608 spin_lock(&dev
->dev_lock
);
1609 ret
= gs_set_config(dev
, wValue
);
1610 spin_unlock(&dev
->dev_lock
);
1613 case USB_REQ_GET_CONFIGURATION
:
1614 if (ctrl
->bRequestType
!= USB_DIR_IN
)
1616 *(u8
*)req
->buf
= dev
->dev_config
;
1617 ret
= min(wLength
, (u16
)1);
1620 case USB_REQ_SET_INTERFACE
:
1621 if (ctrl
->bRequestType
!= USB_RECIP_INTERFACE
1623 || wIndex
>= GS_MAX_NUM_INTERFACES
)
1625 if (dev
->dev_config
== GS_BULK_CONFIG_ID
1626 && wIndex
!= GS_BULK_INTERFACE_ID
)
1628 /* no alternate interface settings */
1631 spin_lock(&dev
->dev_lock
);
1632 /* PXA hardware partially handles SET_INTERFACE;
1633 * we need to kluge around that interference. */
1634 if (gadget_is_pxa(gadget
)) {
1635 ret
= gs_set_config(dev
, use_acm
?
1636 GS_ACM_CONFIG_ID
: GS_BULK_CONFIG_ID
);
1637 goto set_interface_done
;
1639 if (dev
->dev_config
!= GS_BULK_CONFIG_ID
1640 && wIndex
== GS_CONTROL_INTERFACE_ID
) {
1641 if (dev
->dev_notify_ep
) {
1642 usb_ep_disable(dev
->dev_notify_ep
);
1643 usb_ep_enable(dev
->dev_notify_ep
, dev
->dev_notify_ep_desc
);
1646 usb_ep_disable(dev
->dev_in_ep
);
1647 usb_ep_disable(dev
->dev_out_ep
);
1648 usb_ep_enable(dev
->dev_in_ep
, dev
->dev_in_ep_desc
);
1649 usb_ep_enable(dev
->dev_out_ep
, dev
->dev_out_ep_desc
);
1653 spin_unlock(&dev
->dev_lock
);
1656 case USB_REQ_GET_INTERFACE
:
1657 if (ctrl
->bRequestType
!= (USB_DIR_IN
|USB_RECIP_INTERFACE
)
1658 || dev
->dev_config
== GS_NO_CONFIG_ID
)
1660 if (wIndex
>= GS_MAX_NUM_INTERFACES
1661 || (dev
->dev_config
== GS_BULK_CONFIG_ID
1662 && wIndex
!= GS_BULK_INTERFACE_ID
)) {
1666 /* no alternate interface settings */
1667 *(u8
*)req
->buf
= 0;
1668 ret
= min(wLength
, (u16
)1);
1672 printk(KERN_ERR
"gs_setup: unknown standard request, type=%02x, request=%02x, value=%04x, index=%04x, length=%d\n",
1673 ctrl
->bRequestType
, ctrl
->bRequest
,
1674 wValue
, wIndex
, wLength
);
1681 static int gs_setup_class(struct usb_gadget
*gadget
,
1682 const struct usb_ctrlrequest
*ctrl
)
1684 int ret
= -EOPNOTSUPP
;
1685 struct gs_dev
*dev
= get_gadget_data(gadget
);
1686 struct gs_port
*port
= dev
->dev_port
[0]; /* ACM only has one port */
1687 struct usb_request
*req
= dev
->dev_ctrl_req
;
1688 u16 wIndex
= le16_to_cpu(ctrl
->wIndex
);
1689 u16 wValue
= le16_to_cpu(ctrl
->wValue
);
1690 u16 wLength
= le16_to_cpu(ctrl
->wLength
);
1692 switch (ctrl
->bRequest
) {
1693 case USB_CDC_REQ_SET_LINE_CODING
:
1695 (u16
)sizeof(struct usb_cdc_line_coding
));
1697 spin_lock(&port
->port_lock
);
1698 memcpy(&port
->port_line_coding
, req
->buf
, ret
);
1699 spin_unlock(&port
->port_lock
);
1704 case USB_CDC_REQ_GET_LINE_CODING
:
1705 port
= dev
->dev_port
[0]; /* ACM only has one port */
1707 (u16
)sizeof(struct usb_cdc_line_coding
));
1709 spin_lock(&port
->port_lock
);
1710 memcpy(req
->buf
, &port
->port_line_coding
, ret
);
1711 spin_unlock(&port
->port_lock
);
1715 case USB_CDC_REQ_SET_CONTROL_LINE_STATE
:
1720 printk(KERN_ERR
"gs_setup: unknown class request, type=%02x, request=%02x, value=%04x, index=%04x, length=%d\n",
1721 ctrl
->bRequestType
, ctrl
->bRequest
,
1722 wValue
, wIndex
, wLength
);
1732 static void gs_setup_complete(struct usb_ep
*ep
, struct usb_request
*req
)
1734 if (req
->status
|| req
->actual
!= req
->length
) {
1735 printk(KERN_ERR
"gs_setup_complete: status error, status=%d, actual=%d, length=%d\n",
1736 req
->status
, req
->actual
, req
->length
);
1743 * Called when the device is disconnected. Frees the closed
1744 * ports and disconnects open ports. Open ports will be freed
1745 * on close. Then reallocates the ports for the next connection.
1747 static void gs_disconnect(struct usb_gadget
*gadget
)
1749 unsigned long flags
;
1750 struct gs_dev
*dev
= get_gadget_data(gadget
);
1752 spin_lock_irqsave(&dev
->dev_lock
, flags
);
1754 gs_reset_config(dev
);
1756 /* free closed ports and disconnect open ports */
1757 /* (open ports will be freed when closed) */
1760 /* re-allocate ports for the next connection */
1761 if (gs_alloc_ports(dev
, GFP_ATOMIC
) != 0)
1762 printk(KERN_ERR
"gs_disconnect: cannot re-allocate ports\n");
1764 spin_unlock_irqrestore(&dev
->dev_lock
, flags
);
1766 printk(KERN_INFO
"gs_disconnect: %s disconnected\n", GS_LONG_NAME
);
1772 * Configures the device by enabling device specific
1773 * optimizations, setting up the endpoints, allocating
1774 * read and write requests and queuing read requests.
1776 * The device lock must be held when calling this function.
1778 static int gs_set_config(struct gs_dev
*dev
, unsigned config
)
1782 struct usb_gadget
*gadget
= dev
->dev_gadget
;
1784 struct usb_endpoint_descriptor
*ep_desc
;
1785 struct usb_request
*req
;
1786 struct gs_req_entry
*req_entry
;
1789 printk(KERN_ERR
"gs_set_config: NULL device pointer\n");
1793 if (config
== dev
->dev_config
)
1796 gs_reset_config(dev
);
1799 case GS_NO_CONFIG_ID
:
1801 case GS_BULK_CONFIG_ID
:
1804 /* device specific optimizations */
1805 if (gadget_is_net2280(gadget
))
1806 net2280_set_fifo_mode(gadget
, 1);
1808 case GS_ACM_CONFIG_ID
:
1811 /* device specific optimizations */
1812 if (gadget_is_net2280(gadget
))
1813 net2280_set_fifo_mode(gadget
, 1);
1819 dev
->dev_config
= config
;
1821 gadget_for_each_ep(ep
, gadget
) {
1824 && strcmp(ep
->name
, EP_NOTIFY_NAME
) == 0) {
1825 ep_desc
= GS_SPEED_SELECT(
1826 gadget
->speed
== USB_SPEED_HIGH
,
1827 &gs_highspeed_notify_desc
,
1828 &gs_fullspeed_notify_desc
);
1829 ret
= usb_ep_enable(ep
,ep_desc
);
1831 ep
->driver_data
= dev
;
1832 dev
->dev_notify_ep
= ep
;
1833 dev
->dev_notify_ep_desc
= ep_desc
;
1835 printk(KERN_ERR
"gs_set_config: cannot enable notify endpoint %s, ret=%d\n",
1837 goto exit_reset_config
;
1841 else if (strcmp(ep
->name
, EP_IN_NAME
) == 0) {
1842 ep_desc
= GS_SPEED_SELECT(
1843 gadget
->speed
== USB_SPEED_HIGH
,
1844 &gs_highspeed_in_desc
,
1845 &gs_fullspeed_in_desc
);
1846 ret
= usb_ep_enable(ep
,ep_desc
);
1848 ep
->driver_data
= dev
;
1849 dev
->dev_in_ep
= ep
;
1850 dev
->dev_in_ep_desc
= ep_desc
;
1852 printk(KERN_ERR
"gs_set_config: cannot enable in endpoint %s, ret=%d\n",
1854 goto exit_reset_config
;
1858 else if (strcmp(ep
->name
, EP_OUT_NAME
) == 0) {
1859 ep_desc
= GS_SPEED_SELECT(
1860 gadget
->speed
== USB_SPEED_HIGH
,
1861 &gs_highspeed_out_desc
,
1862 &gs_fullspeed_out_desc
);
1863 ret
= usb_ep_enable(ep
,ep_desc
);
1865 ep
->driver_data
= dev
;
1866 dev
->dev_out_ep
= ep
;
1867 dev
->dev_out_ep_desc
= ep_desc
;
1869 printk(KERN_ERR
"gs_set_config: cannot enable out endpoint %s, ret=%d\n",
1871 goto exit_reset_config
;
1877 if (dev
->dev_in_ep
== NULL
|| dev
->dev_out_ep
== NULL
1878 || (config
!= GS_BULK_CONFIG_ID
&& dev
->dev_notify_ep
== NULL
)) {
1879 printk(KERN_ERR
"gs_set_config: cannot find endpoints\n");
1881 goto exit_reset_config
;
1884 /* allocate and queue read requests */
1885 ep
= dev
->dev_out_ep
;
1886 for (i
=0; i
<read_q_size
&& ret
== 0; i
++) {
1887 if ((req
=gs_alloc_req(ep
, ep
->maxpacket
, GFP_ATOMIC
))) {
1888 req
->complete
= gs_read_complete
;
1889 if ((ret
=usb_ep_queue(ep
, req
, GFP_ATOMIC
))) {
1890 printk(KERN_ERR
"gs_set_config: cannot queue read request, ret=%d\n",
1894 printk(KERN_ERR
"gs_set_config: cannot allocate read requests\n");
1896 goto exit_reset_config
;
1900 /* allocate write requests, and put on free list */
1901 ep
= dev
->dev_in_ep
;
1902 for (i
=0; i
<write_q_size
; i
++) {
1903 if ((req_entry
=gs_alloc_req_entry(ep
, ep
->maxpacket
, GFP_ATOMIC
))) {
1904 req_entry
->re_req
->complete
= gs_write_complete
;
1905 list_add(&req_entry
->re_entry
, &dev
->dev_req_list
);
1907 printk(KERN_ERR
"gs_set_config: cannot allocate write requests\n");
1909 goto exit_reset_config
;
1913 printk(KERN_INFO
"gs_set_config: %s configured, %s speed %s config\n",
1915 gadget
->speed
== USB_SPEED_HIGH
? "high" : "full",
1916 config
== GS_BULK_CONFIG_ID
? "BULK" : "CDC-ACM");
1921 gs_reset_config(dev
);
1928 * Mark the device as not configured, disable all endpoints,
1929 * which forces completion of pending I/O and frees queued
1930 * requests, and free the remaining write requests on the
1933 * The device lock must be held when calling this function.
1935 static void gs_reset_config(struct gs_dev
*dev
)
1937 struct gs_req_entry
*req_entry
;
1940 printk(KERN_ERR
"gs_reset_config: NULL device pointer\n");
1944 if (dev
->dev_config
== GS_NO_CONFIG_ID
)
1947 dev
->dev_config
= GS_NO_CONFIG_ID
;
1949 /* free write requests on the free list */
1950 while(!list_empty(&dev
->dev_req_list
)) {
1951 req_entry
= list_entry(dev
->dev_req_list
.next
,
1952 struct gs_req_entry
, re_entry
);
1953 list_del(&req_entry
->re_entry
);
1954 gs_free_req_entry(dev
->dev_in_ep
, req_entry
);
1957 /* disable endpoints, forcing completion of pending i/o; */
1958 /* completion handlers free their requests in this case */
1959 if (dev
->dev_notify_ep
) {
1960 usb_ep_disable(dev
->dev_notify_ep
);
1961 dev
->dev_notify_ep
= NULL
;
1963 if (dev
->dev_in_ep
) {
1964 usb_ep_disable(dev
->dev_in_ep
);
1965 dev
->dev_in_ep
= NULL
;
1967 if (dev
->dev_out_ep
) {
1968 usb_ep_disable(dev
->dev_out_ep
);
1969 dev
->dev_out_ep
= NULL
;
1974 * gs_build_config_buf
1976 * Builds the config descriptors in the given buffer and returns the
1977 * length, or a negative error number.
1979 static int gs_build_config_buf(u8
*buf
, enum usb_device_speed speed
,
1980 u8 type
, unsigned int index
, int is_otg
)
1984 const struct usb_config_descriptor
*config_desc
;
1985 const struct usb_descriptor_header
**function
;
1987 if (index
>= gs_device_desc
.bNumConfigurations
)
1990 /* other speed switches high and full speed */
1991 high_speed
= (speed
== USB_SPEED_HIGH
);
1992 if (type
== USB_DT_OTHER_SPEED_CONFIG
)
1993 high_speed
= !high_speed
;
1996 config_desc
= &gs_acm_config_desc
;
1997 function
= GS_SPEED_SELECT(high_speed
,
1998 gs_acm_highspeed_function
,
1999 gs_acm_fullspeed_function
);
2001 config_desc
= &gs_bulk_config_desc
;
2002 function
= GS_SPEED_SELECT(high_speed
,
2003 gs_bulk_highspeed_function
,
2004 gs_bulk_fullspeed_function
);
2007 /* for now, don't advertise srp-only devices */
2011 len
= usb_gadget_config_buf(config_desc
, buf
, GS_MAX_DESC_LEN
, function
);
2015 ((struct usb_config_descriptor
*)buf
)->bDescriptorType
= type
;
2023 * Allocate a usb_request and its buffer. Returns a pointer to the
2024 * usb_request or NULL if there is an error.
2026 static struct usb_request
*
2027 gs_alloc_req(struct usb_ep
*ep
, unsigned int len
, gfp_t kmalloc_flags
)
2029 struct usb_request
*req
;
2034 req
= usb_ep_alloc_request(ep
, kmalloc_flags
);
2038 req
->buf
= kmalloc(len
, kmalloc_flags
);
2039 if (req
->buf
== NULL
) {
2040 usb_ep_free_request(ep
, req
);
2051 * Free a usb_request and its buffer.
2053 static void gs_free_req(struct usb_ep
*ep
, struct usb_request
*req
)
2055 if (ep
!= NULL
&& req
!= NULL
) {
2057 usb_ep_free_request(ep
, req
);
2062 * gs_alloc_req_entry
2064 * Allocates a request and its buffer, using the given
2065 * endpoint, buffer len, and kmalloc flags.
2067 static struct gs_req_entry
*
2068 gs_alloc_req_entry(struct usb_ep
*ep
, unsigned len
, gfp_t kmalloc_flags
)
2070 struct gs_req_entry
*req
;
2072 req
= kmalloc(sizeof(struct gs_req_entry
), kmalloc_flags
);
2076 req
->re_req
= gs_alloc_req(ep
, len
, kmalloc_flags
);
2077 if (req
->re_req
== NULL
) {
2082 req
->re_req
->context
= req
;
2090 * Frees a request and its buffer.
2092 static void gs_free_req_entry(struct usb_ep
*ep
, struct gs_req_entry
*req
)
2094 if (ep
!= NULL
&& req
!= NULL
) {
2095 if (req
->re_req
!= NULL
)
2096 gs_free_req(ep
, req
->re_req
);
2104 * Allocate all ports and set the gs_dev struct to point to them.
2105 * Return 0 if successful, or a negative error number.
2107 * The device lock is normally held when calling this function.
2109 static int gs_alloc_ports(struct gs_dev
*dev
, gfp_t kmalloc_flags
)
2112 struct gs_port
*port
;
2117 for (i
=0; i
<GS_NUM_PORTS
; i
++) {
2118 if ((port
=kzalloc(sizeof(struct gs_port
), kmalloc_flags
)) == NULL
)
2121 port
->port_dev
= dev
;
2123 port
->port_line_coding
.dwDTERate
= cpu_to_le32(GS_DEFAULT_DTE_RATE
);
2124 port
->port_line_coding
.bCharFormat
= GS_DEFAULT_CHAR_FORMAT
;
2125 port
->port_line_coding
.bParityType
= GS_DEFAULT_PARITY
;
2126 port
->port_line_coding
.bDataBits
= GS_DEFAULT_DATA_BITS
;
2127 spin_lock_init(&port
->port_lock
);
2128 init_waitqueue_head(&port
->port_write_wait
);
2130 dev
->dev_port
[i
] = port
;
2139 * Free all closed ports. Open ports are disconnected by
2140 * freeing their write buffers, setting their device pointers
2141 * and the pointers to them in the device to NULL. These
2142 * ports will be freed when closed.
2144 * The device lock is normally held when calling this function.
2146 static void gs_free_ports(struct gs_dev
*dev
)
2149 unsigned long flags
;
2150 struct gs_port
*port
;
2155 for (i
=0; i
<GS_NUM_PORTS
; i
++) {
2156 if ((port
=dev
->dev_port
[i
]) != NULL
) {
2157 dev
->dev_port
[i
] = NULL
;
2159 spin_lock_irqsave(&port
->port_lock
, flags
);
2161 if (port
->port_write_buf
!= NULL
) {
2162 gs_buf_free(port
->port_write_buf
);
2163 port
->port_write_buf
= NULL
;
2166 if (port
->port_open_count
> 0 || port
->port_in_use
) {
2167 port
->port_dev
= NULL
;
2168 wake_up_interruptible(&port
->port_write_wait
);
2169 if (port
->port_tty
) {
2170 wake_up_interruptible(&port
->port_tty
->read_wait
);
2171 wake_up_interruptible(&port
->port_tty
->write_wait
);
2173 spin_unlock_irqrestore(&port
->port_lock
, flags
);
2175 spin_unlock_irqrestore(&port
->port_lock
, flags
);
2183 /* Circular Buffer */
2188 * Allocate a circular buffer and all associated memory.
2190 static struct gs_buf
*gs_buf_alloc(unsigned int size
, gfp_t kmalloc_flags
)
2197 gb
= kmalloc(sizeof(struct gs_buf
), kmalloc_flags
);
2201 gb
->buf_buf
= kmalloc(size
, kmalloc_flags
);
2202 if (gb
->buf_buf
== NULL
) {
2207 gb
->buf_size
= size
;
2208 gb
->buf_get
= gb
->buf_put
= gb
->buf_buf
;
2216 * Free the buffer and all associated memory.
2218 void gs_buf_free(struct gs_buf
*gb
)
2229 * Clear out all data in the circular buffer.
2231 void gs_buf_clear(struct gs_buf
*gb
)
2234 gb
->buf_get
= gb
->buf_put
;
2235 /* equivalent to a get of all data available */
2241 * Return the number of bytes of data available in the circular
2244 unsigned int gs_buf_data_avail(struct gs_buf
*gb
)
2247 return (gb
->buf_size
+ gb
->buf_put
- gb
->buf_get
) % gb
->buf_size
;
2253 * gs_buf_space_avail
2255 * Return the number of bytes of space available in the circular
2258 unsigned int gs_buf_space_avail(struct gs_buf
*gb
)
2261 return (gb
->buf_size
+ gb
->buf_get
- gb
->buf_put
- 1) % gb
->buf_size
;
2269 * Copy data data from a user buffer and put it into the circular buffer.
2270 * Restrict to the amount of space available.
2272 * Return the number of bytes copied.
2274 unsigned int gs_buf_put(struct gs_buf
*gb
, const char *buf
, unsigned int count
)
2281 len
= gs_buf_space_avail(gb
);
2288 len
= gb
->buf_buf
+ gb
->buf_size
- gb
->buf_put
;
2290 memcpy(gb
->buf_put
, buf
, len
);
2291 memcpy(gb
->buf_buf
, buf
+len
, count
- len
);
2292 gb
->buf_put
= gb
->buf_buf
+ count
- len
;
2294 memcpy(gb
->buf_put
, buf
, count
);
2296 gb
->buf_put
+= count
;
2297 else /* count == len */
2298 gb
->buf_put
= gb
->buf_buf
;
2307 * Get data from the circular buffer and copy to the given buffer.
2308 * Restrict to the amount of data available.
2310 * Return the number of bytes copied.
2312 unsigned int gs_buf_get(struct gs_buf
*gb
, char *buf
, unsigned int count
)
2319 len
= gs_buf_data_avail(gb
);
2326 len
= gb
->buf_buf
+ gb
->buf_size
- gb
->buf_get
;
2328 memcpy(buf
, gb
->buf_get
, len
);
2329 memcpy(buf
+len
, gb
->buf_buf
, count
- len
);
2330 gb
->buf_get
= gb
->buf_buf
+ count
- len
;
2332 memcpy(buf
, gb
->buf_get
, count
);
2334 gb
->buf_get
+= count
;
2335 else /* count == len */
2336 gb
->buf_get
= gb
->buf_buf
;