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