Linux kernel & device driver programming

Cross-Referenced Linux and Device Driver Code

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