blob: b0526786fb026e499c40c3682cb6e37aa3eb54a3 [file] [log] [blame]
Greg Kroah-Hartman5fd54ac2017-11-03 11:28:30 +01001// SPDX-License-Identifier: GPL-2.0+
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3* Digi AccelePort USB-4 and USB-2 Serial Converters
4*
5* Copyright 2000 by Digi International
6*
Linus Torvalds1da177e2005-04-16 15:20:36 -07007* Shamelessly based on Brian Warner's keyspan_pda.c and Greg Kroah-Hartman's
8* usb-serial driver.
9*
10* Peter Berger (pberger@brimson.com)
11* Al Borchers (borchers@steinerpoint.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -070012*/
13
Linus Torvalds1da177e2005-04-16 15:20:36 -070014#include <linux/kernel.h>
15#include <linux/errno.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/slab.h>
17#include <linux/tty.h>
18#include <linux/tty_driver.h>
19#include <linux/tty_flip.h>
20#include <linux/module.h>
21#include <linux/spinlock.h>
22#include <linux/workqueue.h>
Alan Cox41ad4272008-07-22 11:11:02 +010023#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <linux/usb.h>
25#include <linux/wait.h>
Ingo Molnar174cd4b2017-02-02 19:15:33 +010026#include <linux/sched/signal.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -070027#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028
29/* Defines */
30
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#define DRIVER_AUTHOR "Peter Berger <pberger@brimson.com>, Al Borchers <borchers@steinerpoint.com>"
32#define DRIVER_DESC "Digi AccelePort USB-2/USB-4 Serial Converter driver"
33
34/* port output buffer length -- must be <= transfer buffer length - 2 */
35/* so we can be sure to send the full buffer in one urb */
36#define DIGI_OUT_BUF_SIZE 8
37
38/* port input buffer length -- must be >= transfer buffer length - 3 */
39/* so we can be sure to hold at least one full buffer from one urb */
40#define DIGI_IN_BUF_SIZE 64
41
42/* retry timeout while sleeping */
43#define DIGI_RETRY_TIMEOUT (HZ/10)
44
45/* timeout while waiting for tty output to drain in close */
46/* this delay is used twice in close, so the total delay could */
47/* be twice this value */
48#define DIGI_CLOSE_TIMEOUT (5*HZ)
49
50
51/* AccelePort USB Defines */
52
53/* ids */
54#define DIGI_VENDOR_ID 0x05c5
55#define DIGI_2_ID 0x0002 /* USB-2 */
56#define DIGI_4_ID 0x0004 /* USB-4 */
57
58/* commands
59 * "INB": can be used on the in-band endpoint
60 * "OOB": can be used on the out-of-band endpoint
61 */
62#define DIGI_CMD_SET_BAUD_RATE 0 /* INB, OOB */
63#define DIGI_CMD_SET_WORD_SIZE 1 /* INB, OOB */
64#define DIGI_CMD_SET_PARITY 2 /* INB, OOB */
65#define DIGI_CMD_SET_STOP_BITS 3 /* INB, OOB */
66#define DIGI_CMD_SET_INPUT_FLOW_CONTROL 4 /* INB, OOB */
67#define DIGI_CMD_SET_OUTPUT_FLOW_CONTROL 5 /* INB, OOB */
68#define DIGI_CMD_SET_DTR_SIGNAL 6 /* INB, OOB */
69#define DIGI_CMD_SET_RTS_SIGNAL 7 /* INB, OOB */
70#define DIGI_CMD_READ_INPUT_SIGNALS 8 /* OOB */
71#define DIGI_CMD_IFLUSH_FIFO 9 /* OOB */
72#define DIGI_CMD_RECEIVE_ENABLE 10 /* INB, OOB */
73#define DIGI_CMD_BREAK_CONTROL 11 /* INB, OOB */
74#define DIGI_CMD_LOCAL_LOOPBACK 12 /* INB, OOB */
75#define DIGI_CMD_TRANSMIT_IDLE 13 /* INB, OOB */
76#define DIGI_CMD_READ_UART_REGISTER 14 /* OOB */
77#define DIGI_CMD_WRITE_UART_REGISTER 15 /* INB, OOB */
78#define DIGI_CMD_AND_UART_REGISTER 16 /* INB, OOB */
79#define DIGI_CMD_OR_UART_REGISTER 17 /* INB, OOB */
80#define DIGI_CMD_SEND_DATA 18 /* INB */
81#define DIGI_CMD_RECEIVE_DATA 19 /* INB */
82#define DIGI_CMD_RECEIVE_DISABLE 20 /* INB */
83#define DIGI_CMD_GET_PORT_TYPE 21 /* OOB */
84
85/* baud rates */
86#define DIGI_BAUD_50 0
87#define DIGI_BAUD_75 1
88#define DIGI_BAUD_110 2
89#define DIGI_BAUD_150 3
90#define DIGI_BAUD_200 4
91#define DIGI_BAUD_300 5
92#define DIGI_BAUD_600 6
93#define DIGI_BAUD_1200 7
94#define DIGI_BAUD_1800 8
95#define DIGI_BAUD_2400 9
96#define DIGI_BAUD_4800 10
97#define DIGI_BAUD_7200 11
98#define DIGI_BAUD_9600 12
99#define DIGI_BAUD_14400 13
100#define DIGI_BAUD_19200 14
101#define DIGI_BAUD_28800 15
102#define DIGI_BAUD_38400 16
103#define DIGI_BAUD_57600 17
104#define DIGI_BAUD_76800 18
105#define DIGI_BAUD_115200 19
106#define DIGI_BAUD_153600 20
107#define DIGI_BAUD_230400 21
108#define DIGI_BAUD_460800 22
109
110/* arguments */
111#define DIGI_WORD_SIZE_5 0
112#define DIGI_WORD_SIZE_6 1
113#define DIGI_WORD_SIZE_7 2
114#define DIGI_WORD_SIZE_8 3
115
116#define DIGI_PARITY_NONE 0
117#define DIGI_PARITY_ODD 1
118#define DIGI_PARITY_EVEN 2
119#define DIGI_PARITY_MARK 3
120#define DIGI_PARITY_SPACE 4
121
122#define DIGI_STOP_BITS_1 0
123#define DIGI_STOP_BITS_2 1
124
125#define DIGI_INPUT_FLOW_CONTROL_XON_XOFF 1
126#define DIGI_INPUT_FLOW_CONTROL_RTS 2
127#define DIGI_INPUT_FLOW_CONTROL_DTR 4
128
129#define DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF 1
130#define DIGI_OUTPUT_FLOW_CONTROL_CTS 2
131#define DIGI_OUTPUT_FLOW_CONTROL_DSR 4
132
133#define DIGI_DTR_INACTIVE 0
134#define DIGI_DTR_ACTIVE 1
135#define DIGI_DTR_INPUT_FLOW_CONTROL 2
136
137#define DIGI_RTS_INACTIVE 0
138#define DIGI_RTS_ACTIVE 1
139#define DIGI_RTS_INPUT_FLOW_CONTROL 2
140#define DIGI_RTS_TOGGLE 3
141
142#define DIGI_FLUSH_TX 1
143#define DIGI_FLUSH_RX 2
144#define DIGI_RESUME_TX 4 /* clears xoff condition */
145
146#define DIGI_TRANSMIT_NOT_IDLE 0
147#define DIGI_TRANSMIT_IDLE 1
148
149#define DIGI_DISABLE 0
150#define DIGI_ENABLE 1
151
152#define DIGI_DEASSERT 0
153#define DIGI_ASSERT 1
154
155/* in band status codes */
156#define DIGI_OVERRUN_ERROR 4
157#define DIGI_PARITY_ERROR 8
158#define DIGI_FRAMING_ERROR 16
159#define DIGI_BREAK_ERROR 32
160
161/* out of band status */
162#define DIGI_NO_ERROR 0
163#define DIGI_BAD_FIRST_PARAMETER 1
164#define DIGI_BAD_SECOND_PARAMETER 2
165#define DIGI_INVALID_LINE 3
166#define DIGI_INVALID_OPCODE 4
167
168/* input signals */
169#define DIGI_READ_INPUT_SIGNALS_SLOT 1
170#define DIGI_READ_INPUT_SIGNALS_ERR 2
171#define DIGI_READ_INPUT_SIGNALS_BUSY 4
172#define DIGI_READ_INPUT_SIGNALS_PE 8
173#define DIGI_READ_INPUT_SIGNALS_CTS 16
174#define DIGI_READ_INPUT_SIGNALS_DSR 32
175#define DIGI_READ_INPUT_SIGNALS_RI 64
176#define DIGI_READ_INPUT_SIGNALS_DCD 128
177
178
179/* Structures */
180
181struct digi_serial {
182 spinlock_t ds_serial_lock;
183 struct usb_serial_port *ds_oob_port; /* out-of-band port */
184 int ds_oob_port_num; /* index of out-of-band port */
185 int ds_device_started;
186};
187
188struct digi_port {
189 spinlock_t dp_port_lock;
190 int dp_port_num;
191 int dp_out_buf_len;
192 unsigned char dp_out_buf[DIGI_OUT_BUF_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 int dp_write_urb_in_use;
194 unsigned int dp_modem_signals;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195 int dp_transmit_idle;
196 wait_queue_head_t dp_transmit_idle_wait;
197 int dp_throttled;
198 int dp_throttle_restart;
199 wait_queue_head_t dp_flush_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 wait_queue_head_t dp_close_wait; /* wait queue for close */
201 struct work_struct dp_wakeup_work;
David Howellsc4028952006-11-22 14:57:56 +0000202 struct usb_serial_port *dp_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203};
204
205
206/* Local Function Declarations */
207
David Howellsc4028952006-11-22 14:57:56 +0000208static void digi_wakeup_write_lock(struct work_struct *work);
Alan Coxc6d61262007-07-26 18:57:52 +0100209static int digi_write_oob_command(struct usb_serial_port *port,
210 unsigned char *buf, int count, int interruptible);
211static int digi_write_inb_command(struct usb_serial_port *port,
212 unsigned char *buf, int count, unsigned long timeout);
213static int digi_set_modem_signals(struct usb_serial_port *port,
214 unsigned int modem_signals, int interruptible);
215static int digi_transmit_idle(struct usb_serial_port *port,
216 unsigned long timeout);
Alan Cox41ad4272008-07-22 11:11:02 +0100217static void digi_rx_throttle(struct tty_struct *tty);
218static void digi_rx_unthrottle(struct tty_struct *tty);
Alan Cox95da3102008-07-22 11:09:07 +0100219static void digi_set_termios(struct tty_struct *tty,
220 struct usb_serial_port *port, struct ktermios *old_termios);
221static void digi_break_ctl(struct tty_struct *tty, int break_state);
Alan Cox60b33c12011-02-14 16:26:14 +0000222static int digi_tiocmget(struct tty_struct *tty);
Alan Cox20b9d172011-02-14 16:26:50 +0000223static int digi_tiocmset(struct tty_struct *tty, unsigned int set,
224 unsigned int clear);
Alan Cox95da3102008-07-22 11:09:07 +0100225static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
Alan Cox20b9d172011-02-14 16:26:50 +0000226 const unsigned char *buf, int count);
Alan Coxc6d61262007-07-26 18:57:52 +0100227static void digi_write_bulk_callback(struct urb *urb);
Alan Cox95da3102008-07-22 11:09:07 +0100228static int digi_write_room(struct tty_struct *tty);
229static int digi_chars_in_buffer(struct tty_struct *tty);
Alan Coxa509a7e2009-09-19 13:13:26 -0700230static int digi_open(struct tty_struct *tty, struct usb_serial_port *port);
Alan Cox335f8512009-06-11 12:26:29 +0100231static void digi_close(struct usb_serial_port *port);
Alan Cox335f8512009-06-11 12:26:29 +0100232static void digi_dtr_rts(struct usb_serial_port *port, int on);
Alan Coxc6d61262007-07-26 18:57:52 +0100233static int digi_startup_device(struct usb_serial *serial);
234static int digi_startup(struct usb_serial *serial);
Alan Sternf9c99bb2009-06-02 11:53:55 -0400235static void digi_disconnect(struct usb_serial *serial);
236static void digi_release(struct usb_serial *serial);
Johan Hovoldfb44ff82012-10-25 10:29:04 +0200237static int digi_port_probe(struct usb_serial_port *port);
238static int digi_port_remove(struct usb_serial_port *port);
Alan Coxc6d61262007-07-26 18:57:52 +0100239static void digi_read_bulk_callback(struct urb *urb);
240static int digi_read_inb_callback(struct urb *urb);
241static int digi_read_oob_callback(struct urb *urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242
243
Németh Márton7d40d7e2010-01-10 15:34:24 +0100244static const struct usb_device_id id_table_combined[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
246 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
247 { } /* Terminating entry */
248};
249
Németh Márton7d40d7e2010-01-10 15:34:24 +0100250static const struct usb_device_id id_table_2[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
252 { } /* Terminating entry */
253};
254
Németh Márton7d40d7e2010-01-10 15:34:24 +0100255static const struct usb_device_id id_table_4[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
257 { } /* Terminating entry */
258};
259
Alan Cox41ad4272008-07-22 11:11:02 +0100260MODULE_DEVICE_TABLE(usb, id_table_combined);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262/* device info needed for the Digi serial converter */
263
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700264static struct usb_serial_driver digi_acceleport_2_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700265 .driver = {
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700266 .owner = THIS_MODULE,
267 .name = "digi_2",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700268 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700269 .description = "Digi 2 port USB adapter",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 .id_table = id_table_2,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 .num_ports = 3,
Johan Hovolde7d65072017-03-02 12:51:22 +0100272 .num_bulk_in = 4,
273 .num_bulk_out = 4,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 .open = digi_open,
275 .close = digi_close,
Alan Cox335f8512009-06-11 12:26:29 +0100276 .dtr_rts = digi_dtr_rts,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 .write = digi_write,
278 .write_room = digi_write_room,
279 .write_bulk_callback = digi_write_bulk_callback,
280 .read_bulk_callback = digi_read_bulk_callback,
281 .chars_in_buffer = digi_chars_in_buffer,
282 .throttle = digi_rx_throttle,
283 .unthrottle = digi_rx_unthrottle,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700284 .set_termios = digi_set_termios,
285 .break_ctl = digi_break_ctl,
286 .tiocmget = digi_tiocmget,
287 .tiocmset = digi_tiocmset,
288 .attach = digi_startup,
Alan Sternf9c99bb2009-06-02 11:53:55 -0400289 .disconnect = digi_disconnect,
290 .release = digi_release,
Johan Hovoldfb44ff82012-10-25 10:29:04 +0200291 .port_probe = digi_port_probe,
292 .port_remove = digi_port_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293};
294
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700295static struct usb_serial_driver digi_acceleport_4_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700296 .driver = {
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700297 .owner = THIS_MODULE,
298 .name = "digi_4",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700299 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700300 .description = "Digi 4 port USB adapter",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 .id_table = id_table_4,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 .num_ports = 4,
Johan Hovolde7d65072017-03-02 12:51:22 +0100303 .num_bulk_in = 5,
304 .num_bulk_out = 5,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 .open = digi_open,
306 .close = digi_close,
307 .write = digi_write,
308 .write_room = digi_write_room,
309 .write_bulk_callback = digi_write_bulk_callback,
310 .read_bulk_callback = digi_read_bulk_callback,
311 .chars_in_buffer = digi_chars_in_buffer,
312 .throttle = digi_rx_throttle,
313 .unthrottle = digi_rx_unthrottle,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 .set_termios = digi_set_termios,
315 .break_ctl = digi_break_ctl,
316 .tiocmget = digi_tiocmget,
317 .tiocmset = digi_tiocmset,
318 .attach = digi_startup,
Alan Sternf9c99bb2009-06-02 11:53:55 -0400319 .disconnect = digi_disconnect,
320 .release = digi_release,
Johan Hovoldfb44ff82012-10-25 10:29:04 +0200321 .port_probe = digi_port_probe,
322 .port_remove = digi_port_remove,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323};
324
Alan Stern97b6b6d2012-02-23 14:56:32 -0500325static struct usb_serial_driver * const serial_drivers[] = {
326 &digi_acceleport_2_device, &digi_acceleport_4_device, NULL
327};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328
329/* Functions */
330
331/*
Alan Cox41ad4272008-07-22 11:11:02 +0100332 * Cond Wait Interruptible Timeout Irqrestore
333 *
334 * Do spin_unlock_irqrestore and interruptible_sleep_on_timeout
335 * so that wake ups are not lost if they occur between the unlock
336 * and the sleep. In other words, spin_unlock_irqrestore and
337 * interruptible_sleep_on_timeout are "atomic" with respect to
338 * wake ups. This is used to implement condition variables.
339 *
340 * interruptible_sleep_on_timeout is deprecated and has been replaced
341 * with the equivalent code.
342 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343
Alan Coxc6d61262007-07-26 18:57:52 +0100344static long cond_wait_interruptible_timeout_irqrestore(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 wait_queue_head_t *q, long timeout,
Alan Coxc6d61262007-07-26 18:57:52 +0100346 spinlock_t *lock, unsigned long flags)
Harvey Harrison5a339562008-05-30 10:18:53 -0700347__releases(lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348{
349 DEFINE_WAIT(wait);
350
Nishanth Aravamudan45f23f12005-04-18 17:39:25 -0700351 prepare_to_wait(q, &wait, TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 spin_unlock_irqrestore(lock, flags);
353 timeout = schedule_timeout(timeout);
354 finish_wait(q, &wait);
355
356 return timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357}
358
359
360/*
Alan Cox41ad4272008-07-22 11:11:02 +0100361 * Digi Wakeup Write
362 *
363 * Wake up port, line discipline, and tty processes sleeping
364 * on writes.
365 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366
David Howellsc4028952006-11-22 14:57:56 +0000367static void digi_wakeup_write_lock(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
Alan Cox41ad4272008-07-22 11:11:02 +0100369 struct digi_port *priv =
370 container_of(work, struct digi_port, dp_wakeup_work);
David Howellsc4028952006-11-22 14:57:56 +0000371 struct usb_serial_port *port = priv->dp_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Alan Coxc6d61262007-07-26 18:57:52 +0100374 spin_lock_irqsave(&priv->dp_port_lock, flags);
Jiri Slaby6aad04f2013-03-07 13:12:29 +0100375 tty_port_tty_wakeup(&port->port);
Alan Coxc6d61262007-07-26 18:57:52 +0100376 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377}
378
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379/*
Alan Cox41ad4272008-07-22 11:11:02 +0100380 * Digi Write OOB Command
381 *
382 * Write commands on the out of band port. Commands are 4
383 * bytes each, multiple commands can be sent at once, and
384 * no command will be split across USB packets. Returns 0
385 * if successful, -EINTR if interrupted while sleeping and
386 * the interruptible flag is true, or a negative error
387 * returned by usb_submit_urb.
388 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389
Alan Coxc6d61262007-07-26 18:57:52 +0100390static int digi_write_oob_command(struct usb_serial_port *port,
391 unsigned char *buf, int count, int interruptible)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 int ret = 0;
394 int len;
395 struct usb_serial_port *oob_port = (struct usb_serial_port *)((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port;
396 struct digi_port *oob_priv = usb_get_serial_port_data(oob_port);
397 unsigned long flags = 0;
398
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -0700399 dev_dbg(&port->dev,
400 "digi_write_oob_command: TOP: port=%d, count=%d\n",
401 oob_priv->dp_port_num, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402
Alan Coxc6d61262007-07-26 18:57:52 +0100403 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
Alan Cox41ad4272008-07-22 11:11:02 +0100404 while (count > 0) {
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800405 while (oob_priv->dp_write_urb_in_use) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406 cond_wait_interruptible_timeout_irqrestore(
407 &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
Alan Coxc6d61262007-07-26 18:57:52 +0100408 &oob_priv->dp_port_lock, flags);
409 if (interruptible && signal_pending(current))
410 return -EINTR;
411 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 }
413
414 /* len must be a multiple of 4, so commands are not split */
Alan Coxc6d61262007-07-26 18:57:52 +0100415 len = min(count, oob_port->bulk_out_size);
416 if (len > 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 len &= ~3;
Alan Coxc6d61262007-07-26 18:57:52 +0100418 memcpy(oob_port->write_urb->transfer_buffer, buf, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 oob_port->write_urb->transfer_buffer_length = len;
Alan Cox41ad4272008-07-22 11:11:02 +0100420 ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC);
421 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 oob_priv->dp_write_urb_in_use = 1;
423 count -= len;
424 buf += len;
425 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 }
Alan Coxc6d61262007-07-26 18:57:52 +0100427 spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
428 if (ret)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700429 dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n",
430 __func__, ret);
Alan Coxc6d61262007-07-26 18:57:52 +0100431 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432
433}
434
435
436/*
Alan Cox41ad4272008-07-22 11:11:02 +0100437 * Digi Write In Band Command
438 *
439 * Write commands on the given port. Commands are 4
440 * bytes each, multiple commands can be sent at once, and
441 * no command will be split across USB packets. If timeout
442 * is non-zero, write in band command will return after
443 * waiting unsuccessfully for the URB status to clear for
444 * timeout ticks. Returns 0 if successful, or a negative
445 * error returned by digi_write.
446 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447
Alan Coxc6d61262007-07-26 18:57:52 +0100448static int digi_write_inb_command(struct usb_serial_port *port,
449 unsigned char *buf, int count, unsigned long timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 int ret = 0;
452 int len;
453 struct digi_port *priv = usb_get_serial_port_data(port);
454 unsigned char *data = port->write_urb->transfer_buffer;
455 unsigned long flags = 0;
456
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -0700457 dev_dbg(&port->dev, "digi_write_inb_command: TOP: port=%d, count=%d\n",
Alan Coxc6d61262007-07-26 18:57:52 +0100458 priv->dp_port_num, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Alan Coxc6d61262007-07-26 18:57:52 +0100460 if (timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 timeout += jiffies;
462 else
463 timeout = ULONG_MAX;
464
Alan Coxc6d61262007-07-26 18:57:52 +0100465 spin_lock_irqsave(&priv->dp_port_lock, flags);
Alan Cox41ad4272008-07-22 11:11:02 +0100466 while (count > 0 && ret == 0) {
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800467 while (priv->dp_write_urb_in_use &&
468 time_before(jiffies, timeout)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 cond_wait_interruptible_timeout_irqrestore(
470 &port->write_wait, DIGI_RETRY_TIMEOUT,
Alan Coxc6d61262007-07-26 18:57:52 +0100471 &priv->dp_port_lock, flags);
472 if (signal_pending(current))
473 return -EINTR;
474 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475 }
476
477 /* len must be a multiple of 4 and small enough to */
478 /* guarantee the write will send buffered data first, */
479 /* so commands are in order with data and not split */
Alan Coxc6d61262007-07-26 18:57:52 +0100480 len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len);
481 if (len > 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 len &= ~3;
483
484 /* write any buffered data first */
Alan Coxc6d61262007-07-26 18:57:52 +0100485 if (priv->dp_out_buf_len > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 data[0] = DIGI_CMD_SEND_DATA;
487 data[1] = priv->dp_out_buf_len;
Alan Coxc6d61262007-07-26 18:57:52 +0100488 memcpy(data + 2, priv->dp_out_buf,
489 priv->dp_out_buf_len);
490 memcpy(data + 2 + priv->dp_out_buf_len, buf, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491 port->write_urb->transfer_buffer_length
Alan Coxc6d61262007-07-26 18:57:52 +0100492 = priv->dp_out_buf_len + 2 + len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 } else {
Alan Coxc6d61262007-07-26 18:57:52 +0100494 memcpy(data, buf, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 port->write_urb->transfer_buffer_length = len;
496 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Alan Cox41ad4272008-07-22 11:11:02 +0100498 ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
499 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 priv->dp_write_urb_in_use = 1;
501 priv->dp_out_buf_len = 0;
502 count -= len;
503 buf += len;
504 }
505
506 }
Alan Coxc6d61262007-07-26 18:57:52 +0100507 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Alan Coxc6d61262007-07-26 18:57:52 +0100509 if (ret)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700510 dev_err(&port->dev,
511 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800512 __func__, ret, priv->dp_port_num);
Alan Coxc6d61262007-07-26 18:57:52 +0100513 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700514}
515
516
517/*
Alan Cox41ad4272008-07-22 11:11:02 +0100518 * Digi Set Modem Signals
519 *
520 * Sets or clears DTR and RTS on the port, according to the
521 * modem_signals argument. Use TIOCM_DTR and TIOCM_RTS flags
522 * for the modem_signals argument. Returns 0 if successful,
523 * -EINTR if interrupted while sleeping, or a non-zero error
524 * returned by usb_submit_urb.
525 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526
Alan Coxc6d61262007-07-26 18:57:52 +0100527static int digi_set_modem_signals(struct usb_serial_port *port,
528 unsigned int modem_signals, int interruptible)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529{
530
531 int ret;
532 struct digi_port *port_priv = usb_get_serial_port_data(port);
Alan Cox41ad4272008-07-22 11:11:02 +0100533 struct usb_serial_port *oob_port = (struct usb_serial_port *) ((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 struct digi_port *oob_priv = usb_get_serial_port_data(oob_port);
535 unsigned char *data = oob_port->write_urb->transfer_buffer;
536 unsigned long flags = 0;
537
538
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -0700539 dev_dbg(&port->dev,
540 "digi_set_modem_signals: TOP: port=%d, modem_signals=0x%x\n",
Alan Coxc6d61262007-07-26 18:57:52 +0100541 port_priv->dp_port_num, modem_signals);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542
Alan Coxc6d61262007-07-26 18:57:52 +0100543 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
544 spin_lock(&port_priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800546 while (oob_priv->dp_write_urb_in_use) {
Alan Coxc6d61262007-07-26 18:57:52 +0100547 spin_unlock(&port_priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 cond_wait_interruptible_timeout_irqrestore(
549 &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
Alan Coxc6d61262007-07-26 18:57:52 +0100550 &oob_priv->dp_port_lock, flags);
551 if (interruptible && signal_pending(current))
552 return -EINTR;
553 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
554 spin_lock(&port_priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 data[0] = DIGI_CMD_SET_DTR_SIGNAL;
557 data[1] = port_priv->dp_port_num;
Alan Cox41ad4272008-07-22 11:11:02 +0100558 data[2] = (modem_signals & TIOCM_DTR) ?
559 DIGI_DTR_ACTIVE : DIGI_DTR_INACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 data[3] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 data[4] = DIGI_CMD_SET_RTS_SIGNAL;
562 data[5] = port_priv->dp_port_num;
Alan Cox41ad4272008-07-22 11:11:02 +0100563 data[6] = (modem_signals & TIOCM_RTS) ?
564 DIGI_RTS_ACTIVE : DIGI_RTS_INACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 data[7] = 0;
566
567 oob_port->write_urb->transfer_buffer_length = 8;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568
Alan Cox41ad4272008-07-22 11:11:02 +0100569 ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC);
570 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 oob_priv->dp_write_urb_in_use = 1;
572 port_priv->dp_modem_signals =
573 (port_priv->dp_modem_signals&~(TIOCM_DTR|TIOCM_RTS))
574 | (modem_signals&(TIOCM_DTR|TIOCM_RTS));
575 }
Alan Coxc6d61262007-07-26 18:57:52 +0100576 spin_unlock(&port_priv->dp_port_lock);
577 spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
578 if (ret)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700579 dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n",
580 __func__, ret);
Alan Coxc6d61262007-07-26 18:57:52 +0100581 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582}
583
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584/*
Alan Cox41ad4272008-07-22 11:11:02 +0100585 * Digi Transmit Idle
586 *
587 * Digi transmit idle waits, up to timeout ticks, for the transmitter
588 * to go idle. It returns 0 if successful or a negative error.
589 *
590 * There are race conditions here if more than one process is calling
591 * digi_transmit_idle on the same port at the same time. However, this
592 * is only called from close, and only one process can be in close on a
593 * port at a time, so its ok.
594 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
Alan Coxc6d61262007-07-26 18:57:52 +0100596static int digi_transmit_idle(struct usb_serial_port *port,
597 unsigned long timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 int ret;
600 unsigned char buf[2];
601 struct digi_port *priv = usb_get_serial_port_data(port);
602 unsigned long flags = 0;
603
Alan Coxc6d61262007-07-26 18:57:52 +0100604 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 priv->dp_transmit_idle = 0;
Alan Coxc6d61262007-07-26 18:57:52 +0100606 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
608 buf[0] = DIGI_CMD_TRANSMIT_IDLE;
609 buf[1] = 0;
610
611 timeout += jiffies;
612
Alan Cox41ad4272008-07-22 11:11:02 +0100613 ret = digi_write_inb_command(port, buf, 2, timeout - jiffies);
614 if (ret != 0)
Alan Coxc6d61262007-07-26 18:57:52 +0100615 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
Alan Coxc6d61262007-07-26 18:57:52 +0100617 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618
Alan Cox41ad4272008-07-22 11:11:02 +0100619 while (time_before(jiffies, timeout) && !priv->dp_transmit_idle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 cond_wait_interruptible_timeout_irqrestore(
621 &priv->dp_transmit_idle_wait, DIGI_RETRY_TIMEOUT,
Alan Coxc6d61262007-07-26 18:57:52 +0100622 &priv->dp_port_lock, flags);
623 if (signal_pending(current))
624 return -EINTR;
625 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 priv->dp_transmit_idle = 0;
Alan Coxc6d61262007-07-26 18:57:52 +0100628 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
629 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
631}
632
633
Alan Cox95da3102008-07-22 11:09:07 +0100634static void digi_rx_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 unsigned long flags;
Alan Cox95da3102008-07-22 11:09:07 +0100637 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 struct digi_port *priv = usb_get_serial_port_data(port);
639
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 /* stop receiving characters by not resubmitting the read urb */
Alan Coxc6d61262007-07-26 18:57:52 +0100641 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 priv->dp_throttled = 1;
643 priv->dp_throttle_restart = 0;
Alan Coxc6d61262007-07-26 18:57:52 +0100644 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645}
646
647
Alan Cox95da3102008-07-22 11:09:07 +0100648static void digi_rx_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 unsigned long flags;
Alan Cox95da3102008-07-22 11:09:07 +0100652 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 struct digi_port *priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654
Alan Coxc6d61262007-07-26 18:57:52 +0100655 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657 /* restart read chain */
Johan Hovold58330412011-11-06 19:06:28 +0100658 if (priv->dp_throttle_restart)
Alan Coxc6d61262007-07-26 18:57:52 +0100659 ret = usb_submit_urb(port->read_urb, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
Johan Hovoldba6b7022009-09-29 12:39:23 +0200661 /* turn throttle off */
662 priv->dp_throttled = 0;
663 priv->dp_throttle_restart = 0;
664
Alan Coxc6d61262007-07-26 18:57:52 +0100665 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666
Alan Coxc6d61262007-07-26 18:57:52 +0100667 if (ret)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700668 dev_err(&port->dev,
669 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800670 __func__, ret, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671}
672
673
Alan Cox41ad4272008-07-22 11:11:02 +0100674static void digi_set_termios(struct tty_struct *tty,
Alan Cox95da3102008-07-22 11:09:07 +0100675 struct usb_serial_port *port, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 struct digi_port *priv = usb_get_serial_port_data(port);
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -0700678 struct device *dev = &port->dev;
Alan Coxadc8d742012-07-14 15:31:47 +0100679 unsigned int iflag = tty->termios.c_iflag;
680 unsigned int cflag = tty->termios.c_cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 unsigned int old_iflag = old_termios->c_iflag;
682 unsigned int old_cflag = old_termios->c_cflag;
683 unsigned char buf[32];
684 unsigned int modem_signals;
Alan Cox41ad4272008-07-22 11:11:02 +0100685 int arg, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 int i = 0;
Alan Coxc6d61262007-07-26 18:57:52 +0100687 speed_t baud;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -0700689 dev_dbg(dev,
690 "digi_set_termios: TOP: port=%d, iflag=0x%x, old_iflag=0x%x, cflag=0x%x, old_cflag=0x%x\n",
691 priv->dp_port_num, iflag, old_iflag, cflag, old_cflag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692
693 /* set baud rate */
Alan Cox41ad4272008-07-22 11:11:02 +0100694 baud = tty_get_baud_rate(tty);
695 if (baud != tty_termios_baud_rate(old_termios)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696 arg = -1;
697
698 /* reassert DTR and (maybe) RTS on transition from B0 */
Peter Hurley9db276f2016-01-10 20:36:15 -0800699 if ((old_cflag & CBAUD) == B0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 /* don't set RTS if using hardware flow control */
701 /* and throttling input */
702 modem_signals = TIOCM_DTR;
Peter Hurley97ef38b2016-04-09 17:11:36 -0700703 if (!C_CRTSCTS(tty) || !tty_throttled(tty))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704 modem_signals |= TIOCM_RTS;
Alan Coxc6d61262007-07-26 18:57:52 +0100705 digi_set_modem_signals(port, modem_signals, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 }
Alan Coxc6d61262007-07-26 18:57:52 +0100707 switch (baud) {
Alan Cox41ad4272008-07-22 11:11:02 +0100708 /* drop DTR and RTS on transition to B0 */
709 case 0: digi_set_modem_signals(port, 0, 1); break;
710 case 50: arg = DIGI_BAUD_50; break;
711 case 75: arg = DIGI_BAUD_75; break;
712 case 110: arg = DIGI_BAUD_110; break;
713 case 150: arg = DIGI_BAUD_150; break;
714 case 200: arg = DIGI_BAUD_200; break;
715 case 300: arg = DIGI_BAUD_300; break;
716 case 600: arg = DIGI_BAUD_600; break;
717 case 1200: arg = DIGI_BAUD_1200; break;
718 case 1800: arg = DIGI_BAUD_1800; break;
719 case 2400: arg = DIGI_BAUD_2400; break;
720 case 4800: arg = DIGI_BAUD_4800; break;
721 case 9600: arg = DIGI_BAUD_9600; break;
722 case 19200: arg = DIGI_BAUD_19200; break;
723 case 38400: arg = DIGI_BAUD_38400; break;
724 case 57600: arg = DIGI_BAUD_57600; break;
725 case 115200: arg = DIGI_BAUD_115200; break;
726 case 230400: arg = DIGI_BAUD_230400; break;
727 case 460800: arg = DIGI_BAUD_460800; break;
728 default:
729 arg = DIGI_BAUD_9600;
730 baud = 9600;
731 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 }
Alan Coxc6d61262007-07-26 18:57:52 +0100733 if (arg != -1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 buf[i++] = DIGI_CMD_SET_BAUD_RATE;
735 buf[i++] = priv->dp_port_num;
736 buf[i++] = arg;
737 buf[i++] = 0;
738 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 /* set parity */
Alan Coxadc8d742012-07-14 15:31:47 +0100741 tty->termios.c_cflag &= ~CMSPAR;
Alan Cox7fa36a92007-10-18 01:24:19 -0700742
Alan Coxc6d61262007-07-26 18:57:52 +0100743 if ((cflag&(PARENB|PARODD)) != (old_cflag&(PARENB|PARODD))) {
744 if (cflag&PARENB) {
745 if (cflag&PARODD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746 arg = DIGI_PARITY_ODD;
747 else
748 arg = DIGI_PARITY_EVEN;
749 } else {
750 arg = DIGI_PARITY_NONE;
751 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 buf[i++] = DIGI_CMD_SET_PARITY;
753 buf[i++] = priv->dp_port_num;
754 buf[i++] = arg;
755 buf[i++] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 /* set word size */
Alan Coxc6d61262007-07-26 18:57:52 +0100758 if ((cflag&CSIZE) != (old_cflag&CSIZE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 arg = -1;
Alan Coxc6d61262007-07-26 18:57:52 +0100760 switch (cflag&CSIZE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 case CS5: arg = DIGI_WORD_SIZE_5; break;
762 case CS6: arg = DIGI_WORD_SIZE_6; break;
763 case CS7: arg = DIGI_WORD_SIZE_7; break;
764 case CS8: arg = DIGI_WORD_SIZE_8; break;
765 default:
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -0700766 dev_dbg(dev,
767 "digi_set_termios: can't handle word size %d\n",
Alan Coxc6d61262007-07-26 18:57:52 +0100768 (cflag&CSIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 break;
770 }
771
Alan Coxc6d61262007-07-26 18:57:52 +0100772 if (arg != -1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 buf[i++] = DIGI_CMD_SET_WORD_SIZE;
774 buf[i++] = priv->dp_port_num;
775 buf[i++] = arg;
776 buf[i++] = 0;
777 }
778
779 }
780
781 /* set stop bits */
Alan Coxc6d61262007-07-26 18:57:52 +0100782 if ((cflag&CSTOPB) != (old_cflag&CSTOPB)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Alan Coxc6d61262007-07-26 18:57:52 +0100784 if ((cflag&CSTOPB))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 arg = DIGI_STOP_BITS_2;
786 else
787 arg = DIGI_STOP_BITS_1;
788
789 buf[i++] = DIGI_CMD_SET_STOP_BITS;
790 buf[i++] = priv->dp_port_num;
791 buf[i++] = arg;
792 buf[i++] = 0;
793
794 }
795
796 /* set input flow control */
Alan Coxc6d61262007-07-26 18:57:52 +0100797 if ((iflag&IXOFF) != (old_iflag&IXOFF)
798 || (cflag&CRTSCTS) != (old_cflag&CRTSCTS)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 arg = 0;
Alan Coxc6d61262007-07-26 18:57:52 +0100800 if (iflag&IXOFF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 arg |= DIGI_INPUT_FLOW_CONTROL_XON_XOFF;
802 else
803 arg &= ~DIGI_INPUT_FLOW_CONTROL_XON_XOFF;
804
Alan Coxc6d61262007-07-26 18:57:52 +0100805 if (cflag&CRTSCTS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 arg |= DIGI_INPUT_FLOW_CONTROL_RTS;
807
808 /* On USB-4 it is necessary to assert RTS prior */
809 /* to selecting RTS input flow control. */
810 buf[i++] = DIGI_CMD_SET_RTS_SIGNAL;
811 buf[i++] = priv->dp_port_num;
812 buf[i++] = DIGI_RTS_ACTIVE;
813 buf[i++] = 0;
814
815 } else {
816 arg &= ~DIGI_INPUT_FLOW_CONTROL_RTS;
817 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700818 buf[i++] = DIGI_CMD_SET_INPUT_FLOW_CONTROL;
819 buf[i++] = priv->dp_port_num;
820 buf[i++] = arg;
821 buf[i++] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 }
823
824 /* set output flow control */
Alan Cox7fa36a92007-10-18 01:24:19 -0700825 if ((iflag & IXON) != (old_iflag & IXON)
826 || (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827 arg = 0;
Alan Cox7fa36a92007-10-18 01:24:19 -0700828 if (iflag & IXON)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 arg |= DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF;
830 else
831 arg &= ~DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF;
832
Alan Cox7fa36a92007-10-18 01:24:19 -0700833 if (cflag & CRTSCTS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 arg |= DIGI_OUTPUT_FLOW_CONTROL_CTS;
835 } else {
836 arg &= ~DIGI_OUTPUT_FLOW_CONTROL_CTS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837 }
838
839 buf[i++] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL;
840 buf[i++] = priv->dp_port_num;
841 buf[i++] = arg;
842 buf[i++] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 }
844
845 /* set receive enable/disable */
Alan Cox7fa36a92007-10-18 01:24:19 -0700846 if ((cflag & CREAD) != (old_cflag & CREAD)) {
847 if (cflag & CREAD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 arg = DIGI_ENABLE;
849 else
850 arg = DIGI_DISABLE;
851
852 buf[i++] = DIGI_CMD_RECEIVE_ENABLE;
853 buf[i++] = priv->dp_port_num;
854 buf[i++] = arg;
855 buf[i++] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 }
Alan Cox41ad4272008-07-22 11:11:02 +0100857 ret = digi_write_oob_command(port, buf, i, 1);
858 if (ret != 0)
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -0700859 dev_dbg(dev, "digi_set_termios: write oob failed, ret=%d\n", ret);
Alan Cox7fa36a92007-10-18 01:24:19 -0700860 tty_encode_baud_rate(tty, baud, baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861}
862
863
Alan Cox95da3102008-07-22 11:09:07 +0100864static void digi_break_ctl(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865{
Alan Cox95da3102008-07-22 11:09:07 +0100866 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 unsigned char buf[4];
868
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 buf[0] = DIGI_CMD_BREAK_CONTROL;
870 buf[1] = 2; /* length */
871 buf[2] = break_state ? 1 : 0;
872 buf[3] = 0; /* pad */
Alan Coxc6d61262007-07-26 18:57:52 +0100873 digi_write_inb_command(port, buf, 4, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874}
875
876
Alan Cox60b33c12011-02-14 16:26:14 +0000877static int digi_tiocmget(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878{
Alan Cox95da3102008-07-22 11:09:07 +0100879 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 struct digi_port *priv = usb_get_serial_port_data(port);
881 unsigned int val;
882 unsigned long flags;
883
Alan Coxc6d61262007-07-26 18:57:52 +0100884 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 val = priv->dp_modem_signals;
Alan Coxc6d61262007-07-26 18:57:52 +0100886 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 return val;
888}
889
890
Alan Cox20b9d172011-02-14 16:26:50 +0000891static int digi_tiocmset(struct tty_struct *tty,
892 unsigned int set, unsigned int clear)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893{
Alan Cox95da3102008-07-22 11:09:07 +0100894 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 struct digi_port *priv = usb_get_serial_port_data(port);
896 unsigned int val;
897 unsigned long flags;
898
Alan Coxc6d61262007-07-26 18:57:52 +0100899 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 val = (priv->dp_modem_signals & ~clear) | set;
Alan Coxc6d61262007-07-26 18:57:52 +0100901 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
902 return digi_set_modem_signals(port, val, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903}
904
905
Alan Cox95da3102008-07-22 11:09:07 +0100906static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
907 const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908{
909
Alan Cox41ad4272008-07-22 11:11:02 +0100910 int ret, data_len, new_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 struct digi_port *priv = usb_get_serial_port_data(port);
912 unsigned char *data = port->write_urb->transfer_buffer;
913 unsigned long flags = 0;
914
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -0700915 dev_dbg(&port->dev,
916 "digi_write: TOP: port=%d, count=%d, in_interrupt=%ld\n",
Alan Coxc6d61262007-07-26 18:57:52 +0100917 priv->dp_port_num, count, in_interrupt());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919 /* copy user data (which can sleep) before getting spin lock */
Alan Coxc6d61262007-07-26 18:57:52 +0100920 count = min(count, port->bulk_out_size-2);
921 count = min(64, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923 /* be sure only one write proceeds at a time */
924 /* there are races on the port private buffer */
Alan Coxc6d61262007-07-26 18:57:52 +0100925 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926
927 /* wait for urb status clear to submit another urb */
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800928 if (priv->dp_write_urb_in_use) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 /* buffer data if count is 1 (probably put_char) if possible */
Alan Coxc6d61262007-07-26 18:57:52 +0100930 if (count == 1 && priv->dp_out_buf_len < DIGI_OUT_BUF_SIZE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 priv->dp_out_buf[priv->dp_out_buf_len++] = *buf;
932 new_len = 1;
933 } else {
934 new_len = 0;
935 }
Alan Coxc6d61262007-07-26 18:57:52 +0100936 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
937 return new_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938 }
939
940 /* allow space for any buffered data and for new data, up to */
941 /* transfer buffer size - 2 (for command and length bytes) */
942 new_len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len);
943 data_len = new_len + priv->dp_out_buf_len;
944
Alan Coxc6d61262007-07-26 18:57:52 +0100945 if (data_len == 0) {
946 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
947 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 }
949
950 port->write_urb->transfer_buffer_length = data_len+2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951
952 *data++ = DIGI_CMD_SEND_DATA;
953 *data++ = data_len;
954
955 /* copy in buffered data first */
Alan Coxc6d61262007-07-26 18:57:52 +0100956 memcpy(data, priv->dp_out_buf, priv->dp_out_buf_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700957 data += priv->dp_out_buf_len;
958
959 /* copy in new data */
Alan Coxc6d61262007-07-26 18:57:52 +0100960 memcpy(data, buf, new_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700961
Alan Cox41ad4272008-07-22 11:11:02 +0100962 ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
963 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 priv->dp_write_urb_in_use = 1;
965 ret = new_len;
966 priv->dp_out_buf_len = 0;
967 }
968
969 /* return length of new data written, or error */
Alan Coxc6d61262007-07-26 18:57:52 +0100970 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
971 if (ret < 0)
Johan Hovold22a416c2012-02-10 13:20:51 +0100972 dev_err_console(port,
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700973 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800974 __func__, ret, priv->dp_port_num);
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -0700975 dev_dbg(&port->dev, "digi_write: returning %d\n", ret);
Alan Coxc6d61262007-07-26 18:57:52 +0100976 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977
Alan Cox41ad4272008-07-22 11:11:02 +0100978}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979
Alan Coxc6d61262007-07-26 18:57:52 +0100980static void digi_write_bulk_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981{
982
Ming Leicdc97792008-02-24 18:41:47 +0800983 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 struct usb_serial *serial;
985 struct digi_port *priv;
986 struct digi_serial *serial_priv;
987 int ret = 0;
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -0700988 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 /* port and serial sanity check */
Alan Cox41ad4272008-07-22 11:11:02 +0100991 if (port == NULL || (priv = usb_get_serial_port_data(port)) == NULL) {
Julia Lawall109f34e2010-05-27 14:32:09 +0200992 pr_err("%s: port or port->private is NULL, status=%d\n",
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700993 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 return;
995 }
996 serial = port->serial;
Alan Cox41ad4272008-07-22 11:11:02 +0100997 if (serial == NULL || (serial_priv = usb_get_serial_data(serial)) == NULL) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700998 dev_err(&port->dev,
999 "%s: serial or serial->private is NULL, status=%d\n",
1000 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 return;
1002 }
1003
1004 /* handle oob callback */
Alan Coxc6d61262007-07-26 18:57:52 +01001005 if (priv->dp_port_num == serial_priv->ds_oob_port_num) {
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -07001006 dev_dbg(&port->dev, "digi_write_bulk_callback: oob callback\n");
Alan Coxc6d61262007-07-26 18:57:52 +01001007 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008 priv->dp_write_urb_in_use = 0;
Alan Coxc6d61262007-07-26 18:57:52 +01001009 wake_up_interruptible(&port->write_wait);
1010 spin_unlock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 return;
1012 }
1013
Alan Stern1f871582010-02-17 10:05:47 -05001014 /* try to send any buffered data on this port */
Alan Coxc6d61262007-07-26 18:57:52 +01001015 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 priv->dp_write_urb_in_use = 0;
Alan Stern1f871582010-02-17 10:05:47 -05001017 if (priv->dp_out_buf_len > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 *((unsigned char *)(port->write_urb->transfer_buffer))
1019 = (unsigned char)DIGI_CMD_SEND_DATA;
Alan Cox41ad4272008-07-22 11:11:02 +01001020 *((unsigned char *)(port->write_urb->transfer_buffer) + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 = (unsigned char)priv->dp_out_buf_len;
Alan Cox41ad4272008-07-22 11:11:02 +01001022 port->write_urb->transfer_buffer_length =
1023 priv->dp_out_buf_len + 2;
Alan Cox41ad4272008-07-22 11:11:02 +01001024 memcpy(port->write_urb->transfer_buffer + 2, priv->dp_out_buf,
Alan Coxc6d61262007-07-26 18:57:52 +01001025 priv->dp_out_buf_len);
Alan Cox41ad4272008-07-22 11:11:02 +01001026 ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1027 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 priv->dp_write_urb_in_use = 1;
1029 priv->dp_out_buf_len = 0;
1030 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 /* wake up processes sleeping on writes immediately */
Jiri Slaby6aad04f2013-03-07 13:12:29 +01001033 tty_port_tty_wakeup(&port->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 /* also queue up a wakeup at scheduler time, in case we */
1035 /* lost the race in write_chan(). */
1036 schedule_work(&priv->dp_wakeup_work);
1037
Alan Coxc6d61262007-07-26 18:57:52 +01001038 spin_unlock(&priv->dp_port_lock);
Alan Stern1f871582010-02-17 10:05:47 -05001039 if (ret && ret != -EPERM)
Johan Hovold22a416c2012-02-10 13:20:51 +01001040 dev_err_console(port,
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001041 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -08001042 __func__, ret, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043}
1044
Alan Cox95da3102008-07-22 11:09:07 +01001045static int digi_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046{
Alan Cox95da3102008-07-22 11:09:07 +01001047 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 struct digi_port *priv = usb_get_serial_port_data(port);
Alan Cox95da3102008-07-22 11:09:07 +01001049 int room;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 unsigned long flags = 0;
1051
Alan Coxc6d61262007-07-26 18:57:52 +01001052 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001054 if (priv->dp_write_urb_in_use)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 room = 0;
1056 else
1057 room = port->bulk_out_size - 2 - priv->dp_out_buf_len;
1058
Alan Coxc6d61262007-07-26 18:57:52 +01001059 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -07001060 dev_dbg(&port->dev, "digi_write_room: port=%d, room=%d\n", priv->dp_port_num, room);
Alan Coxc6d61262007-07-26 18:57:52 +01001061 return room;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062
1063}
1064
Alan Cox95da3102008-07-22 11:09:07 +01001065static int digi_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066{
Alan Cox95da3102008-07-22 11:09:07 +01001067 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068 struct digi_port *priv = usb_get_serial_port_data(port);
1069
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001070 if (priv->dp_write_urb_in_use) {
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -07001071 dev_dbg(&port->dev, "digi_chars_in_buffer: port=%d, chars=%d\n",
Alan Coxc6d61262007-07-26 18:57:52 +01001072 priv->dp_port_num, port->bulk_out_size - 2);
1073 /* return(port->bulk_out_size - 2); */
1074 return 256;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 } else {
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -07001076 dev_dbg(&port->dev, "digi_chars_in_buffer: port=%d, chars=%d\n",
Alan Coxc6d61262007-07-26 18:57:52 +01001077 priv->dp_port_num, priv->dp_out_buf_len);
1078 return priv->dp_out_buf_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 }
1080
1081}
1082
Alan Cox335f8512009-06-11 12:26:29 +01001083static void digi_dtr_rts(struct usb_serial_port *port, int on)
1084{
1085 /* Adjust DTR and RTS */
1086 digi_set_modem_signals(port, on * (TIOCM_DTR|TIOCM_RTS), 1);
1087}
1088
Alan Coxa509a7e2009-09-19 13:13:26 -07001089static int digi_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091 int ret;
1092 unsigned char buf[32];
1093 struct digi_port *priv = usb_get_serial_port_data(port);
Alan Cox606d0992006-12-08 02:38:45 -08001094 struct ktermios not_termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095
Linus Torvalds1da177e2005-04-16 15:20:36 -07001096 /* be sure the device is started up */
Alan Coxc6d61262007-07-26 18:57:52 +01001097 if (digi_startup_device(port->serial) != 0)
1098 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001099
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 /* read modem signals automatically whenever they change */
1101 buf[0] = DIGI_CMD_READ_INPUT_SIGNALS;
1102 buf[1] = priv->dp_port_num;
1103 buf[2] = DIGI_ENABLE;
1104 buf[3] = 0;
1105
1106 /* flush fifos */
1107 buf[4] = DIGI_CMD_IFLUSH_FIFO;
1108 buf[5] = priv->dp_port_num;
1109 buf[6] = DIGI_FLUSH_TX | DIGI_FLUSH_RX;
1110 buf[7] = 0;
1111
Alan Cox41ad4272008-07-22 11:11:02 +01001112 ret = digi_write_oob_command(port, buf, 8, 1);
1113 if (ret != 0)
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -07001114 dev_dbg(&port->dev, "digi_open: write oob failed, ret=%d\n", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115
1116 /* set termios settings */
Alan Cox95da3102008-07-22 11:09:07 +01001117 if (tty) {
Alan Coxadc8d742012-07-14 15:31:47 +01001118 not_termios.c_cflag = ~tty->termios.c_cflag;
1119 not_termios.c_iflag = ~tty->termios.c_iflag;
Alan Cox95da3102008-07-22 11:09:07 +01001120 digi_set_termios(tty, port, &not_termios);
1121 }
Alan Coxc6d61262007-07-26 18:57:52 +01001122 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123}
1124
1125
Alan Cox335f8512009-06-11 12:26:29 +01001126static void digi_close(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001127{
1128 DEFINE_WAIT(wait);
1129 int ret;
1130 unsigned char buf[32];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 struct digi_port *priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132
Oliver Neukum0915f492008-01-23 12:28:45 +01001133 mutex_lock(&port->serial->disc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 /* if disconnected, just clear flags */
Oliver Neukum0915f492008-01-23 12:28:45 +01001135 if (port->serial->disconnected)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001136 goto exit;
1137
Johan Hovold28e679a2013-03-21 12:36:30 +01001138 /* FIXME: Transmit idle belongs in the wait_unti_sent path */
1139 digi_transmit_idle(port, DIGI_CLOSE_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Johan Hovold28e679a2013-03-21 12:36:30 +01001141 /* disable input flow control */
1142 buf[0] = DIGI_CMD_SET_INPUT_FLOW_CONTROL;
1143 buf[1] = priv->dp_port_num;
1144 buf[2] = DIGI_DISABLE;
1145 buf[3] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
Johan Hovold28e679a2013-03-21 12:36:30 +01001147 /* disable output flow control */
1148 buf[4] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL;
1149 buf[5] = priv->dp_port_num;
1150 buf[6] = DIGI_DISABLE;
1151 buf[7] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152
Johan Hovold28e679a2013-03-21 12:36:30 +01001153 /* disable reading modem signals automatically */
1154 buf[8] = DIGI_CMD_READ_INPUT_SIGNALS;
1155 buf[9] = priv->dp_port_num;
1156 buf[10] = DIGI_DISABLE;
1157 buf[11] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158
Johan Hovold28e679a2013-03-21 12:36:30 +01001159 /* disable receive */
1160 buf[12] = DIGI_CMD_RECEIVE_ENABLE;
1161 buf[13] = priv->dp_port_num;
1162 buf[14] = DIGI_DISABLE;
1163 buf[15] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
Johan Hovold28e679a2013-03-21 12:36:30 +01001165 /* flush fifos */
1166 buf[16] = DIGI_CMD_IFLUSH_FIFO;
1167 buf[17] = priv->dp_port_num;
1168 buf[18] = DIGI_FLUSH_TX | DIGI_FLUSH_RX;
1169 buf[19] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170
Johan Hovold28e679a2013-03-21 12:36:30 +01001171 ret = digi_write_oob_command(port, buf, 20, 0);
1172 if (ret != 0)
1173 dev_dbg(&port->dev, "digi_close: write oob failed, ret=%d\n",
1174 ret);
1175 /* wait for final commands on oob port to complete */
1176 prepare_to_wait(&priv->dp_flush_wait, &wait,
1177 TASK_INTERRUPTIBLE);
1178 schedule_timeout(DIGI_CLOSE_TIMEOUT);
1179 finish_wait(&priv->dp_flush_wait, &wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180
Johan Hovold28e679a2013-03-21 12:36:30 +01001181 /* shutdown any outstanding bulk writes */
1182 usb_kill_urb(port->write_urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183exit:
Oliver Neukum0915f492008-01-23 12:28:45 +01001184 spin_lock_irq(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 priv->dp_write_urb_in_use = 0;
Alan Coxc6d61262007-07-26 18:57:52 +01001186 wake_up_interruptible(&priv->dp_close_wait);
Oliver Neukum0915f492008-01-23 12:28:45 +01001187 spin_unlock_irq(&priv->dp_port_lock);
1188 mutex_unlock(&port->serial->disc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189}
1190
1191
1192/*
Alan Cox41ad4272008-07-22 11:11:02 +01001193 * Digi Startup Device
1194 *
1195 * Starts reads on all ports. Must be called AFTER startup, with
1196 * urbs initialized. Returns 0 if successful, non-zero error otherwise.
1197 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
Alan Coxc6d61262007-07-26 18:57:52 +01001199static int digi_startup_device(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200{
Alan Cox41ad4272008-07-22 11:11:02 +01001201 int i, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 struct digi_serial *serial_priv = usb_get_serial_data(serial);
1203 struct usb_serial_port *port;
1204
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 /* be sure this happens exactly once */
Alan Coxc6d61262007-07-26 18:57:52 +01001206 spin_lock(&serial_priv->ds_serial_lock);
1207 if (serial_priv->ds_device_started) {
1208 spin_unlock(&serial_priv->ds_serial_lock);
1209 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 }
1211 serial_priv->ds_device_started = 1;
Alan Coxc6d61262007-07-26 18:57:52 +01001212 spin_unlock(&serial_priv->ds_serial_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213
1214 /* start reading from each bulk in endpoint for the device */
1215 /* set USB_DISABLE_SPD flag for write bulk urbs */
Alan Coxc6d61262007-07-26 18:57:52 +01001216 for (i = 0; i < serial->type->num_ports + 1; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001217 port = serial->port[i];
Alan Cox41ad4272008-07-22 11:11:02 +01001218 ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
1219 if (ret != 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001220 dev_err(&port->dev,
1221 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
1222 __func__, ret, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223 break;
1224 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 }
Alan Coxc6d61262007-07-26 18:57:52 +01001226 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227}
1228
Johan Hovoldfb44ff82012-10-25 10:29:04 +02001229static int digi_port_init(struct usb_serial_port *port, unsigned port_num)
1230{
1231 struct digi_port *priv;
1232
1233 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1234 if (!priv)
1235 return -ENOMEM;
1236
1237 spin_lock_init(&priv->dp_port_lock);
1238 priv->dp_port_num = port_num;
Johan Hovoldfb44ff82012-10-25 10:29:04 +02001239 init_waitqueue_head(&priv->dp_transmit_idle_wait);
1240 init_waitqueue_head(&priv->dp_flush_wait);
1241 init_waitqueue_head(&priv->dp_close_wait);
1242 INIT_WORK(&priv->dp_wakeup_work, digi_wakeup_write_lock);
1243 priv->dp_port = port;
1244
1245 init_waitqueue_head(&port->write_wait);
1246
1247 usb_set_serial_port_data(port, priv);
1248
1249 return 0;
1250}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251
Alan Coxc6d61262007-07-26 18:57:52 +01001252static int digi_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 struct digi_serial *serial_priv;
Johan Hovoldfb44ff82012-10-25 10:29:04 +02001255 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
Johan Hovoldfb44ff82012-10-25 10:29:04 +02001257 serial_priv = kzalloc(sizeof(*serial_priv), GFP_KERNEL);
1258 if (!serial_priv)
1259 return -ENOMEM;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Alan Coxc6d61262007-07-26 18:57:52 +01001261 spin_lock_init(&serial_priv->ds_serial_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 serial_priv->ds_oob_port_num = serial->type->num_ports;
1263 serial_priv->ds_oob_port = serial->port[serial_priv->ds_oob_port_num];
Johan Hovoldfb44ff82012-10-25 10:29:04 +02001264
1265 ret = digi_port_init(serial_priv->ds_oob_port,
1266 serial_priv->ds_oob_port_num);
1267 if (ret) {
1268 kfree(serial_priv);
1269 return ret;
1270 }
1271
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 usb_set_serial_data(serial, serial_priv);
1273
Alan Coxc6d61262007-07-26 18:57:52 +01001274 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275}
1276
1277
Alan Sternf9c99bb2009-06-02 11:53:55 -04001278static void digi_disconnect(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
1282 /* stop reads and writes on all ports */
Alan Coxc6d61262007-07-26 18:57:52 +01001283 for (i = 0; i < serial->type->num_ports + 1; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 usb_kill_urb(serial->port[i]->read_urb);
1285 usb_kill_urb(serial->port[i]->write_urb);
1286 }
Alan Sternf9c99bb2009-06-02 11:53:55 -04001287}
1288
1289
1290static void digi_release(struct usb_serial *serial)
1291{
Johan Hovoldfb44ff82012-10-25 10:29:04 +02001292 struct digi_serial *serial_priv;
1293 struct digi_port *priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294
Johan Hovoldfb44ff82012-10-25 10:29:04 +02001295 serial_priv = usb_get_serial_data(serial);
1296
1297 priv = usb_get_serial_port_data(serial_priv->ds_oob_port);
1298 kfree(priv);
1299
1300 kfree(serial_priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301}
1302
Johan Hovoldfb44ff82012-10-25 10:29:04 +02001303static int digi_port_probe(struct usb_serial_port *port)
1304{
Greg Kroah-Hartman11438322013-06-06 10:32:00 -07001305 return digi_port_init(port, port->port_number);
Johan Hovoldfb44ff82012-10-25 10:29:04 +02001306}
1307
1308static int digi_port_remove(struct usb_serial_port *port)
1309{
1310 struct digi_port *priv;
1311
1312 priv = usb_get_serial_port_data(port);
1313 kfree(priv);
1314
1315 return 0;
1316}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317
Alan Coxc6d61262007-07-26 18:57:52 +01001318static void digi_read_bulk_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319{
Ming Leicdc97792008-02-24 18:41:47 +08001320 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 struct digi_port *priv;
1322 struct digi_serial *serial_priv;
1323 int ret;
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001324 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 /* port sanity check, do not resubmit if port is not valid */
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001327 if (port == NULL)
1328 return;
1329 priv = usb_get_serial_port_data(port);
1330 if (priv == NULL) {
1331 dev_err(&port->dev, "%s: port->private is NULL, status=%d\n",
1332 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 return;
1334 }
Alan Coxc6d61262007-07-26 18:57:52 +01001335 if (port->serial == NULL ||
Alan Cox41ad4272008-07-22 11:11:02 +01001336 (serial_priv = usb_get_serial_data(port->serial)) == NULL) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001337 dev_err(&port->dev, "%s: serial is bad or serial->private "
1338 "is NULL, status=%d\n", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 return;
1340 }
1341
1342 /* do not resubmit urb if it has any status error */
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001343 if (status) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001344 dev_err(&port->dev,
1345 "%s: nonzero read bulk status: status=%d, port=%d\n",
1346 __func__, status, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001347 return;
1348 }
1349
1350 /* handle oob or inb callback, do not resubmit if error */
Alan Coxc6d61262007-07-26 18:57:52 +01001351 if (priv->dp_port_num == serial_priv->ds_oob_port_num) {
1352 if (digi_read_oob_callback(urb) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353 return;
1354 } else {
Alan Coxc6d61262007-07-26 18:57:52 +01001355 if (digi_read_inb_callback(urb) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001356 return;
1357 }
1358
1359 /* continue read */
Alan Cox41ad4272008-07-22 11:11:02 +01001360 ret = usb_submit_urb(urb, GFP_ATOMIC);
Alan Stern1f871582010-02-17 10:05:47 -05001361 if (ret != 0 && ret != -EPERM) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001362 dev_err(&port->dev,
1363 "%s: failed resubmitting urb, ret=%d, port=%d\n",
1364 __func__, ret, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 }
1366
1367}
1368
Alan Cox41ad4272008-07-22 11:11:02 +01001369/*
1370 * Digi Read INB Callback
1371 *
1372 * Digi Read INB Callback handles reads on the in band ports, sending
1373 * the data on to the tty subsystem. When called we know port and
1374 * port->private are not NULL and port->serial has been validated.
1375 * It returns 0 if successful, 1 if successful but the port is
1376 * throttled, and -1 if the sanity checks failed.
1377 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
Alan Coxc6d61262007-07-26 18:57:52 +01001379static int digi_read_inb_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380{
Ming Leicdc97792008-02-24 18:41:47 +08001381 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 struct digi_port *priv = usb_get_serial_port_data(port);
Johan Hovold1b0aed22017-01-31 17:17:28 +01001383 unsigned char *buf = urb->transfer_buffer;
1384 int opcode;
1385 int len;
1386 int port_status;
1387 unsigned char *data;
Alan Cox41ad4272008-07-22 11:11:02 +01001388 int flag, throttled;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389
1390 /* short/multiple packet check */
Johan Hovold1b0aed22017-01-31 17:17:28 +01001391 if (urb->actual_length < 2) {
1392 dev_warn(&port->dev, "short packet received\n");
1393 return -1;
1394 }
1395
1396 opcode = buf[0];
1397 len = buf[1];
1398
Alan Coxc6d61262007-07-26 18:57:52 +01001399 if (urb->actual_length != len + 2) {
Johan Hovold1b0aed22017-01-31 17:17:28 +01001400 dev_err(&port->dev, "malformed packet received: port=%d, opcode=%d, len=%d, actual_length=%u\n",
1401 priv->dp_port_num, opcode, len, urb->actual_length);
1402 return -1;
1403 }
1404
1405 if (opcode == DIGI_CMD_RECEIVE_DATA && len < 1) {
1406 dev_err(&port->dev, "malformed data packet received\n");
Alan Coxc6d61262007-07-26 18:57:52 +01001407 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 }
1409
Alan Coxc6d61262007-07-26 18:57:52 +01001410 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001411
1412 /* check for throttle; if set, do not resubmit read urb */
1413 /* indicate the read chain needs to be restarted on unthrottle */
1414 throttled = priv->dp_throttled;
Alan Coxc6d61262007-07-26 18:57:52 +01001415 if (throttled)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001416 priv->dp_throttle_restart = 1;
1417
1418 /* receive data */
Jiri Slaby2e124b42013-01-03 15:53:06 +01001419 if (opcode == DIGI_CMD_RECEIVE_DATA) {
Johan Hovold1b0aed22017-01-31 17:17:28 +01001420 port_status = buf[2];
1421 data = &buf[3];
1422
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001423 /* get flag from port_status */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 flag = 0;
1425
1426 /* overrun is special, not associated with a char */
Alan Coxc6d61262007-07-26 18:57:52 +01001427 if (port_status & DIGI_OVERRUN_ERROR)
Jiri Slaby92a19f92013-01-03 15:53:03 +01001428 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
1430 /* break takes precedence over parity, */
1431 /* which takes precedence over framing errors */
Alan Coxc6d61262007-07-26 18:57:52 +01001432 if (port_status & DIGI_BREAK_ERROR)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 flag = TTY_BREAK;
Alan Coxc6d61262007-07-26 18:57:52 +01001434 else if (port_status & DIGI_PARITY_ERROR)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 flag = TTY_PARITY;
Alan Coxc6d61262007-07-26 18:57:52 +01001436 else if (port_status & DIGI_FRAMING_ERROR)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 flag = TTY_FRAME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001439 /* data length is len-1 (one byte of len is port_status) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 --len;
Alan Coxc6d61262007-07-26 18:57:52 +01001441 if (len > 0) {
Jiri Slaby2f693352013-01-03 15:53:02 +01001442 tty_insert_flip_string_fixed_flag(&port->port, data,
1443 flag, len);
Jiri Slaby2e124b42013-01-03 15:53:06 +01001444 tty_flip_buffer_push(&port->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 }
Alan Coxc6d61262007-07-26 18:57:52 +01001447 spin_unlock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448
Alan Coxc6d61262007-07-26 18:57:52 +01001449 if (opcode == DIGI_CMD_RECEIVE_DISABLE)
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -07001450 dev_dbg(&port->dev, "%s: got RECEIVE_DISABLE\n", __func__);
Alan Coxc6d61262007-07-26 18:57:52 +01001451 else if (opcode != DIGI_CMD_RECEIVE_DATA)
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -07001452 dev_dbg(&port->dev, "%s: unknown opcode: %d\n", __func__, opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
Alan Cox41ad4272008-07-22 11:11:02 +01001454 return throttled ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455
1456}
1457
1458
Alan Cox41ad4272008-07-22 11:11:02 +01001459/*
1460 * Digi Read OOB Callback
1461 *
1462 * Digi Read OOB Callback handles reads on the out of band port.
1463 * When called we know port and port->private are not NULL and
1464 * the port->serial is valid. It returns 0 if successful, and
1465 * -1 if the sanity checks failed.
1466 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467
Alan Coxc6d61262007-07-26 18:57:52 +01001468static int digi_read_oob_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469{
1470
Ming Leicdc97792008-02-24 18:41:47 +08001471 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 struct usb_serial *serial = port->serial;
Alan Cox4a90f092008-10-13 10:39:46 +01001473 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 struct digi_port *priv = usb_get_serial_port_data(port);
Johan Hovold2d380882017-01-31 17:17:27 +01001475 unsigned char *buf = urb->transfer_buffer;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 int opcode, line, status, val;
1477 int i;
Alan Cox41ad4272008-07-22 11:11:02 +01001478 unsigned int rts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479
Johan Hovold2d380882017-01-31 17:17:27 +01001480 if (urb->actual_length < 4)
1481 return -1;
1482
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483 /* handle each oob command */
Johan Hovold2f682142017-02-24 19:11:28 +01001484 for (i = 0; i < urb->actual_length - 3; i += 4) {
Johan Hovold2d380882017-01-31 17:17:27 +01001485 opcode = buf[i];
1486 line = buf[i + 1];
1487 status = buf[i + 2];
1488 val = buf[i + 3];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489
Greg Kroah-Hartmanf9dfbeb2012-09-14 09:47:39 -07001490 dev_dbg(&port->dev, "digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d\n",
Alan Coxc6d61262007-07-26 18:57:52 +01001491 opcode, line, status, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492
Alan Coxc6d61262007-07-26 18:57:52 +01001493 if (status != 0 || line >= serial->type->num_ports)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 continue;
1495
1496 port = serial->port[line];
1497
Alan Cox41ad4272008-07-22 11:11:02 +01001498 priv = usb_get_serial_port_data(port);
1499 if (priv == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 return -1;
1501
Alan Cox4a90f092008-10-13 10:39:46 +01001502 tty = tty_port_tty_get(&port->port);
Alan Cox42873412010-05-19 13:01:56 +01001503
Alan Cox41ad4272008-07-22 11:11:02 +01001504 rts = 0;
Alan Cox42873412010-05-19 13:01:56 +01001505 if (tty)
Peter Hurley9db276f2016-01-10 20:36:15 -08001506 rts = C_CRTSCTS(tty);
1507
Alan Cox42873412010-05-19 13:01:56 +01001508 if (tty && opcode == DIGI_CMD_READ_INPUT_SIGNALS) {
Alan Coxc6d61262007-07-26 18:57:52 +01001509 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510 /* convert from digi flags to termiox flags */
Alan Coxc6d61262007-07-26 18:57:52 +01001511 if (val & DIGI_READ_INPUT_SIGNALS_CTS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 priv->dp_modem_signals |= TIOCM_CTS;
1513 /* port must be open to use tty struct */
Peter Hurleyd95e3ca2014-09-10 15:06:27 -04001514 if (rts)
Jiri Slaby6aad04f2013-03-07 13:12:29 +01001515 tty_port_tty_wakeup(&port->port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 } else {
1517 priv->dp_modem_signals &= ~TIOCM_CTS;
1518 /* port must be open to use tty struct */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 }
Alan Coxc6d61262007-07-26 18:57:52 +01001520 if (val & DIGI_READ_INPUT_SIGNALS_DSR)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521 priv->dp_modem_signals |= TIOCM_DSR;
1522 else
1523 priv->dp_modem_signals &= ~TIOCM_DSR;
Alan Coxc6d61262007-07-26 18:57:52 +01001524 if (val & DIGI_READ_INPUT_SIGNALS_RI)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525 priv->dp_modem_signals |= TIOCM_RI;
1526 else
1527 priv->dp_modem_signals &= ~TIOCM_RI;
Alan Coxc6d61262007-07-26 18:57:52 +01001528 if (val & DIGI_READ_INPUT_SIGNALS_DCD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 priv->dp_modem_signals |= TIOCM_CD;
1530 else
1531 priv->dp_modem_signals &= ~TIOCM_CD;
1532
Alan Coxc6d61262007-07-26 18:57:52 +01001533 spin_unlock(&priv->dp_port_lock);
1534 } else if (opcode == DIGI_CMD_TRANSMIT_IDLE) {
1535 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 priv->dp_transmit_idle = 1;
Alan Coxc6d61262007-07-26 18:57:52 +01001537 wake_up_interruptible(&priv->dp_transmit_idle_wait);
1538 spin_unlock(&priv->dp_port_lock);
1539 } else if (opcode == DIGI_CMD_IFLUSH_FIFO) {
1540 wake_up_interruptible(&priv->dp_flush_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001541 }
Alan Cox4a90f092008-10-13 10:39:46 +01001542 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001543 }
Alan Coxc6d61262007-07-26 18:57:52 +01001544 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
1546}
1547
Greg Kroah-Hartman68e24112012-05-08 15:46:14 -07001548module_usb_serial_driver(serial_drivers, id_table_combined);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549
Alan Coxc6d61262007-07-26 18:57:52 +01001550MODULE_AUTHOR(DRIVER_AUTHOR);
1551MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552MODULE_LICENSE("GPL");