V4L/DVB (6715): ivtv: Remove unnecessary register update
[linux-2.6/verdex.git] / drivers / usb / gadget / serial.c
blobf5738eb8e76522ae43c12c3c9a8b56f3732a2fe3
1 /*
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/kernel.h>
21 #include <linux/utsname.h>
22 #include <linux/device.h>
23 #include <linux/tty.h>
24 #include <linux/tty_flip.h>
26 #include <linux/usb/ch9.h>
27 #include <linux/usb/cdc.h>
28 #include <linux/usb/gadget.h>
30 #include "gadget_chips.h"
33 /* Defines */
35 #define GS_VERSION_STR "v2.2"
36 #define GS_VERSION_NUM 0x0202
38 #define GS_LONG_NAME "Gadget Serial"
39 #define GS_SHORT_NAME "g_serial"
41 #define GS_MAJOR 127
42 #define GS_MINOR_START 0
44 #define GS_NUM_PORTS 16
46 #define GS_NUM_CONFIGS 1
47 #define GS_NO_CONFIG_ID 0
48 #define GS_BULK_CONFIG_ID 1
49 #define GS_ACM_CONFIG_ID 2
51 #define GS_MAX_NUM_INTERFACES 2
52 #define GS_BULK_INTERFACE_ID 0
53 #define GS_CONTROL_INTERFACE_ID 0
54 #define GS_DATA_INTERFACE_ID 1
56 #define GS_MAX_DESC_LEN 256
58 #define GS_DEFAULT_READ_Q_SIZE 32
59 #define GS_DEFAULT_WRITE_Q_SIZE 32
61 #define GS_DEFAULT_WRITE_BUF_SIZE 8192
62 #define GS_TMP_BUF_SIZE 8192
64 #define GS_CLOSE_TIMEOUT 15
66 #define GS_DEFAULT_USE_ACM 0
68 #define GS_DEFAULT_DTE_RATE 9600
69 #define GS_DEFAULT_DATA_BITS 8
70 #define GS_DEFAULT_PARITY USB_CDC_NO_PARITY
71 #define GS_DEFAULT_CHAR_FORMAT USB_CDC_1_STOP_BITS
73 /* maxpacket and other transfer characteristics vary by speed. */
74 static inline struct usb_endpoint_descriptor *
75 choose_ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
76 struct usb_endpoint_descriptor *fs)
78 if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
79 return hs;
80 return fs;
84 /* debug settings */
85 #ifdef DEBUG
86 static int debug = 1;
87 #else
88 #define debug 0
89 #endif
91 #define gs_debug(format, arg...) \
92 do { if (debug) printk(KERN_DEBUG format, ## arg); } while(0)
93 #define gs_debug_level(level, format, arg...) \
94 do { if (debug>=level) printk(KERN_DEBUG format, ## arg); } while(0)
97 /* Thanks to NetChip Technologies for donating this product ID.
99 * DO NOT REUSE THESE IDs with a protocol-incompatible driver!! Ever!!
100 * Instead: allocate your own, using normal USB-IF procedures.
102 #define GS_VENDOR_ID 0x0525 /* NetChip */
103 #define GS_PRODUCT_ID 0xa4a6 /* Linux-USB Serial Gadget */
104 #define GS_CDC_PRODUCT_ID 0xa4a7 /* ... as CDC-ACM */
106 #define GS_LOG2_NOTIFY_INTERVAL 5 /* 1 << 5 == 32 msec */
107 #define GS_NOTIFY_MAXPACKET 8
110 /* Structures */
112 struct gs_dev;
114 /* circular buffer */
115 struct gs_buf {
116 unsigned int buf_size;
117 char *buf_buf;
118 char *buf_get;
119 char *buf_put;
122 /* list of requests */
123 struct gs_req_entry {
124 struct list_head re_entry;
125 struct usb_request *re_req;
128 /* the port structure holds info for each port, one for each minor number */
129 struct gs_port {
130 struct gs_dev *port_dev; /* pointer to device struct */
131 struct tty_struct *port_tty; /* pointer to tty struct */
132 spinlock_t port_lock;
133 int port_num;
134 int port_open_count;
135 int port_in_use; /* open/close in progress */
136 wait_queue_head_t port_write_wait;/* waiting to write */
137 struct gs_buf *port_write_buf;
138 struct usb_cdc_line_coding port_line_coding;
141 /* the device structure holds info for the USB device */
142 struct gs_dev {
143 struct usb_gadget *dev_gadget; /* gadget device pointer */
144 spinlock_t dev_lock; /* lock for set/reset config */
145 int dev_config; /* configuration number */
146 struct usb_ep *dev_notify_ep; /* address of notify endpoint */
147 struct usb_ep *dev_in_ep; /* address of in endpoint */
148 struct usb_ep *dev_out_ep; /* address of out endpoint */
149 struct usb_endpoint_descriptor /* descriptor of notify ep */
150 *dev_notify_ep_desc;
151 struct usb_endpoint_descriptor /* descriptor of in endpoint */
152 *dev_in_ep_desc;
153 struct usb_endpoint_descriptor /* descriptor of out endpoint */
154 *dev_out_ep_desc;
155 struct usb_request *dev_ctrl_req; /* control request */
156 struct list_head dev_req_list; /* list of write requests */
157 int dev_sched_port; /* round robin port scheduled */
158 struct gs_port *dev_port[GS_NUM_PORTS]; /* the ports */
162 /* Functions */
164 /* module */
165 static int __init gs_module_init(void);
166 static void __exit gs_module_exit(void);
168 /* tty driver */
169 static int gs_open(struct tty_struct *tty, struct file *file);
170 static void gs_close(struct tty_struct *tty, struct file *file);
171 static int gs_write(struct tty_struct *tty,
172 const unsigned char *buf, int count);
173 static void gs_put_char(struct tty_struct *tty, unsigned char ch);
174 static void gs_flush_chars(struct tty_struct *tty);
175 static int gs_write_room(struct tty_struct *tty);
176 static int gs_chars_in_buffer(struct tty_struct *tty);
177 static void gs_throttle(struct tty_struct * tty);
178 static void gs_unthrottle(struct tty_struct * tty);
179 static void gs_break(struct tty_struct *tty, int break_state);
180 static int gs_ioctl(struct tty_struct *tty, struct file *file,
181 unsigned int cmd, unsigned long arg);
182 static void gs_set_termios(struct tty_struct *tty, struct ktermios *old);
184 static int gs_send(struct gs_dev *dev);
185 static int gs_send_packet(struct gs_dev *dev, char *packet,
186 unsigned int size);
187 static int gs_recv_packet(struct gs_dev *dev, char *packet,
188 unsigned int size);
189 static void gs_read_complete(struct usb_ep *ep, struct usb_request *req);
190 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req);
192 /* gadget driver */
193 static int gs_bind(struct usb_gadget *gadget);
194 static void gs_unbind(struct usb_gadget *gadget);
195 static int gs_setup(struct usb_gadget *gadget,
196 const struct usb_ctrlrequest *ctrl);
197 static int gs_setup_standard(struct usb_gadget *gadget,
198 const struct usb_ctrlrequest *ctrl);
199 static int gs_setup_class(struct usb_gadget *gadget,
200 const struct usb_ctrlrequest *ctrl);
201 static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req);
202 static void gs_disconnect(struct usb_gadget *gadget);
203 static int gs_set_config(struct gs_dev *dev, unsigned config);
204 static void gs_reset_config(struct gs_dev *dev);
205 static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
206 u8 type, unsigned int index, int is_otg);
208 static struct usb_request *gs_alloc_req(struct usb_ep *ep, unsigned int len,
209 gfp_t kmalloc_flags);
210 static void gs_free_req(struct usb_ep *ep, struct usb_request *req);
212 static struct gs_req_entry *gs_alloc_req_entry(struct usb_ep *ep, unsigned len,
213 gfp_t kmalloc_flags);
214 static void gs_free_req_entry(struct usb_ep *ep, struct gs_req_entry *req);
216 static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags);
217 static void gs_free_ports(struct gs_dev *dev);
219 /* circular buffer */
220 static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags);
221 static void gs_buf_free(struct gs_buf *gb);
222 static void gs_buf_clear(struct gs_buf *gb);
223 static unsigned int gs_buf_data_avail(struct gs_buf *gb);
224 static unsigned int gs_buf_space_avail(struct gs_buf *gb);
225 static unsigned int gs_buf_put(struct gs_buf *gb, const char *buf,
226 unsigned int count);
227 static unsigned int gs_buf_get(struct gs_buf *gb, char *buf,
228 unsigned int count);
230 /* external functions */
231 extern int net2280_set_fifo_mode(struct usb_gadget *gadget, int mode);
234 /* Globals */
236 static struct gs_dev *gs_device;
238 static const char *EP_IN_NAME;
239 static const char *EP_OUT_NAME;
240 static const char *EP_NOTIFY_NAME;
242 static struct mutex gs_open_close_lock[GS_NUM_PORTS];
244 static unsigned int read_q_size = GS_DEFAULT_READ_Q_SIZE;
245 static unsigned int write_q_size = GS_DEFAULT_WRITE_Q_SIZE;
247 static unsigned int write_buf_size = GS_DEFAULT_WRITE_BUF_SIZE;
249 static unsigned int use_acm = GS_DEFAULT_USE_ACM;
252 /* tty driver struct */
253 static const struct tty_operations gs_tty_ops = {
254 .open = gs_open,
255 .close = gs_close,
256 .write = gs_write,
257 .put_char = gs_put_char,
258 .flush_chars = gs_flush_chars,
259 .write_room = gs_write_room,
260 .ioctl = gs_ioctl,
261 .set_termios = gs_set_termios,
262 .throttle = gs_throttle,
263 .unthrottle = gs_unthrottle,
264 .break_ctl = gs_break,
265 .chars_in_buffer = gs_chars_in_buffer,
267 static struct tty_driver *gs_tty_driver;
269 /* gadget driver struct */
270 static struct usb_gadget_driver gs_gadget_driver = {
271 #ifdef CONFIG_USB_GADGET_DUALSPEED
272 .speed = USB_SPEED_HIGH,
273 #else
274 .speed = USB_SPEED_FULL,
275 #endif /* CONFIG_USB_GADGET_DUALSPEED */
276 .function = GS_LONG_NAME,
277 .bind = gs_bind,
278 .unbind = gs_unbind,
279 .setup = gs_setup,
280 .disconnect = gs_disconnect,
281 .driver = {
282 .name = GS_SHORT_NAME,
287 /* USB descriptors */
289 #define GS_MANUFACTURER_STR_ID 1
290 #define GS_PRODUCT_STR_ID 2
291 #define GS_SERIAL_STR_ID 3
292 #define GS_BULK_CONFIG_STR_ID 4
293 #define GS_ACM_CONFIG_STR_ID 5
294 #define GS_CONTROL_STR_ID 6
295 #define GS_DATA_STR_ID 7
297 /* static strings, in UTF-8 */
298 static char manufacturer[50];
299 static struct usb_string gs_strings[] = {
300 { GS_MANUFACTURER_STR_ID, manufacturer },
301 { GS_PRODUCT_STR_ID, GS_LONG_NAME },
302 { GS_SERIAL_STR_ID, "0" },
303 { GS_BULK_CONFIG_STR_ID, "Gadget Serial Bulk" },
304 { GS_ACM_CONFIG_STR_ID, "Gadget Serial CDC ACM" },
305 { GS_CONTROL_STR_ID, "Gadget Serial Control" },
306 { GS_DATA_STR_ID, "Gadget Serial Data" },
307 { } /* end of list */
310 static struct usb_gadget_strings gs_string_table = {
311 .language = 0x0409, /* en-us */
312 .strings = gs_strings,
315 static struct usb_device_descriptor gs_device_desc = {
316 .bLength = USB_DT_DEVICE_SIZE,
317 .bDescriptorType = USB_DT_DEVICE,
318 .bcdUSB = __constant_cpu_to_le16(0x0200),
319 .bDeviceSubClass = 0,
320 .bDeviceProtocol = 0,
321 .idVendor = __constant_cpu_to_le16(GS_VENDOR_ID),
322 .idProduct = __constant_cpu_to_le16(GS_PRODUCT_ID),
323 .iManufacturer = GS_MANUFACTURER_STR_ID,
324 .iProduct = GS_PRODUCT_STR_ID,
325 .iSerialNumber = GS_SERIAL_STR_ID,
326 .bNumConfigurations = GS_NUM_CONFIGS,
329 static struct usb_otg_descriptor gs_otg_descriptor = {
330 .bLength = sizeof(gs_otg_descriptor),
331 .bDescriptorType = USB_DT_OTG,
332 .bmAttributes = USB_OTG_SRP,
335 static struct usb_config_descriptor gs_bulk_config_desc = {
336 .bLength = USB_DT_CONFIG_SIZE,
337 .bDescriptorType = USB_DT_CONFIG,
338 /* .wTotalLength computed dynamically */
339 .bNumInterfaces = 1,
340 .bConfigurationValue = GS_BULK_CONFIG_ID,
341 .iConfiguration = GS_BULK_CONFIG_STR_ID,
342 .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
343 .bMaxPower = 1,
346 static struct usb_config_descriptor gs_acm_config_desc = {
347 .bLength = USB_DT_CONFIG_SIZE,
348 .bDescriptorType = USB_DT_CONFIG,
349 /* .wTotalLength computed dynamically */
350 .bNumInterfaces = 2,
351 .bConfigurationValue = GS_ACM_CONFIG_ID,
352 .iConfiguration = GS_ACM_CONFIG_STR_ID,
353 .bmAttributes = USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
354 .bMaxPower = 1,
357 static const struct usb_interface_descriptor gs_bulk_interface_desc = {
358 .bLength = USB_DT_INTERFACE_SIZE,
359 .bDescriptorType = USB_DT_INTERFACE,
360 .bInterfaceNumber = GS_BULK_INTERFACE_ID,
361 .bNumEndpoints = 2,
362 .bInterfaceClass = USB_CLASS_CDC_DATA,
363 .bInterfaceSubClass = 0,
364 .bInterfaceProtocol = 0,
365 .iInterface = GS_DATA_STR_ID,
368 static const struct usb_interface_descriptor gs_control_interface_desc = {
369 .bLength = USB_DT_INTERFACE_SIZE,
370 .bDescriptorType = USB_DT_INTERFACE,
371 .bInterfaceNumber = GS_CONTROL_INTERFACE_ID,
372 .bNumEndpoints = 1,
373 .bInterfaceClass = USB_CLASS_COMM,
374 .bInterfaceSubClass = USB_CDC_SUBCLASS_ACM,
375 .bInterfaceProtocol = USB_CDC_ACM_PROTO_AT_V25TER,
376 .iInterface = GS_CONTROL_STR_ID,
379 static const struct usb_interface_descriptor gs_data_interface_desc = {
380 .bLength = USB_DT_INTERFACE_SIZE,
381 .bDescriptorType = USB_DT_INTERFACE,
382 .bInterfaceNumber = GS_DATA_INTERFACE_ID,
383 .bNumEndpoints = 2,
384 .bInterfaceClass = USB_CLASS_CDC_DATA,
385 .bInterfaceSubClass = 0,
386 .bInterfaceProtocol = 0,
387 .iInterface = GS_DATA_STR_ID,
390 static const struct usb_cdc_header_desc gs_header_desc = {
391 .bLength = sizeof(gs_header_desc),
392 .bDescriptorType = USB_DT_CS_INTERFACE,
393 .bDescriptorSubType = USB_CDC_HEADER_TYPE,
394 .bcdCDC = __constant_cpu_to_le16(0x0110),
397 static const struct usb_cdc_call_mgmt_descriptor gs_call_mgmt_descriptor = {
398 .bLength = sizeof(gs_call_mgmt_descriptor),
399 .bDescriptorType = USB_DT_CS_INTERFACE,
400 .bDescriptorSubType = USB_CDC_CALL_MANAGEMENT_TYPE,
401 .bmCapabilities = 0,
402 .bDataInterface = 1, /* index of data interface */
405 static struct usb_cdc_acm_descriptor gs_acm_descriptor = {
406 .bLength = sizeof(gs_acm_descriptor),
407 .bDescriptorType = USB_DT_CS_INTERFACE,
408 .bDescriptorSubType = USB_CDC_ACM_TYPE,
409 .bmCapabilities = 0,
412 static const struct usb_cdc_union_desc gs_union_desc = {
413 .bLength = sizeof(gs_union_desc),
414 .bDescriptorType = USB_DT_CS_INTERFACE,
415 .bDescriptorSubType = USB_CDC_UNION_TYPE,
416 .bMasterInterface0 = 0, /* index of control interface */
417 .bSlaveInterface0 = 1, /* index of data interface */
420 static struct usb_endpoint_descriptor gs_fullspeed_notify_desc = {
421 .bLength = USB_DT_ENDPOINT_SIZE,
422 .bDescriptorType = USB_DT_ENDPOINT,
423 .bEndpointAddress = USB_DIR_IN,
424 .bmAttributes = USB_ENDPOINT_XFER_INT,
425 .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
426 .bInterval = 1 << GS_LOG2_NOTIFY_INTERVAL,
429 static struct usb_endpoint_descriptor gs_fullspeed_in_desc = {
430 .bLength = USB_DT_ENDPOINT_SIZE,
431 .bDescriptorType = USB_DT_ENDPOINT,
432 .bEndpointAddress = USB_DIR_IN,
433 .bmAttributes = USB_ENDPOINT_XFER_BULK,
436 static struct usb_endpoint_descriptor gs_fullspeed_out_desc = {
437 .bLength = USB_DT_ENDPOINT_SIZE,
438 .bDescriptorType = USB_DT_ENDPOINT,
439 .bEndpointAddress = USB_DIR_OUT,
440 .bmAttributes = USB_ENDPOINT_XFER_BULK,
443 static const struct usb_descriptor_header *gs_bulk_fullspeed_function[] = {
444 (struct usb_descriptor_header *) &gs_otg_descriptor,
445 (struct usb_descriptor_header *) &gs_bulk_interface_desc,
446 (struct usb_descriptor_header *) &gs_fullspeed_in_desc,
447 (struct usb_descriptor_header *) &gs_fullspeed_out_desc,
448 NULL,
451 static const struct usb_descriptor_header *gs_acm_fullspeed_function[] = {
452 (struct usb_descriptor_header *) &gs_otg_descriptor,
453 (struct usb_descriptor_header *) &gs_control_interface_desc,
454 (struct usb_descriptor_header *) &gs_header_desc,
455 (struct usb_descriptor_header *) &gs_call_mgmt_descriptor,
456 (struct usb_descriptor_header *) &gs_acm_descriptor,
457 (struct usb_descriptor_header *) &gs_union_desc,
458 (struct usb_descriptor_header *) &gs_fullspeed_notify_desc,
459 (struct usb_descriptor_header *) &gs_data_interface_desc,
460 (struct usb_descriptor_header *) &gs_fullspeed_in_desc,
461 (struct usb_descriptor_header *) &gs_fullspeed_out_desc,
462 NULL,
465 static struct usb_endpoint_descriptor gs_highspeed_notify_desc = {
466 .bLength = USB_DT_ENDPOINT_SIZE,
467 .bDescriptorType = USB_DT_ENDPOINT,
468 .bEndpointAddress = USB_DIR_IN,
469 .bmAttributes = USB_ENDPOINT_XFER_INT,
470 .wMaxPacketSize = __constant_cpu_to_le16(GS_NOTIFY_MAXPACKET),
471 .bInterval = GS_LOG2_NOTIFY_INTERVAL+4,
474 static struct usb_endpoint_descriptor gs_highspeed_in_desc = {
475 .bLength = USB_DT_ENDPOINT_SIZE,
476 .bDescriptorType = USB_DT_ENDPOINT,
477 .bmAttributes = USB_ENDPOINT_XFER_BULK,
478 .wMaxPacketSize = __constant_cpu_to_le16(512),
481 static struct usb_endpoint_descriptor gs_highspeed_out_desc = {
482 .bLength = USB_DT_ENDPOINT_SIZE,
483 .bDescriptorType = USB_DT_ENDPOINT,
484 .bmAttributes = USB_ENDPOINT_XFER_BULK,
485 .wMaxPacketSize = __constant_cpu_to_le16(512),
488 static struct usb_qualifier_descriptor gs_qualifier_desc = {
489 .bLength = sizeof(struct usb_qualifier_descriptor),
490 .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
491 .bcdUSB = __constant_cpu_to_le16 (0x0200),
492 /* assumes ep0 uses the same value for both speeds ... */
493 .bNumConfigurations = GS_NUM_CONFIGS,
496 static const struct usb_descriptor_header *gs_bulk_highspeed_function[] = {
497 (struct usb_descriptor_header *) &gs_otg_descriptor,
498 (struct usb_descriptor_header *) &gs_bulk_interface_desc,
499 (struct usb_descriptor_header *) &gs_highspeed_in_desc,
500 (struct usb_descriptor_header *) &gs_highspeed_out_desc,
501 NULL,
504 static const struct usb_descriptor_header *gs_acm_highspeed_function[] = {
505 (struct usb_descriptor_header *) &gs_otg_descriptor,
506 (struct usb_descriptor_header *) &gs_control_interface_desc,
507 (struct usb_descriptor_header *) &gs_header_desc,
508 (struct usb_descriptor_header *) &gs_call_mgmt_descriptor,
509 (struct usb_descriptor_header *) &gs_acm_descriptor,
510 (struct usb_descriptor_header *) &gs_union_desc,
511 (struct usb_descriptor_header *) &gs_highspeed_notify_desc,
512 (struct usb_descriptor_header *) &gs_data_interface_desc,
513 (struct usb_descriptor_header *) &gs_highspeed_in_desc,
514 (struct usb_descriptor_header *) &gs_highspeed_out_desc,
515 NULL,
519 /* Module */
520 MODULE_DESCRIPTION(GS_LONG_NAME);
521 MODULE_AUTHOR("Al Borchers");
522 MODULE_LICENSE("GPL");
524 #ifdef DEBUG
525 module_param(debug, int, S_IRUGO|S_IWUSR);
526 MODULE_PARM_DESC(debug, "Enable debugging, 0=off, 1=on");
527 #endif
529 module_param(read_q_size, uint, S_IRUGO);
530 MODULE_PARM_DESC(read_q_size, "Read request queue size, default=32");
532 module_param(write_q_size, uint, S_IRUGO);
533 MODULE_PARM_DESC(write_q_size, "Write request queue size, default=32");
535 module_param(write_buf_size, uint, S_IRUGO);
536 MODULE_PARM_DESC(write_buf_size, "Write buffer size, default=8192");
538 module_param(use_acm, uint, S_IRUGO);
539 MODULE_PARM_DESC(use_acm, "Use CDC ACM, 0=no, 1=yes, default=no");
541 module_init(gs_module_init);
542 module_exit(gs_module_exit);
545 * gs_module_init
547 * Register as a USB gadget driver and a tty driver.
549 static int __init gs_module_init(void)
551 int i;
552 int retval;
554 retval = usb_gadget_register_driver(&gs_gadget_driver);
555 if (retval) {
556 printk(KERN_ERR "gs_module_init: cannot register gadget driver, ret=%d\n", retval);
557 return retval;
560 gs_tty_driver = alloc_tty_driver(GS_NUM_PORTS);
561 if (!gs_tty_driver)
562 return -ENOMEM;
563 gs_tty_driver->owner = THIS_MODULE;
564 gs_tty_driver->driver_name = GS_SHORT_NAME;
565 gs_tty_driver->name = "ttygs";
566 gs_tty_driver->major = GS_MAJOR;
567 gs_tty_driver->minor_start = GS_MINOR_START;
568 gs_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
569 gs_tty_driver->subtype = SERIAL_TYPE_NORMAL;
570 gs_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
571 gs_tty_driver->init_termios = tty_std_termios;
572 gs_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
573 tty_set_operations(gs_tty_driver, &gs_tty_ops);
575 for (i=0; i < GS_NUM_PORTS; i++)
576 mutex_init(&gs_open_close_lock[i]);
578 retval = tty_register_driver(gs_tty_driver);
579 if (retval) {
580 usb_gadget_unregister_driver(&gs_gadget_driver);
581 put_tty_driver(gs_tty_driver);
582 printk(KERN_ERR "gs_module_init: cannot register tty driver, ret=%d\n", retval);
583 return retval;
586 printk(KERN_INFO "gs_module_init: %s %s loaded\n", GS_LONG_NAME, GS_VERSION_STR);
587 return 0;
591 * gs_module_exit
593 * Unregister as a tty driver and a USB gadget driver.
595 static void __exit gs_module_exit(void)
597 tty_unregister_driver(gs_tty_driver);
598 put_tty_driver(gs_tty_driver);
599 usb_gadget_unregister_driver(&gs_gadget_driver);
601 printk(KERN_INFO "gs_module_exit: %s %s unloaded\n", GS_LONG_NAME, GS_VERSION_STR);
604 /* TTY Driver */
607 * gs_open
609 static int gs_open(struct tty_struct *tty, struct file *file)
611 int port_num;
612 unsigned long flags;
613 struct gs_port *port;
614 struct gs_dev *dev;
615 struct gs_buf *buf;
616 struct mutex *mtx;
617 int ret;
619 port_num = tty->index;
621 gs_debug("gs_open: (%d,%p,%p)\n", port_num, tty, file);
623 if (port_num < 0 || port_num >= GS_NUM_PORTS) {
624 printk(KERN_ERR "gs_open: (%d,%p,%p) invalid port number\n",
625 port_num, tty, file);
626 return -ENODEV;
629 dev = gs_device;
631 if (dev == NULL) {
632 printk(KERN_ERR "gs_open: (%d,%p,%p) NULL device pointer\n",
633 port_num, tty, file);
634 return -ENODEV;
637 mtx = &gs_open_close_lock[port_num];
638 if (mutex_lock_interruptible(mtx)) {
639 printk(KERN_ERR
640 "gs_open: (%d,%p,%p) interrupted waiting for mutex\n",
641 port_num, tty, file);
642 return -ERESTARTSYS;
645 spin_lock_irqsave(&dev->dev_lock, flags);
647 if (dev->dev_config == GS_NO_CONFIG_ID) {
648 printk(KERN_ERR
649 "gs_open: (%d,%p,%p) device is not connected\n",
650 port_num, tty, file);
651 ret = -ENODEV;
652 goto exit_unlock_dev;
655 port = dev->dev_port[port_num];
657 if (port == NULL) {
658 printk(KERN_ERR "gs_open: (%d,%p,%p) NULL port pointer\n",
659 port_num, tty, file);
660 ret = -ENODEV;
661 goto exit_unlock_dev;
664 spin_lock(&port->port_lock);
665 spin_unlock(&dev->dev_lock);
667 if (port->port_dev == NULL) {
668 printk(KERN_ERR "gs_open: (%d,%p,%p) port disconnected (1)\n",
669 port_num, tty, file);
670 ret = -EIO;
671 goto exit_unlock_port;
674 if (port->port_open_count > 0) {
675 ++port->port_open_count;
676 gs_debug("gs_open: (%d,%p,%p) already open\n",
677 port_num, tty, file);
678 ret = 0;
679 goto exit_unlock_port;
682 tty->driver_data = NULL;
684 /* mark port as in use, we can drop port lock and sleep if necessary */
685 port->port_in_use = 1;
687 /* allocate write buffer on first open */
688 if (port->port_write_buf == NULL) {
689 spin_unlock_irqrestore(&port->port_lock, flags);
690 buf = gs_buf_alloc(write_buf_size, GFP_KERNEL);
691 spin_lock_irqsave(&port->port_lock, flags);
693 /* might have been disconnected while asleep, check */
694 if (port->port_dev == NULL) {
695 printk(KERN_ERR
696 "gs_open: (%d,%p,%p) port disconnected (2)\n",
697 port_num, tty, file);
698 port->port_in_use = 0;
699 ret = -EIO;
700 goto exit_unlock_port;
703 if ((port->port_write_buf=buf) == NULL) {
704 printk(KERN_ERR "gs_open: (%d,%p,%p) cannot allocate port write buffer\n",
705 port_num, tty, file);
706 port->port_in_use = 0;
707 ret = -ENOMEM;
708 goto exit_unlock_port;
713 /* wait for carrier detect (not implemented) */
715 /* might have been disconnected while asleep, check */
716 if (port->port_dev == NULL) {
717 printk(KERN_ERR "gs_open: (%d,%p,%p) port disconnected (3)\n",
718 port_num, tty, file);
719 port->port_in_use = 0;
720 ret = -EIO;
721 goto exit_unlock_port;
724 tty->driver_data = port;
725 port->port_tty = tty;
726 port->port_open_count = 1;
727 port->port_in_use = 0;
729 gs_debug("gs_open: (%d,%p,%p) completed\n", port_num, tty, file);
731 ret = 0;
733 exit_unlock_port:
734 spin_unlock_irqrestore(&port->port_lock, flags);
735 mutex_unlock(mtx);
736 return ret;
738 exit_unlock_dev:
739 spin_unlock_irqrestore(&dev->dev_lock, flags);
740 mutex_unlock(mtx);
741 return ret;
746 * gs_close
749 #define GS_WRITE_FINISHED_EVENT_SAFELY(p) \
750 ({ \
751 int cond; \
753 spin_lock_irq(&(p)->port_lock); \
754 cond = !(p)->port_dev || !gs_buf_data_avail((p)->port_write_buf); \
755 spin_unlock_irq(&(p)->port_lock); \
756 cond; \
759 static void gs_close(struct tty_struct *tty, struct file *file)
761 struct gs_port *port = tty->driver_data;
762 struct mutex *mtx;
764 if (port == NULL) {
765 printk(KERN_ERR "gs_close: NULL port pointer\n");
766 return;
769 gs_debug("gs_close: (%d,%p,%p)\n", port->port_num, tty, file);
771 mtx = &gs_open_close_lock[port->port_num];
772 mutex_lock(mtx);
774 spin_lock_irq(&port->port_lock);
776 if (port->port_open_count == 0) {
777 printk(KERN_ERR
778 "gs_close: (%d,%p,%p) port is already closed\n",
779 port->port_num, tty, file);
780 goto exit;
783 if (port->port_open_count > 1) {
784 --port->port_open_count;
785 goto exit;
788 /* free disconnected port on final close */
789 if (port->port_dev == NULL) {
790 kfree(port);
791 goto exit;
794 /* mark port as closed but in use, we can drop port lock */
795 /* and sleep if necessary */
796 port->port_in_use = 1;
797 port->port_open_count = 0;
799 /* wait for write buffer to drain, or */
800 /* at most GS_CLOSE_TIMEOUT seconds */
801 if (gs_buf_data_avail(port->port_write_buf) > 0) {
802 spin_unlock_irq(&port->port_lock);
803 wait_event_interruptible_timeout(port->port_write_wait,
804 GS_WRITE_FINISHED_EVENT_SAFELY(port),
805 GS_CLOSE_TIMEOUT * HZ);
806 spin_lock_irq(&port->port_lock);
809 /* free disconnected port on final close */
810 /* (might have happened during the above sleep) */
811 if (port->port_dev == NULL) {
812 kfree(port);
813 goto exit;
816 gs_buf_clear(port->port_write_buf);
818 tty->driver_data = NULL;
819 port->port_tty = NULL;
820 port->port_in_use = 0;
822 gs_debug("gs_close: (%d,%p,%p) completed\n",
823 port->port_num, tty, file);
825 exit:
826 spin_unlock_irq(&port->port_lock);
827 mutex_unlock(mtx);
831 * gs_write
833 static int gs_write(struct tty_struct *tty, const unsigned char *buf, int count)
835 unsigned long flags;
836 struct gs_port *port = tty->driver_data;
837 int ret;
839 if (port == NULL) {
840 printk(KERN_ERR "gs_write: NULL port pointer\n");
841 return -EIO;
844 gs_debug("gs_write: (%d,%p) writing %d bytes\n", port->port_num, tty,
845 count);
847 if (count == 0)
848 return 0;
850 spin_lock_irqsave(&port->port_lock, flags);
852 if (port->port_dev == NULL) {
853 printk(KERN_ERR "gs_write: (%d,%p) port is not connected\n",
854 port->port_num, tty);
855 ret = -EIO;
856 goto exit;
859 if (port->port_open_count == 0) {
860 printk(KERN_ERR "gs_write: (%d,%p) port is closed\n",
861 port->port_num, tty);
862 ret = -EBADF;
863 goto exit;
866 count = gs_buf_put(port->port_write_buf, buf, count);
868 spin_unlock_irqrestore(&port->port_lock, flags);
870 gs_send(gs_device);
872 gs_debug("gs_write: (%d,%p) wrote %d bytes\n", port->port_num, tty,
873 count);
875 return count;
877 exit:
878 spin_unlock_irqrestore(&port->port_lock, flags);
879 return ret;
883 * gs_put_char
885 static void gs_put_char(struct tty_struct *tty, unsigned char ch)
887 unsigned long flags;
888 struct gs_port *port = tty->driver_data;
890 if (port == NULL) {
891 printk(KERN_ERR "gs_put_char: NULL port pointer\n");
892 return;
895 gs_debug("gs_put_char: (%d,%p) char=0x%x, called from %p\n",
896 port->port_num, tty, ch, __builtin_return_address(0));
898 spin_lock_irqsave(&port->port_lock, flags);
900 if (port->port_dev == NULL) {
901 printk(KERN_ERR "gs_put_char: (%d,%p) port is not connected\n",
902 port->port_num, tty);
903 goto exit;
906 if (port->port_open_count == 0) {
907 printk(KERN_ERR "gs_put_char: (%d,%p) port is closed\n",
908 port->port_num, tty);
909 goto exit;
912 gs_buf_put(port->port_write_buf, &ch, 1);
914 exit:
915 spin_unlock_irqrestore(&port->port_lock, flags);
919 * gs_flush_chars
921 static void gs_flush_chars(struct tty_struct *tty)
923 unsigned long flags;
924 struct gs_port *port = tty->driver_data;
926 if (port == NULL) {
927 printk(KERN_ERR "gs_flush_chars: NULL port pointer\n");
928 return;
931 gs_debug("gs_flush_chars: (%d,%p)\n", port->port_num, tty);
933 spin_lock_irqsave(&port->port_lock, flags);
935 if (port->port_dev == NULL) {
936 printk(KERN_ERR
937 "gs_flush_chars: (%d,%p) port is not connected\n",
938 port->port_num, tty);
939 goto exit;
942 if (port->port_open_count == 0) {
943 printk(KERN_ERR "gs_flush_chars: (%d,%p) port is closed\n",
944 port->port_num, tty);
945 goto exit;
948 spin_unlock_irqrestore(&port->port_lock, flags);
950 gs_send(gs_device);
952 return;
954 exit:
955 spin_unlock_irqrestore(&port->port_lock, flags);
959 * gs_write_room
961 static int gs_write_room(struct tty_struct *tty)
964 int room = 0;
965 unsigned long flags;
966 struct gs_port *port = tty->driver_data;
969 if (port == NULL)
970 return 0;
972 spin_lock_irqsave(&port->port_lock, flags);
974 if (port->port_dev != NULL && port->port_open_count > 0
975 && port->port_write_buf != NULL)
976 room = gs_buf_space_avail(port->port_write_buf);
978 spin_unlock_irqrestore(&port->port_lock, flags);
980 gs_debug("gs_write_room: (%d,%p) room=%d\n",
981 port->port_num, tty, room);
983 return room;
987 * gs_chars_in_buffer
989 static int gs_chars_in_buffer(struct tty_struct *tty)
991 int chars = 0;
992 unsigned long flags;
993 struct gs_port *port = tty->driver_data;
995 if (port == NULL)
996 return 0;
998 spin_lock_irqsave(&port->port_lock, flags);
1000 if (port->port_dev != NULL && port->port_open_count > 0
1001 && port->port_write_buf != NULL)
1002 chars = gs_buf_data_avail(port->port_write_buf);
1004 spin_unlock_irqrestore(&port->port_lock, flags);
1006 gs_debug("gs_chars_in_buffer: (%d,%p) chars=%d\n",
1007 port->port_num, tty, chars);
1009 return chars;
1013 * gs_throttle
1015 static void gs_throttle(struct tty_struct *tty)
1020 * gs_unthrottle
1022 static void gs_unthrottle(struct tty_struct *tty)
1027 * gs_break
1029 static void gs_break(struct tty_struct *tty, int break_state)
1034 * gs_ioctl
1036 static int gs_ioctl(struct tty_struct *tty, struct file *file, unsigned int cmd, unsigned long arg)
1038 struct gs_port *port = tty->driver_data;
1040 if (port == NULL) {
1041 printk(KERN_ERR "gs_ioctl: NULL port pointer\n");
1042 return -EIO;
1045 gs_debug("gs_ioctl: (%d,%p,%p) cmd=0x%4.4x, arg=%lu\n",
1046 port->port_num, tty, file, cmd, arg);
1048 /* handle ioctls */
1050 /* could not handle ioctl */
1051 return -ENOIOCTLCMD;
1055 * gs_set_termios
1057 static void gs_set_termios(struct tty_struct *tty, struct ktermios *old)
1062 * gs_send
1064 * This function finds available write requests, calls
1065 * gs_send_packet to fill these packets with data, and
1066 * continues until either there are no more write requests
1067 * available or no more data to send. This function is
1068 * run whenever data arrives or write requests are available.
1070 static int gs_send(struct gs_dev *dev)
1072 int ret,len;
1073 unsigned long flags;
1074 struct usb_ep *ep;
1075 struct usb_request *req;
1076 struct gs_req_entry *req_entry;
1078 if (dev == NULL) {
1079 printk(KERN_ERR "gs_send: NULL device pointer\n");
1080 return -ENODEV;
1083 spin_lock_irqsave(&dev->dev_lock, flags);
1085 ep = dev->dev_in_ep;
1087 while(!list_empty(&dev->dev_req_list)) {
1089 req_entry = list_entry(dev->dev_req_list.next,
1090 struct gs_req_entry, re_entry);
1092 req = req_entry->re_req;
1094 len = gs_send_packet(dev, req->buf, ep->maxpacket);
1096 if (len > 0) {
1097 gs_debug_level(3, "gs_send: len=%d, 0x%2.2x "
1098 "0x%2.2x 0x%2.2x ...\n", len,
1099 *((unsigned char *)req->buf),
1100 *((unsigned char *)req->buf+1),
1101 *((unsigned char *)req->buf+2));
1102 list_del(&req_entry->re_entry);
1103 req->length = len;
1104 spin_unlock_irqrestore(&dev->dev_lock, flags);
1105 if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
1106 printk(KERN_ERR
1107 "gs_send: cannot queue read request, ret=%d\n",
1108 ret);
1109 spin_lock_irqsave(&dev->dev_lock, flags);
1110 break;
1112 spin_lock_irqsave(&dev->dev_lock, flags);
1113 } else {
1114 break;
1119 spin_unlock_irqrestore(&dev->dev_lock, flags);
1121 return 0;
1125 * gs_send_packet
1127 * If there is data to send, a packet is built in the given
1128 * buffer and the size is returned. If there is no data to
1129 * send, 0 is returned. If there is any error a negative
1130 * error number is returned.
1132 * Called during USB completion routine, on interrupt time.
1134 * We assume that disconnect will not happen until all completion
1135 * routines have completed, so we can assume that the dev_port
1136 * array does not change during the lifetime of this function.
1138 static int gs_send_packet(struct gs_dev *dev, char *packet, unsigned int size)
1140 unsigned int len;
1141 struct gs_port *port;
1143 /* TEMPORARY -- only port 0 is supported right now */
1144 port = dev->dev_port[0];
1146 if (port == NULL) {
1147 printk(KERN_ERR
1148 "gs_send_packet: port=%d, NULL port pointer\n",
1150 return -EIO;
1153 spin_lock(&port->port_lock);
1155 len = gs_buf_data_avail(port->port_write_buf);
1156 if (len < size)
1157 size = len;
1159 if (size == 0)
1160 goto exit;
1162 size = gs_buf_get(port->port_write_buf, packet, size);
1164 if (port->port_tty)
1165 wake_up_interruptible(&port->port_tty->write_wait);
1167 exit:
1168 spin_unlock(&port->port_lock);
1169 return size;
1173 * gs_recv_packet
1175 * Called for each USB packet received. Reads the packet
1176 * header and stuffs the data in the appropriate tty buffer.
1177 * Returns 0 if successful, or a negative error number.
1179 * Called during USB completion routine, on interrupt time.
1181 * We assume that disconnect will not happen until all completion
1182 * routines have completed, so we can assume that the dev_port
1183 * array does not change during the lifetime of this function.
1185 static int gs_recv_packet(struct gs_dev *dev, char *packet, unsigned int size)
1187 unsigned int len;
1188 struct gs_port *port;
1189 int ret;
1190 struct tty_struct *tty;
1192 /* TEMPORARY -- only port 0 is supported right now */
1193 port = dev->dev_port[0];
1195 if (port == NULL) {
1196 printk(KERN_ERR "gs_recv_packet: port=%d, NULL port pointer\n",
1197 port->port_num);
1198 return -EIO;
1201 spin_lock(&port->port_lock);
1203 if (port->port_open_count == 0) {
1204 printk(KERN_ERR "gs_recv_packet: port=%d, port is closed\n",
1205 port->port_num);
1206 ret = -EIO;
1207 goto exit;
1211 tty = port->port_tty;
1213 if (tty == NULL) {
1214 printk(KERN_ERR "gs_recv_packet: port=%d, NULL tty pointer\n",
1215 port->port_num);
1216 ret = -EIO;
1217 goto exit;
1220 if (port->port_tty->magic != TTY_MAGIC) {
1221 printk(KERN_ERR "gs_recv_packet: port=%d, bad tty magic\n",
1222 port->port_num);
1223 ret = -EIO;
1224 goto exit;
1227 len = tty_buffer_request_room(tty, size);
1228 if (len > 0) {
1229 tty_insert_flip_string(tty, packet, len);
1230 tty_flip_buffer_push(port->port_tty);
1231 wake_up_interruptible(&port->port_tty->read_wait);
1233 ret = 0;
1234 exit:
1235 spin_unlock(&port->port_lock);
1236 return ret;
1240 * gs_read_complete
1242 static void gs_read_complete(struct usb_ep *ep, struct usb_request *req)
1244 int ret;
1245 struct gs_dev *dev = ep->driver_data;
1247 if (dev == NULL) {
1248 printk(KERN_ERR "gs_read_complete: NULL device pointer\n");
1249 return;
1252 switch(req->status) {
1253 case 0:
1254 /* normal completion */
1255 gs_recv_packet(dev, req->buf, req->actual);
1256 requeue:
1257 req->length = ep->maxpacket;
1258 if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
1259 printk(KERN_ERR
1260 "gs_read_complete: cannot queue read request, ret=%d\n",
1261 ret);
1263 break;
1265 case -ESHUTDOWN:
1266 /* disconnect */
1267 gs_debug("gs_read_complete: shutdown\n");
1268 gs_free_req(ep, req);
1269 break;
1271 default:
1272 /* unexpected */
1273 printk(KERN_ERR
1274 "gs_read_complete: unexpected status error, status=%d\n",
1275 req->status);
1276 goto requeue;
1277 break;
1282 * gs_write_complete
1284 static void gs_write_complete(struct usb_ep *ep, struct usb_request *req)
1286 struct gs_dev *dev = ep->driver_data;
1287 struct gs_req_entry *gs_req = req->context;
1289 if (dev == NULL) {
1290 printk(KERN_ERR "gs_write_complete: NULL device pointer\n");
1291 return;
1294 switch(req->status) {
1295 case 0:
1296 /* normal completion */
1297 requeue:
1298 if (gs_req == NULL) {
1299 printk(KERN_ERR
1300 "gs_write_complete: NULL request pointer\n");
1301 return;
1304 spin_lock(&dev->dev_lock);
1305 list_add(&gs_req->re_entry, &dev->dev_req_list);
1306 spin_unlock(&dev->dev_lock);
1308 gs_send(dev);
1310 break;
1312 case -ESHUTDOWN:
1313 /* disconnect */
1314 gs_debug("gs_write_complete: shutdown\n");
1315 gs_free_req(ep, req);
1316 break;
1318 default:
1319 printk(KERN_ERR
1320 "gs_write_complete: unexpected status error, status=%d\n",
1321 req->status);
1322 goto requeue;
1323 break;
1327 /* Gadget Driver */
1330 * gs_bind
1332 * Called on module load. Allocates and initializes the device
1333 * structure and a control request.
1335 static int __init gs_bind(struct usb_gadget *gadget)
1337 int ret;
1338 struct usb_ep *ep;
1339 struct gs_dev *dev;
1340 int gcnum;
1342 /* Some controllers can't support CDC ACM:
1343 * - sh doesn't support multiple interfaces or configs;
1344 * - sa1100 doesn't have a third interrupt endpoint
1346 if (gadget_is_sh(gadget) || gadget_is_sa1100(gadget))
1347 use_acm = 0;
1349 gcnum = usb_gadget_controller_number(gadget);
1350 if (gcnum >= 0)
1351 gs_device_desc.bcdDevice =
1352 cpu_to_le16(GS_VERSION_NUM | gcnum);
1353 else {
1354 printk(KERN_WARNING "gs_bind: controller '%s' not recognized\n",
1355 gadget->name);
1356 /* unrecognized, but safe unless bulk is REALLY quirky */
1357 gs_device_desc.bcdDevice =
1358 __constant_cpu_to_le16(GS_VERSION_NUM|0x0099);
1361 usb_ep_autoconfig_reset(gadget);
1363 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_in_desc);
1364 if (!ep)
1365 goto autoconf_fail;
1366 EP_IN_NAME = ep->name;
1367 ep->driver_data = ep; /* claim the endpoint */
1369 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_out_desc);
1370 if (!ep)
1371 goto autoconf_fail;
1372 EP_OUT_NAME = ep->name;
1373 ep->driver_data = ep; /* claim the endpoint */
1375 if (use_acm) {
1376 ep = usb_ep_autoconfig(gadget, &gs_fullspeed_notify_desc);
1377 if (!ep) {
1378 printk(KERN_ERR "gs_bind: cannot run ACM on %s\n", gadget->name);
1379 goto autoconf_fail;
1381 gs_device_desc.idProduct = __constant_cpu_to_le16(
1382 GS_CDC_PRODUCT_ID),
1383 EP_NOTIFY_NAME = ep->name;
1384 ep->driver_data = ep; /* claim the endpoint */
1387 gs_device_desc.bDeviceClass = use_acm
1388 ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
1389 gs_device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1391 if (gadget_is_dualspeed(gadget)) {
1392 gs_qualifier_desc.bDeviceClass = use_acm
1393 ? USB_CLASS_COMM : USB_CLASS_VENDOR_SPEC;
1394 /* assume ep0 uses the same packet size for both speeds */
1395 gs_qualifier_desc.bMaxPacketSize0 =
1396 gs_device_desc.bMaxPacketSize0;
1397 /* assume endpoints are dual-speed */
1398 gs_highspeed_notify_desc.bEndpointAddress =
1399 gs_fullspeed_notify_desc.bEndpointAddress;
1400 gs_highspeed_in_desc.bEndpointAddress =
1401 gs_fullspeed_in_desc.bEndpointAddress;
1402 gs_highspeed_out_desc.bEndpointAddress =
1403 gs_fullspeed_out_desc.bEndpointAddress;
1406 usb_gadget_set_selfpowered(gadget);
1408 if (gadget_is_otg(gadget)) {
1409 gs_otg_descriptor.bmAttributes |= USB_OTG_HNP,
1410 gs_bulk_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1411 gs_acm_config_desc.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1414 gs_device = dev = kzalloc(sizeof(struct gs_dev), GFP_KERNEL);
1415 if (dev == NULL)
1416 return -ENOMEM;
1418 snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
1419 init_utsname()->sysname, init_utsname()->release,
1420 gadget->name);
1422 dev->dev_gadget = gadget;
1423 spin_lock_init(&dev->dev_lock);
1424 INIT_LIST_HEAD(&dev->dev_req_list);
1425 set_gadget_data(gadget, dev);
1427 if ((ret=gs_alloc_ports(dev, GFP_KERNEL)) != 0) {
1428 printk(KERN_ERR "gs_bind: cannot allocate ports\n");
1429 gs_unbind(gadget);
1430 return ret;
1433 /* preallocate control response and buffer */
1434 dev->dev_ctrl_req = gs_alloc_req(gadget->ep0, GS_MAX_DESC_LEN,
1435 GFP_KERNEL);
1436 if (dev->dev_ctrl_req == NULL) {
1437 gs_unbind(gadget);
1438 return -ENOMEM;
1440 dev->dev_ctrl_req->complete = gs_setup_complete;
1442 gadget->ep0->driver_data = dev;
1444 printk(KERN_INFO "gs_bind: %s %s bound\n",
1445 GS_LONG_NAME, GS_VERSION_STR);
1447 return 0;
1449 autoconf_fail:
1450 printk(KERN_ERR "gs_bind: cannot autoconfigure on %s\n", gadget->name);
1451 return -ENODEV;
1455 * gs_unbind
1457 * Called on module unload. Frees the control request and device
1458 * structure.
1460 static void /* __init_or_exit */ gs_unbind(struct usb_gadget *gadget)
1462 struct gs_dev *dev = get_gadget_data(gadget);
1464 gs_device = NULL;
1466 /* read/write requests already freed, only control request remains */
1467 if (dev != NULL) {
1468 if (dev->dev_ctrl_req != NULL) {
1469 gs_free_req(gadget->ep0, dev->dev_ctrl_req);
1470 dev->dev_ctrl_req = NULL;
1472 gs_free_ports(dev);
1473 if (dev->dev_notify_ep)
1474 usb_ep_disable(dev->dev_notify_ep);
1475 if (dev->dev_in_ep)
1476 usb_ep_disable(dev->dev_in_ep);
1477 if (dev->dev_out_ep)
1478 usb_ep_disable(dev->dev_out_ep);
1479 kfree(dev);
1480 set_gadget_data(gadget, NULL);
1483 printk(KERN_INFO "gs_unbind: %s %s unbound\n", GS_LONG_NAME,
1484 GS_VERSION_STR);
1488 * gs_setup
1490 * Implements all the control endpoint functionality that's not
1491 * handled in hardware or the hardware driver.
1493 * Returns the size of the data sent to the host, or a negative
1494 * error number.
1496 static int gs_setup(struct usb_gadget *gadget,
1497 const struct usb_ctrlrequest *ctrl)
1499 int ret = -EOPNOTSUPP;
1500 struct gs_dev *dev = get_gadget_data(gadget);
1501 struct usb_request *req = dev->dev_ctrl_req;
1502 u16 wIndex = le16_to_cpu(ctrl->wIndex);
1503 u16 wValue = le16_to_cpu(ctrl->wValue);
1504 u16 wLength = le16_to_cpu(ctrl->wLength);
1506 switch (ctrl->bRequestType & USB_TYPE_MASK) {
1507 case USB_TYPE_STANDARD:
1508 ret = gs_setup_standard(gadget,ctrl);
1509 break;
1511 case USB_TYPE_CLASS:
1512 ret = gs_setup_class(gadget,ctrl);
1513 break;
1515 default:
1516 printk(KERN_ERR "gs_setup: unknown request, type=%02x, request=%02x, value=%04x, index=%04x, length=%d\n",
1517 ctrl->bRequestType, ctrl->bRequest,
1518 wValue, wIndex, wLength);
1519 break;
1522 /* respond with data transfer before status phase? */
1523 if (ret >= 0) {
1524 req->length = ret;
1525 req->zero = ret < wLength
1526 && (ret % gadget->ep0->maxpacket) == 0;
1527 ret = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1528 if (ret < 0) {
1529 printk(KERN_ERR "gs_setup: cannot queue response, ret=%d\n",
1530 ret);
1531 req->status = 0;
1532 gs_setup_complete(gadget->ep0, req);
1536 /* device either stalls (ret < 0) or reports success */
1537 return ret;
1540 static int gs_setup_standard(struct usb_gadget *gadget,
1541 const struct usb_ctrlrequest *ctrl)
1543 int ret = -EOPNOTSUPP;
1544 struct gs_dev *dev = get_gadget_data(gadget);
1545 struct usb_request *req = dev->dev_ctrl_req;
1546 u16 wIndex = le16_to_cpu(ctrl->wIndex);
1547 u16 wValue = le16_to_cpu(ctrl->wValue);
1548 u16 wLength = le16_to_cpu(ctrl->wLength);
1550 switch (ctrl->bRequest) {
1551 case USB_REQ_GET_DESCRIPTOR:
1552 if (ctrl->bRequestType != USB_DIR_IN)
1553 break;
1555 switch (wValue >> 8) {
1556 case USB_DT_DEVICE:
1557 ret = min(wLength,
1558 (u16)sizeof(struct usb_device_descriptor));
1559 memcpy(req->buf, &gs_device_desc, ret);
1560 break;
1562 case USB_DT_DEVICE_QUALIFIER:
1563 if (!gadget_is_dualspeed(gadget))
1564 break;
1565 ret = min(wLength,
1566 (u16)sizeof(struct usb_qualifier_descriptor));
1567 memcpy(req->buf, &gs_qualifier_desc, ret);
1568 break;
1570 case USB_DT_OTHER_SPEED_CONFIG:
1571 if (!gadget_is_dualspeed(gadget))
1572 break;
1573 /* fall through */
1574 case USB_DT_CONFIG:
1575 ret = gs_build_config_buf(req->buf, gadget,
1576 wValue >> 8, wValue & 0xff,
1577 gadget_is_otg(gadget));
1578 if (ret >= 0)
1579 ret = min(wLength, (u16)ret);
1580 break;
1582 case USB_DT_STRING:
1583 /* wIndex == language code. */
1584 ret = usb_gadget_get_string(&gs_string_table,
1585 wValue & 0xff, req->buf);
1586 if (ret >= 0)
1587 ret = min(wLength, (u16)ret);
1588 break;
1590 break;
1592 case USB_REQ_SET_CONFIGURATION:
1593 if (ctrl->bRequestType != 0)
1594 break;
1595 spin_lock(&dev->dev_lock);
1596 ret = gs_set_config(dev, wValue);
1597 spin_unlock(&dev->dev_lock);
1598 break;
1600 case USB_REQ_GET_CONFIGURATION:
1601 if (ctrl->bRequestType != USB_DIR_IN)
1602 break;
1603 *(u8 *)req->buf = dev->dev_config;
1604 ret = min(wLength, (u16)1);
1605 break;
1607 case USB_REQ_SET_INTERFACE:
1608 if (ctrl->bRequestType != USB_RECIP_INTERFACE
1609 || !dev->dev_config
1610 || wIndex >= GS_MAX_NUM_INTERFACES)
1611 break;
1612 if (dev->dev_config == GS_BULK_CONFIG_ID
1613 && wIndex != GS_BULK_INTERFACE_ID)
1614 break;
1615 /* no alternate interface settings */
1616 if (wValue != 0)
1617 break;
1618 spin_lock(&dev->dev_lock);
1619 /* PXA hardware partially handles SET_INTERFACE;
1620 * we need to kluge around that interference. */
1621 if (gadget_is_pxa(gadget)) {
1622 ret = gs_set_config(dev, use_acm ?
1623 GS_ACM_CONFIG_ID : GS_BULK_CONFIG_ID);
1624 goto set_interface_done;
1626 if (dev->dev_config != GS_BULK_CONFIG_ID
1627 && wIndex == GS_CONTROL_INTERFACE_ID) {
1628 if (dev->dev_notify_ep) {
1629 usb_ep_disable(dev->dev_notify_ep);
1630 usb_ep_enable(dev->dev_notify_ep, dev->dev_notify_ep_desc);
1632 } else {
1633 usb_ep_disable(dev->dev_in_ep);
1634 usb_ep_disable(dev->dev_out_ep);
1635 usb_ep_enable(dev->dev_in_ep, dev->dev_in_ep_desc);
1636 usb_ep_enable(dev->dev_out_ep, dev->dev_out_ep_desc);
1638 ret = 0;
1639 set_interface_done:
1640 spin_unlock(&dev->dev_lock);
1641 break;
1643 case USB_REQ_GET_INTERFACE:
1644 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
1645 || dev->dev_config == GS_NO_CONFIG_ID)
1646 break;
1647 if (wIndex >= GS_MAX_NUM_INTERFACES
1648 || (dev->dev_config == GS_BULK_CONFIG_ID
1649 && wIndex != GS_BULK_INTERFACE_ID)) {
1650 ret = -EDOM;
1651 break;
1653 /* no alternate interface settings */
1654 *(u8 *)req->buf = 0;
1655 ret = min(wLength, (u16)1);
1656 break;
1658 default:
1659 printk(KERN_ERR "gs_setup: unknown standard request, type=%02x, request=%02x, value=%04x, index=%04x, length=%d\n",
1660 ctrl->bRequestType, ctrl->bRequest,
1661 wValue, wIndex, wLength);
1662 break;
1665 return ret;
1668 static int gs_setup_class(struct usb_gadget *gadget,
1669 const struct usb_ctrlrequest *ctrl)
1671 int ret = -EOPNOTSUPP;
1672 struct gs_dev *dev = get_gadget_data(gadget);
1673 struct gs_port *port = dev->dev_port[0]; /* ACM only has one port */
1674 struct usb_request *req = dev->dev_ctrl_req;
1675 u16 wIndex = le16_to_cpu(ctrl->wIndex);
1676 u16 wValue = le16_to_cpu(ctrl->wValue);
1677 u16 wLength = le16_to_cpu(ctrl->wLength);
1679 switch (ctrl->bRequest) {
1680 case USB_CDC_REQ_SET_LINE_CODING:
1681 /* FIXME Submit req to read the data; have its completion
1682 * handler copy that data to port->port_line_coding (iff
1683 * it's valid) and maybe pass it on. Until then, fail.
1685 printk(KERN_WARNING "gs_setup: set_line_coding "
1686 "unuspported\n");
1687 break;
1689 case USB_CDC_REQ_GET_LINE_CODING:
1690 port = dev->dev_port[0]; /* ACM only has one port */
1691 ret = min(wLength,
1692 (u16)sizeof(struct usb_cdc_line_coding));
1693 if (port) {
1694 spin_lock(&port->port_lock);
1695 memcpy(req->buf, &port->port_line_coding, ret);
1696 spin_unlock(&port->port_lock);
1698 break;
1700 case USB_CDC_REQ_SET_CONTROL_LINE_STATE:
1701 /* FIXME Submit req to read the data; have its completion
1702 * handler use that to set the state (iff it's valid) and
1703 * maybe pass it on. Until then, fail.
1705 printk(KERN_WARNING "gs_setup: set_control_line_state "
1706 "unuspported\n");
1707 break;
1709 default:
1710 printk(KERN_ERR "gs_setup: unknown class request, "
1711 "type=%02x, request=%02x, value=%04x, "
1712 "index=%04x, length=%d\n",
1713 ctrl->bRequestType, ctrl->bRequest,
1714 wValue, wIndex, wLength);
1715 break;
1718 return ret;
1722 * gs_setup_complete
1724 static void gs_setup_complete(struct usb_ep *ep, struct usb_request *req)
1726 if (req->status || req->actual != req->length) {
1727 printk(KERN_ERR "gs_setup_complete: status error, status=%d, actual=%d, length=%d\n",
1728 req->status, req->actual, req->length);
1733 * gs_disconnect
1735 * Called when the device is disconnected. Frees the closed
1736 * ports and disconnects open ports. Open ports will be freed
1737 * on close. Then reallocates the ports for the next connection.
1739 static void gs_disconnect(struct usb_gadget *gadget)
1741 unsigned long flags;
1742 struct gs_dev *dev = get_gadget_data(gadget);
1744 spin_lock_irqsave(&dev->dev_lock, flags);
1746 gs_reset_config(dev);
1748 /* free closed ports and disconnect open ports */
1749 /* (open ports will be freed when closed) */
1750 gs_free_ports(dev);
1752 /* re-allocate ports for the next connection */
1753 if (gs_alloc_ports(dev, GFP_ATOMIC) != 0)
1754 printk(KERN_ERR "gs_disconnect: cannot re-allocate ports\n");
1756 spin_unlock_irqrestore(&dev->dev_lock, flags);
1758 printk(KERN_INFO "gs_disconnect: %s disconnected\n", GS_LONG_NAME);
1762 * gs_set_config
1764 * Configures the device by enabling device specific
1765 * optimizations, setting up the endpoints, allocating
1766 * read and write requests and queuing read requests.
1768 * The device lock must be held when calling this function.
1770 static int gs_set_config(struct gs_dev *dev, unsigned config)
1772 int i;
1773 int ret = 0;
1774 struct usb_gadget *gadget = dev->dev_gadget;
1775 struct usb_ep *ep;
1776 struct usb_endpoint_descriptor *ep_desc;
1777 struct usb_request *req;
1778 struct gs_req_entry *req_entry;
1780 if (dev == NULL) {
1781 printk(KERN_ERR "gs_set_config: NULL device pointer\n");
1782 return 0;
1785 if (config == dev->dev_config)
1786 return 0;
1788 gs_reset_config(dev);
1790 switch (config) {
1791 case GS_NO_CONFIG_ID:
1792 return 0;
1793 case GS_BULK_CONFIG_ID:
1794 if (use_acm)
1795 return -EINVAL;
1796 /* device specific optimizations */
1797 if (gadget_is_net2280(gadget))
1798 net2280_set_fifo_mode(gadget, 1);
1799 break;
1800 case GS_ACM_CONFIG_ID:
1801 if (!use_acm)
1802 return -EINVAL;
1803 /* device specific optimizations */
1804 if (gadget_is_net2280(gadget))
1805 net2280_set_fifo_mode(gadget, 1);
1806 break;
1807 default:
1808 return -EINVAL;
1811 dev->dev_config = config;
1813 gadget_for_each_ep(ep, gadget) {
1815 if (EP_NOTIFY_NAME
1816 && strcmp(ep->name, EP_NOTIFY_NAME) == 0) {
1817 ep_desc = choose_ep_desc(gadget,
1818 &gs_highspeed_notify_desc,
1819 &gs_fullspeed_notify_desc);
1820 ret = usb_ep_enable(ep,ep_desc);
1821 if (ret == 0) {
1822 ep->driver_data = dev;
1823 dev->dev_notify_ep = ep;
1824 dev->dev_notify_ep_desc = ep_desc;
1825 } else {
1826 printk(KERN_ERR "gs_set_config: cannot enable notify endpoint %s, ret=%d\n",
1827 ep->name, ret);
1828 goto exit_reset_config;
1832 else if (strcmp(ep->name, EP_IN_NAME) == 0) {
1833 ep_desc = choose_ep_desc(gadget,
1834 &gs_highspeed_in_desc,
1835 &gs_fullspeed_in_desc);
1836 ret = usb_ep_enable(ep,ep_desc);
1837 if (ret == 0) {
1838 ep->driver_data = dev;
1839 dev->dev_in_ep = ep;
1840 dev->dev_in_ep_desc = ep_desc;
1841 } else {
1842 printk(KERN_ERR "gs_set_config: cannot enable in endpoint %s, ret=%d\n",
1843 ep->name, ret);
1844 goto exit_reset_config;
1848 else if (strcmp(ep->name, EP_OUT_NAME) == 0) {
1849 ep_desc = choose_ep_desc(gadget,
1850 &gs_highspeed_out_desc,
1851 &gs_fullspeed_out_desc);
1852 ret = usb_ep_enable(ep,ep_desc);
1853 if (ret == 0) {
1854 ep->driver_data = dev;
1855 dev->dev_out_ep = ep;
1856 dev->dev_out_ep_desc = ep_desc;
1857 } else {
1858 printk(KERN_ERR "gs_set_config: cannot enable out endpoint %s, ret=%d\n",
1859 ep->name, ret);
1860 goto exit_reset_config;
1866 if (dev->dev_in_ep == NULL || dev->dev_out_ep == NULL
1867 || (config != GS_BULK_CONFIG_ID && dev->dev_notify_ep == NULL)) {
1868 printk(KERN_ERR "gs_set_config: cannot find endpoints\n");
1869 ret = -ENODEV;
1870 goto exit_reset_config;
1873 /* allocate and queue read requests */
1874 ep = dev->dev_out_ep;
1875 for (i=0; i<read_q_size && ret == 0; i++) {
1876 if ((req=gs_alloc_req(ep, ep->maxpacket, GFP_ATOMIC))) {
1877 req->complete = gs_read_complete;
1878 if ((ret=usb_ep_queue(ep, req, GFP_ATOMIC))) {
1879 printk(KERN_ERR "gs_set_config: cannot queue read request, ret=%d\n",
1880 ret);
1882 } else {
1883 printk(KERN_ERR "gs_set_config: cannot allocate read requests\n");
1884 ret = -ENOMEM;
1885 goto exit_reset_config;
1889 /* allocate write requests, and put on free list */
1890 ep = dev->dev_in_ep;
1891 for (i=0; i<write_q_size; i++) {
1892 if ((req_entry=gs_alloc_req_entry(ep, ep->maxpacket, GFP_ATOMIC))) {
1893 req_entry->re_req->complete = gs_write_complete;
1894 list_add(&req_entry->re_entry, &dev->dev_req_list);
1895 } else {
1896 printk(KERN_ERR "gs_set_config: cannot allocate write requests\n");
1897 ret = -ENOMEM;
1898 goto exit_reset_config;
1902 printk(KERN_INFO "gs_set_config: %s configured, %s speed %s config\n",
1903 GS_LONG_NAME,
1904 gadget->speed == USB_SPEED_HIGH ? "high" : "full",
1905 config == GS_BULK_CONFIG_ID ? "BULK" : "CDC-ACM");
1907 return 0;
1909 exit_reset_config:
1910 gs_reset_config(dev);
1911 return ret;
1915 * gs_reset_config
1917 * Mark the device as not configured, disable all endpoints,
1918 * which forces completion of pending I/O and frees queued
1919 * requests, and free the remaining write requests on the
1920 * free list.
1922 * The device lock must be held when calling this function.
1924 static void gs_reset_config(struct gs_dev *dev)
1926 struct gs_req_entry *req_entry;
1928 if (dev == NULL) {
1929 printk(KERN_ERR "gs_reset_config: NULL device pointer\n");
1930 return;
1933 if (dev->dev_config == GS_NO_CONFIG_ID)
1934 return;
1936 dev->dev_config = GS_NO_CONFIG_ID;
1938 /* free write requests on the free list */
1939 while(!list_empty(&dev->dev_req_list)) {
1940 req_entry = list_entry(dev->dev_req_list.next,
1941 struct gs_req_entry, re_entry);
1942 list_del(&req_entry->re_entry);
1943 gs_free_req_entry(dev->dev_in_ep, req_entry);
1946 /* disable endpoints, forcing completion of pending i/o; */
1947 /* completion handlers free their requests in this case */
1948 if (dev->dev_notify_ep) {
1949 usb_ep_disable(dev->dev_notify_ep);
1950 dev->dev_notify_ep = NULL;
1952 if (dev->dev_in_ep) {
1953 usb_ep_disable(dev->dev_in_ep);
1954 dev->dev_in_ep = NULL;
1956 if (dev->dev_out_ep) {
1957 usb_ep_disable(dev->dev_out_ep);
1958 dev->dev_out_ep = NULL;
1963 * gs_build_config_buf
1965 * Builds the config descriptors in the given buffer and returns the
1966 * length, or a negative error number.
1968 static int gs_build_config_buf(u8 *buf, struct usb_gadget *g,
1969 u8 type, unsigned int index, int is_otg)
1971 int len;
1972 int high_speed = 0;
1973 const struct usb_config_descriptor *config_desc;
1974 const struct usb_descriptor_header **function;
1976 if (index >= gs_device_desc.bNumConfigurations)
1977 return -EINVAL;
1979 /* other speed switches high and full speed */
1980 if (gadget_is_dualspeed(g)) {
1981 high_speed = (g->speed == USB_SPEED_HIGH);
1982 if (type == USB_DT_OTHER_SPEED_CONFIG)
1983 high_speed = !high_speed;
1986 if (use_acm) {
1987 config_desc = &gs_acm_config_desc;
1988 function = high_speed
1989 ? gs_acm_highspeed_function
1990 : gs_acm_fullspeed_function;
1991 } else {
1992 config_desc = &gs_bulk_config_desc;
1993 function = high_speed
1994 ? gs_bulk_highspeed_function
1995 : gs_bulk_fullspeed_function;
1998 /* for now, don't advertise srp-only devices */
1999 if (!is_otg)
2000 function++;
2002 len = usb_gadget_config_buf(config_desc, buf, GS_MAX_DESC_LEN, function);
2003 if (len < 0)
2004 return len;
2006 ((struct usb_config_descriptor *)buf)->bDescriptorType = type;
2008 return len;
2012 * gs_alloc_req
2014 * Allocate a usb_request and its buffer. Returns a pointer to the
2015 * usb_request or NULL if there is an error.
2017 static struct usb_request *
2018 gs_alloc_req(struct usb_ep *ep, unsigned int len, gfp_t kmalloc_flags)
2020 struct usb_request *req;
2022 if (ep == NULL)
2023 return NULL;
2025 req = usb_ep_alloc_request(ep, kmalloc_flags);
2027 if (req != NULL) {
2028 req->length = len;
2029 req->buf = kmalloc(len, kmalloc_flags);
2030 if (req->buf == NULL) {
2031 usb_ep_free_request(ep, req);
2032 return NULL;
2036 return req;
2040 * gs_free_req
2042 * Free a usb_request and its buffer.
2044 static void gs_free_req(struct usb_ep *ep, struct usb_request *req)
2046 if (ep != NULL && req != NULL) {
2047 kfree(req->buf);
2048 usb_ep_free_request(ep, req);
2053 * gs_alloc_req_entry
2055 * Allocates a request and its buffer, using the given
2056 * endpoint, buffer len, and kmalloc flags.
2058 static struct gs_req_entry *
2059 gs_alloc_req_entry(struct usb_ep *ep, unsigned len, gfp_t kmalloc_flags)
2061 struct gs_req_entry *req;
2063 req = kmalloc(sizeof(struct gs_req_entry), kmalloc_flags);
2064 if (req == NULL)
2065 return NULL;
2067 req->re_req = gs_alloc_req(ep, len, kmalloc_flags);
2068 if (req->re_req == NULL) {
2069 kfree(req);
2070 return NULL;
2073 req->re_req->context = req;
2075 return req;
2079 * gs_free_req_entry
2081 * Frees a request and its buffer.
2083 static void gs_free_req_entry(struct usb_ep *ep, struct gs_req_entry *req)
2085 if (ep != NULL && req != NULL) {
2086 if (req->re_req != NULL)
2087 gs_free_req(ep, req->re_req);
2088 kfree(req);
2093 * gs_alloc_ports
2095 * Allocate all ports and set the gs_dev struct to point to them.
2096 * Return 0 if successful, or a negative error number.
2098 * The device lock is normally held when calling this function.
2100 static int gs_alloc_ports(struct gs_dev *dev, gfp_t kmalloc_flags)
2102 int i;
2103 struct gs_port *port;
2105 if (dev == NULL)
2106 return -EIO;
2108 for (i=0; i<GS_NUM_PORTS; i++) {
2109 if ((port=kzalloc(sizeof(struct gs_port), kmalloc_flags)) == NULL)
2110 return -ENOMEM;
2112 port->port_dev = dev;
2113 port->port_num = i;
2114 port->port_line_coding.dwDTERate = cpu_to_le32(GS_DEFAULT_DTE_RATE);
2115 port->port_line_coding.bCharFormat = GS_DEFAULT_CHAR_FORMAT;
2116 port->port_line_coding.bParityType = GS_DEFAULT_PARITY;
2117 port->port_line_coding.bDataBits = GS_DEFAULT_DATA_BITS;
2118 spin_lock_init(&port->port_lock);
2119 init_waitqueue_head(&port->port_write_wait);
2121 dev->dev_port[i] = port;
2124 return 0;
2128 * gs_free_ports
2130 * Free all closed ports. Open ports are disconnected by
2131 * freeing their write buffers, setting their device pointers
2132 * and the pointers to them in the device to NULL. These
2133 * ports will be freed when closed.
2135 * The device lock is normally held when calling this function.
2137 static void gs_free_ports(struct gs_dev *dev)
2139 int i;
2140 unsigned long flags;
2141 struct gs_port *port;
2143 if (dev == NULL)
2144 return;
2146 for (i=0; i<GS_NUM_PORTS; i++) {
2147 if ((port=dev->dev_port[i]) != NULL) {
2148 dev->dev_port[i] = NULL;
2150 spin_lock_irqsave(&port->port_lock, flags);
2152 if (port->port_write_buf != NULL) {
2153 gs_buf_free(port->port_write_buf);
2154 port->port_write_buf = NULL;
2157 if (port->port_open_count > 0 || port->port_in_use) {
2158 port->port_dev = NULL;
2159 wake_up_interruptible(&port->port_write_wait);
2160 if (port->port_tty) {
2161 wake_up_interruptible(&port->port_tty->read_wait);
2162 wake_up_interruptible(&port->port_tty->write_wait);
2164 spin_unlock_irqrestore(&port->port_lock, flags);
2165 } else {
2166 spin_unlock_irqrestore(&port->port_lock, flags);
2167 kfree(port);
2174 /* Circular Buffer */
2177 * gs_buf_alloc
2179 * Allocate a circular buffer and all associated memory.
2181 static struct gs_buf *gs_buf_alloc(unsigned int size, gfp_t kmalloc_flags)
2183 struct gs_buf *gb;
2185 if (size == 0)
2186 return NULL;
2188 gb = kmalloc(sizeof(struct gs_buf), kmalloc_flags);
2189 if (gb == NULL)
2190 return NULL;
2192 gb->buf_buf = kmalloc(size, kmalloc_flags);
2193 if (gb->buf_buf == NULL) {
2194 kfree(gb);
2195 return NULL;
2198 gb->buf_size = size;
2199 gb->buf_get = gb->buf_put = gb->buf_buf;
2201 return gb;
2205 * gs_buf_free
2207 * Free the buffer and all associated memory.
2209 static void gs_buf_free(struct gs_buf *gb)
2211 if (gb) {
2212 kfree(gb->buf_buf);
2213 kfree(gb);
2218 * gs_buf_clear
2220 * Clear out all data in the circular buffer.
2222 static void gs_buf_clear(struct gs_buf *gb)
2224 if (gb != NULL)
2225 gb->buf_get = gb->buf_put;
2226 /* equivalent to a get of all data available */
2230 * gs_buf_data_avail
2232 * Return the number of bytes of data available in the circular
2233 * buffer.
2235 static unsigned int gs_buf_data_avail(struct gs_buf *gb)
2237 if (gb != NULL)
2238 return (gb->buf_size + gb->buf_put - gb->buf_get) % gb->buf_size;
2239 else
2240 return 0;
2244 * gs_buf_space_avail
2246 * Return the number of bytes of space available in the circular
2247 * buffer.
2249 static unsigned int gs_buf_space_avail(struct gs_buf *gb)
2251 if (gb != NULL)
2252 return (gb->buf_size + gb->buf_get - gb->buf_put - 1) % gb->buf_size;
2253 else
2254 return 0;
2258 * gs_buf_put
2260 * Copy data data from a user buffer and put it into the circular buffer.
2261 * Restrict to the amount of space available.
2263 * Return the number of bytes copied.
2265 static unsigned int
2266 gs_buf_put(struct gs_buf *gb, const char *buf, unsigned int count)
2268 unsigned int len;
2270 if (gb == NULL)
2271 return 0;
2273 len = gs_buf_space_avail(gb);
2274 if (count > len)
2275 count = len;
2277 if (count == 0)
2278 return 0;
2280 len = gb->buf_buf + gb->buf_size - gb->buf_put;
2281 if (count > len) {
2282 memcpy(gb->buf_put, buf, len);
2283 memcpy(gb->buf_buf, buf+len, count - len);
2284 gb->buf_put = gb->buf_buf + count - len;
2285 } else {
2286 memcpy(gb->buf_put, buf, count);
2287 if (count < len)
2288 gb->buf_put += count;
2289 else /* count == len */
2290 gb->buf_put = gb->buf_buf;
2293 return count;
2297 * gs_buf_get
2299 * Get data from the circular buffer and copy to the given buffer.
2300 * Restrict to the amount of data available.
2302 * Return the number of bytes copied.
2304 static unsigned int
2305 gs_buf_get(struct gs_buf *gb, char *buf, unsigned int count)
2307 unsigned int len;
2309 if (gb == NULL)
2310 return 0;
2312 len = gs_buf_data_avail(gb);
2313 if (count > len)
2314 count = len;
2316 if (count == 0)
2317 return 0;
2319 len = gb->buf_buf + gb->buf_size - gb->buf_get;
2320 if (count > len) {
2321 memcpy(buf, gb->buf_get, len);
2322 memcpy(buf+len, gb->buf_buf, count - len);
2323 gb->buf_get = gb->buf_buf + count - len;
2324 } else {
2325 memcpy(buf, gb->buf_get, count);
2326 if (count < len)
2327 gb->buf_get += count;
2328 else /* count == len */
2329 gb->buf_get = gb->buf_buf;
2332 return count;