2 * This code was developed for the Quatech USB line for linux, it used
3 * much of the code developed by Greg Kroah-Hartman for USB serial devices
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>
21 /* Version Information */
22 #define DRIVER_VERSION "v2.14"
23 #define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
24 #define DRIVER_DESC "Quatech USB to Serial Driver"
26 #define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */
27 #define QUATECH_SSU200 0xC030 /* SSU200 */
28 #define QUATECH_DSU100 0xC040 /* DSU100 */
29 #define QUATECH_DSU200 0xC050 /* DSU200 */
30 #define QUATECH_QSU100 0xC060 /* QSU100 */
31 #define QUATECH_QSU200 0xC070 /* QSU200 */
32 #define QUATECH_ESU100A 0xC080 /* ESU100A */
33 #define QUATECH_ESU100B 0xC081 /* ESU100B */
34 #define QUATECH_ESU200A 0xC0A0 /* ESU200A */
35 #define QUATECH_ESU200B 0xC0A1 /* ESU200B */
36 #define QUATECH_HSU100A 0xC090 /* HSU100A */
37 #define QUATECH_HSU100B 0xC091 /* HSU100B */
38 #define QUATECH_HSU100C 0xC092 /* HSU100C */
39 #define QUATECH_HSU100D 0xC093 /* HSU100D */
40 #define QUATECH_HSU200A 0xC0B0 /* HSU200A */
41 #define QUATECH_HSU200B 0xC0B1 /* HSU200B */
42 #define QUATECH_HSU200C 0xC0B2 /* HSU200C */
43 #define QUATECH_HSU200D 0xC0B3 /* HSU200D */
44 #define QUATECH_SSU100_2 0xC120 /* SSU100_2 */
45 #define QUATECH_DSU100_2 0xC140 /* DSU100_2 */
46 #define QUATECH_DSU400_2 0xC150 /* DSU400_2 */
47 #define QUATECH_QSU100_2 0xC160 /* QSU100_2 */
48 #define QUATECH_QSU400_2 0xC170 /* QSU400_2 */
49 #define QUATECH_ESU400_2 0xC180 /* ESU400_2 */
50 #define QUATECH_ESU100_2 0xC1A0 /* ESU100_2 */
52 #define QT_SET_GET_DEVICE 0xc2
53 #define QT_OPEN_CLOSE_CHANNEL 0xca
54 #define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
55 #define QT_SET_ATF 0xcd
56 #define QT_GET_SET_REGISTER 0xc0
57 #define QT_GET_SET_UART 0xc1
58 #define QT_HW_FLOW_CONTROL_MASK 0xc5
59 #define QT_SW_FLOW_CONTROL_MASK 0xc6
60 #define QT_SW_FLOW_CONTROL_DISABLE 0xc7
61 #define QT_BREAK_CONTROL 0xc8
63 #define USBD_TRANSFER_DIRECTION_IN 0xc0
64 #define USBD_TRANSFER_DIRECTION_OUT 0x40
66 #define MAX_BAUD_RATE 460800
67 #define MAX_BAUD_REMAINDER 4608
69 #define DIV_LATCH_LS 0x00
70 #define XMT_HOLD_REGISTER 0x00
71 #define XVR_BUFFER_REGISTER 0x00
72 #define DIV_LATCH_MS 0x01
73 #define FIFO_CONTROL_REGISTER 0x02
74 #define LINE_CONTROL_REGISTER 0x03
75 #define MODEM_CONTROL_REGISTER 0x04
76 #define LINE_STATUS_REGISTER 0x05
77 #define MODEM_STATUS_REGISTER 0x06
79 #define SERIAL_MCR_DTR 0x01
80 #define SERIAL_MCR_RTS 0x02
81 #define SERIAL_MCR_LOOP 0x10
83 #define SERIAL_MSR_CTS 0x10
84 #define SERIAL_MSR_CD 0x80
85 #define SERIAL_MSR_RI 0x40
86 #define SERIAL_MSR_DSR 0x20
87 #define SERIAL_MSR_MASK 0xf0
89 #define SERIAL_8_DATA 0x03
90 #define SERIAL_7_DATA 0x02
91 #define SERIAL_6_DATA 0x01
92 #define SERIAL_5_DATA 0x00
94 #define SERIAL_ODD_PARITY 0X08
95 #define SERIAL_EVEN_PARITY 0X18
96 #define SERIAL_TWO_STOPB 0x04
97 #define SERIAL_ONE_STOPB 0x00
99 #define DEFAULT_DIVISOR 0x30 /* gives 9600 baud rate */
100 #define DEFAULT_LCR SERIAL_8_DATA /* 8, none , 1 */
102 #define FULLPWRBIT 0x00000080
103 #define NEXT_BOARD_POWER_BIT 0x00000004
105 #define SERIAL_LSR_OE 0x02
106 #define SERIAL_LSR_PE 0x04
107 #define SERIAL_LSR_FE 0x08
108 #define SERIAL_LSR_BI 0x10
110 #define SERIAL_MSR_CTS 0x10
111 #define SERIAL_MSR_CD 0x80
112 #define SERIAL_MSR_RI 0x40
113 #define SERIAL_MSR_DSR 0x20
114 #define SERIAL_MSR_MASK 0xf0
116 #define PREFUFF_LEVEL_CONSERVATIVE 128
117 #define ATC_DISABLED 0x0
119 #define RR_BITS 0x03 /* for clearing clock bits */
120 #define DUPMODE_BITS 0xc0
123 #define LOOPMODE_BITS 0x41 /* LOOP1 = b6, LOOP0 = b0 (PORT B) */
124 #define ALL_LOOPBACK 0x01
125 #define MODEM_CTRL 0x40
126 #define RS232_MODE 0x00
128 static const struct usb_device_id serqt_id_table[] = {
129 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU200)},
130 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU100)},
131 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU200)},
132 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU100)},
133 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU200)},
134 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100A)},
135 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100B)},
136 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200A)},
137 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU200B)},
138 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100A)},
139 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100B)},
140 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100C)},
141 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU100D)},
142 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200A)},
143 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200B)},
144 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200C)},
145 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_HSU200D)},
146 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU100_2)},
147 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU100_2)},
148 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU400_2)},
149 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU100_2)},
150 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU400_2)},
151 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU400_2)},
152 {USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU100_2)},
153 {} /* Terminating entry */
156 MODULE_DEVICE_TABLE(usb, serqt_id_table);
158 struct qt_get_device_data {
164 struct qt_open_channel_data {
169 struct quatech_port {
170 int port_num; /* number of the port */
171 struct urb *write_urb; /* write URB for this port */
172 struct urb *read_urb; /* read URB for this port */
175 __u8 shadowLCR; /* last LCR value received */
176 __u8 shadowMCR; /* last MCR value received */
177 __u8 shadowMSR; /* last MSR value received */
178 __u8 shadowLSR; /* last LSR value received */
181 /* Used for TIOCMIWAIT */
182 wait_queue_head_t msr_wait;
183 char prev_status, diff_status;
185 wait_queue_head_t wait;
187 struct async_icount icount;
189 struct usb_serial_port *port; /* owner of this object */
190 struct qt_get_device_data DeviceData;
198 static struct usb_driver serqt_usb_driver = {
199 .name = "quatech-usb-serial",
200 .probe = usb_serial_probe,
201 .disconnect = usb_serial_disconnect,
202 .id_table = serqt_id_table,
205 static int port_paranoia_check(struct usb_serial_port *port,
206 const char *function)
209 dbg("%s - port == NULL", function);
213 dbg("%s - port->serial == NULL\n", function);
220 static int serial_paranoia_check(struct usb_serial *serial,
221 const char *function)
224 dbg("%s - serial == NULL\n", function);
229 dbg("%s - serial->type == NULL!", function);
236 static inline struct quatech_port *qt_get_port_private(struct usb_serial_port
239 return (struct quatech_port *)usb_get_serial_port_data(port);
242 static inline void qt_set_port_private(struct usb_serial_port *port,
243 struct quatech_port *data)
245 usb_set_serial_port_data(port, (void *)data);
248 static struct usb_serial *get_usb_serial(struct usb_serial_port *port,
249 const char *function)
251 /* if no port was specified, or it fails a paranoia check */
253 port_paranoia_check(port, function) ||
254 serial_paranoia_check(port->serial, function)) {
256 * then say that we dont have a valid usb_serial thing,
257 * which will end up genrating -ENODEV return values
265 static void ProcessLineStatus(struct quatech_port *qt_port,
266 unsigned char line_status)
270 line_status & (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE |
275 static void ProcessModemStatus(struct quatech_port *qt_port,
276 unsigned char modem_status)
279 qt_port->shadowMSR = modem_status;
280 wake_up_interruptible(&qt_port->wait);
284 static void ProcessRxChar(struct tty_struct *tty, struct usb_serial_port *port,
287 struct urb *urb = port->read_urb;
288 if (urb->actual_length)
289 tty_insert_flip_char(tty, data, TTY_NORMAL);
292 static void qt_write_bulk_callback(struct urb *urb)
294 struct tty_struct *tty;
296 struct quatech_port *quatech_port;
298 status = urb->status;
301 dbg("nonzero write bulk status received:%d\n", status);
305 quatech_port = urb->context;
307 dbg("%s - port %d\n", __func__, quatech_port->port_num);
309 tty = tty_port_tty_get(&quatech_port->port->port);
316 static void qt_interrupt_callback(struct urb *urb)
321 static void qt_read_bulk_callback(struct urb *urb)
324 struct usb_serial_port *port = urb->context;
325 struct usb_serial *serial = get_usb_serial(port, __func__);
326 struct quatech_port *qt_port = qt_get_port_private(port);
328 struct tty_struct *tty;
330 unsigned int RxCount;
335 qt_port->ReadBulkStopped = 1;
336 dbg("%s - nonzero write bulk status received: %d\n",
337 __func__, urb->status);
341 tty = tty_port_tty_get(&port->port);
343 dbg("%s - bad tty pointer - exiting", __func__);
347 data = urb->transfer_buffer;
349 RxCount = urb->actual_length;
351 /* index = MINOR(port->tty->device) - serial->minor; */
352 index = tty->index - serial->minor;
354 dbg("%s - port %d\n", __func__, port->number);
355 dbg("%s - port->RxHolding = %d\n", __func__, qt_port->RxHolding);
357 if (port_paranoia_check(port, __func__) != 0) {
358 dbg("%s - port_paranoia_check, exiting\n", __func__);
359 qt_port->ReadBulkStopped = 1;
364 dbg("%s - bad serial pointer, exiting\n", __func__);
367 if (qt_port->closePending == 1) {
368 /* Were closing , stop reading */
369 dbg("%s - (qt_port->closepending == 1\n", __func__);
370 qt_port->ReadBulkStopped = 1;
375 * RxHolding is asserted by throttle, if we assert it, we're not
376 * receiving any more characters and let the box handle the flow
379 if (qt_port->RxHolding == 1) {
380 qt_port->ReadBulkStopped = 1;
385 qt_port->ReadBulkStopped = 1;
387 dbg("%s - nonzero read bulk status received: %d\n",
388 __func__, urb->status);
392 if (tty && RxCount) {
394 for (i = 0; i < RxCount; ++i) {
395 /* Look ahead code here */
396 if ((i <= (RxCount - 3)) && (data[i] == 0x1b)
397 && (data[i + 1] == 0x1b)) {
399 switch (data[i + 2]) {
401 /* line status change 4th byte must follow */
402 if (i > (RxCount - 4)) {
403 dbg("Illegal escape seuences in received data\n");
406 ProcessLineStatus(qt_port, data[i + 3]);
412 /* Modem status status change 4th byte must follow */
413 dbg("Modem status status.\n");
414 if (i > (RxCount - 4)) {
415 dbg("Illegal escape sequences in received data\n");
418 ProcessModemStatus(qt_port,
424 dbg("No status sequence.\n");
427 ProcessRxChar(tty, port, data[i]);
428 ProcessRxChar(tty, port, data[i + 1]);
437 if (tty && urb->actual_length)
438 tty_insert_flip_char(tty, data[i], TTY_NORMAL);
441 tty_flip_buffer_push(tty);
444 /* Continue trying to always read */
445 usb_fill_bulk_urb(port->read_urb, serial->dev,
446 usb_rcvbulkpipe(serial->dev,
447 port->bulk_in_endpointAddress),
448 port->read_urb->transfer_buffer,
449 port->read_urb->transfer_buffer_length,
450 qt_read_bulk_callback, port);
451 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
453 dbg("%s - failed resubmitting read urb, error %d",
456 if (tty && RxCount) {
457 tty_flip_buffer_push(tty);
458 tty_schedule_flip(tty);
462 schedule_work(&port->work);
469 * Issue a GET_DEVICE vendor-specific request on the default control pipe If
470 * successful, fills in the qt_get_device_data structure pointed to by
471 * device_data, otherwise return a negative error number of the problem.
474 static int qt_get_device(struct usb_serial *serial,
475 struct qt_get_device_data *device_data)
478 unsigned char *transfer_buffer;
481 kmalloc(sizeof(struct qt_get_device_data), GFP_KERNEL);
482 if (!transfer_buffer)
485 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
486 QT_SET_GET_DEVICE, 0xc0, 0, 0,
488 sizeof(struct qt_get_device_data), 300);
490 memcpy(device_data, transfer_buffer,
491 sizeof(struct qt_get_device_data));
492 kfree(transfer_buffer);
497 /****************************************************************************
498 * BoxSetPrebufferLevel
499 TELLS BOX WHEN TO ASSERT FLOW CONTROL
500 ****************************************************************************/
501 static int BoxSetPrebufferLevel(struct usb_serial *serial)
506 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
507 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
508 QT_GET_SET_PREBUF_TRIG_LVL, 0x40,
509 buffer_length, 0, NULL, 0, 300);
513 /****************************************************************************
515 TELLS BOX WHEN TO ASSERT automatic transmitter control
516 ****************************************************************************/
517 static int BoxSetATC(struct usb_serial *serial, __u16 n_Mode)
522 buffer_length = PREFUFF_LEVEL_CONSERVATIVE;
525 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
526 QT_SET_ATF, 0x40, n_Mode, 0, NULL, 0, 300);
533 * Issue a SET_DEVICE vendor-specific request on the default control pipe If
534 * successful returns the number of bytes written, otherwise it returns a
535 * negative error number of the problem.
537 static int qt_set_device(struct usb_serial *serial,
538 struct qt_get_device_data *device_data)
544 PortSettings = ((__u16) (device_data->portb));
545 PortSettings = (PortSettings << 8);
546 PortSettings += ((__u16) (device_data->porta));
548 length = sizeof(struct qt_get_device_data);
549 dbg("%s - PortSettings = 0x%x\n", __func__, PortSettings);
551 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
552 QT_SET_GET_DEVICE, 0x40, PortSettings,
557 static int qt_open_channel(struct usb_serial *serial, __u16 Uart_Number,
558 struct qt_open_channel_data *pDeviceData)
562 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
563 QT_OPEN_CLOSE_CHANNEL,
564 USBD_TRANSFER_DIRECTION_IN, 1, Uart_Number,
566 sizeof(struct qt_open_channel_data), 300);
572 static int qt_close_channel(struct usb_serial *serial, __u16 Uart_Number)
576 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
577 QT_OPEN_CLOSE_CHANNEL,
578 USBD_TRANSFER_DIRECTION_OUT, 0, Uart_Number,
585 /****************************************************************************
587 * issuse a GET_REGISTER vendor-spcific request on the default control pipe
588 * If successful, fills in the pValue with the register value asked for
589 ****************************************************************************/
590 static int BoxGetRegister(struct usb_serial *serial, unsigned short Uart_Number,
591 unsigned short Register_Num, __u8 *pValue)
594 __u16 current_length;
596 current_length = sizeof(struct qt_get_device_data);
599 usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
600 QT_GET_SET_REGISTER, 0xC0, Register_Num,
601 Uart_Number, (void *)pValue, sizeof(*pValue), 300);
606 /****************************************************************************
608 * issuse a GET_REGISTER vendor-spcific request on the default control pipe
609 * If successful, fills in the pValue with the register value asked for
610 ****************************************************************************/
611 static int BoxSetRegister(struct usb_serial *serial, unsigned short Uart_Number,
612 unsigned short Register_Num, unsigned short Value)
615 unsigned short RegAndByte;
618 RegAndByte = RegAndByte << 8;
619 RegAndByte = RegAndByte + Register_Num;
622 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
623 QT_GET_SET_REGISTER, 0xC0, Register_Num,
624 Uart_Number, NULL, 0, 300);
628 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
629 QT_GET_SET_REGISTER, 0x40, RegAndByte, Uart_Number,
637 * issuse a SET_UART vendor-spcific request on the default control pipe
638 * If successful sets baud rate divisor and LCR value
640 static int qt_setuart(struct usb_serial *serial, unsigned short Uart_Number,
641 unsigned short default_divisor, unsigned char default_LCR)
644 unsigned short UartNumandLCR;
646 UartNumandLCR = (default_LCR << 8) + Uart_Number;
649 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
650 QT_GET_SET_UART, 0x40, default_divisor,
651 UartNumandLCR, NULL, 0, 300);
656 static int BoxSetHW_FlowCtrl(struct usb_serial *serial, unsigned int index,
660 __u8 msr = 0, MOUT_Value = 0;
664 /* flow control, box will clear RTS line to prevent remote */
665 mcr = SERIAL_MCR_RTS;
666 } /* device from xmitting more chars */
668 /* no flow control to remote device */
672 MOUT_Value = mcr << 8;
675 /* flow control, box will inhibit xmit data if CTS line is
677 msr = SERIAL_MSR_CTS;
679 /* Box will not inhimbe xmit data due to CTS line */
685 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
686 QT_HW_FLOW_CONTROL_MASK, 0x40, MOUT_Value,
687 index, NULL, 0, 300);
692 static int BoxSetSW_FlowCtrl(struct usb_serial *serial, __u16 index,
693 unsigned char stop_char, unsigned char start_char)
698 nSWflowout = start_char << 8;
699 nSWflowout = (unsigned short)stop_char;
702 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
703 QT_SW_FLOW_CONTROL_MASK, 0x40, nSWflowout,
704 index, NULL, 0, 300);
709 static int BoxDisable_SW_FlowCtrl(struct usb_serial *serial, __u16 index)
714 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
715 QT_SW_FLOW_CONTROL_DISABLE, 0x40, 0, index,
721 static int qt_startup(struct usb_serial *serial)
723 struct usb_serial_port *port;
724 struct quatech_port *qt_port;
725 struct qt_get_device_data DeviceData;
729 dbg("enterting %s", __func__);
731 /* Now setup per port private data */
732 for (i = 0; i < serial->num_ports; i++) {
733 port = serial->port[i];
734 qt_port = kzalloc(sizeof(*qt_port), GFP_KERNEL);
736 dbg("%s: kmalloc for quatech_port (%d) failed!.",
738 for (--i; i >= 0; i--) {
739 port = serial->port[i];
740 kfree(usb_get_serial_port_data(port));
741 usb_set_serial_port_data(port, NULL);
745 mutex_init(&qt_port->lock);
747 usb_set_serial_port_data(port, qt_port);
751 status = qt_get_device(serial, &DeviceData);
753 dbg(__FILE__ "box_get_device failed");
757 dbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
759 DeviceData.portb &= ~FULLPWRBIT;
760 dbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
762 status = qt_set_device(serial, &DeviceData);
764 dbg(__FILE__ "qt_set_device failed\n");
768 status = qt_get_device(serial, &DeviceData);
770 dbg(__FILE__ "qt_get_device failed");
774 switch (serial->dev->descriptor.idProduct) {
777 case QUATECH_ESU100A:
778 case QUATECH_ESU100B:
779 case QUATECH_HSU100A:
780 case QUATECH_HSU100B:
781 case QUATECH_HSU100C:
782 case QUATECH_HSU100D:
783 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
784 DeviceData.porta |= CLKS_X4;
785 DeviceData.portb &= ~(LOOPMODE_BITS);
786 DeviceData.portb |= RS232_MODE;
792 case QUATECH_ESU200A:
793 case QUATECH_ESU200B:
794 case QUATECH_HSU200A:
795 case QUATECH_HSU200B:
796 case QUATECH_HSU200C:
797 case QUATECH_HSU200D:
798 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
799 DeviceData.porta |= CLKS_X4;
800 DeviceData.portb &= ~(LOOPMODE_BITS);
801 DeviceData.portb |= ALL_LOOPBACK;
804 DeviceData.porta &= ~(RR_BITS | DUPMODE_BITS);
805 DeviceData.porta |= CLKS_X4;
806 DeviceData.portb &= ~(LOOPMODE_BITS);
807 DeviceData.portb |= RS232_MODE;
812 status = BoxSetPrebufferLevel(serial); /* sets to default value */
814 dbg(__FILE__ "BoxSetPrebufferLevel failed\n");
818 status = BoxSetATC(serial, ATC_DISABLED);
820 dbg(__FILE__ "BoxSetATC failed\n");
824 dbg(__FILE__ "DeviceData.portb = 0x%x", DeviceData.portb);
826 DeviceData.portb |= NEXT_BOARD_POWER_BIT;
827 dbg(__FILE__ "Changing DeviceData.portb to 0x%x", DeviceData.portb);
829 status = qt_set_device(serial, &DeviceData);
831 dbg(__FILE__ "qt_set_device failed\n");
835 dbg("Exit Success %s\n", __func__);
840 for (i = 0; i < serial->num_ports; i++) {
841 port = serial->port[i];
842 qt_port = qt_get_port_private(port);
844 usb_set_serial_port_data(port, NULL);
847 dbg("Exit fail %s\n", __func__);
852 static void qt_release(struct usb_serial *serial)
854 struct usb_serial_port *port;
855 struct quatech_port *qt_port;
858 dbg("enterting %s", __func__);
860 for (i = 0; i < serial->num_ports; i++) {
861 port = serial->port[i];
865 qt_port = usb_get_serial_port_data(port);
867 usb_set_serial_port_data(port, NULL);
872 static int qt_open(struct tty_struct *tty,
873 struct usb_serial_port *port)
875 struct usb_serial *serial;
876 struct quatech_port *quatech_port;
877 struct quatech_port *port0;
878 struct qt_open_channel_data ChannelData;
882 if (port_paranoia_check(port, __func__))
885 dbg("%s - port %d\n", __func__, port->number);
887 serial = port->serial;
889 if (serial_paranoia_check(serial, __func__))
892 quatech_port = qt_get_port_private(port);
893 port0 = qt_get_port_private(serial->port[0]);
895 if (quatech_port == NULL || port0 == NULL)
898 usb_clear_halt(serial->dev, port->write_urb->pipe);
899 usb_clear_halt(serial->dev, port->read_urb->pipe);
902 result = qt_get_device(serial, &port0->DeviceData);
904 /* Port specific setups */
905 result = qt_open_channel(serial, port->number, &ChannelData);
907 dbg(__FILE__ "qt_open_channel failed\n");
910 dbg(__FILE__ "qt_open_channel completed.\n");
912 /* FIXME: are these needed? Does it even do anything useful? */
913 quatech_port->shadowLSR = ChannelData.line_status &
914 (SERIAL_LSR_OE | SERIAL_LSR_PE | SERIAL_LSR_FE | SERIAL_LSR_BI);
916 quatech_port->shadowMSR = ChannelData.modem_status &
917 (SERIAL_MSR_CTS | SERIAL_MSR_DSR | SERIAL_MSR_RI | SERIAL_MSR_CD);
919 /* Set Baud rate to default and turn off (default)flow control here */
920 result = qt_setuart(serial, port->number, DEFAULT_DIVISOR, DEFAULT_LCR);
922 dbg(__FILE__ "qt_setuart failed\n");
925 dbg(__FILE__ "qt_setuart completed.\n");
928 * Put this here to make it responsive to stty and defaults set by
931 /* FIXME: is this needed? */
932 /* qt_set_termios(tty, port, NULL); */
934 /* Check to see if we've set up our endpoint info yet */
935 if (port0->open_ports == 1) {
936 if (serial->port[0]->interrupt_in_buffer == NULL) {
937 /* set up interrupt urb */
938 usb_fill_int_urb(serial->port[0]->interrupt_in_urb,
940 usb_rcvintpipe(serial->dev,
941 serial->port[0]->interrupt_in_endpointAddress),
942 serial->port[0]->interrupt_in_buffer,
944 interrupt_in_urb->transfer_buffer_length,
945 qt_interrupt_callback, serial,
947 interrupt_in_urb->interval);
950 usb_submit_urb(serial->port[0]->interrupt_in_urb,
954 "%s - Error %d submitting "
955 "interrupt urb\n", __func__, result);
962 dbg("port number is %d\n", port->number);
963 dbg("serial number is %d\n", port->serial->minor);
964 dbg("Bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
965 dbg("BulkOut endpoint is %d\n", port->bulk_out_endpointAddress);
966 dbg("Interrupt endpoint is %d\n", port->interrupt_in_endpointAddress);
967 dbg("port's number in the device is %d\n", quatech_port->port_num);
968 quatech_port->read_urb = port->read_urb;
970 /* set up our bulk in urb */
972 usb_fill_bulk_urb(quatech_port->read_urb,
974 usb_rcvbulkpipe(serial->dev,
975 port->bulk_in_endpointAddress),
976 port->bulk_in_buffer,
977 quatech_port->read_urb->transfer_buffer_length,
978 qt_read_bulk_callback, quatech_port);
980 dbg("qt_open: bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
981 quatech_port->read_urb_busy = true;
982 result = usb_submit_urb(quatech_port->read_urb, GFP_KERNEL);
985 "%s - Error %d submitting control urb\n",
987 quatech_port->read_urb_busy = false;
990 /* initialize our wait queues */
991 init_waitqueue_head(&quatech_port->wait);
992 init_waitqueue_head(&quatech_port->msr_wait);
994 /* initialize our icount structure */
995 memset(&(quatech_port->icount), 0x00, sizeof(quatech_port->icount));
1001 static int qt_chars_in_buffer(struct tty_struct *tty)
1003 struct usb_serial_port *port = tty->driver_data;
1004 struct usb_serial *serial;
1007 serial = get_usb_serial(port, __func__);
1009 dbg("%s - port %d\n", __func__, port->number);
1011 if (serial->num_bulk_out) {
1012 if (port->write_urb->status == -EINPROGRESS)
1013 chars = port->write_urb->transfer_buffer_length;
1016 dbg("%s - returns %d\n", __func__, chars);
1021 static void qt_block_until_empty(struct tty_struct *tty,
1022 struct quatech_port *qt_port)
1024 int timeout = HZ / 10;
1030 count = qt_chars_in_buffer(tty);
1035 interruptible_sleep_on_timeout(&qt_port->wait, timeout);
1039 dbg("%s - TIMEOUT", __func__);
1047 static void qt_close(struct usb_serial_port *port)
1049 struct usb_serial *serial = port->serial;
1050 struct quatech_port *qt_port;
1051 struct quatech_port *port0;
1052 struct tty_struct *tty;
1057 dbg("%s - port %d\n", __func__, port->number);
1059 tty = tty_port_tty_get(&port->port);
1060 index = tty->index - serial->minor;
1062 qt_port = qt_get_port_private(port);
1063 port0 = qt_get_port_private(serial->port[0]);
1065 /* shutdown any bulk reads that might be going on */
1066 if (serial->num_bulk_out)
1067 usb_unlink_urb(port->write_urb);
1068 if (serial->num_bulk_in)
1069 usb_unlink_urb(port->read_urb);
1071 /* wait up to for transmitter to empty */
1073 qt_block_until_empty(tty, qt_port);
1076 /* Close uart channel */
1077 status = qt_close_channel(serial, index);
1079 dbg("%s - port %d qt_close_channel failed.\n",
1080 __func__, port->number);
1082 port0->open_ports--;
1084 dbg("qt_num_open_ports in close%d:in port%d\n",
1085 port0->open_ports, port->number);
1087 if (port0->open_ports == 0) {
1088 if (serial->port[0]->interrupt_in_urb) {
1089 dbg("%s", "Shutdown interrupt_in_urb\n");
1090 usb_kill_urb(serial->port[0]->interrupt_in_urb);
1095 if (qt_port->write_urb) {
1096 /* if this urb had a transfer buffer already (old tx) free it */
1097 kfree(qt_port->write_urb->transfer_buffer);
1098 usb_free_urb(qt_port->write_urb);
1103 static int qt_write(struct tty_struct *tty, struct usb_serial_port *port,
1104 const unsigned char *buf, int count)
1107 struct usb_serial *serial = get_usb_serial(port, __func__);
1112 dbg("%s - port %d\n", __func__, port->number);
1115 dbg("%s - write request of 0 bytes\n", __func__);
1119 /* only do something if we have a bulk out endpoint */
1120 if (serial->num_bulk_out) {
1121 if (port->write_urb->status == -EINPROGRESS) {
1122 dbg("%s - already writing\n", __func__);
1127 (count > port->bulk_out_size) ? port->bulk_out_size : count;
1128 memcpy(port->write_urb->transfer_buffer, buf, count);
1130 /* set up our urb */
1132 usb_fill_bulk_urb(port->write_urb, serial->dev,
1133 usb_sndbulkpipe(serial->dev,
1135 bulk_out_endpointAddress),
1136 port->write_urb->transfer_buffer, count,
1137 qt_write_bulk_callback, port);
1139 /* send the data out the bulk port */
1140 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1142 dbg("%s - failed submitting write urb, error %d\n",
1150 /* no bulk out, so return 0 bytes written */
1154 static int qt_write_room(struct tty_struct *tty)
1156 struct usb_serial_port *port = tty->driver_data;
1157 struct usb_serial *serial;
1158 struct quatech_port *qt_port;
1160 int retval = -EINVAL;
1162 if (port_paranoia_check(port, __func__)) {
1163 dbg("%s", "Invalid port\n");
1167 serial = get_usb_serial(port, __func__);
1172 qt_port = qt_get_port_private(port);
1174 mutex_lock(&qt_port->lock);
1176 dbg("%s - port %d\n", __func__, port->number);
1178 if (serial->num_bulk_out) {
1179 if (port->write_urb->status != -EINPROGRESS)
1180 retval = port->bulk_out_size;
1183 mutex_unlock(&qt_port->lock);
1188 static int qt_ioctl(struct tty_struct *tty,
1189 unsigned int cmd, unsigned long arg)
1191 struct usb_serial_port *port = tty->driver_data;
1192 struct quatech_port *qt_port = qt_get_port_private(port);
1193 struct usb_serial *serial = get_usb_serial(port, __func__);
1196 dbg("%s cmd 0x%04x", __func__, cmd);
1198 index = tty->index - serial->minor;
1200 if (cmd == TIOCMIWAIT) {
1201 while (qt_port != NULL) {
1202 interruptible_sleep_on(&qt_port->msr_wait);
1203 if (signal_pending(current))
1204 return -ERESTARTSYS;
1206 char diff = qt_port->diff_status;
1209 return -EIO; /* no change => error */
1211 /* Consume all events */
1212 qt_port->diff_status = 0;
1214 if (((arg & TIOCM_RNG)
1215 && (diff & SERIAL_MSR_RI))
1216 || ((arg & TIOCM_DSR)
1217 && (diff & SERIAL_MSR_DSR))
1218 || ((arg & TIOCM_CD)
1219 && (diff & SERIAL_MSR_CD))
1220 || ((arg & TIOCM_CTS)
1221 && (diff & SERIAL_MSR_CTS))) {
1229 dbg("%s -No ioctl for that one. port = %d\n", __func__, port->number);
1230 return -ENOIOCTLCMD;
1233 static void qt_set_termios(struct tty_struct *tty,
1234 struct usb_serial_port *port,
1235 struct ktermios *old_termios)
1237 struct ktermios *termios = tty->termios;
1238 unsigned char new_LCR = 0;
1239 unsigned int cflag = termios->c_cflag;
1241 int baud, divisor, remainder;
1244 dbg("%s", __func__);
1246 index = tty->index - port->serial->minor;
1250 new_LCR |= SERIAL_5_DATA;
1253 new_LCR |= SERIAL_6_DATA;
1256 new_LCR |= SERIAL_7_DATA;
1260 new_LCR |= SERIAL_8_DATA;
1265 if (cflag & PARENB) {
1267 new_LCR |= SERIAL_ODD_PARITY;
1269 new_LCR |= SERIAL_EVEN_PARITY;
1272 new_LCR |= SERIAL_TWO_STOPB;
1274 new_LCR |= SERIAL_ONE_STOPB;
1276 dbg("%s - 4\n", __func__);
1278 /* Thats the LCR stuff, go ahead and set it */
1279 baud = tty_get_baud_rate(tty);
1281 /* pick a default, any default... */
1284 dbg("%s - got baud = %d\n", __func__, baud);
1286 divisor = MAX_BAUD_RATE / baud;
1287 remainder = MAX_BAUD_RATE % baud;
1288 /* Round to nearest divisor */
1289 if (((remainder * 2) >= baud) && (baud != 110))
1293 * Set Baud rate to default and turn off (default)flow control here
1296 qt_setuart(port->serial, index, (unsigned short)divisor, new_LCR);
1298 dbg(__FILE__ "qt_setuart failed\n");
1302 /* Now determine flow control */
1303 if (cflag & CRTSCTS) {
1304 dbg("%s - Enabling HW flow control port %d\n", __func__,
1307 /* Enable RTS/CTS flow control */
1308 status = BoxSetHW_FlowCtrl(port->serial, index, 1);
1311 dbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
1315 /* Disable RTS/CTS flow control */
1316 dbg("%s - disabling HW flow control port %d\n", __func__,
1319 status = BoxSetHW_FlowCtrl(port->serial, index, 0);
1321 dbg(__FILE__ "BoxSetHW_FlowCtrl failed\n");
1327 /* if we are implementing XON/XOFF, set the start and stop character in
1329 if (I_IXOFF(tty) || I_IXON(tty)) {
1330 unsigned char stop_char = STOP_CHAR(tty);
1331 unsigned char start_char = START_CHAR(tty);
1333 BoxSetSW_FlowCtrl(port->serial, index, stop_char,
1336 dbg(__FILE__ "BoxSetSW_FlowCtrl (enabled) failed\n");
1339 /* disable SW flow control */
1340 status = BoxDisable_SW_FlowCtrl(port->serial, index);
1342 dbg(__FILE__ "BoxSetSW_FlowCtrl (diabling) failed\n");
1345 tty->termios->c_cflag &= ~CMSPAR;
1346 /* FIXME: Error cases should be returning the actual bits changed only */
1349 static void qt_break(struct tty_struct *tty, int break_state)
1351 struct usb_serial_port *port = tty->driver_data;
1352 struct usb_serial *serial = get_usb_serial(port, __func__);
1353 struct quatech_port *qt_port;
1355 unsigned int result;
1357 index = tty->index - serial->minor;
1359 qt_port = qt_get_port_private(port);
1361 if (break_state == -1)
1366 mutex_lock(&qt_port->lock);
1368 dbg("%s - port %d\n", __func__, port->number);
1371 usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1372 QT_BREAK_CONTROL, 0x40, onoff, index, NULL, 0, 300);
1374 mutex_unlock(&qt_port->lock);
1377 static inline int qt_real_tiocmget(struct tty_struct *tty,
1378 struct usb_serial_port *port,
1379 struct usb_serial *serial)
1384 unsigned int result = 0;
1388 dbg("%s - port %d, tty =0x%p\n", __func__, port->number, tty);
1390 index = tty->index - serial->minor;
1392 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr);
1395 BoxGetRegister(port->serial, index,
1396 MODEM_STATUS_REGISTER, &msr);
1401 result = ((mcr & SERIAL_MCR_DTR) ? TIOCM_DTR : 0)
1403 | ((mcr & SERIAL_MCR_RTS) ? TIOCM_RTS : 0)
1405 | ((msr & SERIAL_MSR_CTS) ? TIOCM_CTS : 0)
1407 | ((msr & SERIAL_MSR_CD) ? TIOCM_CAR : 0)
1408 /* Carrier detect is set */
1409 | ((msr & SERIAL_MSR_RI) ? TIOCM_RI : 0)
1410 /* Ring indicator set */
1411 | ((msr & SERIAL_MSR_DSR) ? TIOCM_DSR : 0);
1419 static inline int qt_real_tiocmset(struct tty_struct *tty,
1420 struct usb_serial_port *port,
1421 struct usb_serial *serial,
1429 dbg("%s - port %d\n", __func__, port->number);
1431 index = tty->index - serial->minor;
1433 BoxGetRegister(port->serial, index, MODEM_CONTROL_REGISTER, &mcr);
1438 * Turn off the RTS and DTR and loopbcck and then only turn on what was
1441 mcr &= ~(SERIAL_MCR_RTS | SERIAL_MCR_DTR | SERIAL_MCR_LOOP);
1442 if (value & TIOCM_RTS)
1443 mcr |= SERIAL_MCR_RTS;
1444 if (value & TIOCM_DTR)
1445 mcr |= SERIAL_MCR_DTR;
1446 if (value & TIOCM_LOOP)
1447 mcr |= SERIAL_MCR_LOOP;
1450 BoxSetRegister(port->serial, index, MODEM_CONTROL_REGISTER, mcr);
1457 static int qt_tiocmget(struct tty_struct *tty)
1459 struct usb_serial_port *port = tty->driver_data;
1460 struct usb_serial *serial = get_usb_serial(port, __func__);
1461 struct quatech_port *qt_port = qt_get_port_private(port);
1462 int retval = -ENODEV;
1464 dbg("In %s\n", __func__);
1469 mutex_lock(&qt_port->lock);
1471 dbg("%s - port %d\n", __func__, port->number);
1472 dbg("%s - port->RxHolding = %d\n", __func__, qt_port->RxHolding);
1474 retval = qt_real_tiocmget(tty, port, serial);
1476 mutex_unlock(&qt_port->lock);
1480 static int qt_tiocmset(struct tty_struct *tty,
1481 unsigned int set, unsigned int clear)
1484 struct usb_serial_port *port = tty->driver_data;
1485 struct usb_serial *serial = get_usb_serial(port, __func__);
1486 struct quatech_port *qt_port = qt_get_port_private(port);
1487 int retval = -ENODEV;
1489 dbg("In %s\n", __func__);
1494 mutex_lock(&qt_port->lock);
1496 dbg("%s - port %d\n", __func__, port->number);
1497 dbg("%s - qt_port->RxHolding = %d\n", __func__, qt_port->RxHolding);
1499 retval = qt_real_tiocmset(tty, port, serial, set);
1501 mutex_unlock(&qt_port->lock);
1505 static void qt_throttle(struct tty_struct *tty)
1507 struct usb_serial_port *port = tty->driver_data;
1508 struct usb_serial *serial = get_usb_serial(port, __func__);
1509 struct quatech_port *qt_port;
1511 dbg("%s - port %d\n", __func__, port->number);
1516 qt_port = qt_get_port_private(port);
1518 mutex_lock(&qt_port->lock);
1520 /* pass on to the driver specific version of this function */
1521 qt_port->RxHolding = 1;
1522 dbg("%s - port->RxHolding = 1\n", __func__);
1524 mutex_unlock(&qt_port->lock);
1528 static void qt_unthrottle(struct tty_struct *tty)
1530 struct usb_serial_port *port = tty->driver_data;
1531 struct usb_serial *serial = get_usb_serial(port, __func__);
1532 struct quatech_port *qt_port;
1533 unsigned int result;
1538 qt_port = qt_get_port_private(port);
1540 mutex_lock(&qt_port->lock);
1542 dbg("%s - port %d\n", __func__, port->number);
1544 if (qt_port->RxHolding == 1) {
1545 dbg("%s -qt_port->RxHolding == 1\n", __func__);
1547 qt_port->RxHolding = 0;
1548 dbg("%s - qt_port->RxHolding = 0\n", __func__);
1550 /* if we have a bulk endpoint, start it up */
1551 if ((serial->num_bulk_in) && (qt_port->ReadBulkStopped == 1)) {
1552 /* Start reading from the device */
1553 usb_fill_bulk_urb(port->read_urb, serial->dev,
1554 usb_rcvbulkpipe(serial->dev,
1555 port->bulk_in_endpointAddress),
1556 port->read_urb->transfer_buffer,
1558 transfer_buffer_length,
1559 qt_read_bulk_callback, port);
1560 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1562 err("%s - failed restarting read urb, error %d",
1566 mutex_unlock(&qt_port->lock);
1571 static int qt_calc_num_ports(struct usb_serial *serial)
1575 dbg("numberofendpoints: %d\n",
1576 (int)serial->interface->cur_altsetting->desc.bNumEndpoints);
1577 dbg("numberofendpoints: %d\n",
1578 (int)serial->interface->altsetting->desc.bNumEndpoints);
1581 (serial->interface->cur_altsetting->desc.bNumEndpoints - 1) / 2;
1586 static struct usb_serial_driver quatech_device = {
1588 .owner = THIS_MODULE,
1591 .description = DRIVER_DESC,
1592 .id_table = serqt_id_table,
1597 .write_room = qt_write_room,
1598 .chars_in_buffer = qt_chars_in_buffer,
1599 .throttle = qt_throttle,
1600 .unthrottle = qt_unthrottle,
1601 .calc_num_ports = qt_calc_num_ports,
1603 .set_termios = qt_set_termios,
1604 .break_ctl = qt_break,
1605 .tiocmget = qt_tiocmget,
1606 .tiocmset = qt_tiocmset,
1607 .attach = qt_startup,
1608 .release = qt_release,
1611 static struct usb_serial_driver * const serial_drivers[] = {
1612 &quatech_device, NULL
1615 module_usb_serial_driver(serqt_usb_driver, serial_drivers);
1617 MODULE_AUTHOR(DRIVER_AUTHOR);
1618 MODULE_DESCRIPTION(DRIVER_DESC);
1619 MODULE_LICENSE("GPL");
1621 module_param(debug, bool, S_IRUGO | S_IWUSR);
1622 MODULE_PARM_DESC(debug, "Debug enabled or not");