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