1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * Digi AccelePort USB-4 and USB-2 Serial Converters |
4 | * |
5 | * Copyright 2000 by Digi International |
6 | * |
7 | * 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) |
12 | */ |
13 | |
14 | #include <linux/kernel.h> |
15 | #include <linux/errno.h> |
16 | #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/uaccess.h> |
23 | #include <linux/usb.h> |
24 | #include <linux/wait.h> |
25 | #include <linux/sched/signal.h> |
26 | #include <linux/usb/serial.h> |
27 | |
28 | /* Defines */ |
29 | |
30 | #define DRIVER_AUTHOR "Peter Berger <pberger@brimson.com>, Al Borchers <borchers@steinerpoint.com>" |
31 | #define DRIVER_DESC "Digi AccelePort USB-2/USB-4 Serial Converter driver" |
32 | |
33 | /* port output buffer length -- must be <= transfer buffer length - 2 */ |
34 | /* so we can be sure to send the full buffer in one urb */ |
35 | #define DIGI_OUT_BUF_SIZE 8 |
36 | |
37 | /* port input buffer length -- must be >= transfer buffer length - 3 */ |
38 | /* so we can be sure to hold at least one full buffer from one urb */ |
39 | #define DIGI_IN_BUF_SIZE 64 |
40 | |
41 | /* retry timeout while sleeping */ |
42 | #define DIGI_RETRY_TIMEOUT (HZ/10) |
43 | |
44 | /* timeout while waiting for tty output to drain in close */ |
45 | /* this delay is used twice in close, so the total delay could */ |
46 | /* be twice this value */ |
47 | #define DIGI_CLOSE_TIMEOUT (5*HZ) |
48 | |
49 | |
50 | /* AccelePort USB Defines */ |
51 | |
52 | /* ids */ |
53 | #define DIGI_VENDOR_ID 0x05c5 |
54 | #define DIGI_2_ID 0x0002 /* USB-2 */ |
55 | #define DIGI_4_ID 0x0004 /* USB-4 */ |
56 | |
57 | /* commands |
58 | * "INB": can be used on the in-band endpoint |
59 | * "OOB": can be used on the out-of-band endpoint |
60 | */ |
61 | #define DIGI_CMD_SET_BAUD_RATE 0 /* INB, OOB */ |
62 | #define DIGI_CMD_SET_WORD_SIZE 1 /* INB, OOB */ |
63 | #define DIGI_CMD_SET_PARITY 2 /* INB, OOB */ |
64 | #define DIGI_CMD_SET_STOP_BITS 3 /* INB, OOB */ |
65 | #define DIGI_CMD_SET_INPUT_FLOW_CONTROL 4 /* INB, OOB */ |
66 | #define DIGI_CMD_SET_OUTPUT_FLOW_CONTROL 5 /* INB, OOB */ |
67 | #define DIGI_CMD_SET_DTR_SIGNAL 6 /* INB, OOB */ |
68 | #define DIGI_CMD_SET_RTS_SIGNAL 7 /* INB, OOB */ |
69 | #define DIGI_CMD_READ_INPUT_SIGNALS 8 /* OOB */ |
70 | #define DIGI_CMD_IFLUSH_FIFO 9 /* OOB */ |
71 | #define DIGI_CMD_RECEIVE_ENABLE 10 /* INB, OOB */ |
72 | #define DIGI_CMD_BREAK_CONTROL 11 /* INB, OOB */ |
73 | #define DIGI_CMD_LOCAL_LOOPBACK 12 /* INB, OOB */ |
74 | #define DIGI_CMD_TRANSMIT_IDLE 13 /* INB, OOB */ |
75 | #define DIGI_CMD_READ_UART_REGISTER 14 /* OOB */ |
76 | #define DIGI_CMD_WRITE_UART_REGISTER 15 /* INB, OOB */ |
77 | #define DIGI_CMD_AND_UART_REGISTER 16 /* INB, OOB */ |
78 | #define DIGI_CMD_OR_UART_REGISTER 17 /* INB, OOB */ |
79 | #define DIGI_CMD_SEND_DATA 18 /* INB */ |
80 | #define DIGI_CMD_RECEIVE_DATA 19 /* INB */ |
81 | #define DIGI_CMD_RECEIVE_DISABLE 20 /* INB */ |
82 | #define DIGI_CMD_GET_PORT_TYPE 21 /* OOB */ |
83 | |
84 | /* baud rates */ |
85 | #define DIGI_BAUD_50 0 |
86 | #define DIGI_BAUD_75 1 |
87 | #define DIGI_BAUD_110 2 |
88 | #define DIGI_BAUD_150 3 |
89 | #define DIGI_BAUD_200 4 |
90 | #define DIGI_BAUD_300 5 |
91 | #define DIGI_BAUD_600 6 |
92 | #define DIGI_BAUD_1200 7 |
93 | #define DIGI_BAUD_1800 8 |
94 | #define DIGI_BAUD_2400 9 |
95 | #define DIGI_BAUD_4800 10 |
96 | #define DIGI_BAUD_7200 11 |
97 | #define DIGI_BAUD_9600 12 |
98 | #define DIGI_BAUD_14400 13 |
99 | #define DIGI_BAUD_19200 14 |
100 | #define DIGI_BAUD_28800 15 |
101 | #define DIGI_BAUD_38400 16 |
102 | #define DIGI_BAUD_57600 17 |
103 | #define DIGI_BAUD_76800 18 |
104 | #define DIGI_BAUD_115200 19 |
105 | #define DIGI_BAUD_153600 20 |
106 | #define DIGI_BAUD_230400 21 |
107 | #define DIGI_BAUD_460800 22 |
108 | |
109 | /* arguments */ |
110 | #define DIGI_WORD_SIZE_5 0 |
111 | #define DIGI_WORD_SIZE_6 1 |
112 | #define DIGI_WORD_SIZE_7 2 |
113 | #define DIGI_WORD_SIZE_8 3 |
114 | |
115 | #define DIGI_PARITY_NONE 0 |
116 | #define DIGI_PARITY_ODD 1 |
117 | #define DIGI_PARITY_EVEN 2 |
118 | #define DIGI_PARITY_MARK 3 |
119 | #define DIGI_PARITY_SPACE 4 |
120 | |
121 | #define DIGI_STOP_BITS_1 0 |
122 | #define DIGI_STOP_BITS_2 1 |
123 | |
124 | #define DIGI_INPUT_FLOW_CONTROL_XON_XOFF 1 |
125 | #define DIGI_INPUT_FLOW_CONTROL_RTS 2 |
126 | #define DIGI_INPUT_FLOW_CONTROL_DTR 4 |
127 | |
128 | #define DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF 1 |
129 | #define DIGI_OUTPUT_FLOW_CONTROL_CTS 2 |
130 | #define DIGI_OUTPUT_FLOW_CONTROL_DSR 4 |
131 | |
132 | #define DIGI_DTR_INACTIVE 0 |
133 | #define DIGI_DTR_ACTIVE 1 |
134 | #define DIGI_DTR_INPUT_FLOW_CONTROL 2 |
135 | |
136 | #define DIGI_RTS_INACTIVE 0 |
137 | #define DIGI_RTS_ACTIVE 1 |
138 | #define DIGI_RTS_INPUT_FLOW_CONTROL 2 |
139 | #define DIGI_RTS_TOGGLE 3 |
140 | |
141 | #define DIGI_FLUSH_TX 1 |
142 | #define DIGI_FLUSH_RX 2 |
143 | #define DIGI_RESUME_TX 4 /* clears xoff condition */ |
144 | |
145 | #define DIGI_TRANSMIT_NOT_IDLE 0 |
146 | #define DIGI_TRANSMIT_IDLE 1 |
147 | |
148 | #define DIGI_DISABLE 0 |
149 | #define DIGI_ENABLE 1 |
150 | |
151 | #define DIGI_DEASSERT 0 |
152 | #define DIGI_ASSERT 1 |
153 | |
154 | /* in band status codes */ |
155 | #define DIGI_OVERRUN_ERROR 4 |
156 | #define DIGI_PARITY_ERROR 8 |
157 | #define DIGI_FRAMING_ERROR 16 |
158 | #define DIGI_BREAK_ERROR 32 |
159 | |
160 | /* out of band status */ |
161 | #define DIGI_NO_ERROR 0 |
162 | #define DIGI_BAD_FIRST_PARAMETER 1 |
163 | #define DIGI_BAD_SECOND_PARAMETER 2 |
164 | #define DIGI_INVALID_LINE 3 |
165 | #define DIGI_INVALID_OPCODE 4 |
166 | |
167 | /* input signals */ |
168 | #define DIGI_READ_INPUT_SIGNALS_SLOT 1 |
169 | #define DIGI_READ_INPUT_SIGNALS_ERR 2 |
170 | #define DIGI_READ_INPUT_SIGNALS_BUSY 4 |
171 | #define DIGI_READ_INPUT_SIGNALS_PE 8 |
172 | #define DIGI_READ_INPUT_SIGNALS_CTS 16 |
173 | #define DIGI_READ_INPUT_SIGNALS_DSR 32 |
174 | #define DIGI_READ_INPUT_SIGNALS_RI 64 |
175 | #define DIGI_READ_INPUT_SIGNALS_DCD 128 |
176 | |
177 | |
178 | /* Structures */ |
179 | |
180 | struct digi_serial { |
181 | spinlock_t ds_serial_lock; |
182 | struct usb_serial_port *ds_oob_port; /* out-of-band port */ |
183 | int ds_oob_port_num; /* index of out-of-band port */ |
184 | int ds_device_started; |
185 | }; |
186 | |
187 | struct digi_port { |
188 | spinlock_t dp_port_lock; |
189 | int dp_port_num; |
190 | int dp_out_buf_len; |
191 | unsigned char dp_out_buf[DIGI_OUT_BUF_SIZE]; |
192 | int dp_write_urb_in_use; |
193 | unsigned int dp_modem_signals; |
194 | int dp_transmit_idle; |
195 | wait_queue_head_t dp_transmit_idle_wait; |
196 | int dp_throttled; |
197 | int dp_throttle_restart; |
198 | wait_queue_head_t dp_flush_wait; |
199 | wait_queue_head_t dp_close_wait; /* wait queue for close */ |
200 | wait_queue_head_t write_wait; |
201 | struct usb_serial_port *dp_port; |
202 | }; |
203 | |
204 | |
205 | /* Local Function Declarations */ |
206 | |
207 | static int digi_write_oob_command(struct usb_serial_port *port, |
208 | unsigned char *buf, int count, int interruptible); |
209 | static int digi_write_inb_command(struct usb_serial_port *port, |
210 | unsigned char *buf, int count, unsigned long timeout); |
211 | static int digi_set_modem_signals(struct usb_serial_port *port, |
212 | unsigned int modem_signals, int interruptible); |
213 | static int digi_transmit_idle(struct usb_serial_port *port, |
214 | unsigned long timeout); |
215 | static void digi_rx_throttle(struct tty_struct *tty); |
216 | static void digi_rx_unthrottle(struct tty_struct *tty); |
217 | static void digi_set_termios(struct tty_struct *tty, |
218 | struct usb_serial_port *port, |
219 | const struct ktermios *old_termios); |
220 | static int digi_break_ctl(struct tty_struct *tty, int break_state); |
221 | static int digi_tiocmget(struct tty_struct *tty); |
222 | static int digi_tiocmset(struct tty_struct *tty, unsigned int set, |
223 | unsigned int clear); |
224 | static int digi_write(struct tty_struct *tty, struct usb_serial_port *port, |
225 | const unsigned char *buf, int count); |
226 | static void digi_write_bulk_callback(struct urb *urb); |
227 | static unsigned int digi_write_room(struct tty_struct *tty); |
228 | static unsigned int digi_chars_in_buffer(struct tty_struct *tty); |
229 | static int digi_open(struct tty_struct *tty, struct usb_serial_port *port); |
230 | static void digi_close(struct usb_serial_port *port); |
231 | static void digi_dtr_rts(struct usb_serial_port *port, int on); |
232 | static int digi_startup_device(struct usb_serial *serial); |
233 | static int digi_startup(struct usb_serial *serial); |
234 | static void digi_disconnect(struct usb_serial *serial); |
235 | static void digi_release(struct usb_serial *serial); |
236 | static int digi_port_probe(struct usb_serial_port *port); |
237 | static void digi_port_remove(struct usb_serial_port *port); |
238 | static void digi_read_bulk_callback(struct urb *urb); |
239 | static int digi_read_inb_callback(struct urb *urb); |
240 | static int digi_read_oob_callback(struct urb *urb); |
241 | |
242 | |
243 | static const struct usb_device_id id_table_combined[] = { |
244 | { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) }, |
245 | { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) }, |
246 | { } /* Terminating entry */ |
247 | }; |
248 | |
249 | static const struct usb_device_id id_table_2[] = { |
250 | { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) }, |
251 | { } /* Terminating entry */ |
252 | }; |
253 | |
254 | static const struct usb_device_id id_table_4[] = { |
255 | { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) }, |
256 | { } /* Terminating entry */ |
257 | }; |
258 | |
259 | MODULE_DEVICE_TABLE(usb, id_table_combined); |
260 | |
261 | /* device info needed for the Digi serial converter */ |
262 | |
263 | static struct usb_serial_driver digi_acceleport_2_device = { |
264 | .driver = { |
265 | .owner = THIS_MODULE, |
266 | .name = "digi_2" , |
267 | }, |
268 | .description = "Digi 2 port USB adapter" , |
269 | .id_table = id_table_2, |
270 | .num_ports = 3, |
271 | .num_bulk_in = 4, |
272 | .num_bulk_out = 4, |
273 | .open = digi_open, |
274 | .close = digi_close, |
275 | .dtr_rts = digi_dtr_rts, |
276 | .write = digi_write, |
277 | .write_room = digi_write_room, |
278 | .write_bulk_callback = digi_write_bulk_callback, |
279 | .read_bulk_callback = digi_read_bulk_callback, |
280 | .chars_in_buffer = digi_chars_in_buffer, |
281 | .throttle = digi_rx_throttle, |
282 | .unthrottle = digi_rx_unthrottle, |
283 | .set_termios = digi_set_termios, |
284 | .break_ctl = digi_break_ctl, |
285 | .tiocmget = digi_tiocmget, |
286 | .tiocmset = digi_tiocmset, |
287 | .attach = digi_startup, |
288 | .disconnect = digi_disconnect, |
289 | .release = digi_release, |
290 | .port_probe = digi_port_probe, |
291 | .port_remove = digi_port_remove, |
292 | }; |
293 | |
294 | static struct usb_serial_driver digi_acceleport_4_device = { |
295 | .driver = { |
296 | .owner = THIS_MODULE, |
297 | .name = "digi_4" , |
298 | }, |
299 | .description = "Digi 4 port USB adapter" , |
300 | .id_table = id_table_4, |
301 | .num_ports = 4, |
302 | .num_bulk_in = 5, |
303 | .num_bulk_out = 5, |
304 | .open = digi_open, |
305 | .close = digi_close, |
306 | .write = digi_write, |
307 | .write_room = digi_write_room, |
308 | .write_bulk_callback = digi_write_bulk_callback, |
309 | .read_bulk_callback = digi_read_bulk_callback, |
310 | .chars_in_buffer = digi_chars_in_buffer, |
311 | .throttle = digi_rx_throttle, |
312 | .unthrottle = digi_rx_unthrottle, |
313 | .set_termios = digi_set_termios, |
314 | .break_ctl = digi_break_ctl, |
315 | .tiocmget = digi_tiocmget, |
316 | .tiocmset = digi_tiocmset, |
317 | .attach = digi_startup, |
318 | .disconnect = digi_disconnect, |
319 | .release = digi_release, |
320 | .port_probe = digi_port_probe, |
321 | .port_remove = digi_port_remove, |
322 | }; |
323 | |
324 | static struct usb_serial_driver * const serial_drivers[] = { |
325 | &digi_acceleport_2_device, &digi_acceleport_4_device, NULL |
326 | }; |
327 | |
328 | /* Functions */ |
329 | |
330 | /* |
331 | * Cond Wait Interruptible Timeout Irqrestore |
332 | * |
333 | * Do spin_unlock_irqrestore and interruptible_sleep_on_timeout |
334 | * so that wake ups are not lost if they occur between the unlock |
335 | * and the sleep. In other words, spin_unlock_irqrestore and |
336 | * interruptible_sleep_on_timeout are "atomic" with respect to |
337 | * wake ups. This is used to implement condition variables. |
338 | * |
339 | * interruptible_sleep_on_timeout is deprecated and has been replaced |
340 | * with the equivalent code. |
341 | */ |
342 | |
343 | static long cond_wait_interruptible_timeout_irqrestore( |
344 | wait_queue_head_t *q, long timeout, |
345 | spinlock_t *lock, unsigned long flags) |
346 | __releases(lock) |
347 | { |
348 | DEFINE_WAIT(wait); |
349 | |
350 | prepare_to_wait(wq_head: q, wq_entry: &wait, TASK_INTERRUPTIBLE); |
351 | spin_unlock_irqrestore(lock, flags); |
352 | timeout = schedule_timeout(timeout); |
353 | finish_wait(wq_head: q, wq_entry: &wait); |
354 | |
355 | return timeout; |
356 | } |
357 | |
358 | /* |
359 | * Digi Write OOB Command |
360 | * |
361 | * Write commands on the out of band port. Commands are 4 |
362 | * bytes each, multiple commands can be sent at once, and |
363 | * no command will be split across USB packets. Returns 0 |
364 | * if successful, -EINTR if interrupted while sleeping and |
365 | * the interruptible flag is true, or a negative error |
366 | * returned by usb_submit_urb. |
367 | */ |
368 | |
369 | static int digi_write_oob_command(struct usb_serial_port *port, |
370 | unsigned char *buf, int count, int interruptible) |
371 | { |
372 | int ret = 0; |
373 | int len; |
374 | struct usb_serial_port *oob_port = (struct usb_serial_port *)((struct digi_serial *)(usb_get_serial_data(serial: port->serial)))->ds_oob_port; |
375 | struct digi_port *oob_priv = usb_get_serial_port_data(port: oob_port); |
376 | unsigned long flags; |
377 | |
378 | dev_dbg(&port->dev, |
379 | "digi_write_oob_command: TOP: port=%d, count=%d\n" , |
380 | oob_priv->dp_port_num, count); |
381 | |
382 | spin_lock_irqsave(&oob_priv->dp_port_lock, flags); |
383 | while (count > 0) { |
384 | while (oob_priv->dp_write_urb_in_use) { |
385 | cond_wait_interruptible_timeout_irqrestore( |
386 | q: &oob_priv->write_wait, DIGI_RETRY_TIMEOUT, |
387 | lock: &oob_priv->dp_port_lock, flags); |
388 | if (interruptible && signal_pending(current)) |
389 | return -EINTR; |
390 | spin_lock_irqsave(&oob_priv->dp_port_lock, flags); |
391 | } |
392 | |
393 | /* len must be a multiple of 4, so commands are not split */ |
394 | len = min(count, oob_port->bulk_out_size); |
395 | if (len > 4) |
396 | len &= ~3; |
397 | memcpy(oob_port->write_urb->transfer_buffer, buf, len); |
398 | oob_port->write_urb->transfer_buffer_length = len; |
399 | ret = usb_submit_urb(urb: oob_port->write_urb, GFP_ATOMIC); |
400 | if (ret == 0) { |
401 | oob_priv->dp_write_urb_in_use = 1; |
402 | count -= len; |
403 | buf += len; |
404 | } |
405 | } |
406 | spin_unlock_irqrestore(lock: &oob_priv->dp_port_lock, flags); |
407 | if (ret) |
408 | dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n" , |
409 | __func__, ret); |
410 | return ret; |
411 | |
412 | } |
413 | |
414 | |
415 | /* |
416 | * Digi Write In Band Command |
417 | * |
418 | * Write commands on the given port. Commands are 4 |
419 | * bytes each, multiple commands can be sent at once, and |
420 | * no command will be split across USB packets. If timeout |
421 | * is non-zero, write in band command will return after |
422 | * waiting unsuccessfully for the URB status to clear for |
423 | * timeout ticks. Returns 0 if successful, or a negative |
424 | * error returned by digi_write. |
425 | */ |
426 | |
427 | static int digi_write_inb_command(struct usb_serial_port *port, |
428 | unsigned char *buf, int count, unsigned long timeout) |
429 | { |
430 | int ret = 0; |
431 | int len; |
432 | struct digi_port *priv = usb_get_serial_port_data(port); |
433 | unsigned char *data = port->write_urb->transfer_buffer; |
434 | unsigned long flags; |
435 | |
436 | dev_dbg(&port->dev, "digi_write_inb_command: TOP: port=%d, count=%d\n" , |
437 | priv->dp_port_num, count); |
438 | |
439 | if (timeout) |
440 | timeout += jiffies; |
441 | else |
442 | timeout = ULONG_MAX; |
443 | |
444 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
445 | while (count > 0 && ret == 0) { |
446 | while (priv->dp_write_urb_in_use && |
447 | time_before(jiffies, timeout)) { |
448 | cond_wait_interruptible_timeout_irqrestore( |
449 | q: &priv->write_wait, DIGI_RETRY_TIMEOUT, |
450 | lock: &priv->dp_port_lock, flags); |
451 | if (signal_pending(current)) |
452 | return -EINTR; |
453 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
454 | } |
455 | |
456 | /* len must be a multiple of 4 and small enough to */ |
457 | /* guarantee the write will send buffered data first, */ |
458 | /* so commands are in order with data and not split */ |
459 | len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len); |
460 | if (len > 4) |
461 | len &= ~3; |
462 | |
463 | /* write any buffered data first */ |
464 | if (priv->dp_out_buf_len > 0) { |
465 | data[0] = DIGI_CMD_SEND_DATA; |
466 | data[1] = priv->dp_out_buf_len; |
467 | memcpy(data + 2, priv->dp_out_buf, |
468 | priv->dp_out_buf_len); |
469 | memcpy(data + 2 + priv->dp_out_buf_len, buf, len); |
470 | port->write_urb->transfer_buffer_length |
471 | = priv->dp_out_buf_len + 2 + len; |
472 | } else { |
473 | memcpy(data, buf, len); |
474 | port->write_urb->transfer_buffer_length = len; |
475 | } |
476 | |
477 | ret = usb_submit_urb(urb: port->write_urb, GFP_ATOMIC); |
478 | if (ret == 0) { |
479 | priv->dp_write_urb_in_use = 1; |
480 | priv->dp_out_buf_len = 0; |
481 | count -= len; |
482 | buf += len; |
483 | } |
484 | |
485 | } |
486 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
487 | |
488 | if (ret) |
489 | dev_err(&port->dev, |
490 | "%s: usb_submit_urb failed, ret=%d, port=%d\n" , |
491 | __func__, ret, priv->dp_port_num); |
492 | return ret; |
493 | } |
494 | |
495 | |
496 | /* |
497 | * Digi Set Modem Signals |
498 | * |
499 | * Sets or clears DTR and RTS on the port, according to the |
500 | * modem_signals argument. Use TIOCM_DTR and TIOCM_RTS flags |
501 | * for the modem_signals argument. Returns 0 if successful, |
502 | * -EINTR if interrupted while sleeping, or a non-zero error |
503 | * returned by usb_submit_urb. |
504 | */ |
505 | |
506 | static int digi_set_modem_signals(struct usb_serial_port *port, |
507 | unsigned int modem_signals, int interruptible) |
508 | { |
509 | |
510 | int ret; |
511 | struct digi_port *port_priv = usb_get_serial_port_data(port); |
512 | struct usb_serial_port *oob_port = (struct usb_serial_port *) ((struct digi_serial *)(usb_get_serial_data(serial: port->serial)))->ds_oob_port; |
513 | struct digi_port *oob_priv = usb_get_serial_port_data(port: oob_port); |
514 | unsigned char *data = oob_port->write_urb->transfer_buffer; |
515 | unsigned long flags; |
516 | |
517 | dev_dbg(&port->dev, |
518 | "digi_set_modem_signals: TOP: port=%d, modem_signals=0x%x\n" , |
519 | port_priv->dp_port_num, modem_signals); |
520 | |
521 | spin_lock_irqsave(&oob_priv->dp_port_lock, flags); |
522 | spin_lock(lock: &port_priv->dp_port_lock); |
523 | |
524 | while (oob_priv->dp_write_urb_in_use) { |
525 | spin_unlock(lock: &port_priv->dp_port_lock); |
526 | cond_wait_interruptible_timeout_irqrestore( |
527 | q: &oob_priv->write_wait, DIGI_RETRY_TIMEOUT, |
528 | lock: &oob_priv->dp_port_lock, flags); |
529 | if (interruptible && signal_pending(current)) |
530 | return -EINTR; |
531 | spin_lock_irqsave(&oob_priv->dp_port_lock, flags); |
532 | spin_lock(lock: &port_priv->dp_port_lock); |
533 | } |
534 | data[0] = DIGI_CMD_SET_DTR_SIGNAL; |
535 | data[1] = port_priv->dp_port_num; |
536 | data[2] = (modem_signals & TIOCM_DTR) ? |
537 | DIGI_DTR_ACTIVE : DIGI_DTR_INACTIVE; |
538 | data[3] = 0; |
539 | data[4] = DIGI_CMD_SET_RTS_SIGNAL; |
540 | data[5] = port_priv->dp_port_num; |
541 | data[6] = (modem_signals & TIOCM_RTS) ? |
542 | DIGI_RTS_ACTIVE : DIGI_RTS_INACTIVE; |
543 | data[7] = 0; |
544 | |
545 | oob_port->write_urb->transfer_buffer_length = 8; |
546 | |
547 | ret = usb_submit_urb(urb: oob_port->write_urb, GFP_ATOMIC); |
548 | if (ret == 0) { |
549 | oob_priv->dp_write_urb_in_use = 1; |
550 | port_priv->dp_modem_signals &= ~(TIOCM_DTR | TIOCM_RTS); |
551 | port_priv->dp_modem_signals |= |
552 | modem_signals & (TIOCM_DTR | TIOCM_RTS); |
553 | } |
554 | spin_unlock(lock: &port_priv->dp_port_lock); |
555 | spin_unlock_irqrestore(lock: &oob_priv->dp_port_lock, flags); |
556 | if (ret) |
557 | dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n" , |
558 | __func__, ret); |
559 | return ret; |
560 | } |
561 | |
562 | /* |
563 | * Digi Transmit Idle |
564 | * |
565 | * Digi transmit idle waits, up to timeout ticks, for the transmitter |
566 | * to go idle. It returns 0 if successful or a negative error. |
567 | * |
568 | * There are race conditions here if more than one process is calling |
569 | * digi_transmit_idle on the same port at the same time. However, this |
570 | * is only called from close, and only one process can be in close on a |
571 | * port at a time, so its ok. |
572 | */ |
573 | |
574 | static int digi_transmit_idle(struct usb_serial_port *port, |
575 | unsigned long timeout) |
576 | { |
577 | int ret; |
578 | unsigned char buf[2]; |
579 | struct digi_port *priv = usb_get_serial_port_data(port); |
580 | unsigned long flags; |
581 | |
582 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
583 | priv->dp_transmit_idle = 0; |
584 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
585 | |
586 | buf[0] = DIGI_CMD_TRANSMIT_IDLE; |
587 | buf[1] = 0; |
588 | |
589 | timeout += jiffies; |
590 | |
591 | ret = digi_write_inb_command(port, buf, count: 2, timeout: timeout - jiffies); |
592 | if (ret != 0) |
593 | return ret; |
594 | |
595 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
596 | |
597 | while (time_before(jiffies, timeout) && !priv->dp_transmit_idle) { |
598 | cond_wait_interruptible_timeout_irqrestore( |
599 | q: &priv->dp_transmit_idle_wait, DIGI_RETRY_TIMEOUT, |
600 | lock: &priv->dp_port_lock, flags); |
601 | if (signal_pending(current)) |
602 | return -EINTR; |
603 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
604 | } |
605 | priv->dp_transmit_idle = 0; |
606 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
607 | return 0; |
608 | |
609 | } |
610 | |
611 | |
612 | static void digi_rx_throttle(struct tty_struct *tty) |
613 | { |
614 | unsigned long flags; |
615 | struct usb_serial_port *port = tty->driver_data; |
616 | struct digi_port *priv = usb_get_serial_port_data(port); |
617 | |
618 | /* stop receiving characters by not resubmitting the read urb */ |
619 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
620 | priv->dp_throttled = 1; |
621 | priv->dp_throttle_restart = 0; |
622 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
623 | } |
624 | |
625 | |
626 | static void digi_rx_unthrottle(struct tty_struct *tty) |
627 | { |
628 | int ret = 0; |
629 | unsigned long flags; |
630 | struct usb_serial_port *port = tty->driver_data; |
631 | struct digi_port *priv = usb_get_serial_port_data(port); |
632 | |
633 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
634 | |
635 | /* restart read chain */ |
636 | if (priv->dp_throttle_restart) |
637 | ret = usb_submit_urb(urb: port->read_urb, GFP_ATOMIC); |
638 | |
639 | /* turn throttle off */ |
640 | priv->dp_throttled = 0; |
641 | priv->dp_throttle_restart = 0; |
642 | |
643 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
644 | |
645 | if (ret) |
646 | dev_err(&port->dev, |
647 | "%s: usb_submit_urb failed, ret=%d, port=%d\n" , |
648 | __func__, ret, priv->dp_port_num); |
649 | } |
650 | |
651 | |
652 | static void digi_set_termios(struct tty_struct *tty, |
653 | struct usb_serial_port *port, |
654 | const struct ktermios *old_termios) |
655 | { |
656 | struct digi_port *priv = usb_get_serial_port_data(port); |
657 | struct device *dev = &port->dev; |
658 | unsigned int iflag = tty->termios.c_iflag; |
659 | unsigned int cflag = tty->termios.c_cflag; |
660 | unsigned int old_iflag = old_termios->c_iflag; |
661 | unsigned int old_cflag = old_termios->c_cflag; |
662 | unsigned char buf[32]; |
663 | unsigned int modem_signals; |
664 | int arg, ret; |
665 | int i = 0; |
666 | speed_t baud; |
667 | |
668 | dev_dbg(dev, |
669 | "digi_set_termios: TOP: port=%d, iflag=0x%x, old_iflag=0x%x, cflag=0x%x, old_cflag=0x%x\n" , |
670 | priv->dp_port_num, iflag, old_iflag, cflag, old_cflag); |
671 | |
672 | /* set baud rate */ |
673 | baud = tty_get_baud_rate(tty); |
674 | if (baud != tty_termios_baud_rate(termios: old_termios)) { |
675 | arg = -1; |
676 | |
677 | /* reassert DTR and (maybe) RTS on transition from B0 */ |
678 | if ((old_cflag & CBAUD) == B0) { |
679 | /* don't set RTS if using hardware flow control */ |
680 | /* and throttling input */ |
681 | modem_signals = TIOCM_DTR; |
682 | if (!C_CRTSCTS(tty) || !tty_throttled(tty)) |
683 | modem_signals |= TIOCM_RTS; |
684 | digi_set_modem_signals(port, modem_signals, interruptible: 1); |
685 | } |
686 | switch (baud) { |
687 | /* drop DTR and RTS on transition to B0 */ |
688 | case 0: digi_set_modem_signals(port, modem_signals: 0, interruptible: 1); break; |
689 | case 50: arg = DIGI_BAUD_50; break; |
690 | case 75: arg = DIGI_BAUD_75; break; |
691 | case 110: arg = DIGI_BAUD_110; break; |
692 | case 150: arg = DIGI_BAUD_150; break; |
693 | case 200: arg = DIGI_BAUD_200; break; |
694 | case 300: arg = DIGI_BAUD_300; break; |
695 | case 600: arg = DIGI_BAUD_600; break; |
696 | case 1200: arg = DIGI_BAUD_1200; break; |
697 | case 1800: arg = DIGI_BAUD_1800; break; |
698 | case 2400: arg = DIGI_BAUD_2400; break; |
699 | case 4800: arg = DIGI_BAUD_4800; break; |
700 | case 9600: arg = DIGI_BAUD_9600; break; |
701 | case 19200: arg = DIGI_BAUD_19200; break; |
702 | case 38400: arg = DIGI_BAUD_38400; break; |
703 | case 57600: arg = DIGI_BAUD_57600; break; |
704 | case 115200: arg = DIGI_BAUD_115200; break; |
705 | case 230400: arg = DIGI_BAUD_230400; break; |
706 | case 460800: arg = DIGI_BAUD_460800; break; |
707 | default: |
708 | arg = DIGI_BAUD_9600; |
709 | baud = 9600; |
710 | break; |
711 | } |
712 | if (arg != -1) { |
713 | buf[i++] = DIGI_CMD_SET_BAUD_RATE; |
714 | buf[i++] = priv->dp_port_num; |
715 | buf[i++] = arg; |
716 | buf[i++] = 0; |
717 | } |
718 | } |
719 | /* set parity */ |
720 | tty->termios.c_cflag &= ~CMSPAR; |
721 | |
722 | if ((cflag & (PARENB | PARODD)) != (old_cflag & (PARENB | PARODD))) { |
723 | if (cflag & PARENB) { |
724 | if (cflag & PARODD) |
725 | arg = DIGI_PARITY_ODD; |
726 | else |
727 | arg = DIGI_PARITY_EVEN; |
728 | } else { |
729 | arg = DIGI_PARITY_NONE; |
730 | } |
731 | buf[i++] = DIGI_CMD_SET_PARITY; |
732 | buf[i++] = priv->dp_port_num; |
733 | buf[i++] = arg; |
734 | buf[i++] = 0; |
735 | } |
736 | /* set word size */ |
737 | if ((cflag & CSIZE) != (old_cflag & CSIZE)) { |
738 | arg = -1; |
739 | switch (cflag & CSIZE) { |
740 | case CS5: arg = DIGI_WORD_SIZE_5; break; |
741 | case CS6: arg = DIGI_WORD_SIZE_6; break; |
742 | case CS7: arg = DIGI_WORD_SIZE_7; break; |
743 | case CS8: arg = DIGI_WORD_SIZE_8; break; |
744 | default: |
745 | dev_dbg(dev, |
746 | "digi_set_termios: can't handle word size %d\n" , |
747 | cflag & CSIZE); |
748 | break; |
749 | } |
750 | |
751 | if (arg != -1) { |
752 | buf[i++] = DIGI_CMD_SET_WORD_SIZE; |
753 | buf[i++] = priv->dp_port_num; |
754 | buf[i++] = arg; |
755 | buf[i++] = 0; |
756 | } |
757 | |
758 | } |
759 | |
760 | /* set stop bits */ |
761 | if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) { |
762 | |
763 | if ((cflag & CSTOPB)) |
764 | arg = DIGI_STOP_BITS_2; |
765 | else |
766 | arg = DIGI_STOP_BITS_1; |
767 | |
768 | buf[i++] = DIGI_CMD_SET_STOP_BITS; |
769 | buf[i++] = priv->dp_port_num; |
770 | buf[i++] = arg; |
771 | buf[i++] = 0; |
772 | |
773 | } |
774 | |
775 | /* set input flow control */ |
776 | if ((iflag & IXOFF) != (old_iflag & IXOFF) || |
777 | (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) { |
778 | arg = 0; |
779 | if (iflag & IXOFF) |
780 | arg |= DIGI_INPUT_FLOW_CONTROL_XON_XOFF; |
781 | else |
782 | arg &= ~DIGI_INPUT_FLOW_CONTROL_XON_XOFF; |
783 | |
784 | if (cflag & CRTSCTS) { |
785 | arg |= DIGI_INPUT_FLOW_CONTROL_RTS; |
786 | |
787 | /* On USB-4 it is necessary to assert RTS prior */ |
788 | /* to selecting RTS input flow control. */ |
789 | buf[i++] = DIGI_CMD_SET_RTS_SIGNAL; |
790 | buf[i++] = priv->dp_port_num; |
791 | buf[i++] = DIGI_RTS_ACTIVE; |
792 | buf[i++] = 0; |
793 | |
794 | } else { |
795 | arg &= ~DIGI_INPUT_FLOW_CONTROL_RTS; |
796 | } |
797 | buf[i++] = DIGI_CMD_SET_INPUT_FLOW_CONTROL; |
798 | buf[i++] = priv->dp_port_num; |
799 | buf[i++] = arg; |
800 | buf[i++] = 0; |
801 | } |
802 | |
803 | /* set output flow control */ |
804 | if ((iflag & IXON) != (old_iflag & IXON) || |
805 | (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) { |
806 | arg = 0; |
807 | if (iflag & IXON) |
808 | arg |= DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF; |
809 | else |
810 | arg &= ~DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF; |
811 | |
812 | if (cflag & CRTSCTS) |
813 | arg |= DIGI_OUTPUT_FLOW_CONTROL_CTS; |
814 | else |
815 | arg &= ~DIGI_OUTPUT_FLOW_CONTROL_CTS; |
816 | |
817 | buf[i++] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL; |
818 | buf[i++] = priv->dp_port_num; |
819 | buf[i++] = arg; |
820 | buf[i++] = 0; |
821 | } |
822 | |
823 | /* set receive enable/disable */ |
824 | if ((cflag & CREAD) != (old_cflag & CREAD)) { |
825 | if (cflag & CREAD) |
826 | arg = DIGI_ENABLE; |
827 | else |
828 | arg = DIGI_DISABLE; |
829 | |
830 | buf[i++] = DIGI_CMD_RECEIVE_ENABLE; |
831 | buf[i++] = priv->dp_port_num; |
832 | buf[i++] = arg; |
833 | buf[i++] = 0; |
834 | } |
835 | ret = digi_write_oob_command(port, buf, count: i, interruptible: 1); |
836 | if (ret != 0) |
837 | dev_dbg(dev, "digi_set_termios: write oob failed, ret=%d\n" , ret); |
838 | tty_encode_baud_rate(tty, ibaud: baud, obaud: baud); |
839 | } |
840 | |
841 | |
842 | static int digi_break_ctl(struct tty_struct *tty, int break_state) |
843 | { |
844 | struct usb_serial_port *port = tty->driver_data; |
845 | unsigned char buf[4]; |
846 | |
847 | buf[0] = DIGI_CMD_BREAK_CONTROL; |
848 | buf[1] = 2; /* length */ |
849 | buf[2] = break_state ? 1 : 0; |
850 | buf[3] = 0; /* pad */ |
851 | |
852 | return digi_write_inb_command(port, buf, count: 4, timeout: 0); |
853 | } |
854 | |
855 | |
856 | static int digi_tiocmget(struct tty_struct *tty) |
857 | { |
858 | struct usb_serial_port *port = tty->driver_data; |
859 | struct digi_port *priv = usb_get_serial_port_data(port); |
860 | unsigned int val; |
861 | unsigned long flags; |
862 | |
863 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
864 | val = priv->dp_modem_signals; |
865 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
866 | return val; |
867 | } |
868 | |
869 | |
870 | static int digi_tiocmset(struct tty_struct *tty, |
871 | unsigned int set, unsigned int clear) |
872 | { |
873 | struct usb_serial_port *port = tty->driver_data; |
874 | struct digi_port *priv = usb_get_serial_port_data(port); |
875 | unsigned int val; |
876 | unsigned long flags; |
877 | |
878 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
879 | val = (priv->dp_modem_signals & ~clear) | set; |
880 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
881 | return digi_set_modem_signals(port, modem_signals: val, interruptible: 1); |
882 | } |
883 | |
884 | |
885 | static int digi_write(struct tty_struct *tty, struct usb_serial_port *port, |
886 | const unsigned char *buf, int count) |
887 | { |
888 | |
889 | int ret, data_len, new_len; |
890 | struct digi_port *priv = usb_get_serial_port_data(port); |
891 | unsigned char *data = port->write_urb->transfer_buffer; |
892 | unsigned long flags; |
893 | |
894 | dev_dbg(&port->dev, "digi_write: TOP: port=%d, count=%d\n" , |
895 | priv->dp_port_num, count); |
896 | |
897 | /* copy user data (which can sleep) before getting spin lock */ |
898 | count = min(count, port->bulk_out_size-2); |
899 | count = min(64, count); |
900 | |
901 | /* be sure only one write proceeds at a time */ |
902 | /* there are races on the port private buffer */ |
903 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
904 | |
905 | /* wait for urb status clear to submit another urb */ |
906 | if (priv->dp_write_urb_in_use) { |
907 | /* buffer data if count is 1 (probably put_char) if possible */ |
908 | if (count == 1 && priv->dp_out_buf_len < DIGI_OUT_BUF_SIZE) { |
909 | priv->dp_out_buf[priv->dp_out_buf_len++] = *buf; |
910 | new_len = 1; |
911 | } else { |
912 | new_len = 0; |
913 | } |
914 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
915 | return new_len; |
916 | } |
917 | |
918 | /* allow space for any buffered data and for new data, up to */ |
919 | /* transfer buffer size - 2 (for command and length bytes) */ |
920 | new_len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len); |
921 | data_len = new_len + priv->dp_out_buf_len; |
922 | |
923 | if (data_len == 0) { |
924 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
925 | return 0; |
926 | } |
927 | |
928 | port->write_urb->transfer_buffer_length = data_len+2; |
929 | |
930 | *data++ = DIGI_CMD_SEND_DATA; |
931 | *data++ = data_len; |
932 | |
933 | /* copy in buffered data first */ |
934 | memcpy(data, priv->dp_out_buf, priv->dp_out_buf_len); |
935 | data += priv->dp_out_buf_len; |
936 | |
937 | /* copy in new data */ |
938 | memcpy(data, buf, new_len); |
939 | |
940 | ret = usb_submit_urb(urb: port->write_urb, GFP_ATOMIC); |
941 | if (ret == 0) { |
942 | priv->dp_write_urb_in_use = 1; |
943 | ret = new_len; |
944 | priv->dp_out_buf_len = 0; |
945 | } |
946 | |
947 | /* return length of new data written, or error */ |
948 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
949 | if (ret < 0) |
950 | dev_err_console(port, |
951 | "%s: usb_submit_urb failed, ret=%d, port=%d\n" , |
952 | __func__, ret, priv->dp_port_num); |
953 | dev_dbg(&port->dev, "digi_write: returning %d\n" , ret); |
954 | return ret; |
955 | |
956 | } |
957 | |
958 | static void digi_write_bulk_callback(struct urb *urb) |
959 | { |
960 | |
961 | struct usb_serial_port *port = urb->context; |
962 | struct usb_serial *serial; |
963 | struct digi_port *priv; |
964 | struct digi_serial *serial_priv; |
965 | unsigned long flags; |
966 | int ret = 0; |
967 | int status = urb->status; |
968 | bool wakeup; |
969 | |
970 | /* port and serial sanity check */ |
971 | if (port == NULL || (priv = usb_get_serial_port_data(port)) == NULL) { |
972 | pr_err("%s: port or port->private is NULL, status=%d\n" , |
973 | __func__, status); |
974 | return; |
975 | } |
976 | serial = port->serial; |
977 | if (serial == NULL || (serial_priv = usb_get_serial_data(serial)) == NULL) { |
978 | dev_err(&port->dev, |
979 | "%s: serial or serial->private is NULL, status=%d\n" , |
980 | __func__, status); |
981 | return; |
982 | } |
983 | |
984 | /* handle oob callback */ |
985 | if (priv->dp_port_num == serial_priv->ds_oob_port_num) { |
986 | dev_dbg(&port->dev, "digi_write_bulk_callback: oob callback\n" ); |
987 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
988 | priv->dp_write_urb_in_use = 0; |
989 | wake_up_interruptible(&priv->write_wait); |
990 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
991 | return; |
992 | } |
993 | |
994 | /* try to send any buffered data on this port */ |
995 | wakeup = true; |
996 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
997 | priv->dp_write_urb_in_use = 0; |
998 | if (priv->dp_out_buf_len > 0) { |
999 | *((unsigned char *)(port->write_urb->transfer_buffer)) |
1000 | = (unsigned char)DIGI_CMD_SEND_DATA; |
1001 | *((unsigned char *)(port->write_urb->transfer_buffer) + 1) |
1002 | = (unsigned char)priv->dp_out_buf_len; |
1003 | port->write_urb->transfer_buffer_length = |
1004 | priv->dp_out_buf_len + 2; |
1005 | memcpy(port->write_urb->transfer_buffer + 2, priv->dp_out_buf, |
1006 | priv->dp_out_buf_len); |
1007 | ret = usb_submit_urb(urb: port->write_urb, GFP_ATOMIC); |
1008 | if (ret == 0) { |
1009 | priv->dp_write_urb_in_use = 1; |
1010 | priv->dp_out_buf_len = 0; |
1011 | wakeup = false; |
1012 | } |
1013 | } |
1014 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
1015 | |
1016 | if (ret && ret != -EPERM) |
1017 | dev_err_console(port, |
1018 | "%s: usb_submit_urb failed, ret=%d, port=%d\n" , |
1019 | __func__, ret, priv->dp_port_num); |
1020 | |
1021 | if (wakeup) |
1022 | tty_port_tty_wakeup(port: &port->port); |
1023 | } |
1024 | |
1025 | static unsigned int digi_write_room(struct tty_struct *tty) |
1026 | { |
1027 | struct usb_serial_port *port = tty->driver_data; |
1028 | struct digi_port *priv = usb_get_serial_port_data(port); |
1029 | unsigned long flags; |
1030 | unsigned int room; |
1031 | |
1032 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
1033 | |
1034 | if (priv->dp_write_urb_in_use) |
1035 | room = 0; |
1036 | else |
1037 | room = port->bulk_out_size - 2 - priv->dp_out_buf_len; |
1038 | |
1039 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
1040 | dev_dbg(&port->dev, "digi_write_room: port=%d, room=%u\n" , priv->dp_port_num, room); |
1041 | return room; |
1042 | |
1043 | } |
1044 | |
1045 | static unsigned int digi_chars_in_buffer(struct tty_struct *tty) |
1046 | { |
1047 | struct usb_serial_port *port = tty->driver_data; |
1048 | struct digi_port *priv = usb_get_serial_port_data(port); |
1049 | unsigned long flags; |
1050 | unsigned int chars; |
1051 | |
1052 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
1053 | if (priv->dp_write_urb_in_use) |
1054 | chars = port->bulk_out_size - 2; |
1055 | else |
1056 | chars = priv->dp_out_buf_len; |
1057 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
1058 | |
1059 | dev_dbg(&port->dev, "%s: port=%d, chars=%d\n" , __func__, |
1060 | priv->dp_port_num, chars); |
1061 | return chars; |
1062 | } |
1063 | |
1064 | static void digi_dtr_rts(struct usb_serial_port *port, int on) |
1065 | { |
1066 | /* Adjust DTR and RTS */ |
1067 | digi_set_modem_signals(port, modem_signals: on * (TIOCM_DTR | TIOCM_RTS), interruptible: 1); |
1068 | } |
1069 | |
1070 | static int digi_open(struct tty_struct *tty, struct usb_serial_port *port) |
1071 | { |
1072 | int ret; |
1073 | unsigned char buf[32]; |
1074 | struct digi_port *priv = usb_get_serial_port_data(port); |
1075 | struct ktermios not_termios; |
1076 | |
1077 | /* be sure the device is started up */ |
1078 | if (digi_startup_device(serial: port->serial) != 0) |
1079 | return -ENXIO; |
1080 | |
1081 | /* read modem signals automatically whenever they change */ |
1082 | buf[0] = DIGI_CMD_READ_INPUT_SIGNALS; |
1083 | buf[1] = priv->dp_port_num; |
1084 | buf[2] = DIGI_ENABLE; |
1085 | buf[3] = 0; |
1086 | |
1087 | /* flush fifos */ |
1088 | buf[4] = DIGI_CMD_IFLUSH_FIFO; |
1089 | buf[5] = priv->dp_port_num; |
1090 | buf[6] = DIGI_FLUSH_TX | DIGI_FLUSH_RX; |
1091 | buf[7] = 0; |
1092 | |
1093 | ret = digi_write_oob_command(port, buf, count: 8, interruptible: 1); |
1094 | if (ret != 0) |
1095 | dev_dbg(&port->dev, "digi_open: write oob failed, ret=%d\n" , ret); |
1096 | |
1097 | /* set termios settings */ |
1098 | if (tty) { |
1099 | not_termios.c_cflag = ~tty->termios.c_cflag; |
1100 | not_termios.c_iflag = ~tty->termios.c_iflag; |
1101 | digi_set_termios(tty, port, old_termios: ¬_termios); |
1102 | } |
1103 | return 0; |
1104 | } |
1105 | |
1106 | |
1107 | static void digi_close(struct usb_serial_port *port) |
1108 | { |
1109 | DEFINE_WAIT(wait); |
1110 | int ret; |
1111 | unsigned char buf[32]; |
1112 | struct digi_port *priv = usb_get_serial_port_data(port); |
1113 | |
1114 | mutex_lock(&port->serial->disc_mutex); |
1115 | /* if disconnected, just clear flags */ |
1116 | if (port->serial->disconnected) |
1117 | goto exit; |
1118 | |
1119 | /* FIXME: Transmit idle belongs in the wait_unti_sent path */ |
1120 | digi_transmit_idle(port, DIGI_CLOSE_TIMEOUT); |
1121 | |
1122 | /* disable input flow control */ |
1123 | buf[0] = DIGI_CMD_SET_INPUT_FLOW_CONTROL; |
1124 | buf[1] = priv->dp_port_num; |
1125 | buf[2] = DIGI_DISABLE; |
1126 | buf[3] = 0; |
1127 | |
1128 | /* disable output flow control */ |
1129 | buf[4] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL; |
1130 | buf[5] = priv->dp_port_num; |
1131 | buf[6] = DIGI_DISABLE; |
1132 | buf[7] = 0; |
1133 | |
1134 | /* disable reading modem signals automatically */ |
1135 | buf[8] = DIGI_CMD_READ_INPUT_SIGNALS; |
1136 | buf[9] = priv->dp_port_num; |
1137 | buf[10] = DIGI_DISABLE; |
1138 | buf[11] = 0; |
1139 | |
1140 | /* disable receive */ |
1141 | buf[12] = DIGI_CMD_RECEIVE_ENABLE; |
1142 | buf[13] = priv->dp_port_num; |
1143 | buf[14] = DIGI_DISABLE; |
1144 | buf[15] = 0; |
1145 | |
1146 | /* flush fifos */ |
1147 | buf[16] = DIGI_CMD_IFLUSH_FIFO; |
1148 | buf[17] = priv->dp_port_num; |
1149 | buf[18] = DIGI_FLUSH_TX | DIGI_FLUSH_RX; |
1150 | buf[19] = 0; |
1151 | |
1152 | ret = digi_write_oob_command(port, buf, count: 20, interruptible: 0); |
1153 | if (ret != 0) |
1154 | dev_dbg(&port->dev, "digi_close: write oob failed, ret=%d\n" , |
1155 | ret); |
1156 | /* wait for final commands on oob port to complete */ |
1157 | prepare_to_wait(wq_head: &priv->dp_flush_wait, wq_entry: &wait, |
1158 | TASK_INTERRUPTIBLE); |
1159 | schedule_timeout(DIGI_CLOSE_TIMEOUT); |
1160 | finish_wait(wq_head: &priv->dp_flush_wait, wq_entry: &wait); |
1161 | |
1162 | /* shutdown any outstanding bulk writes */ |
1163 | usb_kill_urb(urb: port->write_urb); |
1164 | exit: |
1165 | spin_lock_irq(lock: &priv->dp_port_lock); |
1166 | priv->dp_write_urb_in_use = 0; |
1167 | wake_up_interruptible(&priv->dp_close_wait); |
1168 | spin_unlock_irq(lock: &priv->dp_port_lock); |
1169 | mutex_unlock(lock: &port->serial->disc_mutex); |
1170 | } |
1171 | |
1172 | |
1173 | /* |
1174 | * Digi Startup Device |
1175 | * |
1176 | * Starts reads on all ports. Must be called AFTER startup, with |
1177 | * urbs initialized. Returns 0 if successful, non-zero error otherwise. |
1178 | */ |
1179 | |
1180 | static int digi_startup_device(struct usb_serial *serial) |
1181 | { |
1182 | int i, ret = 0; |
1183 | struct digi_serial *serial_priv = usb_get_serial_data(serial); |
1184 | struct usb_serial_port *port; |
1185 | |
1186 | /* be sure this happens exactly once */ |
1187 | spin_lock(lock: &serial_priv->ds_serial_lock); |
1188 | if (serial_priv->ds_device_started) { |
1189 | spin_unlock(lock: &serial_priv->ds_serial_lock); |
1190 | return 0; |
1191 | } |
1192 | serial_priv->ds_device_started = 1; |
1193 | spin_unlock(lock: &serial_priv->ds_serial_lock); |
1194 | |
1195 | /* start reading from each bulk in endpoint for the device */ |
1196 | /* set USB_DISABLE_SPD flag for write bulk urbs */ |
1197 | for (i = 0; i < serial->type->num_ports + 1; i++) { |
1198 | port = serial->port[i]; |
1199 | ret = usb_submit_urb(urb: port->read_urb, GFP_KERNEL); |
1200 | if (ret != 0) { |
1201 | dev_err(&port->dev, |
1202 | "%s: usb_submit_urb failed, ret=%d, port=%d\n" , |
1203 | __func__, ret, i); |
1204 | break; |
1205 | } |
1206 | } |
1207 | return ret; |
1208 | } |
1209 | |
1210 | static int digi_port_init(struct usb_serial_port *port, unsigned port_num) |
1211 | { |
1212 | struct digi_port *priv; |
1213 | |
1214 | priv = kzalloc(size: sizeof(*priv), GFP_KERNEL); |
1215 | if (!priv) |
1216 | return -ENOMEM; |
1217 | |
1218 | spin_lock_init(&priv->dp_port_lock); |
1219 | priv->dp_port_num = port_num; |
1220 | init_waitqueue_head(&priv->dp_transmit_idle_wait); |
1221 | init_waitqueue_head(&priv->dp_flush_wait); |
1222 | init_waitqueue_head(&priv->dp_close_wait); |
1223 | init_waitqueue_head(&priv->write_wait); |
1224 | priv->dp_port = port; |
1225 | |
1226 | usb_set_serial_port_data(port, data: priv); |
1227 | |
1228 | return 0; |
1229 | } |
1230 | |
1231 | static int digi_startup(struct usb_serial *serial) |
1232 | { |
1233 | struct digi_serial *serial_priv; |
1234 | int ret; |
1235 | |
1236 | serial_priv = kzalloc(size: sizeof(*serial_priv), GFP_KERNEL); |
1237 | if (!serial_priv) |
1238 | return -ENOMEM; |
1239 | |
1240 | spin_lock_init(&serial_priv->ds_serial_lock); |
1241 | serial_priv->ds_oob_port_num = serial->type->num_ports; |
1242 | serial_priv->ds_oob_port = serial->port[serial_priv->ds_oob_port_num]; |
1243 | |
1244 | ret = digi_port_init(port: serial_priv->ds_oob_port, |
1245 | port_num: serial_priv->ds_oob_port_num); |
1246 | if (ret) { |
1247 | kfree(objp: serial_priv); |
1248 | return ret; |
1249 | } |
1250 | |
1251 | usb_set_serial_data(serial, data: serial_priv); |
1252 | |
1253 | return 0; |
1254 | } |
1255 | |
1256 | |
1257 | static void digi_disconnect(struct usb_serial *serial) |
1258 | { |
1259 | int i; |
1260 | |
1261 | /* stop reads and writes on all ports */ |
1262 | for (i = 0; i < serial->type->num_ports + 1; i++) { |
1263 | usb_kill_urb(urb: serial->port[i]->read_urb); |
1264 | usb_kill_urb(urb: serial->port[i]->write_urb); |
1265 | } |
1266 | } |
1267 | |
1268 | |
1269 | static void digi_release(struct usb_serial *serial) |
1270 | { |
1271 | struct digi_serial *serial_priv; |
1272 | struct digi_port *priv; |
1273 | |
1274 | serial_priv = usb_get_serial_data(serial); |
1275 | |
1276 | priv = usb_get_serial_port_data(port: serial_priv->ds_oob_port); |
1277 | kfree(objp: priv); |
1278 | |
1279 | kfree(objp: serial_priv); |
1280 | } |
1281 | |
1282 | static int digi_port_probe(struct usb_serial_port *port) |
1283 | { |
1284 | return digi_port_init(port, port_num: port->port_number); |
1285 | } |
1286 | |
1287 | static void digi_port_remove(struct usb_serial_port *port) |
1288 | { |
1289 | struct digi_port *priv; |
1290 | |
1291 | priv = usb_get_serial_port_data(port); |
1292 | kfree(objp: priv); |
1293 | } |
1294 | |
1295 | static void digi_read_bulk_callback(struct urb *urb) |
1296 | { |
1297 | struct usb_serial_port *port = urb->context; |
1298 | struct digi_port *priv; |
1299 | struct digi_serial *serial_priv; |
1300 | int ret; |
1301 | int status = urb->status; |
1302 | |
1303 | /* port sanity check, do not resubmit if port is not valid */ |
1304 | if (port == NULL) |
1305 | return; |
1306 | priv = usb_get_serial_port_data(port); |
1307 | if (priv == NULL) { |
1308 | dev_err(&port->dev, "%s: port->private is NULL, status=%d\n" , |
1309 | __func__, status); |
1310 | return; |
1311 | } |
1312 | if (port->serial == NULL || |
1313 | (serial_priv = usb_get_serial_data(serial: port->serial)) == NULL) { |
1314 | dev_err(&port->dev, "%s: serial is bad or serial->private " |
1315 | "is NULL, status=%d\n" , __func__, status); |
1316 | return; |
1317 | } |
1318 | |
1319 | /* do not resubmit urb if it has any status error */ |
1320 | if (status) { |
1321 | dev_err(&port->dev, |
1322 | "%s: nonzero read bulk status: status=%d, port=%d\n" , |
1323 | __func__, status, priv->dp_port_num); |
1324 | return; |
1325 | } |
1326 | |
1327 | /* handle oob or inb callback, do not resubmit if error */ |
1328 | if (priv->dp_port_num == serial_priv->ds_oob_port_num) { |
1329 | if (digi_read_oob_callback(urb) != 0) |
1330 | return; |
1331 | } else { |
1332 | if (digi_read_inb_callback(urb) != 0) |
1333 | return; |
1334 | } |
1335 | |
1336 | /* continue read */ |
1337 | ret = usb_submit_urb(urb, GFP_ATOMIC); |
1338 | if (ret != 0 && ret != -EPERM) { |
1339 | dev_err(&port->dev, |
1340 | "%s: failed resubmitting urb, ret=%d, port=%d\n" , |
1341 | __func__, ret, priv->dp_port_num); |
1342 | } |
1343 | |
1344 | } |
1345 | |
1346 | /* |
1347 | * Digi Read INB Callback |
1348 | * |
1349 | * Digi Read INB Callback handles reads on the in band ports, sending |
1350 | * the data on to the tty subsystem. When called we know port and |
1351 | * port->private are not NULL and port->serial has been validated. |
1352 | * It returns 0 if successful, 1 if successful but the port is |
1353 | * throttled, and -1 if the sanity checks failed. |
1354 | */ |
1355 | |
1356 | static int digi_read_inb_callback(struct urb *urb) |
1357 | { |
1358 | struct usb_serial_port *port = urb->context; |
1359 | struct digi_port *priv = usb_get_serial_port_data(port); |
1360 | unsigned char *buf = urb->transfer_buffer; |
1361 | unsigned long flags; |
1362 | int opcode; |
1363 | int len; |
1364 | int port_status; |
1365 | unsigned char *data; |
1366 | int tty_flag, throttled; |
1367 | |
1368 | /* short/multiple packet check */ |
1369 | if (urb->actual_length < 2) { |
1370 | dev_warn(&port->dev, "short packet received\n" ); |
1371 | return -1; |
1372 | } |
1373 | |
1374 | opcode = buf[0]; |
1375 | len = buf[1]; |
1376 | |
1377 | if (urb->actual_length != len + 2) { |
1378 | dev_err(&port->dev, "malformed packet received: port=%d, opcode=%d, len=%d, actual_length=%u\n" , |
1379 | priv->dp_port_num, opcode, len, urb->actual_length); |
1380 | return -1; |
1381 | } |
1382 | |
1383 | if (opcode == DIGI_CMD_RECEIVE_DATA && len < 1) { |
1384 | dev_err(&port->dev, "malformed data packet received\n" ); |
1385 | return -1; |
1386 | } |
1387 | |
1388 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
1389 | |
1390 | /* check for throttle; if set, do not resubmit read urb */ |
1391 | /* indicate the read chain needs to be restarted on unthrottle */ |
1392 | throttled = priv->dp_throttled; |
1393 | if (throttled) |
1394 | priv->dp_throttle_restart = 1; |
1395 | |
1396 | /* receive data */ |
1397 | if (opcode == DIGI_CMD_RECEIVE_DATA) { |
1398 | port_status = buf[2]; |
1399 | data = &buf[3]; |
1400 | |
1401 | /* get flag from port_status */ |
1402 | tty_flag = 0; |
1403 | |
1404 | /* overrun is special, not associated with a char */ |
1405 | if (port_status & DIGI_OVERRUN_ERROR) |
1406 | tty_insert_flip_char(port: &port->port, ch: 0, TTY_OVERRUN); |
1407 | |
1408 | /* break takes precedence over parity, */ |
1409 | /* which takes precedence over framing errors */ |
1410 | if (port_status & DIGI_BREAK_ERROR) |
1411 | tty_flag = TTY_BREAK; |
1412 | else if (port_status & DIGI_PARITY_ERROR) |
1413 | tty_flag = TTY_PARITY; |
1414 | else if (port_status & DIGI_FRAMING_ERROR) |
1415 | tty_flag = TTY_FRAME; |
1416 | |
1417 | /* data length is len-1 (one byte of len is port_status) */ |
1418 | --len; |
1419 | if (len > 0) { |
1420 | tty_insert_flip_string_fixed_flag(port: &port->port, chars: data, |
1421 | flag: tty_flag, size: len); |
1422 | tty_flip_buffer_push(port: &port->port); |
1423 | } |
1424 | } |
1425 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
1426 | |
1427 | if (opcode == DIGI_CMD_RECEIVE_DISABLE) |
1428 | dev_dbg(&port->dev, "%s: got RECEIVE_DISABLE\n" , __func__); |
1429 | else if (opcode != DIGI_CMD_RECEIVE_DATA) |
1430 | dev_dbg(&port->dev, "%s: unknown opcode: %d\n" , __func__, opcode); |
1431 | |
1432 | return throttled ? 1 : 0; |
1433 | |
1434 | } |
1435 | |
1436 | |
1437 | /* |
1438 | * Digi Read OOB Callback |
1439 | * |
1440 | * Digi Read OOB Callback handles reads on the out of band port. |
1441 | * When called we know port and port->private are not NULL and |
1442 | * the port->serial is valid. It returns 0 if successful, and |
1443 | * -1 if the sanity checks failed. |
1444 | */ |
1445 | |
1446 | static int digi_read_oob_callback(struct urb *urb) |
1447 | { |
1448 | |
1449 | struct usb_serial_port *port = urb->context; |
1450 | struct usb_serial *serial = port->serial; |
1451 | struct tty_struct *tty; |
1452 | struct digi_port *priv; |
1453 | unsigned char *buf = urb->transfer_buffer; |
1454 | int opcode, line, status, val; |
1455 | unsigned long flags; |
1456 | int i; |
1457 | unsigned int rts; |
1458 | |
1459 | if (urb->actual_length < 4) |
1460 | return -1; |
1461 | |
1462 | /* handle each oob command */ |
1463 | for (i = 0; i < urb->actual_length - 3; i += 4) { |
1464 | opcode = buf[i]; |
1465 | line = buf[i + 1]; |
1466 | status = buf[i + 2]; |
1467 | val = buf[i + 3]; |
1468 | |
1469 | dev_dbg(&port->dev, "digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d\n" , |
1470 | opcode, line, status, val); |
1471 | |
1472 | if (status != 0 || line >= serial->type->num_ports) |
1473 | continue; |
1474 | |
1475 | port = serial->port[line]; |
1476 | |
1477 | priv = usb_get_serial_port_data(port); |
1478 | if (priv == NULL) |
1479 | return -1; |
1480 | |
1481 | tty = tty_port_tty_get(port: &port->port); |
1482 | |
1483 | rts = 0; |
1484 | if (tty) |
1485 | rts = C_CRTSCTS(tty); |
1486 | |
1487 | if (tty && opcode == DIGI_CMD_READ_INPUT_SIGNALS) { |
1488 | bool wakeup = false; |
1489 | |
1490 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
1491 | /* convert from digi flags to termiox flags */ |
1492 | if (val & DIGI_READ_INPUT_SIGNALS_CTS) { |
1493 | priv->dp_modem_signals |= TIOCM_CTS; |
1494 | if (rts) |
1495 | wakeup = true; |
1496 | } else { |
1497 | priv->dp_modem_signals &= ~TIOCM_CTS; |
1498 | /* port must be open to use tty struct */ |
1499 | } |
1500 | if (val & DIGI_READ_INPUT_SIGNALS_DSR) |
1501 | priv->dp_modem_signals |= TIOCM_DSR; |
1502 | else |
1503 | priv->dp_modem_signals &= ~TIOCM_DSR; |
1504 | if (val & DIGI_READ_INPUT_SIGNALS_RI) |
1505 | priv->dp_modem_signals |= TIOCM_RI; |
1506 | else |
1507 | priv->dp_modem_signals &= ~TIOCM_RI; |
1508 | if (val & DIGI_READ_INPUT_SIGNALS_DCD) |
1509 | priv->dp_modem_signals |= TIOCM_CD; |
1510 | else |
1511 | priv->dp_modem_signals &= ~TIOCM_CD; |
1512 | |
1513 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
1514 | |
1515 | if (wakeup) |
1516 | tty_port_tty_wakeup(port: &port->port); |
1517 | } else if (opcode == DIGI_CMD_TRANSMIT_IDLE) { |
1518 | spin_lock_irqsave(&priv->dp_port_lock, flags); |
1519 | priv->dp_transmit_idle = 1; |
1520 | wake_up_interruptible(&priv->dp_transmit_idle_wait); |
1521 | spin_unlock_irqrestore(lock: &priv->dp_port_lock, flags); |
1522 | } else if (opcode == DIGI_CMD_IFLUSH_FIFO) { |
1523 | wake_up_interruptible(&priv->dp_flush_wait); |
1524 | } |
1525 | tty_kref_put(tty); |
1526 | } |
1527 | return 0; |
1528 | |
1529 | } |
1530 | |
1531 | module_usb_serial_driver(serial_drivers, id_table_combined); |
1532 | |
1533 | MODULE_AUTHOR(DRIVER_AUTHOR); |
1534 | MODULE_DESCRIPTION(DRIVER_DESC); |
1535 | MODULE_LICENSE("GPL" ); |
1536 | |