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>
30 /* default urb timeout for usb operations */
31 #define QT2_USB_TIMEOUT USB_CTRL_SET_TIMEOUT
33 #define QT_OPEN_CLOSE_CHANNEL 0xca
34 #define QT_SET_GET_DEVICE 0xc2
35 #define QT_SET_GET_REGISTER 0xc0
36 #define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
37 #define QT_SET_ATF 0xcd
38 #define QT_TRANSFER_IN 0xc0
39 #define QT_HW_FLOW_CONTROL_MASK 0xc5
40 #define QT_SW_FLOW_CONTROL_MASK 0xc6
41 #define QT2_BREAK_CONTROL 0xc8
42 #define QT2_GET_SET_UART 0xc1
43 #define QT2_FLUSH_DEVICE 0xc4
44 #define QT2_GET_SET_QMCR 0xe1
45 #define QT2_QMCR_RS232 0x40
46 #define QT2_QMCR_RS422 0x10
48 #define SERIAL_CRTSCTS ((UART_MCR_RTS << 8) | UART_MSR_CTS)
50 #define SERIAL_EVEN_PARITY (UART_LCR_PARITY | UART_LCR_EPAR)
52 /* status bytes for the device */
53 #define QT2_CONTROL_BYTE 0x1b
54 #define QT2_LINE_STATUS 0x00 /* following 1 byte is line status */
55 #define QT2_MODEM_STATUS 0x01 /* following 1 byte is modem status */
56 #define QT2_XMIT_HOLD 0x02 /* following 2 bytes are ?? */
57 #define QT2_CHANGE_PORT 0x03 /* following 1 byte is port to change to */
58 #define QT2_REC_FLUSH 0x04 /* no following info */
59 #define QT2_XMIT_FLUSH 0x05 /* no following info */
60 #define QT2_CONTROL_ESCAPE 0xff /* pass through previous 2 control bytes */
62 #define MAX_BAUD_RATE 921600
63 #define DEFAULT_BAUD_RATE 9600
65 #define QT2_WRITE_BUFFER_SIZE 512 /* size of write buffer */
66 #define QT2_WRITE_CONTROL_SIZE 5 /* control bytes used for a write */
68 #define DRIVER_DESC "Quatech 2nd gen USB to Serial Driver"
70 #define USB_VENDOR_ID_QUATECH 0x061d
71 #define QUATECH_SSU2_100 0xC120 /* RS232 single port */
72 #define QUATECH_DSU2_100 0xC140 /* RS232 dual port */
73 #define QUATECH_DSU2_400 0xC150 /* RS232/422/485 dual port */
74 #define QUATECH_QSU2_100 0xC160 /* RS232 four port */
75 #define QUATECH_QSU2_400 0xC170 /* RS232/422/485 four port */
76 #define QUATECH_ESU2_100 0xC1A0 /* RS232 eight port */
77 #define QUATECH_ESU2_400 0xC180 /* RS232/422/485 eight port */
79 struct qt2_device_detail
{
84 #define QT_DETAILS(prod, ports) \
85 .product_id = (prod), \
88 static const struct qt2_device_detail qt2_device_details
[] = {
89 {QT_DETAILS(QUATECH_SSU2_100
, 1)},
90 {QT_DETAILS(QUATECH_DSU2_400
, 2)},
91 {QT_DETAILS(QUATECH_DSU2_100
, 2)},
92 {QT_DETAILS(QUATECH_QSU2_400
, 4)},
93 {QT_DETAILS(QUATECH_QSU2_100
, 4)},
94 {QT_DETAILS(QUATECH_ESU2_400
, 8)},
95 {QT_DETAILS(QUATECH_ESU2_100
, 8)},
96 {QT_DETAILS(0, 0)} /* Terminating entry */
99 static const struct usb_device_id id_table
[] = {
100 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_SSU2_100
)},
101 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_DSU2_100
)},
102 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_DSU2_400
)},
103 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_QSU2_100
)},
104 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_QSU2_400
)},
105 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_ESU2_100
)},
106 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_ESU2_400
)},
107 {} /* Terminating entry */
109 MODULE_DEVICE_TABLE(usb
, id_table
);
111 struct qt2_serial_private
{
112 unsigned char current_port
; /* current port for incoming data */
114 struct urb
*read_urb
; /* shared among all ports */
115 char read_buffer
[512];
118 struct qt2_port_private
{
124 struct urb
*write_urb
;
125 char write_buffer
[QT2_WRITE_BUFFER_SIZE
];
131 wait_queue_head_t delta_msr_wait
; /* Used for TIOCMIWAIT */
132 struct async_icount icount
;
134 struct usb_serial_port
*port
;
137 static void qt2_update_lsr(struct usb_serial_port
*port
, unsigned char *ch
);
138 static void qt2_update_msr(struct usb_serial_port
*port
, unsigned char *ch
);
139 static void qt2_write_bulk_callback(struct urb
*urb
);
140 static void qt2_read_bulk_callback(struct urb
*urb
);
142 static void qt2_release(struct usb_serial
*serial
)
144 struct qt2_serial_private
*serial_priv
;
146 serial_priv
= usb_get_serial_data(serial
);
148 usb_free_urb(serial_priv
->read_urb
);
152 static inline int calc_baud_divisor(int baudrate
)
156 divisor
= MAX_BAUD_RATE
/ baudrate
;
157 rem
= MAX_BAUD_RATE
% baudrate
;
158 /* Round to nearest divisor */
159 if (((rem
* 2) >= baudrate
) && (baudrate
!= 110))
165 static inline int qt2_set_port_config(struct usb_device
*dev
,
166 unsigned char port_number
,
167 u16 baudrate
, u16 lcr
)
169 int divisor
= calc_baud_divisor(baudrate
);
170 u16 index
= ((u16
) (lcr
<< 8) | (u16
) (port_number
));
172 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
173 QT2_GET_SET_UART
, 0x40,
174 divisor
, index
, NULL
, 0, QT2_USB_TIMEOUT
);
177 static inline int qt2_control_msg(struct usb_device
*dev
,
178 u8 request
, u16 data
, u16 index
)
180 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
181 request
, 0x40, data
, index
,
182 NULL
, 0, QT2_USB_TIMEOUT
);
185 static inline int qt2_setdevice(struct usb_device
*dev
, u8
*data
)
187 u16 x
= ((u16
) (data
[1] << 8) | (u16
) (data
[0]));
189 return qt2_control_msg(dev
, QT_SET_GET_DEVICE
, x
, 0);
193 static inline int qt2_getdevice(struct usb_device
*dev
, u8
*data
)
195 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
196 QT_SET_GET_DEVICE
, 0xc0, 0, 0,
197 data
, 3, QT2_USB_TIMEOUT
);
200 static inline int qt2_getregister(struct usb_device
*dev
,
205 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
206 QT_SET_GET_REGISTER
, 0xc0, reg
,
207 uart
, data
, sizeof(*data
), QT2_USB_TIMEOUT
);
211 static inline int qt2_setregister(struct usb_device
*dev
,
212 u8 uart
, u8 reg
, u16 data
)
214 u16 value
= (data
<< 8) | reg
;
216 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
217 QT_SET_GET_REGISTER
, 0x40, value
, uart
,
218 NULL
, 0, QT2_USB_TIMEOUT
);
221 static inline int update_mctrl(struct qt2_port_private
*port_priv
,
222 unsigned int set
, unsigned int clear
)
224 struct usb_serial_port
*port
= port_priv
->port
;
225 struct usb_device
*dev
= port
->serial
->dev
;
229 if (((set
| clear
) & (TIOCM_DTR
| TIOCM_RTS
)) == 0) {
231 "update_mctrl - DTR|RTS not being set|cleared\n");
232 return 0; /* no change */
235 clear
&= ~set
; /* 'set' takes precedence over 'clear' */
238 urb_value
|= UART_MCR_DTR
;
240 urb_value
|= UART_MCR_RTS
;
242 status
= qt2_setregister(dev
, port_priv
->device_port
, UART_MCR
,
246 "update_mctrl - Error from MODEM_CTRL urb: %i\n",
251 static int qt2_calc_num_ports(struct usb_serial
*serial
)
253 struct qt2_device_detail d
;
256 for (i
= 0; d
= qt2_device_details
[i
], d
.product_id
!= 0; i
++) {
257 if (d
.product_id
== le16_to_cpu(serial
->dev
->descriptor
.idProduct
))
261 /* we didn't recognize the device */
262 dev_err(&serial
->dev
->dev
,
263 "don't know the number of ports, assuming 1\n");
268 static void qt2_set_termios(struct tty_struct
*tty
,
269 struct usb_serial_port
*port
,
270 struct ktermios
*old_termios
)
272 struct usb_device
*dev
= port
->serial
->dev
;
273 struct qt2_port_private
*port_priv
;
274 struct ktermios
*termios
= &tty
->termios
;
276 unsigned int cflag
= termios
->c_cflag
;
280 port_priv
= usb_get_serial_port_data(port
);
282 if (cflag
& PARENB
) {
284 new_lcr
|= UART_LCR_PARITY
;
286 new_lcr
|= SERIAL_EVEN_PARITY
;
289 switch (cflag
& CSIZE
) {
291 new_lcr
|= UART_LCR_WLEN5
;
294 new_lcr
|= UART_LCR_WLEN6
;
297 new_lcr
|= UART_LCR_WLEN7
;
301 new_lcr
|= UART_LCR_WLEN8
;
305 baud
= tty_get_baud_rate(tty
);
309 status
= qt2_set_port_config(dev
, port_priv
->device_port
, baud
,
312 dev_err(&port
->dev
, "%s - qt2_set_port_config failed: %i\n",
316 status
= qt2_control_msg(dev
, QT_HW_FLOW_CONTROL_MASK
,
318 port_priv
->device_port
);
320 status
= qt2_control_msg(dev
, QT_HW_FLOW_CONTROL_MASK
,
321 0, port_priv
->device_port
);
323 dev_err(&port
->dev
, "%s - set HW flow control failed: %i\n",
326 if (I_IXOFF(tty
) || I_IXON(tty
)) {
327 u16 x
= ((u16
) (START_CHAR(tty
) << 8) | (u16
) (STOP_CHAR(tty
)));
329 status
= qt2_control_msg(dev
, QT_SW_FLOW_CONTROL_MASK
,
330 x
, port_priv
->device_port
);
332 status
= qt2_control_msg(dev
, QT_SW_FLOW_CONTROL_MASK
,
333 0, port_priv
->device_port
);
336 dev_err(&port
->dev
, "%s - set SW flow control failed: %i\n",
341 static int qt2_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
343 struct usb_serial
*serial
;
344 struct qt2_port_private
*port_priv
;
350 device_port
= (u16
) (port
->number
- port
->serial
->minor
);
352 serial
= port
->serial
;
354 port_priv
= usb_get_serial_port_data(port
);
356 /* set the port to RS232 mode */
357 status
= qt2_control_msg(serial
->dev
, QT2_GET_SET_QMCR
,
358 QT2_QMCR_RS232
, device_port
);
361 "%s failed to set RS232 mode for port %i error %i\n",
362 __func__
, device_port
, status
);
366 data
= kzalloc(2, GFP_KERNEL
);
371 status
= usb_control_msg(serial
->dev
,
372 usb_rcvctrlpipe(serial
->dev
, 0),
373 QT_OPEN_CLOSE_CHANNEL
,
375 device_port
, data
, 2, QT2_USB_TIMEOUT
);
378 dev_err(&port
->dev
, "%s - open port failed %i", __func__
,
384 spin_lock_irqsave(&port_priv
->lock
, flags
);
385 port_priv
->shadowLSR
= data
[0];
386 port_priv
->shadowMSR
= data
[1];
387 spin_unlock_irqrestore(&port_priv
->lock
, flags
);
391 /* set to default speed and 8bit word size */
392 status
= qt2_set_port_config(serial
->dev
, device_port
,
393 DEFAULT_BAUD_RATE
, UART_LCR_WLEN8
);
396 "%s - initial setup failed for port %i (%i)\n",
397 __func__
, port
->number
, device_port
);
401 port_priv
->is_open
= true;
402 port_priv
->device_port
= (u8
) device_port
;
405 qt2_set_termios(tty
, port
, &tty
->termios
);
411 static void qt2_close(struct usb_serial_port
*port
)
413 struct usb_serial
*serial
;
414 struct qt2_port_private
*port_priv
;
418 serial
= port
->serial
;
419 port_priv
= usb_get_serial_port_data(port
);
421 port_priv
->is_open
= false;
423 spin_lock_irqsave(&port_priv
->urb_lock
, flags
);
424 usb_kill_urb(port_priv
->write_urb
);
425 port_priv
->urb_in_use
= false;
426 spin_unlock_irqrestore(&port_priv
->urb_lock
, flags
);
428 mutex_lock(&port
->serial
->disc_mutex
);
429 if (port
->serial
->disconnected
) {
430 mutex_unlock(&port
->serial
->disc_mutex
);
434 /* flush the port transmit buffer */
435 i
= usb_control_msg(serial
->dev
,
436 usb_rcvctrlpipe(serial
->dev
, 0),
437 QT2_FLUSH_DEVICE
, 0x40, 1,
438 port_priv
->device_port
, NULL
, 0, QT2_USB_TIMEOUT
);
441 dev_err(&port
->dev
, "%s - transmit buffer flush failed: %i\n",
444 /* flush the port receive buffer */
445 i
= usb_control_msg(serial
->dev
,
446 usb_rcvctrlpipe(serial
->dev
, 0),
447 QT2_FLUSH_DEVICE
, 0x40, 0,
448 port_priv
->device_port
, NULL
, 0, QT2_USB_TIMEOUT
);
451 dev_err(&port
->dev
, "%s - receive buffer flush failed: %i\n",
455 i
= usb_control_msg(serial
->dev
,
456 usb_sndctrlpipe(serial
->dev
, 0),
457 QT_OPEN_CLOSE_CHANNEL
,
459 port_priv
->device_port
, NULL
, 0, QT2_USB_TIMEOUT
);
462 dev_err(&port
->dev
, "%s - close port failed %i\n",
465 mutex_unlock(&port
->serial
->disc_mutex
);
468 static void qt2_disconnect(struct usb_serial
*serial
)
470 struct qt2_serial_private
*serial_priv
= usb_get_serial_data(serial
);
472 usb_kill_urb(serial_priv
->read_urb
);
475 static int get_serial_info(struct usb_serial_port
*port
,
476 struct serial_struct __user
*retinfo
)
478 struct serial_struct tmp
;
483 memset(&tmp
, 0, sizeof(tmp
));
484 tmp
.line
= port
->serial
->minor
;
487 tmp
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
488 tmp
.xmit_fifo_size
= port
->bulk_out_size
;
489 tmp
.baud_base
= 9600;
490 tmp
.close_delay
= 5*HZ
;
491 tmp
.closing_wait
= 30*HZ
;
493 if (copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)))
498 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
500 struct qt2_port_private
*priv
= usb_get_serial_port_data(port
);
501 struct async_icount prev
, cur
;
504 spin_lock_irqsave(&priv
->lock
, flags
);
506 spin_unlock_irqrestore(&priv
->lock
, flags
);
509 wait_event_interruptible(priv
->delta_msr_wait
,
510 ((priv
->icount
.rng
!= prev
.rng
) ||
511 (priv
->icount
.dsr
!= prev
.dsr
) ||
512 (priv
->icount
.dcd
!= prev
.dcd
) ||
513 (priv
->icount
.cts
!= prev
.cts
)));
515 if (signal_pending(current
))
518 spin_lock_irqsave(&priv
->lock
, flags
);
520 spin_unlock_irqrestore(&priv
->lock
, flags
);
522 if ((prev
.rng
== cur
.rng
) &&
523 (prev
.dsr
== cur
.dsr
) &&
524 (prev
.dcd
== cur
.dcd
) &&
525 (prev
.cts
== cur
.cts
))
528 if ((arg
& TIOCM_RNG
&& (prev
.rng
!= cur
.rng
)) ||
529 (arg
& TIOCM_DSR
&& (prev
.dsr
!= cur
.dsr
)) ||
530 (arg
& TIOCM_CD
&& (prev
.dcd
!= cur
.dcd
)) ||
531 (arg
& TIOCM_CTS
&& (prev
.cts
!= cur
.cts
)))
537 static int qt2_get_icount(struct tty_struct
*tty
,
538 struct serial_icounter_struct
*icount
)
540 struct usb_serial_port
*port
= tty
->driver_data
;
541 struct qt2_port_private
*priv
= usb_get_serial_port_data(port
);
542 struct async_icount cnow
= priv
->icount
;
544 icount
->cts
= cnow
.cts
;
545 icount
->dsr
= cnow
.dsr
;
546 icount
->rng
= cnow
.rng
;
547 icount
->dcd
= cnow
.dcd
;
548 icount
->rx
= cnow
.rx
;
549 icount
->tx
= cnow
.tx
;
550 icount
->frame
= cnow
.frame
;
551 icount
->overrun
= cnow
.overrun
;
552 icount
->parity
= cnow
.parity
;
553 icount
->brk
= cnow
.brk
;
554 icount
->buf_overrun
= cnow
.buf_overrun
;
559 static int qt2_ioctl(struct tty_struct
*tty
,
560 unsigned int cmd
, unsigned long arg
)
562 struct usb_serial_port
*port
= tty
->driver_data
;
566 return get_serial_info(port
,
567 (struct serial_struct __user
*)arg
);
570 return wait_modem_info(port
, arg
);
579 static void qt2_process_status(struct usb_serial_port
*port
, unsigned char *ch
)
582 case QT2_LINE_STATUS
:
583 qt2_update_lsr(port
, ch
+ 1);
585 case QT2_MODEM_STATUS
:
586 qt2_update_msr(port
, ch
+ 1);
591 /* not needed, kept to document functionality */
592 static void qt2_process_xmit_empty(struct usb_serial_port
*port
,
597 bytes_written
= (int)(*ch
) + (int)(*(ch
+ 1) << 4);
600 /* not needed, kept to document functionality */
601 static void qt2_process_flush(struct usb_serial_port
*port
, unsigned char *ch
)
606 void qt2_process_read_urb(struct urb
*urb
)
608 struct usb_serial
*serial
;
609 struct qt2_serial_private
*serial_priv
;
610 struct usb_serial_port
*port
;
611 struct qt2_port_private
*port_priv
;
615 unsigned char newport
;
616 int len
= urb
->actual_length
;
621 ch
= urb
->transfer_buffer
;
622 serial
= urb
->context
;
623 serial_priv
= usb_get_serial_data(serial
);
624 port
= serial
->port
[serial_priv
->current_port
];
625 port_priv
= usb_get_serial_port_data(port
);
627 for (i
= 0; i
< urb
->actual_length
; i
++) {
628 ch
= (unsigned char *)urb
->transfer_buffer
+ i
;
629 if ((i
<= (len
- 3)) &&
630 (*ch
== QT2_CONTROL_BYTE
) &&
631 (*(ch
+ 1) == QT2_CONTROL_BYTE
)) {
634 case QT2_LINE_STATUS
:
635 case QT2_MODEM_STATUS
:
638 "%s - status message too short\n",
642 qt2_process_status(port
, ch
+ 2);
649 "%s - xmit_empty message too short\n",
653 qt2_process_xmit_empty(port
, ch
+ 3);
657 case QT2_CHANGE_PORT
:
660 "%s - change_port message too short\n",
664 tty_flip_buffer_push(&port
->port
);
668 if (newport
> serial
->num_ports
) {
670 "%s - port change to invalid port: %i\n",
675 serial_priv
->current_port
= newport
;
676 port
= serial
->port
[serial_priv
->current_port
];
677 port_priv
= usb_get_serial_port_data(port
);
683 qt2_process_flush(port
, ch
+ 2);
687 case QT2_CONTROL_ESCAPE
:
688 tty_buffer_request_room(&port
->port
, 2);
689 tty_insert_flip_string(&port
->port
, ch
, 2);
695 "%s - unsupported command %i\n",
696 __func__
, *(ch
+ 2));
703 tty_buffer_request_room(&port
->port
, 1);
704 tty_insert_flip_string(&port
->port
, ch
, 1);
707 tty_flip_buffer_push(&port
->port
);
710 static void qt2_write_bulk_callback(struct urb
*urb
)
712 struct usb_serial_port
*port
;
713 struct qt2_port_private
*port_priv
;
716 port_priv
= usb_get_serial_port_data(port
);
718 spin_lock(&port_priv
->urb_lock
);
720 port_priv
->urb_in_use
= false;
721 usb_serial_port_softint(port
);
723 spin_unlock(&port_priv
->urb_lock
);
727 static void qt2_read_bulk_callback(struct urb
*urb
)
729 struct usb_serial
*serial
= urb
->context
;
733 dev_warn(&serial
->dev
->dev
,
734 "%s - non-zero urb status: %i\n", __func__
,
739 qt2_process_read_urb(urb
);
741 status
= usb_submit_urb(urb
, GFP_ATOMIC
);
743 dev_err(&serial
->dev
->dev
,
744 "%s - resubmit read urb failed: %i\n",
748 static int qt2_setup_urbs(struct usb_serial
*serial
)
750 struct usb_serial_port
*port0
;
751 struct qt2_serial_private
*serial_priv
;
754 port0
= serial
->port
[0];
756 serial_priv
= usb_get_serial_data(serial
);
757 serial_priv
->read_urb
= usb_alloc_urb(0, GFP_KERNEL
);
758 if (!serial_priv
->read_urb
) {
759 dev_err(&serial
->dev
->dev
, "No free urbs available\n");
763 usb_fill_bulk_urb(serial_priv
->read_urb
, serial
->dev
,
764 usb_rcvbulkpipe(serial
->dev
,
765 port0
->bulk_in_endpointAddress
),
766 serial_priv
->read_buffer
,
767 sizeof(serial_priv
->read_buffer
),
768 qt2_read_bulk_callback
, serial
);
770 status
= usb_submit_urb(serial_priv
->read_urb
, GFP_KERNEL
);
772 dev_err(&serial
->dev
->dev
,
773 "%s - submit read urb failed %i\n", __func__
, status
);
774 usb_free_urb(serial_priv
->read_urb
);
781 static int qt2_attach(struct usb_serial
*serial
)
783 struct qt2_serial_private
*serial_priv
;
787 status
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
788 0xc2, 0x40, 0x8000, 0, NULL
, 0,
791 dev_err(&serial
->dev
->dev
,
792 "%s - failed to power on unit: %i\n", __func__
, status
);
796 serial_priv
= kzalloc(sizeof(*serial_priv
), GFP_KERNEL
);
798 dev_err(&serial
->dev
->dev
, "%s - Out of memory\n", __func__
);
802 usb_set_serial_data(serial
, serial_priv
);
804 status
= qt2_setup_urbs(serial
);
815 static int qt2_port_probe(struct usb_serial_port
*port
)
817 struct usb_serial
*serial
= port
->serial
;
818 struct qt2_port_private
*port_priv
;
821 port_priv
= kzalloc(sizeof(*port_priv
), GFP_KERNEL
);
825 spin_lock_init(&port_priv
->lock
);
826 spin_lock_init(&port_priv
->urb_lock
);
827 init_waitqueue_head(&port_priv
->delta_msr_wait
);
828 port_priv
->port
= port
;
830 port_priv
->write_urb
= usb_alloc_urb(0, GFP_KERNEL
);
831 if (!port_priv
->write_urb
) {
835 bEndpointAddress
= serial
->port
[0]->bulk_out_endpointAddress
;
836 usb_fill_bulk_urb(port_priv
->write_urb
, serial
->dev
,
837 usb_sndbulkpipe(serial
->dev
, bEndpointAddress
),
838 port_priv
->write_buffer
,
839 sizeof(port_priv
->write_buffer
),
840 qt2_write_bulk_callback
, port
);
842 usb_set_serial_port_data(port
, port_priv
);
847 static int qt2_port_remove(struct usb_serial_port
*port
)
849 struct qt2_port_private
*port_priv
;
851 port_priv
= usb_get_serial_port_data(port
);
852 usb_free_urb(port_priv
->write_urb
);
858 static int qt2_tiocmget(struct tty_struct
*tty
)
860 struct usb_serial_port
*port
= tty
->driver_data
;
861 struct usb_device
*dev
= port
->serial
->dev
;
862 struct qt2_port_private
*port_priv
= usb_get_serial_port_data(port
);
866 d
= kzalloc(2, GFP_KERNEL
);
870 r
= qt2_getregister(dev
, port_priv
->device_port
, UART_MCR
, d
);
874 r
= qt2_getregister(dev
, port_priv
->device_port
, UART_MSR
, d
+ 1);
878 r
= (d
[0] & UART_MCR_DTR
? TIOCM_DTR
: 0) |
879 (d
[0] & UART_MCR_RTS
? TIOCM_RTS
: 0) |
880 (d
[1] & UART_MSR_CTS
? TIOCM_CTS
: 0) |
881 (d
[1] & UART_MSR_DCD
? TIOCM_CAR
: 0) |
882 (d
[1] & UART_MSR_RI
? TIOCM_RI
: 0) |
883 (d
[1] & UART_MSR_DSR
? TIOCM_DSR
: 0);
890 static int qt2_tiocmset(struct tty_struct
*tty
,
891 unsigned int set
, unsigned int clear
)
893 struct qt2_port_private
*port_priv
;
895 port_priv
= usb_get_serial_port_data(tty
->driver_data
);
896 return update_mctrl(port_priv
, set
, clear
);
899 static void qt2_break_ctl(struct tty_struct
*tty
, int break_state
)
901 struct usb_serial_port
*port
= tty
->driver_data
;
902 struct qt2_port_private
*port_priv
;
906 port_priv
= usb_get_serial_port_data(port
);
908 if (!port_priv
->is_open
) {
910 "%s - port is not open\n", __func__
);
914 val
= (break_state
== -1) ? 1 : 0;
916 status
= qt2_control_msg(port
->serial
->dev
, QT2_BREAK_CONTROL
,
917 val
, port_priv
->device_port
);
920 "%s - failed to send control message: %i\n", __func__
,
926 static void qt2_dtr_rts(struct usb_serial_port
*port
, int on
)
928 struct usb_device
*dev
= port
->serial
->dev
;
929 struct qt2_port_private
*port_priv
= usb_get_serial_port_data(port
);
931 mutex_lock(&port
->serial
->disc_mutex
);
932 if (!port
->serial
->disconnected
) {
933 /* Disable flow control */
934 if (!on
&& qt2_setregister(dev
, port_priv
->device_port
,
936 dev_warn(&port
->dev
, "error from flowcontrol urb\n");
937 /* drop RTS and DTR */
939 update_mctrl(port_priv
, TIOCM_DTR
| TIOCM_RTS
, 0);
941 update_mctrl(port_priv
, 0, TIOCM_DTR
| TIOCM_RTS
);
943 mutex_unlock(&port
->serial
->disc_mutex
);
946 static void qt2_update_msr(struct usb_serial_port
*port
, unsigned char *ch
)
948 struct qt2_port_private
*port_priv
;
949 u8 newMSR
= (u8
) *ch
;
952 port_priv
= usb_get_serial_port_data(port
);
954 spin_lock_irqsave(&port_priv
->lock
, flags
);
955 port_priv
->shadowMSR
= newMSR
;
956 spin_unlock_irqrestore(&port_priv
->lock
, flags
);
958 if (newMSR
& UART_MSR_ANY_DELTA
) {
959 /* update input line counters */
960 if (newMSR
& UART_MSR_DCTS
)
961 port_priv
->icount
.cts
++;
963 if (newMSR
& UART_MSR_DDSR
)
964 port_priv
->icount
.dsr
++;
966 if (newMSR
& UART_MSR_DDCD
)
967 port_priv
->icount
.dcd
++;
969 if (newMSR
& UART_MSR_TERI
)
970 port_priv
->icount
.rng
++;
972 wake_up_interruptible(&port_priv
->delta_msr_wait
);
976 static void qt2_update_lsr(struct usb_serial_port
*port
, unsigned char *ch
)
978 struct qt2_port_private
*port_priv
;
979 struct async_icount
*icount
;
981 u8 newLSR
= (u8
) *ch
;
983 port_priv
= usb_get_serial_port_data(port
);
985 if (newLSR
& UART_LSR_BI
)
986 newLSR
&= (u8
) (UART_LSR_OE
| UART_LSR_BI
);
988 spin_lock_irqsave(&port_priv
->lock
, flags
);
989 port_priv
->shadowLSR
= newLSR
;
990 spin_unlock_irqrestore(&port_priv
->lock
, flags
);
992 icount
= &port_priv
->icount
;
994 if (newLSR
& UART_LSR_BRK_ERROR_BITS
) {
996 if (newLSR
& UART_LSR_BI
)
999 if (newLSR
& UART_LSR_OE
)
1002 if (newLSR
& UART_LSR_PE
)
1005 if (newLSR
& UART_LSR_FE
)
1011 static int qt2_write_room(struct tty_struct
*tty
)
1013 struct usb_serial_port
*port
= tty
->driver_data
;
1014 struct qt2_port_private
*port_priv
;
1015 unsigned long flags
= 0;
1018 port_priv
= usb_get_serial_port_data(port
);
1020 spin_lock_irqsave(&port_priv
->urb_lock
, flags
);
1022 if (port_priv
->urb_in_use
)
1025 r
= QT2_WRITE_BUFFER_SIZE
- QT2_WRITE_CONTROL_SIZE
;
1027 spin_unlock_irqrestore(&port_priv
->urb_lock
, flags
);
1032 static int qt2_write(struct tty_struct
*tty
,
1033 struct usb_serial_port
*port
,
1034 const unsigned char *buf
, int count
)
1036 struct qt2_port_private
*port_priv
;
1037 struct urb
*write_urb
;
1038 unsigned char *data
;
1039 unsigned long flags
;
1043 port_priv
= usb_get_serial_port_data(port
);
1045 if (port_priv
->write_urb
== NULL
) {
1046 dev_err(&port
->dev
, "%s - no output urb\n", __func__
);
1049 write_urb
= port_priv
->write_urb
;
1051 count
= min(count
, QT2_WRITE_BUFFER_SIZE
- QT2_WRITE_CONTROL_SIZE
);
1053 data
= write_urb
->transfer_buffer
;
1054 spin_lock_irqsave(&port_priv
->urb_lock
, flags
);
1055 if (port_priv
->urb_in_use
== true) {
1056 dev_err(&port
->dev
, "qt2_write - urb is in use\n");
1060 *data
++ = QT2_CONTROL_BYTE
;
1061 *data
++ = QT2_CONTROL_BYTE
;
1062 *data
++ = port_priv
->device_port
;
1063 put_unaligned_le16(count
, data
);
1065 memcpy(data
, buf
, count
);
1067 write_urb
->transfer_buffer_length
= count
+ QT2_WRITE_CONTROL_SIZE
;
1069 status
= usb_submit_urb(write_urb
, GFP_ATOMIC
);
1071 port_priv
->urb_in_use
= true;
1076 spin_unlock_irqrestore(&port_priv
->urb_lock
, flags
);
1081 static struct usb_serial_driver qt2_device
= {
1083 .owner
= THIS_MODULE
,
1084 .name
= "quatech-serial",
1086 .description
= DRIVER_DESC
,
1087 .id_table
= id_table
,
1091 .write_room
= qt2_write_room
,
1092 .calc_num_ports
= qt2_calc_num_ports
,
1093 .attach
= qt2_attach
,
1094 .release
= qt2_release
,
1095 .disconnect
= qt2_disconnect
,
1096 .port_probe
= qt2_port_probe
,
1097 .port_remove
= qt2_port_remove
,
1098 .dtr_rts
= qt2_dtr_rts
,
1099 .break_ctl
= qt2_break_ctl
,
1100 .tiocmget
= qt2_tiocmget
,
1101 .tiocmset
= qt2_tiocmset
,
1102 .get_icount
= qt2_get_icount
,
1104 .set_termios
= qt2_set_termios
,
1107 static struct usb_serial_driver
*const serial_drivers
[] = {
1111 module_usb_serial_driver(serial_drivers
, id_table
);
1113 MODULE_DESCRIPTION(DRIVER_DESC
);
1114 MODULE_LICENSE("GPL");