2 * usb-serial driver for Quatech USB 2 devices
4 * Copyright (C) 2012 Bill Pemberton (wfp5p@virginia.edu)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License version 2
8 * as published by the Free Software Foundation.
11 * These devices all have only 1 bulk in and 1 bulk out that is shared
12 * for all serial ports.
16 #include <asm/unaligned.h>
17 #include <linux/errno.h>
18 #include <linux/init.h>
19 #include <linux/slab.h>
20 #include <linux/tty.h>
21 #include <linux/tty_driver.h>
22 #include <linux/tty_flip.h>
23 #include <linux/module.h>
24 #include <linux/serial.h>
25 #include <linux/usb.h>
26 #include <linux/usb/serial.h>
27 #include <linux/serial_reg.h>
28 #include <linux/uaccess.h>
32 /* default urb timeout for usb operations */
33 #define QT2_USB_TIMEOUT USB_CTRL_SET_TIMEOUT
35 #define QT_OPEN_CLOSE_CHANNEL 0xca
36 #define QT_SET_GET_DEVICE 0xc2
37 #define QT_SET_GET_REGISTER 0xc0
38 #define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
39 #define QT_SET_ATF 0xcd
40 #define QT_TRANSFER_IN 0xc0
41 #define QT_HW_FLOW_CONTROL_MASK 0xc5
42 #define QT_SW_FLOW_CONTROL_MASK 0xc6
43 #define QT2_BREAK_CONTROL 0xc8
44 #define QT2_GET_SET_UART 0xc1
45 #define QT2_FLUSH_DEVICE 0xc4
46 #define QT2_GET_SET_QMCR 0xe1
47 #define QT2_QMCR_RS232 0x40
48 #define QT2_QMCR_RS422 0x10
50 #define SERIAL_CRTSCTS ((UART_MCR_RTS << 8) | UART_MSR_CTS)
52 #define SERIAL_EVEN_PARITY (UART_LCR_PARITY | UART_LCR_EPAR)
54 /* status bytes for the device */
55 #define QT2_CONTROL_BYTE 0x1b
56 #define QT2_LINE_STATUS 0x00 /* following 1 byte is line status */
57 #define QT2_MODEM_STATUS 0x01 /* following 1 byte is modem status */
58 #define QT2_XMIT_HOLD 0x02 /* following 2 bytes are ?? */
59 #define QT2_CHANGE_PORT 0x03 /* following 1 byte is port to change to */
60 #define QT2_REC_FLUSH 0x04 /* no following info */
61 #define QT2_XMIT_FLUSH 0x05 /* no following info */
62 #define QT2_CONTROL_ESCAPE 0xff /* pass through previous 2 control bytes */
64 #define MAX_BAUD_RATE 921600
65 #define DEFAULT_BAUD_RATE 9600
67 #define QT2_WRITE_BUFFER_SIZE 512 /* size of write buffer */
68 #define QT2_WRITE_CONTROL_SIZE 5 /* control bytes used for a write */
70 /* Version Information */
71 #define DRIVER_VERSION "v0.1"
72 #define DRIVER_DESC "Quatech 2nd gen USB to Serial Driver"
74 #define USB_VENDOR_ID_QUATECH 0x061d
75 #define QUATECH_SSU2_100 0xC120 /* RS232 single port */
76 #define QUATECH_DSU2_100 0xC140 /* RS232 dual port */
77 #define QUATECH_DSU2_400 0xC150 /* RS232/422/485 dual port */
78 #define QUATECH_QSU2_100 0xC160 /* RS232 four port */
79 #define QUATECH_QSU2_400 0xC170 /* RS232/422/485 four port */
80 #define QUATECH_ESU2_100 0xC1A0 /* RS232 eight port */
81 #define QUATECH_ESU2_400 0xC180 /* RS232/422/485 eight port */
83 struct qt2_device_detail
{
88 #define QT_DETAILS(prod, ports) \
89 .product_id = (prod), \
92 static const struct qt2_device_detail qt2_device_details
[] = {
93 {QT_DETAILS(QUATECH_SSU2_100
, 1)},
94 {QT_DETAILS(QUATECH_DSU2_400
, 2)},
95 {QT_DETAILS(QUATECH_DSU2_100
, 2)},
96 {QT_DETAILS(QUATECH_QSU2_400
, 4)},
97 {QT_DETAILS(QUATECH_QSU2_100
, 4)},
98 {QT_DETAILS(QUATECH_ESU2_400
, 8)},
99 {QT_DETAILS(QUATECH_ESU2_100
, 8)},
100 {QT_DETAILS(0, 0)} /* Terminating entry */
103 static const struct usb_device_id id_table
[] = {
104 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_SSU2_100
)},
105 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_DSU2_100
)},
106 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_DSU2_400
)},
107 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_QSU2_100
)},
108 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_QSU2_400
)},
109 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_ESU2_100
)},
110 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_ESU2_400
)},
111 {} /* Terminating entry */
113 MODULE_DEVICE_TABLE(usb
, id_table
);
115 struct qt2_serial_private
{
116 unsigned char current_port
; /* current port for incoming data */
118 struct urb
*read_urb
; /* shared among all ports */
119 char read_buffer
[512];
122 struct qt2_port_private
{
128 struct urb
*write_urb
;
129 char write_buffer
[QT2_WRITE_BUFFER_SIZE
];
135 wait_queue_head_t delta_msr_wait
; /* Used for TIOCMIWAIT */
136 struct async_icount icount
;
138 struct usb_serial_port
*port
;
141 static void qt2_update_lsr(struct usb_serial_port
*port
, unsigned char *ch
);
142 static void qt2_update_msr(struct usb_serial_port
*port
, unsigned char *ch
);
143 static void qt2_write_bulk_callback(struct urb
*urb
);
144 static void qt2_read_bulk_callback(struct urb
*urb
);
146 static void qt2_release(struct usb_serial
*serial
)
150 kfree(usb_get_serial_data(serial
));
152 for (i
= 0; i
< serial
->num_ports
; i
++)
153 kfree(usb_get_serial_port_data(serial
->port
[i
]));
156 static inline int calc_baud_divisor(int baudrate
)
160 divisor
= MAX_BAUD_RATE
/ baudrate
;
161 rem
= MAX_BAUD_RATE
% baudrate
;
162 /* Round to nearest divisor */
163 if (((rem
* 2) >= baudrate
) && (baudrate
!= 110))
169 static inline int qt2_set_port_config(struct usb_device
*dev
,
170 unsigned char port_number
,
171 u16 baudrate
, u16 lcr
)
173 int divisor
= calc_baud_divisor(baudrate
);
174 u16 index
= ((u16
) (lcr
<< 8) | (u16
) (port_number
));
176 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
177 QT2_GET_SET_UART
, 0x40,
178 divisor
, index
, NULL
, 0, QT2_USB_TIMEOUT
);
181 static inline int qt2_control_msg(struct usb_device
*dev
,
182 u8 request
, u16 data
, u16 index
)
184 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
185 request
, 0x40, data
, index
,
186 NULL
, 0, QT2_USB_TIMEOUT
);
189 static inline int qt2_setdevice(struct usb_device
*dev
, u8
*data
)
191 u16 x
= ((u16
) (data
[1] << 8) | (u16
) (data
[0]));
193 return qt2_control_msg(dev
, QT_SET_GET_DEVICE
, x
, 0);
197 static inline int qt2_getdevice(struct usb_device
*dev
, u8
*data
)
199 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
200 QT_SET_GET_DEVICE
, 0xc0, 0, 0,
201 data
, 3, QT2_USB_TIMEOUT
);
204 static inline int qt2_getregister(struct usb_device
*dev
,
209 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
210 QT_SET_GET_REGISTER
, 0xc0, reg
,
211 uart
, data
, sizeof(*data
), QT2_USB_TIMEOUT
);
215 static inline int qt2_setregister(struct usb_device
*dev
,
216 u8 uart
, u8 reg
, u16 data
)
218 u16 value
= (data
<< 8) | reg
;
220 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
221 QT_SET_GET_REGISTER
, 0x40, value
, uart
,
222 NULL
, 0, QT2_USB_TIMEOUT
);
225 static inline int update_mctrl(struct qt2_port_private
*port_priv
,
226 unsigned int set
, unsigned int clear
)
228 struct usb_serial_port
*port
= port_priv
->port
;
229 struct usb_device
*dev
= port
->serial
->dev
;
233 if (((set
| clear
) & (TIOCM_DTR
| TIOCM_RTS
)) == 0) {
235 "update_mctrl - DTR|RTS not being set|cleared\n");
236 return 0; /* no change */
239 clear
&= ~set
; /* 'set' takes precedence over 'clear' */
242 urb_value
|= UART_MCR_DTR
;
244 urb_value
|= UART_MCR_RTS
;
246 status
= qt2_setregister(dev
, port_priv
->device_port
, UART_MCR
,
250 "update_mctrl - Error from MODEM_CTRL urb: %i\n",
255 static int qt2_calc_num_ports(struct usb_serial
*serial
)
257 struct qt2_device_detail d
;
260 for (i
= 0; d
= qt2_device_details
[i
], d
.product_id
!= 0; i
++) {
261 if (d
.product_id
== le16_to_cpu(serial
->dev
->descriptor
.idProduct
))
265 /* we didn't recognize the device */
266 dev_err(&serial
->dev
->dev
,
267 "don't know the number of ports, assuming 1\n");
272 static void qt2_set_termios(struct tty_struct
*tty
,
273 struct usb_serial_port
*port
,
274 struct ktermios
*old_termios
)
276 struct usb_device
*dev
= port
->serial
->dev
;
277 struct qt2_port_private
*port_priv
;
278 struct ktermios
*termios
= tty
->termios
;
280 unsigned int cflag
= termios
->c_cflag
;
284 port_priv
= usb_get_serial_port_data(port
);
286 if (cflag
& PARENB
) {
288 new_lcr
|= UART_LCR_PARITY
;
290 new_lcr
|= SERIAL_EVEN_PARITY
;
293 switch (cflag
& CSIZE
) {
295 new_lcr
|= UART_LCR_WLEN5
;
298 new_lcr
|= UART_LCR_WLEN6
;
301 new_lcr
|= UART_LCR_WLEN7
;
305 new_lcr
|= UART_LCR_WLEN8
;
309 baud
= tty_get_baud_rate(tty
);
313 status
= qt2_set_port_config(dev
, port_priv
->device_port
, baud
,
316 dev_err(&port
->dev
, "%s - qt2_set_port_config failed: %i\n",
320 status
= qt2_control_msg(dev
, QT_HW_FLOW_CONTROL_MASK
,
322 port_priv
->device_port
);
324 status
= qt2_control_msg(dev
, QT_HW_FLOW_CONTROL_MASK
,
325 0, port_priv
->device_port
);
327 dev_err(&port
->dev
, "%s - set HW flow control failed: %i\n",
330 if (I_IXOFF(tty
) || I_IXON(tty
)) {
331 u16 x
= ((u16
) (START_CHAR(tty
) << 8) | (u16
) (STOP_CHAR(tty
)));
333 status
= qt2_control_msg(dev
, QT_SW_FLOW_CONTROL_MASK
,
334 x
, port_priv
->device_port
);
336 status
= qt2_control_msg(dev
, QT_SW_FLOW_CONTROL_MASK
,
337 0, port_priv
->device_port
);
340 dev_err(&port
->dev
, "%s - set SW flow control failed: %i\n",
345 static int qt2_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
347 struct usb_serial
*serial
;
348 struct qt2_port_private
*port_priv
;
354 device_port
= (u16
) (port
->number
- port
->serial
->minor
);
356 serial
= port
->serial
;
358 port_priv
= usb_get_serial_port_data(port
);
360 /* set the port to RS232 mode */
361 status
= qt2_control_msg(serial
->dev
, QT2_GET_SET_QMCR
,
362 QT2_QMCR_RS232
, device_port
);
365 "%s failed to set RS232 mode for port %i error %i\n",
366 __func__
, device_port
, status
);
370 data
= kzalloc(2, GFP_KERNEL
);
375 status
= usb_control_msg(serial
->dev
,
376 usb_rcvctrlpipe(serial
->dev
, 0),
377 QT_OPEN_CLOSE_CHANNEL
,
379 device_port
, data
, 2, QT2_USB_TIMEOUT
);
382 dev_err(&port
->dev
, "%s - open port failed %i", __func__
,
388 spin_lock_irqsave(&port_priv
->lock
, flags
);
389 port_priv
->shadowLSR
= data
[0];
390 port_priv
->shadowMSR
= data
[1];
391 spin_unlock_irqrestore(&port_priv
->lock
, flags
);
395 /* set to default speed and 8bit word size */
396 status
= qt2_set_port_config(serial
->dev
, device_port
,
397 DEFAULT_BAUD_RATE
, UART_LCR_WLEN8
);
400 "%s - initial setup failed for port %i (%i)\n",
401 __func__
, port
->number
, device_port
);
405 port_priv
->is_open
= true;
406 port_priv
->device_port
= (u8
) device_port
;
409 qt2_set_termios(tty
, port
, tty
->termios
);
415 static void qt2_close(struct usb_serial_port
*port
)
417 struct usb_serial
*serial
;
418 struct qt2_port_private
*port_priv
;
422 serial
= port
->serial
;
423 port_priv
= usb_get_serial_port_data(port
);
425 port_priv
->is_open
= false;
427 spin_lock_irqsave(&port_priv
->urb_lock
, flags
);
428 if (port_priv
->write_urb
->status
== -EINPROGRESS
)
429 usb_kill_urb(port_priv
->write_urb
);
430 port_priv
->urb_in_use
= false;
431 spin_unlock_irqrestore(&port_priv
->urb_lock
, flags
);
433 /* flush the port transmit buffer */
434 i
= usb_control_msg(serial
->dev
,
435 usb_rcvctrlpipe(serial
->dev
, 0),
436 QT2_FLUSH_DEVICE
, 0x40, 1,
437 port_priv
->device_port
, NULL
, 0, QT2_USB_TIMEOUT
);
440 dev_err(&port
->dev
, "%s - transmit buffer flush failed: %i\n",
443 /* flush the port receive buffer */
444 i
= usb_control_msg(serial
->dev
,
445 usb_rcvctrlpipe(serial
->dev
, 0),
446 QT2_FLUSH_DEVICE
, 0x40, 0,
447 port_priv
->device_port
, NULL
, 0, QT2_USB_TIMEOUT
);
450 dev_err(&port
->dev
, "%s - receive buffer flush failed: %i\n",
454 i
= usb_control_msg(serial
->dev
,
455 usb_sndctrlpipe(serial
->dev
, 0),
456 QT_OPEN_CLOSE_CHANNEL
,
458 port_priv
->device_port
, NULL
, 0, QT2_USB_TIMEOUT
);
461 dev_err(&port
->dev
, "%s - close port failed %i\n",
466 static void qt2_disconnect(struct usb_serial
*serial
)
468 struct qt2_serial_private
*serial_priv
= usb_get_serial_data(serial
);
469 struct qt2_port_private
*port_priv
;
472 if (serial_priv
->read_urb
->status
== -EINPROGRESS
)
473 usb_kill_urb(serial_priv
->read_urb
);
475 usb_free_urb(serial_priv
->read_urb
);
477 for (i
= 0; i
< serial
->num_ports
; i
++) {
478 port_priv
= usb_get_serial_port_data(serial
->port
[i
]);
480 if (port_priv
->write_urb
->status
== -EINPROGRESS
)
481 usb_kill_urb(port_priv
->write_urb
);
482 usb_free_urb(port_priv
->write_urb
);
486 static int get_serial_info(struct usb_serial_port
*port
,
487 struct serial_struct __user
*retinfo
)
489 struct serial_struct tmp
;
494 memset(&tmp
, 0, sizeof(tmp
));
495 tmp
.line
= port
->serial
->minor
;
498 tmp
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
499 tmp
.xmit_fifo_size
= port
->bulk_out_size
;
500 tmp
.baud_base
= 9600;
501 tmp
.close_delay
= 5*HZ
;
502 tmp
.closing_wait
= 30*HZ
;
504 if (copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)))
509 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
511 struct qt2_port_private
*priv
= usb_get_serial_port_data(port
);
512 struct async_icount prev
, cur
;
515 spin_lock_irqsave(&priv
->lock
, flags
);
517 spin_unlock_irqrestore(&priv
->lock
, flags
);
520 wait_event_interruptible(priv
->delta_msr_wait
,
521 ((priv
->icount
.rng
!= prev
.rng
) ||
522 (priv
->icount
.dsr
!= prev
.dsr
) ||
523 (priv
->icount
.dcd
!= prev
.dcd
) ||
524 (priv
->icount
.cts
!= prev
.cts
)));
526 if (signal_pending(current
))
529 spin_lock_irqsave(&priv
->lock
, flags
);
531 spin_unlock_irqrestore(&priv
->lock
, flags
);
533 if ((prev
.rng
== cur
.rng
) &&
534 (prev
.dsr
== cur
.dsr
) &&
535 (prev
.dcd
== cur
.dcd
) &&
536 (prev
.cts
== cur
.cts
))
539 if ((arg
& TIOCM_RNG
&& (prev
.rng
!= cur
.rng
)) ||
540 (arg
& TIOCM_DSR
&& (prev
.dsr
!= cur
.dsr
)) ||
541 (arg
& TIOCM_CD
&& (prev
.dcd
!= cur
.dcd
)) ||
542 (arg
& TIOCM_CTS
&& (prev
.cts
!= cur
.cts
)))
548 static int qt2_get_icount(struct tty_struct
*tty
,
549 struct serial_icounter_struct
*icount
)
551 struct usb_serial_port
*port
= tty
->driver_data
;
552 struct qt2_port_private
*priv
= usb_get_serial_port_data(port
);
553 struct async_icount cnow
= priv
->icount
;
555 icount
->cts
= cnow
.cts
;
556 icount
->dsr
= cnow
.dsr
;
557 icount
->rng
= cnow
.rng
;
558 icount
->dcd
= cnow
.dcd
;
559 icount
->rx
= cnow
.rx
;
560 icount
->tx
= cnow
.tx
;
561 icount
->frame
= cnow
.frame
;
562 icount
->overrun
= cnow
.overrun
;
563 icount
->parity
= cnow
.parity
;
564 icount
->brk
= cnow
.brk
;
565 icount
->buf_overrun
= cnow
.buf_overrun
;
570 static int qt2_ioctl(struct tty_struct
*tty
,
571 unsigned int cmd
, unsigned long arg
)
573 struct usb_serial_port
*port
= tty
->driver_data
;
577 return get_serial_info(port
,
578 (struct serial_struct __user
*)arg
);
581 return wait_modem_info(port
, arg
);
590 static void qt2_process_status(struct usb_serial_port
*port
, unsigned char *ch
)
593 case QT2_LINE_STATUS
:
594 qt2_update_lsr(port
, ch
+ 1);
596 case QT2_MODEM_STATUS
:
597 qt2_update_msr(port
, ch
+ 1);
602 /* not needed, kept to document functionality */
603 static void qt2_process_xmit_empty(struct usb_serial_port
*port
,
608 bytes_written
= (int)(*ch
) + (int)(*(ch
+ 1) << 4);
611 /* not needed, kept to document functionality */
612 static void qt2_process_flush(struct usb_serial_port
*port
, unsigned char *ch
)
617 void qt2_process_read_urb(struct urb
*urb
)
619 struct usb_serial
*serial
;
620 struct qt2_serial_private
*serial_priv
;
621 struct usb_serial_port
*port
;
622 struct qt2_port_private
*port_priv
;
623 struct tty_struct
*tty
;
627 unsigned char newport
;
628 int len
= urb
->actual_length
;
633 ch
= urb
->transfer_buffer
;
635 serial
= urb
->context
;
636 serial_priv
= usb_get_serial_data(serial
);
637 port
= serial
->port
[serial_priv
->current_port
];
638 port_priv
= usb_get_serial_port_data(port
);
640 if (port_priv
->is_open
)
641 tty
= tty_port_tty_get(&port
->port
);
643 for (i
= 0; i
< urb
->actual_length
; i
++) {
644 ch
= (unsigned char *)urb
->transfer_buffer
+ i
;
645 if ((i
<= (len
- 3)) &&
646 (*ch
== QT2_CONTROL_BYTE
) &&
647 (*(ch
+ 1) == QT2_CONTROL_BYTE
)) {
650 case QT2_LINE_STATUS
:
651 case QT2_MODEM_STATUS
:
654 "%s - status message too short\n",
658 qt2_process_status(port
, ch
+ 2);
665 "%s - xmit_empty message too short\n",
669 qt2_process_xmit_empty(port
, ch
+ 3);
673 case QT2_CHANGE_PORT
:
676 "%s - change_port message too short\n",
681 tty_flip_buffer_push(tty
);
687 if (newport
> serial
->num_ports
) {
689 "%s - port change to invalid port: %i\n",
694 serial_priv
->current_port
= newport
;
695 port
= serial
->port
[serial_priv
->current_port
];
696 port_priv
= usb_get_serial_port_data(port
);
697 if (port_priv
->is_open
)
698 tty
= tty_port_tty_get(&port
->port
);
706 qt2_process_flush(port
, ch
+ 2);
710 case QT2_CONTROL_ESCAPE
:
711 tty_buffer_request_room(tty
, 2);
712 tty_insert_flip_string(tty
, ch
, 2);
718 "%s - unsupported command %i\n",
719 __func__
, *(ch
+ 2));
727 tty_buffer_request_room(tty
, 1);
728 tty_insert_flip_string(tty
, ch
, 1);
733 tty_flip_buffer_push(tty
);
738 static void qt2_write_bulk_callback(struct urb
*urb
)
740 struct usb_serial_port
*port
;
741 struct qt2_port_private
*port_priv
;
744 port_priv
= usb_get_serial_port_data(port
);
746 spin_lock(&port_priv
->urb_lock
);
748 port_priv
->urb_in_use
= false;
749 usb_serial_port_softint(port
);
751 spin_unlock(&port_priv
->urb_lock
);
755 static void qt2_read_bulk_callback(struct urb
*urb
)
757 struct usb_serial
*serial
= urb
->context
;
761 dev_warn(&serial
->dev
->dev
,
762 "%s - non-zero urb status: %i\n", __func__
,
767 qt2_process_read_urb(urb
);
769 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
771 dev_err(&serial
->dev
->dev
,
772 "%s - resubmit read urb failed: %i\n",
776 static int qt2_setup_urbs(struct usb_serial
*serial
)
778 struct usb_serial_port
*port
;
779 struct usb_serial_port
*port0
;
780 struct qt2_serial_private
*serial_priv
;
781 struct qt2_port_private
*port_priv
;
784 port0
= serial
->port
[0];
786 serial_priv
= usb_get_serial_data(serial
);
787 serial_priv
->read_urb
= usb_alloc_urb(0, GFP_KERNEL
);
788 if (!serial_priv
->read_urb
) {
789 dev_err(&serial
->dev
->dev
, "No free urbs available\n");
793 usb_fill_bulk_urb(serial_priv
->read_urb
, serial
->dev
,
794 usb_rcvbulkpipe(serial
->dev
,
795 port0
->bulk_in_endpointAddress
),
796 serial_priv
->read_buffer
,
797 sizeof(serial_priv
->read_buffer
),
798 qt2_read_bulk_callback
, serial
);
800 /* setup write_urb for each port */
801 for (pcount
= 0; pcount
< serial
->num_ports
; pcount
++) {
803 port
= serial
->port
[pcount
];
804 port_priv
= usb_get_serial_port_data(port
);
806 port_priv
->write_urb
= usb_alloc_urb(0, GFP_KERNEL
);
807 if (!port_priv
->write_urb
) {
808 dev_err(&serial
->dev
->dev
,
809 "failed to alloc write_urb for port %i\n",
814 usb_fill_bulk_urb(port_priv
->write_urb
,
816 usb_sndbulkpipe(serial
->dev
,
818 bulk_out_endpointAddress
),
819 port_priv
->write_buffer
,
820 sizeof(port_priv
->write_buffer
),
821 qt2_write_bulk_callback
, port
);
824 status
= usb_submit_urb(serial_priv
->read_urb
, GFP_KERNEL
);
826 dev_err(&serial
->dev
->dev
,
827 "%s - submit read urb failed %i\n", __func__
, status
);
835 static int qt2_attach(struct usb_serial
*serial
)
837 struct qt2_serial_private
*serial_priv
;
838 struct qt2_port_private
*port_priv
;
842 status
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
843 0xc2, 0x40, 0x8000, 0, NULL
, 0,
846 dev_err(&serial
->dev
->dev
,
847 "%s - failed to power on unit: %i\n", __func__
, status
);
851 serial_priv
= kzalloc(sizeof(*serial_priv
), GFP_KERNEL
);
853 dev_err(&serial
->dev
->dev
, "%s - Out of memory\n", __func__
);
857 usb_set_serial_data(serial
, serial_priv
);
859 for (pcount
= 0; pcount
< serial
->num_ports
; pcount
++) {
860 port_priv
= kzalloc(sizeof(*port_priv
), GFP_KERNEL
);
862 dev_err(&serial
->dev
->dev
,
863 "%s- kmalloc(%Zd) failed.\n", __func__
,
870 spin_lock_init(&port_priv
->lock
);
871 spin_lock_init(&port_priv
->urb_lock
);
872 init_waitqueue_head(&port_priv
->delta_msr_wait
);
874 port_priv
->port
= serial
->port
[pcount
];
876 usb_set_serial_port_data(serial
->port
[pcount
], port_priv
);
879 status
= qt2_setup_urbs(serial
);
886 for (/* empty */; pcount
>= 0; pcount
--) {
887 port_priv
= usb_get_serial_port_data(serial
->port
[pcount
]);
894 static int qt2_tiocmget(struct tty_struct
*tty
)
896 struct usb_serial_port
*port
= tty
->driver_data
;
897 struct usb_device
*dev
= port
->serial
->dev
;
898 struct qt2_port_private
*port_priv
= usb_get_serial_port_data(port
);
902 d
= kzalloc(2, GFP_KERNEL
);
906 r
= qt2_getregister(dev
, port_priv
->device_port
, UART_MCR
, d
);
910 r
= qt2_getregister(dev
, port_priv
->device_port
, UART_MSR
, d
+ 1);
914 r
= (d
[0] & UART_MCR_DTR
? TIOCM_DTR
: 0) |
915 (d
[0] & UART_MCR_RTS
? TIOCM_RTS
: 0) |
916 (d
[1] & UART_MSR_CTS
? TIOCM_CTS
: 0) |
917 (d
[1] & UART_MSR_DCD
? TIOCM_CAR
: 0) |
918 (d
[1] & UART_MSR_RI
? TIOCM_RI
: 0) |
919 (d
[1] & UART_MSR_DSR
? TIOCM_DSR
: 0);
926 static int qt2_tiocmset(struct tty_struct
*tty
,
927 unsigned int set
, unsigned int clear
)
929 struct qt2_port_private
*port_priv
;
931 port_priv
= usb_get_serial_port_data(tty
->driver_data
);
932 return update_mctrl(port_priv
, set
, clear
);
935 static void qt2_break_ctl(struct tty_struct
*tty
, int break_state
)
937 struct usb_serial_port
*port
= tty
->driver_data
;
938 struct qt2_port_private
*port_priv
;
942 port_priv
= usb_get_serial_port_data(port
);
944 if (!port_priv
->is_open
) {
946 "%s - port is not open\n", __func__
);
950 val
= (break_state
== -1) ? 1 : 0;
952 status
= qt2_control_msg(port
->serial
->dev
, QT2_BREAK_CONTROL
,
953 val
, port_priv
->device_port
);
956 "%s - failed to send control message: %i\n", __func__
,
962 static void qt2_dtr_rts(struct usb_serial_port
*port
, int on
)
964 struct usb_device
*dev
= port
->serial
->dev
;
965 struct qt2_port_private
*port_priv
= usb_get_serial_port_data(port
);
967 mutex_lock(&port
->serial
->disc_mutex
);
968 if (!port
->serial
->disconnected
) {
969 /* Disable flow control */
970 if (!on
&& qt2_setregister(dev
, port_priv
->device_port
,
972 dev_warn(&port
->dev
, "error from flowcontrol urb\n");
973 /* drop RTS and DTR */
975 update_mctrl(port_priv
, TIOCM_DTR
| TIOCM_RTS
, 0);
977 update_mctrl(port_priv
, 0, TIOCM_DTR
| TIOCM_RTS
);
979 mutex_unlock(&port
->serial
->disc_mutex
);
982 static void qt2_update_msr(struct usb_serial_port
*port
, unsigned char *ch
)
984 struct qt2_port_private
*port_priv
;
985 u8 newMSR
= (u8
) *ch
;
988 port_priv
= usb_get_serial_port_data(port
);
990 spin_lock_irqsave(&port_priv
->lock
, flags
);
991 port_priv
->shadowMSR
= newMSR
;
992 spin_unlock_irqrestore(&port_priv
->lock
, flags
);
994 if (newMSR
& UART_MSR_ANY_DELTA
) {
995 /* update input line counters */
996 if (newMSR
& UART_MSR_DCTS
)
997 port_priv
->icount
.cts
++;
999 if (newMSR
& UART_MSR_DDSR
)
1000 port_priv
->icount
.dsr
++;
1002 if (newMSR
& UART_MSR_DDCD
)
1003 port_priv
->icount
.dcd
++;
1005 if (newMSR
& UART_MSR_TERI
)
1006 port_priv
->icount
.rng
++;
1008 wake_up_interruptible(&port_priv
->delta_msr_wait
);
1012 static void qt2_update_lsr(struct usb_serial_port
*port
, unsigned char *ch
)
1014 struct qt2_port_private
*port_priv
;
1015 struct async_icount
*icount
;
1016 unsigned long flags
;
1017 u8 newLSR
= (u8
) *ch
;
1019 port_priv
= usb_get_serial_port_data(port
);
1021 if (newLSR
& UART_LSR_BI
)
1022 newLSR
&= (u8
) (UART_LSR_OE
| UART_LSR_BI
);
1024 spin_lock_irqsave(&port_priv
->lock
, flags
);
1025 port_priv
->shadowLSR
= newLSR
;
1026 spin_unlock_irqrestore(&port_priv
->lock
, flags
);
1028 icount
= &port_priv
->icount
;
1030 if (newLSR
& UART_LSR_BRK_ERROR_BITS
) {
1032 if (newLSR
& UART_LSR_BI
)
1035 if (newLSR
& UART_LSR_OE
)
1038 if (newLSR
& UART_LSR_PE
)
1041 if (newLSR
& UART_LSR_FE
)
1047 static int qt2_write_room(struct tty_struct
*tty
)
1049 struct usb_serial_port
*port
= tty
->driver_data
;
1050 struct qt2_port_private
*port_priv
;
1051 unsigned long flags
= 0;
1054 port_priv
= usb_get_serial_port_data(port
);
1056 spin_lock_irqsave(&port_priv
->urb_lock
, flags
);
1058 if (port_priv
->urb_in_use
)
1061 r
= QT2_WRITE_BUFFER_SIZE
- QT2_WRITE_CONTROL_SIZE
;
1063 spin_unlock_irqrestore(&port_priv
->urb_lock
, flags
);
1068 static int qt2_write(struct tty_struct
*tty
,
1069 struct usb_serial_port
*port
,
1070 const unsigned char *buf
, int count
)
1072 struct qt2_port_private
*port_priv
;
1073 struct urb
*write_urb
;
1074 unsigned char *data
;
1075 unsigned long flags
;
1079 port_priv
= usb_get_serial_port_data(port
);
1081 if (port_priv
->write_urb
== NULL
) {
1082 dev_err(&port
->dev
, "%s - no output urb\n", __func__
);
1085 write_urb
= port_priv
->write_urb
;
1087 count
= min(count
, QT2_WRITE_BUFFER_SIZE
- QT2_WRITE_CONTROL_SIZE
);
1089 data
= write_urb
->transfer_buffer
;
1090 spin_lock_irqsave(&port_priv
->urb_lock
, flags
);
1091 if (port_priv
->urb_in_use
== true) {
1092 printk(KERN_INFO
"qt2_write - urb is in use\n");
1096 *data
++ = QT2_CONTROL_BYTE
;
1097 *data
++ = QT2_CONTROL_BYTE
;
1098 *data
++ = port_priv
->device_port
;
1099 put_unaligned_le16(count
, data
);
1101 memcpy(data
, buf
, count
);
1103 write_urb
->transfer_buffer_length
= count
+ QT2_WRITE_CONTROL_SIZE
;
1105 status
= usb_submit_urb(write_urb
, GFP_ATOMIC
);
1107 port_priv
->urb_in_use
= true;
1112 spin_unlock_irqrestore(&port_priv
->urb_lock
, flags
);
1117 static struct usb_serial_driver qt2_device
= {
1119 .owner
= THIS_MODULE
,
1120 .name
= "quatech-serial",
1122 .description
= DRIVER_DESC
,
1123 .id_table
= id_table
,
1127 .write_room
= qt2_write_room
,
1128 .calc_num_ports
= qt2_calc_num_ports
,
1129 .attach
= qt2_attach
,
1130 .release
= qt2_release
,
1131 .disconnect
= qt2_disconnect
,
1132 .dtr_rts
= qt2_dtr_rts
,
1133 .break_ctl
= qt2_break_ctl
,
1134 .tiocmget
= qt2_tiocmget
,
1135 .tiocmset
= qt2_tiocmset
,
1136 .get_icount
= qt2_get_icount
,
1138 .set_termios
= qt2_set_termios
,
1141 static struct usb_serial_driver
*const serial_drivers
[] = {
1145 module_usb_serial_driver(serial_drivers
, id_table
);
1147 MODULE_DESCRIPTION(DRIVER_DESC
);
1148 MODULE_LICENSE("GPL");
1150 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1151 MODULE_PARM_DESC(debug
, "Debug enabled or not");