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