1
2
3
4
5
6
7#include <linux/errno.h>
8#include <linux/init.h>
9#include <linux/slab.h>
10#include <linux/tty.h>
11#include <linux/tty_driver.h>
12#include <linux/tty_flip.h>
13#include <linux/module.h>
14#include <linux/serial.h>
15#include <linux/usb.h>
16#include <linux/usb/serial.h>
17#include <linux/uaccess.h>
18
19
20#define DRIVER_VERSION "v2.14"
21#define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
22#define DRIVER_DESC "Quatech USB to Serial Driver"
23
24#define USB_VENDOR_ID_QUATECH 0x061d
25#define QUATECH_SSU200 0xC030
26#define QUATECH_DSU100 0xC040
27#define QUATECH_DSU200 0xC050
28#define QUATECH_QSU100 0xC060
29#define QUATECH_QSU200 0xC070
30#define QUATECH_ESU100A 0xC080
31#define QUATECH_ESU100B 0xC081
32#define QUATECH_ESU200A 0xC0A0
33#define QUATECH_ESU200B 0xC0A1
34#define QUATECH_HSU100A 0xC090
35#define QUATECH_HSU100B 0xC091
36#define QUATECH_HSU100C 0xC092
37#define QUATECH_HSU100D 0xC093
38#define QUATECH_HSU200A 0xC0B0
39#define QUATECH_HSU200B 0xC0B1
40#define QUATECH_HSU200C 0xC0B2
41#define QUATECH_HSU200D 0xC0B3
42
43#define QT_SET_GET_DEVICE 0xc2
44#define QT_OPEN_CLOSE_CHANNEL 0xca
45#define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
46#define QT_SET_ATF 0xcd
47#define QT_GET_SET_REGISTER 0xc0
48#define QT_GET_SET_UART 0xc1
49#define QT_HW_FLOW_CONTROL_MASK 0xc5
50#define QT_SW_FLOW_CONTROL_MASK 0xc6
51#define QT_SW_FLOW_CONTROL_DISABLE 0xc7
52#define QT_BREAK_CONTROL 0xc8
53
54#define USBD_TRANSFER_DIRECTION_IN 0xc0
55#define USBD_TRANSFER_DIRECTION_OUT 0x40
56
57#define MAX_BAUD_RATE 460800
58#define MAX_BAUD_REMAINDER 4608
59
60#define DIV_LATCH_LS 0x00
61#define XMT_HOLD_REGISTER 0x00
62#define XVR_BUFFER_REGISTER 0x00
63#define DIV_LATCH_MS 0x01
64#define FIFO_CONTROL_REGISTER 0x02
65#define LINE_CONTROL_REGISTER 0x03
66#define MODEM_CONTROL_REGISTER 0x04
67#define LINE_STATUS_REGISTER 0x05
68#define MODEM_STATUS_REGISTER 0x06
69
70#define SERIAL_MCR_DTR 0x01
71#define SERIAL_MCR_RTS 0x02
72#define SERIAL_MCR_LOOP 0x10
73
74#define SERIAL_MSR_CTS 0x10
75#define SERIAL_MSR_CD 0x80
76#define SERIAL_MSR_RI 0x40
77#define SERIAL_MSR_DSR 0x20
78#define SERIAL_MSR_MASK 0xf0
79
80#define SERIAL_8_DATA 0x03
81#define SERIAL_7_DATA 0x02
82#define SERIAL_6_DATA 0x01
83#define SERIAL_5_DATA 0x00
84
85#define SERIAL_ODD_PARITY 0X08
86#define SERIAL_EVEN_PARITY 0X18
87#define SERIAL_TWO_STOPB 0x04
88#define SERIAL_ONE_STOPB 0x00
89
90#define DEFAULT_DIVISOR 0x30
91#define DEFAULT_LCR SERIAL_8_DATA
92
93#define FULLPWRBIT 0x00000080
94#define NEXT_BOARD_POWER_BIT 0x00000004
95
96#define SERIAL_LSR_OE 0x02
97#define SERIAL_LSR_PE 0x04
98#define SERIAL_LSR_FE 0x08
99#define SERIAL_LSR_BI 0x10
100
101#define SERIAL_MSR_CTS 0x10
102#define SERIAL_MSR_CD 0x80
103#define SERIAL_MSR_RI 0x40
104#define SERIAL_MSR_DSR 0x20
105#define SERIAL_MSR_MASK 0xf0
106
107#define PREFUFF_LEVEL_CONSERVATIVE 128
108#define ATC_DISABLED 0x0
109
110#define RR_BITS 0x03
111#define DUPMODE_BITS 0xc0
112#define CLKS_X4 0x02
113
114#define LOOPMODE_BITS 0x41
115#define ALL_LOOPBACK 0x01
116#define MODEM_CTRL 0x40
117#define RS232_MODE 0x00
118
119static const struct usb_device_id id_table[] = {
120 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU200)},
121 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU100)},
122 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU200)},
123 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU100)},
124 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU200)},
125 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100A)},
126 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100B)},
127 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200A)},
128 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200B)},
129 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100A)},
130 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100B)},
131 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100C)},
132 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100D)},
133 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200A)},
134 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200B)},
135 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200C)},
136 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200D)},
137 {}
138};
139MODULE_DEVICE_TABLE(usb, id_table);
140
141struct qt_get_device_data {
142 __u8 porta;
143 __u8 portb;
144 __u8 portc;
145};
146
147struct qt_open_channel_data {
148 __u8 line_status;
149 __u8 modem_status;
150};
151
152struct quatech_port {
153 int port_num;
154 struct urb *write_urb;
155 struct urb *read_urb;
156 struct urb *int_urb;
157
158 __u8 shadowLCR;
159 __u8 shadowMCR;
160 __u8 shadowMSR;
161 __u8 shadowLSR;
162 char open_ports;
163
164
165 wait_queue_head_t msr_wait;
166 char prev_status, diff_status;
167
168 wait_queue_head_t wait;
169
170 struct async_icount icount;
171
172 struct usb_serial_port *port;
173 struct qt_get_device_data DeviceData;
174 struct mutex lock;
175 bool read_urb_busy;
176 int RxHolding;
177 int ReadBulkStopped;
178 char closePending;
179};
180
181static int port_paranoia_check(struct usb_serial_port *port,
182 const char *function)
183{
184 if (!port) {
185 pr_debug("%s - port == NULL", function);
186 return -1;
187 }
188 if (!port->serial) {
189 pr_debug("%s - port->serial == NULL\n", function);
190 return -1;
191 }
192
193 return 0;
194}
195
196static int serial_paranoia_check(struct usb_serial *serial,
197 const char *function)
198{
199 if (!serial) {
200 pr_debug("%s - serial == NULL\n", function);
201 return -1;
202 }
203
204 if (!serial->type) {
205 pr_debug("%s - serial->type == NULL!", function);
206 return -1;
207 }
208
209 return 0;
210}
211
212static inline struct quatech_port *qt_get_port_private(struct usb_serial_port
213 *port)
214{
215 return (struct quatech_port *)usb_get_serial_port_data(port);
216}
217
218static inline void qt_set_port_private(struct usb_serial_port *port,
219 struct quatech_port *data)
220{
221 usb_set_serial_port_data(port, (void *)data);
222}
223
224static struct usb_serial *get_usb_serial(struct usb_serial_port *port,
225 const char *function)
226{
227
228 if (!port ||
229 port_paranoia_check(port, function) ||
230 serial_paranoia_check(port->serial, function)) {
231
232
233
234
235 return NULL;
236 }
237
238 return port->serial;
239}
240
241static void ProcessLineStatus(struct quatech_port *qt_port,
242 unsigned char line_status)
243{
244
245 qt_port->shadowLSR =
246 line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE |
247 SERIAL_LSR_BI);
248}
249
250static void ProcessModemStatus(struct quatech_port *qt_port,
251 unsigned char modem_status)
252{
253
254 qt_port->shadowMSR = modem_status;
255 wake_up_interruptible(&qt_port->wait);
256}
257
258static void ProcessRxChar(struct usb_serial_port *port, unsigned char data)
259{
260 struct urb *urb = port->read_urb;
261 if (urb->actual_length)
262 tty_insert_flip_char(&port->port, data, TTY_NORMAL);
263}
264
265static void qt_write_bulk_callback(struct urb *urb)
266{
267 struct tty_struct *tty;
268 int status;
269 struct quatech_port *quatech_port;
270
271 status = urb->status;
272
273 if (status) {
274 dev_dbg(&urb->dev->dev,
275 "nonzero write bulk status received:%d\n", status);
276 return;
277 }
278
279 quatech_port = urb->context;
280
281 tty = tty_port_tty_get(&quatech_port->port->port);
282
283 if (tty)
284 tty_wakeup(tty);
285 tty_kref_put(tty);
286}
287
288static void qt_interrupt_callback(struct urb *urb)
289{
290
291}
292
293static void qt_status_change_check(struct urb *urb,
294 struct quatech_port *qt_port,
295 struct usb_serial_port *port)
296{
297 int flag, i;
298 unsigned char *data = urb->transfer_buffer;
299 unsigned int RxCount = urb->actual_length;
300
301 for (i = 0; i < RxCount; ++i) {
302
303 if ((i <= (RxCount - 3)) && (data[i] == 0x1b)
304 && (data[i + 1] == 0x1b)) {
305 flag = 0;
306 switch (data[i + 2]) {
307 case 0x00:
308 if (i > (RxCount - 4)) {
309 dev_dbg(&port->dev,
310 "Illegal escape seuences in received data\n");
311 break;
312 }
313
314 ProcessLineStatus(qt_port, data[i + 3]);
315
316 i += 3;
317 flag = 1;
318 break;
319
320 case 0x01:
321 if (i > (RxCount - 4)) {
322 dev_dbg(&port->dev,
323 "Illegal escape seuences in received data\n");
324 break;
325 }
326
327 ProcessModemStatus(qt_port, data[i + 3]);
328
329 i += 3;
330 flag = 1;
331 break;
332
333 case 0xff:
334 dev_dbg(&port->dev, "No status sequence.\n");
335
336 ProcessRxChar(port, data[i]);
337 ProcessRxChar(port, data[i + 1]);
338
339 i += 2;
340 break;
341 }
342 if (flag == 1)
343 continue;
344 }
345
346 if (urb->actual_length)
347 tty_insert_flip_char(&port->port, data[i], TTY_NORMAL);
348
349 }
350 tty_flip_buffer_push(&port->port);
351}
352
353static void qt_read_bulk_callback(struct urb *urb)
354{
355
356 struct usb_serial_port *port = urb->context;
357 struct usb_serial *serial = get_usb_serial(port, __func__);
358 struct quatech_port *qt_port = qt_get_port_private(port);
359 int result;
360
361 if (urb->status) {
362 qt_port->ReadBulkStopped = 1;
363 dev_dbg(&urb->dev->dev,
364 "%s - nonzero write bulk status received: %d\n",
365 __func__, urb->status);
366 return;
367 }
368
369 dev_dbg(&port->dev,
370 "%s - port->RxHolding = %d\n", __func__, qt_port->RxHolding);
371
372 if (port_paranoia_check(port, __func__) != 0) {
373 qt_port->ReadBulkStopped = 1;
374 return;
375 }
376
377 if (!serial)
378 return;
379
380 if (qt_port->closePending == 1) {
381
382 dev_dbg(&port->dev,
383 "%s - (qt_port->closepending == 1\n", __func__);
384 qt_port->ReadBulkStopped = 1;
385 return;
386 }
387
388
389
390
391
392
393 if (qt_port->RxHolding == 1) {
394 qt_port->ReadBulkStopped = 1;
395 return;
396 }
397
398 if (urb->status) {
399 qt_port->ReadBulkStopped = 1;
400
401 dev_dbg(&port->dev,
402 "%s - nonzero read bulk status received: %d\n",
403 __func__, urb->status);
404 return;
405 }
406
407 if (urb->actual_length)
408 qt_status_change_check(urb, qt_port, port);
409
410
411 usb_fill_bulk_urb(port->read_urb, serial->dev,
412 usb_rcvbulkpipe(serial->dev,
413 port->bulk_in_endpointAddress),
414 port->read_urb->transfer_buffer,
415 port->read_urb->transfer_buffer_length,
416 qt_read_bulk_callback, port);
417 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
418 if (result)
419 dev_dbg(&port->dev,
420 "%s - failed resubmitting read urb, error %d",
421 __func__, result);
422 else {
423 if (urb->actual_length) {
424 tty_flip_buffer_push(&port->port);
425 tty_schedule_flip(&port->port);
426 }
427 }
428
429 schedule_work(&port->work);
430}
431
432
433
434
435
436
437
438
439static int qt_get_device(struct usb_serial *serial,
440 struct qt_get_device_data *device_data)
441{
442 int result;
443 unsigned char *transfer_buffer;
444
445 transfer_buffer =
446 kmalloc(sizeof(struct qt_get_device_data), GFP_KERNEL);
447 if (!transfer_buffer)
448 return -ENOMEM;
449
450 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
451 QT_SET_GET_DEVICE, 0xc0, 0, 0,
452 transfer_buffer,
453 sizeof(struct qt_get_device_data), 300);
454 if (result > 0)
455 memcpy(device_data, transfer_buffer,
456 sizeof(struct qt_get_device_data));
457 kfree(transfer_buffer);
458
459 return result;
460}
461
462
463
464
465
466static int BoxSetPrebufferLevel(struct usb_serial *serial)
467{
468 int result;
469 __u16 buffer_length;
470
471 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
472 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
473 QT_GET_SET_PREBUF_TRIG_LVL, 0x40,
474 buffer_length, 0, NULL, 0, 300);
475 return result;
476}
477
478
479
480
481
482static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode)
483{
484 int result;
485 __u16 buffer_length;
486
487 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
488
489 result =
490 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
491 QT_SET_ATF, 0x40, n_Mode, 0, NULL, 0, 300);
492
493 return result;
494}
495
496
497
498
499
500
501
502static int qt_set_device(struct usb_serial *serial,
503 struct qt_get_device_data *device_data)
504{
505 int result;
506 __u16 length;
507 __u16 PortSettings;
508
509 PortSettings = ((__u16) (device_data->portb));
510 PortSettings = (PortSettings << 8);
511 PortSettings += ((__u16) (device_data->porta));
512
513 length = sizeof(struct qt_get_device_data);
514
515 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
516 QT_SET_GET_DEVICE, 0x40, PortSettings,
517 0, NULL, 0, 300);
518 return result;
519}
520
521static int qt_open_channel(struct usb_serial *serial, __u16 Uart_Number,
522 struct qt_open_channel_data *pDeviceData)
523{
524 int result;
525
526 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
527 QT_OPEN_CLOSE_CHANNEL,
528 USBD_TRANSFER_DIRECTION_IN, 1, Uart_Number,
529 pDeviceData,
530 sizeof(struct qt_open_channel_data), 300);
531
532 return result;
533
534}
535
536static int qt_close_channel(struct usb_serial *serial, __u16 Uart_Number)
537{
538 int result;
539
540 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
541 QT_OPEN_CLOSE_CHANNEL,
542 USBD_TRANSFER_DIRECTION_OUT, 0, Uart_Number,
543 NULL, 0, 300);
544
545 return result;
546
547}
548
549
550
551
552
553
554static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
555 unsigned short Register_Num, __u8 *pValue)
556{
557 int result;
558 __u16 current_length;
559
560 current_length = sizeof(struct qt_get_device_data);
561
562 result =
563 usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
564 QT_GET_SET_REGISTER, 0xC0, Register_Num,
565 Uart_Number, (void *)pValue, sizeof(*pValue), 300);
566
567 return result;
568}
569
570
571
572
573
574
575static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
576 unsigned short Register_Num, unsigned short Value)
577{
578 int result;
579 unsigned short RegAndByte;
580
581 RegAndByte = Value;
582 RegAndByte = RegAndByte << 8;
583 RegAndByte = RegAndByte + Register_Num;
584
585
586
587
588
589
590
591 result =
592 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
593 QT_GET_SET_REGISTER, 0x40, RegAndByte, Uart_Number,
594 NULL, 0, 300);
595
596 return result;
597}
598
599
600
601
602
603
604static int qt_setuart(struct usb_serial *serial, unsigned short Uart_Number,
605 unsigned short default_divisor, unsigned char default_LCR)
606{
607 int result;
608 unsigned short UartNumandLCR;
609
610 UartNumandLCR = (default_LCR << 8) + Uart_Number;
611
612 result =
613 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
614 QT_GET_SET_UART, 0x40, default_divisor,
615 UartNumandLCR, NULL, 0, 300);
616
617 return result;
618}
619
620static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index,
621 int bSet)
622{
623 __u8 mcr = 0;
624 __u8 msr = 0, MOUT_Value = 0;
625 unsigned int status;
626
627 if (bSet == 1) {
628
629 mcr = SERIAL_MCR_RTS;
630 }
631 else {
632
633 mcr = 0;
634
635 }
636 MOUT_Value = mcr << 8;
637
638 if (bSet == 1) {
639
640
641 msr = SERIAL_MSR_CTS;
642 } else {
643
644 msr = 0;
645 }
646 MOUT_Value |= msr;
647
648 status =
649 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
650 QT_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value,
651 index, NULL, 0, 300);
652 return status;
653
654}
655
656static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 index,
657 unsigned char stop_char, unsigned char start_char)
658{
659 __u16 nSWflowout;
660 int result;
661
662 nSWflowout = start_char << 8;
663 nSWflowout = (unsigned short)stop_char;
664
665 result =
666 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
667 QT_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout,
668 index, NULL, 0, 300);
669 return result;
670
671}
672
673static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index)
674{
675 int result;
676
677 result =
678 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
679 QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, index,
680 NULL, 0, 300);
681 return result;
682
683}
684
685static int qt_startup(struct usb_serial *serial)
686{
687 struct device *dev = &serial->dev->dev;
688 struct usb_serial_port *port;
689 struct quatech_port *qt_port;
690 struct qt_get_device_data DeviceData;
691 int i;
692 int status;
693
694
695 for (i = 0; i < serial->num_ports; i++) {
696 port = serial->port[i];
697 qt_port = kzalloc(sizeof(*qt_port), GFP_KERNEL);
698 if (!qt_port) {
699 for (--i; i >= 0; i--) {
700 port = serial->port[i];
701 kfree(usb_get_serial_port_data(port));
702 usb_set_serial_port_data(port, NULL);
703 }
704 return -ENOMEM;
705 }
706 mutex_init(&qt_port->lock);
707
708 usb_set_serial_port_data(port, qt_port);
709
710 }
711
712 status = qt_get_device(serial, &DeviceData);
713 if (status < 0)
714 goto startup_error;
715
716 dev_dbg(dev, "DeviceData.portb = 0x%x\n", DeviceData.portb);
717
718 DeviceData.portb &= ~FULLPWRBIT;
719 dev_dbg(dev, "Changing DeviceData.portb to 0x%x\n", DeviceData.portb);
720
721 status = qt_set_device(serial, &DeviceData);
722 if (status < 0) {
723 dev_dbg(dev, "qt_set_device failed\n");
724 goto startup_error;
725 }
726
727 status = qt_get_device(serial, &DeviceData);
728 if (status < 0) {
729 dev_dbg(dev, "qt_get_device failed\n");
730 goto startup_error;
731 }
732
733 switch (serial->dev->descriptor.idProduct) {
734 case QUATECH_DSU100:
735 case QUATECH_QSU100:
736 case QUATECH_ESU100A:
737 case QUATECH_ESU100B:
738 case QUATECH_HSU100A:
739 case QUATECH_HSU100B:
740 case QUATECH_HSU100C:
741 case QUATECH_HSU100D:
742 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
743 DeviceData.porta |= CLKS_X4;
744 DeviceData.portb &= ~(LOOPMODE_BITS);
745 DeviceData.portb |= RS232_MODE;
746 break;
747
748 case QUATECH_SSU200:
749 case QUATECH_DSU200:
750 case QUATECH_QSU200:
751 case QUATECH_ESU200A:
752 case QUATECH_ESU200B:
753 case QUATECH_HSU200A:
754 case QUATECH_HSU200B:
755 case QUATECH_HSU200C:
756 case QUATECH_HSU200D:
757 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
758 DeviceData.porta |= CLKS_X4;
759 DeviceData.portb &= ~(LOOPMODE_BITS);
760 DeviceData.portb |= ALL_LOOPBACK;
761 break;
762 default:
763 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
764 DeviceData.porta |= CLKS_X4;
765 DeviceData.portb &= ~(LOOPMODE_BITS);
766 DeviceData.portb |= RS232_MODE;
767 break;
768
769 }
770
771 status = BoxSetPrebufferLevel(serial);
772 if (status < 0) {
773 dev_dbg(dev, "BoxSetPrebufferLevel failed\n");
774 goto startup_error;
775 }
776
777 status = BoxSetATC(serial, ATC_DISABLED);
778 if (status < 0) {
779 dev_dbg(dev, "BoxSetATC failed\n");
780 goto startup_error;
781 }
782
783 dev_dbg(dev, "DeviceData.portb = 0x%x\n", DeviceData.portb);
784
785 DeviceData.portb |= NEXT_BOARD_POWER_BIT;
786 dev_dbg(dev, "Changing DeviceData.portb to 0x%x\n", DeviceData.portb);
787
788 status = qt_set_device(serial, &DeviceData);
789 if (status < 0) {
790 dev_dbg(dev, "qt_set_device failed\n");
791 goto startup_error;
792 }
793
794 return 0;
795
796startup_error:
797 for (i = 0; i < serial->num_ports; i++) {
798 port = serial->port[i];
799 qt_port = qt_get_port_private(port);
800 kfree(qt_port);
801 usb_set_serial_port_data(port, NULL);
802 }
803
804 return -EIO;
805}
806
807static void qt_release(struct usb_serial *serial)
808{
809 struct usb_serial_port *port;
810 struct quatech_port *qt_port;
811 int i;
812
813 for (i = 0; i < serial->num_ports; i++) {
814 port = serial->port[i];
815 if (!port)
816 continue;
817
818 qt_port = usb_get_serial_port_data(port);
819 kfree(qt_port);
820 usb_set_serial_port_data(port, NULL);
821 }
822
823}
824
825static void qt_submit_urb_from_open(struct usb_serial *serial,
826 struct usb_serial_port *port)
827{
828 int result;
829 struct usb_serial_port *port0 = serial->port[0];
830
831
832 usb_fill_int_urb(port0->interrupt_in_urb,
833 serial->dev,
834 usb_rcvintpipe(serial->dev,
835 port0->interrupt_in_endpointAddress),
836 port0->interrupt_in_buffer,
837 port0->interrupt_in_urb->transfer_buffer_length,
838 qt_interrupt_callback, serial,
839 port0->interrupt_in_urb->interval);
840
841 result = usb_submit_urb(port0->interrupt_in_urb,
842 GFP_KERNEL);
843 if (result) {
844 dev_err(&port->dev,
845 "%s - Error %d submitting interrupt urb\n",
846 __func__, result);
847 }
848}
849
850static int qt_open(struct tty_struct *tty,
851 struct usb_serial_port *port)
852{
853 struct usb_serial *serial;
854 struct quatech_port *quatech_port;
855 struct quatech_port *port0;
856 struct qt_open_channel_data ChannelData;
857
858 int result;
859
860 if (port_paranoia_check(port, __func__))
861 return -ENODEV;
862
863 serial = port->serial;
864
865 if (serial_paranoia_check(serial, __func__))
866 return -ENODEV;
867
868 quatech_port = qt_get_port_private(port);
869 port0 = qt_get_port_private(serial->port[0]);
870
871 if (quatech_port == NULL || port0 == NULL)
872 return -ENODEV;
873
874 usb_clear_halt(serial->dev, port->write_urb->pipe);
875 usb_clear_halt(serial->dev, port->read_urb->pipe);
876 port0->open_ports++;
877
878 result = qt_get_device(serial, &port0->DeviceData);
879
880
881 result = qt_open_channel(serial, port->number, &ChannelData);
882 if (result < 0) {
883 dev_dbg(&port->dev, "qt_open_channel failed\n");
884 return result;
885 }
886 dev_dbg(&port->dev, "qt_open_channel completed.\n");
887
888
889 quatech_port->shadowLSR = ChannelData.line_status &
890 (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI);
891
892 quatech_port->shadowMSR = ChannelData.modem_status &
893 (SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
894
895
896 result = qt_setuart(serial, port->number, DEFAULT_DIVISOR, DEFAULT_LCR);
897 if (result < 0) {
898 dev_dbg(&port->dev, "qt_setuart failed\n");
899 return result;
900 }
901 dev_dbg(&port->dev, "qt_setuart completed.\n");
902
903
904
905
906
907
908
909 if (port0->open_ports == 1) {
910 if (serial->port[0]->interrupt_in_buffer == NULL)
911 qt_submit_urb_from_open(serial, port);
912 }
913
914 dev_dbg(&port->dev, "port number is %d\n", port->number);
915 dev_dbg(&port->dev, "serial number is %d\n", port->serial->minor);
916 dev_dbg(&port->dev,
917 "Bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
918 dev_dbg(&port->dev,
919 "BulkOut endpoint is %d\n", port->bulk_out_endpointAddress);
920 dev_dbg(&port->dev, "Interrupt endpoint is %d\n",
921 port->interrupt_in_endpointAddress);
922 dev_dbg(&port->dev, "port's number in the device is %d\n",
923 quatech_port->port_num);
924 quatech_port->read_urb = port->read_urb;
925
926
927
928 usb_fill_bulk_urb(quatech_port->read_urb,
929 serial->dev,
930 usb_rcvbulkpipe(serial->dev,
931 port->bulk_in_endpointAddress),
932 port->bulk_in_buffer,
933 quatech_port->read_urb->transfer_buffer_length,
934 qt_read_bulk_callback, quatech_port);
935
936 dev_dbg(&port->dev, "qt_open: bulkin endpoint is %d\n",
937 port->bulk_in_endpointAddress);
938 quatech_port->read_urb_busy = true;
939 result = usb_submit_urb(quatech_port->read_urb, GFP_KERNEL);
940 if (result) {
941 dev_err(&port->dev,
942 "%s - Error %d submitting control urb\n",
943 __func__, result);
944 quatech_port->read_urb_busy = false;
945 }
946
947
948 init_waitqueue_head(&quatech_port->wait);
949 init_waitqueue_head(&quatech_port->msr_wait);
950
951
952 memset(&(quatech_port->icount), 0x00, sizeof(quatech_port->icount));
953
954 return 0;
955
956}
957
958static int qt_chars_in_buffer(struct tty_struct *tty)
959{
960 struct usb_serial_port *port = tty->driver_data;
961 struct usb_serial *serial;
962 int chars = 0;
963
964 serial = get_usb_serial(port, __func__);
965
966 if (serial->num_bulk_out) {
967 if (port->write_urb->status == -EINPROGRESS)
968 chars = port->write_urb->transfer_buffer_length;
969 }
970
971 return chars;
972}
973
974static void qt_block_until_empty(struct tty_struct *tty,
975 struct quatech_port *qt_port)
976{
977 int timeout = HZ / 10;
978 int wait = 30;
979 int count;
980
981 while (1) {
982
983 count = qt_chars_in_buffer(tty);
984
985 if (count <= 0)
986 return;
987
988 interruptible_sleep_on_timeout(&qt_port->wait, timeout);
989
990 wait--;
991 if (wait == 0) {
992 dev_dbg(&qt_port->port->dev, "%s - TIMEOUT", __func__);
993 return;
994 } else {
995 wait = 30;
996 }
997 }
998}
999
1000static void qt_close(struct usb_serial_port *port)
1001{
1002 struct usb_serial *serial = port->serial;
1003 struct quatech_port *qt_port;
1004 struct quatech_port *port0;
1005 struct tty_struct *tty;
1006 int status;
1007 unsigned int index;
1008 status = 0;
1009
1010 tty = tty_port_tty_get(&port->port);
1011 index = tty->index - serial->minor;
1012
1013 qt_port = qt_get_port_private(port);
1014 port0 = qt_get_port_private(serial->port[0]);
1015
1016
1017 if (serial->num_bulk_out)
1018 usb_unlink_urb(port->write_urb);
1019 if (serial->num_bulk_in)
1020 usb_unlink_urb(port->read_urb);
1021
1022
1023 if (serial->dev)
1024 qt_block_until_empty(tty, qt_port);
1025 tty_kref_put(tty);
1026
1027
1028 status = qt_close_channel(serial, index);
1029 if (status < 0)
1030 dev_dbg(&port->dev,
1031 "%s - port %d qt_close_channel failed.\n",
1032 __func__, port->number);
1033
1034 port0->open_ports--;
1035
1036 dev_dbg(&port->dev, "qt_num_open_ports in close%d:in port%d\n",
1037 port0->open_ports, port->number);
1038
1039 if (port0->open_ports == 0) {
1040 if (serial->port[0]->interrupt_in_urb) {
1041 dev_dbg(&port->dev, "Shutdown interrupt_in_urb\n");
1042 usb_kill_urb(serial->port[0]->interrupt_in_urb);
1043 }
1044
1045 }
1046
1047 if (qt_port->write_urb) {
1048
1049 kfree(qt_port->write_urb->transfer_buffer);
1050 usb_free_urb(qt_port->write_urb);
1051 }
1052
1053}
1054
1055static int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
1056 const unsigned char *buf, int count)
1057{
1058 int result;
1059 struct usb_serial *serial = get_usb_serial(port, __func__);
1060
1061 if (serial == NULL)
1062 return -ENODEV;
1063
1064 if (count == 0) {
1065 dev_dbg(&port->dev,
1066 "%s - write request of 0 bytes\n", __func__);
1067 return 0;
1068 }
1069
1070
1071 if (serial->num_bulk_out) {
1072 if (port->write_urb->status == -EINPROGRESS) {
1073 dev_dbg(&port->dev, "%s - already writing\n", __func__);
1074 return 0;
1075 }
1076
1077 count =
1078 (count > port->bulk_out_size) ? port->bulk_out_size : count;
1079 memcpy(port->write_urb->transfer_buffer, buf, count);
1080
1081
1082
1083 usb_fill_bulk_urb(port->write_urb, serial->dev,
1084 usb_sndbulkpipe(serial->dev,
1085 port->
1086 bulk_out_endpointAddress),
1087 port->write_urb->transfer_buffer, count,
1088 qt_write_bulk_callback, port);
1089
1090
1091 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1092 if (result)
1093 dev_dbg(&port->dev,
1094 "%s - failed submitting write urb, error %d\n",
1095 __func__, result);
1096 else
1097 result = count;
1098
1099 return result;
1100 }
1101
1102
1103 return 0;
1104}
1105
1106static int qt_write_room(struct tty_struct *tty)
1107{
1108 struct usb_serial_port *port = tty->driver_data;
1109 struct usb_serial *serial;
1110 struct quatech_port *qt_port;
1111
1112 int retval = -EINVAL;
1113
1114 if (port_paranoia_check(port, __func__))
1115 return -1;
1116
1117 serial = get_usb_serial(port, __func__);
1118
1119 if (!serial)
1120 return -ENODEV;
1121
1122 qt_port = qt_get_port_private(port);
1123
1124 mutex_lock(&qt_port->lock);
1125
1126 if (serial->num_bulk_out) {
1127 if (port->write_urb->status != -EINPROGRESS)
1128 retval = port->bulk_out_size;
1129 }
1130
1131 mutex_unlock(&qt_port->lock);
1132 return retval;
1133
1134}
1135
1136static int qt_ioctl(struct tty_struct *tty,
1137 unsigned int cmd, unsigned long arg)
1138{
1139 struct usb_serial_port *port = tty->driver_data;
1140 struct quatech_port *qt_port = qt_get_port_private(port);
1141 struct usb_serial *serial = get_usb_serial(port, __func__);
1142 unsigned int index;
1143
1144 dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
1145
1146 index = tty->index - serial->minor;
1147
1148 if (cmd == TIOCMIWAIT) {
1149 while (qt_port != NULL) {
1150 interruptible_sleep_on(&qt_port->msr_wait);
1151 if (signal_pending(current))
1152 return -ERESTARTSYS;
1153 else {
1154 char diff = qt_port->diff_status;
1155
1156 if (diff == 0)
1157 return -EIO;
1158
1159
1160 qt_port->diff_status = 0;
1161
1162 if (((arg & TIOCM_RNG)
1163 && (diff & SERIAL_MSR_RI))
1164 || ((arg & TIOCM_DSR)
1165 && (diff & SERIAL_MSR_DSR))
1166 || ((arg & TIOCM_CD)
1167 && (diff & SERIAL_MSR_CD))
1168 || ((arg & TIOCM_CTS)
1169 && (diff & SERIAL_MSR_CTS))) {
1170 return 0;
1171 }
1172 }
1173 }
1174 return 0;
1175 }
1176
1177 dev_dbg(&port->dev, "%s -No ioctl for that one. port = %d\n",
1178 __func__, port->number);
1179 return -ENOIOCTLCMD;
1180}
1181
1182static void qt_set_termios(struct tty_struct *tty,
1183 struct usb_serial_port *port,
1184 struct ktermios *old_termios)
1185{
1186 struct ktermios *termios = &tty->termios;
1187 unsigned char new_LCR = 0;
1188 unsigned int cflag = termios->c_cflag;
1189 unsigned int index;
1190 int baud, divisor, remainder;
1191 int status;
1192
1193 index = tty->index - port->serial->minor;
1194
1195 switch (cflag & CSIZE) {
1196 case CS5:
1197 new_LCR |= SERIAL_5_DATA;
1198 break;
1199 case CS6:
1200 new_LCR |= SERIAL_6_DATA;
1201 break;
1202 case CS7:
1203 new_LCR |= SERIAL_7_DATA;
1204 break;
1205 default:
1206 termios->c_cflag &= ~CSIZE;
1207 termios->c_cflag |= CS8;
1208 case CS8:
1209 new_LCR |= SERIAL_8_DATA;
1210 break;
1211 }
1212
1213
1214 if (cflag & PARENB) {
1215 if (cflag & PARODD)
1216 new_LCR |= SERIAL_ODD_PARITY;
1217 else
1218 new_LCR |= SERIAL_EVEN_PARITY;
1219 }
1220 if (cflag & CSTOPB)
1221 new_LCR |= SERIAL_TWO_STOPB;
1222 else
1223 new_LCR |= SERIAL_ONE_STOPB;
1224
1225 dev_dbg(&port->dev, "%s - 4\n", __func__);
1226
1227
1228 baud = tty_get_baud_rate(tty);
1229 if (!baud)
1230
1231 baud = 9600;
1232
1233 dev_dbg(&port->dev, "%s - got baud = %d\n", __func__, baud);
1234
1235 divisor = MAX_BAUD_RATE / baud;
1236 remainder = MAX_BAUD_RATE % baud;
1237
1238 if (((remainder * 2) >= baud) && (baud != 110))
1239 divisor++;
1240
1241
1242
1243
1244 status =
1245 qt_setuart(port->serial, index, (unsigned short)divisor, new_LCR);
1246 if (status < 0) {
1247 dev_dbg(&port->dev, "qt_setuart failed\n");
1248 return;
1249 }
1250
1251
1252 if (cflag & CRTSCTS) {
1253 dev_dbg(&port->dev, "%s - Enabling HW flow control port %d\n",
1254 __func__, port->number);
1255
1256
1257 status = BoxSetHW_FlowCtrl(port->serial, index, 1);
1258
1259 if (status < 0) {
1260 dev_dbg(&port->dev, "BoxSetHW_FlowCtrl failed\n");
1261 return;
1262 }
1263 } else {
1264
1265 dev_dbg(&port->dev,
1266 "%s - disabling HW flow control port %d\n",
1267 __func__, port->number);
1268
1269 status = BoxSetHW_FlowCtrl(port->serial, index, 0);
1270 if (status < 0) {
1271 dev_dbg(&port->dev, "BoxSetHW_FlowCtrl failed\n");
1272 return;
1273 }
1274
1275 }
1276
1277
1278
1279 if (I_IXOFF(tty) || I_IXON(tty)) {
1280 unsigned char stop_char = STOP_CHAR(tty);
1281 unsigned char start_char = START_CHAR(tty);
1282 status =
1283 BoxSetSW_FlowCtrl(port->serial, index, stop_char,
1284 start_char);
1285 if (status < 0)
1286 dev_dbg(&port->dev,
1287 "BoxSetSW_FlowCtrl (enabled) failed\n");
1288
1289 } else {
1290
1291 status = BoxDisable_SW_FlowCtrl(port->serial, index);
1292 if (status < 0)
1293 dev_dbg(&port->dev,
1294 "BoxSetSW_FlowCtrl (diabling) failed\n");
1295
1296 }
1297 termios->c_cflag &= ~CMSPAR;
1298
1299
1300
1301}
1302
1303static void qt_break(struct tty_struct *tty, int break_state)
1304{
1305 struct usb_serial_port *port = tty->driver_data;
1306 struct usb_serial *serial = get_usb_serial(port, __func__);
1307 struct quatech_port *qt_port;
1308 u16 index, onoff;
1309 unsigned int result;
1310
1311 index = tty->index - serial->minor;
1312
1313 qt_port = qt_get_port_private(port);
1314
1315 if (break_state == -1)
1316 onoff = 1;
1317 else
1318 onoff = 0;
1319
1320 mutex_lock(&qt_port->lock);
1321
1322 result =
1323 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1324 QT_BREAK_CONTROL, 0x40, onoff, index, NULL, 0, 300);
1325
1326 mutex_unlock(&qt_port->lock);
1327}
1328
1329static inline int qt_real_tiocmget(struct tty_struct *tty,
1330 struct usb_serial_port *port,
1331 struct usb_serial *serial)
1332{
1333
1334 u8 mcr;
1335 u8 msr;
1336 unsigned int result = 0;
1337 int status;
1338 unsigned int index;
1339
1340 index = tty->index - serial->minor;
1341 status =
1342 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr);
1343 if (status >= 0) {
1344 status =
1345 BoxGetRegister(port->serial, index,
1346 MODEM_STATUS_REGISTER, &msr);
1347
1348 }
1349
1350 if (status >= 0) {
1351 result = ((mcr & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
1352
1353 | ((mcr & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
1354
1355 | ((msr & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
1356
1357 | ((msr & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
1358
1359 | ((msr & SERIAL_MSR_RI) ? TIOCM_RI : 0)
1360
1361 | ((msr & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
1362
1363 return result;
1364
1365 } else
1366 return -ESPIPE;
1367}
1368
1369static inline int qt_real_tiocmset(struct tty_struct *tty,
1370 struct usb_serial_port *port,
1371 struct usb_serial *serial,
1372 unsigned int value)
1373{
1374
1375 u8 mcr;
1376 int status;
1377 unsigned int index;
1378
1379 index = tty->index - serial->minor;
1380 status =
1381 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr);
1382 if (status < 0)
1383 return -ESPIPE;
1384
1385
1386
1387
1388
1389 mcr &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
1390 if (value & TIOCM_RTS)
1391 mcr |= SERIAL_MCR_RTS;
1392 if (value & TIOCM_DTR)
1393 mcr |= SERIAL_MCR_DTR;
1394 if (value & TIOCM_LOOP)
1395 mcr |= SERIAL_MCR_LOOP;
1396
1397 status =
1398 BoxSetRegister(port->serial, index, MODEM_CONTROL_REGISTER, mcr);
1399 if (status < 0)
1400 return -ESPIPE;
1401 else
1402 return 0;
1403}
1404
1405static int qt_tiocmget(struct tty_struct *tty)
1406{
1407 struct usb_serial_port *port = tty->driver_data;
1408 struct usb_serial *serial = get_usb_serial(port, __func__);
1409 struct quatech_port *qt_port = qt_get_port_private(port);
1410 int retval;
1411
1412 if (!serial)
1413 return -ENODEV;
1414
1415 mutex_lock(&qt_port->lock);
1416 retval = qt_real_tiocmget(tty, port, serial);
1417 mutex_unlock(&qt_port->lock);
1418 return retval;
1419}
1420
1421static int qt_tiocmset(struct tty_struct *tty,
1422 unsigned int set, unsigned int clear)
1423{
1424
1425 struct usb_serial_port *port = tty->driver_data;
1426 struct usb_serial *serial = get_usb_serial(port, __func__);
1427 struct quatech_port *qt_port = qt_get_port_private(port);
1428 int retval;
1429
1430 if (!serial)
1431 return -ENODEV;
1432
1433 mutex_lock(&qt_port->lock);
1434 retval = qt_real_tiocmset(tty, port, serial, set);
1435 mutex_unlock(&qt_port->lock);
1436 return retval;
1437}
1438
1439static void qt_throttle(struct tty_struct *tty)
1440{
1441 struct usb_serial_port *port = tty->driver_data;
1442 struct usb_serial *serial = get_usb_serial(port, __func__);
1443 struct quatech_port *qt_port;
1444
1445 if (!serial)
1446 return;
1447
1448 qt_port = qt_get_port_private(port);
1449
1450 mutex_lock(&qt_port->lock);
1451
1452
1453 qt_port->RxHolding = 1;
1454
1455 mutex_unlock(&qt_port->lock);
1456}
1457
1458static void qt_submit_urb_from_unthrottle(struct usb_serial_port *port,
1459 struct usb_serial *serial)
1460{
1461 int result;
1462
1463
1464 usb_fill_bulk_urb(port->read_urb, serial->dev,
1465 usb_rcvbulkpipe(serial->dev,
1466 port->bulk_in_endpointAddress),
1467 port->read_urb->transfer_buffer,
1468 port->read_urb->transfer_buffer_length,
1469 qt_read_bulk_callback, port);
1470
1471 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1472
1473 if (result)
1474 dev_err(&port->dev,
1475 "%s - failed restarting read urb, error %d\n",
1476 __func__, result);
1477}
1478
1479static void qt_unthrottle(struct tty_struct *tty)
1480{
1481 struct usb_serial_port *port = tty->driver_data;
1482 struct usb_serial *serial = get_usb_serial(port, __func__);
1483 struct quatech_port *qt_port;
1484
1485 if (!serial)
1486 return;
1487
1488 qt_port = qt_get_port_private(port);
1489
1490 mutex_lock(&qt_port->lock);
1491
1492 if (qt_port->RxHolding == 1) {
1493 dev_dbg(&port->dev, "%s -qt_port->RxHolding == 1\n", __func__);
1494
1495 qt_port->RxHolding = 0;
1496 dev_dbg(&port->dev, "%s - qt_port->RxHolding = 0\n", __func__);
1497
1498
1499 if ((serial->num_bulk_in) && (qt_port->ReadBulkStopped == 1))
1500 qt_submit_urb_from_unthrottle(port, serial);
1501 }
1502 mutex_unlock(&qt_port->lock);
1503}
1504
1505static int qt_calc_num_ports(struct usb_serial *serial)
1506{
1507 int num_ports;
1508
1509 num_ports =
1510 (serial->interface->cur_altsetting->desc.bNumEndpoints - 1) / 2;
1511
1512 return num_ports;
1513}
1514
1515static struct usb_serial_driver quatech_device = {
1516 .driver = {
1517 .owner = THIS_MODULE,
1518 .name = "serqt",
1519 },
1520 .description = DRIVER_DESC,
1521 .id_table = id_table,
1522 .num_ports = 8,
1523 .open = qt_open,
1524 .close = qt_close,
1525 .write = qt_write,
1526 .write_room = qt_write_room,
1527 .chars_in_buffer = qt_chars_in_buffer,
1528 .throttle = qt_throttle,
1529 .unthrottle = qt_unthrottle,
1530 .calc_num_ports = qt_calc_num_ports,
1531 .ioctl = qt_ioctl,
1532 .set_termios = qt_set_termios,
1533 .break_ctl = qt_break,
1534 .tiocmget = qt_tiocmget,
1535 .tiocmset = qt_tiocmset,
1536 .attach = qt_startup,
1537 .release = qt_release,
1538};
1539
1540static struct usb_serial_driver * const serial_drivers[] = {
1541 &quatech_device, NULL
1542};
1543
1544module_usb_serial_driver(serial_drivers, id_table);
1545
1546MODULE_AUTHOR(DRIVER_AUTHOR);
1547MODULE_DESCRIPTION(DRIVER_DESC);
1548MODULE_LICENSE("GPL");
1549
