blob: 296612153ea20ca5bac102b9b98716e4bb7e2cdb [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * USB Serial Converter Generic functions
3 *
Johan Hovoldd83b4052011-11-06 19:06:37 +01004 * Copyright (C) 2010 - 2011 Johan Hovold (jhovold@gmail.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
6 *
7 * This program is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU General Public License version
9 * 2 as published by the Free Software Foundation.
10 *
11 */
12
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/kernel.h>
14#include <linux/errno.h>
15#include <linux/slab.h>
Randy Dunlap7f0ae3a2010-03-25 11:29:16 -070016#include <linux/sysrq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070017#include <linux/tty.h>
18#include <linux/tty_flip.h>
19#include <linux/module.h>
20#include <linux/moduleparam.h>
21#include <linux/usb.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070022#include <linux/usb/serial.h>
Alan Coxae643872008-07-22 11:11:55 +010023#include <linux/uaccess.h>
David VomLehn8e8dce02009-08-28 12:54:27 -070024#include <linux/kfifo.h>
Alan Stern1f871582010-02-17 10:05:47 -050025#include <linux/serial.h>
Johannes Hölzld9b1b782006-12-17 21:50:24 +010026
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#ifdef CONFIG_USB_SERIAL_GENERIC
David Brownellb46d60f2007-03-23 12:51:55 -070028
Linus Torvalds1da177e2005-04-16 15:20:36 -070029static __u16 vendor = 0x05f9;
30static __u16 product = 0xffff;
31
32module_param(vendor, ushort, 0);
33MODULE_PARM_DESC(vendor, "User specified USB idVendor");
34
35module_param(product, ushort, 0);
36MODULE_PARM_DESC(product, "User specified USB idProduct");
37
38static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */
39
40/* All of the device info needed for the Generic Serial Converter */
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -070041struct usb_serial_driver usb_serial_generic_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -070042 .driver = {
43 .owner = THIS_MODULE,
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -070044 .name = "generic",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -070045 },
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 .id_table = generic_device_ids,
Linus Torvalds1da177e2005-04-16 15:20:36 -070047 .num_ports = 1,
Alan Sternf9c99bb2009-06-02 11:53:55 -040048 .disconnect = usb_serial_generic_disconnect,
49 .release = usb_serial_generic_release,
Joris van Rantwijk253ca922007-02-01 20:08:18 +010050 .throttle = usb_serial_generic_throttle,
51 .unthrottle = usb_serial_generic_unthrottle,
Oliver Neukumec225592007-04-27 20:54:57 +020052 .resume = usb_serial_generic_resume,
Linus Torvalds1da177e2005-04-16 15:20:36 -070053};
54
Alan Stern765e0ba2012-02-23 14:55:59 -050055static struct usb_serial_driver * const serial_drivers[] = {
56 &usb_serial_generic_device, NULL
57};
58
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#endif
60
Greg Kroah-Hartman3033bc82012-09-18 16:05:17 +010061int usb_serial_generic_register(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070062{
63 int retval = 0;
64
Linus Torvalds1da177e2005-04-16 15:20:36 -070065#ifdef CONFIG_USB_SERIAL_GENERIC
66 generic_device_ids[0].idVendor = vendor;
67 generic_device_ids[0].idProduct = product;
Alan Coxae643872008-07-22 11:11:55 +010068 generic_device_ids[0].match_flags =
69 USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
71 /* register our generic driver with ourselves */
Alan Stern0b847042012-05-31 17:03:52 -040072 retval = usb_serial_register_drivers(serial_drivers,
73 "usbserial_generic", generic_device_ids);
Linus Torvalds1da177e2005-04-16 15:20:36 -070074#endif
75 return retval;
76}
77
Alan Coxae643872008-07-22 11:11:55 +010078void usb_serial_generic_deregister(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070079{
80#ifdef CONFIG_USB_SERIAL_GENERIC
81 /* remove our generic driver */
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -070082 usb_serial_deregister_drivers(serial_drivers);
Linus Torvalds1da177e2005-04-16 15:20:36 -070083#endif
84}
85
Alan Coxa509a7e2009-09-19 13:13:26 -070086int usb_serial_generic_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -070087{
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 int result = 0;
Joris van Rantwijk253ca922007-02-01 20:08:18 +010089 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Joris van Rantwijk253ca922007-02-01 20:08:18 +010091 /* clear the throttle flags */
92 spin_lock_irqsave(&port->lock, flags);
93 port->throttled = 0;
94 port->throttle_req = 0;
95 spin_unlock_irqrestore(&port->lock, flags);
96
97 /* if we have a bulk endpoint, start reading from it */
Johan Hovold41bd72f2010-03-17 23:05:53 +010098 if (port->bulk_in_size)
Johan Hovoldd83b4052011-11-06 19:06:37 +010099 result = usb_serial_generic_submit_read_urbs(port, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
101 return result;
102}
Greg Kroah-Hartman815ddc92006-05-12 11:05:29 -0700103EXPORT_SYMBOL_GPL(usb_serial_generic_open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104
Alan Cox95da3102008-07-22 11:09:07 +0100105static void generic_cleanup(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106{
107 struct usb_serial *serial = port->serial;
Johan Hovoldec3ee502010-03-17 23:00:44 +0100108 unsigned long flags;
Johan Hovold27c7acf2010-05-05 23:57:37 +0200109 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 if (serial->dev) {
Johan Hovoldeb8878a2010-02-27 16:24:49 +0100112 /* shutdown any bulk transfers that might be going on */
Johan Hovoldec3ee502010-03-17 23:00:44 +0100113 if (port->bulk_out_size) {
Johan Hovold27c7acf2010-05-05 23:57:37 +0200114 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
115 usb_kill_urb(port->write_urbs[i]);
Johan Hovoldec3ee502010-03-17 23:00:44 +0100116
117 spin_lock_irqsave(&port->lock, flags);
118 kfifo_reset_out(&port->write_fifo);
119 spin_unlock_irqrestore(&port->lock, flags);
120 }
Johan Hovoldd83b4052011-11-06 19:06:37 +0100121 if (port->bulk_in_size) {
122 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
123 usb_kill_urb(port->read_urbs[i]);
124 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 }
126}
127
Alan Cox335f8512009-06-11 12:26:29 +0100128void usb_serial_generic_close(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129{
Alan Coxae643872008-07-22 11:11:55 +0100130 generic_cleanup(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131}
Johan Hovoldf26788d2010-03-17 23:00:45 +0100132EXPORT_SYMBOL_GPL(usb_serial_generic_close);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133
Johan Hovoldeaa3bcb2010-03-17 23:06:08 +0100134int usb_serial_generic_prepare_write_buffer(struct usb_serial_port *port,
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200135 void *dest, size_t size)
Johan Hovoldeaa3bcb2010-03-17 23:06:08 +0100136{
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200137 return kfifo_out_locked(&port->write_fifo, dest, size, &port->lock);
Jason Wessel715b1dc2009-05-11 15:24:07 -0500138}
139
David VomLehn8e8dce02009-08-28 12:54:27 -0700140/**
141 * usb_serial_generic_write_start - kick off an URB write
142 * @port: Pointer to the &struct usb_serial_port data
143 *
Johan Hovold27c7acf2010-05-05 23:57:37 +0200144 * Returns zero on success, or a negative errno value
David VomLehn8e8dce02009-08-28 12:54:27 -0700145 */
146static int usb_serial_generic_write_start(struct usb_serial_port *port)
147{
Johan Hovold27c7acf2010-05-05 23:57:37 +0200148 struct urb *urb;
149 int count, result;
David VomLehn8e8dce02009-08-28 12:54:27 -0700150 unsigned long flags;
Johan Hovold27c7acf2010-05-05 23:57:37 +0200151 int i;
David VomLehn8e8dce02009-08-28 12:54:27 -0700152
Johan Hovold27c7acf2010-05-05 23:57:37 +0200153 if (test_and_set_bit_lock(USB_SERIAL_WRITE_BUSY, &port->flags))
154 return 0;
155retry:
David VomLehn8e8dce02009-08-28 12:54:27 -0700156 spin_lock_irqsave(&port->lock, flags);
Johan Hovold27c7acf2010-05-05 23:57:37 +0200157 if (!port->write_urbs_free || !kfifo_len(&port->write_fifo)) {
158 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
Johan Hovold50a5f702010-03-17 23:06:02 +0100159 spin_unlock_irqrestore(&port->lock, flags);
David VomLehn8e8dce02009-08-28 12:54:27 -0700160 return 0;
Johan Hovold50a5f702010-03-17 23:06:02 +0100161 }
Johan Hovold27c7acf2010-05-05 23:57:37 +0200162 i = (int)find_first_bit(&port->write_urbs_free,
163 ARRAY_SIZE(port->write_urbs));
Johan Hovold50a5f702010-03-17 23:06:02 +0100164 spin_unlock_irqrestore(&port->lock, flags);
David VomLehn8e8dce02009-08-28 12:54:27 -0700165
Johan Hovold27c7acf2010-05-05 23:57:37 +0200166 urb = port->write_urbs[i];
Johan Hovoldeaa3bcb2010-03-17 23:06:08 +0100167 count = port->serial->type->prepare_write_buffer(port,
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200168 urb->transfer_buffer,
169 port->bulk_out_size);
Johan Hovold27c7acf2010-05-05 23:57:37 +0200170 urb->transfer_buffer_length = count;
Greg Kroah-Hartman59d33f22012-09-18 09:58:57 +0100171 usb_serial_debug_data(&port->dev, __func__, count, urb->transfer_buffer);
Johan Hovoldb58af402010-08-04 15:45:57 +0200172 spin_lock_irqsave(&port->lock, flags);
173 port->tx_bytes += count;
174 spin_unlock_irqrestore(&port->lock, flags);
175
176 clear_bit(i, &port->write_urbs_free);
Johan Hovold27c7acf2010-05-05 23:57:37 +0200177 result = usb_submit_urb(urb, GFP_ATOMIC);
David VomLehn8e8dce02009-08-28 12:54:27 -0700178 if (result) {
Johan Hovoldf1475a02012-02-10 13:20:50 +0100179 dev_err_console(port, "%s - error submitting urb: %d\n",
David VomLehn8e8dce02009-08-28 12:54:27 -0700180 __func__, result);
Johan Hovoldb58af402010-08-04 15:45:57 +0200181 set_bit(i, &port->write_urbs_free);
182 spin_lock_irqsave(&port->lock, flags);
183 port->tx_bytes -= count;
184 spin_unlock_irqrestore(&port->lock, flags);
185
Johan Hovold27c7acf2010-05-05 23:57:37 +0200186 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
Johan Hovold30af7fb2010-03-17 23:00:42 +0100187 return result;
188 }
Johan Hovold30af7fb2010-03-17 23:00:42 +0100189
Johan Hovold27c7acf2010-05-05 23:57:37 +0200190 /* Try sending off another urb, unless in irq context (in which case
191 * there will be no free urb). */
192 if (!in_irq())
193 goto retry;
194
195 clear_bit_unlock(USB_SERIAL_WRITE_BUSY, &port->flags);
196
197 return 0;
David VomLehn8e8dce02009-08-28 12:54:27 -0700198}
199
200/**
201 * usb_serial_generic_write - generic write function for serial USB devices
202 * @tty: Pointer to &struct tty_struct for the device
203 * @port: Pointer to the &usb_serial_port structure for the device
204 * @buf: Pointer to the data to write
205 * @count: Number of bytes to write
206 *
207 * Returns the number of characters actually written, which may be anything
208 * from zero to @count. If an error occurs, it returns the negative errno
209 * value.
210 */
Alan Cox95da3102008-07-22 11:09:07 +0100211int usb_serial_generic_write(struct tty_struct *tty,
212 struct usb_serial_port *port, const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214 int result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
Johan Hovoldeb8878a2010-02-27 16:24:49 +0100216 /* only do something if we have a bulk out endpoint */
217 if (!port->bulk_out_size)
218 return -ENODEV;
219
Johan Hovold1a1405e2010-03-17 23:06:01 +0100220 if (!count)
Alan Coxae643872008-07-22 11:11:55 +0100221 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222
Stefani Seibold119eecc2009-12-23 09:10:48 +0100223 count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
David VomLehn8e8dce02009-08-28 12:54:27 -0700224 result = usb_serial_generic_write_start(port);
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200225 if (result)
226 return result;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200228 return count;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229}
Jason Wessel98fcb5f2009-05-11 15:24:09 -0500230EXPORT_SYMBOL_GPL(usb_serial_generic_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Alan Coxae643872008-07-22 11:11:55 +0100232int usb_serial_generic_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233{
Alan Cox95da3102008-07-22 11:09:07 +0100234 struct usb_serial_port *port = tty->driver_data;
Jason Wessel715b1dc2009-05-11 15:24:07 -0500235 unsigned long flags;
Johan Hovold25d514c2010-03-17 23:06:07 +0100236 int room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237
Johan Hovoldeb8878a2010-02-27 16:24:49 +0100238 if (!port->bulk_out_size)
239 return 0;
240
Jason Wessel715b1dc2009-05-11 15:24:07 -0500241 spin_lock_irqsave(&port->lock, flags);
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200242 room = kfifo_avail(&port->write_fifo);
Jason Wessel715b1dc2009-05-11 15:24:07 -0500243 spin_unlock_irqrestore(&port->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
Greg Kroah-Hartman689c2782012-05-15 16:27:18 -0700245 dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
Alan Coxa5b6f602008-04-08 17:16:06 +0100246 return room;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247}
248
Alan Cox95da3102008-07-22 11:09:07 +0100249int usb_serial_generic_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250{
Alan Cox95da3102008-07-22 11:09:07 +0100251 struct usb_serial_port *port = tty->driver_data;
Jason Wessel715b1dc2009-05-11 15:24:07 -0500252 unsigned long flags;
Johan Hovoldeb8878a2010-02-27 16:24:49 +0100253 int chars;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254
Johan Hovoldeb8878a2010-02-27 16:24:49 +0100255 if (!port->bulk_out_size)
256 return 0;
257
Stefani Seibold25719e6b2010-01-05 14:30:31 +0100258 spin_lock_irqsave(&port->lock, flags);
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200259 chars = kfifo_len(&port->write_fifo) + port->tx_bytes;
Stefani Seibold25719e6b2010-01-05 14:30:31 +0100260 spin_unlock_irqrestore(&port->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
Greg Kroah-Hartman689c2782012-05-15 16:27:18 -0700262 dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
Alan Cox95da3102008-07-22 11:09:07 +0100263 return chars;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264}
265
Johan Hovoldd83b4052011-11-06 19:06:37 +0100266static int usb_serial_generic_submit_read_urb(struct usb_serial_port *port,
267 int index, gfp_t mem_flags)
268{
269 int res;
270
271 if (!test_and_clear_bit(index, &port->read_urbs_free))
272 return 0;
273
Greg Kroah-Hartman689c2782012-05-15 16:27:18 -0700274 dev_dbg(&port->dev, "%s - port %d, urb %d\n", __func__,
275 port->number, index);
Johan Hovoldd83b4052011-11-06 19:06:37 +0100276
277 res = usb_submit_urb(port->read_urbs[index], mem_flags);
278 if (res) {
279 if (res != -EPERM) {
280 dev_err(&port->dev,
281 "%s - usb_submit_urb failed: %d\n",
282 __func__, res);
283 }
284 set_bit(index, &port->read_urbs_free);
285 return res;
286 }
287
288 return 0;
289}
290
291int usb_serial_generic_submit_read_urbs(struct usb_serial_port *port,
Johan Hovold41bd72f2010-03-17 23:05:53 +0100292 gfp_t mem_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293{
Johan Hovoldd83b4052011-11-06 19:06:37 +0100294 int res;
295 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
Johan Hovoldd83b4052011-11-06 19:06:37 +0100297 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
298 res = usb_serial_generic_submit_read_urb(port, i, mem_flags);
299 if (res)
300 goto err;
Johan Hovold0ae14742010-02-27 14:05:46 +0100301 }
Johan Hovoldd83b4052011-11-06 19:06:37 +0100302
303 return 0;
304err:
305 for (; i >= 0; --i)
306 usb_kill_urb(port->read_urbs[i]);
307
308 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309}
Johan Hovoldd83b4052011-11-06 19:06:37 +0100310EXPORT_SYMBOL_GPL(usb_serial_generic_submit_read_urbs);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100311
Johan Hovold23154322010-03-17 23:05:57 +0100312void usb_serial_generic_process_read_urb(struct urb *urb)
Oliver Neukum1abdeeb2007-05-07 12:09:33 +0200313{
Johan Hovold0f3d5ba2010-03-17 23:05:56 +0100314 struct usb_serial_port *port = urb->context;
315 struct tty_struct *tty;
Jason Wessel98fcb5f2009-05-11 15:24:09 -0500316 char *ch = (char *)urb->transfer_buffer;
317 int i;
318
Johan Hovold56a1df42010-05-15 17:53:44 +0200319 if (!urb->actual_length)
320 return;
321
Johan Hovold0f3d5ba2010-03-17 23:05:56 +0100322 tty = tty_port_tty_get(&port->port);
Jason Wessel98fcb5f2009-05-11 15:24:09 -0500323 if (!tty)
Johan Hovold0f3d5ba2010-03-17 23:05:56 +0100324 return;
Oliver Neukum1abdeeb2007-05-07 12:09:33 +0200325
Alan Cox4cd1de02009-07-09 13:35:52 +0100326 /* The per character mucking around with sysrq path it too slow for
327 stuff like 3G modems, so shortcircuit it in the 99.9999999% of cases
328 where the USB serial is not a console anyway */
Jason Wesselbd5afa92010-03-08 21:50:12 -0600329 if (!port->port.console || !port->sysrq)
Alan Cox4cd1de02009-07-09 13:35:52 +0100330 tty_insert_flip_string(tty, ch, urb->actual_length);
331 else {
Alan Cox4cd1de02009-07-09 13:35:52 +0100332 for (i = 0; i < urb->actual_length; i++, ch++) {
Dmitry Torokhov6ee9f4b2010-08-17 21:15:47 -0700333 if (!usb_serial_handle_sysrq_char(port, *ch))
Alan Cox4cd1de02009-07-09 13:35:52 +0100334 tty_insert_flip_char(tty, *ch, TTY_NORMAL);
335 }
Oliver Neukum1abdeeb2007-05-07 12:09:33 +0200336 }
Jason Wessel98fcb5f2009-05-11 15:24:09 -0500337 tty_flip_buffer_push(tty);
Alan Cox4a90f092008-10-13 10:39:46 +0100338 tty_kref_put(tty);
Oliver Neukum1abdeeb2007-05-07 12:09:33 +0200339}
Johan Hovold23154322010-03-17 23:05:57 +0100340EXPORT_SYMBOL_GPL(usb_serial_generic_process_read_urb);
Oliver Neukum1abdeeb2007-05-07 12:09:33 +0200341
Alan Cox95da3102008-07-22 11:09:07 +0100342void usb_serial_generic_read_bulk_callback(struct urb *urb)
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100343{
Ming Leicdc97792008-02-24 18:41:47 +0800344 struct usb_serial_port *port = urb->context;
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100345 unsigned char *data = urb->transfer_buffer;
Borislav Petkovbfaeafc2007-10-28 13:24:16 +0100346 unsigned long flags;
Johan Hovoldd83b4052011-11-06 19:06:37 +0100347 int i;
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100348
Johan Hovoldd83b4052011-11-06 19:06:37 +0100349 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
350 if (urb == port->read_urbs[i])
351 break;
352 }
353 set_bit(i, &port->read_urbs_free);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100354
Greg Kroah-Hartman689c2782012-05-15 16:27:18 -0700355 dev_dbg(&port->dev, "%s - port %d, urb %d, len %d\n",
356 __func__, port->number, i, urb->actual_length);
357
Johan Hovoldd83b4052011-11-06 19:06:37 +0100358 if (urb->status) {
Greg Kroah-Hartman689c2782012-05-15 16:27:18 -0700359 dev_dbg(&port->dev, "%s - non-zero urb status: %d\n",
360 __func__, urb->status);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100361 return;
362 }
363
Greg Kroah-Hartman59d33f22012-09-18 09:58:57 +0100364 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
Johan Hovold23154322010-03-17 23:05:57 +0100365 port->serial->type->process_read_urb(urb);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100366
367 /* Throttle the device if requested by tty */
Borislav Petkovbfaeafc2007-10-28 13:24:16 +0100368 spin_lock_irqsave(&port->lock, flags);
Alan Coxae643872008-07-22 11:11:55 +0100369 port->throttled = port->throttle_req;
370 if (!port->throttled) {
Pete Zaitcevb507cc92008-03-04 23:28:42 -0800371 spin_unlock_irqrestore(&port->lock, flags);
Johan Hovoldd83b4052011-11-06 19:06:37 +0100372 usb_serial_generic_submit_read_urb(port, i, GFP_ATOMIC);
Alan Coxae643872008-07-22 11:11:55 +0100373 } else
Pete Zaitcevb507cc92008-03-04 23:28:42 -0800374 spin_unlock_irqrestore(&port->lock, flags);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100375}
Luiz Fernando N. Capitulino166ffcc2006-07-11 14:19:25 -0300376EXPORT_SYMBOL_GPL(usb_serial_generic_read_bulk_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Alan Cox95da3102008-07-22 11:09:07 +0100378void usb_serial_generic_write_bulk_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379{
Jason Wessel715b1dc2009-05-11 15:24:07 -0500380 unsigned long flags;
Ming Leicdc97792008-02-24 18:41:47 +0800381 struct usb_serial_port *port = urb->context;
Greg Kroah-Hartmanfbd272252007-06-15 15:44:13 -0700382 int status = urb->status;
Johan Hovold27c7acf2010-05-05 23:57:37 +0200383 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700384
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200385 for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
386 if (port->write_urbs[i] == urb)
387 break;
388
389 spin_lock_irqsave(&port->lock, flags);
390 port->tx_bytes -= urb->transfer_buffer_length;
391 set_bit(i, &port->write_urbs_free);
392 spin_unlock_irqrestore(&port->lock, flags);
393
394 if (status) {
Greg Kroah-Hartman689c2782012-05-15 16:27:18 -0700395 dev_dbg(&port->dev, "%s - non-zero urb status: %d\n",
396 __func__, status);
Johan Hovold25915302010-01-06 15:48:42 -0800397
Jason Wessel715b1dc2009-05-11 15:24:07 -0500398 spin_lock_irqsave(&port->lock, flags);
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200399 kfifo_reset_out(&port->write_fifo);
Jason Wessel715b1dc2009-05-11 15:24:07 -0500400 spin_unlock_irqrestore(&port->lock, flags);
401 } else {
Johan Hovoldc23e5fc2010-05-05 23:58:13 +0200402 usb_serial_generic_write_start(port);
Jason Wessel715b1dc2009-05-11 15:24:07 -0500403 }
404
Pete Zaitcevcf2c7482006-05-22 21:58:49 -0700405 usb_serial_port_softint(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406}
Greg Kroah-Hartmanbb833982005-11-17 09:48:18 -0800407EXPORT_SYMBOL_GPL(usb_serial_generic_write_bulk_callback);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Alan Cox95da3102008-07-22 11:09:07 +0100409void usb_serial_generic_throttle(struct tty_struct *tty)
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100410{
Alan Cox95da3102008-07-22 11:09:07 +0100411 struct usb_serial_port *port = tty->driver_data;
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100412 unsigned long flags;
413
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100414 /* Set the throttle request flag. It will be picked up
415 * by usb_serial_generic_read_bulk_callback(). */
416 spin_lock_irqsave(&port->lock, flags);
417 port->throttle_req = 1;
418 spin_unlock_irqrestore(&port->lock, flags);
419}
Johan Hovoldf1e949a2010-03-17 23:05:59 +0100420EXPORT_SYMBOL_GPL(usb_serial_generic_throttle);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100421
Alan Cox95da3102008-07-22 11:09:07 +0100422void usb_serial_generic_unthrottle(struct tty_struct *tty)
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100423{
Alan Cox95da3102008-07-22 11:09:07 +0100424 struct usb_serial_port *port = tty->driver_data;
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100425 int was_throttled;
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100426
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100427 /* Clear the throttle flags */
Johan Hovold0f3d5ba2010-03-17 23:05:56 +0100428 spin_lock_irq(&port->lock);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100429 was_throttled = port->throttled;
430 port->throttled = port->throttle_req = 0;
Johan Hovold0f3d5ba2010-03-17 23:05:56 +0100431 spin_unlock_irq(&port->lock);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100432
Johan Hovold0f3d5ba2010-03-17 23:05:56 +0100433 if (was_throttled)
Johan Hovoldd83b4052011-11-06 19:06:37 +0100434 usb_serial_generic_submit_read_urbs(port, GFP_KERNEL);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100435}
Johan Hovoldf1e949a2010-03-17 23:05:59 +0100436EXPORT_SYMBOL_GPL(usb_serial_generic_unthrottle);
Joris van Rantwijk253ca922007-02-01 20:08:18 +0100437
Randy Dunlap7f0ae3a2010-03-25 11:29:16 -0700438#ifdef CONFIG_MAGIC_SYSRQ
Dmitry Torokhov6ee9f4b2010-08-17 21:15:47 -0700439int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch)
Jason Wessel98fcb5f2009-05-11 15:24:09 -0500440{
Jason Wesselbd5afa92010-03-08 21:50:12 -0600441 if (port->sysrq && port->port.console) {
Jason Wessel98fcb5f2009-05-11 15:24:09 -0500442 if (ch && time_before(jiffies, port->sysrq)) {
Dmitry Torokhovf3353972010-08-17 21:15:47 -0700443 handle_sysrq(ch);
Jason Wessel98fcb5f2009-05-11 15:24:09 -0500444 port->sysrq = 0;
445 return 1;
446 }
447 port->sysrq = 0;
448 }
449 return 0;
450}
Randy Dunlap7f0ae3a2010-03-25 11:29:16 -0700451#else
Dmitry Torokhov6ee9f4b2010-08-17 21:15:47 -0700452int usb_serial_handle_sysrq_char(struct usb_serial_port *port, unsigned int ch)
Randy Dunlap7f0ae3a2010-03-25 11:29:16 -0700453{
454 return 0;
455}
456#endif
Jason Wessel98fcb5f2009-05-11 15:24:09 -0500457EXPORT_SYMBOL_GPL(usb_serial_handle_sysrq_char);
458
459int usb_serial_handle_break(struct usb_serial_port *port)
460{
461 if (!port->sysrq) {
462 port->sysrq = jiffies + HZ*5;
463 return 1;
464 }
465 port->sysrq = 0;
466 return 0;
467}
468EXPORT_SYMBOL_GPL(usb_serial_handle_break);
469
Libor Pechacekd14fc1a2011-01-14 14:30:21 +0100470/**
471 * usb_serial_handle_dcd_change - handle a change of carrier detect state
472 * @port: usb_serial_port structure for the open port
473 * @tty: tty_struct structure for the port
474 * @status: new carrier detect status, nonzero if active
475 */
476void usb_serial_handle_dcd_change(struct usb_serial_port *usb_port,
477 struct tty_struct *tty, unsigned int status)
478{
479 struct tty_port *port = &usb_port->port;
480
Greg Kroah-Hartman689c2782012-05-15 16:27:18 -0700481 dev_dbg(&usb_port->dev, "%s - port %d, status %d\n", __func__,
482 usb_port->number, status);
Libor Pechacekd14fc1a2011-01-14 14:30:21 +0100483
484 if (status)
485 wake_up_interruptible(&port->open_wait);
486 else if (tty && !C_CLOCAL(tty))
487 tty_hangup(tty);
488}
489EXPORT_SYMBOL_GPL(usb_serial_handle_dcd_change);
490
David VomLehn8e8dce02009-08-28 12:54:27 -0700491int usb_serial_generic_resume(struct usb_serial *serial)
492{
493 struct usb_serial_port *port;
494 int i, c = 0, r;
495
496 for (i = 0; i < serial->num_ports; i++) {
497 port = serial->port[i];
Alan Stern1f871582010-02-17 10:05:47 -0500498 if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
David VomLehn8e8dce02009-08-28 12:54:27 -0700499 continue;
500
Johan Hovoldd83b4052011-11-06 19:06:37 +0100501 if (port->bulk_in_size) {
502 r = usb_serial_generic_submit_read_urbs(port,
503 GFP_NOIO);
David VomLehn8e8dce02009-08-28 12:54:27 -0700504 if (r < 0)
505 c++;
506 }
507
Johan Hovold27c7acf2010-05-05 23:57:37 +0200508 if (port->bulk_out_size) {
David VomLehn8e8dce02009-08-28 12:54:27 -0700509 r = usb_serial_generic_write_start(port);
510 if (r < 0)
511 c++;
512 }
513 }
514
515 return c ? -EIO : 0;
516}
517EXPORT_SYMBOL_GPL(usb_serial_generic_resume);
518
Alan Sternf9c99bb2009-06-02 11:53:55 -0400519void usb_serial_generic_disconnect(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520{
521 int i;
522
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 /* stop reads and writes on all ports */
Alan Coxae643872008-07-22 11:11:55 +0100524 for (i = 0; i < serial->num_ports; ++i)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 generic_cleanup(serial->port[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526}
Bill Pemberton5c7efeb2010-08-05 17:01:10 -0400527EXPORT_SYMBOL_GPL(usb_serial_generic_disconnect);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528
Alan Sternf9c99bb2009-06-02 11:53:55 -0400529void usb_serial_generic_release(struct usb_serial *serial)
530{
Alan Sternf9c99bb2009-06-02 11:53:55 -0400531}