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