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>
36 #include <linux/mutex.h>
38 #include <asm/byteorder.h>
41 #include <asm/system.h>
42 #include <asm/unaligned.h>
43 #include <asm/uaccess.h>
45 #include <linux/usb/ch9.h>
46 #include <linux/usb/cdc.h>
47 #include <linux/usb_gadget.h>
49 #include "gadget_chips.h"
54 #define GS_VERSION_STR "v2.2"
55 #define GS_VERSION_NUM 0x0202
57 #define GS_LONG_NAME "Gadget Serial"
58 #define GS_SHORT_NAME "g_serial"
61 #define GS_MINOR_START 0
63 #define GS_NUM_PORTS 16
65 #define GS_NUM_CONFIGS 1
66 #define GS_NO_CONFIG_ID 0
67 #define GS_BULK_CONFIG_ID 1
68 #define GS_ACM_CONFIG_ID 2
70 #define GS_MAX_NUM_INTERFACES 2
71 #define GS_BULK_INTERFACE_ID 0
72 #define GS_CONTROL_INTERFACE_ID 0
73 #define GS_DATA_INTERFACE_ID 1
75 #define GS_MAX_DESC_LEN 256
77 #define GS_DEFAULT_READ_Q_SIZE 32
78 #define GS_DEFAULT_WRITE_Q_SIZE 32
80 #define GS_DEFAULT_WRITE_BUF_SIZE 8192
81 #define GS_TMP_BUF_SIZE 8192
83 #define GS_CLOSE_TIMEOUT 15
85 #define GS_DEFAULT_USE_ACM 0
87 #define GS_DEFAULT_DTE_RATE 9600
88 #define GS_DEFAULT_DATA_BITS 8
89 #define GS_DEFAULT_PARITY USB_CDC_NO_PARITY
90 #define GS_DEFAULT_CHAR_FORMAT USB_CDC_1_STOP_BITS
92 /* select highspeed/fullspeed, hiding highspeed if not configured */
93 #ifdef CONFIG_USB_GADGET_DUALSPEED
94 #define GS_SPEED_SELECT(is_hs,hs,fs) ((is_hs) ? (hs) : (fs))
96 #define GS_SPEED_SELECT(is_hs,hs,fs) (fs)
97 #endif /* CONFIG_USB_GADGET_DUALSPEED */
101 static int debug
= 1;
103 #define gs_debug(format, arg...) \
104 do { if (debug) printk(KERN_DEBUG format, ## arg); } while(0)
105 #define gs_debug_level(level, format, arg...) \
106 do { if (debug>=level) printk(KERN_DEBUG format, ## arg); } while(0)
110 #define gs_debug(format, arg...) \
112 #define gs_debug_level(level, format, arg...) \
115 #endif /* GS_DEBUG */
117 /* Thanks to NetChip Technologies for donating this product ID.
119 * DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
120 * Instead: allocate your own, using normal USB-IF procedures.
122 #define GS_VENDOR_ID 0x0525 /* NetChip */
123 #define GS_PRODUCT_ID 0xa4a6 /* Linux-USB Serial Gadget */
124 #define GS_CDC_PRODUCT_ID 0xa4a7 /* ... as CDC-ACM */
126 #define GS_LOG2_NOTIFY_INTERVAL 5 /* 1 << 5 == 32 msec */
127 #define GS_NOTIFY_MAXPACKET 8
134 /* circular buffer */
136 unsigned int buf_size
;
142 /* list of requests */
143 struct gs_req_entry
{
144 struct list_head re_entry
;
145 struct usb_request
*re_req
;
148 /* the port structure holds info for each port, one for each minor number */
150 struct gs_dev
*port_dev
; /* pointer to device struct */
151 struct tty_struct
*port_tty
; /* pointer to tty struct */
152 spinlock_t port_lock
;
155 int port_in_use
; /* open/close in progress */
156 wait_queue_head_t port_write_wait
;/* waiting to write */
157 struct gs_buf
*port_write_buf
;
158 struct usb_cdc_line_coding port_line_coding
;
161 /* the device structure holds info for the USB device */
163 struct usb_gadget
*dev_gadget
; /* gadget device pointer */
164 spinlock_t dev_lock
; /* lock for set/reset config */
165 int dev_config
; /* configuration number */
166 struct usb_ep
*dev_notify_ep
; /* address of notify endpoint */
167 struct usb_ep
*dev_in_ep
; /* address of in endpoint */
168 struct usb_ep
*dev_out_ep
; /* address of out endpoint */
169 struct usb_endpoint_descriptor
/* descriptor of notify ep */
171 struct usb_endpoint_descriptor
/* descriptor of in endpoint */
173 struct usb_endpoint_descriptor
/* descriptor of out endpoint */
175 struct usb_request
*dev_ctrl_req
; /* control request */
176 struct list_head dev_req_list
; /* list of write requests */
177 int dev_sched_port
; /* round robin port scheduled */
178 struct gs_port
*dev_port
[GS_NUM_PORTS
]; /* the ports */
185 static int __init
gs_module_init(void);
186 static void __exit
gs_module_exit(void);
189 static int gs_open(struct tty_struct
*tty
, struct file
*file
);
190 static void gs_close(struct tty_struct
*tty
, struct file
*file
);
191 static int gs_write(struct tty_struct
*tty
,
192 const unsigned char *buf
, int count
);
193 static void gs_put_char(struct tty_struct
*tty
, unsigned char ch
);
194 static void gs_flush_chars(struct tty_struct
*tty
);
195 static int gs_write_room(struct tty_struct
*tty
);
196 static int gs_chars_in_buffer(struct tty_struct
*tty
);
197 static void gs_throttle(struct tty_struct
* tty
);
198 static void gs_unthrottle(struct tty_struct
* tty
);
199 static void gs_break(struct tty_struct
*tty
, int break_state
);
200 static int gs_ioctl(struct tty_struct
*tty
, struct file
*file
,
201 unsigned int cmd
, unsigned long arg
);
202 static void gs_set_termios(struct tty_struct
*tty
, struct ktermios
*old
);
204 static int gs_send(struct gs_dev
*dev
);
205 static int gs_send_packet(struct gs_dev
*dev
, char *packet
,
207 static int gs_recv_packet(struct gs_dev
*dev
, char *packet
,
209 static void gs_read_complete(struct usb_ep
*ep
, struct usb_request
*req
);
210 static void gs_write_complete(struct usb_ep
*ep
, struct usb_request
*req
);
213 static int gs_bind(struct usb_gadget
*gadget
);
214 static void gs_unbind(struct usb_gadget
*gadget
);
215 static int gs_setup(struct usb_gadget
*gadget
,
216 const struct usb_ctrlrequest
*ctrl
);
217 static int gs_setup_standard(struct usb_gadget
*gadget
,
218 const struct usb_ctrlrequest
*ctrl
);
219 static int gs_setup_class(struct usb_gadget
*gadget
,
220 const struct usb_ctrlrequest
*ctrl
);
221 static void gs_setup_complete(struct usb_ep
*ep
, struct usb_request
*req
);
222 static void gs_disconnect(struct usb_gadget
*gadget
);
223 static int gs_set_config(struct gs_dev
*dev
, unsigned config
);
224 static void gs_reset_config(struct gs_dev
*dev
);
225 static int gs_build_config_buf(u8
*buf
, enum usb_device_speed speed
,
226 u8 type
, unsigned int index
, int is_otg
);
228 static struct usb_request
*gs_alloc_req(struct usb_ep
*ep
, unsigned int len
,
229 gfp_t kmalloc_flags
);
230 static void gs_free_req(struct usb_ep
*ep
, struct usb_request
*req
);
232 static struct gs_req_entry
*gs_alloc_req_entry(struct usb_ep
*ep
, unsigned len
,
233 gfp_t kmalloc_flags
);
234 static void gs_free_req_entry(struct usb_ep
*ep
, struct gs_req_entry
*req
);
236 static int gs_alloc_ports(struct gs_dev
*dev
, gfp_t kmalloc_flags
);
237 static void gs_free_ports(struct gs_dev
*dev
);
239 /* circular buffer */
240 static struct gs_buf
*gs_buf_alloc(unsigned int size
, gfp_t kmalloc_flags
);
241 static void gs_buf_free(struct gs_buf
*gb
);
242 static void gs_buf_clear(struct gs_buf
*gb
);
243 static unsigned int gs_buf_data_avail(struct gs_buf
*gb
);
244 static unsigned int gs_buf_space_avail(struct gs_buf
*gb
);
245 static unsigned int gs_buf_put(struct gs_buf
*gb
, const char *buf
,
247 static unsigned int gs_buf_get(struct gs_buf
*gb
, char *buf
,
250 /* external functions */
251 extern int net2280_set_fifo_mode(struct usb_gadget
*gadget
, int mode
);
256 static struct gs_dev
*gs_device
;
258 static const char *EP_IN_NAME
;
259 static const char *EP_OUT_NAME
;
260 static const char *EP_NOTIFY_NAME
;
262 static struct mutex gs_open_close_lock
[GS_NUM_PORTS
];
264 static unsigned int read_q_size
= GS_DEFAULT_READ_Q_SIZE
;
265 static unsigned int write_q_size
= GS_DEFAULT_WRITE_Q_SIZE
;
267 static unsigned int write_buf_size
= GS_DEFAULT_WRITE_BUF_SIZE
;
269 static unsigned int use_acm
= GS_DEFAULT_USE_ACM
;
272 /* tty driver struct */
273 static const struct tty_operations gs_tty_ops
= {
277 .put_char
= gs_put_char
,
278 .flush_chars
= gs_flush_chars
,
279 .write_room
= gs_write_room
,
281 .set_termios
= gs_set_termios
,
282 .throttle
= gs_throttle
,
283 .unthrottle
= gs_unthrottle
,
284 .break_ctl
= gs_break
,
285 .chars_in_buffer
= gs_chars_in_buffer
,
287 static struct tty_driver
*gs_tty_driver
;
289 /* gadget driver struct */
290 static struct usb_gadget_driver gs_gadget_driver
= {
291 #ifdef CONFIG_USB_GADGET_DUALSPEED
292 .speed
= USB_SPEED_HIGH
,
294 .speed
= USB_SPEED_FULL
,
295 #endif /* CONFIG_USB_GADGET_DUALSPEED */
296 .function
= GS_LONG_NAME
,
300 .disconnect
= gs_disconnect
,
302 .name
= GS_SHORT_NAME
,
307 /* USB descriptors */
309 #define GS_MANUFACTURER_STR_ID 1
310 #define GS_PRODUCT_STR_ID 2
311 #define GS_SERIAL_STR_ID 3
312 #define GS_BULK_CONFIG_STR_ID 4
313 #define GS_ACM_CONFIG_STR_ID 5
314 #define GS_CONTROL_STR_ID 6
315 #define GS_DATA_STR_ID 7
317 /* static strings, in UTF-8 */
318 static char manufacturer
[50];
319 static struct usb_string gs_strings
[] = {
320 { GS_MANUFACTURER_STR_ID
, manufacturer
},
321 { GS_PRODUCT_STR_ID
, GS_LONG_NAME
},
322 { GS_SERIAL_STR_ID
, "0" },
323 { GS_BULK_CONFIG_STR_ID
, "Gadget Serial Bulk" },
324 { GS_ACM_CONFIG_STR_ID
, "Gadget Serial CDC ACM" },
325 { GS_CONTROL_STR_ID
, "Gadget Serial Control" },
326 { GS_DATA_STR_ID
, "Gadget Serial Data" },
327 { } /* end of list */
330 static struct usb_gadget_strings gs_string_table
= {
331 .language
= 0x0409, /* en-us */
332 .strings
= gs_strings
,
335 static struct usb_device_descriptor gs_device_desc
= {
336 .bLength
= USB_DT_DEVICE_SIZE
,
337 .bDescriptorType
= USB_DT_DEVICE
,
338 .bcdUSB
= __constant_cpu_to_le16(0x0200),
339 .bDeviceSubClass
= 0,
340 .bDeviceProtocol
= 0,
341 .idVendor
= __constant_cpu_to_le16(GS_VENDOR_ID
),
342 .idProduct
= __constant_cpu_to_le16(GS_PRODUCT_ID
),
343 .iManufacturer
= GS_MANUFACTURER_STR_ID
,
344 .iProduct
= GS_PRODUCT_STR_ID
,
345 .iSerialNumber
= GS_SERIAL_STR_ID
,
346 .bNumConfigurations
= GS_NUM_CONFIGS
,
349 static struct usb_otg_descriptor gs_otg_descriptor
= {
350 .bLength
= sizeof(gs_otg_descriptor
),
351 .bDescriptorType
= USB_DT_OTG
,
352 .bmAttributes
= USB_OTG_SRP
,
355 static struct usb_config_descriptor gs_bulk_config_desc
= {
356 .bLength
= USB_DT_CONFIG_SIZE
,
357 .bDescriptorType
= USB_DT_CONFIG
,
358 /* .wTotalLength computed dynamically */
360 .bConfigurationValue
= GS_BULK_CONFIG_ID
,
361 .iConfiguration
= GS_BULK_CONFIG_STR_ID
,
362 .bmAttributes
= USB_CONFIG_ATT_ONE
| USB_CONFIG_ATT_SELFPOWER
,
366 static struct usb_config_descriptor gs_acm_config_desc
= {
367 .bLength
= USB_DT_CONFIG_SIZE
,
368 .bDescriptorType
= USB_DT_CONFIG
,
369 /* .wTotalLength computed dynamically */
371 .bConfigurationValue
= GS_ACM_CONFIG_ID
,
372 .iConfiguration
= GS_ACM_CONFIG_STR_ID
,
373 .bmAttributes
= USB_CONFIG_ATT_ONE
| USB_CONFIG_ATT_SELFPOWER
,
377 static const struct usb_interface_descriptor gs_bulk_interface_desc
= {
378 .bLength
= USB_DT_INTERFACE_SIZE
,
379 .bDescriptorType
= USB_DT_INTERFACE
,
380 .bInterfaceNumber
= GS_BULK_INTERFACE_ID
,
382 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
383 .bInterfaceSubClass
= 0,
384 .bInterfaceProtocol
= 0,
385 .iInterface
= GS_DATA_STR_ID
,
388 static const struct usb_interface_descriptor gs_control_interface_desc
= {
389 .bLength
= USB_DT_INTERFACE_SIZE
,
390 .bDescriptorType
= USB_DT_INTERFACE
,
391 .bInterfaceNumber
= GS_CONTROL_INTERFACE_ID
,
393 .bInterfaceClass
= USB_CLASS_COMM
,
394 .bInterfaceSubClass
= USB_CDC_SUBCLASS_ACM
,
395 .bInterfaceProtocol
= USB_CDC_ACM_PROTO_AT_V25TER
,
396 .iInterface
= GS_CONTROL_STR_ID
,
399 static const struct usb_interface_descriptor gs_data_interface_desc
= {
400 .bLength
= USB_DT_INTERFACE_SIZE
,
401 .bDescriptorType
= USB_DT_INTERFACE
,
402 .bInterfaceNumber
= GS_DATA_INTERFACE_ID
,
404 .bInterfaceClass
= USB_CLASS_CDC_DATA
,
405 .bInterfaceSubClass
= 0,
406 .bInterfaceProtocol
= 0,
407 .iInterface
= GS_DATA_STR_ID
,
410 static const struct usb_cdc_header_desc gs_header_desc
= {
411 .bLength
= sizeof(gs_header_desc
),
412 .bDescriptorType
= USB_DT_CS_INTERFACE
,
413 .bDescriptorSubType
= USB_CDC_HEADER_TYPE
,
414 .bcdCDC
= __constant_cpu_to_le16(0x0110),
417 static const struct usb_cdc_call_mgmt_descriptor gs_call_mgmt_descriptor
= {
418 .bLength
= sizeof(gs_call_mgmt_descriptor
),
419 .bDescriptorType
= USB_DT_CS_INTERFACE
,
420 .bDescriptorSubType
= USB_CDC_CALL_MANAGEMENT_TYPE
,
422 .bDataInterface
= 1, /* index of data interface */
425 static struct usb_cdc_acm_descriptor gs_acm_descriptor
= {
426 .bLength
= sizeof(gs_acm_descriptor
),
427 .bDescriptorType
= USB_DT_CS_INTERFACE
,
428 .bDescriptorSubType
= USB_CDC_ACM_TYPE
,
432 static const struct usb_cdc_union_desc gs_union_desc
= {
433 .bLength
= sizeof(gs_union_desc
),
434 .bDescriptorType
= USB_DT_CS_INTERFACE
,
435 .bDescriptorSubType
= USB_CDC_UNION_TYPE
,
436 .bMasterInterface0
= 0, /* index of control interface */
437 .bSlaveInterface0
= 1, /* index of data interface */
440 static struct usb_endpoint_descriptor gs_fullspeed_notify_desc
= {
441 .bLength
= USB_DT_ENDPOINT_SIZE
,
442 .bDescriptorType
= USB_DT_ENDPOINT
,
443 .bEndpointAddress
= USB_DIR_IN
,
444 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
445 .wMaxPacketSize
= __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET
),
446 .bInterval
= 1 << GS_LOG2_NOTIFY_INTERVAL
,
449 static struct usb_endpoint_descriptor gs_fullspeed_in_desc
= {
450 .bLength
= USB_DT_ENDPOINT_SIZE
,
451 .bDescriptorType
= USB_DT_ENDPOINT
,
452 .bEndpointAddress
= USB_DIR_IN
,
453 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
456 static struct usb_endpoint_descriptor gs_fullspeed_out_desc
= {
457 .bLength
= USB_DT_ENDPOINT_SIZE
,
458 .bDescriptorType
= USB_DT_ENDPOINT
,
459 .bEndpointAddress
= USB_DIR_OUT
,
460 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
463 static const struct usb_descriptor_header
*gs_bulk_fullspeed_function
[] = {
464 (struct usb_descriptor_header
*) &gs_otg_descriptor
,
465 (struct usb_descriptor_header
*) &gs_bulk_interface_desc
,
466 (struct usb_descriptor_header
*) &gs_fullspeed_in_desc
,
467 (struct usb_descriptor_header
*) &gs_fullspeed_out_desc
,
471 static const struct usb_descriptor_header
*gs_acm_fullspeed_function
[] = {
472 (struct usb_descriptor_header
*) &gs_otg_descriptor
,
473 (struct usb_descriptor_header
*) &gs_control_interface_desc
,
474 (struct usb_descriptor_header
*) &gs_header_desc
,
475 (struct usb_descriptor_header
*) &gs_call_mgmt_descriptor
,
476 (struct usb_descriptor_header
*) &gs_acm_descriptor
,
477 (struct usb_descriptor_header
*) &gs_union_desc
,
478 (struct usb_descriptor_header
*) &gs_fullspeed_notify_desc
,
479 (struct usb_descriptor_header
*) &gs_data_interface_desc
,
480 (struct usb_descriptor_header
*) &gs_fullspeed_in_desc
,
481 (struct usb_descriptor_header
*) &gs_fullspeed_out_desc
,
485 #ifdef CONFIG_USB_GADGET_DUALSPEED
486 static struct usb_endpoint_descriptor gs_highspeed_notify_desc
= {
487 .bLength
= USB_DT_ENDPOINT_SIZE
,
488 .bDescriptorType
= USB_DT_ENDPOINT
,
489 .bEndpointAddress
= USB_DIR_IN
,
490 .bmAttributes
= USB_ENDPOINT_XFER_INT
,
491 .wMaxPacketSize
= __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET
),
492 .bInterval
= GS_LOG2_NOTIFY_INTERVAL
+4,
495 static struct usb_endpoint_descriptor gs_highspeed_in_desc
= {
496 .bLength
= USB_DT_ENDPOINT_SIZE
,
497 .bDescriptorType
= USB_DT_ENDPOINT
,
498 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
499 .wMaxPacketSize
= __constant_cpu_to_le16(512),
502 static struct usb_endpoint_descriptor gs_highspeed_out_desc
= {
503 .bLength
= USB_DT_ENDPOINT_SIZE
,
504 .bDescriptorType
= USB_DT_ENDPOINT
,
505 .bmAttributes
= USB_ENDPOINT_XFER_BULK
,
506 .wMaxPacketSize
= __constant_cpu_to_le16(512),
509 static struct usb_qualifier_descriptor gs_qualifier_desc
= {
510 .bLength
= sizeof(struct usb_qualifier_descriptor
),
511 .bDescriptorType
= USB_DT_DEVICE_QUALIFIER
,
512 .bcdUSB
= __constant_cpu_to_le16 (0x0200),
513 /* assumes ep0 uses the same value for both speeds ... */
514 .bNumConfigurations
= GS_NUM_CONFIGS
,
517 static const struct usb_descriptor_header
*gs_bulk_highspeed_function
[] = {
518 (struct usb_descriptor_header
*) &gs_otg_descriptor
,
519 (struct usb_descriptor_header
*) &gs_bulk_interface_desc
,
520 (struct usb_descriptor_header
*) &gs_highspeed_in_desc
,
521 (struct usb_descriptor_header
*) &gs_highspeed_out_desc
,
525 static const struct usb_descriptor_header
*gs_acm_highspeed_function
[] = {
526 (struct usb_descriptor_header
*) &gs_otg_descriptor
,
527 (struct usb_descriptor_header
*) &gs_control_interface_desc
,
528 (struct usb_descriptor_header
*) &gs_header_desc
,
529 (struct usb_descriptor_header
*) &gs_call_mgmt_descriptor
,
530 (struct usb_descriptor_header
*) &gs_acm_descriptor
,
531 (struct usb_descriptor_header
*) &gs_union_desc
,
532 (struct usb_descriptor_header
*) &gs_highspeed_notify_desc
,
533 (struct usb_descriptor_header
*) &gs_data_interface_desc
,
534 (struct usb_descriptor_header
*) &gs_highspeed_in_desc
,
535 (struct usb_descriptor_header
*) &gs_highspeed_out_desc
,
539 #endif /* CONFIG_USB_GADGET_DUALSPEED */
543 MODULE_DESCRIPTION(GS_LONG_NAME
);
544 MODULE_AUTHOR("Al Borchers");
545 MODULE_LICENSE("GPL");
548 module_param(debug
, int, S_IRUGO
|S_IWUSR
);
549 MODULE_PARM_DESC(debug
, "Enable debugging, 0=off, 1=on");
552 module_param(read_q_size
, uint
, S_IRUGO
);
553 MODULE_PARM_DESC(read_q_size
, "Read request queue size, default=32");
555 module_param(write_q_size
, uint
, S_IRUGO
);
556 MODULE_PARM_DESC(write_q_size
, "Write request queue size, default=32");
558 module_param(write_buf_size
, uint
, S_IRUGO
);
559 MODULE_PARM_DESC(write_buf_size
, "Write buffer size, default=8192");
561 module_param(use_acm
, uint
, S_IRUGO
);
562 MODULE_PARM_DESC(use_acm
, "Use CDC ACM, 0=no, 1=yes, default=no");
564 module_init(gs_module_init
);
565 module_exit(gs_module_exit
);
570 * Register as a USB gadget driver and a tty driver.
572 static int __init
gs_module_init(void)
577 retval
= usb_gadget_register_driver(&gs_gadget_driver
);
579 printk(KERN_ERR
"gs_module_init: cannot register gadget driver, ret=%d\n", retval
);
583 gs_tty_driver
= alloc_tty_driver(GS_NUM_PORTS
);
586 gs_tty_driver
->owner
= THIS_MODULE
;
587 gs_tty_driver
->driver_name
= GS_SHORT_NAME
;
588 gs_tty_driver
->name
= "ttygs";
589 gs_tty_driver
->major
= GS_MAJOR
;
590 gs_tty_driver
->minor_start
= GS_MINOR_START
;
591 gs_tty_driver
->type
= TTY_DRIVER_TYPE_SERIAL
;
592 gs_tty_driver
->subtype
= SERIAL_TYPE_NORMAL
;
593 gs_tty_driver
->flags
= TTY_DRIVER_REAL_RAW
| TTY_DRIVER_DYNAMIC_DEV
;
594 gs_tty_driver
->init_termios
= tty_std_termios
;
595 gs_tty_driver
->init_termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
| CLOCAL
;
596 tty_set_operations(gs_tty_driver
, &gs_tty_ops
);
598 for (i
=0; i
< GS_NUM_PORTS
; i
++)
599 mutex_init(&gs_open_close_lock
[i
]);
601 retval
= tty_register_driver(gs_tty_driver
);
603 usb_gadget_unregister_driver(&gs_gadget_driver
);
604 put_tty_driver(gs_tty_driver
);
605 printk(KERN_ERR
"gs_module_init: cannot register tty driver, ret=%d\n", retval
);
609 printk(KERN_INFO
"gs_module_init: %s %s loaded\n", GS_LONG_NAME
, GS_VERSION_STR
);
616 * Unregister as a tty driver and a USB gadget driver.
618 static void __exit
gs_module_exit(void)
620 tty_unregister_driver(gs_tty_driver
);
621 put_tty_driver(gs_tty_driver
);
622 usb_gadget_unregister_driver(&gs_gadget_driver
);
624 printk(KERN_INFO
"gs_module_exit: %s %s unloaded\n", GS_LONG_NAME
, GS_VERSION_STR
);
632 static int gs_open(struct tty_struct
*tty
, struct file
*file
)
636 struct gs_port
*port
;
642 port_num
= tty
->index
;
644 gs_debug("gs_open: (%d,%p,%p)\n", port_num
, tty
, file
);
646 if (port_num
< 0 || port_num
>= GS_NUM_PORTS
) {
647 printk(KERN_ERR
"gs_open: (%d,%p,%p) invalid port number\n",
648 port_num
, tty
, file
);
655 printk(KERN_ERR
"gs_open: (%d,%p,%p) NULL device pointer\n",
656 port_num
, tty
, file
);
660 mtx
= &gs_open_close_lock
[port_num
];
661 if (mutex_lock_interruptible(mtx
)) {
663 "gs_open: (%d,%p,%p) interrupted waiting for mutex\n",
664 port_num
, tty
, file
);
668 spin_lock_irqsave(&dev
->dev_lock
, flags
);
670 if (dev
->dev_config
== GS_NO_CONFIG_ID
) {
672 "gs_open: (%d,%p,%p) device is not connected\n",
673 port_num
, tty
, file
);
675 goto exit_unlock_dev
;
678 port
= dev
->dev_port
[port_num
];
681 printk(KERN_ERR
"gs_open: (%d,%p,%p) NULL port pointer\n",
682 port_num
, tty
, file
);
684 goto exit_unlock_dev
;
687 spin_lock(&port
->port_lock
);
688 spin_unlock(&dev
->dev_lock
);
690 if (port
->port_dev
== NULL
) {
691 printk(KERN_ERR
"gs_open: (%d,%p,%p) port disconnected (1)\n",
692 port_num
, tty
, file
);
694 goto exit_unlock_port
;
697 if (port
->port_open_count
> 0) {
698 ++port
->port_open_count
;
699 gs_debug("gs_open: (%d,%p,%p) already open\n",
700 port_num
, tty
, file
);
702 goto exit_unlock_port
;
705 tty
->driver_data
= NULL
;
707 /* mark port as in use, we can drop port lock and sleep if necessary */
708 port
->port_in_use
= 1;
710 /* allocate write buffer on first open */
711 if (port
->port_write_buf
== NULL
) {
712 spin_unlock_irqrestore(&port
->port_lock
, flags
);
713 buf
= gs_buf_alloc(write_buf_size
, GFP_KERNEL
);
714 spin_lock_irqsave(&port
->port_lock
, flags
);
716 /* might have been disconnected while asleep, check */
717 if (port
->port_dev
== NULL
) {
719 "gs_open: (%d,%p,%p) port disconnected (2)\n",
720 port_num
, tty
, file
);
721 port
->port_in_use
= 0;
723 goto exit_unlock_port
;
726 if ((port
->port_write_buf
=buf
) == NULL
) {
727 printk(KERN_ERR
"gs_open: (%d,%p,%p) cannot allocate port write buffer\n",
728 port_num
, tty
, file
);
729 port
->port_in_use
= 0;
731 goto exit_unlock_port
;
736 /* wait for carrier detect (not implemented) */
738 /* might have been disconnected while asleep, check */
739 if (port
->port_dev
== NULL
) {
740 printk(KERN_ERR
"gs_open: (%d,%p,%p) port disconnected (3)\n",
741 port_num
, tty
, file
);
742 port
->port_in_use
= 0;
744 goto exit_unlock_port
;
747 tty
->driver_data
= port
;
748 port
->port_tty
= tty
;
749 port
->port_open_count
= 1;
750 port
->port_in_use
= 0;
752 gs_debug("gs_open: (%d,%p,%p) completed\n", port_num
, tty
, file
);
757 spin_unlock_irqrestore(&port
->port_lock
, flags
);
762 spin_unlock_irqrestore(&dev
->dev_lock
, flags
);
772 #define GS_WRITE_FINISHED_EVENT_SAFELY(p) \
776 spin_lock_irq(&(p)->port_lock); \
777 cond = !(p)->port_dev || !gs_buf_data_avail((p)->port_write_buf); \
778 spin_unlock_irq(&(p)->port_lock); \
782 static void gs_close(struct tty_struct
*tty
, struct file
*file
)
784 struct gs_port
*port
= tty
->driver_data
;
788 printk(KERN_ERR
"gs_close: NULL port pointer\n");
792 gs_debug("gs_close: (%d,%p,%p)\n", port
->port_num
, tty
, file
);
794 mtx
= &gs_open_close_lock
[port
->port_num
];
797 spin_lock_irq(&port
->port_lock
);
799 if (port
->port_open_count
== 0) {
801 "gs_close: (%d,%p,%p) port is already closed\n",
802 port
->port_num
, tty
, file
);
806 if (port
->port_open_count
> 1) {
807 --port
->port_open_count
;
811 /* free disconnected port on final close */
812 if (port
->port_dev
== NULL
) {
817 /* mark port as closed but in use, we can drop port lock */
818 /* and sleep if necessary */
819 port
->port_in_use
= 1;
820 port
->port_open_count
= 0;
822 /* wait for write buffer to drain, or */
823 /* at most GS_CLOSE_TIMEOUT seconds */
824 if (gs_buf_data_avail(port
->port_write_buf
) > 0) {
825 spin_unlock_irq(&port
->port_lock
);
826 wait_event_interruptible_timeout(port
->port_write_wait
,
827 GS_WRITE_FINISHED_EVENT_SAFELY(port
),
828 GS_CLOSE_TIMEOUT
* HZ
);
829 spin_lock_irq(&port
->port_lock
);
832 /* free disconnected port on final close */
833 /* (might have happened during the above sleep) */
834 if (port
->port_dev
== NULL
) {
839 gs_buf_clear(port
->port_write_buf
);
841 tty
->driver_data
= NULL
;
842 port
->port_tty
= NULL
;
843 port
->port_in_use
= 0;
845 gs_debug("gs_close: (%d,%p,%p) completed\n",
846 port
->port_num
, tty
, file
);
849 spin_unlock_irq(&port
->port_lock
);
856 static int gs_write(struct tty_struct
*tty
, const unsigned char *buf
, int count
)
859 struct gs_port
*port
= tty
->driver_data
;
863 printk(KERN_ERR
"gs_write: NULL port pointer\n");
867 gs_debug("gs_write: (%d,%p) writing %d bytes\n", port
->port_num
, tty
,
873 spin_lock_irqsave(&port
->port_lock
, flags
);
875 if (port
->port_dev
== NULL
) {
876 printk(KERN_ERR
"gs_write: (%d,%p) port is not connected\n",
877 port
->port_num
, tty
);
882 if (port
->port_open_count
== 0) {
883 printk(KERN_ERR
"gs_write: (%d,%p) port is closed\n",
884 port
->port_num
, tty
);
889 count
= gs_buf_put(port
->port_write_buf
, buf
, count
);
891 spin_unlock_irqrestore(&port
->port_lock
, flags
);
895 gs_debug("gs_write: (%d,%p) wrote %d bytes\n", port
->port_num
, tty
,
901 spin_unlock_irqrestore(&port
->port_lock
, flags
);
908 static void gs_put_char(struct tty_struct
*tty
, unsigned char ch
)
911 struct gs_port
*port
= tty
->driver_data
;
914 printk(KERN_ERR
"gs_put_char: NULL port pointer\n");
918 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));
920 spin_lock_irqsave(&port
->port_lock
, flags
);
922 if (port
->port_dev
== NULL
) {
923 printk(KERN_ERR
"gs_put_char: (%d,%p) port is not connected\n",
924 port
->port_num
, tty
);
928 if (port
->port_open_count
== 0) {
929 printk(KERN_ERR
"gs_put_char: (%d,%p) port is closed\n",
930 port
->port_num
, tty
);
934 gs_buf_put(port
->port_write_buf
, &ch
, 1);
937 spin_unlock_irqrestore(&port
->port_lock
, flags
);
943 static void gs_flush_chars(struct tty_struct
*tty
)
946 struct gs_port
*port
= tty
->driver_data
;
949 printk(KERN_ERR
"gs_flush_chars: NULL port pointer\n");
953 gs_debug("gs_flush_chars: (%d,%p)\n", port
->port_num
, tty
);
955 spin_lock_irqsave(&port
->port_lock
, flags
);
957 if (port
->port_dev
== NULL
) {
959 "gs_flush_chars: (%d,%p) port is not connected\n",
960 port
->port_num
, tty
);
964 if (port
->port_open_count
== 0) {
965 printk(KERN_ERR
"gs_flush_chars: (%d,%p) port is closed\n",
966 port
->port_num
, tty
);
970 spin_unlock_irqrestore(&port
->port_lock
, flags
);
977 spin_unlock_irqrestore(&port
->port_lock
, flags
);
983 static int gs_write_room(struct tty_struct
*tty
)
988 struct gs_port
*port
= tty
->driver_data
;
994 spin_lock_irqsave(&port
->port_lock
, flags
);
996 if (port
->port_dev
!= NULL
&& port
->port_open_count
> 0
997 && port
->port_write_buf
!= NULL
)
998 room
= gs_buf_space_avail(port
->port_write_buf
);
1000 spin_unlock_irqrestore(&port
->port_lock
, flags
);
1002 gs_debug("gs_write_room: (%d,%p) room=%d\n",
1003 port
->port_num
, tty
, room
);
1009 * gs_chars_in_buffer
1011 static int gs_chars_in_buffer(struct tty_struct
*tty
)
1014 unsigned long flags
;
1015 struct gs_port
*port
= tty
->driver_data
;
1020 spin_lock_irqsave(&port
->port_lock
, flags
);
1022 if (port
->port_dev
!= NULL
&& port
->port_open_count
> 0
1023 && port
->port_write_buf
!= NULL
)
1024 chars
= gs_buf_data_avail(port
->port_write_buf
);
1026 spin_unlock_irqrestore(&port
->port_lock
, flags
);
1028 gs_debug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
1029 port
->port_num
, tty
, chars
);
1037 static void gs_throttle(struct tty_struct
*tty
)
1044 static void gs_unthrottle(struct tty_struct
*tty
)
1051 static void gs_break(struct tty_struct
*tty
, int break_state
)
1058 static int gs_ioctl(struct tty_struct
*tty
, struct file
*file
, unsigned int cmd
, unsigned long arg
)
1060 struct gs_port
*port
= tty
->driver_data
;
1063 printk(KERN_ERR
"gs_ioctl: NULL port pointer\n");
1067 gs_debug("gs_ioctl: (%d,%p,%p) cmd=0x%4.4x, arg=%lu\n",
1068 port
->port_num
, tty
, file
, cmd
, arg
);
1072 /* could not handle ioctl */
1073 return -ENOIOCTLCMD
;
1079 static void gs_set_termios(struct tty_struct
*tty
, struct ktermios
*old
)
1086 * This function finds available write requests, calls
1087 * gs_send_packet to fill these packets with data, and
1088 * continues until either there are no more write requests
1089 * available or no more data to send. This function is
1090 * run whenever data arrives or write requests are available.
1092 static int gs_send(struct gs_dev
*dev
)
1095 unsigned long flags
;
1097 struct usb_request
*req
;
1098 struct gs_req_entry
*req_entry
;
1101 printk(KERN_ERR
"gs_send: NULL device pointer\n");
1105 spin_lock_irqsave(&dev
->dev_lock
, flags
);
1107 ep
= dev
->dev_in_ep
;
1109 while(!list_empty(&dev
->dev_req_list
)) {
1111 req_entry
= list_entry(dev
->dev_req_list
.next
,
1112 struct gs_req_entry
, re_entry
);
1114 req
= req_entry
->re_req
;
1116 len
= gs_send_packet(dev
, req
->buf
, ep
->maxpacket
);
1119 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));
1120 list_del(&req_entry
->re_entry
);
1122 spin_unlock_irqrestore(&dev
->dev_lock
, flags
);
1123 if ((ret
=usb_ep_queue(ep
, req
, GFP_ATOMIC
))) {
1125 "gs_send: cannot queue read request, ret=%d\n",
1127 spin_lock_irqsave(&dev
->dev_lock
, flags
);
1130 spin_lock_irqsave(&dev
->dev_lock
, flags
);
1137 spin_unlock_irqrestore(&dev
->dev_lock
, flags
);
1145 * If there is data to send, a packet is built in the given
1146 * buffer and the size is returned. If there is no data to
1147 * send, 0 is returned. If there is any error a negative
1148 * error number is returned.
1150 * Called during USB completion routine, on interrupt time.
1152 * We assume that disconnect will not happen until all completion
1153 * routines have completed, so we can assume that the dev_port
1154 * array does not change during the lifetime of this function.
1156 static int gs_send_packet(struct gs_dev
*dev
, char *packet
, unsigned int size
)
1159 struct gs_port
*port
;
1161 /* TEMPORARY -- only port 0 is supported right now */
1162 port
= dev
->dev_port
[0];
1166 "gs_send_packet: port=%d, NULL port pointer\n",
1171 spin_lock(&port
->port_lock
);
1173 len
= gs_buf_data_avail(port
->port_write_buf
);
1180 size
= gs_buf_get(port
->port_write_buf
, packet
, size
);
1183 wake_up_interruptible(&port
->port_tty
->write_wait
);
1186 spin_unlock(&port
->port_lock
);
1193 * Called for each USB packet received. Reads the packet
1194 * header and stuffs the data in the appropriate tty buffer.
1195 * Returns 0 if successful, or a negative error number.
1197 * Called during USB completion routine, on interrupt time.
1199 * We assume that disconnect will not happen until all completion
1200 * routines have completed, so we can assume that the dev_port
1201 * array does not change during the lifetime of this function.
1203 static int gs_recv_packet(struct gs_dev
*dev
, char *packet
, unsigned int size
)
1206 struct gs_port
*port
;
1208 struct tty_struct
*tty
;
1210 /* TEMPORARY -- only port 0 is supported right now */
1211 port
= dev
->dev_port
[0];
1214 printk(KERN_ERR
"gs_recv_packet: port=%d, NULL port pointer\n",
1219 spin_lock(&port
->port_lock
);
1221 if (port
->port_open_count
== 0) {
1222 printk(KERN_ERR
"gs_recv_packet: port=%d, port is closed\n",
1229 tty
= port
->port_tty
;
1232 printk(KERN_ERR
"gs_recv_packet: port=%d, NULL tty pointer\n",
1238 if (port
->port_tty
->magic
!= TTY_MAGIC
) {
1239 printk(KERN_ERR
"gs_recv_packet: port=%d, bad tty magic\n",
1245 len
= tty_buffer_request_room(tty
, size
);
1247 tty_insert_flip_string(tty
, packet
, len
);
1248 tty_flip_buffer_push(port
->port_tty
);
1249 wake_up_interruptible(&port
->port_tty
->read_wait
);
1253 spin_unlock(&port
->port_lock
);
1260 static void gs_read_complete(struct usb_ep
*ep
, struct usb_request
*req
)
1263 struct gs_dev
*dev
= ep
->driver_data
;
1266 printk(KERN_ERR
"gs_read_complete: NULL device pointer\n");
1270 switch(req
->status
) {
1272 /* normal completion */
1273 gs_recv_packet(dev
, req
->buf
, req
->actual
);
1275 req
->length
= ep
->maxpacket
;
1276 if ((ret
=usb_ep_queue(ep
, req
, GFP_ATOMIC
))) {
1278 "gs_read_complete: cannot queue read request, ret=%d\n",
1285 gs_debug("gs_read_complete: shutdown\n");
1286 gs_free_req(ep
, req
);
1292 "gs_read_complete: unexpected status error, status=%d\n",
1302 static void gs_write_complete(struct usb_ep
*ep
, struct usb_request
*req
)
1304 struct gs_dev
*dev
= ep
->driver_data
;
1305 struct gs_req_entry
*gs_req
= req
->context
;
1308 printk(KERN_ERR
"gs_write_complete: NULL device pointer\n");
1312 switch(req
->status
) {
1314 /* normal completion */
1316 if (gs_req
== NULL
) {
1318 "gs_write_complete: NULL request pointer\n");
1322 spin_lock(&dev
->dev_lock
);
1323 list_add(&gs_req
->re_entry
, &dev
->dev_req_list
);
1324 spin_unlock(&dev
->dev_lock
);
1332 gs_debug("gs_write_complete: shutdown\n");
1333 gs_free_req(ep
, req
);
1338 "gs_write_complete: unexpected status error, status=%d\n",
1350 * Called on module load. Allocates and initializes the device
1351 * structure and a control request.
1353 static int __init
gs_bind(struct usb_gadget
*gadget
)
1360 /* Some controllers can't support CDC ACM:
1361 * - sh doesn't support multiple interfaces or configs;
1362 * - sa1100 doesn't have a third interrupt endpoint
1364 if (gadget_is_sh(gadget
) || gadget_is_sa1100(gadget
))
1367 gcnum
= usb_gadget_controller_number(gadget
);
1369 gs_device_desc
.bcdDevice
=
1370 cpu_to_le16(GS_VERSION_NUM
| gcnum
);
1372 printk(KERN_WARNING
"gs_bind: controller '%s' not recognized\n",
1374 /* unrecognized, but safe unless bulk is REALLY quirky */
1375 gs_device_desc
.bcdDevice
=
1376 __constant_cpu_to_le16(GS_VERSION_NUM
|0x0099);
1379 usb_ep_autoconfig_reset(gadget
);
1381 ep
= usb_ep_autoconfig(gadget
, &gs_fullspeed_in_desc
);
1384 EP_IN_NAME
= ep
->name
;
1385 ep
->driver_data
= ep
; /* claim the endpoint */
1387 ep
= usb_ep_autoconfig(gadget
, &gs_fullspeed_out_desc
);
1390 EP_OUT_NAME
= ep
->name
;
1391 ep
->driver_data
= ep
; /* claim the endpoint */
1394 ep
= usb_ep_autoconfig(gadget
, &gs_fullspeed_notify_desc
);
1396 printk(KERN_ERR
"gs_bind: cannot run ACM on %s\n", gadget
->name
);
1399 gs_device_desc
.idProduct
= __constant_cpu_to_le16(
1401 EP_NOTIFY_NAME
= ep
->name
;
1402 ep
->driver_data
= ep
; /* claim the endpoint */
1405 gs_device_desc
.bDeviceClass
= use_acm
1406 ? USB_CLASS_COMM
: USB_CLASS_VENDOR_SPEC
;
1407 gs_device_desc
.bMaxPacketSize0
= gadget
->ep0
->maxpacket
;
1409 #ifdef CONFIG_USB_GADGET_DUALSPEED
1410 gs_qualifier_desc
.bDeviceClass
= use_acm
1411 ? USB_CLASS_COMM
: USB_CLASS_VENDOR_SPEC
;
1412 /* assume ep0 uses the same packet size for both speeds */
1413 gs_qualifier_desc
.bMaxPacketSize0
= gs_device_desc
.bMaxPacketSize0
;
1414 /* assume endpoints are dual-speed */
1415 gs_highspeed_notify_desc
.bEndpointAddress
=
1416 gs_fullspeed_notify_desc
.bEndpointAddress
;
1417 gs_highspeed_in_desc
.bEndpointAddress
=
1418 gs_fullspeed_in_desc
.bEndpointAddress
;
1419 gs_highspeed_out_desc
.bEndpointAddress
=
1420 gs_fullspeed_out_desc
.bEndpointAddress
;
1421 #endif /* CONFIG_USB_GADGET_DUALSPEED */
1423 usb_gadget_set_selfpowered(gadget
);
1425 if (gadget
->is_otg
) {
1426 gs_otg_descriptor
.bmAttributes
|= USB_OTG_HNP
,
1427 gs_bulk_config_desc
.bmAttributes
|= USB_CONFIG_ATT_WAKEUP
;
1428 gs_acm_config_desc
.bmAttributes
|= USB_CONFIG_ATT_WAKEUP
;
1431 gs_device
= dev
= kzalloc(sizeof(struct gs_dev
), GFP_KERNEL
);
1435 snprintf(manufacturer
, sizeof(manufacturer
), "%s %s with %s",
1436 init_utsname()->sysname
, init_utsname()->release
,
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
:
1694 /* FIXME Submit req to read the data; have its completion
1695 * handler copy that data to port->port_line_coding (iff
1696 * it's valid) and maybe pass it on. Until then, fail.
1698 printk(KERN_WARNING
"gs_setup: set_line_coding "
1702 case USB_CDC_REQ_GET_LINE_CODING
:
1703 port
= dev
->dev_port
[0]; /* ACM only has one port */
1705 (u16
)sizeof(struct usb_cdc_line_coding
));
1707 spin_lock(&port
->port_lock
);
1708 memcpy(req
->buf
, &port
->port_line_coding
, ret
);
1709 spin_unlock(&port
->port_lock
);
1713 case USB_CDC_REQ_SET_CONTROL_LINE_STATE
:
1714 /* FIXME Submit req to read the data; have its completion
1715 * handler use that to set the state (iff it's valid) and
1716 * maybe pass it on. Until then, fail.
1718 printk(KERN_WARNING
"gs_setup: set_control_line_state "
1723 printk(KERN_ERR
"gs_setup: unknown class request, "
1724 "type=%02x, request=%02x, value=%04x, "
1725 "index=%04x, length=%d\n",
1726 ctrl
->bRequestType
, ctrl
->bRequest
,
1727 wValue
, wIndex
, wLength
);
1737 static void gs_setup_complete(struct usb_ep
*ep
, struct usb_request
*req
)
1739 if (req
->status
|| req
->actual
!= req
->length
) {
1740 printk(KERN_ERR
"gs_setup_complete: status error, status=%d, actual=%d, length=%d\n",
1741 req
->status
, req
->actual
, req
->length
);
1748 * Called when the device is disconnected. Frees the closed
1749 * ports and disconnects open ports. Open ports will be freed
1750 * on close. Then reallocates the ports for the next connection.
1752 static void gs_disconnect(struct usb_gadget
*gadget
)
1754 unsigned long flags
;
1755 struct gs_dev
*dev
= get_gadget_data(gadget
);
1757 spin_lock_irqsave(&dev
->dev_lock
, flags
);
1759 gs_reset_config(dev
);
1761 /* free closed ports and disconnect open ports */
1762 /* (open ports will be freed when closed) */
1765 /* re-allocate ports for the next connection */
1766 if (gs_alloc_ports(dev
, GFP_ATOMIC
) != 0)
1767 printk(KERN_ERR
"gs_disconnect: cannot re-allocate ports\n");
1769 spin_unlock_irqrestore(&dev
->dev_lock
, flags
);
1771 printk(KERN_INFO
"gs_disconnect: %s disconnected\n", GS_LONG_NAME
);
1777 * Configures the device by enabling device specific
1778 * optimizations, setting up the endpoints, allocating
1779 * read and write requests and queuing read requests.
1781 * The device lock must be held when calling this function.
1783 static int gs_set_config(struct gs_dev
*dev
, unsigned config
)
1787 struct usb_gadget
*gadget
= dev
->dev_gadget
;
1789 struct usb_endpoint_descriptor
*ep_desc
;
1790 struct usb_request
*req
;
1791 struct gs_req_entry
*req_entry
;
1794 printk(KERN_ERR
"gs_set_config: NULL device pointer\n");
1798 if (config
== dev
->dev_config
)
1801 gs_reset_config(dev
);
1804 case GS_NO_CONFIG_ID
:
1806 case GS_BULK_CONFIG_ID
:
1809 /* device specific optimizations */
1810 if (gadget_is_net2280(gadget
))
1811 net2280_set_fifo_mode(gadget
, 1);
1813 case GS_ACM_CONFIG_ID
:
1816 /* device specific optimizations */
1817 if (gadget_is_net2280(gadget
))
1818 net2280_set_fifo_mode(gadget
, 1);
1824 dev
->dev_config
= config
;
1826 gadget_for_each_ep(ep
, gadget
) {
1829 && strcmp(ep
->name
, EP_NOTIFY_NAME
) == 0) {
1830 ep_desc
= GS_SPEED_SELECT(
1831 gadget
->speed
== USB_SPEED_HIGH
,
1832 &gs_highspeed_notify_desc
,
1833 &gs_fullspeed_notify_desc
);
1834 ret
= usb_ep_enable(ep
,ep_desc
);
1836 ep
->driver_data
= dev
;
1837 dev
->dev_notify_ep
= ep
;
1838 dev
->dev_notify_ep_desc
= ep_desc
;
1840 printk(KERN_ERR
"gs_set_config: cannot enable notify endpoint %s, ret=%d\n",
1842 goto exit_reset_config
;
1846 else if (strcmp(ep
->name
, EP_IN_NAME
) == 0) {
1847 ep_desc
= GS_SPEED_SELECT(
1848 gadget
->speed
== USB_SPEED_HIGH
,
1849 &gs_highspeed_in_desc
,
1850 &gs_fullspeed_in_desc
);
1851 ret
= usb_ep_enable(ep
,ep_desc
);
1853 ep
->driver_data
= dev
;
1854 dev
->dev_in_ep
= ep
;
1855 dev
->dev_in_ep_desc
= ep_desc
;
1857 printk(KERN_ERR
"gs_set_config: cannot enable in endpoint %s, ret=%d\n",
1859 goto exit_reset_config
;
1863 else if (strcmp(ep
->name
, EP_OUT_NAME
) == 0) {
1864 ep_desc
= GS_SPEED_SELECT(
1865 gadget
->speed
== USB_SPEED_HIGH
,
1866 &gs_highspeed_out_desc
,
1867 &gs_fullspeed_out_desc
);
1868 ret
= usb_ep_enable(ep
,ep_desc
);
1870 ep
->driver_data
= dev
;
1871 dev
->dev_out_ep
= ep
;
1872 dev
->dev_out_ep_desc
= ep_desc
;
1874 printk(KERN_ERR
"gs_set_config: cannot enable out endpoint %s, ret=%d\n",
1876 goto exit_reset_config
;
1882 if (dev
->dev_in_ep
== NULL
|| dev
->dev_out_ep
== NULL
1883 || (config
!= GS_BULK_CONFIG_ID
&& dev
->dev_notify_ep
== NULL
)) {
1884 printk(KERN_ERR
"gs_set_config: cannot find endpoints\n");
1886 goto exit_reset_config
;
1889 /* allocate and queue read requests */
1890 ep
= dev
->dev_out_ep
;
1891 for (i
=0; i
<read_q_size
&& ret
== 0; i
++) {
1892 if ((req
=gs_alloc_req(ep
, ep
->maxpacket
, GFP_ATOMIC
))) {
1893 req
->complete
= gs_read_complete
;
1894 if ((ret
=usb_ep_queue(ep
, req
, GFP_ATOMIC
))) {
1895 printk(KERN_ERR
"gs_set_config: cannot queue read request, ret=%d\n",
1899 printk(KERN_ERR
"gs_set_config: cannot allocate read requests\n");
1901 goto exit_reset_config
;
1905 /* allocate write requests, and put on free list */
1906 ep
= dev
->dev_in_ep
;
1907 for (i
=0; i
<write_q_size
; i
++) {
1908 if ((req_entry
=gs_alloc_req_entry(ep
, ep
->maxpacket
, GFP_ATOMIC
))) {
1909 req_entry
->re_req
->complete
= gs_write_complete
;
1910 list_add(&req_entry
->re_entry
, &dev
->dev_req_list
);
1912 printk(KERN_ERR
"gs_set_config: cannot allocate write requests\n");
1914 goto exit_reset_config
;
1918 printk(KERN_INFO
"gs_set_config: %s configured, %s speed %s config\n",
1920 gadget
->speed
== USB_SPEED_HIGH
? "high" : "full",
1921 config
== GS_BULK_CONFIG_ID
? "BULK" : "CDC-ACM");
1926 gs_reset_config(dev
);
1933 * Mark the device as not configured, disable all endpoints,
1934 * which forces completion of pending I/O and frees queued
1935 * requests, and free the remaining write requests on the
1938 * The device lock must be held when calling this function.
1940 static void gs_reset_config(struct gs_dev
*dev
)
1942 struct gs_req_entry
*req_entry
;
1945 printk(KERN_ERR
"gs_reset_config: NULL device pointer\n");
1949 if (dev
->dev_config
== GS_NO_CONFIG_ID
)
1952 dev
->dev_config
= GS_NO_CONFIG_ID
;
1954 /* free write requests on the free list */
1955 while(!list_empty(&dev
->dev_req_list
)) {
1956 req_entry
= list_entry(dev
->dev_req_list
.next
,
1957 struct gs_req_entry
, re_entry
);
1958 list_del(&req_entry
->re_entry
);
1959 gs_free_req_entry(dev
->dev_in_ep
, req_entry
);
1962 /* disable endpoints, forcing completion of pending i/o; */
1963 /* completion handlers free their requests in this case */
1964 if (dev
->dev_notify_ep
) {
1965 usb_ep_disable(dev
->dev_notify_ep
);
1966 dev
->dev_notify_ep
= NULL
;
1968 if (dev
->dev_in_ep
) {
1969 usb_ep_disable(dev
->dev_in_ep
);
1970 dev
->dev_in_ep
= NULL
;
1972 if (dev
->dev_out_ep
) {
1973 usb_ep_disable(dev
->dev_out_ep
);
1974 dev
->dev_out_ep
= NULL
;
1979 * gs_build_config_buf
1981 * Builds the config descriptors in the given buffer and returns the
1982 * length, or a negative error number.
1984 static int gs_build_config_buf(u8
*buf
, enum usb_device_speed speed
,
1985 u8 type
, unsigned int index
, int is_otg
)
1989 const struct usb_config_descriptor
*config_desc
;
1990 const struct usb_descriptor_header
**function
;
1992 if (index
>= gs_device_desc
.bNumConfigurations
)
1995 /* other speed switches high and full speed */
1996 high_speed
= (speed
== USB_SPEED_HIGH
);
1997 if (type
== USB_DT_OTHER_SPEED_CONFIG
)
1998 high_speed
= !high_speed
;
2001 config_desc
= &gs_acm_config_desc
;
2002 function
= GS_SPEED_SELECT(high_speed
,
2003 gs_acm_highspeed_function
,
2004 gs_acm_fullspeed_function
);
2006 config_desc
= &gs_bulk_config_desc
;
2007 function
= GS_SPEED_SELECT(high_speed
,
2008 gs_bulk_highspeed_function
,
2009 gs_bulk_fullspeed_function
);
2012 /* for now, don't advertise srp-only devices */
2016 len
= usb_gadget_config_buf(config_desc
, buf
, GS_MAX_DESC_LEN
, function
);
2020 ((struct usb_config_descriptor
*)buf
)->bDescriptorType
= type
;
2028 * Allocate a usb_request and its buffer. Returns a pointer to the
2029 * usb_request or NULL if there is an error.
2031 static struct usb_request
*
2032 gs_alloc_req(struct usb_ep
*ep
, unsigned int len
, gfp_t kmalloc_flags
)
2034 struct usb_request
*req
;
2039 req
= usb_ep_alloc_request(ep
, kmalloc_flags
);
2043 req
->buf
= kmalloc(len
, kmalloc_flags
);
2044 if (req
->buf
== NULL
) {
2045 usb_ep_free_request(ep
, req
);
2056 * Free a usb_request and its buffer.
2058 static void gs_free_req(struct usb_ep
*ep
, struct usb_request
*req
)
2060 if (ep
!= NULL
&& req
!= NULL
) {
2062 usb_ep_free_request(ep
, req
);
2067 * gs_alloc_req_entry
2069 * Allocates a request and its buffer, using the given
2070 * endpoint, buffer len, and kmalloc flags.
2072 static struct gs_req_entry
*
2073 gs_alloc_req_entry(struct usb_ep
*ep
, unsigned len
, gfp_t kmalloc_flags
)
2075 struct gs_req_entry
*req
;
2077 req
= kmalloc(sizeof(struct gs_req_entry
), kmalloc_flags
);
2081 req
->re_req
= gs_alloc_req(ep
, len
, kmalloc_flags
);
2082 if (req
->re_req
== NULL
) {
2087 req
->re_req
->context
= req
;
2095 * Frees a request and its buffer.
2097 static void gs_free_req_entry(struct usb_ep
*ep
, struct gs_req_entry
*req
)
2099 if (ep
!= NULL
&& req
!= NULL
) {
2100 if (req
->re_req
!= NULL
)
2101 gs_free_req(ep
, req
->re_req
);
2109 * Allocate all ports and set the gs_dev struct to point to them.
2110 * Return 0 if successful, or a negative error number.
2112 * The device lock is normally held when calling this function.
2114 static int gs_alloc_ports(struct gs_dev
*dev
, gfp_t kmalloc_flags
)
2117 struct gs_port
*port
;
2122 for (i
=0; i
<GS_NUM_PORTS
; i
++) {
2123 if ((port
=kzalloc(sizeof(struct gs_port
), kmalloc_flags
)) == NULL
)
2126 port
->port_dev
= dev
;
2128 port
->port_line_coding
.dwDTERate
= cpu_to_le32(GS_DEFAULT_DTE_RATE
);
2129 port
->port_line_coding
.bCharFormat
= GS_DEFAULT_CHAR_FORMAT
;
2130 port
->port_line_coding
.bParityType
= GS_DEFAULT_PARITY
;
2131 port
->port_line_coding
.bDataBits
= GS_DEFAULT_DATA_BITS
;
2132 spin_lock_init(&port
->port_lock
);
2133 init_waitqueue_head(&port
->port_write_wait
);
2135 dev
->dev_port
[i
] = port
;
2144 * Free all closed ports. Open ports are disconnected by
2145 * freeing their write buffers, setting their device pointers
2146 * and the pointers to them in the device to NULL. These
2147 * ports will be freed when closed.
2149 * The device lock is normally held when calling this function.
2151 static void gs_free_ports(struct gs_dev
*dev
)
2154 unsigned long flags
;
2155 struct gs_port
*port
;
2160 for (i
=0; i
<GS_NUM_PORTS
; i
++) {
2161 if ((port
=dev
->dev_port
[i
]) != NULL
) {
2162 dev
->dev_port
[i
] = NULL
;
2164 spin_lock_irqsave(&port
->port_lock
, flags
);
2166 if (port
->port_write_buf
!= NULL
) {
2167 gs_buf_free(port
->port_write_buf
);
2168 port
->port_write_buf
= NULL
;
2171 if (port
->port_open_count
> 0 || port
->port_in_use
) {
2172 port
->port_dev
= NULL
;
2173 wake_up_interruptible(&port
->port_write_wait
);
2174 if (port
->port_tty
) {
2175 wake_up_interruptible(&port
->port_tty
->read_wait
);
2176 wake_up_interruptible(&port
->port_tty
->write_wait
);
2178 spin_unlock_irqrestore(&port
->port_lock
, flags
);
2180 spin_unlock_irqrestore(&port
->port_lock
, flags
);
2188 /* Circular Buffer */
2193 * Allocate a circular buffer and all associated memory.
2195 static struct gs_buf
*gs_buf_alloc(unsigned int size
, gfp_t kmalloc_flags
)
2202 gb
= kmalloc(sizeof(struct gs_buf
), kmalloc_flags
);
2206 gb
->buf_buf
= kmalloc(size
, kmalloc_flags
);
2207 if (gb
->buf_buf
== NULL
) {
2212 gb
->buf_size
= size
;
2213 gb
->buf_get
= gb
->buf_put
= gb
->buf_buf
;
2221 * Free the buffer and all associated memory.
2223 static void gs_buf_free(struct gs_buf
*gb
)
2234 * Clear out all data in the circular buffer.
2236 static void gs_buf_clear(struct gs_buf
*gb
)
2239 gb
->buf_get
= gb
->buf_put
;
2240 /* equivalent to a get of all data available */
2246 * Return the number of bytes of data available in the circular
2249 static unsigned int gs_buf_data_avail(struct gs_buf
*gb
)
2252 return (gb
->buf_size
+ gb
->buf_put
- gb
->buf_get
) % gb
->buf_size
;
2258 * gs_buf_space_avail
2260 * Return the number of bytes of space available in the circular
2263 static unsigned int gs_buf_space_avail(struct gs_buf
*gb
)
2266 return (gb
->buf_size
+ gb
->buf_get
- gb
->buf_put
- 1) % gb
->buf_size
;
2274 * Copy data data from a user buffer and put it into the circular buffer.
2275 * Restrict to the amount of space available.
2277 * Return the number of bytes copied.
2280 gs_buf_put(struct gs_buf
*gb
, const char *buf
, unsigned int count
)
2287 len
= gs_buf_space_avail(gb
);
2294 len
= gb
->buf_buf
+ gb
->buf_size
- gb
->buf_put
;
2296 memcpy(gb
->buf_put
, buf
, len
);
2297 memcpy(gb
->buf_buf
, buf
+len
, count
- len
);
2298 gb
->buf_put
= gb
->buf_buf
+ count
- len
;
2300 memcpy(gb
->buf_put
, buf
, count
);
2302 gb
->buf_put
+= count
;
2303 else /* count == len */
2304 gb
->buf_put
= gb
->buf_buf
;
2313 * Get data from the circular buffer and copy to the given buffer.
2314 * Restrict to the amount of data available.
2316 * Return the number of bytes copied.
2319 gs_buf_get(struct gs_buf
*gb
, char *buf
, unsigned int count
)
2326 len
= gs_buf_data_avail(gb
);
2333 len
= gb
->buf_buf
+ gb
->buf_size
- gb
->buf_get
;
2335 memcpy(buf
, gb
->buf_get
, len
);
2336 memcpy(buf
+len
, gb
->buf_buf
, count
- len
);
2337 gb
->buf_get
= gb
->buf_buf
+ count
- len
;
2339 memcpy(buf
, gb
->buf_get
, count
);
2341 gb
->buf_get
+= count
;
2342 else /* count == len */
2343 gb
->buf_get
= gb
->buf_buf
;