blob: a78f01571ef0cefd7ed37bae11e59f10a1b8138f [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * USB Serial Converter driver
3 *
Johan Hovold659597b72013-03-21 12:37:51 +01004 * Copyright (C) 2009 - 2013 Johan Hovold (jhovold@gmail.com)
Greg Kroah-Hartman71863642012-05-15 15:40:00 -07005 * Copyright (C) 1999 - 2012 Greg Kroah-Hartman (greg@kroah.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
7 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
8 *
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
12 *
Greg Kroah-Hartman502b95c2005-06-20 21:15:16 -070013 * This driver was originally based on the ACM driver by Armin Fuerst (which was
Linus Torvalds1da177e2005-04-16 15:20:36 -070014 * based on a driver by Brad Keryan)
15 *
Alan Coxa8d6f0a2008-07-22 11:12:24 +010016 * See Documentation/usb/usb-serial.txt for more information on using this
17 * driver
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 */
19
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -070020#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
21
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/kernel.h>
23#include <linux/errno.h>
24#include <linux/init.h>
25#include <linux/slab.h>
26#include <linux/tty.h>
27#include <linux/tty_driver.h>
28#include <linux/tty_flip.h>
29#include <linux/module.h>
30#include <linux/moduleparam.h>
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -070031#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/spinlock.h>
Luiz Fernando Capitulino1ce7dd22006-03-24 17:12:31 -030033#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/list.h>
Alan Coxa8d6f0a2008-07-22 11:12:24 +010035#include <linux/uaccess.h>
Alan Coxc56d3002009-07-28 00:34:58 +010036#include <linux/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070038#include <linux/usb/serial.h>
David VomLehn8e8dce02009-08-28 12:54:27 -070039#include <linux/kfifo.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "pl2303.h"
41
Greg Kroah-Hartmanee42f6c2012-09-18 17:10:29 +010042#define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#define DRIVER_DESC "USB Serial Driver core"
44
Linus Torvalds1da177e2005-04-16 15:20:36 -070045/* 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
Alan Coxa8d6f0a2008-07-22 11:12:24 +010052static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
Oliver Neukum3ddad822007-07-24 15:13:42 +020053static DEFINE_MUTEX(table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054static LIST_HEAD(usb_serial_driver_list);
55
Alan Stern8bc2c1b2009-09-01 11:38:59 -040056/*
57 * Look up the serial structure. If it is found and it hasn't been
58 * disconnected, return with its disc_mutex held and its refcount
59 * incremented. Otherwise return NULL.
60 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070061struct usb_serial *usb_serial_get_by_index(unsigned index)
62{
Oliver Neukum34ef50e2007-01-13 07:29:26 +010063 struct usb_serial *serial;
64
Oliver Neukum3ddad822007-07-24 15:13:42 +020065 mutex_lock(&table_lock);
Oliver Neukum34ef50e2007-01-13 07:29:26 +010066 serial = serial_table[index];
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Alan Stern8bc2c1b2009-09-01 11:38:59 -040068 if (serial) {
69 mutex_lock(&serial->disc_mutex);
70 if (serial->disconnected) {
71 mutex_unlock(&serial->disc_mutex);
72 serial = NULL;
73 } else {
74 kref_get(&serial->kref);
75 }
76 }
Oliver Neukum3ddad822007-07-24 15:13:42 +020077 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 return serial;
79}
80
Alan Coxa8d6f0a2008-07-22 11:12:24 +010081static struct usb_serial *get_free_serial(struct usb_serial *serial,
82 int num_ports, unsigned int *minor)
Linus Torvalds1da177e2005-04-16 15:20:36 -070083{
84 unsigned int i, j;
85 int good_spot;
86
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -070087 dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
Linus Torvalds1da177e2005-04-16 15:20:36 -070088
89 *minor = 0;
Oliver Neukum3ddad822007-07-24 15:13:42 +020090 mutex_lock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070091 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
92 if (serial_table[i])
93 continue;
94
95 good_spot = 1;
96 for (j = 1; j <= num_ports-1; ++j)
97 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
98 good_spot = 0;
99 i += j;
100 break;
101 }
102 if (good_spot == 0)
103 continue;
104
105 *minor = i;
Oliver Neukuma1f721c2007-03-05 15:23:51 +0100106 j = 0;
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700107 dev_dbg(&serial->interface->dev, "%s - minor base = %d\n", __func__, *minor);
Oliver Neukuma1f721c2007-03-05 15:23:51 +0100108 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 serial_table[i] = serial;
Oliver Neukuma1f721c2007-03-05 15:23:51 +0100110 serial->port[j++]->number = i;
111 }
Oliver Neukum3ddad822007-07-24 15:13:42 +0200112 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 return serial;
114 }
Oliver Neukum3ddad822007-07-24 15:13:42 +0200115 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 return NULL;
117}
118
119static void return_serial(struct usb_serial *serial)
120{
121 int i;
122
Alan Stern8bc2c1b2009-09-01 11:38:59 -0400123 mutex_lock(&table_lock);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100124 for (i = 0; i < serial->num_ports; ++i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 serial_table[serial->minor + i] = NULL;
Alan Stern8bc2c1b2009-09-01 11:38:59 -0400126 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127}
128
129static void destroy_serial(struct kref *kref)
130{
131 struct usb_serial *serial;
132 struct usb_serial_port *port;
133 int i;
134
135 serial = to_usb_serial(kref);
136
Jim Radford521b85a2007-03-13 08:30:50 -0700137 /* return the minor range that this device had */
Alan Stern0282b7f2008-07-29 12:01:04 -0400138 if (serial->minor != SERIAL_TTY_NO_MINOR)
139 return_serial(serial);
Jim Radford521b85a2007-03-13 08:30:50 -0700140
Johan Hovold79b80b82013-03-21 12:36:43 +0100141 if (serial->attached && serial->type->release)
Alan Sterna4720c62009-10-09 12:43:12 -0400142 serial->type->release(serial);
Alan Sternf9c99bb2009-06-02 11:53:55 -0400143
Alan Stern41bd34d2009-09-01 11:38:34 -0400144 /* Now that nothing is using the ports, they can be freed */
145 for (i = 0; i < serial->num_port_pointers; ++i) {
Alan Sternf9c99bb2009-06-02 11:53:55 -0400146 port = serial->port[i];
Alan Stern41bd34d2009-09-01 11:38:34 -0400147 if (port) {
148 port->serial = NULL;
Alan Sternf9c99bb2009-06-02 11:53:55 -0400149 put_device(&port->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150 }
151 }
152
Johan Hovoldd7971052013-03-19 09:21:09 +0100153 usb_put_intf(serial->interface);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 usb_put_dev(serial->dev);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100155 kfree(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156}
157
Guennadi Liakhovetski73e487f2006-04-25 07:46:17 +0200158void usb_serial_put(struct usb_serial *serial)
159{
160 kref_put(&serial->kref, destroy_serial);
161}
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163/*****************************************************************************
164 * Driver tty interface functions
165 *****************************************************************************/
Alan Sternf5b09532009-09-01 11:38:44 -0400166
167/**
168 * serial_install - install tty
169 * @driver: the driver (USB in our case)
170 * @tty: the tty being created
171 *
172 * Create the termios objects for this tty. We use the default
173 * USB serial settings but permit them to be overridden by
174 * serial->type->init_termios.
Alan Sterncc56cd02009-09-01 11:39:13 -0400175 *
176 * This is the first place a new tty gets used. Hence this is where we
177 * acquire references to the usb_serial structure and the driver module,
178 * where we store a pointer to the port, and where we do an autoresume.
Dave Youngf278a2f2009-09-27 16:00:42 +0000179 * All these actions are reversed in serial_cleanup().
Alan Sternf5b09532009-09-01 11:38:44 -0400180 */
181static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
182{
183 int idx = tty->index;
184 struct usb_serial *serial;
Alan Sterncc56cd02009-09-01 11:39:13 -0400185 struct usb_serial_port *port;
186 int retval = -ENODEV;
187
188 serial = usb_serial_get_by_index(idx);
189 if (!serial)
190 return retval;
191
192 port = serial->port[idx - serial->minor];
193 if (!port)
194 goto error_no_port;
195 if (!try_module_get(serial->type->driver.owner))
196 goto error_module_get;
197
198 retval = usb_autopm_get_interface(serial->interface);
199 if (retval)
200 goto error_get_interface;
Alan Sternf5b09532009-09-01 11:38:44 -0400201
Jiri Slabyca4ff102012-06-04 13:35:34 +0200202 retval = tty_port_install(&port->port, driver, tty);
Jiri Slaby76f82a72012-01-30 21:14:29 +0100203 if (retval)
204 goto error_init_termios;
205
Alan Sterncc56cd02009-09-01 11:39:13 -0400206 mutex_unlock(&serial->disc_mutex);
207
Alan Stern7e29bb42009-09-01 11:39:22 -0400208 /* allow the driver to update the settings */
209 if (serial->type->init_termios)
210 serial->type->init_termios(tty);
211
Alan Sterncc56cd02009-09-01 11:39:13 -0400212 tty->driver_data = port;
213
Alan Sterncc56cd02009-09-01 11:39:13 -0400214 return retval;
215
Alan Stern7e29bb42009-09-01 11:39:22 -0400216 error_init_termios:
Jiri Slaby76f82a72012-01-30 21:14:29 +0100217 usb_autopm_put_interface(serial->interface);
218 error_get_interface:
Alan Sterncc56cd02009-09-01 11:39:13 -0400219 module_put(serial->type->driver.owner);
220 error_module_get:
221 error_no_port:
222 usb_serial_put(serial);
223 mutex_unlock(&serial->disc_mutex);
224 return retval;
Alan Sternf5b09532009-09-01 11:38:44 -0400225}
226
Johan Hovold395e08d2013-03-21 12:36:23 +0100227static int serial_port_activate(struct tty_port *tport, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
Alan Cox64bc3972009-10-06 16:06:11 +0100229 struct usb_serial_port *port =
230 container_of(tport, struct usb_serial_port, port);
Alan Stern320348c2009-09-01 11:39:59 -0400231 struct usb_serial *serial = port->serial;
232 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233
Alan Cox64bc3972009-10-06 16:06:11 +0100234 mutex_lock(&serial->disc_mutex);
235 if (serial->disconnected)
236 retval = -ENODEV;
237 else
238 retval = port->serial->type->open(tty, port);
239 mutex_unlock(&serial->disc_mutex);
Johan Hovold3827d872011-11-10 17:38:13 +0100240
241 if (retval < 0)
242 retval = usb_translate_errors(retval);
243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 return retval;
245}
246
Alan Cox64bc3972009-10-06 16:06:11 +0100247static int serial_open(struct tty_struct *tty, struct file *filp)
248{
249 struct usb_serial_port *port = tty->driver_data;
250
Johan Hovoldd12e2112013-03-21 12:36:25 +0100251 dev_dbg(tty->dev, "%s\n", __func__);
252
Alan Cox64bc3972009-10-06 16:06:11 +0100253 return tty_port_open(&port->port, tty, filp);
254}
255
Alan Cox335f8512009-06-11 12:26:29 +0100256/**
Johan Hovold395e08d2013-03-21 12:36:23 +0100257 * serial_port_shutdown - shut down hardware
Alan Coxe1108a62009-10-06 16:06:36 +0100258 * @tport: tty port to shut down
Alan Cox335f8512009-06-11 12:26:29 +0100259 *
Peter Hurley8a7298d2013-02-23 10:11:35 -0500260 * Shut down a USB serial port. Serialized against activate by the
261 * tport mutex and kept to matching open/close pairs
Alan Coxe1108a62009-10-06 16:06:36 +0100262 * of calls by the ASYNCB_INITIALIZED flag.
Peter Hurley8a7298d2013-02-23 10:11:35 -0500263 *
264 * Not called if tty is console.
Alan Cox335f8512009-06-11 12:26:29 +0100265 */
Johan Hovold395e08d2013-03-21 12:36:23 +0100266static void serial_port_shutdown(struct tty_port *tport)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267{
Alan Coxe1108a62009-10-06 16:06:36 +0100268 struct usb_serial_port *port =
269 container_of(tport, struct usb_serial_port, port);
Alan Cox335f8512009-06-11 12:26:29 +0100270 struct usb_serial_driver *drv = port->serial->type;
Peter Hurley8a7298d2013-02-23 10:11:35 -0500271
Alan Cox335f8512009-06-11 12:26:29 +0100272 if (drv->close)
273 drv->close(port);
Alan Cox335f8512009-06-11 12:26:29 +0100274}
275
Alan Sternf5b09532009-09-01 11:38:44 -0400276static void serial_hangup(struct tty_struct *tty)
Alan Cox335f8512009-06-11 12:26:29 +0100277{
Alan Cox4455e342009-09-19 13:13:24 -0700278 struct usb_serial_port *port = tty->driver_data;
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700279
Johan Hovoldd12e2112013-03-21 12:36:25 +0100280 dev_dbg(tty->dev, "%s\n", __func__);
281
Alan Sternf5b09532009-09-01 11:38:44 -0400282 tty_port_hangup(&port->port);
Alan Cox335f8512009-06-11 12:26:29 +0100283}
284
285static void serial_close(struct tty_struct *tty, struct file *filp)
286{
287 struct usb_serial_port *port = tty->driver_data;
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700288
Johan Hovoldd12e2112013-03-21 12:36:25 +0100289 dev_dbg(tty->dev, "%s\n", __func__);
290
Alan Coxe1108a62009-10-06 16:06:36 +0100291 tty_port_close(&port->port, tty, filp);
Alan Cox335f8512009-06-11 12:26:29 +0100292}
293
Alan Sternf5b09532009-09-01 11:38:44 -0400294/**
Dave Youngf278a2f2009-09-27 16:00:42 +0000295 * serial_cleanup - free resources post close/hangup
Alan Sternf5b09532009-09-01 11:38:44 -0400296 * @port: port to free up
297 *
298 * Do the resource freeing and refcount dropping for the port.
299 * Avoid freeing the console.
300 *
Alan Cox36b3c072012-07-17 17:06:57 +0100301 * Called asynchronously after the last tty kref is dropped.
Alan Sternf5b09532009-09-01 11:38:44 -0400302 */
Dave Youngf278a2f2009-09-27 16:00:42 +0000303static void serial_cleanup(struct tty_struct *tty)
Alan Cox335f8512009-06-11 12:26:29 +0100304{
305 struct usb_serial_port *port = tty->driver_data;
Alan Sternf5b09532009-09-01 11:38:44 -0400306 struct usb_serial *serial;
307 struct module *owner;
308
Johan Hovoldd12e2112013-03-21 12:36:25 +0100309 dev_dbg(tty->dev, "%s\n", __func__);
310
Alan Sternf5b09532009-09-01 11:38:44 -0400311 /* The console is magical. Do not hang up the console hardware
312 * or there will be tears.
313 */
Jason Wesselbd5afa92010-03-08 21:50:12 -0600314 if (port->port.console)
Alan Sternf5b09532009-09-01 11:38:44 -0400315 return;
316
Alan Sterncc56cd02009-09-01 11:39:13 -0400317 tty->driver_data = NULL;
318
Alan Sternf5b09532009-09-01 11:38:44 -0400319 serial = port->serial;
320 owner = serial->type->driver.owner;
321
322 mutex_lock(&serial->disc_mutex);
323 if (!serial->disconnected)
324 usb_autopm_put_interface(serial->interface);
325 mutex_unlock(&serial->disc_mutex);
326
327 usb_serial_put(serial);
328 module_put(owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329}
330
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100331static int serial_write(struct tty_struct *tty, const unsigned char *buf,
332 int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200334 struct usb_serial_port *port = tty->driver_data;
Oliver Neukum3ff4fd92007-01-13 07:32:27 +0100335 int retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Alan Coxf34d7a52008-04-30 00:54:13 -0700337 if (port->serial->dev->state == USB_STATE_NOTATTACHED)
Luiz Fernando Capitulino487f9c62005-11-28 19:16:05 -0200338 goto exit;
339
Johan Hovoldd12e2112013-03-21 12:36:25 +0100340 dev_dbg(tty->dev, "%s - %d byte(s)\n", __func__, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Alan Cox95da3102008-07-22 11:09:07 +0100342 retval = port->serial->type->write(tty, port, buf, count);
Johan Hovoldc6249ff2011-11-10 17:40:44 +0100343 if (retval < 0)
344 retval = usb_translate_errors(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345exit:
346 return retval;
347}
348
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100349static int serial_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200351 struct usb_serial_port *port = tty->driver_data;
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700352
Johan Hovoldd12e2112013-03-21 12:36:25 +0100353 dev_dbg(tty->dev, "%s\n", __func__);
Johan Hovold9993b422013-03-21 12:36:24 +0100354
Alan Cox95da3102008-07-22 11:09:07 +0100355 return port->serial->type->write_room(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356}
357
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100358static int serial_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200360 struct usb_serial_port *port = tty->driver_data;
Johan Hovold810360a2013-01-14 16:52:56 +0100361 struct usb_serial *serial = port->serial;
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700362
Johan Hovoldd12e2112013-03-21 12:36:25 +0100363 dev_dbg(tty->dev, "%s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
Johan Hovold810360a2013-01-14 16:52:56 +0100365 if (serial->disconnected)
Johan Hovold4746b6c2013-05-05 20:32:33 +0200366 return 0;
Johan Hovold810360a2013-01-14 16:52:56 +0100367
Johan Hovold4746b6c2013-05-05 20:32:33 +0200368 return serial->type->chars_in_buffer(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369}
370
Johan Hovold06931962013-05-05 20:32:27 +0200371static void serial_wait_until_sent(struct tty_struct *tty, int timeout)
372{
373 struct usb_serial_port *port = tty->driver_data;
374 struct usb_serial *serial = port->serial;
375
376 dev_dbg(tty->dev, "%s\n", __func__);
377
378 if (!port->serial->type->wait_until_sent)
379 return;
380
381 mutex_lock(&serial->disc_mutex);
382 if (!serial->disconnected)
383 port->serial->type->wait_until_sent(tty, timeout);
384 mutex_unlock(&serial->disc_mutex);
385}
386
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100387static void serial_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200389 struct usb_serial_port *port = tty->driver_data;
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700390
Johan Hovoldd12e2112013-03-21 12:36:25 +0100391 dev_dbg(tty->dev, "%s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 if (port->serial->type->throttle)
Alan Cox95da3102008-07-22 11:09:07 +0100394 port->serial->type->throttle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395}
396
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100397static void serial_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200399 struct usb_serial_port *port = tty->driver_data;
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700400
Johan Hovoldd12e2112013-03-21 12:36:25 +0100401 dev_dbg(tty->dev, "%s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 if (port->serial->type->unthrottle)
Alan Cox95da3102008-07-22 11:09:07 +0100404 port->serial->type->unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405}
406
Alan Cox6caa76b2011-02-14 16:27:22 +0000407static int serial_ioctl(struct tty_struct *tty,
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100408 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200410 struct usb_serial_port *port = tty->driver_data;
Johan Hovoldf44880352013-06-05 12:21:11 +0200411 int retval = -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412
Johan Hovoldd12e2112013-03-21 12:36:25 +0100413 dev_dbg(tty->dev, "%s - cmd 0x%.4x\n", __func__, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414
Johan Hovold143d9d92013-03-21 12:36:51 +0100415 switch (cmd) {
416 case TIOCMIWAIT:
417 if (port->serial->type->tiocmiwait)
418 retval = port->serial->type->tiocmiwait(tty, arg);
419 break;
420 default:
421 if (port->serial->type->ioctl)
422 retval = port->serial->type->ioctl(tty, cmd, arg);
Johan Hovold143d9d92013-03-21 12:36:51 +0100423 }
Johan Hovold9993b422013-03-21 12:36:24 +0100424
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 return retval;
426}
427
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100428static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200430 struct usb_serial_port *port = tty->driver_data;
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700431
Johan Hovoldd12e2112013-03-21 12:36:25 +0100432 dev_dbg(tty->dev, "%s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 if (port->serial->type->set_termios)
Alan Cox95da3102008-07-22 11:09:07 +0100435 port->serial->type->set_termios(tty, port, old);
Alan Cox33785092007-10-18 01:24:22 -0700436 else
Alan Coxadc8d742012-07-14 15:31:47 +0100437 tty_termios_copy_hw(&tty->termios, old);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438}
439
Alan Cox9e989662008-07-22 11:18:03 +0100440static int serial_break(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200442 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443
Johan Hovoldd12e2112013-03-21 12:36:25 +0100444 dev_dbg(tty->dev, "%s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
Alan Cox6b447f042009-01-02 13:48:56 +0000446 if (port->serial->type->break_ctl)
Alan Cox95da3102008-07-22 11:09:07 +0100447 port->serial->type->break_ctl(tty, break_state);
Johan Hovold9993b422013-03-21 12:36:24 +0100448
Alan Cox9e989662008-07-22 11:18:03 +0100449 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450}
451
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700452static int serial_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453{
454 struct usb_serial *serial;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 char tmp[40];
457
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700458 seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
459 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 serial = usb_serial_get_by_index(i);
461 if (serial == NULL)
462 continue;
463
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700464 seq_printf(m, "%d:", i);
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700465 if (serial->type->driver.owner)
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700466 seq_printf(m, " module:%s",
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100467 module_name(serial->type->driver.owner));
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700468 seq_printf(m, " name:\"%s\"",
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100469 serial->type->description);
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700470 seq_printf(m, " vendor:%04x product:%04x",
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100471 le16_to_cpu(serial->dev->descriptor.idVendor),
472 le16_to_cpu(serial->dev->descriptor.idProduct));
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700473 seq_printf(m, " num_ports:%d", serial->num_ports);
474 seq_printf(m, " port:%d", i - serial->minor + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 usb_make_path(serial->dev, tmp, sizeof(tmp));
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700476 seq_printf(m, " path:%s", tmp);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100477
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700478 seq_putc(m, '\n');
Guennadi Liakhovetski73e487f2006-04-25 07:46:17 +0200479 usb_serial_put(serial);
Alan Stern8bc2c1b2009-09-01 11:38:59 -0400480 mutex_unlock(&serial->disc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 }
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700482 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483}
484
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700485static int serial_proc_open(struct inode *inode, struct file *file)
486{
487 return single_open(file, serial_proc_show, NULL);
488}
489
490static const struct file_operations serial_proc_fops = {
491 .owner = THIS_MODULE,
492 .open = serial_proc_open,
493 .read = seq_read,
494 .llseek = seq_lseek,
495 .release = single_release,
496};
497
Alan Cox60b33c12011-02-14 16:26:14 +0000498static int serial_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200500 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Johan Hovoldd12e2112013-03-21 12:36:25 +0100502 dev_dbg(tty->dev, "%s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 if (port->serial->type->tiocmget)
Alan Cox60b33c12011-02-14 16:26:14 +0000505 return port->serial->type->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 return -EINVAL;
507}
508
Alan Cox20b9d172011-02-14 16:26:50 +0000509static int serial_tiocmset(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 unsigned int set, unsigned int clear)
511{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200512 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513
Johan Hovoldd12e2112013-03-21 12:36:25 +0100514 dev_dbg(tty->dev, "%s\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 if (port->serial->type->tiocmset)
Alan Cox20b9d172011-02-14 16:26:50 +0000517 return port->serial->type->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 return -EINVAL;
519}
520
Alan Coxd281da72010-09-16 18:21:24 +0100521static int serial_get_icount(struct tty_struct *tty,
522 struct serial_icounter_struct *icount)
523{
524 struct usb_serial_port *port = tty->driver_data;
525
Johan Hovoldd12e2112013-03-21 12:36:25 +0100526 dev_dbg(tty->dev, "%s\n", __func__);
Alan Coxd281da72010-09-16 18:21:24 +0100527
528 if (port->serial->type->get_icount)
529 return port->serial->type->get_icount(tty, icount);
530 return -EINVAL;
531}
532
Pete Zaitcevcf2c7482006-05-22 21:58:49 -0700533/*
534 * We would be calling tty_wakeup here, but unfortunately some line
535 * disciplines have an annoying habit of calling tty->write from
536 * the write wakeup callback (e.g. n_hdlc.c).
537 */
538void usb_serial_port_softint(struct usb_serial_port *port)
539{
540 schedule_work(&port->work);
541}
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100542EXPORT_SYMBOL_GPL(usb_serial_port_softint);
Pete Zaitcevcf2c7482006-05-22 21:58:49 -0700543
David Howellsc4028952006-11-22 14:57:56 +0000544static void usb_serial_port_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545{
David Howellsc4028952006-11-22 14:57:56 +0000546 struct usb_serial_port *port =
547 container_of(work, struct usb_serial_port, work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
Jiri Slaby6aad04f2013-03-07 13:12:29 +0100549 tty_port_tty_wakeup(&port->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550}
551
Johan Hovold6a5c8212013-03-21 12:36:49 +0100552static void usb_serial_port_poison_urbs(struct usb_serial_port *port)
Pete Zaitcev34f8e762006-06-21 15:00:45 -0700553{
Johan Hovold27c7acf2010-05-05 23:57:37 +0200554 int i;
555
Johan Hovoldd83b4052011-11-06 19:06:37 +0100556 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
Johan Hovold6a5c8212013-03-21 12:36:49 +0100557 usb_poison_urb(port->read_urbs[i]);
Johan Hovold27c7acf2010-05-05 23:57:37 +0200558 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
Johan Hovold6a5c8212013-03-21 12:36:49 +0100559 usb_poison_urb(port->write_urbs[i]);
560
561 usb_poison_urb(port->interrupt_in_urb);
562 usb_poison_urb(port->interrupt_out_urb);
Oliver Neukum34ef50e2007-01-13 07:29:26 +0100563}
564
Johan Hovold6a5c8212013-03-21 12:36:49 +0100565static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port)
566{
567 int i;
568
569 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
570 usb_unpoison_urb(port->read_urbs[i]);
571 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
572 usb_unpoison_urb(port->write_urbs[i]);
573
574 usb_unpoison_urb(port->interrupt_in_urb);
575 usb_unpoison_urb(port->interrupt_out_urb);
Oliver Neukum34ef50e2007-01-13 07:29:26 +0100576}
577
Johan Hovold69a3d212013-03-21 12:36:47 +0100578static void usb_serial_port_release(struct device *dev)
Oliver Neukum34ef50e2007-01-13 07:29:26 +0100579{
Alan Stern41bd34d2009-09-01 11:38:34 -0400580 struct usb_serial_port *port = to_usb_serial_port(dev);
Johan Hovold27c7acf2010-05-05 23:57:37 +0200581 int i;
Alan Stern41bd34d2009-09-01 11:38:34 -0400582
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700583 dev_dbg(dev, "%s\n", __func__);
Alan Stern41bd34d2009-09-01 11:38:34 -0400584
Oliver Neukum34ef50e2007-01-13 07:29:26 +0100585 usb_free_urb(port->interrupt_in_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 usb_free_urb(port->interrupt_out_urb);
Johan Hovoldd83b4052011-11-06 19:06:37 +0100587 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
588 usb_free_urb(port->read_urbs[i]);
589 kfree(port->bulk_in_buffers[i]);
590 }
Johan Hovold27c7acf2010-05-05 23:57:37 +0200591 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
592 usb_free_urb(port->write_urbs[i]);
593 kfree(port->bulk_out_buffers[i]);
594 }
Stefani Seibold119eecc2009-12-23 09:10:48 +0100595 kfifo_free(&port->write_fifo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 kfree(port->interrupt_in_buffer);
597 kfree(port->interrupt_out_buffer);
Jiri Slaby191c5f12012-11-15 09:49:56 +0100598 tty_port_destroy(&port->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 kfree(port);
600}
601
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100602static struct usb_serial *create_serial(struct usb_device *dev,
603 struct usb_interface *interface,
604 struct usb_serial_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
606 struct usb_serial *serial;
607
Eric Sesterhenn80b6ca42006-02-27 21:29:43 +0100608 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
Johan Hovold6b03f7f2013-03-21 12:36:26 +0100609 if (!serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 serial->dev = usb_get_dev(dev);
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700612 serial->type = driver;
Johan Hovoldd7971052013-03-19 09:21:09 +0100613 serial->interface = usb_get_intf(interface);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 kref_init(&serial->kref);
Oliver Neukuma1cd7e92008-01-16 17:18:52 +0100615 mutex_init(&serial->disc_mutex);
Alan Stern0282b7f2008-07-29 12:01:04 -0400616 serial->minor = SERIAL_TTY_NO_MINOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617
618 return serial;
619}
620
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100621static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100622 struct usb_serial_driver *drv)
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100623{
624 struct usb_dynid *dynid;
625
626 spin_lock(&drv->dynids.lock);
627 list_for_each_entry(dynid, &drv->dynids.list, node) {
628 if (usb_match_one_id(intf, &dynid->id)) {
629 spin_unlock(&drv->dynids.lock);
630 return &dynid->id;
631 }
632 }
633 spin_unlock(&drv->dynids.lock);
634 return NULL;
635}
636
637static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
638 struct usb_interface *intf)
639{
640 const struct usb_device_id *id;
641
642 id = usb_match_id(intf, drv->id_table);
643 if (id) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700644 dev_dbg(&intf->dev, "static descriptor matches\n");
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100645 goto exit;
646 }
647 id = match_dynamic_id(intf, drv);
648 if (id)
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700649 dev_dbg(&intf->dev, "dynamic descriptor matches\n");
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100650exit:
651 return id;
652}
653
Andi Kleen0daeed32010-06-01 23:04:42 +0200654/* Caller must hold table_lock */
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100655static struct usb_serial_driver *search_serial_device(
656 struct usb_interface *iface)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657{
Bjørn Mork954c3f82012-05-30 10:00:14 +0200658 const struct usb_device_id *id = NULL;
Alan Stern063a2da2007-10-10 16:24:06 -0400659 struct usb_serial_driver *drv;
Bjørn Mork954c3f82012-05-30 10:00:14 +0200660 struct usb_driver *driver = to_usb_driver(iface->dev.driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661
Adrian Bunk93b1fae2006-01-10 00:13:33 +0100662 /* Check if the usb id matches a known device */
Alan Stern063a2da2007-10-10 16:24:06 -0400663 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
Bjørn Mork954c3f82012-05-30 10:00:14 +0200664 if (drv->usb_driver == driver)
665 id = get_iface_id(drv, iface);
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100666 if (id)
Alan Stern063a2da2007-10-10 16:24:06 -0400667 return drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 }
669
670 return NULL;
671}
672
Johan Hovold395e08d2013-03-21 12:36:23 +0100673static int serial_port_carrier_raised(struct tty_port *port)
Alan Cox335f8512009-06-11 12:26:29 +0100674{
675 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
676 struct usb_serial_driver *drv = p->serial->type;
Johan Hovold3e1f4902011-11-10 17:40:43 +0100677
Alan Cox335f8512009-06-11 12:26:29 +0100678 if (drv->carrier_raised)
679 return drv->carrier_raised(p);
680 /* No carrier control - don't block */
Johan Hovold3e1f4902011-11-10 17:40:43 +0100681 return 1;
Alan Cox335f8512009-06-11 12:26:29 +0100682}
683
Johan Hovold395e08d2013-03-21 12:36:23 +0100684static void serial_port_dtr_rts(struct tty_port *port, int on)
Alan Cox335f8512009-06-11 12:26:29 +0100685{
686 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
Johan Hovoldb2ca6992013-02-13 17:53:28 +0100687 struct usb_serial *serial = p->serial;
688 struct usb_serial_driver *drv = serial->type;
Johan Hovold3e1f4902011-11-10 17:40:43 +0100689
Johan Hovoldb2ca6992013-02-13 17:53:28 +0100690 if (!drv->dtr_rts)
691 return;
692 /*
693 * Work-around bug in the tty-layer which can result in dtr_rts
694 * being called after a disconnect (and tty_unregister_device
695 * has returned). Remove once bug has been squashed.
696 */
697 mutex_lock(&serial->disc_mutex);
698 if (!serial->disconnected)
Alan Cox335f8512009-06-11 12:26:29 +0100699 drv->dtr_rts(p, on);
Johan Hovoldb2ca6992013-02-13 17:53:28 +0100700 mutex_unlock(&serial->disc_mutex);
Alan Cox335f8512009-06-11 12:26:29 +0100701}
702
703static const struct tty_port_operations serial_port_ops = {
Johan Hovold395e08d2013-03-21 12:36:23 +0100704 .carrier_raised = serial_port_carrier_raised,
705 .dtr_rts = serial_port_dtr_rts,
706 .activate = serial_port_activate,
707 .shutdown = serial_port_shutdown,
Alan Cox335f8512009-06-11 12:26:29 +0100708};
709
Greg Kroah-Hartman2edd2842012-05-07 14:46:48 -0700710static int usb_serial_probe(struct usb_interface *interface,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711 const struct usb_device_id *id)
712{
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700713 struct device *ddev = &interface->dev;
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100714 struct usb_device *dev = interface_to_usbdev(interface);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 struct usb_serial *serial = NULL;
716 struct usb_serial_port *port;
717 struct usb_host_interface *iface_desc;
718 struct usb_endpoint_descriptor *endpoint;
719 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
720 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
721 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
722 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700723 struct usb_serial_driver *type = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 int retval;
Andre Hauptdd9ca5d2008-06-18 15:56:00 +0200725 unsigned int minor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 int buffer_size;
727 int i;
Johan Hovoldd83b4052011-11-06 19:06:37 +0100728 int j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 int num_interrupt_in = 0;
730 int num_interrupt_out = 0;
731 int num_bulk_in = 0;
732 int num_bulk_out = 0;
733 int num_ports = 0;
734 int max_endpoints;
735
Andi Kleen0daeed32010-06-01 23:04:42 +0200736 mutex_lock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 type = search_serial_device(interface);
738 if (!type) {
Andi Kleen0daeed32010-06-01 23:04:42 +0200739 mutex_unlock(&table_lock);
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700740 dev_dbg(ddev, "none matched\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 return -ENODEV;
742 }
743
Andi Kleen0daeed32010-06-01 23:04:42 +0200744 if (!try_module_get(type->driver.owner)) {
745 mutex_unlock(&table_lock);
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700746 dev_err(ddev, "module get failed, exiting\n");
Andi Kleen0daeed32010-06-01 23:04:42 +0200747 return -EIO;
748 }
749 mutex_unlock(&table_lock);
750
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100751 serial = create_serial(dev, interface, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 if (!serial) {
Ming Leid92a3ca2010-08-07 16:20:35 +0800753 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 return -ENOMEM;
755 }
756
757 /* if this device type has a probe function, call it */
758 if (type->probe) {
759 const struct usb_device_id *id;
760
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100761 id = get_iface_id(type, interface);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 retval = type->probe(serial, id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
764 if (retval) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700765 dev_dbg(ddev, "sub driver rejected device\n");
Jan Safrata0658a332012-05-22 14:04:50 +0200766 usb_serial_put(serial);
Ming Leid92a3ca2010-08-07 16:20:35 +0800767 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 return retval;
769 }
770 }
771
772 /* descriptor matches, let's find the endpoints needed */
773 /* check out the endpoints */
774 iface_desc = interface->cur_altsetting;
775 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
776 endpoint = &iface_desc->endpoint[i].desc;
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700777
778 if (usb_endpoint_is_bulk_in(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 /* we found a bulk in endpoint */
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700780 dev_dbg(ddev, "found bulk in on endpoint %d\n", i);
Johan Hovoldecb80e62014-08-27 11:55:18 +0200781 if (num_bulk_in < MAX_NUM_PORTS) {
782 bulk_in_endpoint[num_bulk_in] = endpoint;
783 ++num_bulk_in;
784 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 }
786
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700787 if (usb_endpoint_is_bulk_out(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788 /* we found a bulk out endpoint */
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700789 dev_dbg(ddev, "found bulk out on endpoint %d\n", i);
Johan Hovoldecb80e62014-08-27 11:55:18 +0200790 if (num_bulk_out < MAX_NUM_PORTS) {
791 bulk_out_endpoint[num_bulk_out] = endpoint;
792 ++num_bulk_out;
793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 }
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700795
796 if (usb_endpoint_is_int_in(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 /* we found a interrupt in endpoint */
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700798 dev_dbg(ddev, "found interrupt in on endpoint %d\n", i);
Johan Hovoldecb80e62014-08-27 11:55:18 +0200799 if (num_interrupt_in < MAX_NUM_PORTS) {
800 interrupt_in_endpoint[num_interrupt_in] =
801 endpoint;
802 ++num_interrupt_in;
803 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 }
805
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700806 if (usb_endpoint_is_int_out(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807 /* we found an interrupt out endpoint */
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700808 dev_dbg(ddev, "found interrupt out on endpoint %d\n", i);
Johan Hovoldecb80e62014-08-27 11:55:18 +0200809 if (num_interrupt_out < MAX_NUM_PORTS) {
810 interrupt_out_endpoint[num_interrupt_out] =
811 endpoint;
812 ++num_interrupt_out;
813 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 }
815 }
816
817#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100818 /* BEGIN HORRIBLE HACK FOR PL2303 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 /* this is needed due to the looney way its endpoints are set up */
820 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
821 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
822 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
Johannes Steingraeber8fd80132006-09-16 16:17:34 +0200823 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
824 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
Andreas Bombece816cf2008-09-14 01:58:55 +0200825 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
826 ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
827 (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828 if (interface != dev->actconfig->interface[0]) {
829 /* check out the endpoints of the other interface*/
830 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
831 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
832 endpoint = &iface_desc->endpoint[i].desc;
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700833 if (usb_endpoint_is_int_in(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 /* we found a interrupt in endpoint */
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700835 dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
Johan Hovoldecb80e62014-08-27 11:55:18 +0200836 if (num_interrupt_in < MAX_NUM_PORTS) {
837 interrupt_in_endpoint[num_interrupt_in] = endpoint;
838 ++num_interrupt_in;
839 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 }
841 }
842 }
843
844 /* Now make sure the PL-2303 is configured correctly.
845 * If not, give up now and hope this hack will work
846 * properly during a later invocation of usb_serial_probe
847 */
848 if (num_bulk_in == 0 || num_bulk_out == 0) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700849 dev_info(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
Jan Safrata0658a332012-05-22 14:04:50 +0200850 usb_serial_put(serial);
Ming Leid92a3ca2010-08-07 16:20:35 +0800851 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 return -ENODEV;
853 }
854 }
855 /* END HORRIBLE HACK FOR PL2303 */
856#endif
857
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858#ifdef CONFIG_USB_SERIAL_GENERIC
859 if (type == &usb_serial_generic_device) {
860 num_ports = num_bulk_out;
861 if (num_ports == 0) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700862 dev_err(ddev, "Generic device with no bulk out, not allowed.\n");
Jan Safrata0658a332012-05-22 14:04:50 +0200863 usb_serial_put(serial);
Ming Leid92a3ca2010-08-07 16:20:35 +0800864 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 return -EIO;
866 }
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700867 dev_info(ddev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
868 dev_info(ddev, "Tell linux-usb@vger.kernel.org to add your device to a proper driver.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 }
870#endif
871 if (!num_ports) {
872 /* if this device type has a calc_num_ports function, call it */
Ming Leid92a3ca2010-08-07 16:20:35 +0800873 if (type->calc_num_ports)
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100874 num_ports = type->calc_num_ports(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 if (!num_ports)
876 num_ports = type->num_ports;
877 }
878
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 serial->num_ports = num_ports;
880 serial->num_bulk_in = num_bulk_in;
881 serial->num_bulk_out = num_bulk_out;
882 serial->num_interrupt_in = num_interrupt_in;
883 serial->num_interrupt_out = num_interrupt_out;
884
Alan Stern063a2da2007-10-10 16:24:06 -0400885 /* found all that we need */
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700886 dev_info(ddev, "%s converter detected\n", type->description);
Alan Stern063a2da2007-10-10 16:24:06 -0400887
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 /* create our ports, we need as many as the max endpoints */
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100889 /* we don't use num_ports here because some devices have more
890 endpoint pairs than ports */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 max_endpoints = max(num_bulk_in, num_bulk_out);
892 max_endpoints = max(max_endpoints, num_interrupt_in);
893 max_endpoints = max(max_endpoints, num_interrupt_out);
894 max_endpoints = max(max_endpoints, (int)serial->num_ports);
895 serial->num_port_pointers = max_endpoints;
Oliver Neukum4b10f0f2007-01-13 07:31:27 +0100896
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -0700897 dev_dbg(ddev, "setting up %d port structures for this device", max_endpoints);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 for (i = 0; i < max_endpoints; ++i) {
Eric Sesterhenn80b6ca42006-02-27 21:29:43 +0100899 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 if (!port)
901 goto probe_error;
Alan Cox4a90f092008-10-13 10:39:46 +0100902 tty_port_init(&port->port);
Alan Cox335f8512009-06-11 12:26:29 +0100903 port->port.ops = &serial_port_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 port->serial = serial;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700905 spin_lock_init(&port->lock);
Alan Coxe1108a62009-10-06 16:06:36 +0100906 /* Keep this for private driver use for the moment but
907 should probably go away */
David Howellsc4028952006-11-22 14:57:56 +0000908 INIT_WORK(&port->work, usb_serial_port_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 serial->port[i] = port;
Alan Stern41bd34d2009-09-01 11:38:34 -0400910 port->dev.parent = &interface->dev;
911 port->dev.driver = NULL;
912 port->dev.bus = &usb_serial_bus_type;
Johan Hovold69a3d212013-03-21 12:36:47 +0100913 port->dev.release = &usb_serial_port_release;
Alan Stern41bd34d2009-09-01 11:38:34 -0400914 device_initialize(&port->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 }
916
917 /* set up the endpoint information */
918 for (i = 0; i < num_bulk_in; ++i) {
919 endpoint = bulk_in_endpoint[i];
920 port = serial->port[i];
Alan Stern969e3032011-02-23 15:28:18 -0500921 buffer_size = max_t(int, serial->type->bulk_in_size,
Kuninori Morimoto29cc8892011-08-23 03:12:03 -0700922 usb_endpoint_maxp(endpoint));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 port->bulk_in_size = buffer_size;
924 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
Johan Hovoldd83b4052011-11-06 19:06:37 +0100925
926 for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
927 set_bit(j, &port->read_urbs_free);
928 port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
Johan Hovold6b03f7f2013-03-21 12:36:26 +0100929 if (!port->read_urbs[j])
Johan Hovoldd83b4052011-11-06 19:06:37 +0100930 goto probe_error;
Johan Hovoldd83b4052011-11-06 19:06:37 +0100931 port->bulk_in_buffers[j] = kmalloc(buffer_size,
932 GFP_KERNEL);
Johan Hovold6b03f7f2013-03-21 12:36:26 +0100933 if (!port->bulk_in_buffers[j])
Johan Hovoldd83b4052011-11-06 19:06:37 +0100934 goto probe_error;
Johan Hovoldd83b4052011-11-06 19:06:37 +0100935 usb_fill_bulk_urb(port->read_urbs[j], dev,
936 usb_rcvbulkpipe(dev,
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100937 endpoint->bEndpointAddress),
Johan Hovoldd83b4052011-11-06 19:06:37 +0100938 port->bulk_in_buffers[j], buffer_size,
939 serial->type->read_bulk_callback,
940 port);
941 }
942
943 port->read_urb = port->read_urbs[0];
944 port->bulk_in_buffer = port->bulk_in_buffers[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 }
946
947 for (i = 0; i < num_bulk_out; ++i) {
948 endpoint = bulk_out_endpoint[i];
949 port = serial->port[i];
Stefani Seibold119eecc2009-12-23 09:10:48 +0100950 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
David VomLehn8e8dce02009-08-28 12:54:27 -0700951 goto probe_error;
Johan Hovoldbbcb2b92010-03-17 23:00:37 +0100952 buffer_size = serial->type->bulk_out_size;
953 if (!buffer_size)
Kuninori Morimoto29cc8892011-08-23 03:12:03 -0700954 buffer_size = usb_endpoint_maxp(endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955 port->bulk_out_size = buffer_size;
956 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
Johan Hovold1ce7b932011-11-06 19:06:31 +0100957
Johan Hovold27c7acf2010-05-05 23:57:37 +0200958 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
959 set_bit(j, &port->write_urbs_free);
960 port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
Johan Hovold6b03f7f2013-03-21 12:36:26 +0100961 if (!port->write_urbs[j])
Johan Hovold27c7acf2010-05-05 23:57:37 +0200962 goto probe_error;
Johan Hovold27c7acf2010-05-05 23:57:37 +0200963 port->bulk_out_buffers[j] = kmalloc(buffer_size,
964 GFP_KERNEL);
Johan Hovold6b03f7f2013-03-21 12:36:26 +0100965 if (!port->bulk_out_buffers[j])
Johan Hovold27c7acf2010-05-05 23:57:37 +0200966 goto probe_error;
Johan Hovold27c7acf2010-05-05 23:57:37 +0200967 usb_fill_bulk_urb(port->write_urbs[j], dev,
968 usb_sndbulkpipe(dev,
969 endpoint->bEndpointAddress),
970 port->bulk_out_buffers[j], buffer_size,
971 serial->type->write_bulk_callback,
972 port);
973 }
Johan Hovold1ce7b932011-11-06 19:06:31 +0100974
975 port->write_urb = port->write_urbs[0];
976 port->bulk_out_buffer = port->bulk_out_buffers[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 }
978
979 if (serial->type->read_int_callback) {
980 for (i = 0; i < num_interrupt_in; ++i) {
981 endpoint = interrupt_in_endpoint[i];
982 port = serial->port[i];
983 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
Johan Hovold6b03f7f2013-03-21 12:36:26 +0100984 if (!port->interrupt_in_urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 goto probe_error;
Kuninori Morimoto29cc8892011-08-23 03:12:03 -0700986 buffer_size = usb_endpoint_maxp(endpoint);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100987 port->interrupt_in_endpointAddress =
988 endpoint->bEndpointAddress;
989 port->interrupt_in_buffer = kmalloc(buffer_size,
990 GFP_KERNEL);
Johan Hovold6b03f7f2013-03-21 12:36:26 +0100991 if (!port->interrupt_in_buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 goto probe_error;
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100993 usb_fill_int_urb(port->interrupt_in_urb, dev,
994 usb_rcvintpipe(dev,
995 endpoint->bEndpointAddress),
996 port->interrupt_in_buffer, buffer_size,
997 serial->type->read_int_callback, port,
998 endpoint->bInterval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 }
1000 } else if (num_interrupt_in) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001001 dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001002 }
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001003
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 if (serial->type->write_int_callback) {
1005 for (i = 0; i < num_interrupt_out; ++i) {
1006 endpoint = interrupt_out_endpoint[i];
1007 port = serial->port[i];
1008 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
Johan Hovold6b03f7f2013-03-21 12:36:26 +01001009 if (!port->interrupt_out_urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 goto probe_error;
Kuninori Morimoto29cc8892011-08-23 03:12:03 -07001011 buffer_size = usb_endpoint_maxp(endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 port->interrupt_out_size = buffer_size;
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001013 port->interrupt_out_endpointAddress =
1014 endpoint->bEndpointAddress;
1015 port->interrupt_out_buffer = kmalloc(buffer_size,
1016 GFP_KERNEL);
Johan Hovold6b03f7f2013-03-21 12:36:26 +01001017 if (!port->interrupt_out_buffer)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 goto probe_error;
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001019 usb_fill_int_urb(port->interrupt_out_urb, dev,
1020 usb_sndintpipe(dev,
1021 endpoint->bEndpointAddress),
1022 port->interrupt_out_buffer, buffer_size,
1023 serial->type->write_int_callback, port,
1024 endpoint->bInterval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 }
1026 } else if (num_interrupt_out) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001027 dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 }
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001029
Johan Hovoldbdce6612012-04-25 15:56:32 +02001030 usb_set_intfdata(interface, serial);
1031
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 /* if this device type has an attach function, call it */
1033 if (type->attach) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001034 retval = type->attach(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 if (retval < 0)
1036 goto probe_error;
Alan Sterna4720c62009-10-09 12:43:12 -04001037 serial->attached = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 if (retval > 0) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001039 /* quietly accept this device, but don't bind to a
1040 serial port as it's about to disappear */
Alan Stern0a3c8542009-05-27 11:25:52 -04001041 serial->num_ports = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 goto exit;
1043 }
Alan Sterna4720c62009-10-09 12:43:12 -04001044 } else {
1045 serial->attached = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 }
1047
Johan Hovolda65a6f12012-03-20 16:59:33 +01001048 /* Avoid race with tty_open and serial_install by setting the
1049 * disconnected flag and not clearing it until all ports have been
1050 * registered.
1051 */
1052 serial->disconnected = 1;
1053
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001054 if (get_free_serial(serial, num_ports, &minor) == NULL) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001055 dev_err(ddev, "No more free serial devices\n");
Oliver Neukum34ef50e2007-01-13 07:29:26 +01001056 goto probe_error;
1057 }
Oliver Neukumc744f992007-02-26 15:43:00 +01001058 serial->minor = minor;
Oliver Neukum34ef50e2007-01-13 07:29:26 +01001059
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 /* register all of the individual ports with the driver core */
1061 for (i = 0; i < num_ports; ++i) {
1062 port = serial->port[i];
Kay Sievers0031a062008-05-02 06:02:41 +02001063 dev_set_name(&port->dev, "ttyUSB%d", port->number);
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001064 dev_dbg(ddev, "registering %s", dev_name(&port->dev));
Ming Leia7a6b792010-07-13 23:56:24 +08001065 device_enable_async_suspend(&port->dev);
1066
Alan Stern41bd34d2009-09-01 11:38:34 -04001067 retval = device_add(&port->dev);
Alan Stern891a3b12012-03-28 16:10:49 -04001068 if (retval)
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001069 dev_err(ddev, "Error registering port device, continuing\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 }
1071
Johan Hovolda65a6f12012-03-20 16:59:33 +01001072 serial->disconnected = 0;
1073
Greg Kroah-Hartman3033bc82012-09-18 16:05:17 +01001074 usb_serial_console_init(minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075exit:
Ming Leid92a3ca2010-08-07 16:20:35 +08001076 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 return 0;
1078
1079probe_error:
Alan Stern41bd34d2009-09-01 11:38:34 -04001080 usb_serial_put(serial);
Ming Leid92a3ca2010-08-07 16:20:35 +08001081 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 return -EIO;
1083}
1084
Greg Kroah-Hartman32078f92012-05-07 14:02:13 -07001085static void usb_serial_disconnect(struct usb_interface *interface)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086{
1087 int i;
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001088 struct usb_serial *serial = usb_get_intfdata(interface);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 struct device *dev = &interface->dev;
1090 struct usb_serial_port *port;
1091
Guennadi Liakhovetski73e487f2006-04-25 07:46:17 +02001092 usb_serial_console_disconnect(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001093
Oliver Neukuma1cd7e92008-01-16 17:18:52 +01001094 mutex_lock(&serial->disc_mutex);
Oliver Neukuma1cd7e92008-01-16 17:18:52 +01001095 /* must set a flag, to signal subdrivers */
1096 serial->disconnected = 1;
Alan Stern2d931482009-04-14 11:31:02 -04001097 mutex_unlock(&serial->disc_mutex);
1098
Oliver Neukuma1cd7e92008-01-16 17:18:52 +01001099 for (i = 0; i < serial->num_ports; ++i) {
1100 port = serial->port[i];
1101 if (port) {
Alan Cox4a90f092008-10-13 10:39:46 +01001102 struct tty_struct *tty = tty_port_tty_get(&port->port);
1103 if (tty) {
Alan Coxd2b39182009-09-19 13:13:23 -07001104 tty_vhangup(tty);
Alan Cox4a90f092008-10-13 10:39:46 +01001105 tty_kref_put(tty);
1106 }
Johan Hovold6a5c8212013-03-21 12:36:49 +01001107 usb_serial_port_poison_urbs(port);
Johan Hovoldc371de142013-03-21 12:36:53 +01001108 wake_up_interruptible(&port->port.delta_msr_wait);
Alan Stern2d931482009-04-14 11:31:02 -04001109 cancel_work_sync(&port->work);
Alan Stern891a3b12012-03-28 16:10:49 -04001110 if (device_is_registered(&port->dev))
Alan Sternc706ebd2009-06-02 11:54:11 -04001111 device_del(&port->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 }
Johan Hovold0f16cfe2013-03-21 12:36:42 +01001114 if (serial->type->disconnect)
1115 serial->type->disconnect(serial);
Alan Stern2d931482009-04-14 11:31:02 -04001116
Alan Stern41bd34d2009-09-01 11:38:34 -04001117 /* let the last holder of this object cause it to be cleaned up */
Oliver Neukuma1cd7e92008-01-16 17:18:52 +01001118 usb_serial_put(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 dev_info(dev, "device disconnected\n");
1120}
1121
Oliver Neukumec225592007-04-27 20:54:57 +02001122int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1123{
1124 struct usb_serial *serial = usb_get_intfdata(intf);
1125 struct usb_serial_port *port;
1126 int i, r = 0;
1127
Oliver Neukumf8bece82009-02-05 16:54:25 +01001128 serial->suspending = 1;
1129
Ming Lei93e4f472013-03-15 12:08:54 +08001130 /*
1131 * serial->type->suspend() MUST return 0 in system sleep context,
1132 * otherwise, the resume callback has to recover device from
1133 * previous suspend failure.
1134 */
Oliver Neukum81e5b232009-07-21 08:47:34 +02001135 if (serial->type->suspend) {
1136 r = serial->type->suspend(serial, message);
Oliver Neukuma5f60052009-10-01 15:01:17 +02001137 if (r < 0) {
1138 serial->suspending = 0;
Oliver Neukum81e5b232009-07-21 08:47:34 +02001139 goto err_out;
Oliver Neukuma5f60052009-10-01 15:01:17 +02001140 }
Oliver Neukum81e5b232009-07-21 08:47:34 +02001141 }
1142
Oliver Neukume31c1882007-07-23 08:58:39 +02001143 for (i = 0; i < serial->num_ports; ++i) {
1144 port = serial->port[i];
1145 if (port)
Johan Hovold6a5c8212013-03-21 12:36:49 +01001146 usb_serial_port_poison_urbs(port);
Oliver Neukumec225592007-04-27 20:54:57 +02001147 }
1148
Oliver Neukum81e5b232009-07-21 08:47:34 +02001149err_out:
Oliver Neukumec225592007-04-27 20:54:57 +02001150 return r;
1151}
1152EXPORT_SYMBOL(usb_serial_suspend);
1153
Johan Hovold6a5c8212013-03-21 12:36:49 +01001154static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
1155{
1156 struct usb_serial_port *port;
1157 int i;
1158
1159 for (i = 0; i < serial->num_ports; ++i) {
1160 port = serial->port[i];
1161 if (port)
1162 usb_serial_port_unpoison_urbs(port);
1163 }
1164}
1165
Oliver Neukumec225592007-04-27 20:54:57 +02001166int usb_serial_resume(struct usb_interface *intf)
1167{
1168 struct usb_serial *serial = usb_get_intfdata(intf);
Oliver Neukumc49cfa912009-02-06 18:06:43 +01001169 int rv;
Oliver Neukumec225592007-04-27 20:54:57 +02001170
Johan Hovold6a5c8212013-03-21 12:36:49 +01001171 usb_serial_unpoison_port_urbs(serial);
1172
Oliver Neukumf8bece82009-02-05 16:54:25 +01001173 serial->suspending = 0;
Sarah Sharp8abaee22007-10-25 10:58:43 -07001174 if (serial->type->resume)
Oliver Neukumc49cfa912009-02-06 18:06:43 +01001175 rv = serial->type->resume(serial);
1176 else
1177 rv = usb_serial_generic_resume(serial);
Oliver Neukumf8bece82009-02-05 16:54:25 +01001178
Oliver Neukumc49cfa912009-02-06 18:06:43 +01001179 return rv;
Oliver Neukumec225592007-04-27 20:54:57 +02001180}
1181EXPORT_SYMBOL(usb_serial_resume);
1182
Greg Kroah-Hartman71863642012-05-15 15:40:00 -07001183static int usb_serial_reset_resume(struct usb_interface *intf)
1184{
1185 struct usb_serial *serial = usb_get_intfdata(intf);
1186 int rv;
1187
Johan Hovold6a5c8212013-03-21 12:36:49 +01001188 usb_serial_unpoison_port_urbs(serial);
1189
Greg Kroah-Hartman71863642012-05-15 15:40:00 -07001190 serial->suspending = 0;
1191 if (serial->type->reset_resume)
1192 rv = serial->type->reset_resume(serial);
Greg Kroah-Hartmandcd82cd2012-05-16 08:37:17 -07001193 else {
1194 rv = -EOPNOTSUPP;
1195 intf->needs_binding = 1;
1196 }
Greg Kroah-Hartman71863642012-05-15 15:40:00 -07001197
1198 return rv;
1199}
1200
Jeff Dikeb68e31d2006-10-02 02:17:18 -07001201static const struct tty_operations serial_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 .open = serial_open,
1203 .close = serial_close,
1204 .write = serial_write,
Johan Hovold3e1f4902011-11-10 17:40:43 +01001205 .hangup = serial_hangup,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 .write_room = serial_write_room,
1207 .ioctl = serial_ioctl,
1208 .set_termios = serial_set_termios,
1209 .throttle = serial_throttle,
1210 .unthrottle = serial_unthrottle,
1211 .break_ctl = serial_break,
1212 .chars_in_buffer = serial_chars_in_buffer,
Johan Hovold06931962013-05-05 20:32:27 +02001213 .wait_until_sent = serial_wait_until_sent,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214 .tiocmget = serial_tiocmget,
1215 .tiocmset = serial_tiocmset,
Johan Hovold3e1f4902011-11-10 17:40:43 +01001216 .get_icount = serial_get_icount,
1217 .cleanup = serial_cleanup,
1218 .install = serial_install,
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -07001219 .proc_fops = &serial_proc_fops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220};
1221
Alan Cox335f8512009-06-11 12:26:29 +01001222
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223struct tty_driver *usb_serial_tty_driver;
1224
Greg Kroah-Hartman32078f92012-05-07 14:02:13 -07001225/* Driver structure we register with the USB core */
1226static struct usb_driver usb_serial_driver = {
1227 .name = "usbserial",
1228 .probe = usb_serial_probe,
1229 .disconnect = usb_serial_disconnect,
1230 .suspend = usb_serial_suspend,
1231 .resume = usb_serial_resume,
1232 .no_dynamic_id = 1,
1233 .supports_autosuspend = 1,
1234};
1235
Linus Torvalds1da177e2005-04-16 15:20:36 -07001236static int __init usb_serial_init(void)
1237{
1238 int i;
1239 int result;
1240
1241 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1242 if (!usb_serial_tty_driver)
1243 return -ENOMEM;
1244
1245 /* Initialize our global data */
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001246 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 serial_table[i] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248
1249 result = bus_register(&usb_serial_bus_type);
1250 if (result) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001251 pr_err("%s - registering bus driver failed\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 goto exit_bus;
1253 }
1254
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255 usb_serial_tty_driver->driver_name = "usbserial";
Johan Hovold3e1f4902011-11-10 17:40:43 +01001256 usb_serial_tty_driver->name = "ttyUSB";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1258 usb_serial_tty_driver->minor_start = 0;
1259 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1260 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001261 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1262 TTY_DRIVER_DYNAMIC_DEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 usb_serial_tty_driver->init_termios = tty_std_termios;
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001264 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1265 | HUPCL | CLOCAL;
Alan Coxa5b6f602008-04-08 17:16:06 +01001266 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1267 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1269 result = tty_register_driver(usb_serial_tty_driver);
1270 if (result) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001271 pr_err("%s - tty_register_driver failed\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 goto exit_reg_driver;
1273 }
1274
1275 /* register the USB driver */
1276 result = usb_register(&usb_serial_driver);
1277 if (result < 0) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001278 pr_err("%s - usb_register failed\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 goto exit_tty;
1280 }
1281
Greg Kroah-Hartman06299db2005-05-26 05:55:55 -07001282 /* register the generic driver, if we should */
Greg Kroah-Hartman3033bc82012-09-18 16:05:17 +01001283 result = usb_serial_generic_register();
Greg Kroah-Hartman06299db2005-05-26 05:55:55 -07001284 if (result < 0) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001285 pr_err("%s - registering generic driver failed\n", __func__);
Greg Kroah-Hartman06299db2005-05-26 05:55:55 -07001286 goto exit_generic;
1287 }
1288
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 return result;
1290
Greg Kroah-Hartman06299db2005-05-26 05:55:55 -07001291exit_generic:
1292 usb_deregister(&usb_serial_driver);
1293
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294exit_tty:
1295 tty_unregister_driver(usb_serial_tty_driver);
1296
1297exit_reg_driver:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298 bus_unregister(&usb_serial_bus_type);
1299
1300exit_bus:
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001301 pr_err("%s - returning with error %d\n", __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 put_tty_driver(usb_serial_tty_driver);
1303 return result;
1304}
1305
1306
1307static void __exit usb_serial_exit(void)
1308{
1309 usb_serial_console_exit();
1310
1311 usb_serial_generic_deregister();
1312
1313 usb_deregister(&usb_serial_driver);
1314 tty_unregister_driver(usb_serial_tty_driver);
1315 put_tty_driver(usb_serial_tty_driver);
1316 bus_unregister(&usb_serial_bus_type);
1317}
1318
1319
1320module_init(usb_serial_init);
1321module_exit(usb_serial_exit);
1322
1323#define set_to_generic_if_null(type, function) \
1324 do { \
1325 if (!type->function) { \
1326 type->function = usb_serial_generic_##function; \
Johan Hovoldc3452f52013-03-21 12:36:44 +01001327 pr_debug("%s: using generic " #function "\n", \
1328 type->driver.name); \
1329 } \
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 } while (0)
1331
Johan Hovoldc3452f52013-03-21 12:36:44 +01001332static void usb_serial_operations_init(struct usb_serial_driver *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333{
1334 set_to_generic_if_null(device, open);
1335 set_to_generic_if_null(device, write);
1336 set_to_generic_if_null(device, close);
1337 set_to_generic_if_null(device, write_room);
1338 set_to_generic_if_null(device, chars_in_buffer);
Johan Hovolddcf01052013-05-08 17:51:43 +02001339 if (device->tx_empty)
1340 set_to_generic_if_null(device, wait_until_sent);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 set_to_generic_if_null(device, read_bulk_callback);
1342 set_to_generic_if_null(device, write_bulk_callback);
Johan Hovold23154322010-03-17 23:05:57 +01001343 set_to_generic_if_null(device, process_read_urb);
Johan Hovoldeaa3bcb2010-03-17 23:06:08 +01001344 set_to_generic_if_null(device, prepare_write_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345}
1346
Greg Kroah-Hartmanf799e762012-02-24 12:50:30 -08001347static int usb_serial_register(struct usb_serial_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348{
1349 int retval;
1350
Dave Younge4abe662009-02-14 21:21:13 +08001351 if (usb_disabled())
1352 return -ENODEV;
1353
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -07001354 if (!driver->description)
1355 driver->description = driver->driver.name;
Alan Stern5620b5f2011-01-11 14:16:50 -05001356 if (!driver->usb_driver) {
1357 WARN(1, "Serial driver %s has no usb_driver\n",
1358 driver->description);
1359 return -EINVAL;
1360 }
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -07001361
Johan Hovoldc3452f52013-03-21 12:36:44 +01001362 usb_serial_operations_init(driver);
1363
Linus Torvalds1da177e2005-04-16 15:20:36 -07001364 /* Add this device to our list of devices */
Andi Kleen0daeed32010-06-01 23:04:42 +02001365 mutex_lock(&table_lock);
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -07001366 list_add(&driver->driver_list, &usb_serial_driver_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001367
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -07001368 retval = usb_serial_bus_register(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 if (retval) {
Greg Kroah-Hartman92931d22012-09-13 16:30:31 -07001370 pr_err("problem %d when registering driver %s\n", retval, driver->description);
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -07001371 list_del(&driver->driver_list);
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001372 } else
Greg Kroah-Hartmanee42f6c2012-09-18 17:10:29 +01001373 pr_info("USB Serial support registered for %s\n", driver->description);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001374
Andi Kleen0daeed32010-06-01 23:04:42 +02001375 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376 return retval;
1377}
1378
Greg Kroah-Hartmanf799e762012-02-24 12:50:30 -08001379static void usb_serial_deregister(struct usb_serial_driver *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380{
Greg Kroah-Hartmanee42f6c2012-09-18 17:10:29 +01001381 pr_info("USB Serial deregistering driver %s\n", device->description);
Johan Hovold2eb1a582014-04-23 11:32:19 +02001382
Andi Kleen0daeed32010-06-01 23:04:42 +02001383 mutex_lock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 list_del(&device->driver_list);
Andi Kleen0daeed32010-06-01 23:04:42 +02001385 mutex_unlock(&table_lock);
Johan Hovold2eb1a582014-04-23 11:32:19 +02001386
1387 usb_serial_bus_deregister(device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
Alan Stern765e0ba2012-02-23 14:55:59 -05001390/**
1391 * usb_serial_register_drivers - register drivers for a usb-serial module
Alan Stern765e0ba2012-02-23 14:55:59 -05001392 * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001393 * @name: name of the usb_driver for this set of @serial_drivers
1394 * @id_table: list of all devices this @serial_drivers set binds to
Alan Stern765e0ba2012-02-23 14:55:59 -05001395 *
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001396 * Registers all the drivers in the @serial_drivers array, and dynamically
1397 * creates a struct usb_driver with the name @name and id_table of @id_table.
Alan Stern765e0ba2012-02-23 14:55:59 -05001398 */
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001399int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1400 const char *name,
1401 const struct usb_device_id *id_table)
Alan Stern765e0ba2012-02-23 14:55:59 -05001402{
1403 int rc;
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001404 struct usb_driver *udriver;
Alan Stern765e0ba2012-02-23 14:55:59 -05001405 struct usb_serial_driver * const *sd;
1406
1407 /*
1408 * udriver must be registered before any of the serial drivers,
1409 * because the store_new_id() routine for the serial drivers (in
1410 * bus.c) probes udriver.
1411 *
1412 * Performance hack: We don't want udriver to be probed until
1413 * the serial drivers are registered, because the probe would
1414 * simply fail for lack of a matching serial driver.
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001415 * So we leave udriver's id_table set to NULL until we are all set.
Alan Stern5cbe61c2012-05-07 11:20:06 -04001416 *
1417 * Suspend/resume support is implemented in the usb-serial core,
1418 * so fill in the PM-related fields in udriver.
Alan Stern765e0ba2012-02-23 14:55:59 -05001419 */
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001420 udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1421 if (!udriver)
1422 return -ENOMEM;
Alan Stern765e0ba2012-02-23 14:55:59 -05001423
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001424 udriver->name = name;
Alan Stern765e0ba2012-02-23 14:55:59 -05001425 udriver->no_dynamic_id = 1;
Alan Stern5cbe61c2012-05-07 11:20:06 -04001426 udriver->supports_autosuspend = 1;
1427 udriver->suspend = usb_serial_suspend;
1428 udriver->resume = usb_serial_resume;
Greg Kroah-Hartman5026bb02012-05-07 13:48:33 -07001429 udriver->probe = usb_serial_probe;
Greg Kroah-Hartman32078f92012-05-07 14:02:13 -07001430 udriver->disconnect = usb_serial_disconnect;
Greg Kroah-Hartman71863642012-05-15 15:40:00 -07001431
1432 /* we only set the reset_resume field if the serial_driver has one */
1433 for (sd = serial_drivers; *sd; ++sd) {
Greg Kroah-Hartman44b0f082012-09-19 08:15:21 +01001434 if ((*sd)->reset_resume) {
Greg Kroah-Hartman71863642012-05-15 15:40:00 -07001435 udriver->reset_resume = usb_serial_reset_resume;
1436 break;
Greg Kroah-Hartman44b0f082012-09-19 08:15:21 +01001437 }
Greg Kroah-Hartman71863642012-05-15 15:40:00 -07001438 }
1439
Alan Stern765e0ba2012-02-23 14:55:59 -05001440 rc = usb_register(udriver);
1441 if (rc)
1442 return rc;
1443
1444 for (sd = serial_drivers; *sd; ++sd) {
1445 (*sd)->usb_driver = udriver;
1446 rc = usb_serial_register(*sd);
1447 if (rc)
1448 goto failed;
1449 }
1450
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001451 /* Now set udriver's id_table and look for matches */
1452 udriver->id_table = id_table;
Alan Stern765e0ba2012-02-23 14:55:59 -05001453 rc = driver_attach(&udriver->drvwrap.driver);
1454 return 0;
1455
1456 failed:
1457 while (sd-- > serial_drivers)
1458 usb_serial_deregister(*sd);
1459 usb_deregister(udriver);
1460 return rc;
1461}
1462EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1463
1464/**
1465 * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
Alan Stern765e0ba2012-02-23 14:55:59 -05001466 * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1467 *
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001468 * Deregisters all the drivers in the @serial_drivers array and deregisters and
1469 * frees the struct usb_driver that was created by the call to
1470 * usb_serial_register_drivers().
Alan Stern765e0ba2012-02-23 14:55:59 -05001471 */
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001472void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
Alan Stern765e0ba2012-02-23 14:55:59 -05001473{
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001474 struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1475
Alan Stern765e0ba2012-02-23 14:55:59 -05001476 for (; *serial_drivers; ++serial_drivers)
1477 usb_serial_deregister(*serial_drivers);
1478 usb_deregister(udriver);
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001479 kfree(udriver);
Alan Stern765e0ba2012-02-23 14:55:59 -05001480}
1481EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001483MODULE_AUTHOR(DRIVER_AUTHOR);
1484MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485MODULE_LICENSE("GPL");