2 * usb-serial driver for Quatech SSU-100
4 * based on ftdi_sio.c and the original serqt_usb.c from Quatech
8 #include <linux/errno.h>
9 #include <linux/init.h>
10 #include <linux/slab.h>
11 #include <linux/tty.h>
12 #include <linux/tty_driver.h>
13 #include <linux/tty_flip.h>
14 #include <linux/module.h>
15 #include <linux/serial.h>
16 #include <linux/usb.h>
17 #include <linux/usb/serial.h>
18 #include <linux/serial_reg.h>
19 #include <linux/uaccess.h>
21 #define QT_OPEN_CLOSE_CHANNEL 0xca
22 #define QT_SET_GET_DEVICE 0xc2
23 #define QT_SET_GET_REGISTER 0xc0
24 #define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
25 #define QT_SET_ATF 0xcd
26 #define QT_GET_SET_UART 0xc1
27 #define QT_TRANSFER_IN 0xc0
28 #define QT_HW_FLOW_CONTROL_MASK 0xc5
29 #define QT_SW_FLOW_CONTROL_MASK 0xc6
31 #define SERIAL_MSR_MASK 0xf0
33 #define SERIAL_CRTSCTS ((UART_MCR_RTS << 8) | UART_MSR_CTS)
35 #define SERIAL_EVEN_PARITY (UART_LCR_PARITY | UART_LCR_EPAR)
37 #define MAX_BAUD_RATE 460800
39 #define ATC_DISABLED 0x00
40 #define DUPMODE_BITS 0xc0
42 #define LOOPMODE_BITS 0x41
43 #define RS232_MODE 0x00
44 #define RTSCTS_TO_CONNECTOR 0x40
46 #define FULLPWRBIT 0x00000080
47 #define NEXT_BOARD_POWER_BIT 0x00000004
51 /* Version Information */
52 #define DRIVER_VERSION "v0.1"
53 #define DRIVER_DESC "Quatech SSU-100 USB to Serial Driver"
55 #define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */
56 #define QUATECH_SSU100 0xC020 /* SSU100 */
58 static const struct usb_device_id id_table
[] = {
59 {USB_DEVICE(USB_VENDOR_ID_QUATECH
, QUATECH_SSU100
)},
60 {} /* Terminating entry */
63 MODULE_DEVICE_TABLE(usb
, id_table
);
66 static struct usb_driver ssu100_driver
= {
68 .probe
= usb_serial_probe
,
69 .disconnect
= usb_serial_disconnect
,
71 .suspend
= usb_serial_suspend
,
72 .resume
= usb_serial_resume
,
73 .supports_autosuspend
= 1,
76 struct ssu100_port_private
{
77 spinlock_t status_lock
;
80 wait_queue_head_t delta_msr_wait
; /* Used for TIOCMIWAIT */
81 struct async_icount icount
;
84 static void ssu100_release(struct usb_serial
*serial
)
86 struct ssu100_port_private
*priv
= usb_get_serial_port_data(*serial
->port
);
92 static inline int ssu100_control_msg(struct usb_device
*dev
,
93 u8 request
, u16 data
, u16 index
)
95 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
96 request
, 0x40, data
, index
,
100 static inline int ssu100_setdevice(struct usb_device
*dev
, u8
*data
)
102 u16 x
= ((u16
)(data
[1] << 8) | (u16
)(data
[0]));
104 return ssu100_control_msg(dev
, QT_SET_GET_DEVICE
, x
, 0);
108 static inline int ssu100_getdevice(struct usb_device
*dev
, u8
*data
)
110 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
111 QT_SET_GET_DEVICE
, 0xc0, 0, 0,
115 static inline int ssu100_getregister(struct usb_device
*dev
,
120 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
121 QT_SET_GET_REGISTER
, 0xc0, reg
,
122 uart
, data
, sizeof(*data
), 300);
127 static inline int ssu100_setregister(struct usb_device
*dev
,
132 u16 value
= (data
<< 8) | reg
;
134 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
135 QT_SET_GET_REGISTER
, 0x40, value
, uart
,
140 #define set_mctrl(dev, set) update_mctrl((dev), (set), 0)
141 #define clear_mctrl(dev, clear) update_mctrl((dev), 0, (clear))
143 /* these do not deal with device that have more than 1 port */
144 static inline int update_mctrl(struct usb_device
*dev
, unsigned int set
,
150 if (((set
| clear
) & (TIOCM_DTR
| TIOCM_RTS
)) == 0) {
151 dbg("%s - DTR|RTS not being set|cleared", __func__
);
152 return 0; /* no change */
155 clear
&= ~set
; /* 'set' takes precedence over 'clear' */
158 urb_value
|= UART_MCR_DTR
;
160 urb_value
|= UART_MCR_RTS
;
162 result
= ssu100_setregister(dev
, 0, UART_MCR
, urb_value
);
164 dbg("%s Error from MODEM_CTRL urb", __func__
);
169 static int ssu100_initdevice(struct usb_device
*dev
)
176 data
= kzalloc(3, GFP_KERNEL
);
180 result
= ssu100_getdevice(dev
, data
);
182 dbg("%s - get_device failed %i", __func__
, result
);
186 data
[1] &= ~FULLPWRBIT
;
188 result
= ssu100_setdevice(dev
, data
);
190 dbg("%s - setdevice failed %i", __func__
, result
);
194 result
= ssu100_control_msg(dev
, QT_GET_SET_PREBUF_TRIG_LVL
, 128, 0);
196 dbg("%s - set prebuffer level failed %i", __func__
, result
);
200 result
= ssu100_control_msg(dev
, QT_SET_ATF
, ATC_DISABLED
, 0);
202 dbg("%s - set ATFprebuffer level failed %i", __func__
, result
);
206 result
= ssu100_getdevice(dev
, data
);
208 dbg("%s - get_device failed %i", __func__
, result
);
212 data
[0] &= ~(RR_BITS
| DUPMODE_BITS
);
214 data
[1] &= ~(LOOPMODE_BITS
);
215 data
[1] |= RS232_MODE
;
217 result
= ssu100_setdevice(dev
, data
);
219 dbg("%s - setdevice failed %i", __func__
, result
);
229 static void ssu100_set_termios(struct tty_struct
*tty
,
230 struct usb_serial_port
*port
,
231 struct ktermios
*old_termios
)
233 struct usb_device
*dev
= port
->serial
->dev
;
234 struct ktermios
*termios
= tty
->termios
;
235 u16 baud
, divisor
, remainder
;
236 unsigned int cflag
= termios
->c_cflag
;
237 u16 urb_value
= 0; /* will hold the new flags */
242 if (cflag
& PARENB
) {
244 urb_value
|= UART_LCR_PARITY
;
246 urb_value
|= SERIAL_EVEN_PARITY
;
249 switch (cflag
& CSIZE
) {
251 urb_value
|= UART_LCR_WLEN5
;
254 urb_value
|= UART_LCR_WLEN6
;
257 urb_value
|= UART_LCR_WLEN7
;
261 urb_value
|= UART_LCR_WLEN8
;
265 baud
= tty_get_baud_rate(tty
);
269 dbg("%s - got baud = %d\n", __func__
, baud
);
272 divisor
= MAX_BAUD_RATE
/ baud
;
273 remainder
= MAX_BAUD_RATE
% baud
;
274 if (((remainder
* 2) >= baud
) && (baud
!= 110))
277 urb_value
= urb_value
<< 8;
279 result
= ssu100_control_msg(dev
, QT_GET_SET_UART
, divisor
, urb_value
);
281 dbg("%s - set uart failed", __func__
);
284 result
= ssu100_control_msg(dev
, QT_HW_FLOW_CONTROL_MASK
,
287 result
= ssu100_control_msg(dev
, QT_HW_FLOW_CONTROL_MASK
,
290 dbg("%s - set HW flow control failed", __func__
);
292 if (I_IXOFF(tty
) || I_IXON(tty
)) {
293 u16 x
= ((u16
)(START_CHAR(tty
) << 8) | (u16
)(STOP_CHAR(tty
)));
295 result
= ssu100_control_msg(dev
, QT_SW_FLOW_CONTROL_MASK
,
298 result
= ssu100_control_msg(dev
, QT_SW_FLOW_CONTROL_MASK
,
302 dbg("%s - set SW flow control failed", __func__
);
307 static int ssu100_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
309 struct usb_device
*dev
= port
->serial
->dev
;
310 struct ssu100_port_private
*priv
= usb_get_serial_port_data(port
);
315 dbg("%s - port %d", __func__
, port
->number
);
317 data
= kzalloc(2, GFP_KERNEL
);
321 result
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
322 QT_OPEN_CLOSE_CHANNEL
,
323 QT_TRANSFER_IN
, 0x01,
326 dbg("%s - open failed %i", __func__
, result
);
331 spin_lock_irqsave(&priv
->status_lock
, flags
);
332 priv
->shadowLSR
= data
[0];
333 priv
->shadowMSR
= data
[1];
334 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
339 result
= ssu100_control_msg(dev
, QT_GET_SET_UART
, 0x30, 0x0300);
341 dbg("%s - set uart failed", __func__
);
344 ssu100_set_termios(tty
, port
, tty
->termios
);
346 return usb_serial_generic_open(tty
, port
);
349 static void ssu100_close(struct usb_serial_port
*port
)
352 usb_serial_generic_close(port
);
355 static int get_serial_info(struct usb_serial_port
*port
,
356 struct serial_struct __user
*retinfo
)
358 struct serial_struct tmp
;
363 memset(&tmp
, 0, sizeof(tmp
));
364 tmp
.line
= port
->serial
->minor
;
367 tmp
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
368 tmp
.xmit_fifo_size
= port
->bulk_out_size
;
369 tmp
.baud_base
= 9600;
370 tmp
.close_delay
= 5*HZ
;
371 tmp
.closing_wait
= 30*HZ
;
373 if (copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)))
378 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
380 struct ssu100_port_private
*priv
= usb_get_serial_port_data(port
);
381 struct async_icount prev
, cur
;
384 spin_lock_irqsave(&priv
->status_lock
, flags
);
386 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
389 wait_event_interruptible(priv
->delta_msr_wait
,
390 ((priv
->icount
.rng
!= prev
.rng
) ||
391 (priv
->icount
.dsr
!= prev
.dsr
) ||
392 (priv
->icount
.dcd
!= prev
.dcd
) ||
393 (priv
->icount
.cts
!= prev
.cts
)));
395 if (signal_pending(current
))
398 spin_lock_irqsave(&priv
->status_lock
, flags
);
400 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
402 if ((prev
.rng
== cur
.rng
) &&
403 (prev
.dsr
== cur
.dsr
) &&
404 (prev
.dcd
== cur
.dcd
) &&
405 (prev
.cts
== cur
.cts
))
408 if ((arg
& TIOCM_RNG
&& (prev
.rng
!= cur
.rng
)) ||
409 (arg
& TIOCM_DSR
&& (prev
.dsr
!= cur
.dsr
)) ||
410 (arg
& TIOCM_CD
&& (prev
.dcd
!= cur
.dcd
)) ||
411 (arg
& TIOCM_CTS
&& (prev
.cts
!= cur
.cts
)))
417 static int ssu100_get_icount(struct tty_struct
*tty
,
418 struct serial_icounter_struct
*icount
)
420 struct usb_serial_port
*port
= tty
->driver_data
;
421 struct ssu100_port_private
*priv
= usb_get_serial_port_data(port
);
422 struct async_icount cnow
= priv
->icount
;
424 icount
->cts
= cnow
.cts
;
425 icount
->dsr
= cnow
.dsr
;
426 icount
->rng
= cnow
.rng
;
427 icount
->dcd
= cnow
.dcd
;
428 icount
->rx
= cnow
.rx
;
429 icount
->tx
= cnow
.tx
;
430 icount
->frame
= cnow
.frame
;
431 icount
->overrun
= cnow
.overrun
;
432 icount
->parity
= cnow
.parity
;
433 icount
->brk
= cnow
.brk
;
434 icount
->buf_overrun
= cnow
.buf_overrun
;
441 static int ssu100_ioctl(struct tty_struct
*tty
,
442 unsigned int cmd
, unsigned long arg
)
444 struct usb_serial_port
*port
= tty
->driver_data
;
446 dbg("%s cmd 0x%04x", __func__
, cmd
);
450 return get_serial_info(port
,
451 (struct serial_struct __user
*) arg
);
454 return wait_modem_info(port
, arg
);
460 dbg("%s arg not supported", __func__
);
465 static int ssu100_attach(struct usb_serial
*serial
)
467 struct ssu100_port_private
*priv
;
468 struct usb_serial_port
*port
= *serial
->port
;
472 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
474 dev_err(&port
->dev
, "%s- kmalloc(%Zd) failed.\n", __func__
,
479 spin_lock_init(&priv
->status_lock
);
480 init_waitqueue_head(&priv
->delta_msr_wait
);
481 usb_set_serial_port_data(port
, priv
);
483 return ssu100_initdevice(serial
->dev
);
486 static int ssu100_tiocmget(struct tty_struct
*tty
)
488 struct usb_serial_port
*port
= tty
->driver_data
;
489 struct usb_device
*dev
= port
->serial
->dev
;
493 dbg("%s\n", __func__
);
495 d
= kzalloc(2, GFP_KERNEL
);
499 r
= ssu100_getregister(dev
, 0, UART_MCR
, d
);
503 r
= ssu100_getregister(dev
, 0, UART_MSR
, d
+1);
507 r
= (d
[0] & UART_MCR_DTR
? TIOCM_DTR
: 0) |
508 (d
[0] & UART_MCR_RTS
? TIOCM_RTS
: 0) |
509 (d
[1] & UART_MSR_CTS
? TIOCM_CTS
: 0) |
510 (d
[1] & UART_MSR_DCD
? TIOCM_CAR
: 0) |
511 (d
[1] & UART_MSR_RI
? TIOCM_RI
: 0) |
512 (d
[1] & UART_MSR_DSR
? TIOCM_DSR
: 0);
519 static int ssu100_tiocmset(struct tty_struct
*tty
,
520 unsigned int set
, unsigned int clear
)
522 struct usb_serial_port
*port
= tty
->driver_data
;
523 struct usb_device
*dev
= port
->serial
->dev
;
525 dbg("%s\n", __func__
);
526 return update_mctrl(dev
, set
, clear
);
529 static void ssu100_dtr_rts(struct usb_serial_port
*port
, int on
)
531 struct usb_device
*dev
= port
->serial
->dev
;
533 dbg("%s\n", __func__
);
535 mutex_lock(&port
->serial
->disc_mutex
);
536 if (!port
->serial
->disconnected
) {
537 /* Disable flow control */
539 ssu100_setregister(dev
, 0, UART_MCR
, 0) < 0)
540 dev_err(&port
->dev
, "error from flowcontrol urb\n");
541 /* drop RTS and DTR */
543 set_mctrl(dev
, TIOCM_DTR
| TIOCM_RTS
);
545 clear_mctrl(dev
, TIOCM_DTR
| TIOCM_RTS
);
547 mutex_unlock(&port
->serial
->disc_mutex
);
550 static void ssu100_update_msr(struct usb_serial_port
*port
, u8 msr
)
552 struct ssu100_port_private
*priv
= usb_get_serial_port_data(port
);
555 spin_lock_irqsave(&priv
->status_lock
, flags
);
556 priv
->shadowMSR
= msr
;
557 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
559 if (msr
& UART_MSR_ANY_DELTA
) {
560 /* update input line counters */
561 if (msr
& UART_MSR_DCTS
)
563 if (msr
& UART_MSR_DDSR
)
565 if (msr
& UART_MSR_DDCD
)
567 if (msr
& UART_MSR_TERI
)
569 wake_up_interruptible(&priv
->delta_msr_wait
);
573 static void ssu100_update_lsr(struct usb_serial_port
*port
, u8 lsr
,
576 struct ssu100_port_private
*priv
= usb_get_serial_port_data(port
);
579 spin_lock_irqsave(&priv
->status_lock
, flags
);
580 priv
->shadowLSR
= lsr
;
581 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
583 *tty_flag
= TTY_NORMAL
;
584 if (lsr
& UART_LSR_BRK_ERROR_BITS
) {
585 /* we always want to update icount, but we only want to
586 * update tty_flag for one case */
587 if (lsr
& UART_LSR_BI
) {
589 *tty_flag
= TTY_BREAK
;
590 usb_serial_handle_break(port
);
592 if (lsr
& UART_LSR_PE
) {
593 priv
->icount
.parity
++;
594 if (*tty_flag
== TTY_NORMAL
)
595 *tty_flag
= TTY_PARITY
;
597 if (lsr
& UART_LSR_FE
) {
598 priv
->icount
.frame
++;
599 if (*tty_flag
== TTY_NORMAL
)
600 *tty_flag
= TTY_FRAME
;
602 if (lsr
& UART_LSR_OE
){
603 priv
->icount
.overrun
++;
604 if (*tty_flag
== TTY_NORMAL
)
605 *tty_flag
= TTY_OVERRUN
;
611 static int ssu100_process_packet(struct urb
*urb
,
612 struct tty_struct
*tty
)
614 struct usb_serial_port
*port
= urb
->context
;
615 char *packet
= (char *)urb
->transfer_buffer
;
616 char flag
= TTY_NORMAL
;
617 u32 len
= urb
->actual_length
;
621 dbg("%s - port %d", __func__
, port
->number
);
624 (packet
[0] == 0x1b) && (packet
[1] == 0x1b) &&
625 ((packet
[2] == 0x00) || (packet
[2] == 0x01))) {
626 if (packet
[2] == 0x00) {
627 ssu100_update_lsr(port
, packet
[3], &flag
);
628 if (flag
== TTY_OVERRUN
)
629 tty_insert_flip_char(tty
, 0, TTY_OVERRUN
);
631 if (packet
[2] == 0x01)
632 ssu100_update_msr(port
, packet
[3]);
640 return 0; /* status only */
642 if (port
->port
.console
&& port
->sysrq
) {
643 for (i
= 0; i
< len
; i
++, ch
++) {
644 if (!usb_serial_handle_sysrq_char(port
, *ch
))
645 tty_insert_flip_char(tty
, *ch
, flag
);
648 tty_insert_flip_string_fixed_flag(tty
, ch
, flag
, len
);
653 static void ssu100_process_read_urb(struct urb
*urb
)
655 struct usb_serial_port
*port
= urb
->context
;
656 struct tty_struct
*tty
;
661 tty
= tty_port_tty_get(&port
->port
);
665 count
= ssu100_process_packet(urb
, tty
);
668 tty_flip_buffer_push(tty
);
672 static struct usb_serial_driver ssu100_device
= {
674 .owner
= THIS_MODULE
,
677 .description
= DRIVER_DESC
,
678 .id_table
= id_table
,
681 .close
= ssu100_close
,
682 .attach
= ssu100_attach
,
683 .release
= ssu100_release
,
684 .dtr_rts
= ssu100_dtr_rts
,
685 .process_read_urb
= ssu100_process_read_urb
,
686 .tiocmget
= ssu100_tiocmget
,
687 .tiocmset
= ssu100_tiocmset
,
688 .get_icount
= ssu100_get_icount
,
689 .ioctl
= ssu100_ioctl
,
690 .set_termios
= ssu100_set_termios
,
691 .disconnect
= usb_serial_generic_disconnect
,
694 static struct usb_serial_driver
* const serial_drivers
[] = {
698 module_usb_serial_driver(ssu100_driver
, serial_drivers
);
700 MODULE_DESCRIPTION(DRIVER_DESC
);
701 MODULE_LICENSE("GPL");
703 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
704 MODULE_PARM_DESC(debug
, "Debug enabled or not");