1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234#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>
244#include <linux/uaccess.h>
245#include <linux/usb.h>
246#include <linux/wait.h>
247#include <linux/usb/serial.h>
248
249
250
251
252
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
259
260#define DIGI_OUT_BUF_SIZE 8
261
262
263
264#define DIGI_IN_BUF_SIZE 64
265
266
267#define DIGI_RETRY_TIMEOUT (HZ/10)
268
269
270
271
272#define DIGI_CLOSE_TIMEOUT (5*HZ)
273
274
275
276
277
278#define DIGI_VENDOR_ID 0x05c5
279#define DIGI_2_ID 0x0002
280#define DIGI_4_ID 0x0004
281
282
283
284
285
286#define DIGI_CMD_SET_BAUD_RATE 0
287#define DIGI_CMD_SET_WORD_SIZE 1
288#define DIGI_CMD_SET_PARITY 2
289#define DIGI_CMD_SET_STOP_BITS 3
290#define DIGI_CMD_SET_INPUT_FLOW_CONTROL 4
291#define DIGI_CMD_SET_OUTPUT_FLOW_CONTROL 5
292#define DIGI_CMD_SET_DTR_SIGNAL 6
293#define DIGI_CMD_SET_RTS_SIGNAL 7
294#define DIGI_CMD_READ_INPUT_SIGNALS 8
295#define DIGI_CMD_IFLUSH_FIFO 9
296#define DIGI_CMD_RECEIVE_ENABLE 10
297#define DIGI_CMD_BREAK_CONTROL 11
298#define DIGI_CMD_LOCAL_LOOPBACK 12
299#define DIGI_CMD_TRANSMIT_IDLE 13
300#define DIGI_CMD_READ_UART_REGISTER 14
301#define DIGI_CMD_WRITE_UART_REGISTER 15
302#define DIGI_CMD_AND_UART_REGISTER 16
303#define DIGI_CMD_OR_UART_REGISTER 17
304#define DIGI_CMD_SEND_DATA 18
305#define DIGI_CMD_RECEIVE_DATA 19
306#define DIGI_CMD_RECEIVE_DISABLE 20
307#define DIGI_CMD_GET_PORT_TYPE 21
308
309
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
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
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
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
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
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
404
405struct digi_serial {
406 spinlock_t ds_serial_lock;
407 struct usb_serial_port *ds_oob_port;
408 int ds_oob_port_num;
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];
417 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;
425 int dp_in_close;
426 wait_queue_head_t dp_close_wait;
427 struct work_struct dp_wakeup_work;
428 struct usb_serial_port *dp_port;
429};
430
431
432
433
434static void digi_wakeup_write(struct usb_serial_port *port);
435static void digi_wakeup_write_lock(struct work_struct *work);
436static int digi_write_oob_command(struct usb_serial_port *port,
437 unsigned char *buf, int count, int interruptible);
438static int digi_write_inb_command(struct usb_serial_port *port,
439 unsigned char *buf, int count, unsigned long timeout);
440static int digi_set_modem_signals(struct usb_serial_port *port,
441 unsigned int modem_signals, int interruptible);
442static int digi_transmit_idle(struct usb_serial_port *port,
443 unsigned long timeout);
444static void digi_rx_throttle(struct tty_struct *tty);
445static void digi_rx_unthrottle(struct tty_struct *tty);
446static void digi_set_termios(struct tty_struct *tty,
447 struct usb_serial_port *port, struct ktermios *old_termios);
448static void digi_break_ctl(struct tty_struct *tty, int break_state);
449static int digi_tiocmget(struct tty_struct *tty, struct file *file);
450static int digi_tiocmset(struct tty_struct *tty, struct file *file,
451 unsigned int set, unsigned int clear);
452static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
453 const unsigned char *buf, int count);
454static void digi_write_bulk_callback(struct urb *urb);
455static int digi_write_room(struct tty_struct *tty);
456static int digi_chars_in_buffer(struct tty_struct *tty);
457static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
458 struct file *filp);
459static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
460 struct file *filp);
461static int digi_startup_device(struct usb_serial *serial);
462static int digi_startup(struct usb_serial *serial);
463static void digi_shutdown(struct usb_serial *serial);
464static 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);
467
468
469
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 { }
477};
478
479static struct usb_device_id id_table_2 [] = {
480 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
481 { }
482};
483
484static struct usb_device_id id_table_4 [] = {
485 { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
486 { }
487};
488
489MODULE_DEVICE_TABLE(usb, id_table_combined);
490
491static struct usb_driver digi_driver = {
492 .name = "digi_acceleport",
493 .probe = usb_serial_probe,
494 .disconnect = usb_serial_disconnect,
495 .id_table = id_table_combined,
496 .no_dynamic_id = 1,
497};
498
499
500
501
502static struct usb_serial_driver digi_acceleport_2_device = {
503 .driver = {
504 .owner = THIS_MODULE,
505 .name = "digi_2",
506 },
507 .description = "Digi 2 port USB adapter",
508 .usb_driver = &digi_driver,
509 .id_table = id_table_2,
510 .num_ports = 3,
511 .open = digi_open,
512 .close = digi_close,
513 .write = digi_write,
514 .write_room = digi_write_room,
515 .write_bulk_callback = digi_write_bulk_callback,
516 .read_bulk_callback = digi_read_bulk_callback,
517 .chars_in_buffer = digi_chars_in_buffer,
518 .throttle = digi_rx_throttle,
519 .unthrottle = digi_rx_unthrottle,
520 .set_termios = digi_set_termios,
521 .break_ctl = digi_break_ctl,
522 .tiocmget = digi_tiocmget,
523 .tiocmset = digi_tiocmset,
524 .attach = digi_startup,
525 .shutdown = digi_shutdown,
526};
527
528static struct usb_serial_driver digi_acceleport_4_device = {
529 .driver = {
530 .owner = THIS_MODULE,
531 .name = "digi_4",
532 },
533 .description = "Digi 4 port USB adapter",
534 .usb_driver = &digi_driver,
535 .id_table = id_table_4,
536 .num_ports = 4,
537 .open = digi_open,
538 .close = digi_close,
539 .write = digi_write,
540 .write_room = digi_write_room,
541 .write_bulk_callback = digi_write_bulk_callback,
542 .read_bulk_callback = digi_read_bulk_callback,
543 .chars_in_buffer = digi_chars_in_buffer,
544 .throttle = digi_rx_throttle,
545 .unthrottle = digi_rx_unthrottle,
546 .set_termios = digi_set_termios,
547 .break_ctl = digi_break_ctl,
548 .tiocmget = digi_tiocmget,
549 .tiocmset = digi_tiocmset,
550 .attach = digi_startup,
551 .shutdown = digi_shutdown,
552};
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570static long cond_wait_interruptible_timeout_irqrestore(
571 wait_queue_head_t *q, long timeout,
572 spinlock_t *lock, unsigned long flags)
573__releases(lock)
574{
575 DEFINE_WAIT(wait);
576
577 prepare_to_wait(q, &wait, TASK_INTERRUPTIBLE);
578 spin_unlock_irqrestore(lock, flags);
579 timeout = schedule_timeout(timeout);
580 finish_wait(q, &wait);
581
582 return timeout;
583}
584
585
586
587
588
589
590
591
592
593static void digi_wakeup_write_lock(struct work_struct *work)
594{
595 struct digi_port *priv =
596 container_of(work, struct digi_port, dp_wakeup_work);
597 struct usb_serial_port *port = priv->dp_port;
598 unsigned long flags;
599
600 spin_lock_irqsave(&priv->dp_port_lock, flags);
601 digi_wakeup_write(port);
602 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
603}
604
605static void digi_wakeup_write(struct usb_serial_port *port)
606{
607 struct tty_struct *tty = tty_port_tty_get(&port->port);
608 tty_wakeup(tty);
609 tty_kref_put(tty);
610}
611
612
613
614
615
616
617
618
619
620
621
622
623
624static int digi_write_oob_command(struct usb_serial_port *port,
625 unsigned char *buf, int count, int interruptible)
626{
627
628 int ret = 0;
629 int len;
630 struct usb_serial_port *oob_port = (struct usb_serial_port *)((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port;
631 struct digi_port *oob_priv = usb_get_serial_port_data(oob_port);
632 unsigned long flags = 0;
633
634 dbg("digi_write_oob_command: TOP: port=%d, count=%d", oob_priv->dp_port_num, count);
635
636 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
637 while (count > 0) {
638 while (oob_port->write_urb->status == -EINPROGRESS
639 || oob_priv->dp_write_urb_in_use) {
640 cond_wait_interruptible_timeout_irqrestore(
641 &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
642 &oob_priv->dp_port_lock, flags);
643 if (interruptible && signal_pending(current))
644 return -EINTR;
645 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
646 }
647
648
649 len = min(count, oob_port->bulk_out_size);
650 if (len > 4)
651 len &= ~3;
652 memcpy(oob_port->write_urb->transfer_buffer, buf, len);
653 oob_port->write_urb->transfer_buffer_length = len;
654 oob_port->write_urb->dev = port->serial->dev;
655 ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC);
656 if (ret == 0) {
657 oob_priv->dp_write_urb_in_use = 1;
658 count -= len;
659 buf += len;
660 }
661 }
662 spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
663 if (ret)
664 dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n",
665 __func__, ret);
666 return ret;
667
668}
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683static int digi_write_inb_command(struct usb_serial_port *port,
684 unsigned char *buf, int count, unsigned long timeout)
685{
686 int ret = 0;
687 int len;
688 struct digi_port *priv = usb_get_serial_port_data(port);
689 unsigned char *data = port->write_urb->transfer_buffer;
690 unsigned long flags = 0;
691
692 dbg("digi_write_inb_command: TOP: port=%d, count=%d",
693 priv->dp_port_num, count);
694
695 if (timeout)
696 timeout += jiffies;
697 else
698 timeout = ULONG_MAX;
699
700 spin_lock_irqsave(&priv->dp_port_lock, flags);
701 while (count > 0 && ret == 0) {
702 while ((port->write_urb->status == -EINPROGRESS
703 || priv->dp_write_urb_in_use)
704 && time_before(jiffies, timeout)) {
705 cond_wait_interruptible_timeout_irqrestore(
706 &port->write_wait, DIGI_RETRY_TIMEOUT,
707 &priv->dp_port_lock, flags);
708 if (signal_pending(current))
709 return -EINTR;
710 spin_lock_irqsave(&priv->dp_port_lock, flags);
711 }
712
713
714
715
716 len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len);
717 if (len > 4)
718 len &= ~3;
719
720
721 if (priv->dp_out_buf_len > 0) {
722 data[0] = DIGI_CMD_SEND_DATA;
723 data[1] = priv->dp_out_buf_len;
724 memcpy(data + 2, priv->dp_out_buf,
725 priv->dp_out_buf_len);
726 memcpy(data + 2 + priv->dp_out_buf_len, buf, len);
727 port->write_urb->transfer_buffer_length
728 = priv->dp_out_buf_len + 2 + len;
729 } else {
730 memcpy(data, buf, len);
731 port->write_urb->transfer_buffer_length = len;
732 }
733 port->write_urb->dev = port->serial->dev;
734
735 ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
736 if (ret == 0) {
737 priv->dp_write_urb_in_use = 1;
738 priv->dp_out_buf_len = 0;
739 count -= len;
740 buf += len;
741 }
742
743 }
744 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
745
746 if (ret)
747 dev_err(&port->dev,
748 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
749 __func__, ret, priv->dp_port_num);
750 return ret;
751}
752
753
754
755
756
757
758
759
760
761
762
763
764static int digi_set_modem_signals(struct usb_serial_port *port,
765 unsigned int modem_signals, int interruptible)
766{
767
768 int ret;
769 struct digi_port *port_priv = usb_get_serial_port_data(port);
770 struct usb_serial_port *oob_port = (struct usb_serial_port *) ((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port;
771 struct digi_port *oob_priv = usb_get_serial_port_data(oob_port);
772 unsigned char *data = oob_port->write_urb->transfer_buffer;
773 unsigned long flags = 0;
774
775
776 dbg("digi_set_modem_signals: TOP: port=%d, modem_signals=0x%x",
777 port_priv->dp_port_num, modem_signals);
778
779 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
780 spin_lock(&port_priv->dp_port_lock);
781
782 while (oob_port->write_urb->status == -EINPROGRESS ||
783 oob_priv->dp_write_urb_in_use) {
784 spin_unlock(&port_priv->dp_port_lock);
785 cond_wait_interruptible_timeout_irqrestore(
786 &oob_port->write_wait, DIGI_RETRY_TIMEOUT,
787 &oob_priv->dp_port_lock, flags);
788 if (interruptible && signal_pending(current))
789 return -EINTR;
790 spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
791 spin_lock(&port_priv->dp_port_lock);
792 }
793 data[0] = DIGI_CMD_SET_DTR_SIGNAL;
794 data[1] = port_priv->dp_port_num;
795 data[2] = (modem_signals & TIOCM_DTR) ?
796 DIGI_DTR_ACTIVE : DIGI_DTR_INACTIVE;
797 data[3] = 0;
798 data[4] = DIGI_CMD_SET_RTS_SIGNAL;
799 data[5] = port_priv->dp_port_num;
800 data[6] = (modem_signals & TIOCM_RTS) ?
801 DIGI_RTS_ACTIVE : DIGI_RTS_INACTIVE;
802 data[7] = 0;
803
804 oob_port->write_urb->transfer_buffer_length = 8;
805 oob_port->write_urb->dev = port->serial->dev;
806
807 ret = usb_submit_urb(oob_port->write_urb, GFP_ATOMIC);
808 if (ret == 0) {
809 oob_priv->dp_write_urb_in_use = 1;
810 port_priv->dp_modem_signals =
811 (port_priv->dp_modem_signals&~(TIOCM_DTR|TIOCM_RTS))
812 | (modem_signals&(TIOCM_DTR|TIOCM_RTS));
813 }
814 spin_unlock(&port_priv->dp_port_lock);
815 spin_unlock_irqrestore(&oob_priv->dp_port_lock, flags);
816 if (ret)
817 dev_err(&port->dev, "%s: usb_submit_urb failed, ret=%d\n",
818 __func__, ret);
819 return ret;
820}
821
822
823
824
825
826
827
828
829
830
831
832
833
834static int digi_transmit_idle(struct usb_serial_port *port,
835 unsigned long timeout)
836{
837 int ret;
838 unsigned char buf[2];
839 struct digi_port *priv = usb_get_serial_port_data(port);
840 unsigned long flags = 0;
841
842 spin_lock_irqsave(&priv->dp_port_lock, flags);
843 priv->dp_transmit_idle = 0;
844 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
845
846 buf[0] = DIGI_CMD_TRANSMIT_IDLE;
847 buf[1] = 0;
848
849 timeout += jiffies;
850
851 ret = digi_write_inb_command(port, buf, 2, timeout - jiffies);
852 if (ret != 0)
853 return ret;
854
855 spin_lock_irqsave(&priv->dp_port_lock, flags);
856
857 while (time_before(jiffies, timeout) && !priv->dp_transmit_idle) {
858 cond_wait_interruptible_timeout_irqrestore(
859 &priv->dp_transmit_idle_wait, DIGI_RETRY_TIMEOUT,
860 &priv->dp_port_lock, flags);
861 if (signal_pending(current))
862 return -EINTR;
863 spin_lock_irqsave(&priv->dp_port_lock, flags);
864 }
865 priv->dp_transmit_idle = 0;
866 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
867 return 0;
868
869}
870
871
872static void digi_rx_throttle(struct tty_struct *tty)
873{
874 unsigned long flags;
875 struct usb_serial_port *port = tty->driver_data;
876 struct digi_port *priv = usb_get_serial_port_data(port);
877
878
879 dbg("digi_rx_throttle: TOP: port=%d", priv->dp_port_num);
880
881
882 spin_lock_irqsave(&priv->dp_port_lock, flags);
883 priv->dp_throttled = 1;
884 priv->dp_throttle_restart = 0;
885 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
886}
887
888
889static void digi_rx_unthrottle(struct tty_struct *tty)
890{
891 int ret = 0;
892 unsigned long flags;
893 struct usb_serial_port *port = tty->driver_data;
894 struct digi_port *priv = usb_get_serial_port_data(port);
895
896 dbg("digi_rx_unthrottle: TOP: port=%d", priv->dp_port_num);
897
898 spin_lock_irqsave(&priv->dp_port_lock, flags);
899
900
901 priv->dp_throttled = 0;
902 priv->dp_throttle_restart = 0;
903
904
905 if (priv->dp_throttle_restart) {
906 port->read_urb->dev = port->serial->dev;
907 ret = usb_submit_urb(port->read_urb, GFP_ATOMIC);
908 }
909
910 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
911
912 if (ret)
913 dev_err(&port->dev,
914 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
915 __func__, ret, priv->dp_port_num);
916}
917
918
919static void digi_set_termios(struct tty_struct *tty,
920 struct usb_serial_port *port, struct ktermios *old_termios)
921{
922 struct digi_port *priv = usb_get_serial_port_data(port);
923 unsigned int iflag = tty->termios->c_iflag;
924 unsigned int cflag = tty->termios->c_cflag;
925 unsigned int old_iflag = old_termios->c_iflag;
926 unsigned int old_cflag = old_termios->c_cflag;
927 unsigned char buf[32];
928 unsigned int modem_signals;
929 int arg, ret;
930 int i = 0;
931 speed_t baud;
932
933 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);
934
935
936 baud = tty_get_baud_rate(tty);
937 if (baud != tty_termios_baud_rate(old_termios)) {
938 arg = -1;
939
940
941 if ((old_cflag&CBAUD) == B0) {
942
943
944 modem_signals = TIOCM_DTR;
945 if (!(tty->termios->c_cflag & CRTSCTS) ||
946 !test_bit(TTY_THROTTLED, &tty->flags))
947 modem_signals |= TIOCM_RTS;
948 digi_set_modem_signals(port, modem_signals, 1);
949 }
950 switch (baud) {
951
952 case 0: digi_set_modem_signals(port, 0, 1); break;
953 case 50: arg = DIGI_BAUD_50; break;
954 case 75: arg = DIGI_BAUD_75; break;
955 case 110: arg = DIGI_BAUD_110; break;
956 case 150: arg = DIGI_BAUD_150; break;
957 case 200: arg = DIGI_BAUD_200; break;
958 case 300: arg = DIGI_BAUD_300; break;
959 case 600: arg = DIGI_BAUD_600; break;
960 case 1200: arg = DIGI_BAUD_1200; break;
961 case 1800: arg = DIGI_BAUD_1800; break;
962 case 2400: arg = DIGI_BAUD_2400; break;
963 case 4800: arg = DIGI_BAUD_4800; break;
964 case 9600: arg = DIGI_BAUD_9600; break;
965 case 19200: arg = DIGI_BAUD_19200; break;
966 case 38400: arg = DIGI_BAUD_38400; break;
967 case 57600: arg = DIGI_BAUD_57600; break;
968 case 115200: arg = DIGI_BAUD_115200; break;
969 case 230400: arg = DIGI_BAUD_230400; break;
970 case 460800: arg = DIGI_BAUD_460800; break;
971 default:
972 arg = DIGI_BAUD_9600;
973 baud = 9600;
974 break;
975 }
976 if (arg != -1) {
977 buf[i++] = DIGI_CMD_SET_BAUD_RATE;
978 buf[i++] = priv->dp_port_num;
979 buf[i++] = arg;
980 buf[i++] = 0;
981 }
982 }
983
984 tty->termios->c_cflag &= ~CMSPAR;
985
986 if ((cflag&(PARENB|PARODD)) != (old_cflag&(PARENB|PARODD))) {
987 if (cflag&PARENB) {
988 if (cflag&PARODD)
989 arg = DIGI_PARITY_ODD;
990 else
991 arg = DIGI_PARITY_EVEN;
992 } else {
993 arg = DIGI_PARITY_NONE;
994 }
995 buf[i++] = DIGI_CMD_SET_PARITY;
996 buf[i++] = priv->dp_port_num;
997 buf[i++] = arg;
998 buf[i++] = 0;
999 }
1000
1001 if ((cflag&CSIZE) != (old_cflag&CSIZE)) {
1002 arg = -1;
1003 switch (cflag&CSIZE) {
1004 case CS5: arg = DIGI_WORD_SIZE_5; break;
1005 case CS6: arg = DIGI_WORD_SIZE_6; break;
1006 case CS7: arg = DIGI_WORD_SIZE_7; break;
1007 case CS8: arg = DIGI_WORD_SIZE_8; break;
1008 default:
1009 dbg("digi_set_termios: can't handle word size %d",
1010 (cflag&CSIZE));
1011 break;
1012 }
1013
1014 if (arg != -1) {
1015 buf[i++] = DIGI_CMD_SET_WORD_SIZE;
1016 buf[i++] = priv->dp_port_num;
1017 buf[i++] = arg;
1018 buf[i++] = 0;
1019 }
1020
1021 }
1022
1023
1024 if ((cflag&CSTOPB) != (old_cflag&CSTOPB)) {
1025
1026 if ((cflag&CSTOPB))
1027 arg = DIGI_STOP_BITS_2;
1028 else
1029 arg = DIGI_STOP_BITS_1;
1030
1031 buf[i++] = DIGI_CMD_SET_STOP_BITS;
1032 buf[i++] = priv->dp_port_num;
1033 buf[i++] = arg;
1034 buf[i++] = 0;
1035
1036 }
1037
1038
1039 if ((iflag&IXOFF) != (old_iflag&IXOFF)
1040 || (cflag&CRTSCTS) != (old_cflag&CRTSCTS)) {
1041 arg = 0;
1042 if (iflag&IXOFF)
1043 arg |= DIGI_INPUT_FLOW_CONTROL_XON_XOFF;
1044 else
1045 arg &= ~DIGI_INPUT_FLOW_CONTROL_XON_XOFF;
1046
1047 if (cflag&CRTSCTS) {
1048 arg |= DIGI_INPUT_FLOW_CONTROL_RTS;
1049
1050
1051
1052 buf[i++] = DIGI_CMD_SET_RTS_SIGNAL;
1053 buf[i++] = priv->dp_port_num;
1054 buf[i++] = DIGI_RTS_ACTIVE;
1055 buf[i++] = 0;
1056
1057 } else {
1058 arg &= ~DIGI_INPUT_FLOW_CONTROL_RTS;
1059 }
1060 buf[i++] = DIGI_CMD_SET_INPUT_FLOW_CONTROL;
1061 buf[i++] = priv->dp_port_num;
1062 buf[i++] = arg;
1063 buf[i++] = 0;
1064 }
1065
1066
1067 if ((iflag & IXON) != (old_iflag & IXON)
1068 || (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
1069 arg = 0;
1070 if (iflag & IXON)
1071 arg |= DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF;
1072 else
1073 arg &= ~DIGI_OUTPUT_FLOW_CONTROL_XON_XOFF;
1074
1075 if (cflag & CRTSCTS) {
1076 arg |= DIGI_OUTPUT_FLOW_CONTROL_CTS;
1077 } else {
1078 arg &= ~DIGI_OUTPUT_FLOW_CONTROL_CTS;
1079 tty->hw_stopped = 0;
1080 }
1081
1082 buf[i++] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL;
1083 buf[i++] = priv->dp_port_num;
1084 buf[i++] = arg;
1085 buf[i++] = 0;
1086 }
1087
1088
1089 if ((cflag & CREAD) != (old_cflag & CREAD)) {
1090 if (cflag & CREAD)
1091 arg = DIGI_ENABLE;
1092 else
1093 arg = DIGI_DISABLE;
1094
1095 buf[i++] = DIGI_CMD_RECEIVE_ENABLE;
1096 buf[i++] = priv->dp_port_num;
1097 buf[i++] = arg;
1098 buf[i++] = 0;
1099 }
1100 ret = digi_write_oob_command(port, buf, i, 1);
1101 if (ret != 0)
1102 dbg("digi_set_termios: write oob failed, ret=%d", ret);
1103 tty_encode_baud_rate(tty, baud, baud);
1104}
1105
1106
1107static void digi_break_ctl(struct tty_struct *tty, int break_state)
1108{
1109 struct usb_serial_port *port = tty->driver_data;
1110 unsigned char buf[4];
1111
1112 buf[0] = DIGI_CMD_BREAK_CONTROL;
1113 buf[1] = 2;
1114 buf[2] = break_state ? 1 : 0;
1115 buf[3] = 0;
1116 digi_write_inb_command(port, buf, 4, 0);
1117}
1118
1119
1120static int digi_tiocmget(struct tty_struct *tty, struct file *file)
1121{
1122 struct usb_serial_port *port = tty->driver_data;
1123 struct digi_port *priv = usb_get_serial_port_data(port);
1124 unsigned int val;
1125 unsigned long flags;
1126
1127 dbg("%s: TOP: port=%d", __func__, priv->dp_port_num);
1128
1129 spin_lock_irqsave(&priv->dp_port_lock, flags);
1130 val = priv->dp_modem_signals;
1131 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1132 return val;
1133}
1134
1135
1136static int digi_tiocmset(struct tty_struct *tty, struct file *file,
1137 unsigned int set, unsigned int clear)
1138{
1139 struct usb_serial_port *port = tty->driver_data;
1140 struct digi_port *priv = usb_get_serial_port_data(port);
1141 unsigned int val;
1142 unsigned long flags;
1143
1144 dbg("%s: TOP: port=%d", __func__, priv->dp_port_num);
1145
1146 spin_lock_irqsave(&priv->dp_port_lock, flags);
1147 val = (priv->dp_modem_signals & ~clear) | set;
1148 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1149 return digi_set_modem_signals(port, val, 1);
1150}
1151
1152
1153static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
1154 const unsigned char *buf, int count)
1155{
1156
1157 int ret, data_len, new_len;
1158 struct digi_port *priv = usb_get_serial_port_data(port);
1159 unsigned char *data = port->write_urb->transfer_buffer;
1160 unsigned long flags = 0;
1161
1162 dbg("digi_write: TOP: port=%d, count=%d, in_interrupt=%ld",
1163 priv->dp_port_num, count, in_interrupt());
1164
1165
1166 count = min(count, port->bulk_out_size-2);
1167 count = min(64, count);
1168
1169
1170
1171
1172 spin_lock_irqsave(&priv->dp_port_lock, flags);
1173
1174
1175 if (port->write_urb->status == -EINPROGRESS ||
1176 priv->dp_write_urb_in_use) {
1177
1178 if (count == 1 && priv->dp_out_buf_len < DIGI_OUT_BUF_SIZE) {
1179 priv->dp_out_buf[priv->dp_out_buf_len++] = *buf;
1180 new_len = 1;
1181 } else {
1182 new_len = 0;
1183 }
1184 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1185 return new_len;
1186 }
1187
1188
1189
1190 new_len = min(count, port->bulk_out_size-2-priv->dp_out_buf_len);
1191 data_len = new_len + priv->dp_out_buf_len;
1192
1193 if (data_len == 0) {
1194 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1195 return 0;
1196 }
1197
1198 port->write_urb->transfer_buffer_length = data_len+2;
1199 port->write_urb->dev = port->serial->dev;
1200
1201 *data++ = DIGI_CMD_SEND_DATA;
1202 *data++ = data_len;
1203
1204
1205 memcpy(data, priv->dp_out_buf, priv->dp_out_buf_len);
1206 data += priv->dp_out_buf_len;
1207
1208
1209 memcpy(data, buf, new_len);
1210
1211 ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1212 if (ret == 0) {
1213 priv->dp_write_urb_in_use = 1;
1214 ret = new_len;
1215 priv->dp_out_buf_len = 0;
1216 }
1217
1218
1219 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1220 if (ret < 0)
1221 dev_err(&port->dev,
1222 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
1223 __func__, ret, priv->dp_port_num);
1224 dbg("digi_write: returning %d", ret);
1225 return ret;
1226
1227}
1228
1229static void digi_write_bulk_callback(struct urb *urb)
1230{
1231
1232 struct usb_serial_port *port = urb->context;
1233 struct usb_serial *serial;
1234 struct digi_port *priv;
1235 struct digi_serial *serial_priv;
1236 int ret = 0;
1237 int status = urb->status;
1238
1239 dbg("digi_write_bulk_callback: TOP, urb->status=%d", status);
1240
1241
1242 if (port == NULL || (priv = usb_get_serial_port_data(port)) == NULL) {
1243 dev_err(&port->dev,
1244 "%s: port or port->private is NULL, status=%d\n",
1245 __func__, status);
1246 return;
1247 }
1248 serial = port->serial;
1249 if (serial == NULL || (serial_priv = usb_get_serial_data(serial)) == NULL) {
1250 dev_err(&port->dev,
1251 "%s: serial or serial->private is NULL, status=%d\n",
1252 __func__, status);
1253 return;
1254 }
1255
1256
1257 if (priv->dp_port_num == serial_priv->ds_oob_port_num) {
1258 dbg("digi_write_bulk_callback: oob callback");
1259 spin_lock(&priv->dp_port_lock);
1260 priv->dp_write_urb_in_use = 0;
1261 wake_up_interruptible(&port->write_wait);
1262 spin_unlock(&priv->dp_port_lock);
1263 return;
1264 }
1265
1266
1267 spin_lock(&priv->dp_port_lock);
1268 priv->dp_write_urb_in_use = 0;
1269 if (port->port.count && port->write_urb->status != -EINPROGRESS
1270 && priv->dp_out_buf_len > 0) {
1271 *((unsigned char *)(port->write_urb->transfer_buffer))
1272 = (unsigned char)DIGI_CMD_SEND_DATA;
1273 *((unsigned char *)(port->write_urb->transfer_buffer) + 1)
1274 = (unsigned char)priv->dp_out_buf_len;
1275 port->write_urb->transfer_buffer_length =
1276 priv->dp_out_buf_len + 2;
1277 port->write_urb->dev = serial->dev;
1278 memcpy(port->write_urb->transfer_buffer + 2, priv->dp_out_buf,
1279 priv->dp_out_buf_len);
1280 ret = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1281 if (ret == 0) {
1282 priv->dp_write_urb_in_use = 1;
1283 priv->dp_out_buf_len = 0;
1284 }
1285 }
1286
1287 digi_wakeup_write(port);
1288
1289
1290 schedule_work(&priv->dp_wakeup_work);
1291
1292 spin_unlock(&priv->dp_port_lock);
1293 if (ret)
1294 dev_err(&port->dev,
1295 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
1296 __func__, ret, priv->dp_port_num);
1297}
1298
1299static int digi_write_room(struct tty_struct *tty)
1300{
1301 struct usb_serial_port *port = tty->driver_data;
1302 struct digi_port *priv = usb_get_serial_port_data(port);
1303 int room;
1304 unsigned long flags = 0;
1305
1306 spin_lock_irqsave(&priv->dp_port_lock, flags);
1307
1308 if (port->write_urb->status == -EINPROGRESS ||
1309 priv->dp_write_urb_in_use)
1310 room = 0;
1311 else
1312 room = port->bulk_out_size - 2 - priv->dp_out_buf_len;
1313
1314 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1315 dbg("digi_write_room: port=%d, room=%d", priv->dp_port_num, room);
1316 return room;
1317
1318}
1319
1320static int digi_chars_in_buffer(struct tty_struct *tty)
1321{
1322 struct usb_serial_port *port = tty->driver_data;
1323 struct digi_port *priv = usb_get_serial_port_data(port);
1324
1325 if (port->write_urb->status == -EINPROGRESS
1326 || priv->dp_write_urb_in_use) {
1327 dbg("digi_chars_in_buffer: port=%d, chars=%d",
1328 priv->dp_port_num, port->bulk_out_size - 2);
1329
1330 return 256;
1331 } else {
1332 dbg("digi_chars_in_buffer: port=%d, chars=%d",
1333 priv->dp_port_num, priv->dp_out_buf_len);
1334 return priv->dp_out_buf_len;
1335 }
1336
1337}
1338
1339
1340static int digi_open(struct tty_struct *tty, struct usb_serial_port *port,
1341 struct file *filp)
1342{
1343 int ret;
1344 unsigned char buf[32];
1345 struct digi_port *priv = usb_get_serial_port_data(port);
1346 struct ktermios not_termios;
1347 unsigned long flags = 0;
1348
1349 dbg("digi_open: TOP: port=%d, open_count=%d",
1350 priv->dp_port_num, port->port.count);
1351
1352
1353 if (digi_startup_device(port->serial) != 0)
1354 return -ENXIO;
1355
1356 spin_lock_irqsave(&priv->dp_port_lock, flags);
1357
1358
1359 if (priv->dp_in_close && (filp->f_flags&(O_NDELAY|O_NONBLOCK)) == 0) {
1360 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1361 return -EAGAIN;
1362 }
1363
1364
1365 while (priv->dp_in_close) {
1366 cond_wait_interruptible_timeout_irqrestore(
1367 &priv->dp_close_wait, DIGI_RETRY_TIMEOUT,
1368 &priv->dp_port_lock, flags);
1369 if (signal_pending(current))
1370 return -EINTR;
1371 spin_lock_irqsave(&priv->dp_port_lock, flags);
1372 }
1373
1374 spin_unlock_irqrestore(&priv->dp_port_lock, flags);
1375
1376
1377 buf[0] = DIGI_CMD_READ_INPUT_SIGNALS;
1378 buf[1] = priv->dp_port_num;
1379 buf[2] = DIGI_ENABLE;
1380 buf[3] = 0;
1381
1382
1383 buf[4] = DIGI_CMD_IFLUSH_FIFO;
1384 buf[5] = priv->dp_port_num;
1385 buf[6] = DIGI_FLUSH_TX | DIGI_FLUSH_RX;
1386 buf[7] = 0;
1387
1388 ret = digi_write_oob_command(port, buf, 8, 1);
1389 if (ret != 0)
1390 dbg("digi_open: write oob failed, ret=%d", ret);
1391
1392
1393 if (tty) {
1394 not_termios.c_cflag = ~tty->termios->c_cflag;
1395 not_termios.c_iflag = ~tty->termios->c_iflag;
1396 digi_set_termios(tty, port, ¬_termios);
1397 }
1398
1399
1400 digi_set_modem_signals(port, TIOCM_DTR|TIOCM_RTS, 1);
1401
1402 return 0;
1403}
1404
1405
1406static void digi_close(struct tty_struct *tty, struct usb_serial_port *port,
1407 struct file *filp)
1408{
1409 DEFINE_WAIT(wait);
1410 int ret;
1411 unsigned char buf[32];
1412 struct digi_port *priv = usb_get_serial_port_data(port);
1413
1414 dbg("digi_close: TOP: port=%d, open_count=%d",
1415 priv->dp_port_num, port->port.count);
1416
1417 mutex_lock(&port->serial->disc_mutex);
1418
1419 if (port->serial->disconnected)
1420 goto exit;
1421
1422
1423 spin_lock_irq(&priv->dp_port_lock);
1424 priv->dp_in_close = 1;
1425 spin_unlock_irq(&priv->dp_port_lock);
1426
1427
1428 tty->closing = 1;
1429
1430
1431 if ((filp->f_flags&(O_NDELAY|O_NONBLOCK)) == 0)
1432 tty_wait_until_sent(tty, DIGI_CLOSE_TIMEOUT);
1433
1434
1435 tty_driver_flush_buffer(tty);
1436 tty_ldisc_flush(tty);
1437
1438 if (port->serial->dev) {
1439
1440 if ((filp->f_flags&(O_NDELAY|O_NONBLOCK)) == 0)
1441 digi_transmit_idle(port, DIGI_CLOSE_TIMEOUT);
1442
1443 digi_set_modem_signals(port, 0, 0);
1444
1445
1446 buf[0] = DIGI_CMD_SET_INPUT_FLOW_CONTROL;
1447 buf[1] = priv->dp_port_num;
1448 buf[2] = DIGI_DISABLE;
1449 buf[3] = 0;
1450
1451
1452 buf[4] = DIGI_CMD_SET_OUTPUT_FLOW_CONTROL;
1453 buf[5] = priv->dp_port_num;
1454 buf[6] = DIGI_DISABLE;
1455 buf[7] = 0;
1456
1457
1458 buf[8] = DIGI_CMD_READ_INPUT_SIGNALS;
1459 buf[9] = priv->dp_port_num;
1460 buf[10] = DIGI_DISABLE;
1461 buf[11] = 0;
1462
1463
1464 buf[12] = DIGI_CMD_RECEIVE_ENABLE;
1465 buf[13] = priv->dp_port_num;
1466 buf[14] = DIGI_DISABLE;
1467 buf[15] = 0;
1468
1469
1470 buf[16] = DIGI_CMD_IFLUSH_FIFO;
1471 buf[17] = priv->dp_port_num;
1472 buf[18] = DIGI_FLUSH_TX | DIGI_FLUSH_RX;
1473 buf[19] = 0;
1474
1475 ret = digi_write_oob_command(port, buf, 20, 0);
1476 if (ret != 0)
1477 dbg("digi_close: write oob failed, ret=%d", ret);
1478
1479
1480 prepare_to_wait(&priv->dp_flush_wait, &wait,
1481 TASK_INTERRUPTIBLE);
1482 schedule_timeout(DIGI_CLOSE_TIMEOUT);
1483 finish_wait(&priv->dp_flush_wait, &wait);
1484
1485
1486 usb_kill_urb(port->write_urb);
1487 }
1488 tty->closing = 0;
1489exit:
1490 spin_lock_irq(&priv->dp_port_lock);
1491 priv->dp_write_urb_in_use = 0;
1492 priv->dp_in_close = 0;
1493 wake_up_interruptible(&priv->dp_close_wait);
1494 spin_unlock_irq(&priv->dp_port_lock);
1495 mutex_unlock(&port->serial->disc_mutex);
1496 dbg("digi_close: done");
1497}
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507static int digi_startup_device(struct usb_serial *serial)
1508{
1509 int i, ret = 0;
1510 struct digi_serial *serial_priv = usb_get_serial_data(serial);
1511 struct usb_serial_port *port;
1512
1513
1514 spin_lock(&serial_priv->ds_serial_lock);
1515 if (serial_priv->ds_device_started) {
1516 spin_unlock(&serial_priv->ds_serial_lock);
1517 return 0;
1518 }
1519 serial_priv->ds_device_started = 1;
1520 spin_unlock(&serial_priv->ds_serial_lock);
1521
1522
1523
1524 for (i = 0; i < serial->type->num_ports + 1; i++) {
1525 port = serial->port[i];
1526 port->write_urb->dev = port->serial->dev;
1527 ret = usb_submit_urb(port->read_urb, GFP_KERNEL);
1528 if (ret != 0) {
1529 dev_err(&port->dev,
1530 "%s: usb_submit_urb failed, ret=%d, port=%d\n",
1531 __func__, ret, i);
1532 break;
1533 }
1534 }
1535 return ret;
1536}
1537
1538
1539static int digi_startup(struct usb_serial *serial)
1540{
1541
1542 int i;
1543 struct digi_port *priv;
1544 struct digi_serial *serial_priv;
1545
1546 dbg("digi_startup: TOP");
1547
1548
1549
1550 for (i = 0; i < serial->type->num_ports + 1; i++) {
1551
1552 priv = kmalloc(sizeof(struct digi_port), GFP_KERNEL);
1553 if (priv == NULL) {
1554 while (--i >= 0)
1555 kfree(usb_get_serial_port_data(serial->port[i]));
1556 return 1;
1557 }
1558
1559
1560 spin_lock_init(&priv->dp_port_lock);
1561 priv->dp_port_num = i;
1562 priv->dp_out_buf_len = 0;
1563 priv->dp_write_urb_in_use = 0;
1564 priv->dp_modem_signals = 0;
1565 init_waitqueue_head(&priv->dp_modem_change_wait);
1566 priv->dp_transmit_idle = 0;
1567 init_waitqueue_head(&priv->dp_transmit_idle_wait);
1568 priv->dp_throttled = 0;
1569 priv->dp_throttle_restart = 0;
1570 init_waitqueue_head(&priv->dp_flush_wait);
1571 priv->dp_in_close = 0;
1572 init_waitqueue_head(&priv->dp_close_wait);
1573 INIT_WORK(&priv->dp_wakeup_work, digi_wakeup_write_lock);
1574 priv->dp_port = serial->port[i];
1575
1576 init_waitqueue_head(&serial->port[i]->write_wait);
1577
1578 usb_set_serial_port_data(serial->port[i], priv);
1579 }
1580
1581
1582 serial_priv = kmalloc(sizeof(struct digi_serial), GFP_KERNEL);
1583 if (serial_priv == NULL) {
1584 for (i = 0; i < serial->type->num_ports + 1; i++)
1585 kfree(usb_get_serial_port_data(serial->port[i]));
1586 return 1;
1587 }
1588
1589
1590 spin_lock_init(&serial_priv->ds_serial_lock);
1591 serial_priv->ds_oob_port_num = serial->type->num_ports;
1592 serial_priv->ds_oob_port = serial->port[serial_priv->ds_oob_port_num];
1593 serial_priv->ds_device_started = 0;
1594 usb_set_serial_data(serial, serial_priv);
1595
1596 return 0;
1597}
1598
1599
1600static void digi_shutdown(struct usb_serial *serial)
1601{
1602 int i;
1603 dbg("digi_shutdown: TOP, in_interrupt()=%ld", in_interrupt());
1604
1605
1606 for (i = 0; i < serial->type->num_ports + 1; i++) {
1607 usb_kill_urb(serial->port[i]->read_urb);
1608 usb_kill_urb(serial->port[i]->write_urb);
1609 }
1610
1611
1612
1613 for (i = 0; i < serial->type->num_ports + 1; i++)
1614 kfree(usb_get_serial_port_data(serial->port[i]));
1615 kfree(usb_get_serial_data(serial));
1616}
1617
1618
1619static void digi_read_bulk_callback(struct urb *urb)
1620{
1621 struct usb_serial_port *port = urb->context;
1622 struct digi_port *priv;
1623 struct digi_serial *serial_priv;
1624 int ret;
1625 int status = urb->status;
1626
1627 dbg("digi_read_bulk_callback: TOP");
1628
1629
1630 if (port == NULL)
1631 return;
1632 priv = usb_get_serial_port_data(port);
1633 if (priv == NULL) {
1634 dev_err(&port->dev, "%s: port->private is NULL, status=%d\n",
1635 __func__, status);
1636 return;
1637 }
1638 if (port->serial == NULL ||
1639 (serial_priv = usb_get_serial_data(port->serial)) == NULL) {
1640 dev_err(&port->dev, "%s: serial is bad or serial->private "
1641 "is NULL, status=%d\n", __func__, status);
1642 return;
1643 }
1644
1645
1646 if (status) {
1647 dev_err(&port->dev,
1648 "%s: nonzero read bulk status: status=%d, port=%d\n",
1649 __func__, status, priv->dp_port_num);
1650 return;
1651 }
1652
1653
1654 if (priv->dp_port_num == serial_priv->ds_oob_port_num) {
1655 if (digi_read_oob_callback(urb) != 0)
1656 return;
1657 } else {
1658 if (digi_read_inb_callback(urb) != 0)
1659 return;
1660 }
1661
1662
1663 urb->dev = port->serial->dev;
1664 ret = usb_submit_urb(urb, GFP_ATOMIC);
1665 if (ret != 0) {
1666 dev_err(&port->dev,
1667 "%s: failed resubmitting urb, ret=%d, port=%d\n",
1668 __func__, ret, priv->dp_port_num);
1669 }
1670
1671}
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683static int digi_read_inb_callback(struct urb *urb)
1684{
1685
1686 struct usb_serial_port *port = urb->context;
1687 struct tty_struct *tty;
1688 struct digi_port *priv = usb_get_serial_port_data(port);
1689 int opcode = ((unsigned char *)urb->transfer_buffer)[0];
1690 int len = ((unsigned char *)urb->transfer_buffer)[1];
1691 int port_status = ((unsigned char *)urb->transfer_buffer)[2];
1692 unsigned char *data = ((unsigned char *)urb->transfer_buffer) + 3;
1693 int flag, throttled;
1694 int i;
1695 int status = urb->status;
1696
1697
1698
1699 if (port->port.count == 0)
1700 return 0;
1701
1702
1703 if (urb->actual_length != len + 2) {
1704 dev_err(&port->dev, "%s: INCOMPLETE OR MULTIPLE PACKET, "
1705 "urb->status=%d, port=%d, opcode=%d, len=%d, "
1706 "actual_length=%d, status=%d\n", __func__, status,
1707 priv->dp_port_num, opcode, len, urb->actual_length,
1708 port_status);
1709 return -1;
1710 }
1711
1712 tty = tty_port_tty_get(&port->port);
1713 spin_lock(&priv->dp_port_lock);
1714
1715
1716
1717 throttled = priv->dp_throttled;
1718 if (throttled)
1719 priv->dp_throttle_restart = 1;
1720
1721
1722 if (opcode == DIGI_CMD_RECEIVE_DATA) {
1723
1724 flag = 0;
1725
1726
1727 if (port_status & DIGI_OVERRUN_ERROR)
1728 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1729
1730
1731
1732 if (port_status & DIGI_BREAK_ERROR)
1733 flag = TTY_BREAK;
1734 else if (port_status & DIGI_PARITY_ERROR)
1735 flag = TTY_PARITY;
1736 else if (port_status & DIGI_FRAMING_ERROR)
1737 flag = TTY_FRAME;
1738
1739
1740 --len;
1741
1742 len = tty_buffer_request_room(tty, len);
1743 if (len > 0) {
1744
1745 if (flag == TTY_NORMAL)
1746 tty_insert_flip_string(tty, data, len);
1747 else {
1748 for (i = 0; i < len; i++)
1749 tty_insert_flip_char(tty,
1750 data[i], flag);
1751 }
1752 tty_flip_buffer_push(tty);
1753 }
1754 }
1755 spin_unlock(&priv->dp_port_lock);
1756 tty_kref_put(tty);
1757
1758 if (opcode == DIGI_CMD_RECEIVE_DISABLE)
1759 dbg("%s: got RECEIVE_DISABLE", __func__);
1760 else if (opcode != DIGI_CMD_RECEIVE_DATA)
1761 dbg("%s: unknown opcode: %d", __func__, opcode);
1762
1763 return throttled ? 1 : 0;
1764
1765}
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777static int digi_read_oob_callback(struct urb *urb)
1778{
1779
1780 struct usb_serial_port *port = urb->context;
1781 struct usb_serial *serial = port->serial;
1782 struct tty_struct *tty;
1783 struct digi_port *priv = usb_get_serial_port_data(port);
1784 int opcode, line, status, val;
1785 int i;
1786 unsigned int rts;
1787
1788 dbg("digi_read_oob_callback: port=%d, len=%d",
1789 priv->dp_port_num, urb->actual_length);
1790
1791
1792 for (i = 0; i < urb->actual_length - 3;) {
1793 opcode = ((unsigned char *)urb->transfer_buffer)[i++];
1794 line = ((unsigned char *)urb->transfer_buffer)[i++];
1795 status = ((unsigned char *)urb->transfer_buffer)[i++];
1796 val = ((unsigned char *)urb->transfer_buffer)[i++];
1797
1798 dbg("digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d",
1799 opcode, line, status, val);
1800
1801 if (status != 0 || line >= serial->type->num_ports)
1802 continue;
1803
1804 port = serial->port[line];
1805
1806 priv = usb_get_serial_port_data(port);
1807 if (priv == NULL)
1808 return -1;
1809
1810 tty = tty_port_tty_get(&port->port);
1811 rts = 0;
1812 if (port->port.count)
1813 rts = tty->termios->c_cflag & CRTSCTS;
1814
1815 if (opcode == DIGI_CMD_READ_INPUT_SIGNALS) {
1816 spin_lock(&priv->dp_port_lock);
1817
1818 if (val & DIGI_READ_INPUT_SIGNALS_CTS) {
1819 priv->dp_modem_signals |= TIOCM_CTS;
1820
1821 if (rts) {
1822 tty->hw_stopped = 0;
1823 digi_wakeup_write(port);
1824 }
1825 } else {
1826 priv->dp_modem_signals &= ~TIOCM_CTS;
1827
1828 if (rts)
1829 tty->hw_stopped = 1;
1830 }
1831 if (val & DIGI_READ_INPUT_SIGNALS_DSR)
1832 priv->dp_modem_signals |= TIOCM_DSR;
1833 else
1834 priv->dp_modem_signals &= ~TIOCM_DSR;
1835 if (val & DIGI_READ_INPUT_SIGNALS_RI)
1836 priv->dp_modem_signals |= TIOCM_RI;
1837 else
1838 priv->dp_modem_signals &= ~TIOCM_RI;
1839 if (val & DIGI_READ_INPUT_SIGNALS_DCD)
1840 priv->dp_modem_signals |= TIOCM_CD;
1841 else
1842 priv->dp_modem_signals &= ~TIOCM_CD;
1843
1844 wake_up_interruptible(&priv->dp_modem_change_wait);
1845 spin_unlock(&priv->dp_port_lock);
1846 } else if (opcode == DIGI_CMD_TRANSMIT_IDLE) {
1847 spin_lock(&priv->dp_port_lock);
1848 priv->dp_transmit_idle = 1;
1849 wake_up_interruptible(&priv->dp_transmit_idle_wait);
1850 spin_unlock(&priv->dp_port_lock);
1851 } else if (opcode == DIGI_CMD_IFLUSH_FIFO) {
1852 wake_up_interruptible(&priv->dp_flush_wait);
1853 }
1854 tty_kref_put(tty);
1855 }
1856 return 0;
1857
1858}
1859
1860static int __init digi_init(void)
1861{
1862 int retval;
1863 retval = usb_serial_register(&digi_acceleport_2_device);
1864 if (retval)
1865 goto failed_acceleport_2_device;
1866 retval = usb_serial_register(&digi_acceleport_4_device);
1867 if (retval)
1868 goto failed_acceleport_4_device;
1869 retval = usb_register(&digi_driver);
1870 if (retval)
1871 goto failed_usb_register;
1872 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
1873 DRIVER_DESC "\n");
1874 return 0;
1875failed_usb_register:
1876 usb_serial_deregister(&digi_acceleport_4_device);
1877failed_acceleport_4_device:
1878 usb_serial_deregister(&digi_acceleport_2_device);
1879failed_acceleport_2_device:
1880 return retval;
1881}
1882
1883static void __exit digi_exit (void)
1884{
1885 usb_deregister(&digi_driver);
1886 usb_serial_deregister(&digi_acceleport_2_device);
1887 usb_serial_deregister(&digi_acceleport_4_device);
1888}
1889
1890
1891module_init(digi_init);
1892module_exit(digi_exit);
1893
1894
1895MODULE_AUTHOR(DRIVER_AUTHOR);
1896MODULE_DESCRIPTION(DRIVER_DESC);
1897MODULE_LICENSE("GPL");
1898
1899module_param(debug, bool, S_IRUGO | S_IWUSR);
1900MODULE_PARM_DESC(debug, "Debug enabled or not");