blob: 68e80be6b9e1888dbc82b7c8cc6584a9f7abddb7 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2* Digi AccelePort USB-4 and USB-2 Serial Converters
3*
4* Copyright 2000 by Digi International
5*
6* This program is free software; you can redistribute it and/or modify
7* it under the terms of the GNU General Public License as published by
8* the Free Software Foundation; either version 2 of the License, or
9* (at your option) any later version.
10*
11* Shamelessly based on Brian Warner's keyspan_pda.c and Greg Kroah-Hartman's
12* usb-serial driver.
13*
14* Peter Berger (pberger@brimson.com)
15* Al Borchers (borchers@steinerpoint.com)
16*
17* (12/03/2001) gkh
Alan Cox95da3102008-07-22 11:09:07 +010018* switched to using port->port.count instead of private version.
Linus Torvalds1da177e2005-04-16 15:20:36 -070019* Removed port->active
20*
21* (04/08/2001) gb
22* Identify version on module load.
23*
24* (11/01/2000) Adam J. Richter
25* usb_device_id table support
26*
27* (11/01/2000) pberger and borchers
28* -- Turned off the USB_DISABLE_SPD flag for write bulk urbs--it caused
29* USB 4 ports to hang on startup.
30* -- Serialized access to write urbs by adding the dp_write_urb_in_use
31* flag; otherwise, the driver caused SMP system hangs. Watching the
32* urb status is not sufficient.
33*
34* (10/05/2000) gkh
35* -- Fixed bug with urb->dev not being set properly, now that the usb
36* core needs it.
37*
38* (8/8/2000) pberger and borchers
39* -- Fixed close so that
40* - it can timeout while waiting for transmit idle, if needed;
41* - it ignores interrupts when flushing the port, turning
42* of modem signalling, and so on;
43* - it waits for the flush to really complete before returning.
44* -- Read_bulk_callback and write_bulk_callback check for a closed
45* port before using the tty struct or writing to the port.
46* -- The two changes above fix the oops caused by interrupted closes.
47* -- Added interruptible args to write_oob_command and set_modem_signals
48* and added a timeout arg to transmit_idle; needed for fixes to
49* close.
50* -- Added code for rx_throttle and rx_unthrottle so that input flow
51* control works.
52* -- Added code to set overrun, parity, framing, and break errors
53* (untested).
54* -- Set USB_DISABLE_SPD flag for write bulk urbs, so no 0 length
55* bulk writes are done. These hung the Digi USB device. The
56* 0 length bulk writes were a new feature of usb-uhci added in
57* the 2.4.0-test6 kernels.
58* -- Fixed mod inc race in open; do mod inc before sleeping to wait
59* for a close to finish.
60*
61* (7/31/2000) pberger
62* -- Fixed bugs with hardware handshaking:
63* - Added code to set/clear tty->hw_stopped in digi_read_oob_callback()
64* and digi_set_termios()
65* -- Added code in digi_set_termios() to
66* - add conditional in code handling transition from B0 to only
67* set RTS if RTS/CTS flow control is either not in use or if
68* the port is not currently throttled.
69* - handle turning off CRTSCTS.
70*
71* (7/30/2000) borchers
72* -- Added support for more than one Digi USB device by moving
73* globals to a private structure in the pointed to from the
74* usb_serial structure.
75* -- Moved the modem change and transmit idle wait queues into
76* the port private structure, so each port has its own queue
77* rather than sharing global queues.
78* -- Added support for break signals.
79*
80* (7/25/2000) pberger
81* -- Added USB-2 support. Note: the USB-2 supports 3 devices: two
82* serial and a parallel port. The parallel port is implemented
83* as a serial-to-parallel converter. That is, the driver actually
84* presents all three USB-2 interfaces as serial ports, but the third
85* one physically connects to a parallel device. Thus, for example,
86* one could plug a parallel printer into the USB-2's third port,
87* but from the kernel's (and userland's) point of view what's
88* actually out there is a serial device.
89*
90* (7/15/2000) borchers
91* -- Fixed race in open when a close is in progress.
92* -- Keep count of opens and dec the module use count for each
93* outstanding open when shutdown is called (on disconnect).
94* -- Fixed sanity checks in read_bulk_callback and write_bulk_callback
95* so pointers are checked before use.
96* -- Split read bulk callback into in band and out of band
97* callbacks, and no longer restart read chains if there is
98* a status error or a sanity error. This fixed the seg
99* faults and other errors we used to get on disconnect.
100* -- Port->active is once again a flag as usb-serial intended it
101* to be, not a count. Since it was only a char it would
102* have been limited to 256 simultaneous opens. Now the open
103* count is kept in the port private structure in dp_open_count.
104* -- Added code for modularization of the digi_acceleport driver.
105*
106* (6/27/2000) pberger and borchers
107* -- Zeroed out sync field in the wakeup_task before first use;
108* otherwise the uninitialized value might prevent the task from
109* being scheduled.
110* -- Initialized ret value to 0 in write_bulk_callback, otherwise
111* the uninitialized value could cause a spurious debugging message.
112*
113* (6/22/2000) pberger and borchers
114* -- Made cond_wait_... inline--apparently on SPARC the flags arg
115* to spin_lock_irqsave cannot be passed to another function
116* to call spin_unlock_irqrestore. Thanks to Pauline Middelink.
117* -- In digi_set_modem_signals the inner nested spin locks use just
118* spin_lock() rather than spin_lock_irqsave(). The old code
119* mistakenly left interrupts off. Thanks to Pauline Middelink.
120* -- copy_from_user (which can sleep) is no longer called while a
121* spinlock is held. We copy to a local buffer before getting
122* the spinlock--don't like the extra copy but the code is simpler.
123* -- Printk and dbg are no longer called while a spin lock is held.
124*
125* (6/4/2000) pberger and borchers
126* -- Replaced separate calls to spin_unlock_irqrestore and
127* interruptible_sleep_on_timeout with a new function
128* cond_wait_interruptible_timeout_irqrestore. This eliminates
129* the race condition where the wake up could happen after
130* the unlock and before the sleep.
131* -- Close now waits for output to drain.
132* -- Open waits until any close in progress is finished.
133* -- All out of band responses are now processed, not just the
134* first in a USB packet.
135* -- Fixed a bug that prevented the driver from working when the
136* first Digi port was not the first USB serial port--the driver
137* was mistakenly using the external USB serial port number to
138* try to index into its internal ports.
139* -- Fixed an SMP bug -- write_bulk_callback is called directly from
140* an interrupt, so spin_lock_irqsave/spin_unlock_irqrestore are
141* needed for locks outside write_bulk_callback that are also
142* acquired by write_bulk_callback to prevent deadlocks.
143* -- Fixed support for select() by making digi_chars_in_buffer()
144* return 256 when -EINPROGRESS is set, as the line discipline
145* code in n_tty.c expects.
146* -- Fixed an include file ordering problem that prevented debugging
147* messages from working.
148* -- Fixed an intermittent timeout problem that caused writes to
149* sometimes get stuck on some machines on some kernels. It turns
150* out in these circumstances write_chan() (in n_tty.c) was
151* asleep waiting for our wakeup call. Even though we call
152* wake_up_interruptible() in digi_write_bulk_callback(), there is
153* a race condition that could cause the wakeup to fail: if our
154* wake_up_interruptible() call occurs between the time that our
155* driver write routine finishes and write_chan() sets current->state
156* to TASK_INTERRUPTIBLE, the effect of our wakeup setting the state
157* to TASK_RUNNING will be lost and write_chan's subsequent call to
158* schedule() will never return (unless it catches a signal).
159* This race condition occurs because write_bulk_callback() (and thus
Matt LaPlante0779bf22006-11-30 05:24:39 +0100160* the wakeup) are called asynchronously from an interrupt, rather than
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161* from the scheduler. We can avoid the race by calling the wakeup
162* from the scheduler queue and that's our fix: Now, at the end of
163* write_bulk_callback() we queue up a wakeup call on the scheduler
164* task queue. We still also invoke the wakeup directly since that
165* squeezes a bit more performance out of the driver, and any lost
166* race conditions will get cleaned up at the next scheduler run.
167*
168* NOTE: The problem also goes away if you comment out
169* the two code lines in write_chan() where current->state
170* is set to TASK_RUNNING just before calling driver.write() and to
171* TASK_INTERRUPTIBLE immediately afterwards. This is why the
172* problem did not show up with the 2.2 kernels -- they do not
173* include that code.
174*
175* (5/16/2000) pberger and borchers
176* -- Added timeouts to sleeps, to defend against lost wake ups.
177* -- Handle transition to/from B0 baud rate in digi_set_termios.
178*
179* (5/13/2000) pberger and borchers
180* -- All commands now sent on out of band port, using
181* digi_write_oob_command.
182* -- Get modem control signals whenever they change, support TIOCMGET/
183* SET/BIS/BIC ioctls.
184* -- digi_set_termios now supports parity, word size, stop bits, and
185* receive enable.
186* -- Cleaned up open and close, use digi_set_termios and
187* digi_write_oob_command to set port parameters.
188* -- Added digi_startup_device to start read chains on all ports.
189* -- Write buffer is only used when count==1, to be sure put_char can
190* write a char (unless the buffer is full).
191*
192* (5/10/2000) pberger and borchers
193* -- Added MOD_INC_USE_COUNT/MOD_DEC_USE_COUNT calls on open/close.
194* -- Fixed problem where the first incoming character is lost on
195* port opens after the first close on that port. Now we keep
196* the read_urb chain open until shutdown.
197* -- Added more port conditioning calls in digi_open and digi_close.
198* -- Convert port->active to a use count so that we can deal with multiple
199* opens and closes properly.
200* -- Fixed some problems with the locking code.
201*
202* (5/3/2000) pberger and borchers
203* -- First alpha version of the driver--many known limitations and bugs.
204*
205*
206* Locking and SMP
207*
208* - Each port, including the out-of-band port, has a lock used to
209* serialize all access to the port's private structure.
210* - The port lock is also used to serialize all writes and access to
211* the port's URB.
212* - The port lock is also used for the port write_wait condition
213* variable. Holding the port lock will prevent a wake up on the
214* port's write_wait; this can be used with cond_wait_... to be sure
215* the wake up is not lost in a race when dropping the lock and
216* sleeping waiting for the wakeup.
217* - digi_write() does not sleep, since it is sometimes called on
218* interrupt time.
219* - digi_write_bulk_callback() and digi_read_bulk_callback() are
220* called directly from interrupts. Hence spin_lock_irqsave()
221* and spin_unlock_irqrestore() are used in the rest of the code
222* for any locks they acquire.
223* - digi_write_bulk_callback() gets the port lock before waking up
224* processes sleeping on the port write_wait. It also schedules
225* wake ups so they happen from the scheduler, because the tty
226* system can miss wake ups from interrupts.
227* - All sleeps use a timeout of DIGI_RETRY_TIMEOUT before looping to
228* recheck the condition they are sleeping on. This is defensive,
229* in case a wake up is lost.
230* - Following Documentation/DocBook/kernel-locking.pdf no spin locks
231* are held when calling copy_to/from_user or printk.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232*/
233
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234#include <linux/kernel.h>
235#include <linux/errno.h>
236#include <linux/init.h>
237#include <linux/slab.h>
238#include <linux/tty.h>
239#include <linux/tty_driver.h>
240#include <linux/tty_flip.h>
241#include <linux/module.h>
242#include <linux/spinlock.h>
243#include <linux/workqueue.h>
Alan Cox41ad4272008-07-22 11:11:02 +0100244#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245#include <linux/usb.h>
246#include <linux/wait.h>
Greg Kroah-Hartmana9698882006-07-11 21:22:58 -0700247#include <linux/usb/serial.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700248
249/* Defines */
250
251/*
252 * Version Information
253 */
254#define DRIVER_VERSION "v1.80.1.2"
255#define DRIVER_AUTHOR "Peter Berger <pberger@brimson.com>, Al Borchers <borchers@steinerpoint.com>"
256#define DRIVER_DESC "Digi AccelePort USB-2/USB-4 Serial Converter driver"
257
258/* port output buffer length -- must be <= transfer buffer length - 2 */
259/* so we can be sure to send the full buffer in one urb */
260#define DIGI_OUT_BUF_SIZE 8
261
262/* port input buffer length -- must be >= transfer buffer length - 3 */
263/* so we can be sure to hold at least one full buffer from one urb */
264#define DIGI_IN_BUF_SIZE 64
265
266/* retry timeout while sleeping */
267#define DIGI_RETRY_TIMEOUT (HZ/10)
268
269/* timeout while waiting for tty output to drain in close */
270/* this delay is used twice in close, so the total delay could */
271/* be twice this value */
272#define DIGI_CLOSE_TIMEOUT (5*HZ)
273
274
275/* AccelePort USB Defines */
276
277/* ids */
278#define DIGI_VENDOR_ID 0x05c5
279#define DIGI_2_ID 0x0002 /* USB-2 */
280#define DIGI_4_ID 0x0004 /* USB-4 */
281
282/* commands
283 * "INB": can be used on the in-band endpoint
284 * "OOB": can be used on the out-of-band endpoint
285 */
286#define DIGI_CMD_SET_BAUD_RATE 0 /* INB, OOB */
287#define DIGI_CMD_SET_WORD_SIZE 1 /* INB, OOB */
288#define DIGI_CMD_SET_PARITY 2 /* INB, OOB */
289#define DIGI_CMD_SET_STOP_BITS 3 /* INB, OOB */
290#define DIGI_CMD_SET_INPUT_FLOW_CONTROL 4 /* INB, OOB */
291#define DIGI_CMD_SET_OUTPUT_FLOW_CONTROL 5 /* INB, OOB */
292#define DIGI_CMD_SET_DTR_SIGNAL 6 /* INB, OOB */
293#define DIGI_CMD_SET_RTS_SIGNAL 7 /* INB, OOB */
294#define DIGI_CMD_READ_INPUT_SIGNALS 8 /* OOB */
295#define DIGI_CMD_IFLUSH_FIFO 9 /* OOB */
296#define DIGI_CMD_RECEIVE_ENABLE 10 /* INB, OOB */
297#define DIGI_CMD_BREAK_CONTROL 11 /* INB, OOB */
298#define DIGI_CMD_LOCAL_LOOPBACK 12 /* INB, OOB */
299#define DIGI_CMD_TRANSMIT_IDLE 13 /* INB, OOB */
300#define DIGI_CMD_READ_UART_REGISTER 14 /* OOB */
301#define DIGI_CMD_WRITE_UART_REGISTER 15 /* INB, OOB */
302#define DIGI_CMD_AND_UART_REGISTER 16 /* INB, OOB */
303#define DIGI_CMD_OR_UART_REGISTER 17 /* INB, OOB */
304#define DIGI_CMD_SEND_DATA 18 /* INB */
305#define DIGI_CMD_RECEIVE_DATA 19 /* INB */
306#define DIGI_CMD_RECEIVE_DISABLE 20 /* INB */
307#define DIGI_CMD_GET_PORT_TYPE 21 /* OOB */
308
309/* baud rates */
310#define DIGI_BAUD_50 0
311#define DIGI_BAUD_75 1
312#define DIGI_BAUD_110 2
313#define DIGI_BAUD_150 3
314#define DIGI_BAUD_200 4
315#define DIGI_BAUD_300 5
316#define DIGI_BAUD_600 6
317#define DIGI_BAUD_1200 7
318#define DIGI_BAUD_1800 8
319#define DIGI_BAUD_2400 9
320#define DIGI_BAUD_4800 10
321#define DIGI_BAUD_7200 11
322#define DIGI_BAUD_9600 12
323#define DIGI_BAUD_14400 13
324#define DIGI_BAUD_19200 14
325#define DIGI_BAUD_28800 15
326#define DIGI_BAUD_38400 16
327#define DIGI_BAUD_57600 17
328#define DIGI_BAUD_76800 18
329#define DIGI_BAUD_115200 19
330#define DIGI_BAUD_153600 20
331#define DIGI_BAUD_230400 21
332#define DIGI_BAUD_460800 22
333
334/* arguments */
335#define DIGI_WORD_SIZE_5 0
336#define DIGI_WORD_SIZE_6 1
337#define DIGI_WORD_SIZE_7 2
338#define DIGI_WORD_SIZE_8 3
339
340#define DIGI_PARITY_NONE 0
341#define DIGI_PARITY_ODD 1
342#define DIGI_PARITY_EVEN 2
343#define DIGI_PARITY_MARK 3
344#define DIGI_PARITY_SPACE 4
345
346#define DIGI_STOP_BITS_1 0
347#define DIGI_STOP_BITS_2 1
348
349#define DIGI_INPUT_FLOW_CONTROL_XON_XOFF 1
350#define DIGI_INPUT_FLOW_CONTROL_RTS 2
351#define DIGI_INPUT_FLOW_CONTROL_DTR 4
352
353#define DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF 1
354#define DIGI_OUTPUT_FLOW_CONTROL_CTS 2
355#define DIGI_OUTPUT_FLOW_CONTROL_DSR 4
356
357#define DIGI_DTR_INACTIVE 0
358#define DIGI_DTR_ACTIVE 1
359#define DIGI_DTR_INPUT_FLOW_CONTROL 2
360
361#define DIGI_RTS_INACTIVE 0
362#define DIGI_RTS_ACTIVE 1
363#define DIGI_RTS_INPUT_FLOW_CONTROL 2
364#define DIGI_RTS_TOGGLE 3
365
366#define DIGI_FLUSH_TX 1
367#define DIGI_FLUSH_RX 2
368#define DIGI_RESUME_TX 4 /* clears xoff condition */
369
370#define DIGI_TRANSMIT_NOT_IDLE 0
371#define DIGI_TRANSMIT_IDLE 1
372
373#define DIGI_DISABLE 0
374#define DIGI_ENABLE 1
375
376#define DIGI_DEASSERT 0
377#define DIGI_ASSERT 1
378
379/* in band status codes */
380#define DIGI_OVERRUN_ERROR 4
381#define DIGI_PARITY_ERROR 8
382#define DIGI_FRAMING_ERROR 16
383#define DIGI_BREAK_ERROR 32
384
385/* out of band status */
386#define DIGI_NO_ERROR 0
387#define DIGI_BAD_FIRST_PARAMETER 1
388#define DIGI_BAD_SECOND_PARAMETER 2
389#define DIGI_INVALID_LINE 3
390#define DIGI_INVALID_OPCODE 4
391
392/* input signals */
393#define DIGI_READ_INPUT_SIGNALS_SLOT 1
394#define DIGI_READ_INPUT_SIGNALS_ERR 2
395#define DIGI_READ_INPUT_SIGNALS_BUSY 4
396#define DIGI_READ_INPUT_SIGNALS_PE 8
397#define DIGI_READ_INPUT_SIGNALS_CTS 16
398#define DIGI_READ_INPUT_SIGNALS_DSR 32
399#define DIGI_READ_INPUT_SIGNALS_RI 64
400#define DIGI_READ_INPUT_SIGNALS_DCD 128
401
402
403/* Structures */
404
405struct digi_serial {
406 spinlock_t ds_serial_lock;
407 struct usb_serial_port *ds_oob_port; /* out-of-band port */
408 int ds_oob_port_num; /* index of out-of-band port */
409 int ds_device_started;
410};
411
412struct digi_port {
413 spinlock_t dp_port_lock;
414 int dp_port_num;
415 int dp_out_buf_len;
416 unsigned char dp_out_buf[DIGI_OUT_BUF_SIZE];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 int dp_write_urb_in_use;
418 unsigned int dp_modem_signals;
419 wait_queue_head_t dp_modem_change_wait;
420 int dp_transmit_idle;
421 wait_queue_head_t dp_transmit_idle_wait;
422 int dp_throttled;
423 int dp_throttle_restart;
424 wait_queue_head_t dp_flush_wait;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 wait_queue_head_t dp_close_wait; /* wait queue for close */
426 struct work_struct dp_wakeup_work;
David Howellsc4028952006-11-22 14:57:56 +0000427 struct usb_serial_port *dp_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428};
429
430
431/* Local Function Declarations */
432
Alan Coxc6d61262007-07-26 18:57:52 +0100433static void digi_wakeup_write(struct usb_serial_port *port);
David Howellsc4028952006-11-22 14:57:56 +0000434static void digi_wakeup_write_lock(struct work_struct *work);
Alan Coxc6d61262007-07-26 18:57:52 +0100435static int digi_write_oob_command(struct usb_serial_port *port,
436 unsigned char *buf, int count, int interruptible);
437static int digi_write_inb_command(struct usb_serial_port *port,
438 unsigned char *buf, int count, unsigned long timeout);
439static int digi_set_modem_signals(struct usb_serial_port *port,
440 unsigned int modem_signals, int interruptible);
441static int digi_transmit_idle(struct usb_serial_port *port,
442 unsigned long timeout);
Alan Cox41ad4272008-07-22 11:11:02 +0100443static void digi_rx_throttle(struct tty_struct *tty);
444static void digi_rx_unthrottle(struct tty_struct *tty);
Alan Cox95da3102008-07-22 11:09:07 +0100445static void digi_set_termios(struct tty_struct *tty,
446 struct usb_serial_port *port, struct ktermios *old_termios);
447static void digi_break_ctl(struct tty_struct *tty, int break_state);
448static int digi_tiocmget(struct tty_struct *tty, struct file *file);
449static int digi_tiocmset(struct tty_struct *tty, struct file *file,
Alan Coxc6d61262007-07-26 18:57:52 +0100450 unsigned int set, unsigned int clear);
Alan Cox95da3102008-07-22 11:09:07 +0100451static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
452 const unsigned char *buf, int count);
Alan Coxc6d61262007-07-26 18:57:52 +0100453static void digi_write_bulk_callback(struct urb *urb);
Alan Cox95da3102008-07-22 11:09:07 +0100454static int digi_write_room(struct tty_struct *tty);
455static int digi_chars_in_buffer(struct tty_struct *tty);
Alan Coxa509a7e2009-09-19 13:13:26 -0700456static int digi_open(struct tty_struct *tty, struct usb_serial_port *port);
Alan Cox335f8512009-06-11 12:26:29 +0100457static void digi_close(struct usb_serial_port *port);
458static int digi_carrier_raised(struct usb_serial_port *port);
459static void digi_dtr_rts(struct usb_serial_port *port, int on);
Alan Coxc6d61262007-07-26 18:57:52 +0100460static int digi_startup_device(struct usb_serial *serial);
461static int digi_startup(struct usb_serial *serial);
Alan Sternf9c99bb2009-06-02 11:53:55 -0400462static void digi_disconnect(struct usb_serial *serial);
463static void digi_release(struct usb_serial *serial);
Alan Coxc6d61262007-07-26 18:57:52 +0100464static void digi_read_bulk_callback(struct urb *urb);
465static int digi_read_inb_callback(struct urb *urb);
466static int digi_read_oob_callback(struct urb *urb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
468
469/* Statics */
470
471static int debug;
472
473static struct usb_device_id id_table_combined [] = {
474 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
475 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
476 { } /* Terminating entry */
477};
478
479static struct usb_device_id id_table_2 [] = {
480 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
481 { } /* Terminating entry */
482};
483
484static struct usb_device_id id_table_4 [] = {
485 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
486 { } /* Terminating entry */
487};
488
Alan Cox41ad4272008-07-22 11:11:02 +0100489MODULE_DEVICE_TABLE(usb, id_table_combined);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490
491static struct usb_driver digi_driver = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492 .name = "digi_acceleport",
493 .probe = usb_serial_probe,
494 .disconnect = usb_serial_disconnect,
495 .id_table = id_table_combined,
Greg Kroah-Hartmanba9dc652005-11-16 13:41:28 -0800496 .no_dynamic_id = 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497};
498
499
500/* device info needed for the Digi serial converter */
501
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700502static struct usb_serial_driver digi_acceleport_2_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700503 .driver = {
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700504 .owner = THIS_MODULE,
505 .name = "digi_2",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700506 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700507 .description = "Digi 2 port USB adapter",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100508 .usb_driver = &digi_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 .id_table = id_table_2,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510 .num_ports = 3,
511 .open = digi_open,
512 .close = digi_close,
Alan Cox335f8512009-06-11 12:26:29 +0100513 .dtr_rts = digi_dtr_rts,
514 .carrier_raised = digi_carrier_raised,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 .write = digi_write,
516 .write_room = digi_write_room,
517 .write_bulk_callback = digi_write_bulk_callback,
518 .read_bulk_callback = digi_read_bulk_callback,
519 .chars_in_buffer = digi_chars_in_buffer,
520 .throttle = digi_rx_throttle,
521 .unthrottle = digi_rx_unthrottle,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 .set_termios = digi_set_termios,
523 .break_ctl = digi_break_ctl,
524 .tiocmget = digi_tiocmget,
525 .tiocmset = digi_tiocmset,
526 .attach = digi_startup,
Alan Sternf9c99bb2009-06-02 11:53:55 -0400527 .disconnect = digi_disconnect,
528 .release = digi_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529};
530
Greg Kroah-Hartmanea653702005-06-20 21:15:16 -0700531static struct usb_serial_driver digi_acceleport_4_device = {
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700532 .driver = {
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700533 .owner = THIS_MODULE,
534 .name = "digi_4",
Greg Kroah-Hartman18fcac32005-06-20 21:15:16 -0700535 },
Greg Kroah-Hartman269bda12005-06-20 21:15:16 -0700536 .description = "Digi 4 port USB adapter",
Johannes Hölzld9b1b782006-12-17 21:50:24 +0100537 .usb_driver = &digi_driver,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538 .id_table = id_table_4,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 .num_ports = 4,
540 .open = digi_open,
541 .close = digi_close,
542 .write = digi_write,
543 .write_room = digi_write_room,
544 .write_bulk_callback = digi_write_bulk_callback,
545 .read_bulk_callback = digi_read_bulk_callback,
546 .chars_in_buffer = digi_chars_in_buffer,
547 .throttle = digi_rx_throttle,
548 .unthrottle = digi_rx_unthrottle,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 .set_termios = digi_set_termios,
550 .break_ctl = digi_break_ctl,
551 .tiocmget = digi_tiocmget,
552 .tiocmset = digi_tiocmset,
553 .attach = digi_startup,
Alan Sternf9c99bb2009-06-02 11:53:55 -0400554 .disconnect = digi_disconnect,
555 .release = digi_release,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556};
557
558
559/* Functions */
560
561/*
Alan Cox41ad4272008-07-22 11:11:02 +0100562 * Cond Wait Interruptible Timeout Irqrestore
563 *
564 * Do spin_unlock_irqrestore and interruptible_sleep_on_timeout
565 * so that wake ups are not lost if they occur between the unlock
566 * and the sleep. In other words, spin_unlock_irqrestore and
567 * interruptible_sleep_on_timeout are "atomic" with respect to
568 * wake ups. This is used to implement condition variables.
569 *
570 * interruptible_sleep_on_timeout is deprecated and has been replaced
571 * with the equivalent code.
572 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Alan Coxc6d61262007-07-26 18:57:52 +0100574static long cond_wait_interruptible_timeout_irqrestore(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 wait_queue_head_t *q, long timeout,
Alan Coxc6d61262007-07-26 18:57:52 +0100576 spinlock_t *lock, unsigned long flags)
Harvey Harrison5a339562008-05-30 10:18:53 -0700577__releases(lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578{
579 DEFINE_WAIT(wait);
580
Nishanth Aravamudan45f23f12005-04-18 17:39:25 -0700581 prepare_to_wait(q, &wait, TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 spin_unlock_irqrestore(lock, flags);
583 timeout = schedule_timeout(timeout);
584 finish_wait(q, &wait);
585
586 return timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587}
588
589
590/*
Alan Cox41ad4272008-07-22 11:11:02 +0100591 * Digi Wakeup Write
592 *
593 * Wake up port, line discipline, and tty processes sleeping
594 * on writes.
595 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
David Howellsc4028952006-11-22 14:57:56 +0000597static void digi_wakeup_write_lock(struct work_struct *work)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
Alan Cox41ad4272008-07-22 11:11:02 +0100599 struct digi_port *priv =
600 container_of(work, struct digi_port, dp_wakeup_work);
David Howellsc4028952006-11-22 14:57:56 +0000601 struct usb_serial_port *port = priv->dp_port;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603
Alan Coxc6d61262007-07-26 18:57:52 +0100604 spin_lock_irqsave(&priv->dp_port_lock, flags);
605 digi_wakeup_write(port);
606 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607}
608
Alan Coxc6d61262007-07-26 18:57:52 +0100609static void digi_wakeup_write(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610{
Alan Cox4a90f092008-10-13 10:39:46 +0100611 struct tty_struct *tty = tty_port_tty_get(&port->port);
612 tty_wakeup(tty);
613 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614}
615
616
617/*
Alan Cox41ad4272008-07-22 11:11:02 +0100618 * Digi Write OOB Command
619 *
620 * Write commands on the out of band port. Commands are 4
621 * bytes each, multiple commands can be sent at once, and
622 * no command will be split across USB packets. Returns 0
623 * if successful, -EINTR if interrupted while sleeping and
624 * the interruptible flag is true, or a negative error
625 * returned by usb_submit_urb.
626 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627
Alan Coxc6d61262007-07-26 18:57:52 +0100628static int digi_write_oob_command(struct usb_serial_port *port,
629 unsigned char *buf, int count, int interruptible)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630{
631
632 int ret = 0;
633 int len;
634 struct usb_serial_port *oob_port = (struct usb_serial_port *)((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port;
635 struct digi_port *oob_priv = usb_get_serial_port_data(oob_port);
636 unsigned long flags = 0;
637
Alan Coxc6d61262007-07-26 18:57:52 +0100638 dbg("digi_write_oob_command: TOP: port=%d, count=%d", oob_priv->dp_port_num, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639
Alan Coxc6d61262007-07-26 18:57:52 +0100640 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
Alan Cox41ad4272008-07-22 11:11:02 +0100641 while (count > 0) {
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800642 while (oob_priv->dp_write_urb_in_use) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 cond_wait_interruptible_timeout_irqrestore(
644 &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
Alan Coxc6d61262007-07-26 18:57:52 +0100645 &oob_priv->dp_port_lock, flags);
646 if (interruptible && signal_pending(current))
647 return -EINTR;
648 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 }
650
651 /* len must be a multiple of 4, so commands are not split */
Alan Coxc6d61262007-07-26 18:57:52 +0100652 len = min(count, oob_port->bulk_out_size);
653 if (len > 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 len &= ~3;
Alan Coxc6d61262007-07-26 18:57:52 +0100655 memcpy(oob_port->write_urb->transfer_buffer, buf, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 oob_port->write_urb->transfer_buffer_length = len;
657 oob_port->write_urb->dev = port->serial->dev;
Alan Cox41ad4272008-07-22 11:11:02 +0100658 ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC);
659 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 oob_priv->dp_write_urb_in_use = 1;
661 count -= len;
662 buf += len;
663 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 }
Alan Coxc6d61262007-07-26 18:57:52 +0100665 spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
666 if (ret)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700667 dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n",
668 __func__, ret);
Alan Coxc6d61262007-07-26 18:57:52 +0100669 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700670
671}
672
673
674/*
Alan Cox41ad4272008-07-22 11:11:02 +0100675 * Digi Write In Band Command
676 *
677 * Write commands on the given port. Commands are 4
678 * bytes each, multiple commands can be sent at once, and
679 * no command will be split across USB packets. If timeout
680 * is non-zero, write in band command will return after
681 * waiting unsuccessfully for the URB status to clear for
682 * timeout ticks. Returns 0 if successful, or a negative
683 * error returned by digi_write.
684 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685
Alan Coxc6d61262007-07-26 18:57:52 +0100686static int digi_write_inb_command(struct usb_serial_port *port,
687 unsigned char *buf, int count, unsigned long timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 int ret = 0;
690 int len;
691 struct digi_port *priv = usb_get_serial_port_data(port);
692 unsigned char *data = port->write_urb->transfer_buffer;
693 unsigned long flags = 0;
694
Alan Coxc6d61262007-07-26 18:57:52 +0100695 dbg("digi_write_inb_command: TOP: port=%d, count=%d",
696 priv->dp_port_num, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Alan Coxc6d61262007-07-26 18:57:52 +0100698 if (timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 timeout += jiffies;
700 else
701 timeout = ULONG_MAX;
702
Alan Coxc6d61262007-07-26 18:57:52 +0100703 spin_lock_irqsave(&priv->dp_port_lock, flags);
Alan Cox41ad4272008-07-22 11:11:02 +0100704 while (count > 0 && ret == 0) {
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800705 while (priv->dp_write_urb_in_use &&
706 time_before(jiffies, timeout)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 cond_wait_interruptible_timeout_irqrestore(
708 &port->write_wait, DIGI_RETRY_TIMEOUT,
Alan Coxc6d61262007-07-26 18:57:52 +0100709 &priv->dp_port_lock, flags);
710 if (signal_pending(current))
711 return -EINTR;
712 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713 }
714
715 /* len must be a multiple of 4 and small enough to */
716 /* guarantee the write will send buffered data first, */
717 /* so commands are in order with data and not split */
Alan Coxc6d61262007-07-26 18:57:52 +0100718 len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len);
719 if (len > 4)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 len &= ~3;
721
722 /* write any buffered data first */
Alan Coxc6d61262007-07-26 18:57:52 +0100723 if (priv->dp_out_buf_len > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 data[0] = DIGI_CMD_SEND_DATA;
725 data[1] = priv->dp_out_buf_len;
Alan Coxc6d61262007-07-26 18:57:52 +0100726 memcpy(data + 2, priv->dp_out_buf,
727 priv->dp_out_buf_len);
728 memcpy(data + 2 + priv->dp_out_buf_len, buf, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 port->write_urb->transfer_buffer_length
Alan Coxc6d61262007-07-26 18:57:52 +0100730 = priv->dp_out_buf_len + 2 + len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 } else {
Alan Coxc6d61262007-07-26 18:57:52 +0100732 memcpy(data, buf, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 port->write_urb->transfer_buffer_length = len;
734 }
735 port->write_urb->dev = port->serial->dev;
736
Alan Cox41ad4272008-07-22 11:11:02 +0100737 ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
738 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 priv->dp_write_urb_in_use = 1;
740 priv->dp_out_buf_len = 0;
741 count -= len;
742 buf += len;
743 }
744
745 }
Alan Coxc6d61262007-07-26 18:57:52 +0100746 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700747
Alan Coxc6d61262007-07-26 18:57:52 +0100748 if (ret)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700749 dev_err(&port->dev,
750 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800751 __func__, ret, priv->dp_port_num);
Alan Coxc6d61262007-07-26 18:57:52 +0100752 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753}
754
755
756/*
Alan Cox41ad4272008-07-22 11:11:02 +0100757 * Digi Set Modem Signals
758 *
759 * Sets or clears DTR and RTS on the port, according to the
760 * modem_signals argument. Use TIOCM_DTR and TIOCM_RTS flags
761 * for the modem_signals argument. Returns 0 if successful,
762 * -EINTR if interrupted while sleeping, or a non-zero error
763 * returned by usb_submit_urb.
764 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765
Alan Coxc6d61262007-07-26 18:57:52 +0100766static int digi_set_modem_signals(struct usb_serial_port *port,
767 unsigned int modem_signals, int interruptible)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768{
769
770 int ret;
771 struct digi_port *port_priv = usb_get_serial_port_data(port);
Alan Cox41ad4272008-07-22 11:11:02 +0100772 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 -0700773 struct digi_port *oob_priv = usb_get_serial_port_data(oob_port);
774 unsigned char *data = oob_port->write_urb->transfer_buffer;
775 unsigned long flags = 0;
776
777
Alan Coxc6d61262007-07-26 18:57:52 +0100778 dbg("digi_set_modem_signals: TOP: port=%d, modem_signals=0x%x",
779 port_priv->dp_port_num, modem_signals);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Alan Coxc6d61262007-07-26 18:57:52 +0100781 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
782 spin_lock(&port_priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -0800784 while (oob_priv->dp_write_urb_in_use) {
Alan Coxc6d61262007-07-26 18:57:52 +0100785 spin_unlock(&port_priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 cond_wait_interruptible_timeout_irqrestore(
787 &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
Alan Coxc6d61262007-07-26 18:57:52 +0100788 &oob_priv->dp_port_lock, flags);
789 if (interruptible && signal_pending(current))
790 return -EINTR;
791 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
792 spin_lock(&port_priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 data[0] = DIGI_CMD_SET_DTR_SIGNAL;
795 data[1] = port_priv->dp_port_num;
Alan Cox41ad4272008-07-22 11:11:02 +0100796 data[2] = (modem_signals & TIOCM_DTR) ?
797 DIGI_DTR_ACTIVE : DIGI_DTR_INACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 data[3] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 data[4] = DIGI_CMD_SET_RTS_SIGNAL;
800 data[5] = port_priv->dp_port_num;
Alan Cox41ad4272008-07-22 11:11:02 +0100801 data[6] = (modem_signals & TIOCM_RTS) ?
802 DIGI_RTS_ACTIVE : DIGI_RTS_INACTIVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 data[7] = 0;
804
805 oob_port->write_urb->transfer_buffer_length = 8;
806 oob_port->write_urb->dev = port->serial->dev;
807
Alan Cox41ad4272008-07-22 11:11:02 +0100808 ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC);
809 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 oob_priv->dp_write_urb_in_use = 1;
811 port_priv->dp_modem_signals =
812 (port_priv->dp_modem_signals&~(TIOCM_DTR|TIOCM_RTS))
813 | (modem_signals&(TIOCM_DTR|TIOCM_RTS));
814 }
Alan Coxc6d61262007-07-26 18:57:52 +0100815 spin_unlock(&port_priv->dp_port_lock);
816 spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
817 if (ret)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700818 dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n",
819 __func__, ret);
Alan Coxc6d61262007-07-26 18:57:52 +0100820 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821}
822
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823/*
Alan Cox41ad4272008-07-22 11:11:02 +0100824 * Digi Transmit Idle
825 *
826 * Digi transmit idle waits, up to timeout ticks, for the transmitter
827 * to go idle. It returns 0 if successful or a negative error.
828 *
829 * There are race conditions here if more than one process is calling
830 * digi_transmit_idle on the same port at the same time. However, this
831 * is only called from close, and only one process can be in close on a
832 * port at a time, so its ok.
833 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
Alan Coxc6d61262007-07-26 18:57:52 +0100835static int digi_transmit_idle(struct usb_serial_port *port,
836 unsigned long timeout)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 int ret;
839 unsigned char buf[2];
840 struct digi_port *priv = usb_get_serial_port_data(port);
841 unsigned long flags = 0;
842
Alan Coxc6d61262007-07-26 18:57:52 +0100843 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 priv->dp_transmit_idle = 0;
Alan Coxc6d61262007-07-26 18:57:52 +0100845 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846
847 buf[0] = DIGI_CMD_TRANSMIT_IDLE;
848 buf[1] = 0;
849
850 timeout += jiffies;
851
Alan Cox41ad4272008-07-22 11:11:02 +0100852 ret = digi_write_inb_command(port, buf, 2, timeout - jiffies);
853 if (ret != 0)
Alan Coxc6d61262007-07-26 18:57:52 +0100854 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855
Alan Coxc6d61262007-07-26 18:57:52 +0100856 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700857
Alan Cox41ad4272008-07-22 11:11:02 +0100858 while (time_before(jiffies, timeout) && !priv->dp_transmit_idle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 cond_wait_interruptible_timeout_irqrestore(
860 &priv->dp_transmit_idle_wait, DIGI_RETRY_TIMEOUT,
Alan Coxc6d61262007-07-26 18:57:52 +0100861 &priv->dp_port_lock, flags);
862 if (signal_pending(current))
863 return -EINTR;
864 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 priv->dp_transmit_idle = 0;
Alan Coxc6d61262007-07-26 18:57:52 +0100867 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
868 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869
870}
871
872
Alan Cox95da3102008-07-22 11:09:07 +0100873static void digi_rx_throttle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 unsigned long flags;
Alan Cox95da3102008-07-22 11:09:07 +0100876 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 struct digi_port *priv = usb_get_serial_port_data(port);
878
879
Alan Coxc6d61262007-07-26 18:57:52 +0100880 dbg("digi_rx_throttle: TOP: port=%d", priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881
882 /* stop receiving characters by not resubmitting the read urb */
Alan Coxc6d61262007-07-26 18:57:52 +0100883 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 priv->dp_throttled = 1;
885 priv->dp_throttle_restart = 0;
Alan Coxc6d61262007-07-26 18:57:52 +0100886 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887}
888
889
Alan Cox95da3102008-07-22 11:09:07 +0100890static void digi_rx_unthrottle(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 unsigned long flags;
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896
Alan Coxc6d61262007-07-26 18:57:52 +0100897 dbg("digi_rx_unthrottle: TOP: port=%d", priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
Alan Coxc6d61262007-07-26 18:57:52 +0100899 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900
Linus Torvalds1da177e2005-04-16 15:20:36 -0700901 /* restart read chain */
Alan Coxc6d61262007-07-26 18:57:52 +0100902 if (priv->dp_throttle_restart) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903 port->read_urb->dev = port->serial->dev;
Alan Coxc6d61262007-07-26 18:57:52 +0100904 ret = usb_submit_urb(port->read_urb, GFP_ATOMIC);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905 }
906
Johan Hovoldba6b7022009-09-29 12:39:23 +0200907 /* turn throttle off */
908 priv->dp_throttled = 0;
909 priv->dp_throttle_restart = 0;
910
Alan Coxc6d61262007-07-26 18:57:52 +0100911 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912
Alan Coxc6d61262007-07-26 18:57:52 +0100913 if (ret)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -0700914 dev_err(&port->dev,
915 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -0800916 __func__, ret, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917}
918
919
Alan Cox41ad4272008-07-22 11:11:02 +0100920static void digi_set_termios(struct tty_struct *tty,
Alan Cox95da3102008-07-22 11:09:07 +0100921 struct usb_serial_port *port, struct ktermios *old_termios)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 struct digi_port *priv = usb_get_serial_port_data(port);
Alan Coxc6d61262007-07-26 18:57:52 +0100924 unsigned int iflag = tty->termios->c_iflag;
925 unsigned int cflag = tty->termios->c_cflag;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926 unsigned int old_iflag = old_termios->c_iflag;
927 unsigned int old_cflag = old_termios->c_cflag;
928 unsigned char buf[32];
929 unsigned int modem_signals;
Alan Cox41ad4272008-07-22 11:11:02 +0100930 int arg, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 int i = 0;
Alan Coxc6d61262007-07-26 18:57:52 +0100932 speed_t baud;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933
Alan Coxc6d61262007-07-26 18:57:52 +0100934 dbg("digi_set_termios: TOP: port=%d, iflag=0x%x, old_iflag=0x%x, cflag=0x%x, old_cflag=0x%x", priv->dp_port_num, iflag, old_iflag, cflag, old_cflag);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936 /* set baud rate */
Alan Cox41ad4272008-07-22 11:11:02 +0100937 baud = tty_get_baud_rate(tty);
938 if (baud != tty_termios_baud_rate(old_termios)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 arg = -1;
940
941 /* reassert DTR and (maybe) RTS on transition from B0 */
Alan Coxc6d61262007-07-26 18:57:52 +0100942 if ((old_cflag&CBAUD) == B0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 /* don't set RTS if using hardware flow control */
944 /* and throttling input */
945 modem_signals = TIOCM_DTR;
Alan Coxc6d61262007-07-26 18:57:52 +0100946 if (!(tty->termios->c_cflag & CRTSCTS) ||
947 !test_bit(TTY_THROTTLED, &tty->flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 modem_signals |= TIOCM_RTS;
Alan Coxc6d61262007-07-26 18:57:52 +0100949 digi_set_modem_signals(port, modem_signals, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 }
Alan Coxc6d61262007-07-26 18:57:52 +0100951 switch (baud) {
Alan Cox41ad4272008-07-22 11:11:02 +0100952 /* drop DTR and RTS on transition to B0 */
953 case 0: digi_set_modem_signals(port, 0, 1); break;
954 case 50: arg = DIGI_BAUD_50; break;
955 case 75: arg = DIGI_BAUD_75; break;
956 case 110: arg = DIGI_BAUD_110; break;
957 case 150: arg = DIGI_BAUD_150; break;
958 case 200: arg = DIGI_BAUD_200; break;
959 case 300: arg = DIGI_BAUD_300; break;
960 case 600: arg = DIGI_BAUD_600; break;
961 case 1200: arg = DIGI_BAUD_1200; break;
962 case 1800: arg = DIGI_BAUD_1800; break;
963 case 2400: arg = DIGI_BAUD_2400; break;
964 case 4800: arg = DIGI_BAUD_4800; break;
965 case 9600: arg = DIGI_BAUD_9600; break;
966 case 19200: arg = DIGI_BAUD_19200; break;
967 case 38400: arg = DIGI_BAUD_38400; break;
968 case 57600: arg = DIGI_BAUD_57600; break;
969 case 115200: arg = DIGI_BAUD_115200; break;
970 case 230400: arg = DIGI_BAUD_230400; break;
971 case 460800: arg = DIGI_BAUD_460800; break;
972 default:
973 arg = DIGI_BAUD_9600;
974 baud = 9600;
975 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 }
Alan Coxc6d61262007-07-26 18:57:52 +0100977 if (arg != -1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 buf[i++] = DIGI_CMD_SET_BAUD_RATE;
979 buf[i++] = priv->dp_port_num;
980 buf[i++] = arg;
981 buf[i++] = 0;
982 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 /* set parity */
Alan Cox7fa36a92007-10-18 01:24:19 -0700985 tty->termios->c_cflag &= ~CMSPAR;
986
Alan Coxc6d61262007-07-26 18:57:52 +0100987 if ((cflag&(PARENB|PARODD)) != (old_cflag&(PARENB|PARODD))) {
988 if (cflag&PARENB) {
989 if (cflag&PARODD)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 arg = DIGI_PARITY_ODD;
991 else
992 arg = DIGI_PARITY_EVEN;
993 } else {
994 arg = DIGI_PARITY_NONE;
995 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 buf[i++] = DIGI_CMD_SET_PARITY;
997 buf[i++] = priv->dp_port_num;
998 buf[i++] = arg;
999 buf[i++] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 /* set word size */
Alan Coxc6d61262007-07-26 18:57:52 +01001002 if ((cflag&CSIZE) != (old_cflag&CSIZE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 arg = -1;
Alan Coxc6d61262007-07-26 18:57:52 +01001004 switch (cflag&CSIZE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 case CS5: arg = DIGI_WORD_SIZE_5; break;
1006 case CS6: arg = DIGI_WORD_SIZE_6; break;
1007 case CS7: arg = DIGI_WORD_SIZE_7; break;
1008 case CS8: arg = DIGI_WORD_SIZE_8; break;
1009 default:
Alan Coxc6d61262007-07-26 18:57:52 +01001010 dbg("digi_set_termios: can't handle word size %d",
1011 (cflag&CSIZE));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 break;
1013 }
1014
Alan Coxc6d61262007-07-26 18:57:52 +01001015 if (arg != -1) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016 buf[i++] = DIGI_CMD_SET_WORD_SIZE;
1017 buf[i++] = priv->dp_port_num;
1018 buf[i++] = arg;
1019 buf[i++] = 0;
1020 }
1021
1022 }
1023
1024 /* set stop bits */
Alan Coxc6d61262007-07-26 18:57:52 +01001025 if ((cflag&CSTOPB) != (old_cflag&CSTOPB)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
Alan Coxc6d61262007-07-26 18:57:52 +01001027 if ((cflag&CSTOPB))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 arg = DIGI_STOP_BITS_2;
1029 else
1030 arg = DIGI_STOP_BITS_1;
1031
1032 buf[i++] = DIGI_CMD_SET_STOP_BITS;
1033 buf[i++] = priv->dp_port_num;
1034 buf[i++] = arg;
1035 buf[i++] = 0;
1036
1037 }
1038
1039 /* set input flow control */
Alan Coxc6d61262007-07-26 18:57:52 +01001040 if ((iflag&IXOFF) != (old_iflag&IXOFF)
1041 || (cflag&CRTSCTS) != (old_cflag&CRTSCTS)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 arg = 0;
Alan Coxc6d61262007-07-26 18:57:52 +01001043 if (iflag&IXOFF)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 arg |= DIGI_INPUT_FLOW_CONTROL_XON_XOFF;
1045 else
1046 arg &= ~DIGI_INPUT_FLOW_CONTROL_XON_XOFF;
1047
Alan Coxc6d61262007-07-26 18:57:52 +01001048 if (cflag&CRTSCTS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049 arg |= DIGI_INPUT_FLOW_CONTROL_RTS;
1050
1051 /* On USB-4 it is necessary to assert RTS prior */
1052 /* to selecting RTS input flow control. */
1053 buf[i++] = DIGI_CMD_SET_RTS_SIGNAL;
1054 buf[i++] = priv->dp_port_num;
1055 buf[i++] = DIGI_RTS_ACTIVE;
1056 buf[i++] = 0;
1057
1058 } else {
1059 arg &= ~DIGI_INPUT_FLOW_CONTROL_RTS;
1060 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001061 buf[i++] = DIGI_CMD_SET_INPUT_FLOW_CONTROL;
1062 buf[i++] = priv->dp_port_num;
1063 buf[i++] = arg;
1064 buf[i++] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 }
1066
1067 /* set output flow control */
Alan Cox7fa36a92007-10-18 01:24:19 -07001068 if ((iflag & IXON) != (old_iflag & IXON)
1069 || (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070 arg = 0;
Alan Cox7fa36a92007-10-18 01:24:19 -07001071 if (iflag & IXON)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 arg |= DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF;
1073 else
1074 arg &= ~DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF;
1075
Alan Cox7fa36a92007-10-18 01:24:19 -07001076 if (cflag & CRTSCTS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 arg |= DIGI_OUTPUT_FLOW_CONTROL_CTS;
1078 } else {
1079 arg &= ~DIGI_OUTPUT_FLOW_CONTROL_CTS;
Alan Coxc6d61262007-07-26 18:57:52 +01001080 tty->hw_stopped = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 }
1082
1083 buf[i++] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL;
1084 buf[i++] = priv->dp_port_num;
1085 buf[i++] = arg;
1086 buf[i++] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 }
1088
1089 /* set receive enable/disable */
Alan Cox7fa36a92007-10-18 01:24:19 -07001090 if ((cflag & CREAD) != (old_cflag & CREAD)) {
1091 if (cflag & CREAD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 arg = DIGI_ENABLE;
1093 else
1094 arg = DIGI_DISABLE;
1095
1096 buf[i++] = DIGI_CMD_RECEIVE_ENABLE;
1097 buf[i++] = priv->dp_port_num;
1098 buf[i++] = arg;
1099 buf[i++] = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 }
Alan Cox41ad4272008-07-22 11:11:02 +01001101 ret = digi_write_oob_command(port, buf, i, 1);
1102 if (ret != 0)
Alan Coxc6d61262007-07-26 18:57:52 +01001103 dbg("digi_set_termios: write oob failed, ret=%d", ret);
Alan Cox7fa36a92007-10-18 01:24:19 -07001104 tty_encode_baud_rate(tty, baud, baud);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105}
1106
1107
Alan Cox95da3102008-07-22 11:09:07 +01001108static void digi_break_ctl(struct tty_struct *tty, int break_state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109{
Alan Cox95da3102008-07-22 11:09:07 +01001110 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001111 unsigned char buf[4];
1112
Linus Torvalds1da177e2005-04-16 15:20:36 -07001113 buf[0] = DIGI_CMD_BREAK_CONTROL;
1114 buf[1] = 2; /* length */
1115 buf[2] = break_state ? 1 : 0;
1116 buf[3] = 0; /* pad */
Alan Coxc6d61262007-07-26 18:57:52 +01001117 digi_write_inb_command(port, buf, 4, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118}
1119
1120
Alan Cox95da3102008-07-22 11:09:07 +01001121static int digi_tiocmget(struct tty_struct *tty, struct file *file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122{
Alan Cox95da3102008-07-22 11:09:07 +01001123 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 struct digi_port *priv = usb_get_serial_port_data(port);
1125 unsigned int val;
1126 unsigned long flags;
1127
Harvey Harrison441b62c2008-03-03 16:08:34 -08001128 dbg("%s: TOP: port=%d", __func__, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
Alan Coxc6d61262007-07-26 18:57:52 +01001130 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 val = priv->dp_modem_signals;
Alan Coxc6d61262007-07-26 18:57:52 +01001132 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 return val;
1134}
1135
1136
Alan Cox95da3102008-07-22 11:09:07 +01001137static int digi_tiocmset(struct tty_struct *tty, struct file *file,
Alan Coxc6d61262007-07-26 18:57:52 +01001138 unsigned int set, unsigned int clear)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139{
Alan Cox95da3102008-07-22 11:09:07 +01001140 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001141 struct digi_port *priv = usb_get_serial_port_data(port);
1142 unsigned int val;
1143 unsigned long flags;
1144
Harvey Harrison441b62c2008-03-03 16:08:34 -08001145 dbg("%s: TOP: port=%d", __func__, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001146
Alan Coxc6d61262007-07-26 18:57:52 +01001147 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148 val = (priv->dp_modem_signals & ~clear) | set;
Alan Coxc6d61262007-07-26 18:57:52 +01001149 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1150 return digi_set_modem_signals(port, val, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151}
1152
1153
Alan Cox95da3102008-07-22 11:09:07 +01001154static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
1155 const unsigned char *buf, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156{
1157
Alan Cox41ad4272008-07-22 11:11:02 +01001158 int ret, data_len, new_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 struct digi_port *priv = usb_get_serial_port_data(port);
1160 unsigned char *data = port->write_urb->transfer_buffer;
1161 unsigned long flags = 0;
1162
Alan Coxc6d61262007-07-26 18:57:52 +01001163 dbg("digi_write: TOP: port=%d, count=%d, in_interrupt=%ld",
1164 priv->dp_port_num, count, in_interrupt());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165
1166 /* copy user data (which can sleep) before getting spin lock */
Alan Coxc6d61262007-07-26 18:57:52 +01001167 count = min(count, port->bulk_out_size-2);
1168 count = min(64, count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169
1170 /* be sure only one write proceeds at a time */
1171 /* there are races on the port private buffer */
Alan Coxc6d61262007-07-26 18:57:52 +01001172 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173
1174 /* wait for urb status clear to submit another urb */
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001175 if (priv->dp_write_urb_in_use) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176 /* buffer data if count is 1 (probably put_char) if possible */
Alan Coxc6d61262007-07-26 18:57:52 +01001177 if (count == 1 && priv->dp_out_buf_len < DIGI_OUT_BUF_SIZE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178 priv->dp_out_buf[priv->dp_out_buf_len++] = *buf;
1179 new_len = 1;
1180 } else {
1181 new_len = 0;
1182 }
Alan Coxc6d61262007-07-26 18:57:52 +01001183 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1184 return new_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 }
1186
1187 /* allow space for any buffered data and for new data, up to */
1188 /* transfer buffer size - 2 (for command and length bytes) */
1189 new_len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len);
1190 data_len = new_len + priv->dp_out_buf_len;
1191
Alan Coxc6d61262007-07-26 18:57:52 +01001192 if (data_len == 0) {
1193 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1194 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 }
1196
1197 port->write_urb->transfer_buffer_length = data_len+2;
1198 port->write_urb->dev = port->serial->dev;
1199
1200 *data++ = DIGI_CMD_SEND_DATA;
1201 *data++ = data_len;
1202
1203 /* copy in buffered data first */
Alan Coxc6d61262007-07-26 18:57:52 +01001204 memcpy(data, priv->dp_out_buf, priv->dp_out_buf_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 data += priv->dp_out_buf_len;
1206
1207 /* copy in new data */
Alan Coxc6d61262007-07-26 18:57:52 +01001208 memcpy(data, buf, new_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209
Alan Cox41ad4272008-07-22 11:11:02 +01001210 ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1211 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 priv->dp_write_urb_in_use = 1;
1213 ret = new_len;
1214 priv->dp_out_buf_len = 0;
1215 }
1216
1217 /* return length of new data written, or error */
Alan Coxc6d61262007-07-26 18:57:52 +01001218 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
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",
Harvey Harrison441b62c2008-03-03 16:08:34 -08001222 __func__, ret, priv->dp_port_num);
Alan Coxc6d61262007-07-26 18:57:52 +01001223 dbg("digi_write: returning %d", ret);
1224 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225
Alan Cox41ad4272008-07-22 11:11:02 +01001226}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227
Alan Coxc6d61262007-07-26 18:57:52 +01001228static void digi_write_bulk_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229{
1230
Ming Leicdc97792008-02-24 18:41:47 +08001231 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232 struct usb_serial *serial;
1233 struct digi_port *priv;
1234 struct digi_serial *serial_priv;
1235 int ret = 0;
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001236 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001238 dbg("digi_write_bulk_callback: TOP, status=%d", status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001239
1240 /* port and serial sanity check */
Alan Cox41ad4272008-07-22 11:11:02 +01001241 if (port == NULL || (priv = usb_get_serial_port_data(port)) == NULL) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001242 dev_err(&port->dev,
1243 "%s: port or port->private is NULL, status=%d\n",
1244 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 return;
1246 }
1247 serial = port->serial;
Alan Cox41ad4272008-07-22 11:11:02 +01001248 if (serial == NULL || (serial_priv = usb_get_serial_data(serial)) == NULL) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001249 dev_err(&port->dev,
1250 "%s: serial or serial->private is NULL, status=%d\n",
1251 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001252 return;
1253 }
1254
1255 /* handle oob callback */
Alan Coxc6d61262007-07-26 18:57:52 +01001256 if (priv->dp_port_num == serial_priv->ds_oob_port_num) {
1257 dbg("digi_write_bulk_callback: oob callback");
1258 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259 priv->dp_write_urb_in_use = 0;
Alan Coxc6d61262007-07-26 18:57:52 +01001260 wake_up_interruptible(&port->write_wait);
1261 spin_unlock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262 return;
1263 }
1264
1265 /* try to send any buffered data on this port, if it is open */
Alan Coxc6d61262007-07-26 18:57:52 +01001266 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 priv->dp_write_urb_in_use = 0;
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001268 if (port->port.count && priv->dp_out_buf_len > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001269 *((unsigned char *)(port->write_urb->transfer_buffer))
1270 = (unsigned char)DIGI_CMD_SEND_DATA;
Alan Cox41ad4272008-07-22 11:11:02 +01001271 *((unsigned char *)(port->write_urb->transfer_buffer) + 1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 = (unsigned char)priv->dp_out_buf_len;
Alan Cox41ad4272008-07-22 11:11:02 +01001273 port->write_urb->transfer_buffer_length =
1274 priv->dp_out_buf_len + 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275 port->write_urb->dev = serial->dev;
Alan Cox41ad4272008-07-22 11:11:02 +01001276 memcpy(port->write_urb->transfer_buffer + 2, priv->dp_out_buf,
Alan Coxc6d61262007-07-26 18:57:52 +01001277 priv->dp_out_buf_len);
Alan Cox41ad4272008-07-22 11:11:02 +01001278 ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1279 if (ret == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 priv->dp_write_urb_in_use = 1;
1281 priv->dp_out_buf_len = 0;
1282 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 /* wake up processes sleeping on writes immediately */
Alan Coxc6d61262007-07-26 18:57:52 +01001285 digi_wakeup_write(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 /* also queue up a wakeup at scheduler time, in case we */
1287 /* lost the race in write_chan(). */
1288 schedule_work(&priv->dp_wakeup_work);
1289
Alan Coxc6d61262007-07-26 18:57:52 +01001290 spin_unlock(&priv->dp_port_lock);
1291 if (ret)
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001292 dev_err(&port->dev,
1293 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
Harvey Harrison441b62c2008-03-03 16:08:34 -08001294 __func__, ret, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295}
1296
Alan Cox95da3102008-07-22 11:09:07 +01001297static int digi_write_room(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001298{
Alan Cox95da3102008-07-22 11:09:07 +01001299 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300 struct digi_port *priv = usb_get_serial_port_data(port);
Alan Cox95da3102008-07-22 11:09:07 +01001301 int room;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302 unsigned long flags = 0;
1303
Alan Coxc6d61262007-07-26 18:57:52 +01001304 spin_lock_irqsave(&priv->dp_port_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001306 if (priv->dp_write_urb_in_use)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 room = 0;
1308 else
1309 room = port->bulk_out_size - 2 - priv->dp_out_buf_len;
1310
Alan Coxc6d61262007-07-26 18:57:52 +01001311 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1312 dbg("digi_write_room: port=%d, room=%d", priv->dp_port_num, room);
1313 return room;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314
1315}
1316
Alan Cox95da3102008-07-22 11:09:07 +01001317static int digi_chars_in_buffer(struct tty_struct *tty)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318{
Alan Cox95da3102008-07-22 11:09:07 +01001319 struct usb_serial_port *port = tty->driver_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 struct digi_port *priv = usb_get_serial_port_data(port);
1321
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001322 if (priv->dp_write_urb_in_use) {
Alan Coxc6d61262007-07-26 18:57:52 +01001323 dbg("digi_chars_in_buffer: port=%d, chars=%d",
1324 priv->dp_port_num, port->bulk_out_size - 2);
1325 /* return(port->bulk_out_size - 2); */
1326 return 256;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 } else {
Alan Coxc6d61262007-07-26 18:57:52 +01001328 dbg("digi_chars_in_buffer: port=%d, chars=%d",
1329 priv->dp_port_num, priv->dp_out_buf_len);
1330 return priv->dp_out_buf_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 }
1332
1333}
1334
Alan Cox335f8512009-06-11 12:26:29 +01001335static void digi_dtr_rts(struct usb_serial_port *port, int on)
1336{
1337 /* Adjust DTR and RTS */
1338 digi_set_modem_signals(port, on * (TIOCM_DTR|TIOCM_RTS), 1);
1339}
1340
1341static int digi_carrier_raised(struct usb_serial_port *port)
1342{
1343 struct digi_port *priv = usb_get_serial_port_data(port);
1344 if (priv->dp_modem_signals & TIOCM_CD)
1345 return 1;
1346 return 0;
1347}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348
Alan Coxa509a7e2009-09-19 13:13:26 -07001349static int digi_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 int ret;
1352 unsigned char buf[32];
1353 struct digi_port *priv = usb_get_serial_port_data(port);
Alan Cox606d0992006-12-08 02:38:45 -08001354 struct ktermios not_termios;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355
Alan Coxc6d61262007-07-26 18:57:52 +01001356 dbg("digi_open: TOP: port=%d, open_count=%d",
Alan Cox95da3102008-07-22 11:09:07 +01001357 priv->dp_port_num, port->port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
1359 /* be sure the device is started up */
Alan Coxc6d61262007-07-26 18:57:52 +01001360 if (digi_startup_device(port->serial) != 0)
1361 return -ENXIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001362
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 /* read modem signals automatically whenever they change */
1364 buf[0] = DIGI_CMD_READ_INPUT_SIGNALS;
1365 buf[1] = priv->dp_port_num;
1366 buf[2] = DIGI_ENABLE;
1367 buf[3] = 0;
1368
1369 /* flush fifos */
1370 buf[4] = DIGI_CMD_IFLUSH_FIFO;
1371 buf[5] = priv->dp_port_num;
1372 buf[6] = DIGI_FLUSH_TX | DIGI_FLUSH_RX;
1373 buf[7] = 0;
1374
Alan Cox41ad4272008-07-22 11:11:02 +01001375 ret = digi_write_oob_command(port, buf, 8, 1);
1376 if (ret != 0)
Alan Coxc6d61262007-07-26 18:57:52 +01001377 dbg("digi_open: write oob failed, ret=%d", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378
1379 /* set termios settings */
Alan Cox95da3102008-07-22 11:09:07 +01001380 if (tty) {
1381 not_termios.c_cflag = ~tty->termios->c_cflag;
1382 not_termios.c_iflag = ~tty->termios->c_iflag;
1383 digi_set_termios(tty, port, &not_termios);
1384 }
Alan Coxc6d61262007-07-26 18:57:52 +01001385 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386}
1387
1388
Alan Cox335f8512009-06-11 12:26:29 +01001389static void digi_close(struct usb_serial_port *port)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390{
1391 DEFINE_WAIT(wait);
1392 int ret;
1393 unsigned char buf[32];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 struct digi_port *priv = usb_get_serial_port_data(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395
Alan Coxc6d61262007-07-26 18:57:52 +01001396 dbg("digi_close: TOP: port=%d, open_count=%d",
Alan Cox95da3102008-07-22 11:09:07 +01001397 priv->dp_port_num, port->port.count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398
Oliver Neukum0915f492008-01-23 12:28:45 +01001399 mutex_lock(&port->serial->disc_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 /* if disconnected, just clear flags */
Oliver Neukum0915f492008-01-23 12:28:45 +01001401 if (port->serial->disconnected)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 goto exit;
1403
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404 if (port->serial->dev) {
Alan Cox335f8512009-06-11 12:26:29 +01001405 /* FIXME: Transmit idle belongs in the wait_unti_sent path */
1406 digi_transmit_idle(port, DIGI_CLOSE_TIMEOUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407
1408 /* disable input flow control */
1409 buf[0] = DIGI_CMD_SET_INPUT_FLOW_CONTROL;
1410 buf[1] = priv->dp_port_num;
1411 buf[2] = DIGI_DISABLE;
1412 buf[3] = 0;
1413
1414 /* disable output flow control */
1415 buf[4] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL;
1416 buf[5] = priv->dp_port_num;
1417 buf[6] = DIGI_DISABLE;
1418 buf[7] = 0;
1419
1420 /* disable reading modem signals automatically */
1421 buf[8] = DIGI_CMD_READ_INPUT_SIGNALS;
1422 buf[9] = priv->dp_port_num;
1423 buf[10] = DIGI_DISABLE;
1424 buf[11] = 0;
1425
1426 /* disable receive */
1427 buf[12] = DIGI_CMD_RECEIVE_ENABLE;
1428 buf[13] = priv->dp_port_num;
1429 buf[14] = DIGI_DISABLE;
1430 buf[15] = 0;
1431
1432 /* flush fifos */
1433 buf[16] = DIGI_CMD_IFLUSH_FIFO;
1434 buf[17] = priv->dp_port_num;
1435 buf[18] = DIGI_FLUSH_TX | DIGI_FLUSH_RX;
1436 buf[19] = 0;
1437
Alan Cox41ad4272008-07-22 11:11:02 +01001438 ret = digi_write_oob_command(port, buf, 20, 0);
1439 if (ret != 0)
Alan Coxc6d61262007-07-26 18:57:52 +01001440 dbg("digi_close: write oob failed, ret=%d", ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441
1442 /* wait for final commands on oob port to complete */
Alan Cox41ad4272008-07-22 11:11:02 +01001443 prepare_to_wait(&priv->dp_flush_wait, &wait,
1444 TASK_INTERRUPTIBLE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445 schedule_timeout(DIGI_CLOSE_TIMEOUT);
1446 finish_wait(&priv->dp_flush_wait, &wait);
1447
1448 /* shutdown any outstanding bulk writes */
1449 usb_kill_urb(port->write_urb);
1450 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451exit:
Oliver Neukum0915f492008-01-23 12:28:45 +01001452 spin_lock_irq(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 priv->dp_write_urb_in_use = 0;
Alan Coxc6d61262007-07-26 18:57:52 +01001454 wake_up_interruptible(&priv->dp_close_wait);
Oliver Neukum0915f492008-01-23 12:28:45 +01001455 spin_unlock_irq(&priv->dp_port_lock);
1456 mutex_unlock(&port->serial->disc_mutex);
Alan Coxc6d61262007-07-26 18:57:52 +01001457 dbg("digi_close: done");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458}
1459
1460
1461/*
Alan Cox41ad4272008-07-22 11:11:02 +01001462 * Digi Startup Device
1463 *
1464 * Starts reads on all ports. Must be called AFTER startup, with
1465 * urbs initialized. Returns 0 if successful, non-zero error otherwise.
1466 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467
Alan Coxc6d61262007-07-26 18:57:52 +01001468static int digi_startup_device(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469{
Alan Cox41ad4272008-07-22 11:11:02 +01001470 int i, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471 struct digi_serial *serial_priv = usb_get_serial_data(serial);
1472 struct usb_serial_port *port;
1473
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 /* be sure this happens exactly once */
Alan Coxc6d61262007-07-26 18:57:52 +01001475 spin_lock(&serial_priv->ds_serial_lock);
1476 if (serial_priv->ds_device_started) {
1477 spin_unlock(&serial_priv->ds_serial_lock);
1478 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 }
1480 serial_priv->ds_device_started = 1;
Alan Coxc6d61262007-07-26 18:57:52 +01001481 spin_unlock(&serial_priv->ds_serial_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482
1483 /* start reading from each bulk in endpoint for the device */
1484 /* set USB_DISABLE_SPD flag for write bulk urbs */
Alan Coxc6d61262007-07-26 18:57:52 +01001485 for (i = 0; i < serial->type->num_ports + 1; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 port = serial->port[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 port->write_urb->dev = port->serial->dev;
Alan Cox41ad4272008-07-22 11:11:02 +01001488 ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
1489 if (ret != 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001490 dev_err(&port->dev,
1491 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
1492 __func__, ret, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001493 break;
1494 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 }
Alan Coxc6d61262007-07-26 18:57:52 +01001496 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497}
1498
1499
Alan Coxc6d61262007-07-26 18:57:52 +01001500static int digi_startup(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501{
1502
1503 int i;
1504 struct digi_port *priv;
1505 struct digi_serial *serial_priv;
1506
Alan Coxc6d61262007-07-26 18:57:52 +01001507 dbg("digi_startup: TOP");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508
1509 /* allocate the private data structures for all ports */
1510 /* number of regular ports + 1 for the out-of-band port */
Alan Cox41ad4272008-07-22 11:11:02 +01001511 for (i = 0; i < serial->type->num_ports + 1; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 /* allocate port private structure */
Alan Coxc6d61262007-07-26 18:57:52 +01001513 priv = kmalloc(sizeof(struct digi_port), GFP_KERNEL);
1514 if (priv == NULL) {
1515 while (--i >= 0)
1516 kfree(usb_get_serial_port_data(serial->port[i]));
1517 return 1; /* error */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 }
1519
1520 /* initialize port private structure */
Alan Coxc6d61262007-07-26 18:57:52 +01001521 spin_lock_init(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 priv->dp_port_num = i;
1523 priv->dp_out_buf_len = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524 priv->dp_write_urb_in_use = 0;
1525 priv->dp_modem_signals = 0;
Alan Coxc6d61262007-07-26 18:57:52 +01001526 init_waitqueue_head(&priv->dp_modem_change_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001527 priv->dp_transmit_idle = 0;
Alan Coxc6d61262007-07-26 18:57:52 +01001528 init_waitqueue_head(&priv->dp_transmit_idle_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 priv->dp_throttled = 0;
1530 priv->dp_throttle_restart = 0;
Alan Coxc6d61262007-07-26 18:57:52 +01001531 init_waitqueue_head(&priv->dp_flush_wait);
Alan Coxc6d61262007-07-26 18:57:52 +01001532 init_waitqueue_head(&priv->dp_close_wait);
David Howellsc4028952006-11-22 14:57:56 +00001533 INIT_WORK(&priv->dp_wakeup_work, digi_wakeup_write_lock);
1534 priv->dp_port = serial->port[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535 /* initialize write wait queue for this port */
Alan Coxc6d61262007-07-26 18:57:52 +01001536 init_waitqueue_head(&serial->port[i]->write_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537
1538 usb_set_serial_port_data(serial->port[i], priv);
1539 }
1540
1541 /* allocate serial private structure */
Alan Coxc6d61262007-07-26 18:57:52 +01001542 serial_priv = kmalloc(sizeof(struct digi_serial), GFP_KERNEL);
1543 if (serial_priv == NULL) {
1544 for (i = 0; i < serial->type->num_ports + 1; i++)
1545 kfree(usb_get_serial_port_data(serial->port[i]));
1546 return 1; /* error */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001547 }
1548
1549 /* initialize serial private structure */
Alan Coxc6d61262007-07-26 18:57:52 +01001550 spin_lock_init(&serial_priv->ds_serial_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 serial_priv->ds_oob_port_num = serial->type->num_ports;
1552 serial_priv->ds_oob_port = serial->port[serial_priv->ds_oob_port_num];
1553 serial_priv->ds_device_started = 0;
1554 usb_set_serial_data(serial, serial_priv);
1555
Alan Coxc6d61262007-07-26 18:57:52 +01001556 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557}
1558
1559
Alan Sternf9c99bb2009-06-02 11:53:55 -04001560static void digi_disconnect(struct usb_serial *serial)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 int i;
Alan Sternf9c99bb2009-06-02 11:53:55 -04001563 dbg("digi_disconnect: TOP, in_interrupt()=%ld", in_interrupt());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564
1565 /* stop reads and writes on all ports */
Alan Coxc6d61262007-07-26 18:57:52 +01001566 for (i = 0; i < serial->type->num_ports + 1; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 usb_kill_urb(serial->port[i]->read_urb);
1568 usb_kill_urb(serial->port[i]->write_urb);
1569 }
Alan Sternf9c99bb2009-06-02 11:53:55 -04001570}
1571
1572
1573static void digi_release(struct usb_serial *serial)
1574{
1575 int i;
1576 dbg("digi_release: TOP, in_interrupt()=%ld", in_interrupt());
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577
1578 /* free the private data structures for all ports */
1579 /* number of regular ports + 1 for the out-of-band port */
Alan Cox41ad4272008-07-22 11:11:02 +01001580 for (i = 0; i < serial->type->num_ports + 1; i++)
Alan Coxc6d61262007-07-26 18:57:52 +01001581 kfree(usb_get_serial_port_data(serial->port[i]));
1582 kfree(usb_get_serial_data(serial));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583}
1584
1585
Alan Coxc6d61262007-07-26 18:57:52 +01001586static void digi_read_bulk_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587{
Ming Leicdc97792008-02-24 18:41:47 +08001588 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 struct digi_port *priv;
1590 struct digi_serial *serial_priv;
1591 int ret;
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001592 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593
Alan Coxc6d61262007-07-26 18:57:52 +01001594 dbg("digi_read_bulk_callback: TOP");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595
1596 /* port sanity check, do not resubmit if port is not valid */
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001597 if (port == NULL)
1598 return;
1599 priv = usb_get_serial_port_data(port);
1600 if (priv == NULL) {
1601 dev_err(&port->dev, "%s: port->private is NULL, status=%d\n",
1602 __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603 return;
1604 }
Alan Coxc6d61262007-07-26 18:57:52 +01001605 if (port->serial == NULL ||
Alan Cox41ad4272008-07-22 11:11:02 +01001606 (serial_priv = usb_get_serial_data(port->serial)) == NULL) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001607 dev_err(&port->dev, "%s: serial is bad or serial->private "
1608 "is NULL, status=%d\n", __func__, status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 return;
1610 }
1611
1612 /* do not resubmit urb if it has any status error */
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001613 if (status) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001614 dev_err(&port->dev,
1615 "%s: nonzero read bulk status: status=%d, port=%d\n",
1616 __func__, status, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617 return;
1618 }
1619
1620 /* handle oob or inb callback, do not resubmit if error */
Alan Coxc6d61262007-07-26 18:57:52 +01001621 if (priv->dp_port_num == serial_priv->ds_oob_port_num) {
1622 if (digi_read_oob_callback(urb) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 return;
1624 } else {
Alan Coxc6d61262007-07-26 18:57:52 +01001625 if (digi_read_inb_callback(urb) != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626 return;
1627 }
1628
1629 /* continue read */
1630 urb->dev = port->serial->dev;
Alan Cox41ad4272008-07-22 11:11:02 +01001631 ret = usb_submit_urb(urb, GFP_ATOMIC);
1632 if (ret != 0) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001633 dev_err(&port->dev,
1634 "%s: failed resubmitting urb, ret=%d, port=%d\n",
1635 __func__, ret, priv->dp_port_num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 }
1637
1638}
1639
Alan Cox41ad4272008-07-22 11:11:02 +01001640/*
1641 * Digi Read INB Callback
1642 *
1643 * Digi Read INB Callback handles reads on the in band ports, sending
1644 * the data on to the tty subsystem. When called we know port and
1645 * port->private are not NULL and port->serial has been validated.
1646 * It returns 0 if successful, 1 if successful but the port is
1647 * throttled, and -1 if the sanity checks failed.
1648 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
Alan Coxc6d61262007-07-26 18:57:52 +01001650static int digi_read_inb_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651{
1652
Ming Leicdc97792008-02-24 18:41:47 +08001653 struct usb_serial_port *port = urb->context;
Alan Cox4a90f092008-10-13 10:39:46 +01001654 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655 struct digi_port *priv = usb_get_serial_port_data(port);
1656 int opcode = ((unsigned char *)urb->transfer_buffer)[0];
1657 int len = ((unsigned char *)urb->transfer_buffer)[1];
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001658 int port_status = ((unsigned char *)urb->transfer_buffer)[2];
Alan Cox41ad4272008-07-22 11:11:02 +01001659 unsigned char *data = ((unsigned char *)urb->transfer_buffer) + 3;
1660 int flag, throttled;
Alan Cox33f0f882006-01-09 20:54:13 -08001661 int i;
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001662 int status = urb->status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
1664 /* do not process callbacks on closed ports */
1665 /* but do continue the read chain */
Alan Cox95da3102008-07-22 11:09:07 +01001666 if (port->port.count == 0)
Alan Coxc6d61262007-07-26 18:57:52 +01001667 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668
1669 /* short/multiple packet check */
Alan Coxc6d61262007-07-26 18:57:52 +01001670 if (urb->actual_length != len + 2) {
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001671 dev_err(&port->dev, "%s: INCOMPLETE OR MULTIPLE PACKET, "
Greg Kroah-Hartman50de36f2008-12-10 16:00:30 -08001672 "status=%d, port=%d, opcode=%d, len=%d, "
Greg Kroah-Hartman194343d2008-08-20 16:56:34 -07001673 "actual_length=%d, status=%d\n", __func__, status,
1674 priv->dp_port_num, opcode, len, urb->actual_length,
1675 port_status);
Alan Coxc6d61262007-07-26 18:57:52 +01001676 return -1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 }
1678
Alan Cox4a90f092008-10-13 10:39:46 +01001679 tty = tty_port_tty_get(&port->port);
Alan Coxc6d61262007-07-26 18:57:52 +01001680 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681
1682 /* check for throttle; if set, do not resubmit read urb */
1683 /* indicate the read chain needs to be restarted on unthrottle */
1684 throttled = priv->dp_throttled;
Alan Coxc6d61262007-07-26 18:57:52 +01001685 if (throttled)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001686 priv->dp_throttle_restart = 1;
1687
1688 /* receive data */
Alan Coxc6d61262007-07-26 18:57:52 +01001689 if (opcode == DIGI_CMD_RECEIVE_DATA) {
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001690 /* get flag from port_status */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 flag = 0;
1692
1693 /* overrun is special, not associated with a char */
Alan Coxc6d61262007-07-26 18:57:52 +01001694 if (port_status & DIGI_OVERRUN_ERROR)
1695 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696
1697 /* break takes precedence over parity, */
1698 /* which takes precedence over framing errors */
Alan Coxc6d61262007-07-26 18:57:52 +01001699 if (port_status & DIGI_BREAK_ERROR)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 flag = TTY_BREAK;
Alan Coxc6d61262007-07-26 18:57:52 +01001701 else if (port_status & DIGI_PARITY_ERROR)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702 flag = TTY_PARITY;
Alan Coxc6d61262007-07-26 18:57:52 +01001703 else if (port_status & DIGI_FRAMING_ERROR)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 flag = TTY_FRAME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705
Greg Kroah-Hartman85d75102007-06-15 15:44:13 -07001706 /* data length is len-1 (one byte of len is port_status) */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 --len;
1708
Oliver Neukum39892da2007-05-07 13:16:58 +02001709 len = tty_buffer_request_room(tty, len);
Alan Coxc6d61262007-07-26 18:57:52 +01001710 if (len > 0) {
Oliver Neukum39892da2007-05-07 13:16:58 +02001711 /* Hot path */
Alan Coxc6d61262007-07-26 18:57:52 +01001712 if (flag == TTY_NORMAL)
Oliver Neukum39892da2007-05-07 13:16:58 +02001713 tty_insert_flip_string(tty, data, len);
1714 else {
Alan Cox41ad4272008-07-22 11:11:02 +01001715 for (i = 0; i < len; i++)
1716 tty_insert_flip_char(tty,
1717 data[i], flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 }
Alan Coxc6d61262007-07-26 18:57:52 +01001719 tty_flip_buffer_push(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 }
Alan Coxc6d61262007-07-26 18:57:52 +01001722 spin_unlock(&priv->dp_port_lock);
Alan Cox4a90f092008-10-13 10:39:46 +01001723 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001724
Alan Coxc6d61262007-07-26 18:57:52 +01001725 if (opcode == DIGI_CMD_RECEIVE_DISABLE)
Harvey Harrison441b62c2008-03-03 16:08:34 -08001726 dbg("%s: got RECEIVE_DISABLE", __func__);
Alan Coxc6d61262007-07-26 18:57:52 +01001727 else if (opcode != DIGI_CMD_RECEIVE_DATA)
Harvey Harrison441b62c2008-03-03 16:08:34 -08001728 dbg("%s: unknown opcode: %d", __func__, opcode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
Alan Cox41ad4272008-07-22 11:11:02 +01001730 return throttled ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
1732}
1733
1734
Alan Cox41ad4272008-07-22 11:11:02 +01001735/*
1736 * Digi Read OOB Callback
1737 *
1738 * Digi Read OOB Callback handles reads on the out of band port.
1739 * When called we know port and port->private are not NULL and
1740 * the port->serial is valid. It returns 0 if successful, and
1741 * -1 if the sanity checks failed.
1742 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743
Alan Coxc6d61262007-07-26 18:57:52 +01001744static int digi_read_oob_callback(struct urb *urb)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745{
1746
Ming Leicdc97792008-02-24 18:41:47 +08001747 struct usb_serial_port *port = urb->context;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 struct usb_serial *serial = port->serial;
Alan Cox4a90f092008-10-13 10:39:46 +01001749 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750 struct digi_port *priv = usb_get_serial_port_data(port);
1751 int opcode, line, status, val;
1752 int i;
Alan Cox41ad4272008-07-22 11:11:02 +01001753 unsigned int rts;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
Alan Coxc6d61262007-07-26 18:57:52 +01001755 dbg("digi_read_oob_callback: port=%d, len=%d",
1756 priv->dp_port_num, urb->actual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757
1758 /* handle each oob command */
Alan Cox41ad4272008-07-22 11:11:02 +01001759 for (i = 0; i < urb->actual_length - 3;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 opcode = ((unsigned char *)urb->transfer_buffer)[i++];
1761 line = ((unsigned char *)urb->transfer_buffer)[i++];
1762 status = ((unsigned char *)urb->transfer_buffer)[i++];
1763 val = ((unsigned char *)urb->transfer_buffer)[i++];
1764
Alan Coxc6d61262007-07-26 18:57:52 +01001765 dbg("digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d",
1766 opcode, line, status, val);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
Alan Coxc6d61262007-07-26 18:57:52 +01001768 if (status != 0 || line >= serial->type->num_ports)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 continue;
1770
1771 port = serial->port[line];
1772
Alan Cox41ad4272008-07-22 11:11:02 +01001773 priv = usb_get_serial_port_data(port);
1774 if (priv == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 return -1;
1776
Alan Cox4a90f092008-10-13 10:39:46 +01001777 tty = tty_port_tty_get(&port->port);
Alan Cox41ad4272008-07-22 11:11:02 +01001778 rts = 0;
1779 if (port->port.count)
Alan Cox4a90f092008-10-13 10:39:46 +01001780 rts = tty->termios->c_cflag & CRTSCTS;
1781
Alan Coxc6d61262007-07-26 18:57:52 +01001782 if (opcode == DIGI_CMD_READ_INPUT_SIGNALS) {
1783 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 /* convert from digi flags to termiox flags */
Alan Coxc6d61262007-07-26 18:57:52 +01001785 if (val & DIGI_READ_INPUT_SIGNALS_CTS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 priv->dp_modem_signals |= TIOCM_CTS;
1787 /* port must be open to use tty struct */
Alan Cox41ad4272008-07-22 11:11:02 +01001788 if (rts) {
Alan Cox4a90f092008-10-13 10:39:46 +01001789 tty->hw_stopped = 0;
Alan Coxc6d61262007-07-26 18:57:52 +01001790 digi_wakeup_write(port);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 }
1792 } else {
1793 priv->dp_modem_signals &= ~TIOCM_CTS;
1794 /* port must be open to use tty struct */
Alan Cox41ad4272008-07-22 11:11:02 +01001795 if (rts)
Alan Cox4a90f092008-10-13 10:39:46 +01001796 tty->hw_stopped = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 }
Alan Coxc6d61262007-07-26 18:57:52 +01001798 if (val & DIGI_READ_INPUT_SIGNALS_DSR)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 priv->dp_modem_signals |= TIOCM_DSR;
1800 else
1801 priv->dp_modem_signals &= ~TIOCM_DSR;
Alan Coxc6d61262007-07-26 18:57:52 +01001802 if (val & DIGI_READ_INPUT_SIGNALS_RI)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 priv->dp_modem_signals |= TIOCM_RI;
1804 else
1805 priv->dp_modem_signals &= ~TIOCM_RI;
Alan Coxc6d61262007-07-26 18:57:52 +01001806 if (val & DIGI_READ_INPUT_SIGNALS_DCD)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 priv->dp_modem_signals |= TIOCM_CD;
1808 else
1809 priv->dp_modem_signals &= ~TIOCM_CD;
1810
Alan Coxc6d61262007-07-26 18:57:52 +01001811 wake_up_interruptible(&priv->dp_modem_change_wait);
1812 spin_unlock(&priv->dp_port_lock);
1813 } else if (opcode == DIGI_CMD_TRANSMIT_IDLE) {
1814 spin_lock(&priv->dp_port_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 priv->dp_transmit_idle = 1;
Alan Coxc6d61262007-07-26 18:57:52 +01001816 wake_up_interruptible(&priv->dp_transmit_idle_wait);
1817 spin_unlock(&priv->dp_port_lock);
1818 } else if (opcode == DIGI_CMD_IFLUSH_FIFO) {
1819 wake_up_interruptible(&priv->dp_flush_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820 }
Alan Cox4a90f092008-10-13 10:39:46 +01001821 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 }
Alan Coxc6d61262007-07-26 18:57:52 +01001823 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824
1825}
1826
Alan Coxc6d61262007-07-26 18:57:52 +01001827static int __init digi_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828{
1829 int retval;
1830 retval = usb_serial_register(&digi_acceleport_2_device);
1831 if (retval)
1832 goto failed_acceleport_2_device;
1833 retval = usb_serial_register(&digi_acceleport_4_device);
Alan Cox41ad4272008-07-22 11:11:02 +01001834 if (retval)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 goto failed_acceleport_4_device;
1836 retval = usb_register(&digi_driver);
1837 if (retval)
1838 goto failed_usb_register;
Greg Kroah-Hartmanc197a8d2008-08-18 13:21:04 -07001839 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1840 DRIVER_DESC "\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 return 0;
1842failed_usb_register:
1843 usb_serial_deregister(&digi_acceleport_4_device);
1844failed_acceleport_4_device:
1845 usb_serial_deregister(&digi_acceleport_2_device);
1846failed_acceleport_2_device:
1847 return retval;
1848}
1849
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850static void __exit digi_exit (void)
1851{
Alan Coxc6d61262007-07-26 18:57:52 +01001852 usb_deregister(&digi_driver);
1853 usb_serial_deregister(&digi_acceleport_2_device);
1854 usb_serial_deregister(&digi_acceleport_4_device);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855}
1856
1857
1858module_init(digi_init);
1859module_exit(digi_exit);
1860
1861
Alan Coxc6d61262007-07-26 18:57:52 +01001862MODULE_AUTHOR(DRIVER_AUTHOR);
1863MODULE_DESCRIPTION(DRIVER_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864MODULE_LICENSE("GPL");
1865
1866module_param(debug, bool, S_IRUGO | S_IWUSR);
1867MODULE_PARM_DESC(debug, "Debug enabled or not");