?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
USB: fix bug in serial driver unregistration
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / serial / usb-serial.c
blob5413bd50078101b6de6333ca5a7256ad6d1dc36d
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/seq_file.h>
30 #include <linux/spinlock.h>
31 #include <linux/mutex.h>
32 #include <linux/list.h>
33 #include <linux/uaccess.h>
34 #include <linux/serial.h>
35 #include <linux/usb.h>
36 #include <linux/usb/serial.h>
37 #include <linux/kfifo.h>
38 #include "pl2303.h"
39
40 /*
41 * Version Information
42 */
43 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
44 #define DRIVER_DESC "USB Serial Driver core"
45
46 /* Driver structure we register with the USB core */
47 static struct usb_driver usb_serial_driver = {
48 .name = "usbserial",
49 .probe = usb_serial_probe,
50 .disconnect = usb_serial_disconnect,
51 .suspend = usb_serial_suspend,
52 .resume = usb_serial_resume,
53 .no_dynamic_id = 1,
54 .supports_autosuspend = 1,
55 };
56
57 /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
58 the MODULE_DEVICE_TABLE declarations in each serial driver
59 cause the "hotplug" program to pull in whatever module is necessary
60 via modprobe, and modprobe will load usbserial because the serial
61 drivers depend on it.
62 */
63
64 static bool debug;
65 /* initially all NULL */
66 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
67 static DEFINE_MUTEX(table_lock);
68 static LIST_HEAD(usb_serial_driver_list);
69
70 /*
71 * Look up the serial structure. If it is found and it hasn't been
72 * disconnected, return with its disc_mutex held and its refcount
73 * incremented. Otherwise return NULL.
74 */
75 struct usb_serial *usb_serial_get_by_index(unsigned index)
76 {
77 struct usb_serial *serial;
78
79 mutex_lock(&table_lock);
80 serial = serial_table[index];
81
82 if (serial) {
83 mutex_lock(&serial->disc_mutex);
84 if (serial->disconnected) {
85 mutex_unlock(&serial->disc_mutex);
86 serial = NULL;
87 } else {
88 kref_get(&serial->kref);
89 }
90 }
91 mutex_unlock(&table_lock);
92 return serial;
93 }
94
95 static struct usb_serial *get_free_serial(struct usb_serial *serial,
96 int num_ports, unsigned int *minor)
97 {
98 unsigned int i, j;
99 int good_spot;
100
101 dbg("%s %d", __func__, num_ports);
102
103 *minor = 0;
104 mutex_lock(&table_lock);
105 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
106 if (serial_table[i])
107 continue;
108
109 good_spot = 1;
110 for (j = 1; j <= num_ports-1; ++j)
111 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
112 good_spot = 0;
113 i += j;
114 break;
115 }
116 if (good_spot == 0)
117 continue;
118
119 *minor = i;
120 j = 0;
121 dbg("%s - minor base = %d", __func__, *minor);
122 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
123 serial_table[i] = serial;
124 serial->port[j++]->number = i;
125 }
126 mutex_unlock(&table_lock);
127 return serial;
128 }
129 mutex_unlock(&table_lock);
130 return NULL;
131 }
132
133 static void return_serial(struct usb_serial *serial)
134 {
135 int i;
136
137 dbg("%s", __func__);
138
139 mutex_lock(&table_lock);
140 for (i = 0; i < serial->num_ports; ++i)
141 serial_table[serial->minor + i] = NULL;
142 mutex_unlock(&table_lock);
143 }
144
145 static void destroy_serial(struct kref *kref)
146 {
147 struct usb_serial *serial;
148 struct usb_serial_port *port;
149 int i;
150
151 serial = to_usb_serial(kref);
152
153 dbg("%s - %s", __func__, serial->type->description);
154
155 /* return the minor range that this device had */
156 if (serial->minor != SERIAL_TTY_NO_MINOR)
157 return_serial(serial);
158
159 if (serial->attached)
160 serial->type->release(serial);
161
162 /* Now that nothing is using the ports, they can be freed */
163 for (i = 0; i < serial->num_port_pointers; ++i) {
164 port = serial->port[i];
165 if (port) {
166 port->serial = NULL;
167 put_device(&port->dev);
168 }
169 }
170
171 usb_put_dev(serial->dev);
172 kfree(serial);
173 }
174
175 void usb_serial_put(struct usb_serial *serial)
176 {
177 kref_put(&serial->kref, destroy_serial);
178 }
179
180 /*****************************************************************************
181 * Driver tty interface functions
182 *****************************************************************************/
183
184 /**
185 * serial_install - install tty
186 * @driver: the driver (USB in our case)
187 * @tty: the tty being created
188 *
189 * Create the termios objects for this tty. We use the default
190 * USB serial settings but permit them to be overridden by
191 * serial->type->init_termios.
192 *
193 * This is the first place a new tty gets used. Hence this is where we
194 * acquire references to the usb_serial structure and the driver module,
195 * where we store a pointer to the port, and where we do an autoresume.
196 * All these actions are reversed in serial_cleanup().
197 */
198 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
199 {
200 int idx = tty->index;
201 struct usb_serial *serial;
202 struct usb_serial_port *port;
203 int retval = -ENODEV;
204
205 dbg("%s", __func__);
206
207 serial = usb_serial_get_by_index(idx);
208 if (!serial)
209 return retval;
210
211 port = serial->port[idx - serial->minor];
212 if (!port)
213 goto error_no_port;
214 if (!try_module_get(serial->type->driver.owner))
215 goto error_module_get;
216
217 retval = usb_autopm_get_interface(serial->interface);
218 if (retval)
219 goto error_get_interface;
220
221 retval = tty_standard_install(driver, tty);
222 if (retval)
223 goto error_init_termios;
224
225 mutex_unlock(&serial->disc_mutex);
226
227 /* allow the driver to update the settings */
228 if (serial->type->init_termios)
229 serial->type->init_termios(tty);
230
231 tty->driver_data = port;
232
233 return retval;
234
235 error_init_termios:
236 usb_autopm_put_interface(serial->interface);
237 error_get_interface:
238 module_put(serial->type->driver.owner);
239 error_module_get:
240 error_no_port:
241 usb_serial_put(serial);
242 mutex_unlock(&serial->disc_mutex);
243 return retval;
244 }
245
246 static int serial_activate(struct tty_port *tport, struct tty_struct *tty)
247 {
248 struct usb_serial_port *port =
249 container_of(tport, struct usb_serial_port, port);
250 struct usb_serial *serial = port->serial;
251 int retval;
252
253 mutex_lock(&serial->disc_mutex);
254 if (serial->disconnected)
255 retval = -ENODEV;
256 else
257 retval = port->serial->type->open(tty, port);
258 mutex_unlock(&serial->disc_mutex);
259
260 if (retval < 0)
261 retval = usb_translate_errors(retval);
262
263 return retval;
264 }
265
266 static int serial_open(struct tty_struct *tty, struct file *filp)
267 {
268 struct usb_serial_port *port = tty->driver_data;
269
270 dbg("%s - port %d", __func__, port->number);
271 return tty_port_open(&port->port, tty, filp);
272 }
273
274 /**
275 * serial_down - shut down hardware
276 * @tport: tty port to shut down
277 *
278 * Shut down a USB serial port unless it is the console. We never
279 * shut down the console hardware as it will always be in use. Serialized
280 * against activate by the tport mutex and kept to matching open/close pairs
281 * of calls by the ASYNCB_INITIALIZED flag.
282 */
283 static void serial_down(struct tty_port *tport)
284 {
285 struct usb_serial_port *port =
286 container_of(tport, struct usb_serial_port, port);
287 struct usb_serial_driver *drv = port->serial->type;
288 /*
289 * The console is magical. Do not hang up the console hardware
290 * or there will be tears.
291 */
292 if (port->port.console)
293 return;
294 if (drv->close)
295 drv->close(port);
296 }
297
298 static void serial_hangup(struct tty_struct *tty)
299 {
300 struct usb_serial_port *port = tty->driver_data;
301 dbg("%s - port %d", __func__, port->number);
302 tty_port_hangup(&port->port);
303 }
304
305 static void serial_close(struct tty_struct *tty, struct file *filp)
306 {
307 struct usb_serial_port *port = tty->driver_data;
308 dbg("%s - port %d", __func__, port->number);
309 tty_port_close(&port->port, tty, filp);
310 }
311
312 /**
313 * serial_cleanup - free resources post close/hangup
314 * @port: port to free up
315 *
316 * Do the resource freeing and refcount dropping for the port.
317 * Avoid freeing the console.
318 *
319 * Called asynchronously after the last tty kref is dropped,
320 * and the tty layer has already done the tty_shutdown(tty);
321 */
322 static void serial_cleanup(struct tty_struct *tty)
323 {
324 struct usb_serial_port *port = tty->driver_data;
325 struct usb_serial *serial;
326 struct module *owner;
327
328 /* The console is magical. Do not hang up the console hardware
329 * or there will be tears.
330 */
331 if (port->port.console)
332 return;
333
334 dbg("%s - port %d", __func__, port->number);
335
336 tty->driver_data = NULL;
337
338 serial = port->serial;
339 owner = serial->type->driver.owner;
340
341 mutex_lock(&serial->disc_mutex);
342 if (!serial->disconnected)
343 usb_autopm_put_interface(serial->interface);
344 mutex_unlock(&serial->disc_mutex);
345
346 usb_serial_put(serial);
347 module_put(owner);
348 }
349
350 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
351 int count)
352 {
353 struct usb_serial_port *port = tty->driver_data;
354 int retval = -ENODEV;
355
356 if (port->serial->dev->state == USB_STATE_NOTATTACHED)
357 goto exit;
358
359 dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
360
361 /* pass on to the driver specific version of this function */
362 retval = port->serial->type->write(tty, port, buf, count);
363 if (retval < 0)
364 retval = usb_translate_errors(retval);
365 exit:
366 return retval;
367 }
368
369 static int serial_write_room(struct tty_struct *tty)
370 {
371 struct usb_serial_port *port = tty->driver_data;
372 dbg("%s - port %d", __func__, port->number);
373 /* pass on to the driver specific version of this function */
374 return port->serial->type->write_room(tty);
375 }
376
377 static int serial_chars_in_buffer(struct tty_struct *tty)
378 {
379 struct usb_serial_port *port = tty->driver_data;
380 dbg("%s - port %d", __func__, port->number);
381
382 /* if the device was unplugged then any remaining characters
383 fell out of the connector ;) */
384 if (port->serial->disconnected)
385 return 0;
386 /* pass on to the driver specific version of this function */
387 return port->serial->type->chars_in_buffer(tty);
388 }
389
390 static void serial_throttle(struct tty_struct *tty)
391 {
392 struct usb_serial_port *port = tty->driver_data;
393 dbg("%s - port %d", __func__, port->number);
394
395 /* pass on to the driver specific version of this function */
396 if (port->serial->type->throttle)
397 port->serial->type->throttle(tty);
398 }
399
400 static void serial_unthrottle(struct tty_struct *tty)
401 {
402 struct usb_serial_port *port = tty->driver_data;
403 dbg("%s - port %d", __func__, port->number);
404
405 /* pass on to the driver specific version of this function */
406 if (port->serial->type->unthrottle)
407 port->serial->type->unthrottle(tty);
408 }
409
410 static int serial_ioctl(struct tty_struct *tty,
411 unsigned int cmd, unsigned long arg)
412 {
413 struct usb_serial_port *port = tty->driver_data;
414 int retval = -ENODEV;
415
416 dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
417
418 /* pass on to the driver specific version of this function
419 if it is available */
420 if (port->serial->type->ioctl) {
421 retval = port->serial->type->ioctl(tty, cmd, arg);
422 } else
423 retval = -ENOIOCTLCMD;
424 return retval;
425 }
426
427 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
428 {
429 struct usb_serial_port *port = tty->driver_data;
430 dbg("%s - port %d", __func__, port->number);
431
432 /* pass on to the driver specific version of this function
433 if it is available */
434 if (port->serial->type->set_termios)
435 port->serial->type->set_termios(tty, port, old);
436 else
437 tty_termios_copy_hw(tty->termios, old);
438 }
439
440 static int serial_break(struct tty_struct *tty, int break_state)
441 {
442 struct usb_serial_port *port = tty->driver_data;
443
444 dbg("%s - port %d", __func__, port->number);
445
446 /* pass on to the driver specific version of this function
447 if it is available */
448 if (port->serial->type->break_ctl)
449 port->serial->type->break_ctl(tty, break_state);
450 return 0;
451 }
452
453 static int serial_proc_show(struct seq_file *m, void *v)
454 {
455 struct usb_serial *serial;
456 int i;
457 char tmp[40];
458
459 dbg("%s", __func__);
460 seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
461 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
462 serial = usb_serial_get_by_index(i);
463 if (serial == NULL)
464 continue;
465
466 seq_printf(m, "%d:", i);
467 if (serial->type->driver.owner)
468 seq_printf(m, " module:%s",
469 module_name(serial->type->driver.owner));
470 seq_printf(m, " name:\"%s\"",
471 serial->type->description);
472 seq_printf(m, " vendor:%04x product:%04x",
473 le16_to_cpu(serial->dev->descriptor.idVendor),
474 le16_to_cpu(serial->dev->descriptor.idProduct));
475 seq_printf(m, " num_ports:%d", serial->num_ports);
476 seq_printf(m, " port:%d", i - serial->minor + 1);
477 usb_make_path(serial->dev, tmp, sizeof(tmp));
478 seq_printf(m, " path:%s", tmp);
479
480 seq_putc(m, '\n');
481 usb_serial_put(serial);
482 mutex_unlock(&serial->disc_mutex);
483 }
484 return 0;
485 }
486
487 static int serial_proc_open(struct inode *inode, struct file *file)
488 {
489 return single_open(file, serial_proc_show, NULL);
490 }
491
492 static const struct file_operations serial_proc_fops = {
493 .owner = THIS_MODULE,
494 .open = serial_proc_open,
495 .read = seq_read,
496 .llseek = seq_lseek,
497 .release = single_release,
498 };
499
500 static int serial_tiocmget(struct tty_struct *tty)
501 {
502 struct usb_serial_port *port = tty->driver_data;
503
504 dbg("%s - port %d", __func__, port->number);
505
506 if (port->serial->type->tiocmget)
507 return port->serial->type->tiocmget(tty);
508 return -EINVAL;
509 }
510
511 static int serial_tiocmset(struct tty_struct *tty,
512 unsigned int set, unsigned int clear)
513 {
514 struct usb_serial_port *port = tty->driver_data;
515
516 dbg("%s - port %d", __func__, port->number);
517
518 if (port->serial->type->tiocmset)
519 return port->serial->type->tiocmset(tty, set, clear);
520 return -EINVAL;
521 }
522
523 static int serial_get_icount(struct tty_struct *tty,
524 struct serial_icounter_struct *icount)
525 {
526 struct usb_serial_port *port = tty->driver_data;
527
528 dbg("%s - port %d", __func__, port->number);
529
530 if (port->serial->type->get_icount)
531 return port->serial->type->get_icount(tty, icount);
532 return -EINVAL;
533 }
534
535 /*
536 * We would be calling tty_wakeup here, but unfortunately some line
537 * disciplines have an annoying habit of calling tty->write from
538 * the write wakeup callback (e.g. n_hdlc.c).
539 */
540 void usb_serial_port_softint(struct usb_serial_port *port)
541 {
542 schedule_work(&port->work);
543 }
544 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
545
546 static void usb_serial_port_work(struct work_struct *work)
547 {
548 struct usb_serial_port *port =
549 container_of(work, struct usb_serial_port, work);
550 struct tty_struct *tty;
551
552 dbg("%s - port %d", __func__, port->number);
553
554 tty = tty_port_tty_get(&port->port);
555 if (!tty)
556 return;
557
558 tty_wakeup(tty);
559 tty_kref_put(tty);
560 }
561
562 static void kill_traffic(struct usb_serial_port *port)
563 {
564 int i;
565
566 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
567 usb_kill_urb(port->read_urbs[i]);
568 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
569 usb_kill_urb(port->write_urbs[i]);
570 /*
571 * This is tricky.
572 * Some drivers submit the read_urb in the
573 * handler for the write_urb or vice versa
574 * this order determines the order in which
575 * usb_kill_urb() must be used to reliably
576 * kill the URBs. As it is unknown here,
577 * both orders must be used in turn.
578 * The call below is not redundant.
579 */
580 usb_kill_urb(port->read_urb);
581 usb_kill_urb(port->interrupt_in_urb);
582 usb_kill_urb(port->interrupt_out_urb);
583 }
584
585 static void port_release(struct device *dev)
586 {
587 struct usb_serial_port *port = to_usb_serial_port(dev);
588 int i;
589
590 dbg ("%s - %s", __func__, dev_name(dev));
591
592 /*
593 * Stop all the traffic before cancelling the work, so that
594 * nobody will restart it by calling usb_serial_port_softint.
595 */
596 kill_traffic(port);
597 cancel_work_sync(&port->work);
598
599 usb_free_urb(port->interrupt_in_urb);
600 usb_free_urb(port->interrupt_out_urb);
601 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
602 usb_free_urb(port->read_urbs[i]);
603 kfree(port->bulk_in_buffers[i]);
604 }
605 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
606 usb_free_urb(port->write_urbs[i]);
607 kfree(port->bulk_out_buffers[i]);
608 }
609 kfifo_free(&port->write_fifo);
610 kfree(port->interrupt_in_buffer);
611 kfree(port->interrupt_out_buffer);
612 kfree(port);
613 }
614
615 static struct usb_serial *create_serial(struct usb_device *dev,
616 struct usb_interface *interface,
617 struct usb_serial_driver *driver)
618 {
619 struct usb_serial *serial;
620
621 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
622 if (!serial) {
623 dev_err(&dev->dev, "%s - out of memory\n", __func__);
624 return NULL;
625 }
626 serial->dev = usb_get_dev(dev);
627 serial->type = driver;
628 serial->interface = interface;
629 kref_init(&serial->kref);
630 mutex_init(&serial->disc_mutex);
631 serial->minor = SERIAL_TTY_NO_MINOR;
632
633 return serial;
634 }
635
636 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
637 struct usb_serial_driver *drv)
638 {
639 struct usb_dynid *dynid;
640
641 spin_lock(&drv->dynids.lock);
642 list_for_each_entry(dynid, &drv->dynids.list, node) {
643 if (usb_match_one_id(intf, &dynid->id)) {
644 spin_unlock(&drv->dynids.lock);
645 return &dynid->id;
646 }
647 }
648 spin_unlock(&drv->dynids.lock);
649 return NULL;
650 }
651
652 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
653 struct usb_interface *intf)
654 {
655 const struct usb_device_id *id;
656
657 id = usb_match_id(intf, drv->id_table);
658 if (id) {
659 dbg("static descriptor matches");
660 goto exit;
661 }
662 id = match_dynamic_id(intf, drv);
663 if (id)
664 dbg("dynamic descriptor matches");
665 exit:
666 return id;
667 }
668
669 /* Caller must hold table_lock */
670 static struct usb_serial_driver *search_serial_device(
671 struct usb_interface *iface)
672 {
673 const struct usb_device_id *id;
674 struct usb_serial_driver *drv;
675
676 /* Check if the usb id matches a known device */
677 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
678 id = get_iface_id(drv, iface);
679 if (id)
680 return drv;
681 }
682
683 return NULL;
684 }
685
686 static int serial_carrier_raised(struct tty_port *port)
687 {
688 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
689 struct usb_serial_driver *drv = p->serial->type;
690
691 if (drv->carrier_raised)
692 return drv->carrier_raised(p);
693 /* No carrier control - don't block */
694 return 1;
695 }
696
697 static void serial_dtr_rts(struct tty_port *port, int on)
698 {
699 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
700 struct usb_serial_driver *drv = p->serial->type;
701
702 if (drv->dtr_rts)
703 drv->dtr_rts(p, on);
704 }
705
706 static const struct tty_port_operations serial_port_ops = {
707 .carrier_raised = serial_carrier_raised,
708 .dtr_rts = serial_dtr_rts,
709 .activate = serial_activate,
710 .shutdown = serial_down,
711 };
712
713 int usb_serial_probe(struct usb_interface *interface,
714 const struct usb_device_id *id)
715 {
716 struct usb_device *dev = interface_to_usbdev(interface);
717 struct usb_serial *serial = NULL;
718 struct usb_serial_port *port;
719 struct usb_host_interface *iface_desc;
720 struct usb_endpoint_descriptor *endpoint;
721 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
722 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
723 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
724 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
725 struct usb_serial_driver *type = NULL;
726 int retval;
727 unsigned int minor;
728 int buffer_size;
729 int i;
730 int j;
731 int num_interrupt_in = 0;
732 int num_interrupt_out = 0;
733 int num_bulk_in = 0;
734 int num_bulk_out = 0;
735 int num_ports = 0;
736 int max_endpoints;
737
738 mutex_lock(&table_lock);
739 type = search_serial_device(interface);
740 if (!type) {
741 mutex_unlock(&table_lock);
742 dbg("none matched");
743 return -ENODEV;
744 }
745
746 if (!try_module_get(type->driver.owner)) {
747 mutex_unlock(&table_lock);
748 dev_err(&interface->dev, "module get failed, exiting\n");
749 return -EIO;
750 }
751 mutex_unlock(&table_lock);
752
753 serial = create_serial(dev, interface, type);
754 if (!serial) {
755 module_put(type->driver.owner);
756 dev_err(&interface->dev, "%s - out of memory\n", __func__);
757 return -ENOMEM;
758 }
759
760 /* if this device type has a probe function, call it */
761 if (type->probe) {
762 const struct usb_device_id *id;
763
764 id = get_iface_id(type, interface);
765 retval = type->probe(serial, id);
766
767 if (retval) {
768 dbg("sub driver rejected device");
769 kfree(serial);
770 module_put(type->driver.owner);
771 return retval;
772 }
773 }
774
775 /* descriptor matches, let's find the endpoints needed */
776 /* check out the endpoints */
777 iface_desc = interface->cur_altsetting;
778 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
779 endpoint = &iface_desc->endpoint[i].desc;
780
781 if (usb_endpoint_is_bulk_in(endpoint)) {
782 /* we found a bulk in endpoint */
783 dbg("found bulk in on endpoint %d", i);
784 bulk_in_endpoint[num_bulk_in] = endpoint;
785 ++num_bulk_in;
786 }
787
788 if (usb_endpoint_is_bulk_out(endpoint)) {
789 /* we found a bulk out endpoint */
790 dbg("found bulk out on endpoint %d", i);
791 bulk_out_endpoint[num_bulk_out] = endpoint;
792 ++num_bulk_out;
793 }
794
795 if (usb_endpoint_is_int_in(endpoint)) {
796 /* we found a interrupt in endpoint */
797 dbg("found interrupt in on endpoint %d", i);
798 interrupt_in_endpoint[num_interrupt_in] = endpoint;
799 ++num_interrupt_in;
800 }
801
802 if (usb_endpoint_is_int_out(endpoint)) {
803 /* we found an interrupt out endpoint */
804 dbg("found interrupt out on endpoint %d", i);
805 interrupt_out_endpoint[num_interrupt_out] = endpoint;
806 ++num_interrupt_out;
807 }
808 }
809
810 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
811 /* BEGIN HORRIBLE HACK FOR PL2303 */
812 /* this is needed due to the looney way its endpoints are set up */
813 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
814 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
815 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
816 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
817 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
818 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
819 ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
820 (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
821 if (interface != dev->actconfig->interface[0]) {
822 /* check out the endpoints of the other interface*/
823 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
824 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
825 endpoint = &iface_desc->endpoint[i].desc;
826 if (usb_endpoint_is_int_in(endpoint)) {
827 /* we found a interrupt in endpoint */
828 dbg("found interrupt in for Prolific device on separate interface");
829 interrupt_in_endpoint[num_interrupt_in] = endpoint;
830 ++num_interrupt_in;
831 }
832 }
833 }
834
835 /* Now make sure the PL-2303 is configured correctly.
836 * If not, give up now and hope this hack will work
837 * properly during a later invocation of usb_serial_probe
838 */
839 if (num_bulk_in == 0 || num_bulk_out == 0) {
840 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
841 kfree(serial);
842 module_put(type->driver.owner);
843 return -ENODEV;
844 }
845 }
846 /* END HORRIBLE HACK FOR PL2303 */
847 #endif
848
849 #ifdef CONFIG_USB_SERIAL_GENERIC
850 if (type == &usb_serial_generic_device) {
851 num_ports = num_bulk_out;
852 if (num_ports == 0) {
853 dev_err(&interface->dev,
854 "Generic device with no bulk out, not allowed.\n");
855 kfree(serial);
856 module_put(type->driver.owner);
857 return -EIO;
858 }
859 }
860 #endif
861 if (!num_ports) {
862 /* if this device type has a calc_num_ports function, call it */
863 if (type->calc_num_ports)
864 num_ports = type->calc_num_ports(serial);
865 if (!num_ports)
866 num_ports = type->num_ports;
867 }
868
869 serial->num_ports = num_ports;
870 serial->num_bulk_in = num_bulk_in;
871 serial->num_bulk_out = num_bulk_out;
872 serial->num_interrupt_in = num_interrupt_in;
873 serial->num_interrupt_out = num_interrupt_out;
874
875 /* found all that we need */
876 dev_info(&interface->dev, "%s converter detected\n",
877 type->description);
878
879 /* create our ports, we need as many as the max endpoints */
880 /* we don't use num_ports here because some devices have more
881 endpoint pairs than ports */
882 max_endpoints = max(num_bulk_in, num_bulk_out);
883 max_endpoints = max(max_endpoints, num_interrupt_in);
884 max_endpoints = max(max_endpoints, num_interrupt_out);
885 max_endpoints = max(max_endpoints, (int)serial->num_ports);
886 serial->num_port_pointers = max_endpoints;
887
888 dbg("%s - setting up %d port structures for this device",
889 __func__, max_endpoints);
890 for (i = 0; i < max_endpoints; ++i) {
891 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
892 if (!port)
893 goto probe_error;
894 tty_port_init(&port->port);
895 port->port.ops = &serial_port_ops;
896 port->serial = serial;
897 spin_lock_init(&port->lock);
898 /* Keep this for private driver use for the moment but
899 should probably go away */
900 INIT_WORK(&port->work, usb_serial_port_work);
901 serial->port[i] = port;
902 port->dev.parent = &interface->dev;
903 port->dev.driver = NULL;
904 port->dev.bus = &usb_serial_bus_type;
905 port->dev.release = &port_release;
906 device_initialize(&port->dev);
907 }
908
909 /* set up the endpoint information */
910 for (i = 0; i < num_bulk_in; ++i) {
911 endpoint = bulk_in_endpoint[i];
912 port = serial->port[i];
913 buffer_size = max_t(int, serial->type->bulk_in_size,
914 usb_endpoint_maxp(endpoint));
915 port->bulk_in_size = buffer_size;
916 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
917
918 for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
919 set_bit(j, &port->read_urbs_free);
920 port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
921 if (!port->read_urbs[j]) {
922 dev_err(&interface->dev,
923 "No free urbs available\n");
924 goto probe_error;
925 }
926 port->bulk_in_buffers[j] = kmalloc(buffer_size,
927 GFP_KERNEL);
928 if (!port->bulk_in_buffers[j]) {
929 dev_err(&interface->dev,
930 "Couldn't allocate bulk_in_buffer\n");
931 goto probe_error;
932 }
933 usb_fill_bulk_urb(port->read_urbs[j], dev,
934 usb_rcvbulkpipe(dev,
935 endpoint->bEndpointAddress),
936 port->bulk_in_buffers[j], buffer_size,
937 serial->type->read_bulk_callback,
938 port);
939 }
940
941 port->read_urb = port->read_urbs[0];
942 port->bulk_in_buffer = port->bulk_in_buffers[0];
943 }
944
945 for (i = 0; i < num_bulk_out; ++i) {
946 endpoint = bulk_out_endpoint[i];
947 port = serial->port[i];
948 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
949 goto probe_error;
950 buffer_size = serial->type->bulk_out_size;
951 if (!buffer_size)
952 buffer_size = usb_endpoint_maxp(endpoint);
953 port->bulk_out_size = buffer_size;
954 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
955
956 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
957 set_bit(j, &port->write_urbs_free);
958 port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
959 if (!port->write_urbs[j]) {
960 dev_err(&interface->dev,
961 "No free urbs available\n");
962 goto probe_error;
963 }
964 port->bulk_out_buffers[j] = kmalloc(buffer_size,
965 GFP_KERNEL);
966 if (!port->bulk_out_buffers[j]) {
967 dev_err(&interface->dev,
968 "Couldn't allocate bulk_out_buffer\n");
969 goto probe_error;
970 }
971 usb_fill_bulk_urb(port->write_urbs[j], dev,
972 usb_sndbulkpipe(dev,
973 endpoint->bEndpointAddress),
974 port->bulk_out_buffers[j], buffer_size,
975 serial->type->write_bulk_callback,
976 port);
977 }
978
979 port->write_urb = port->write_urbs[0];
980 port->bulk_out_buffer = port->bulk_out_buffers[0];
981 }
982
983 if (serial->type->read_int_callback) {
984 for (i = 0; i < num_interrupt_in; ++i) {
985 endpoint = interrupt_in_endpoint[i];
986 port = serial->port[i];
987 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
988 if (!port->interrupt_in_urb) {
989 dev_err(&interface->dev,
990 "No free urbs available\n");
991 goto probe_error;
992 }
993 buffer_size = usb_endpoint_maxp(endpoint);
994 port->interrupt_in_endpointAddress =
995 endpoint->bEndpointAddress;
996 port->interrupt_in_buffer = kmalloc(buffer_size,
997 GFP_KERNEL);
998 if (!port->interrupt_in_buffer) {
999 dev_err(&interface->dev,
1000 "Couldn't allocate interrupt_in_buffer\n");
1001 goto probe_error;
1002 }
1003 usb_fill_int_urb(port->interrupt_in_urb, dev,
1004 usb_rcvintpipe(dev,
1005 endpoint->bEndpointAddress),
1006 port->interrupt_in_buffer, buffer_size,
1007 serial->type->read_int_callback, port,
1008 endpoint->bInterval);
1009 }
1010 } else if (num_interrupt_in) {
1011 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1012 }
1013
1014 if (serial->type->write_int_callback) {
1015 for (i = 0; i < num_interrupt_out; ++i) {
1016 endpoint = interrupt_out_endpoint[i];
1017 port = serial->port[i];
1018 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1019 if (!port->interrupt_out_urb) {
1020 dev_err(&interface->dev,
1021 "No free urbs available\n");
1022 goto probe_error;
1023 }
1024 buffer_size = usb_endpoint_maxp(endpoint);
1025 port->interrupt_out_size = buffer_size;
1026 port->interrupt_out_endpointAddress =
1027 endpoint->bEndpointAddress;
1028 port->interrupt_out_buffer = kmalloc(buffer_size,
1029 GFP_KERNEL);
1030 if (!port->interrupt_out_buffer) {
1031 dev_err(&interface->dev,
1032 "Couldn't allocate interrupt_out_buffer\n");
1033 goto probe_error;
1034 }
1035 usb_fill_int_urb(port->interrupt_out_urb, dev,
1036 usb_sndintpipe(dev,
1037 endpoint->bEndpointAddress),
1038 port->interrupt_out_buffer, buffer_size,
1039 serial->type->write_int_callback, port,
1040 endpoint->bInterval);
1041 }
1042 } else if (num_interrupt_out) {
1043 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1044 }
1045
1046 /* if this device type has an attach function, call it */
1047 if (type->attach) {
1048 retval = type->attach(serial);
1049 if (retval < 0)
1050 goto probe_error;
1051 serial->attached = 1;
1052 if (retval > 0) {
1053 /* quietly accept this device, but don't bind to a
1054 serial port as it's about to disappear */
1055 serial->num_ports = 0;
1056 goto exit;
1057 }
1058 } else {
1059 serial->attached = 1;
1060 }
1061
1062 if (get_free_serial(serial, num_ports, &minor) == NULL) {
1063 dev_err(&interface->dev, "No more free serial devices\n");
1064 goto probe_error;
1065 }
1066 serial->minor = minor;
1067
1068 /* register all of the individual ports with the driver core */
1069 for (i = 0; i < num_ports; ++i) {
1070 port = serial->port[i];
1071 dev_set_name(&port->dev, "ttyUSB%d", port->number);
1072 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
1073 device_enable_async_suspend(&port->dev);
1074
1075 retval = device_add(&port->dev);
1076 if (retval)
1077 dev_err(&port->dev, "Error registering port device, "
1078 "continuing\n");
1079 }
1080
1081 usb_serial_console_init(debug, minor);
1082
1083 exit:
1084 /* success */
1085 usb_set_intfdata(interface, serial);
1086 module_put(type->driver.owner);
1087 return 0;
1088
1089 probe_error:
1090 usb_serial_put(serial);
1091 module_put(type->driver.owner);
1092 return -EIO;
1093 }
1094 EXPORT_SYMBOL_GPL(usb_serial_probe);
1095
1096 void usb_serial_disconnect(struct usb_interface *interface)
1097 {
1098 int i;
1099 struct usb_serial *serial = usb_get_intfdata(interface);
1100 struct device *dev = &interface->dev;
1101 struct usb_serial_port *port;
1102
1103 usb_serial_console_disconnect(serial);
1104 dbg("%s", __func__);
1105
1106 mutex_lock(&serial->disc_mutex);
1107 usb_set_intfdata(interface, NULL);
1108 /* must set a flag, to signal subdrivers */
1109 serial->disconnected = 1;
1110 mutex_unlock(&serial->disc_mutex);
1111
1112 for (i = 0; i < serial->num_ports; ++i) {
1113 port = serial->port[i];
1114 if (port) {
1115 struct tty_struct *tty = tty_port_tty_get(&port->port);
1116 if (tty) {
1117 tty_vhangup(tty);
1118 tty_kref_put(tty);
1119 }
1120 kill_traffic(port);
1121 cancel_work_sync(&port->work);
1122 if (device_is_registered(&port->dev))
1123 device_del(&port->dev);
1124 }
1125 }
1126 serial->type->disconnect(serial);
1127
1128 /* let the last holder of this object cause it to be cleaned up */
1129 usb_serial_put(serial);
1130 dev_info(dev, "device disconnected\n");
1131 }
1132 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1133
1134 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1135 {
1136 struct usb_serial *serial = usb_get_intfdata(intf);
1137 struct usb_serial_port *port;
1138 int i, r = 0;
1139
1140 serial->suspending = 1;
1141
1142 if (serial->type->suspend) {
1143 r = serial->type->suspend(serial, message);
1144 if (r < 0) {
1145 serial->suspending = 0;
1146 goto err_out;
1147 }
1148 }
1149
1150 for (i = 0; i < serial->num_ports; ++i) {
1151 port = serial->port[i];
1152 if (port)
1153 kill_traffic(port);
1154 }
1155
1156 err_out:
1157 return r;
1158 }
1159 EXPORT_SYMBOL(usb_serial_suspend);
1160
1161 int usb_serial_resume(struct usb_interface *intf)
1162 {
1163 struct usb_serial *serial = usb_get_intfdata(intf);
1164 int rv;
1165
1166 serial->suspending = 0;
1167 if (serial->type->resume)
1168 rv = serial->type->resume(serial);
1169 else
1170 rv = usb_serial_generic_resume(serial);
1171
1172 return rv;
1173 }
1174 EXPORT_SYMBOL(usb_serial_resume);
1175
1176 static const struct tty_operations serial_ops = {
1177 .open = serial_open,
1178 .close = serial_close,
1179 .write = serial_write,
1180 .hangup = serial_hangup,
1181 .write_room = serial_write_room,
1182 .ioctl = serial_ioctl,
1183 .set_termios = serial_set_termios,
1184 .throttle = serial_throttle,
1185 .unthrottle = serial_unthrottle,
1186 .break_ctl = serial_break,
1187 .chars_in_buffer = serial_chars_in_buffer,
1188 .tiocmget = serial_tiocmget,
1189 .tiocmset = serial_tiocmset,
1190 .get_icount = serial_get_icount,
1191 .cleanup = serial_cleanup,
1192 .install = serial_install,
1193 .proc_fops = &serial_proc_fops,
1194 };
1195
1196
1197 struct tty_driver *usb_serial_tty_driver;
1198
1199 static int __init usb_serial_init(void)
1200 {
1201 int i;
1202 int result;
1203
1204 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1205 if (!usb_serial_tty_driver)
1206 return -ENOMEM;
1207
1208 /* Initialize our global data */
1209 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1210 serial_table[i] = NULL;
1211
1212 result = bus_register(&usb_serial_bus_type);
1213 if (result) {
1214 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1215 "failed\n", __func__);
1216 goto exit_bus;
1217 }
1218
1219 usb_serial_tty_driver->driver_name = "usbserial";
1220 usb_serial_tty_driver->name = "ttyUSB";
1221 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1222 usb_serial_tty_driver->minor_start = 0;
1223 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1224 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1225 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1226 TTY_DRIVER_DYNAMIC_DEV;
1227 usb_serial_tty_driver->init_termios = tty_std_termios;
1228 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1229 | HUPCL | CLOCAL;
1230 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1231 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1232 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1233 result = tty_register_driver(usb_serial_tty_driver);
1234 if (result) {
1235 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1236 __func__);
1237 goto exit_reg_driver;
1238 }
1239
1240 /* register the USB driver */
1241 result = usb_register(&usb_serial_driver);
1242 if (result < 0) {
1243 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1244 __func__);
1245 goto exit_tty;
1246 }
1247
1248 /* register the generic driver, if we should */
1249 result = usb_serial_generic_register(debug);
1250 if (result < 0) {
1251 printk(KERN_ERR "usb-serial: %s - registering generic "
1252 "driver failed\n", __func__);
1253 goto exit_generic;
1254 }
1255
1256 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1257
1258 return result;
1259
1260 exit_generic:
1261 usb_deregister(&usb_serial_driver);
1262
1263 exit_tty:
1264 tty_unregister_driver(usb_serial_tty_driver);
1265
1266 exit_reg_driver:
1267 bus_unregister(&usb_serial_bus_type);
1268
1269 exit_bus:
1270 printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1271 __func__, result);
1272 put_tty_driver(usb_serial_tty_driver);
1273 return result;
1274 }
1275
1276
1277 static void __exit usb_serial_exit(void)
1278 {
1279 usb_serial_console_exit();
1280
1281 usb_serial_generic_deregister();
1282
1283 usb_deregister(&usb_serial_driver);
1284 tty_unregister_driver(usb_serial_tty_driver);
1285 put_tty_driver(usb_serial_tty_driver);
1286 bus_unregister(&usb_serial_bus_type);
1287 }
1288
1289
1290 module_init(usb_serial_init);
1291 module_exit(usb_serial_exit);
1292
1293 #define set_to_generic_if_null(type, function) \
1294 do { \
1295 if (!type->function) { \
1296 type->function = usb_serial_generic_##function; \
1297 dbg("Had to override the " #function \
1298 " usb serial operation with the generic one.");\
1299 } \
1300 } while (0)
1301
1302 static void fixup_generic(struct usb_serial_driver *device)
1303 {
1304 set_to_generic_if_null(device, open);
1305 set_to_generic_if_null(device, write);
1306 set_to_generic_if_null(device, close);
1307 set_to_generic_if_null(device, write_room);
1308 set_to_generic_if_null(device, chars_in_buffer);
1309 set_to_generic_if_null(device, read_bulk_callback);
1310 set_to_generic_if_null(device, write_bulk_callback);
1311 set_to_generic_if_null(device, disconnect);
1312 set_to_generic_if_null(device, release);
1313 set_to_generic_if_null(device, process_read_urb);
1314 set_to_generic_if_null(device, prepare_write_buffer);
1315 }
1316
1317 static int usb_serial_register(struct usb_serial_driver *driver)
1318 {
1319 int retval;
1320
1321 if (usb_disabled())
1322 return -ENODEV;
1323
1324 fixup_generic(driver);
1325
1326 if (!driver->description)
1327 driver->description = driver->driver.name;
1328 if (!driver->usb_driver) {
1329 WARN(1, "Serial driver %s has no usb_driver\n",
1330 driver->description);
1331 return -EINVAL;
1332 }
1333 driver->usb_driver->supports_autosuspend = 1;
1334
1335 /* Add this device to our list of devices */
1336 mutex_lock(&table_lock);
1337 list_add(&driver->driver_list, &usb_serial_driver_list);
1338
1339 retval = usb_serial_bus_register(driver);
1340 if (retval) {
1341 printk(KERN_ERR "usb-serial: problem %d when registering "
1342 "driver %s\n", retval, driver->description);
1343 list_del(&driver->driver_list);
1344 } else
1345 printk(KERN_INFO "USB Serial support registered for %s\n",
1346 driver->description);
1347
1348 mutex_unlock(&table_lock);
1349 return retval;
1350 }
1351
1352 static void usb_serial_deregister(struct usb_serial_driver *device)
1353 {
1354 printk(KERN_INFO "USB Serial deregistering driver %s\n",
1355 device->description);
1356 mutex_lock(&table_lock);
1357 list_del(&device->driver_list);
1358 usb_serial_bus_deregister(device);
1359 mutex_unlock(&table_lock);
1360 }
1361
1362 /**
1363 * usb_serial_register_drivers - register drivers for a usb-serial module
1364 * @udriver: usb_driver used for matching devices/interfaces
1365 * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1366 *
1367 * Registers @udriver and all the drivers in the @serial_drivers array.
1368 * Automatically fills in the .no_dynamic_id field in @udriver and
1369 * the .usb_driver field in each serial driver.
1370 */
1371 int usb_serial_register_drivers(struct usb_driver *udriver,
1372 struct usb_serial_driver * const serial_drivers[])
1373 {
1374 int rc;
1375 const struct usb_device_id *saved_id_table;
1376 struct usb_serial_driver * const *sd;
1377
1378 /*
1379 * udriver must be registered before any of the serial drivers,
1380 * because the store_new_id() routine for the serial drivers (in
1381 * bus.c) probes udriver.
1382 *
1383 * Performance hack: We don't want udriver to be probed until
1384 * the serial drivers are registered, because the probe would
1385 * simply fail for lack of a matching serial driver.
1386 * Therefore save off udriver's id_table until we are all set.
1387 */
1388 saved_id_table = udriver->id_table;
1389 udriver->id_table = NULL;
1390
1391 udriver->no_dynamic_id = 1;
1392 rc = usb_register(udriver);
1393 if (rc)
1394 return rc;
1395
1396 for (sd = serial_drivers; *sd; ++sd) {
1397 (*sd)->usb_driver = udriver;
1398 rc = usb_serial_register(*sd);
1399 if (rc)
1400 goto failed;
1401 }
1402
1403 /* Now restore udriver's id_table and look for matches */
1404 udriver->id_table = saved_id_table;
1405 rc = driver_attach(&udriver->drvwrap.driver);
1406 return 0;
1407
1408 failed:
1409 while (sd-- > serial_drivers)
1410 usb_serial_deregister(*sd);
1411 usb_deregister(udriver);
1412 return rc;
1413 }
1414 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1415
1416 /**
1417 * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1418 * @udriver: usb_driver to unregister
1419 * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1420 *
1421 * Deregisters @udriver and all the drivers in the @serial_drivers array.
1422 */
1423 void usb_serial_deregister_drivers(struct usb_driver *udriver,
1424 struct usb_serial_driver * const serial_drivers[])
1425 {
1426 for (; *serial_drivers; ++serial_drivers)
1427 usb_serial_deregister(*serial_drivers);
1428 usb_deregister(udriver);
1429 }
1430 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1431
1432 /* Module information */
1433 MODULE_AUTHOR(DRIVER_AUTHOR);
1434 MODULE_DESCRIPTION(DRIVER_DESC);
1435 MODULE_LICENSE("GPL");
1436
1437 module_param(debug, bool, S_IRUGO | S_IWUSR);
1438 MODULE_PARM_DESC(debug, "Debug enabled or not");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree