source: src/linux/universal/linux-3.18/drivers/usb/serial/digi_acceleport.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 6 weeks ago

update

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