?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
usb-serial: Coding style
[linux-2.6/sactl.git] / drivers / usb / serial / usb-serial.c
blob51917b0f079a6d816744bec0ea5646e8aa0f2149
1 /*
2 * USB Serial Converter driver
3 *
4 * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
6 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
11 *
12 * This driver was originally based on the ACM driver by Armin Fuerst (which was
13 * based on a driver by Brad Keryan)
14 *
15 * See Documentation/usb/usb-serial.txt for more information on using this
16 * driver
17 *
18 */
19
20 #include <linux/kernel.h>
21 #include <linux/errno.h>
22 #include <linux/init.h>
23 #include <linux/slab.h>
24 #include <linux/tty.h>
25 #include <linux/tty_driver.h>
26 #include <linux/tty_flip.h>
27 #include <linux/module.h>
28 #include <linux/moduleparam.h>
29 #include <linux/spinlock.h>
30 #include <linux/mutex.h>
31 #include <linux/list.h>
32 #include <linux/uaccess.h>
33 #include <linux/usb.h>
34 #include <linux/usb/serial.h>
35 #include "pl2303.h"
36
37 /*
38 * Version Information
39 */
40 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
41 #define DRIVER_DESC "USB Serial Driver core"
42
43 static void port_free(struct usb_serial_port *port);
44
45 /* Driver structure we register with the USB core */
46 static struct usb_driver usb_serial_driver = {
47 .name = "usbserial",
48 .probe = usb_serial_probe,
49 .disconnect = usb_serial_disconnect,
50 .suspend = usb_serial_suspend,
51 .resume = usb_serial_resume,
52 .no_dynamic_id = 1,
53 };
54
55 /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
56 the MODULE_DEVICE_TABLE declarations in each serial driver
57 cause the "hotplug" program to pull in whatever module is necessary
58 via modprobe, and modprobe will load usbserial because the serial
59 drivers depend on it.
60 */
61
62 static int debug;
63 /* initially all NULL */
64 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
65 static DEFINE_MUTEX(table_lock);
66 static LIST_HEAD(usb_serial_driver_list);
67
68 struct usb_serial *usb_serial_get_by_index(unsigned index)
69 {
70 struct usb_serial *serial;
71
72 mutex_lock(&table_lock);
73 serial = serial_table[index];
74
75 if (serial)
76 kref_get(&serial->kref);
77 mutex_unlock(&table_lock);
78 return serial;
79 }
80
81 static struct usb_serial *get_free_serial(struct usb_serial *serial,
82 int num_ports, unsigned int *minor)
83 {
84 unsigned int i, j;
85 int good_spot;
86
87 dbg("%s %d", __func__, num_ports);
88
89 *minor = 0;
90 mutex_lock(&table_lock);
91 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
92 if (serial_table[i])
93 continue;
94
95 good_spot = 1;
96 for (j = 1; j <= num_ports-1; ++j)
97 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
98 good_spot = 0;
99 i += j;
100 break;
101 }
102 if (good_spot == 0)
103 continue;
104
105 *minor = i;
106 j = 0;
107 dbg("%s - minor base = %d", __func__, *minor);
108 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
109 serial_table[i] = serial;
110 serial->port[j++]->number = i;
111 }
112 mutex_unlock(&table_lock);
113 return serial;
114 }
115 mutex_unlock(&table_lock);
116 return NULL;
117 }
118
119 static void return_serial(struct usb_serial *serial)
120 {
121 int i;
122
123 dbg("%s", __func__);
124
125 if (serial == NULL)
126 return;
127
128 for (i = 0; i < serial->num_ports; ++i)
129 serial_table[serial->minor + i] = NULL;
130 }
131
132 static void destroy_serial(struct kref *kref)
133 {
134 struct usb_serial *serial;
135 struct usb_serial_port *port;
136 int i;
137
138 serial = to_usb_serial(kref);
139
140 dbg("%s - %s", __func__, serial->type->description);
141
142 serial->type->shutdown(serial);
143
144 /* return the minor range that this device had */
145 return_serial(serial);
146
147 for (i = 0; i < serial->num_ports; ++i)
148 serial->port[i]->port.count = 0;
149
150 /* the ports are cleaned up and released in port_release() */
151 for (i = 0; i < serial->num_ports; ++i)
152 if (serial->port[i]->dev.parent != NULL) {
153 device_unregister(&serial->port[i]->dev);
154 serial->port[i] = NULL;
155 }
156
157 /* If this is a "fake" port, we have to clean it up here, as it will
158 * not get cleaned up in port_release() as it was never registered with
159 * the driver core */
160 if (serial->num_ports < serial->num_port_pointers) {
161 for (i = serial->num_ports;
162 i < serial->num_port_pointers; ++i) {
163 port = serial->port[i];
164 if (!port)
165 continue;
166 port_free(port);
167 }
168 }
169
170 usb_put_dev(serial->dev);
171
172 /* free up any memory that we allocated */
173 kfree(serial);
174 }
175
176 void usb_serial_put(struct usb_serial *serial)
177 {
178 mutex_lock(&table_lock);
179 kref_put(&serial->kref, destroy_serial);
180 mutex_unlock(&table_lock);
181 }
182
183 /*****************************************************************************
184 * Driver tty interface functions
185 *****************************************************************************/
186 static int serial_open (struct tty_struct *tty, struct file *filp)
187 {
188 struct usb_serial *serial;
189 struct usb_serial_port *port;
190 unsigned int portNumber;
191 int retval;
192
193 dbg("%s", __func__);
194
195 /* get the serial object associated with this tty pointer */
196 serial = usb_serial_get_by_index(tty->index);
197 if (!serial) {
198 tty->driver_data = NULL;
199 return -ENODEV;
200 }
201
202 portNumber = tty->index - serial->minor;
203 port = serial->port[portNumber];
204 if (!port) {
205 retval = -ENODEV;
206 goto bailout_kref_put;
207 }
208
209 if (mutex_lock_interruptible(&port->mutex)) {
210 retval = -ERESTARTSYS;
211 goto bailout_kref_put;
212 }
213
214 ++port->port.count;
215
216 /* set up our port structure making the tty driver
217 * remember our port object, and us it */
218 tty->driver_data = port;
219 port->port.tty = tty;
220
221 if (port->port.count == 1) {
222
223 /* lock this module before we call it
224 * this may fail, which means we must bail out,
225 * safe because we are called with BKL held */
226 if (!try_module_get(serial->type->driver.owner)) {
227 retval = -ENODEV;
228 goto bailout_mutex_unlock;
229 }
230
231 retval = usb_autopm_get_interface(serial->interface);
232 if (retval)
233 goto bailout_module_put;
234 /* only call the device specific open if this
235 * is the first time the port is opened */
236 retval = serial->type->open(tty, port, filp);
237 if (retval)
238 goto bailout_interface_put;
239 }
240
241 mutex_unlock(&port->mutex);
242 return 0;
243
244 bailout_interface_put:
245 usb_autopm_put_interface(serial->interface);
246 bailout_module_put:
247 module_put(serial->type->driver.owner);
248 bailout_mutex_unlock:
249 port->port.count = 0;
250 tty->driver_data = NULL;
251 port->port.tty = NULL;
252 mutex_unlock(&port->mutex);
253 bailout_kref_put:
254 usb_serial_put(serial);
255 return retval;
256 }
257
258 static void serial_close(struct tty_struct *tty, struct file *filp)
259 {
260 struct usb_serial_port *port = tty->driver_data;
261
262 if (!port)
263 return;
264
265 dbg("%s - port %d", __func__, port->number);
266
267 mutex_lock(&port->mutex);
268
269 if (port->port.count == 0) {
270 mutex_unlock(&port->mutex);
271 return;
272 }
273
274 --port->port.count;
275 if (port->port.count == 0)
276 /* only call the device specific close if this
277 * port is being closed by the last owner */
278 port->serial->type->close(tty, port, filp);
279
280 if (port->port.count == (port->console? 1 : 0)) {
281 if (port->port.tty) {
282 if (port->port.tty->driver_data)
283 port->port.tty->driver_data = NULL;
284 port->port.tty = NULL;
285 }
286 }
287
288 if (port->port.count == 0) {
289 mutex_lock(&port->serial->disc_mutex);
290 if (!port->serial->disconnected)
291 usb_autopm_put_interface(port->serial->interface);
292 mutex_unlock(&port->serial->disc_mutex);
293 module_put(port->serial->type->driver.owner);
294 }
295
296 mutex_unlock(&port->mutex);
297 usb_serial_put(port->serial);
298 }
299
300 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
301 int count)
302 {
303 struct usb_serial_port *port = tty->driver_data;
304 int retval = -ENODEV;
305
306 if (port->serial->dev->state == USB_STATE_NOTATTACHED)
307 goto exit;
308
309 dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
310
311 /* count is managed under the mutex lock for the tty so cannot
312 drop to zero until after the last close completes */
313 WARN_ON(!port->port.count);
314
315 /* pass on to the driver specific version of this function */
316 retval = port->serial->type->write(tty, port, buf, count);
317
318 exit:
319 return retval;
320 }
321
322 static int serial_write_room(struct tty_struct *tty)
323 {
324 struct usb_serial_port *port = tty->driver_data;
325 dbg("%s - port %d", __func__, port->number);
326 WARN_ON(!port->port.count);
327 /* pass on to the driver specific version of this function */
328 return port->serial->type->write_room(tty);
329 }
330
331 static int serial_chars_in_buffer(struct tty_struct *tty)
332 {
333 struct usb_serial_port *port = tty->driver_data;
334 dbg("%s = port %d", __func__, port->number);
335
336 WARN_ON(!port->port.count);
337 /* pass on to the driver specific version of this function */
338 return port->serial->type->chars_in_buffer(tty);
339 }
340
341 static void serial_throttle(struct tty_struct *tty)
342 {
343 struct usb_serial_port *port = tty->driver_data;
344 dbg("%s - port %d", __func__, port->number);
345
346 WARN_ON(!port->port.count);
347 /* pass on to the driver specific version of this function */
348 if (port->serial->type->throttle)
349 port->serial->type->throttle(tty);
350 }
351
352 static void serial_unthrottle(struct tty_struct *tty)
353 {
354 struct usb_serial_port *port = tty->driver_data;
355 dbg("%s - port %d", __func__, port->number);
356
357 WARN_ON(!port->port.count);
358 /* pass on to the driver specific version of this function */
359 if (port->serial->type->unthrottle)
360 port->serial->type->unthrottle(tty);
361 }
362
363 static int serial_ioctl(struct tty_struct *tty, struct file *file,
364 unsigned int cmd, unsigned long arg)
365 {
366 struct usb_serial_port *port = tty->driver_data;
367 int retval = -ENODEV;
368
369 dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
370
371 WARN_ON(!port->port.count);
372
373 /* pass on to the driver specific version of this function
374 if it is available */
375 if (port->serial->type->ioctl) {
376 lock_kernel();
377 retval = port->serial->type->ioctl(tty, file, cmd, arg);
378 unlock_kernel();
379 } else
380 retval = -ENOIOCTLCMD;
381 return retval;
382 }
383
384 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
385 {
386 struct usb_serial_port *port = tty->driver_data;
387 dbg("%s - port %d", __func__, port->number);
388
389 WARN_ON(!port->port.count);
390 /* pass on to the driver specific version of this function
391 if it is available */
392 if (port->serial->type->set_termios)
393 port->serial->type->set_termios(tty, port, old);
394 else
395 tty_termios_copy_hw(tty->termios, old);
396 }
397
398 static void serial_break(struct tty_struct *tty, int break_state)
399 {
400 struct usb_serial_port *port = tty->driver_data;
401
402 dbg("%s - port %d", __func__, port->number);
403
404 WARN_ON(!port->port.count);
405 /* pass on to the driver specific version of this function
406 if it is available */
407 if (port->serial->type->break_ctl) {
408 lock_kernel();
409 port->serial->type->break_ctl(tty, break_state);
410 unlock_kernel();
411 }
412 }
413
414 static int serial_read_proc(char *page, char **start, off_t off, int count,
415 int *eof, void *data)
416 {
417 struct usb_serial *serial;
418 int length = 0;
419 int i;
420 off_t begin = 0;
421 char tmp[40];
422
423 dbg("%s", __func__);
424 length += sprintf(page, "usbserinfo:1.0 driver:2.0\n");
425 for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
426 serial = usb_serial_get_by_index(i);
427 if (serial == NULL)
428 continue;
429
430 length += sprintf(page+length, "%d:", i);
431 if (serial->type->driver.owner)
432 length += sprintf(page+length, " module:%s",
433 module_name(serial->type->driver.owner));
434 length += sprintf(page+length, " name:\"%s\"",
435 serial->type->description);
436 length += sprintf(page+length, " vendor:%04x product:%04x",
437 le16_to_cpu(serial->dev->descriptor.idVendor),
438 le16_to_cpu(serial->dev->descriptor.idProduct));
439 length += sprintf(page+length, " num_ports:%d",
440 serial->num_ports);
441 length += sprintf(page+length, " port:%d",
442 i - serial->minor + 1);
443 usb_make_path(serial->dev, tmp, sizeof(tmp));
444 length += sprintf(page+length, " path:%s", tmp);
445
446 length += sprintf(page+length, "\n");
447 if ((length + begin) > (off + count)) {
448 usb_serial_put(serial);
449 goto done;
450 }
451 if ((length + begin) < off) {
452 begin += length;
453 length = 0;
454 }
455 usb_serial_put(serial);
456 }
457 *eof = 1;
458 done:
459 if (off >= (length + begin))
460 return 0;
461 *start = page + (off-begin);
462 return (count < begin+length-off) ? count : begin+length-off;
463 }
464
465 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
466 {
467 struct usb_serial_port *port = tty->driver_data;
468
469 dbg("%s - port %d", __func__, port->number);
470
471 WARN_ON(!port->port.count);
472 if (port->serial->type->tiocmget)
473 return port->serial->type->tiocmget(tty, file);
474 return -EINVAL;
475 }
476
477 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
478 unsigned int set, unsigned int clear)
479 {
480 struct usb_serial_port *port = tty->driver_data;
481
482 dbg("%s - port %d", __func__, port->number);
483
484 WARN_ON(!port->port.count);
485 if (port->serial->type->tiocmset)
486 return port->serial->type->tiocmset(tty, file, set, clear);
487 return -EINVAL;
488 }
489
490 /*
491 * We would be calling tty_wakeup here, but unfortunately some line
492 * disciplines have an annoying habit of calling tty->write from
493 * the write wakeup callback (e.g. n_hdlc.c).
494 */
495 void usb_serial_port_softint(struct usb_serial_port *port)
496 {
497 schedule_work(&port->work);
498 }
499 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
500
501 static void usb_serial_port_work(struct work_struct *work)
502 {
503 struct usb_serial_port *port =
504 container_of(work, struct usb_serial_port, work);
505 struct tty_struct *tty;
506
507 dbg("%s - port %d", __func__, port->number);
508
509 if (!port)
510 return;
511
512 tty = port->port.tty;
513 if (!tty)
514 return;
515
516 tty_wakeup(tty);
517 }
518
519 static void port_release(struct device *dev)
520 {
521 struct usb_serial_port *port = to_usb_serial_port(dev);
522
523 dbg ("%s - %s", __func__, dev_name(dev));
524 port_free(port);
525 }
526
527 static void kill_traffic(struct usb_serial_port *port)
528 {
529 usb_kill_urb(port->read_urb);
530 usb_kill_urb(port->write_urb);
531 /*
532 * This is tricky.
533 * Some drivers submit the read_urb in the
534 * handler for the write_urb or vice versa
535 * this order determines the order in which
536 * usb_kill_urb() must be used to reliably
537 * kill the URBs. As it is unknown here,
538 * both orders must be used in turn.
539 * The call below is not redundant.
540 */
541 usb_kill_urb(port->read_urb);
542 usb_kill_urb(port->interrupt_in_urb);
543 usb_kill_urb(port->interrupt_out_urb);
544 }
545
546 static void port_free(struct usb_serial_port *port)
547 {
548 kill_traffic(port);
549 usb_free_urb(port->read_urb);
550 usb_free_urb(port->write_urb);
551 usb_free_urb(port->interrupt_in_urb);
552 usb_free_urb(port->interrupt_out_urb);
553 kfree(port->bulk_in_buffer);
554 kfree(port->bulk_out_buffer);
555 kfree(port->interrupt_in_buffer);
556 kfree(port->interrupt_out_buffer);
557 flush_scheduled_work(); /* port->work */
558 kfree(port);
559 }
560
561 static struct usb_serial *create_serial(struct usb_device *dev,
562 struct usb_interface *interface,
563 struct usb_serial_driver *driver)
564 {
565 struct usb_serial *serial;
566
567 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
568 if (!serial) {
569 dev_err(&dev->dev, "%s - out of memory\n", __func__);
570 return NULL;
571 }
572 serial->dev = usb_get_dev(dev);
573 serial->type = driver;
574 serial->interface = interface;
575 kref_init(&serial->kref);
576 mutex_init(&serial->disc_mutex);
577
578 return serial;
579 }
580
581 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
582 struct usb_serial_driver *drv)
583 {
584 struct usb_dynid *dynid;
585
586 spin_lock(&drv->dynids.lock);
587 list_for_each_entry(dynid, &drv->dynids.list, node) {
588 if (usb_match_one_id(intf, &dynid->id)) {
589 spin_unlock(&drv->dynids.lock);
590 return &dynid->id;
591 }
592 }
593 spin_unlock(&drv->dynids.lock);
594 return NULL;
595 }
596
597 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
598 struct usb_interface *intf)
599 {
600 const struct usb_device_id *id;
601
602 id = usb_match_id(intf, drv->id_table);
603 if (id) {
604 dbg("static descriptor matches");
605 goto exit;
606 }
607 id = match_dynamic_id(intf, drv);
608 if (id)
609 dbg("dynamic descriptor matches");
610 exit:
611 return id;
612 }
613
614 static struct usb_serial_driver *search_serial_device(
615 struct usb_interface *iface)
616 {
617 const struct usb_device_id *id;
618 struct usb_serial_driver *drv;
619
620 /* Check if the usb id matches a known device */
621 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
622 id = get_iface_id(drv, iface);
623 if (id)
624 return drv;
625 }
626
627 return NULL;
628 }
629
630 int usb_serial_probe(struct usb_interface *interface,
631 const struct usb_device_id *id)
632 {
633 struct usb_device *dev = interface_to_usbdev(interface);
634 struct usb_serial *serial = NULL;
635 struct usb_serial_port *port;
636 struct usb_host_interface *iface_desc;
637 struct usb_endpoint_descriptor *endpoint;
638 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
639 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
640 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
641 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
642 struct usb_serial_driver *type = NULL;
643 int retval;
644 unsigned int minor;
645 int buffer_size;
646 int i;
647 int num_interrupt_in = 0;
648 int num_interrupt_out = 0;
649 int num_bulk_in = 0;
650 int num_bulk_out = 0;
651 int num_ports = 0;
652 int max_endpoints;
653
654 lock_kernel(); /* guard against unloading a serial driver module */
655 type = search_serial_device(interface);
656 if (!type) {
657 unlock_kernel();
658 dbg("none matched");
659 return -ENODEV;
660 }
661
662 serial = create_serial(dev, interface, type);
663 if (!serial) {
664 unlock_kernel();
665 dev_err(&interface->dev, "%s - out of memory\n", __func__);
666 return -ENOMEM;
667 }
668
669 /* if this device type has a probe function, call it */
670 if (type->probe) {
671 const struct usb_device_id *id;
672
673 if (!try_module_get(type->driver.owner)) {
674 unlock_kernel();
675 dev_err(&interface->dev,
676 "module get failed, exiting\n");
677 kfree(serial);
678 return -EIO;
679 }
680
681 id = get_iface_id(type, interface);
682 retval = type->probe(serial, id);
683 module_put(type->driver.owner);
684
685 if (retval) {
686 unlock_kernel();
687 dbg("sub driver rejected device");
688 kfree(serial);
689 return retval;
690 }
691 }
692
693 /* descriptor matches, let's find the endpoints needed */
694 /* check out the endpoints */
695 iface_desc = interface->cur_altsetting;
696 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
697 endpoint = &iface_desc->endpoint[i].desc;
698
699 if (usb_endpoint_is_bulk_in(endpoint)) {
700 /* we found a bulk in endpoint */
701 dbg("found bulk in on endpoint %d", i);
702 bulk_in_endpoint[num_bulk_in] = endpoint;
703 ++num_bulk_in;
704 }
705
706 if (usb_endpoint_is_bulk_out(endpoint)) {
707 /* we found a bulk out endpoint */
708 dbg("found bulk out on endpoint %d", i);
709 bulk_out_endpoint[num_bulk_out] = endpoint;
710 ++num_bulk_out;
711 }
712
713 if (usb_endpoint_is_int_in(endpoint)) {
714 /* we found a interrupt in endpoint */
715 dbg("found interrupt in on endpoint %d", i);
716 interrupt_in_endpoint[num_interrupt_in] = endpoint;
717 ++num_interrupt_in;
718 }
719
720 if (usb_endpoint_is_int_out(endpoint)) {
721 /* we found an interrupt out endpoint */
722 dbg("found interrupt out on endpoint %d", i);
723 interrupt_out_endpoint[num_interrupt_out] = endpoint;
724 ++num_interrupt_out;
725 }
726 }
727
728 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
729 /* BEGIN HORRIBLE HACK FOR PL2303 */
730 /* this is needed due to the looney way its endpoints are set up */
731 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
732 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
733 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
734 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
735 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
736 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID))) {
737 if (interface != dev->actconfig->interface[0]) {
738 /* check out the endpoints of the other interface*/
739 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
740 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
741 endpoint = &iface_desc->endpoint[i].desc;
742 if (usb_endpoint_is_int_in(endpoint)) {
743 /* we found a interrupt in endpoint */
744 dbg("found interrupt in for Prolific device on separate interface");
745 interrupt_in_endpoint[num_interrupt_in] = endpoint;
746 ++num_interrupt_in;
747 }
748 }
749 }
750
751 /* Now make sure the PL-2303 is configured correctly.
752 * If not, give up now and hope this hack will work
753 * properly during a later invocation of usb_serial_probe
754 */
755 if (num_bulk_in == 0 || num_bulk_out == 0) {
756 unlock_kernel();
757 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
758 kfree(serial);
759 return -ENODEV;
760 }
761 }
762 /* END HORRIBLE HACK FOR PL2303 */
763 #endif
764
765 #ifdef CONFIG_USB_SERIAL_GENERIC
766 if (type == &usb_serial_generic_device) {
767 num_ports = num_bulk_out;
768 if (num_ports == 0) {
769 unlock_kernel();
770 dev_err(&interface->dev,
771 "Generic device with no bulk out, not allowed.\n");
772 kfree(serial);
773 return -EIO;
774 }
775 }
776 #endif
777 if (!num_ports) {
778 /* if this device type has a calc_num_ports function, call it */
779 if (type->calc_num_ports) {
780 if (!try_module_get(type->driver.owner)) {
781 unlock_kernel();
782 dev_err(&interface->dev,
783 "module get failed, exiting\n");
784 kfree(serial);
785 return -EIO;
786 }
787 num_ports = type->calc_num_ports(serial);
788 module_put(type->driver.owner);
789 }
790 if (!num_ports)
791 num_ports = type->num_ports;
792 }
793
794 serial->num_ports = num_ports;
795 serial->num_bulk_in = num_bulk_in;
796 serial->num_bulk_out = num_bulk_out;
797 serial->num_interrupt_in = num_interrupt_in;
798 serial->num_interrupt_out = num_interrupt_out;
799
800 /* found all that we need */
801 dev_info(&interface->dev, "%s converter detected\n",
802 type->description);
803
804 /* create our ports, we need as many as the max endpoints */
805 /* we don't use num_ports here because some devices have more
806 endpoint pairs than ports */
807 max_endpoints = max(num_bulk_in, num_bulk_out);
808 max_endpoints = max(max_endpoints, num_interrupt_in);
809 max_endpoints = max(max_endpoints, num_interrupt_out);
810 max_endpoints = max(max_endpoints, (int)serial->num_ports);
811 serial->num_port_pointers = max_endpoints;
812 unlock_kernel();
813
814 dbg("%s - setting up %d port structures for this device",
815 __func__, max_endpoints);
816 for (i = 0; i < max_endpoints; ++i) {
817 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
818 if (!port)
819 goto probe_error;
820 port->serial = serial;
821 spin_lock_init(&port->lock);
822 mutex_init(&port->mutex);
823 INIT_WORK(&port->work, usb_serial_port_work);
824 serial->port[i] = port;
825 }
826
827 /* set up the endpoint information */
828 for (i = 0; i < num_bulk_in; ++i) {
829 endpoint = bulk_in_endpoint[i];
830 port = serial->port[i];
831 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
832 if (!port->read_urb) {
833 dev_err(&interface->dev, "No free urbs available\n");
834 goto probe_error;
835 }
836 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
837 port->bulk_in_size = buffer_size;
838 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
839 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
840 if (!port->bulk_in_buffer) {
841 dev_err(&interface->dev,
842 "Couldn't allocate bulk_in_buffer\n");
843 goto probe_error;
844 }
845 usb_fill_bulk_urb(port->read_urb, dev,
846 usb_rcvbulkpipe(dev,
847 endpoint->bEndpointAddress),
848 port->bulk_in_buffer, buffer_size,
849 serial->type->read_bulk_callback, port);
850 }
851
852 for (i = 0; i < num_bulk_out; ++i) {
853 endpoint = bulk_out_endpoint[i];
854 port = serial->port[i];
855 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
856 if (!port->write_urb) {
857 dev_err(&interface->dev, "No free urbs available\n");
858 goto probe_error;
859 }
860 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
861 port->bulk_out_size = buffer_size;
862 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
863 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
864 if (!port->bulk_out_buffer) {
865 dev_err(&interface->dev,
866 "Couldn't allocate bulk_out_buffer\n");
867 goto probe_error;
868 }
869 usb_fill_bulk_urb(port->write_urb, dev,
870 usb_sndbulkpipe(dev,
871 endpoint->bEndpointAddress),
872 port->bulk_out_buffer, buffer_size,
873 serial->type->write_bulk_callback, port);
874 }
875
876 if (serial->type->read_int_callback) {
877 for (i = 0; i < num_interrupt_in; ++i) {
878 endpoint = interrupt_in_endpoint[i];
879 port = serial->port[i];
880 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
881 if (!port->interrupt_in_urb) {
882 dev_err(&interface->dev,
883 "No free urbs available\n");
884 goto probe_error;
885 }
886 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
887 port->interrupt_in_endpointAddress =
888 endpoint->bEndpointAddress;
889 port->interrupt_in_buffer = kmalloc(buffer_size,
890 GFP_KERNEL);
891 if (!port->interrupt_in_buffer) {
892 dev_err(&interface->dev,
893 "Couldn't allocate interrupt_in_buffer\n");
894 goto probe_error;
895 }
896 usb_fill_int_urb(port->interrupt_in_urb, dev,
897 usb_rcvintpipe(dev,
898 endpoint->bEndpointAddress),
899 port->interrupt_in_buffer, buffer_size,
900 serial->type->read_int_callback, port,
901 endpoint->bInterval);
902 }
903 } else if (num_interrupt_in) {
904 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
905 }
906
907 if (serial->type->write_int_callback) {
908 for (i = 0; i < num_interrupt_out; ++i) {
909 endpoint = interrupt_out_endpoint[i];
910 port = serial->port[i];
911 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
912 if (!port->interrupt_out_urb) {
913 dev_err(&interface->dev,
914 "No free urbs available\n");
915 goto probe_error;
916 }
917 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
918 port->interrupt_out_size = buffer_size;
919 port->interrupt_out_endpointAddress =
920 endpoint->bEndpointAddress;
921 port->interrupt_out_buffer = kmalloc(buffer_size,
922 GFP_KERNEL);
923 if (!port->interrupt_out_buffer) {
924 dev_err(&interface->dev,
925 "Couldn't allocate interrupt_out_buffer\n");
926 goto probe_error;
927 }
928 usb_fill_int_urb(port->interrupt_out_urb, dev,
929 usb_sndintpipe(dev,
930 endpoint->bEndpointAddress),
931 port->interrupt_out_buffer, buffer_size,
932 serial->type->write_int_callback, port,
933 endpoint->bInterval);
934 }
935 } else if (num_interrupt_out) {
936 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
937 }
938
939 /* if this device type has an attach function, call it */
940 if (type->attach) {
941 if (!try_module_get(type->driver.owner)) {
942 dev_err(&interface->dev,
943 "module get failed, exiting\n");
944 goto probe_error;
945 }
946 retval = type->attach(serial);
947 module_put(type->driver.owner);
948 if (retval < 0)
949 goto probe_error;
950 if (retval > 0) {
951 /* quietly accept this device, but don't bind to a
952 serial port as it's about to disappear */
953 goto exit;
954 }
955 }
956
957 if (get_free_serial(serial, num_ports, &minor) == NULL) {
958 dev_err(&interface->dev, "No more free serial devices\n");
959 goto probe_error;
960 }
961 serial->minor = minor;
962
963 /* register all of the individual ports with the driver core */
964 for (i = 0; i < num_ports; ++i) {
965 port = serial->port[i];
966 port->dev.parent = &interface->dev;
967 port->dev.driver = NULL;
968 port->dev.bus = &usb_serial_bus_type;
969 port->dev.release = &port_release;
970
971 dev_set_name(&port->dev, "ttyUSB%d", port->number);
972 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
973 retval = device_register(&port->dev);
974 if (retval)
975 dev_err(&port->dev, "Error registering port device, "
976 "continuing\n");
977 }
978
979 usb_serial_console_init(debug, minor);
980
981 exit:
982 /* success */
983 usb_set_intfdata(interface, serial);
984 return 0;
985
986 probe_error:
987 for (i = 0; i < num_bulk_in; ++i) {
988 port = serial->port[i];
989 if (!port)
990 continue;
991 usb_free_urb(port->read_urb);
992 kfree(port->bulk_in_buffer);
993 }
994 for (i = 0; i < num_bulk_out; ++i) {
995 port = serial->port[i];
996 if (!port)
997 continue;
998 usb_free_urb(port->write_urb);
999 kfree(port->bulk_out_buffer);
1000 }
1001 for (i = 0; i < num_interrupt_in; ++i) {
1002 port = serial->port[i];
1003 if (!port)
1004 continue;
1005 usb_free_urb(port->interrupt_in_urb);
1006 kfree(port->interrupt_in_buffer);
1007 }
1008 for (i = 0; i < num_interrupt_out; ++i) {
1009 port = serial->port[i];
1010 if (!port)
1011 continue;
1012 usb_free_urb(port->interrupt_out_urb);
1013 kfree(port->interrupt_out_buffer);
1014 }
1015
1016 /* free up any memory that we allocated */
1017 for (i = 0; i < serial->num_port_pointers; ++i)
1018 kfree(serial->port[i]);
1019 kfree(serial);
1020 return -EIO;
1021 }
1022 EXPORT_SYMBOL_GPL(usb_serial_probe);
1023
1024 void usb_serial_disconnect(struct usb_interface *interface)
1025 {
1026 int i;
1027 struct usb_serial *serial = usb_get_intfdata(interface);
1028 struct device *dev = &interface->dev;
1029 struct usb_serial_port *port;
1030
1031 usb_serial_console_disconnect(serial);
1032 dbg("%s", __func__);
1033
1034 mutex_lock(&serial->disc_mutex);
1035 usb_set_intfdata(interface, NULL);
1036 /* must set a flag, to signal subdrivers */
1037 serial->disconnected = 1;
1038 for (i = 0; i < serial->num_ports; ++i) {
1039 port = serial->port[i];
1040 if (port) {
1041 if (port->port.tty)
1042 tty_hangup(port->port.tty);
1043 kill_traffic(port);
1044 }
1045 }
1046 /* let the last holder of this object
1047 * cause it to be cleaned up */
1048 mutex_unlock(&serial->disc_mutex);
1049 usb_serial_put(serial);
1050 dev_info(dev, "device disconnected\n");
1051 }
1052 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1053
1054 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1055 {
1056 struct usb_serial *serial = usb_get_intfdata(intf);
1057 struct usb_serial_port *port;
1058 int i, r = 0;
1059
1060 for (i = 0; i < serial->num_ports; ++i) {
1061 port = serial->port[i];
1062 if (port)
1063 kill_traffic(port);
1064 }
1065
1066 if (serial->type->suspend)
1067 r = serial->type->suspend(serial, message);
1068
1069 return r;
1070 }
1071 EXPORT_SYMBOL(usb_serial_suspend);
1072
1073 int usb_serial_resume(struct usb_interface *intf)
1074 {
1075 struct usb_serial *serial = usb_get_intfdata(intf);
1076
1077 if (serial->type->resume)
1078 return serial->type->resume(serial);
1079 return 0;
1080 }
1081 EXPORT_SYMBOL(usb_serial_resume);
1082
1083 static const struct tty_operations serial_ops = {
1084 .open = serial_open,
1085 .close = serial_close,
1086 .write = serial_write,
1087 .write_room = serial_write_room,
1088 .ioctl = serial_ioctl,
1089 .set_termios = serial_set_termios,
1090 .throttle = serial_throttle,
1091 .unthrottle = serial_unthrottle,
1092 .break_ctl = serial_break,
1093 .chars_in_buffer = serial_chars_in_buffer,
1094 .read_proc = serial_read_proc,
1095 .tiocmget = serial_tiocmget,
1096 .tiocmset = serial_tiocmset,
1097 };
1098
1099 struct tty_driver *usb_serial_tty_driver;
1100
1101 static int __init usb_serial_init(void)
1102 {
1103 int i;
1104 int result;
1105
1106 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1107 if (!usb_serial_tty_driver)
1108 return -ENOMEM;
1109
1110 /* Initialize our global data */
1111 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1112 serial_table[i] = NULL;
1113
1114 result = bus_register(&usb_serial_bus_type);
1115 if (result) {
1116 err("%s - registering bus driver failed", __func__);
1117 goto exit_bus;
1118 }
1119
1120 usb_serial_tty_driver->owner = THIS_MODULE;
1121 usb_serial_tty_driver->driver_name = "usbserial";
1122 usb_serial_tty_driver->name = "ttyUSB";
1123 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1124 usb_serial_tty_driver->minor_start = 0;
1125 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1126 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1127 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1128 TTY_DRIVER_DYNAMIC_DEV;
1129 usb_serial_tty_driver->init_termios = tty_std_termios;
1130 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1131 | HUPCL | CLOCAL;
1132 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1133 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1134 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1135 result = tty_register_driver(usb_serial_tty_driver);
1136 if (result) {
1137 err("%s - tty_register_driver failed", __func__);
1138 goto exit_reg_driver;
1139 }
1140
1141 /* register the USB driver */
1142 result = usb_register(&usb_serial_driver);
1143 if (result < 0) {
1144 err("%s - usb_register failed", __func__);
1145 goto exit_tty;
1146 }
1147
1148 /* register the generic driver, if we should */
1149 result = usb_serial_generic_register(debug);
1150 if (result < 0) {
1151 err("%s - registering generic driver failed", __func__);
1152 goto exit_generic;
1153 }
1154
1155 info(DRIVER_DESC);
1156
1157 return result;
1158
1159 exit_generic:
1160 usb_deregister(&usb_serial_driver);
1161
1162 exit_tty:
1163 tty_unregister_driver(usb_serial_tty_driver);
1164
1165 exit_reg_driver:
1166 bus_unregister(&usb_serial_bus_type);
1167
1168 exit_bus:
1169 err("%s - returning with error %d", __func__, result);
1170 put_tty_driver(usb_serial_tty_driver);
1171 return result;
1172 }
1173
1174
1175 static void __exit usb_serial_exit(void)
1176 {
1177 usb_serial_console_exit();
1178
1179 usb_serial_generic_deregister();
1180
1181 usb_deregister(&usb_serial_driver);
1182 tty_unregister_driver(usb_serial_tty_driver);
1183 put_tty_driver(usb_serial_tty_driver);
1184 bus_unregister(&usb_serial_bus_type);
1185 }
1186
1187
1188 module_init(usb_serial_init);
1189 module_exit(usb_serial_exit);
1190
1191 #define set_to_generic_if_null(type, function) \
1192 do { \
1193 if (!type->function) { \
1194 type->function = usb_serial_generic_##function; \
1195 dbg("Had to override the " #function \
1196 " usb serial operation with the generic one.");\
1197 } \
1198 } while (0)
1199
1200 static void fixup_generic(struct usb_serial_driver *device)
1201 {
1202 set_to_generic_if_null(device, open);
1203 set_to_generic_if_null(device, write);
1204 set_to_generic_if_null(device, close);
1205 set_to_generic_if_null(device, write_room);
1206 set_to_generic_if_null(device, chars_in_buffer);
1207 set_to_generic_if_null(device, read_bulk_callback);
1208 set_to_generic_if_null(device, write_bulk_callback);
1209 set_to_generic_if_null(device, shutdown);
1210 set_to_generic_if_null(device, resume);
1211 }
1212
1213 int usb_serial_register(struct usb_serial_driver *driver)
1214 {
1215 /* must be called with BKL held */
1216 int retval;
1217
1218 fixup_generic(driver);
1219
1220 if (!driver->description)
1221 driver->description = driver->driver.name;
1222
1223 /* Add this device to our list of devices */
1224 list_add(&driver->driver_list, &usb_serial_driver_list);
1225
1226 retval = usb_serial_bus_register(driver);
1227 if (retval) {
1228 err("problem %d when registering driver %s",
1229 retval, driver->description);
1230 list_del(&driver->driver_list);
1231 } else
1232 info("USB Serial support registered for %s",
1233 driver->description);
1234
1235 return retval;
1236 }
1237 EXPORT_SYMBOL_GPL(usb_serial_register);
1238
1239
1240 void usb_serial_deregister(struct usb_serial_driver *device)
1241 {
1242 /* must be called with BKL held */
1243 info("USB Serial deregistering driver %s", device->description);
1244 list_del(&device->driver_list);
1245 usb_serial_bus_deregister(device);
1246 }
1247 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1248
1249 /* Module information */
1250 MODULE_AUTHOR(DRIVER_AUTHOR);
1251 MODULE_DESCRIPTION(DRIVER_DESC);
1252 MODULE_LICENSE("GPL");
1253
1254 module_param(debug, bool, S_IRUGO | S_IWUSR);
1255 MODULE_PARM_DESC(debug, "Debug enabled or not");
SocketAccessConTroL development