blob: 97355a15bbea8b5a36f3c7e52fd0eb5d4c3caa8a [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * USB Serial Converter driver
3 *
Greg Kroah-Hartman502b95c2005-06-20 21:15:16 -07004 * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
6 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
11 *
Greg Kroah-Hartman502b95c2005-06-20 21:15:16 -070012 * This driver was originally based on the ACM driver by Armin Fuerst (which was
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * based on a driver by Brad Keryan)
14 *
Alan Coxa8d6f0a2008-07-22 11:12:24 +010015 * See Documentation/usb/usb-serial.txt for more information on using this
16 * driver
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 */
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/kernel.h>
21#include <linux/errno.h>
22#include <linux/init.h>
23#include <linux/slab.h>
24#include <linux/tty.h>
25#include <linux/tty_driver.h>
26#include <linux/tty_flip.h>
27#include <linux/module.h>
28#include <linux/moduleparam.h>
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -070029#include <linux/seq_file.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/spinlock.h>
Luiz Fernando Capitulino1ce7dd22006-03-24 17:12:31 -030031#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/list.h>
Alan Coxa8d6f0a2008-07-22 11:12:24 +010033#include <linux/uaccess.h>
Alan Coxc56d3002009-07-28 00:34:58 +010034#include <linux/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070036#include <linux/usb/serial.h>
David VomLehn8e8dce02009-08-28 12:54:27 -070037#include <linux/kfifo.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070038#include "pl2303.h"
39
40/*
41 * Version Information
42 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
44#define DRIVER_DESC "USB Serial Driver core"
45
46/* Driver structure we register with the USB core */
47static struct usb_driver usb_serial_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 .name = "usbserial",
49 .probe = usb_serial_probe,
50 .disconnect = usb_serial_disconnect,
Oliver Neukumec225592007-04-27 20:54:57 +020051 .suspend = usb_serial_suspend,
52 .resume = usb_serial_resume,
Johan Hovold3e1f4902011-11-10 17:40:43 +010053 .no_dynamic_id = 1,
Alan Sternabf03182010-11-29 10:17:22 -050054 .supports_autosuspend = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -070055};
56
57/* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
58 the MODULE_DEVICE_TABLE declarations in each serial driver
59 cause the "hotplug" program to pull in whatever module is necessary
60 via modprobe, and modprobe will load usbserial because the serial
61 drivers depend on it.
62*/
63
Rusty Russell90ab5ee2012-01-13 09:32:20 +103064static bool debug;
Alan Coxa8d6f0a2008-07-22 11:12:24 +010065/* initially all NULL */
66static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
Oliver Neukum3ddad822007-07-24 15:13:42 +020067static DEFINE_MUTEX(table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070068static LIST_HEAD(usb_serial_driver_list);
69
Alan Stern8bc2c1b2009-09-01 11:38:59 -040070/*
71 * Look up the serial structure. If it is found and it hasn't been
72 * disconnected, return with its disc_mutex held and its refcount
73 * incremented. Otherwise return NULL.
74 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070075struct usb_serial *usb_serial_get_by_index(unsigned index)
76{
Oliver Neukum34ef50e2007-01-13 07:29:26 +010077 struct usb_serial *serial;
78
Oliver Neukum3ddad822007-07-24 15:13:42 +020079 mutex_lock(&table_lock);
Oliver Neukum34ef50e2007-01-13 07:29:26 +010080 serial = serial_table[index];
Linus Torvalds1da177e2005-04-16 15:20:36 -070081
Alan Stern8bc2c1b2009-09-01 11:38:59 -040082 if (serial) {
83 mutex_lock(&serial->disc_mutex);
84 if (serial->disconnected) {
85 mutex_unlock(&serial->disc_mutex);
86 serial = NULL;
87 } else {
88 kref_get(&serial->kref);
89 }
90 }
Oliver Neukum3ddad822007-07-24 15:13:42 +020091 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 return serial;
93}
94
Alan Coxa8d6f0a2008-07-22 11:12:24 +010095static struct usb_serial *get_free_serial(struct usb_serial *serial,
96 int num_ports, unsigned int *minor)
Linus Torvalds1da177e2005-04-16 15:20:36 -070097{
98 unsigned int i, j;
99 int good_spot;
100
Harvey Harrison441b62c2008-03-03 16:08:34 -0800101 dbg("%s %d", __func__, num_ports);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102
103 *minor = 0;
Oliver Neukum3ddad822007-07-24 15:13:42 +0200104 mutex_lock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
106 if (serial_table[i])
107 continue;
108
109 good_spot = 1;
110 for (j = 1; j <= num_ports-1; ++j)
111 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
112 good_spot = 0;
113 i += j;
114 break;
115 }
116 if (good_spot == 0)
117 continue;
118
119 *minor = i;
Oliver Neukuma1f721c2007-03-05 15:23:51 +0100120 j = 0;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800121 dbg("%s - minor base = %d", __func__, *minor);
Oliver Neukuma1f721c2007-03-05 15:23:51 +0100122 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 serial_table[i] = serial;
Oliver Neukuma1f721c2007-03-05 15:23:51 +0100124 serial->port[j++]->number = i;
125 }
Oliver Neukum3ddad822007-07-24 15:13:42 +0200126 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 return serial;
128 }
Oliver Neukum3ddad822007-07-24 15:13:42 +0200129 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 return NULL;
131}
132
133static void return_serial(struct usb_serial *serial)
134{
135 int i;
136
Harvey Harrison441b62c2008-03-03 16:08:34 -0800137 dbg("%s", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138
Alan Stern8bc2c1b2009-09-01 11:38:59 -0400139 mutex_lock(&table_lock);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100140 for (i = 0; i < serial->num_ports; ++i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 serial_table[serial->minor + i] = NULL;
Alan Stern8bc2c1b2009-09-01 11:38:59 -0400142 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143}
144
145static void destroy_serial(struct kref *kref)
146{
147 struct usb_serial *serial;
148 struct usb_serial_port *port;
149 int i;
150
151 serial = to_usb_serial(kref);
152
Harvey Harrison441b62c2008-03-03 16:08:34 -0800153 dbg("%s - %s", __func__, serial->type->description);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154
Jim Radford521b85a2007-03-13 08:30:50 -0700155 /* return the minor range that this device had */
Alan Stern0282b7f2008-07-29 12:01:04 -0400156 if (serial->minor != SERIAL_TTY_NO_MINOR)
157 return_serial(serial);
Jim Radford521b85a2007-03-13 08:30:50 -0700158
Alan Sterna4720c62009-10-09 12:43:12 -0400159 if (serial->attached)
160 serial->type->release(serial);
Alan Sternf9c99bb2009-06-02 11:53:55 -0400161
Alan Stern41bd34d2009-09-01 11:38:34 -0400162 /* Now that nothing is using the ports, they can be freed */
163 for (i = 0; i < serial->num_port_pointers; ++i) {
Alan Sternf9c99bb2009-06-02 11:53:55 -0400164 port = serial->port[i];
Alan Stern41bd34d2009-09-01 11:38:34 -0400165 if (port) {
166 port->serial = NULL;
Alan Sternf9c99bb2009-06-02 11:53:55 -0400167 put_device(&port->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 }
169 }
170
171 usb_put_dev(serial->dev);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100172 kfree(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173}
174
Guennadi Liakhovetski73e487f2006-04-25 07:46:17 +0200175void usb_serial_put(struct usb_serial *serial)
176{
177 kref_put(&serial->kref, destroy_serial);
178}
179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180/*****************************************************************************
181 * Driver tty interface functions
182 *****************************************************************************/
Alan Sternf5b09532009-09-01 11:38:44 -0400183
184/**
185 * serial_install - install tty
186 * @driver: the driver (USB in our case)
187 * @tty: the tty being created
188 *
189 * Create the termios objects for this tty. We use the default
190 * USB serial settings but permit them to be overridden by
191 * serial->type->init_termios.
Alan Sterncc56cd02009-09-01 11:39:13 -0400192 *
193 * This is the first place a new tty gets used. Hence this is where we
194 * acquire references to the usb_serial structure and the driver module,
195 * where we store a pointer to the port, and where we do an autoresume.
Dave Youngf278a2f2009-09-27 16:00:42 +0000196 * All these actions are reversed in serial_cleanup().
Alan Sternf5b09532009-09-01 11:38:44 -0400197 */
198static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
199{
200 int idx = tty->index;
201 struct usb_serial *serial;
Alan Sterncc56cd02009-09-01 11:39:13 -0400202 struct usb_serial_port *port;
203 int retval = -ENODEV;
204
Alan Sternff8324d2009-09-01 11:39:51 -0400205 dbg("%s", __func__);
206
Alan Sterncc56cd02009-09-01 11:39:13 -0400207 serial = usb_serial_get_by_index(idx);
208 if (!serial)
209 return retval;
210
211 port = serial->port[idx - serial->minor];
212 if (!port)
213 goto error_no_port;
214 if (!try_module_get(serial->type->driver.owner))
215 goto error_module_get;
216
217 retval = usb_autopm_get_interface(serial->interface);
218 if (retval)
219 goto error_get_interface;
Alan Sternf5b09532009-09-01 11:38:44 -0400220
Jiri Slaby76f82a72012-01-30 21:14:29 +0100221 retval = tty_standard_install(driver, tty);
222 if (retval)
223 goto error_init_termios;
224
Alan Sterncc56cd02009-09-01 11:39:13 -0400225 mutex_unlock(&serial->disc_mutex);
226
Alan Stern7e29bb42009-09-01 11:39:22 -0400227 /* allow the driver to update the settings */
228 if (serial->type->init_termios)
229 serial->type->init_termios(tty);
230
Alan Sterncc56cd02009-09-01 11:39:13 -0400231 tty->driver_data = port;
232
Alan Sterncc56cd02009-09-01 11:39:13 -0400233 return retval;
234
Alan Stern7e29bb42009-09-01 11:39:22 -0400235 error_init_termios:
Jiri Slaby76f82a72012-01-30 21:14:29 +0100236 usb_autopm_put_interface(serial->interface);
237 error_get_interface:
Alan Sterncc56cd02009-09-01 11:39:13 -0400238 module_put(serial->type->driver.owner);
239 error_module_get:
240 error_no_port:
241 usb_serial_put(serial);
242 mutex_unlock(&serial->disc_mutex);
243 return retval;
Alan Sternf5b09532009-09-01 11:38:44 -0400244}
245
Alan Cox64bc3972009-10-06 16:06:11 +0100246static int serial_activate(struct tty_port *tport, struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247{
Alan Cox64bc3972009-10-06 16:06:11 +0100248 struct usb_serial_port *port =
249 container_of(tport, struct usb_serial_port, port);
Alan Stern320348c2009-09-01 11:39:59 -0400250 struct usb_serial *serial = port->serial;
251 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
Alan Cox64bc3972009-10-06 16:06:11 +0100253 mutex_lock(&serial->disc_mutex);
254 if (serial->disconnected)
255 retval = -ENODEV;
256 else
257 retval = port->serial->type->open(tty, port);
258 mutex_unlock(&serial->disc_mutex);
Johan Hovold3827d872011-11-10 17:38:13 +0100259
260 if (retval < 0)
261 retval = usb_translate_errors(retval);
262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 return retval;
264}
265
Alan Cox64bc3972009-10-06 16:06:11 +0100266static int serial_open(struct tty_struct *tty, struct file *filp)
267{
268 struct usb_serial_port *port = tty->driver_data;
269
270 dbg("%s - port %d", __func__, port->number);
271 return tty_port_open(&port->port, tty, filp);
272}
273
Alan Cox335f8512009-06-11 12:26:29 +0100274/**
Alan Stern74556122009-09-01 11:39:40 -0400275 * serial_down - shut down hardware
Alan Coxe1108a62009-10-06 16:06:36 +0100276 * @tport: tty port to shut down
Alan Cox335f8512009-06-11 12:26:29 +0100277 *
Alan Sternf5b09532009-09-01 11:38:44 -0400278 * Shut down a USB serial port unless it is the console. We never
Alan Coxe1108a62009-10-06 16:06:36 +0100279 * shut down the console hardware as it will always be in use. Serialized
280 * against activate by the tport mutex and kept to matching open/close pairs
281 * of calls by the ASYNCB_INITIALIZED flag.
Alan Cox335f8512009-06-11 12:26:29 +0100282 */
Alan Coxe1108a62009-10-06 16:06:36 +0100283static void serial_down(struct tty_port *tport)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284{
Alan Coxe1108a62009-10-06 16:06:36 +0100285 struct usb_serial_port *port =
286 container_of(tport, struct usb_serial_port, port);
Alan Cox335f8512009-06-11 12:26:29 +0100287 struct usb_serial_driver *drv = port->serial->type;
Alan Sternf5b09532009-09-01 11:38:44 -0400288 /*
289 * The console is magical. Do not hang up the console hardware
290 * or there will be tears.
291 */
Jason Wesselbd5afa92010-03-08 21:50:12 -0600292 if (port->port.console)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 return;
Alan Cox335f8512009-06-11 12:26:29 +0100294 if (drv->close)
295 drv->close(port);
Alan Cox335f8512009-06-11 12:26:29 +0100296}
297
Alan Sternf5b09532009-09-01 11:38:44 -0400298static void serial_hangup(struct tty_struct *tty)
Alan Cox335f8512009-06-11 12:26:29 +0100299{
Alan Cox4455e342009-09-19 13:13:24 -0700300 struct usb_serial_port *port = tty->driver_data;
Alan Sternff8324d2009-09-01 11:39:51 -0400301 dbg("%s - port %d", __func__, port->number);
Alan Sternf5b09532009-09-01 11:38:44 -0400302 tty_port_hangup(&port->port);
Alan Cox335f8512009-06-11 12:26:29 +0100303}
304
305static void serial_close(struct tty_struct *tty, struct file *filp)
306{
307 struct usb_serial_port *port = tty->driver_data;
Alan Cox335f8512009-06-11 12:26:29 +0100308 dbg("%s - port %d", __func__, port->number);
Alan Coxe1108a62009-10-06 16:06:36 +0100309 tty_port_close(&port->port, tty, filp);
Alan Cox335f8512009-06-11 12:26:29 +0100310}
311
Alan Sternf5b09532009-09-01 11:38:44 -0400312/**
Dave Youngf278a2f2009-09-27 16:00:42 +0000313 * serial_cleanup - free resources post close/hangup
Alan Sternf5b09532009-09-01 11:38:44 -0400314 * @port: port to free up
315 *
316 * Do the resource freeing and refcount dropping for the port.
317 * Avoid freeing the console.
318 *
Dave Youngf278a2f2009-09-27 16:00:42 +0000319 * Called asynchronously after the last tty kref is dropped,
320 * and the tty layer has already done the tty_shutdown(tty);
Alan Sternf5b09532009-09-01 11:38:44 -0400321 */
Dave Youngf278a2f2009-09-27 16:00:42 +0000322static void serial_cleanup(struct tty_struct *tty)
Alan Cox335f8512009-06-11 12:26:29 +0100323{
324 struct usb_serial_port *port = tty->driver_data;
Alan Sternf5b09532009-09-01 11:38:44 -0400325 struct usb_serial *serial;
326 struct module *owner;
327
328 /* The console is magical. Do not hang up the console hardware
329 * or there will be tears.
330 */
Jason Wesselbd5afa92010-03-08 21:50:12 -0600331 if (port->port.console)
Alan Sternf5b09532009-09-01 11:38:44 -0400332 return;
333
Alan Sternff8324d2009-09-01 11:39:51 -0400334 dbg("%s - port %d", __func__, port->number);
335
Alan Sterncc56cd02009-09-01 11:39:13 -0400336 tty->driver_data = NULL;
337
Alan Sternf5b09532009-09-01 11:38:44 -0400338 serial = port->serial;
339 owner = serial->type->driver.owner;
340
341 mutex_lock(&serial->disc_mutex);
342 if (!serial->disconnected)
343 usb_autopm_put_interface(serial->interface);
344 mutex_unlock(&serial->disc_mutex);
345
346 usb_serial_put(serial);
347 module_put(owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348}
349
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100350static int serial_write(struct tty_struct *tty, const unsigned char *buf,
351 int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200353 struct usb_serial_port *port = tty->driver_data;
Oliver Neukum3ff4fd92007-01-13 07:32:27 +0100354 int retval = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355
Alan Coxf34d7a52008-04-30 00:54:13 -0700356 if (port->serial->dev->state == USB_STATE_NOTATTACHED)
Luiz Fernando Capitulino487f9c62005-11-28 19:16:05 -0200357 goto exit;
358
Harvey Harrison441b62c2008-03-03 16:08:34 -0800359 dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 /* pass on to the driver specific version of this function */
Alan Cox95da3102008-07-22 11:09:07 +0100362 retval = port->serial->type->write(tty, port, buf, count);
Johan Hovoldc6249ff2011-11-10 17:40:44 +0100363 if (retval < 0)
364 retval = usb_translate_errors(retval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365exit:
366 return retval;
367}
368
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100369static int serial_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200371 struct usb_serial_port *port = tty->driver_data;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800372 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 /* pass on to the driver specific version of this function */
Alan Cox95da3102008-07-22 11:09:07 +0100374 return port->serial->type->write_room(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375}
376
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100377static int serial_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200379 struct usb_serial_port *port = tty->driver_data;
Johan Hovoldb4fc2ae2009-11-22 17:42:34 +0100380 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700381
Alan Coxeff69372009-01-02 13:47:06 +0000382 /* if the device was unplugged then any remaining characters
383 fell out of the connector ;) */
384 if (port->serial->disconnected)
385 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386 /* pass on to the driver specific version of this function */
Alan Cox95da3102008-07-22 11:09:07 +0100387 return port->serial->type->chars_in_buffer(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388}
389
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100390static void serial_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200392 struct usb_serial_port *port = tty->driver_data;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800393 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 /* pass on to the driver specific version of this function */
396 if (port->serial->type->throttle)
Alan Cox95da3102008-07-22 11:09:07 +0100397 port->serial->type->throttle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398}
399
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100400static void serial_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200402 struct usb_serial_port *port = tty->driver_data;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800403 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 /* pass on to the driver specific version of this function */
406 if (port->serial->type->unthrottle)
Alan Cox95da3102008-07-22 11:09:07 +0100407 port->serial->type->unthrottle(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408}
409
Alan Cox6caa76b2011-02-14 16:27:22 +0000410static int serial_ioctl(struct tty_struct *tty,
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100411 unsigned int cmd, unsigned long arg)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200413 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 int retval = -ENODEV;
415
Harvey Harrison441b62c2008-03-03 16:08:34 -0800416 dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100418 /* pass on to the driver specific version of this function
419 if it is available */
Alan Coxf34d7a52008-04-30 00:54:13 -0700420 if (port->serial->type->ioctl) {
Alan Cox00a0d0d2011-02-14 16:27:06 +0000421 retval = port->serial->type->ioctl(tty, cmd, arg);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100422 } else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700423 retval = -ENOIOCTLCMD;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 return retval;
425}
426
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100427static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200429 struct usb_serial_port *port = tty->driver_data;
Harvey Harrison441b62c2008-03-03 16:08:34 -0800430 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100432 /* pass on to the driver specific version of this function
433 if it is available */
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
437 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
Harvey Harrison441b62c2008-03-03 16:08:34 -0800444 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100446 /* pass on to the driver specific version of this function
447 if it is available */
Alan Cox6b447f042009-01-02 13:48:56 +0000448 if (port->serial->type->break_ctl)
Alan Cox95da3102008-07-22 11:09:07 +0100449 port->serial->type->break_ctl(tty, break_state);
Alan Cox9e989662008-07-22 11:18:03 +0100450 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451}
452
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700453static int serial_proc_show(struct seq_file *m, void *v)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454{
455 struct usb_serial *serial;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 char tmp[40];
458
Harvey Harrison441b62c2008-03-03 16:08:34 -0800459 dbg("%s", __func__);
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700460 seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
461 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 serial = usb_serial_get_by_index(i);
463 if (serial == NULL)
464 continue;
465
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700466 seq_printf(m, "%d:", i);
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700467 if (serial->type->driver.owner)
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700468 seq_printf(m, " module:%s",
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100469 module_name(serial->type->driver.owner));
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700470 seq_printf(m, " name:\"%s\"",
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100471 serial->type->description);
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700472 seq_printf(m, " vendor:%04x product:%04x",
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100473 le16_to_cpu(serial->dev->descriptor.idVendor),
474 le16_to_cpu(serial->dev->descriptor.idProduct));
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700475 seq_printf(m, " num_ports:%d", serial->num_ports);
476 seq_printf(m, " port:%d", i - serial->minor + 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 usb_make_path(serial->dev, tmp, sizeof(tmp));
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700478 seq_printf(m, " path:%s", tmp);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100479
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700480 seq_putc(m, '\n');
Guennadi Liakhovetski73e487f2006-04-25 07:46:17 +0200481 usb_serial_put(serial);
Alan Stern8bc2c1b2009-09-01 11:38:59 -0400482 mutex_unlock(&serial->disc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 }
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700484 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485}
486
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -0700487static int serial_proc_open(struct inode *inode, struct file *file)
488{
489 return single_open(file, serial_proc_show, NULL);
490}
491
492static const struct file_operations serial_proc_fops = {
493 .owner = THIS_MODULE,
494 .open = serial_proc_open,
495 .read = seq_read,
496 .llseek = seq_lseek,
497 .release = single_release,
498};
499
Alan Cox60b33c12011-02-14 16:26:14 +0000500static int serial_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200502 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503
Harvey Harrison441b62c2008-03-03 16:08:34 -0800504 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 if (port->serial->type->tiocmget)
Alan Cox60b33c12011-02-14 16:26:14 +0000507 return port->serial->type->tiocmget(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 return -EINVAL;
509}
510
Alan Cox20b9d172011-02-14 16:26:50 +0000511static int serial_tiocmset(struct tty_struct *tty,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512 unsigned int set, unsigned int clear)
513{
Tobias Klauser81671dd2005-07-04 19:32:51 +0200514 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Harvey Harrison441b62c2008-03-03 16:08:34 -0800516 dbg("%s - port %d", __func__, port->number);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 if (port->serial->type->tiocmset)
Alan Cox20b9d172011-02-14 16:26:50 +0000519 return port->serial->type->tiocmset(tty, set, clear);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 return -EINVAL;
521}
522
Alan Coxd281da72010-09-16 18:21:24 +0100523static int serial_get_icount(struct tty_struct *tty,
524 struct serial_icounter_struct *icount)
525{
526 struct usb_serial_port *port = tty->driver_data;
527
528 dbg("%s - port %d", __func__, port->number);
529
530 if (port->serial->type->get_icount)
531 return port->serial->type->get_icount(tty, icount);
532 return -EINVAL;
533}
534
Pete Zaitcevcf2c7482006-05-22 21:58:49 -0700535/*
536 * We would be calling tty_wakeup here, but unfortunately some line
537 * disciplines have an annoying habit of calling tty->write from
538 * the write wakeup callback (e.g. n_hdlc.c).
539 */
540void usb_serial_port_softint(struct usb_serial_port *port)
541{
542 schedule_work(&port->work);
543}
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100544EXPORT_SYMBOL_GPL(usb_serial_port_softint);
Pete Zaitcevcf2c7482006-05-22 21:58:49 -0700545
David Howellsc4028952006-11-22 14:57:56 +0000546static void usb_serial_port_work(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547{
David Howellsc4028952006-11-22 14:57:56 +0000548 struct usb_serial_port *port =
549 container_of(work, struct usb_serial_port, work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 struct tty_struct *tty;
551
Harvey Harrison441b62c2008-03-03 16:08:34 -0800552 dbg("%s - port %d", __func__, port->number);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100553
Alan Cox4a90f092008-10-13 10:39:46 +0100554 tty = tty_port_tty_get(&port->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 if (!tty)
556 return;
557
558 tty_wakeup(tty);
Alan Cox4a90f092008-10-13 10:39:46 +0100559 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560}
561
Oliver Neukum34ef50e2007-01-13 07:29:26 +0100562static void kill_traffic(struct usb_serial_port *port)
Pete Zaitcev34f8e762006-06-21 15:00:45 -0700563{
Johan Hovold27c7acf2010-05-05 23:57:37 +0200564 int i;
565
Johan Hovoldd83b4052011-11-06 19:06:37 +0100566 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
567 usb_kill_urb(port->read_urbs[i]);
Johan Hovold27c7acf2010-05-05 23:57:37 +0200568 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
569 usb_kill_urb(port->write_urbs[i]);
Oliver Neukum5adceac2007-08-17 14:01:38 +0200570 /*
571 * This is tricky.
572 * Some drivers submit the read_urb in the
573 * handler for the write_urb or vice versa
574 * this order determines the order in which
575 * usb_kill_urb() must be used to reliably
576 * kill the URBs. As it is unknown here,
577 * both orders must be used in turn.
578 * The call below is not redundant.
579 */
580 usb_kill_urb(port->read_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 usb_kill_urb(port->interrupt_in_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 usb_kill_urb(port->interrupt_out_urb);
Oliver Neukum34ef50e2007-01-13 07:29:26 +0100583}
584
Alan Stern41bd34d2009-09-01 11:38:34 -0400585static void port_release(struct device *dev)
Oliver Neukum34ef50e2007-01-13 07:29:26 +0100586{
Alan Stern41bd34d2009-09-01 11:38:34 -0400587 struct usb_serial_port *port = to_usb_serial_port(dev);
Johan Hovold27c7acf2010-05-05 23:57:37 +0200588 int i;
Alan Stern41bd34d2009-09-01 11:38:34 -0400589
590 dbg ("%s - %s", __func__, dev_name(dev));
591
Alan Stern2d931482009-04-14 11:31:02 -0400592 /*
593 * Stop all the traffic before cancelling the work, so that
594 * nobody will restart it by calling usb_serial_port_softint.
595 */
Oliver Neukum34ef50e2007-01-13 07:29:26 +0100596 kill_traffic(port);
Alan Stern2d931482009-04-14 11:31:02 -0400597 cancel_work_sync(&port->work);
598
Oliver Neukum34ef50e2007-01-13 07:29:26 +0100599 usb_free_urb(port->interrupt_in_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 usb_free_urb(port->interrupt_out_urb);
Johan Hovoldd83b4052011-11-06 19:06:37 +0100601 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
602 usb_free_urb(port->read_urbs[i]);
603 kfree(port->bulk_in_buffers[i]);
604 }
Johan Hovold27c7acf2010-05-05 23:57:37 +0200605 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
606 usb_free_urb(port->write_urbs[i]);
607 kfree(port->bulk_out_buffers[i]);
608 }
Stefani Seibold119eecc2009-12-23 09:10:48 +0100609 kfifo_free(&port->write_fifo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 kfree(port->interrupt_in_buffer);
611 kfree(port->interrupt_out_buffer);
612 kfree(port);
613}
614
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100615static struct usb_serial *create_serial(struct usb_device *dev,
616 struct usb_interface *interface,
617 struct usb_serial_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618{
619 struct usb_serial *serial;
620
Eric Sesterhenn80b6ca42006-02-27 21:29:43 +0100621 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 if (!serial) {
Harvey Harrison441b62c2008-03-03 16:08:34 -0800623 dev_err(&dev->dev, "%s - out of memory\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 return NULL;
625 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 serial->dev = usb_get_dev(dev);
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700627 serial->type = driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 serial->interface = interface;
629 kref_init(&serial->kref);
Oliver Neukuma1cd7e92008-01-16 17:18:52 +0100630 mutex_init(&serial->disc_mutex);
Alan Stern0282b7f2008-07-29 12:01:04 -0400631 serial->minor = SERIAL_TTY_NO_MINOR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
633 return serial;
634}
635
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100636static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100637 struct usb_serial_driver *drv)
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100638{
639 struct usb_dynid *dynid;
640
641 spin_lock(&drv->dynids.lock);
642 list_for_each_entry(dynid, &drv->dynids.list, node) {
643 if (usb_match_one_id(intf, &dynid->id)) {
644 spin_unlock(&drv->dynids.lock);
645 return &dynid->id;
646 }
647 }
648 spin_unlock(&drv->dynids.lock);
649 return NULL;
650}
651
652static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
653 struct usb_interface *intf)
654{
655 const struct usb_device_id *id;
656
657 id = usb_match_id(intf, drv->id_table);
658 if (id) {
659 dbg("static descriptor matches");
660 goto exit;
661 }
662 id = match_dynamic_id(intf, drv);
663 if (id)
664 dbg("dynamic descriptor matches");
665exit:
666 return id;
667}
668
Andi Kleen0daeed32010-06-01 23:04:42 +0200669/* Caller must hold table_lock */
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100670static struct usb_serial_driver *search_serial_device(
671 struct usb_interface *iface)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 const struct usb_device_id *id;
Alan Stern063a2da2007-10-10 16:24:06 -0400674 struct usb_serial_driver *drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Adrian Bunk93b1fae2006-01-10 00:13:33 +0100676 /* Check if the usb id matches a known device */
Alan Stern063a2da2007-10-10 16:24:06 -0400677 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
678 id = get_iface_id(drv, iface);
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100679 if (id)
Alan Stern063a2da2007-10-10 16:24:06 -0400680 return drv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 }
682
683 return NULL;
684}
685
Alan Cox335f8512009-06-11 12:26:29 +0100686static int serial_carrier_raised(struct tty_port *port)
687{
688 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
689 struct usb_serial_driver *drv = p->serial->type;
Johan Hovold3e1f4902011-11-10 17:40:43 +0100690
Alan Cox335f8512009-06-11 12:26:29 +0100691 if (drv->carrier_raised)
692 return drv->carrier_raised(p);
693 /* No carrier control - don't block */
Johan Hovold3e1f4902011-11-10 17:40:43 +0100694 return 1;
Alan Cox335f8512009-06-11 12:26:29 +0100695}
696
697static void serial_dtr_rts(struct tty_port *port, int on)
698{
699 struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
700 struct usb_serial_driver *drv = p->serial->type;
Johan Hovold3e1f4902011-11-10 17:40:43 +0100701
Alan Cox335f8512009-06-11 12:26:29 +0100702 if (drv->dtr_rts)
703 drv->dtr_rts(p, on);
704}
705
706static const struct tty_port_operations serial_port_ops = {
707 .carrier_raised = serial_carrier_raised,
708 .dtr_rts = serial_dtr_rts,
Alan Cox64bc3972009-10-06 16:06:11 +0100709 .activate = serial_activate,
Alan Coxe1108a62009-10-06 16:06:36 +0100710 .shutdown = serial_down,
Alan Cox335f8512009-06-11 12:26:29 +0100711};
712
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713int usb_serial_probe(struct usb_interface *interface,
714 const struct usb_device_id *id)
715{
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100716 struct usb_device *dev = interface_to_usbdev(interface);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717 struct usb_serial *serial = NULL;
718 struct usb_serial_port *port;
719 struct usb_host_interface *iface_desc;
720 struct usb_endpoint_descriptor *endpoint;
721 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
722 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
723 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
724 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700725 struct usb_serial_driver *type = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 int retval;
Andre Hauptdd9ca5d2008-06-18 15:56:00 +0200727 unsigned int minor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728 int buffer_size;
729 int i;
Johan Hovoldd83b4052011-11-06 19:06:37 +0100730 int j;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 int num_interrupt_in = 0;
732 int num_interrupt_out = 0;
733 int num_bulk_in = 0;
734 int num_bulk_out = 0;
735 int num_ports = 0;
736 int max_endpoints;
737
Andi Kleen0daeed32010-06-01 23:04:42 +0200738 mutex_lock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 type = search_serial_device(interface);
740 if (!type) {
Andi Kleen0daeed32010-06-01 23:04:42 +0200741 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 dbg("none matched");
743 return -ENODEV;
744 }
745
Andi Kleen0daeed32010-06-01 23:04:42 +0200746 if (!try_module_get(type->driver.owner)) {
747 mutex_unlock(&table_lock);
748 dev_err(&interface->dev, "module get failed, exiting\n");
749 return -EIO;
750 }
751 mutex_unlock(&table_lock);
752
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100753 serial = create_serial(dev, interface, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 if (!serial) {
Ming Leid92a3ca2010-08-07 16:20:35 +0800755 module_put(type->driver.owner);
Harvey Harrison441b62c2008-03-03 16:08:34 -0800756 dev_err(&interface->dev, "%s - out of memory\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 return -ENOMEM;
758 }
759
760 /* if this device type has a probe function, call it */
761 if (type->probe) {
762 const struct usb_device_id *id;
763
Greg Kroah-Hartman93bacef2006-12-17 21:50:23 +0100764 id = get_iface_id(type, interface);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 retval = type->probe(serial, id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
767 if (retval) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100768 dbg("sub driver rejected device");
769 kfree(serial);
Ming Leid92a3ca2010-08-07 16:20:35 +0800770 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 return retval;
772 }
773 }
774
775 /* descriptor matches, let's find the endpoints needed */
776 /* check out the endpoints */
777 iface_desc = interface->cur_altsetting;
778 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
779 endpoint = &iface_desc->endpoint[i].desc;
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700780
781 if (usb_endpoint_is_bulk_in(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 /* we found a bulk in endpoint */
783 dbg("found bulk in on endpoint %d", i);
784 bulk_in_endpoint[num_bulk_in] = endpoint;
785 ++num_bulk_in;
786 }
787
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700788 if (usb_endpoint_is_bulk_out(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 /* we found a bulk out endpoint */
790 dbg("found bulk out on endpoint %d", i);
791 bulk_out_endpoint[num_bulk_out] = endpoint;
792 ++num_bulk_out;
793 }
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700794
795 if (usb_endpoint_is_int_in(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 /* we found a interrupt in endpoint */
797 dbg("found interrupt in on endpoint %d", i);
798 interrupt_in_endpoint[num_interrupt_in] = endpoint;
799 ++num_interrupt_in;
800 }
801
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700802 if (usb_endpoint_is_int_out(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 /* we found an interrupt out endpoint */
804 dbg("found interrupt out on endpoint %d", i);
805 interrupt_out_endpoint[num_interrupt_out] = endpoint;
806 ++num_interrupt_out;
807 }
808 }
809
810#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100811 /* BEGIN HORRIBLE HACK FOR PL2303 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 /* this is needed due to the looney way its endpoints are set up */
813 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
814 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
815 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
Johannes Steingraeber8fd80132006-09-16 16:17:34 +0200816 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
817 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
Andreas Bombece816cf2008-09-14 01:58:55 +0200818 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
819 ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
820 (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 if (interface != dev->actconfig->interface[0]) {
822 /* check out the endpoints of the other interface*/
823 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
824 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
825 endpoint = &iface_desc->endpoint[i].desc;
Luiz Fernando N. Capitulino4fa1bbf2006-09-27 11:58:53 -0700826 if (usb_endpoint_is_int_in(endpoint)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 /* we found a interrupt in endpoint */
828 dbg("found interrupt in for Prolific device on separate interface");
829 interrupt_in_endpoint[num_interrupt_in] = endpoint;
830 ++num_interrupt_in;
831 }
832 }
833 }
834
835 /* Now make sure the PL-2303 is configured correctly.
836 * If not, give up now and hope this hack will work
837 * properly during a later invocation of usb_serial_probe
838 */
839 if (num_bulk_in == 0 || num_bulk_out == 0) {
840 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100841 kfree(serial);
Ming Leid92a3ca2010-08-07 16:20:35 +0800842 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 return -ENODEV;
844 }
845 }
846 /* END HORRIBLE HACK FOR PL2303 */
847#endif
848
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849#ifdef CONFIG_USB_SERIAL_GENERIC
850 if (type == &usb_serial_generic_device) {
851 num_ports = num_bulk_out;
852 if (num_ports == 0) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100853 dev_err(&interface->dev,
854 "Generic device with no bulk out, not allowed.\n");
855 kfree(serial);
Ming Leid92a3ca2010-08-07 16:20:35 +0800856 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857 return -EIO;
858 }
859 }
860#endif
861 if (!num_ports) {
862 /* if this device type has a calc_num_ports function, call it */
Ming Leid92a3ca2010-08-07 16:20:35 +0800863 if (type->calc_num_ports)
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100864 num_ports = type->calc_num_ports(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 if (!num_ports)
866 num_ports = type->num_ports;
867 }
868
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 serial->num_ports = num_ports;
870 serial->num_bulk_in = num_bulk_in;
871 serial->num_bulk_out = num_bulk_out;
872 serial->num_interrupt_in = num_interrupt_in;
873 serial->num_interrupt_out = num_interrupt_out;
874
Alan Stern063a2da2007-10-10 16:24:06 -0400875 /* found all that we need */
876 dev_info(&interface->dev, "%s converter detected\n",
877 type->description);
878
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 /* create our ports, we need as many as the max endpoints */
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100880 /* we don't use num_ports here because some devices have more
881 endpoint pairs than ports */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 max_endpoints = max(num_bulk_in, num_bulk_out);
883 max_endpoints = max(max_endpoints, num_interrupt_in);
884 max_endpoints = max(max_endpoints, num_interrupt_out);
885 max_endpoints = max(max_endpoints, (int)serial->num_ports);
886 serial->num_port_pointers = max_endpoints;
Oliver Neukum4b10f0f2007-01-13 07:31:27 +0100887
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100888 dbg("%s - setting up %d port structures for this device",
889 __func__, max_endpoints);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 for (i = 0; i < max_endpoints; ++i) {
Eric Sesterhenn80b6ca42006-02-27 21:29:43 +0100891 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 if (!port)
893 goto probe_error;
Alan Cox4a90f092008-10-13 10:39:46 +0100894 tty_port_init(&port->port);
Alan Cox335f8512009-06-11 12:26:29 +0100895 port->port.ops = &serial_port_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 port->serial = serial;
Greg Kroah-Hartman507ca9b2005-04-23 12:49:16 -0700897 spin_lock_init(&port->lock);
Alan Coxe1108a62009-10-06 16:06:36 +0100898 /* Keep this for private driver use for the moment but
899 should probably go away */
David Howellsc4028952006-11-22 14:57:56 +0000900 INIT_WORK(&port->work, usb_serial_port_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 serial->port[i] = port;
Alan Stern41bd34d2009-09-01 11:38:34 -0400902 port->dev.parent = &interface->dev;
903 port->dev.driver = NULL;
904 port->dev.bus = &usb_serial_bus_type;
905 port->dev.release = &port_release;
906 device_initialize(&port->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 }
908
909 /* set up the endpoint information */
910 for (i = 0; i < num_bulk_in; ++i) {
911 endpoint = bulk_in_endpoint[i];
912 port = serial->port[i];
Alan Stern969e3032011-02-23 15:28:18 -0500913 buffer_size = max_t(int, serial->type->bulk_in_size,
Kuninori Morimoto29cc8892011-08-23 03:12:03 -0700914 usb_endpoint_maxp(endpoint));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 port->bulk_in_size = buffer_size;
916 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
Johan Hovoldd83b4052011-11-06 19:06:37 +0100917
918 for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
919 set_bit(j, &port->read_urbs_free);
920 port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
921 if (!port->read_urbs[j]) {
922 dev_err(&interface->dev,
923 "No free urbs available\n");
924 goto probe_error;
925 }
926 port->bulk_in_buffers[j] = kmalloc(buffer_size,
927 GFP_KERNEL);
928 if (!port->bulk_in_buffers[j]) {
929 dev_err(&interface->dev,
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100930 "Couldn't allocate bulk_in_buffer\n");
Johan Hovoldd83b4052011-11-06 19:06:37 +0100931 goto probe_error;
932 }
933 usb_fill_bulk_urb(port->read_urbs[j], dev,
934 usb_rcvbulkpipe(dev,
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100935 endpoint->bEndpointAddress),
Johan Hovoldd83b4052011-11-06 19:06:37 +0100936 port->bulk_in_buffers[j], buffer_size,
937 serial->type->read_bulk_callback,
938 port);
939 }
940
941 port->read_urb = port->read_urbs[0];
942 port->bulk_in_buffer = port->bulk_in_buffers[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 }
944
945 for (i = 0; i < num_bulk_out; ++i) {
946 endpoint = bulk_out_endpoint[i];
947 port = serial->port[i];
Stefani Seibold119eecc2009-12-23 09:10:48 +0100948 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
David VomLehn8e8dce02009-08-28 12:54:27 -0700949 goto probe_error;
Johan Hovoldbbcb2b92010-03-17 23:00:37 +0100950 buffer_size = serial->type->bulk_out_size;
951 if (!buffer_size)
Kuninori Morimoto29cc8892011-08-23 03:12:03 -0700952 buffer_size = usb_endpoint_maxp(endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953 port->bulk_out_size = buffer_size;
954 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
Johan Hovold1ce7b932011-11-06 19:06:31 +0100955
Johan Hovold27c7acf2010-05-05 23:57:37 +0200956 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
957 set_bit(j, &port->write_urbs_free);
958 port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
959 if (!port->write_urbs[j]) {
960 dev_err(&interface->dev,
961 "No free urbs available\n");
962 goto probe_error;
963 }
964 port->bulk_out_buffers[j] = kmalloc(buffer_size,
965 GFP_KERNEL);
966 if (!port->bulk_out_buffers[j]) {
967 dev_err(&interface->dev,
968 "Couldn't allocate bulk_out_buffer\n");
969 goto probe_error;
970 }
971 usb_fill_bulk_urb(port->write_urbs[j], dev,
972 usb_sndbulkpipe(dev,
973 endpoint->bEndpointAddress),
974 port->bulk_out_buffers[j], buffer_size,
975 serial->type->write_bulk_callback,
976 port);
977 }
Johan Hovold1ce7b932011-11-06 19:06:31 +0100978
979 port->write_urb = port->write_urbs[0];
980 port->bulk_out_buffer = port->bulk_out_buffers[0];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981 }
982
983 if (serial->type->read_int_callback) {
984 for (i = 0; i < num_interrupt_in; ++i) {
985 endpoint = interrupt_in_endpoint[i];
986 port = serial->port[i];
987 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
988 if (!port->interrupt_in_urb) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100989 dev_err(&interface->dev,
990 "No free urbs available\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 goto probe_error;
992 }
Kuninori Morimoto29cc8892011-08-23 03:12:03 -0700993 buffer_size = usb_endpoint_maxp(endpoint);
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100994 port->interrupt_in_endpointAddress =
995 endpoint->bEndpointAddress;
996 port->interrupt_in_buffer = kmalloc(buffer_size,
997 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 if (!port->interrupt_in_buffer) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +0100999 dev_err(&interface->dev,
1000 "Couldn't allocate interrupt_in_buffer\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 goto probe_error;
1002 }
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001003 usb_fill_int_urb(port->interrupt_in_urb, dev,
1004 usb_rcvintpipe(dev,
1005 endpoint->bEndpointAddress),
1006 port->interrupt_in_buffer, buffer_size,
1007 serial->type->read_int_callback, port,
1008 endpoint->bInterval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 }
1010 } else if (num_interrupt_in) {
1011 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
1012 }
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001013
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 if (serial->type->write_int_callback) {
1015 for (i = 0; i < num_interrupt_out; ++i) {
1016 endpoint = interrupt_out_endpoint[i];
1017 port = serial->port[i];
1018 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1019 if (!port->interrupt_out_urb) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001020 dev_err(&interface->dev,
1021 "No free urbs available\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 goto probe_error;
1023 }
Kuninori Morimoto29cc8892011-08-23 03:12:03 -07001024 buffer_size = usb_endpoint_maxp(endpoint);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025 port->interrupt_out_size = buffer_size;
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001026 port->interrupt_out_endpointAddress =
1027 endpoint->bEndpointAddress;
1028 port->interrupt_out_buffer = kmalloc(buffer_size,
1029 GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030 if (!port->interrupt_out_buffer) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001031 dev_err(&interface->dev,
1032 "Couldn't allocate interrupt_out_buffer\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 goto probe_error;
1034 }
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001035 usb_fill_int_urb(port->interrupt_out_urb, dev,
1036 usb_sndintpipe(dev,
1037 endpoint->bEndpointAddress),
1038 port->interrupt_out_buffer, buffer_size,
1039 serial->type->write_int_callback, port,
1040 endpoint->bInterval);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041 }
1042 } else if (num_interrupt_out) {
1043 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1044 }
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001045
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 /* if this device type has an attach function, call it */
1047 if (type->attach) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001048 retval = type->attach(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 if (retval < 0)
1050 goto probe_error;
Alan Sterna4720c62009-10-09 12:43:12 -04001051 serial->attached = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 if (retval > 0) {
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001053 /* quietly accept this device, but don't bind to a
1054 serial port as it's about to disappear */
Alan Stern0a3c8542009-05-27 11:25:52 -04001055 serial->num_ports = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 goto exit;
1057 }
Alan Sterna4720c62009-10-09 12:43:12 -04001058 } else {
1059 serial->attached = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001060 }
1061
Johan Hovolda65a6f12012-03-20 16:59:33 +01001062 /* Avoid race with tty_open and serial_install by setting the
1063 * disconnected flag and not clearing it until all ports have been
1064 * registered.
1065 */
1066 serial->disconnected = 1;
1067
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001068 if (get_free_serial(serial, num_ports, &minor) == NULL) {
Oliver Neukum34ef50e2007-01-13 07:29:26 +01001069 dev_err(&interface->dev, "No more free serial devices\n");
1070 goto probe_error;
1071 }
Oliver Neukumc744f992007-02-26 15:43:00 +01001072 serial->minor = minor;
Oliver Neukum34ef50e2007-01-13 07:29:26 +01001073
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 /* register all of the individual ports with the driver core */
1075 for (i = 0; i < num_ports; ++i) {
1076 port = serial->port[i];
Kay Sievers0031a062008-05-02 06:02:41 +02001077 dev_set_name(&port->dev, "ttyUSB%d", port->number);
Kay Sievers7071a3c2008-05-02 06:02:41 +02001078 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
Ming Leia7a6b792010-07-13 23:56:24 +08001079 device_enable_async_suspend(&port->dev);
1080
Alan Stern41bd34d2009-09-01 11:38:34 -04001081 retval = device_add(&port->dev);
Alan Stern891a3b12012-03-28 16:10:49 -04001082 if (retval)
Greg Kroah-Hartman13f4db92006-08-28 11:43:25 -07001083 dev_err(&port->dev, "Error registering port device, "
1084 "continuing\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 }
1086
Johan Hovolda65a6f12012-03-20 16:59:33 +01001087 serial->disconnected = 0;
1088
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001089 usb_serial_console_init(debug, minor);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090
1091exit:
1092 /* success */
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001093 usb_set_intfdata(interface, serial);
Ming Leid92a3ca2010-08-07 16:20:35 +08001094 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095 return 0;
1096
1097probe_error:
Alan Stern41bd34d2009-09-01 11:38:34 -04001098 usb_serial_put(serial);
Ming Leid92a3ca2010-08-07 16:20:35 +08001099 module_put(type->driver.owner);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 return -EIO;
1101}
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001102EXPORT_SYMBOL_GPL(usb_serial_probe);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001103
1104void usb_serial_disconnect(struct usb_interface *interface)
1105{
1106 int i;
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001107 struct usb_serial *serial = usb_get_intfdata(interface);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001108 struct device *dev = &interface->dev;
1109 struct usb_serial_port *port;
1110
Guennadi Liakhovetski73e487f2006-04-25 07:46:17 +02001111 usb_serial_console_disconnect(serial);
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001112 dbg("%s", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113
Oliver Neukuma1cd7e92008-01-16 17:18:52 +01001114 mutex_lock(&serial->disc_mutex);
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001115 usb_set_intfdata(interface, NULL);
Oliver Neukuma1cd7e92008-01-16 17:18:52 +01001116 /* must set a flag, to signal subdrivers */
1117 serial->disconnected = 1;
Alan Stern2d931482009-04-14 11:31:02 -04001118 mutex_unlock(&serial->disc_mutex);
1119
Oliver Neukuma1cd7e92008-01-16 17:18:52 +01001120 for (i = 0; i < serial->num_ports; ++i) {
1121 port = serial->port[i];
1122 if (port) {
Alan Cox4a90f092008-10-13 10:39:46 +01001123 struct tty_struct *tty = tty_port_tty_get(&port->port);
1124 if (tty) {
Alan Coxd2b39182009-09-19 13:13:23 -07001125 tty_vhangup(tty);
Alan Cox4a90f092008-10-13 10:39:46 +01001126 tty_kref_put(tty);
1127 }
Oliver Neukuma1cd7e92008-01-16 17:18:52 +01001128 kill_traffic(port);
Alan Stern2d931482009-04-14 11:31:02 -04001129 cancel_work_sync(&port->work);
Alan Stern891a3b12012-03-28 16:10:49 -04001130 if (device_is_registered(&port->dev))
Alan Sternc706ebd2009-06-02 11:54:11 -04001131 device_del(&port->dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 }
Alan Sternf9c99bb2009-06-02 11:53:55 -04001134 serial->type->disconnect(serial);
Alan Stern2d931482009-04-14 11:31:02 -04001135
Alan Stern41bd34d2009-09-01 11:38:34 -04001136 /* let the last holder of this object cause it to be cleaned up */
Oliver Neukuma1cd7e92008-01-16 17:18:52 +01001137 usb_serial_put(serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 dev_info(dev, "device disconnected\n");
1139}
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001140EXPORT_SYMBOL_GPL(usb_serial_disconnect);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141
Oliver Neukumec225592007-04-27 20:54:57 +02001142int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1143{
1144 struct usb_serial *serial = usb_get_intfdata(intf);
1145 struct usb_serial_port *port;
1146 int i, r = 0;
1147
Oliver Neukumf8bece82009-02-05 16:54:25 +01001148 serial->suspending = 1;
1149
Oliver Neukum81e5b232009-07-21 08:47:34 +02001150 if (serial->type->suspend) {
1151 r = serial->type->suspend(serial, message);
Oliver Neukuma5f60052009-10-01 15:01:17 +02001152 if (r < 0) {
1153 serial->suspending = 0;
Oliver Neukum81e5b232009-07-21 08:47:34 +02001154 goto err_out;
Oliver Neukuma5f60052009-10-01 15:01:17 +02001155 }
Oliver Neukum81e5b232009-07-21 08:47:34 +02001156 }
1157
Oliver Neukume31c1882007-07-23 08:58:39 +02001158 for (i = 0; i < serial->num_ports; ++i) {
1159 port = serial->port[i];
1160 if (port)
1161 kill_traffic(port);
Oliver Neukumec225592007-04-27 20:54:57 +02001162 }
1163
Oliver Neukum81e5b232009-07-21 08:47:34 +02001164err_out:
Oliver Neukumec225592007-04-27 20:54:57 +02001165 return r;
1166}
1167EXPORT_SYMBOL(usb_serial_suspend);
1168
1169int usb_serial_resume(struct usb_interface *intf)
1170{
1171 struct usb_serial *serial = usb_get_intfdata(intf);
Oliver Neukumc49cfa912009-02-06 18:06:43 +01001172 int rv;
Oliver Neukumec225592007-04-27 20:54:57 +02001173
Oliver Neukumf8bece82009-02-05 16:54:25 +01001174 serial->suspending = 0;
Sarah Sharp8abaee22007-10-25 10:58:43 -07001175 if (serial->type->resume)
Oliver Neukumc49cfa912009-02-06 18:06:43 +01001176 rv = serial->type->resume(serial);
1177 else
1178 rv = usb_serial_generic_resume(serial);
Oliver Neukumf8bece82009-02-05 16:54:25 +01001179
Oliver Neukumc49cfa912009-02-06 18:06:43 +01001180 return rv;
Oliver Neukumec225592007-04-27 20:54:57 +02001181}
1182EXPORT_SYMBOL(usb_serial_resume);
1183
Jeff Dikeb68e31d2006-10-02 02:17:18 -07001184static const struct tty_operations serial_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 .open = serial_open,
1186 .close = serial_close,
1187 .write = serial_write,
Johan Hovold3e1f4902011-11-10 17:40:43 +01001188 .hangup = serial_hangup,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 .write_room = serial_write_room,
1190 .ioctl = serial_ioctl,
1191 .set_termios = serial_set_termios,
1192 .throttle = serial_throttle,
1193 .unthrottle = serial_unthrottle,
1194 .break_ctl = serial_break,
1195 .chars_in_buffer = serial_chars_in_buffer,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 .tiocmget = serial_tiocmget,
1197 .tiocmset = serial_tiocmset,
Johan Hovold3e1f4902011-11-10 17:40:43 +01001198 .get_icount = serial_get_icount,
1199 .cleanup = serial_cleanup,
1200 .install = serial_install,
Alexey Dobriyan6fd69d32009-03-31 15:19:21 -07001201 .proc_fops = &serial_proc_fops,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202};
1203
Alan Cox335f8512009-06-11 12:26:29 +01001204
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205struct tty_driver *usb_serial_tty_driver;
1206
1207static int __init usb_serial_init(void)
1208{
1209 int i;
1210 int result;
1211
1212 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1213 if (!usb_serial_tty_driver)
1214 return -ENOMEM;
1215
1216 /* Initialize our global data */
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001217 for (i = 0; i < SERIAL_TTY_MINORS; ++i)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 serial_table[i] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219
1220 result = bus_register(&usb_serial_bus_type);
1221 if (result) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001222 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1223 "failed\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224 goto exit_bus;
1225 }
1226
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227 usb_serial_tty_driver->driver_name = "usbserial";
Johan Hovold3e1f4902011-11-10 17:40:43 +01001228 usb_serial_tty_driver->name = "ttyUSB";
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1230 usb_serial_tty_driver->minor_start = 0;
1231 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1232 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001233 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1234 TTY_DRIVER_DYNAMIC_DEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001235 usb_serial_tty_driver->init_termios = tty_std_termios;
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001236 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1237 | HUPCL | CLOCAL;
Alan Coxa5b6f602008-04-08 17:16:06 +01001238 usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1239 usb_serial_tty_driver->init_termios.c_ospeed = 9600;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001240 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1241 result = tty_register_driver(usb_serial_tty_driver);
1242 if (result) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001243 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1244 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 goto exit_reg_driver;
1246 }
1247
1248 /* register the USB driver */
1249 result = usb_register(&usb_serial_driver);
1250 if (result < 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001251 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1252 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 goto exit_tty;
1254 }
1255
Greg Kroah-Hartman06299db2005-05-26 05:55:55 -07001256 /* register the generic driver, if we should */
1257 result = usb_serial_generic_register(debug);
1258 if (result < 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001259 printk(KERN_ERR "usb-serial: %s - registering generic "
1260 "driver failed\n", __func__);
Greg Kroah-Hartman06299db2005-05-26 05:55:55 -07001261 goto exit_generic;
1262 }
1263
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -07001264 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265
1266 return result;
1267
Greg Kroah-Hartman06299db2005-05-26 05:55:55 -07001268exit_generic:
1269 usb_deregister(&usb_serial_driver);
1270
Linus Torvalds1da177e2005-04-16 15:20:36 -07001271exit_tty:
1272 tty_unregister_driver(usb_serial_tty_driver);
1273
1274exit_reg_driver:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 bus_unregister(&usb_serial_bus_type);
1276
1277exit_bus:
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001278 printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1279 __func__, result);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 put_tty_driver(usb_serial_tty_driver);
1281 return result;
1282}
1283
1284
1285static void __exit usb_serial_exit(void)
1286{
1287 usb_serial_console_exit();
1288
1289 usb_serial_generic_deregister();
1290
1291 usb_deregister(&usb_serial_driver);
1292 tty_unregister_driver(usb_serial_tty_driver);
1293 put_tty_driver(usb_serial_tty_driver);
1294 bus_unregister(&usb_serial_bus_type);
1295}
1296
1297
1298module_init(usb_serial_init);
1299module_exit(usb_serial_exit);
1300
1301#define set_to_generic_if_null(type, function) \
1302 do { \
1303 if (!type->function) { \
1304 type->function = usb_serial_generic_##function; \
1305 dbg("Had to override the " #function \
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001306 " usb serial operation with the generic one.");\
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 } \
1308 } while (0)
1309
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -07001310static void fixup_generic(struct usb_serial_driver *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311{
1312 set_to_generic_if_null(device, open);
1313 set_to_generic_if_null(device, write);
1314 set_to_generic_if_null(device, close);
1315 set_to_generic_if_null(device, write_room);
1316 set_to_generic_if_null(device, chars_in_buffer);
1317 set_to_generic_if_null(device, read_bulk_callback);
1318 set_to_generic_if_null(device, write_bulk_callback);
Alan Sternf9c99bb2009-06-02 11:53:55 -04001319 set_to_generic_if_null(device, disconnect);
1320 set_to_generic_if_null(device, release);
Johan Hovold23154322010-03-17 23:05:57 +01001321 set_to_generic_if_null(device, process_read_urb);
Johan Hovoldeaa3bcb2010-03-17 23:06:08 +01001322 set_to_generic_if_null(device, prepare_write_buffer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323}
1324
Greg Kroah-Hartmanf799e762012-02-24 12:50:30 -08001325static int usb_serial_register(struct usb_serial_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326{
1327 int retval;
1328
Dave Younge4abe662009-02-14 21:21:13 +08001329 if (usb_disabled())
1330 return -ENODEV;
1331
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -07001332 fixup_generic(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -07001334 if (!driver->description)
1335 driver->description = driver->driver.name;
Alan Stern5620b5f2011-01-11 14:16:50 -05001336 if (!driver->usb_driver) {
1337 WARN(1, "Serial driver %s has no usb_driver\n",
1338 driver->description);
1339 return -EINVAL;
1340 }
1341 driver->usb_driver->supports_autosuspend = 1;
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -07001342
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 /* Add this device to our list of devices */
Andi Kleen0daeed32010-06-01 23:04:42 +02001344 mutex_lock(&table_lock);
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -07001345 list_add(&driver->driver_list, &usb_serial_driver_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -07001347 retval = usb_serial_bus_register(driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 if (retval) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001349 printk(KERN_ERR "usb-serial: problem %d when registering "
1350 "driver %s\n", retval, driver->description);
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -07001351 list_del(&driver->driver_list);
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001352 } else
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -07001353 printk(KERN_INFO "USB Serial support registered for %s\n",
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001354 driver->description);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
Andi Kleen0daeed32010-06-01 23:04:42 +02001356 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 return retval;
1358}
1359
Greg Kroah-Hartmanf799e762012-02-24 12:50:30 -08001360static void usb_serial_deregister(struct usb_serial_driver *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361{
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -07001362 printk(KERN_INFO "USB Serial deregistering driver %s\n",
1363 device->description);
Andi Kleen0daeed32010-06-01 23:04:42 +02001364 mutex_lock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 list_del(&device->driver_list);
1366 usb_serial_bus_deregister(device);
Andi Kleen0daeed32010-06-01 23:04:42 +02001367 mutex_unlock(&table_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001368}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369
Alan Stern765e0ba2012-02-23 14:55:59 -05001370/**
1371 * usb_serial_register_drivers - register drivers for a usb-serial module
1372 * @udriver: usb_driver used for matching devices/interfaces
1373 * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1374 *
1375 * Registers @udriver and all the drivers in the @serial_drivers array.
1376 * Automatically fills in the .no_dynamic_id field in @udriver and
1377 * the .usb_driver field in each serial driver.
1378 */
1379int usb_serial_register_drivers(struct usb_driver *udriver,
1380 struct usb_serial_driver * const serial_drivers[])
1381{
1382 int rc;
1383 const struct usb_device_id *saved_id_table;
1384 struct usb_serial_driver * const *sd;
1385
1386 /*
1387 * udriver must be registered before any of the serial drivers,
1388 * because the store_new_id() routine for the serial drivers (in
1389 * bus.c) probes udriver.
1390 *
1391 * Performance hack: We don't want udriver to be probed until
1392 * the serial drivers are registered, because the probe would
1393 * simply fail for lack of a matching serial driver.
1394 * Therefore save off udriver's id_table until we are all set.
1395 */
1396 saved_id_table = udriver->id_table;
1397 udriver->id_table = NULL;
1398
1399 udriver->no_dynamic_id = 1;
1400 rc = usb_register(udriver);
1401 if (rc)
1402 return rc;
1403
1404 for (sd = serial_drivers; *sd; ++sd) {
1405 (*sd)->usb_driver = udriver;
1406 rc = usb_serial_register(*sd);
1407 if (rc)
1408 goto failed;
1409 }
1410
1411 /* Now restore udriver's id_table and look for matches */
1412 udriver->id_table = saved_id_table;
1413 rc = driver_attach(&udriver->drvwrap.driver);
1414 return 0;
1415
1416 failed:
1417 while (sd-- > serial_drivers)
1418 usb_serial_deregister(*sd);
1419 usb_deregister(udriver);
1420 return rc;
1421}
1422EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1423
1424/**
1425 * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1426 * @udriver: usb_driver to unregister
1427 * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1428 *
1429 * Deregisters @udriver and all the drivers in the @serial_drivers array.
1430 */
1431void usb_serial_deregister_drivers(struct usb_driver *udriver,
1432 struct usb_serial_driver * const serial_drivers[])
1433{
1434 for (; *serial_drivers; ++serial_drivers)
1435 usb_serial_deregister(*serial_drivers);
1436 usb_deregister(udriver);
1437}
1438EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439
1440/* Module information */
Alan Coxa8d6f0a2008-07-22 11:12:24 +01001441MODULE_AUTHOR(DRIVER_AUTHOR);
1442MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443MODULE_LICENSE("GPL");
1444
1445module_param(debug, bool, S_IRUGO | S_IWUSR);
1446MODULE_PARM_DESC(debug, "Debug enabled or not");