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
,
74 .supports_autosuspend
= 1,
77 struct ssu100_port_private
{
78 spinlock_t status_lock
;
81 wait_queue_head_t delta_msr_wait
; /* Used for TIOCMIWAIT */
82 unsigned short max_packet_size
;
85 static void ssu100_release(struct usb_serial
*serial
)
87 struct ssu100_port_private
*priv
= usb_get_serial_port_data(*serial
->port
);
93 static inline int ssu100_control_msg(struct usb_device
*dev
,
94 u8 request
, u16 data
, u16 index
)
96 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
97 request
, 0x40, data
, index
,
101 static inline int ssu100_setdevice(struct usb_device
*dev
, u8
*data
)
103 u16 x
= ((u16
)(data
[1] << 8) | (u16
)(data
[0]));
105 return ssu100_control_msg(dev
, QT_SET_GET_DEVICE
, x
, 0);
109 static inline int ssu100_getdevice(struct usb_device
*dev
, u8
*data
)
111 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
112 QT_SET_GET_DEVICE
, 0xc0, 0, 0,
116 static inline int ssu100_getregister(struct usb_device
*dev
,
121 return usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
122 QT_SET_GET_REGISTER
, 0xc0, reg
,
123 uart
, data
, sizeof(*data
), 300);
128 static inline int ssu100_setregister(struct usb_device
*dev
,
133 u16 value
= (data
<< 8) | reg
;
135 return usb_control_msg(dev
, usb_sndctrlpipe(dev
, 0),
136 QT_SET_GET_REGISTER
, 0x40, value
, uart
,
141 #define set_mctrl(dev, set) update_mctrl((dev), (set), 0)
142 #define clear_mctrl(dev, clear) update_mctrl((dev), 0, (clear))
144 /* these do not deal with device that have more than 1 port */
145 static inline int update_mctrl(struct usb_device
*dev
, unsigned int set
,
151 if (((set
| clear
) & (TIOCM_DTR
| TIOCM_RTS
)) == 0) {
152 dbg("%s - DTR|RTS not being set|cleared", __func__
);
153 return 0; /* no change */
156 clear
&= ~set
; /* 'set' takes precedence over 'clear' */
159 urb_value
|= UART_MCR_DTR
;
161 urb_value
|= UART_MCR_RTS
;
163 result
= ssu100_setregister(dev
, 0, UART_MCR
, urb_value
);
165 dbg("%s Error from MODEM_CTRL urb", __func__
);
170 static int ssu100_initdevice(struct usb_device
*dev
)
177 data
= kzalloc(3, GFP_KERNEL
);
181 result
= ssu100_getdevice(dev
, data
);
183 dbg("%s - get_device failed %i", __func__
, result
);
187 data
[1] &= ~FULLPWRBIT
;
189 result
= ssu100_setdevice(dev
, data
);
191 dbg("%s - setdevice failed %i", __func__
, result
);
195 result
= ssu100_control_msg(dev
, QT_GET_SET_PREBUF_TRIG_LVL
, 128, 0);
197 dbg("%s - set prebuffer level failed %i", __func__
, result
);
201 result
= ssu100_control_msg(dev
, QT_SET_ATF
, ATC_DISABLED
, 0);
203 dbg("%s - set ATFprebuffer level failed %i", __func__
, result
);
207 result
= ssu100_getdevice(dev
, data
);
209 dbg("%s - get_device failed %i", __func__
, result
);
213 data
[0] &= ~(RR_BITS
| DUPMODE_BITS
);
215 data
[1] &= ~(LOOPMODE_BITS
);
216 data
[1] |= RS232_MODE
;
218 result
= ssu100_setdevice(dev
, data
);
220 dbg("%s - setdevice failed %i", __func__
, result
);
230 static void ssu100_set_termios(struct tty_struct
*tty
,
231 struct usb_serial_port
*port
,
232 struct ktermios
*old_termios
)
234 struct usb_device
*dev
= port
->serial
->dev
;
235 struct ktermios
*termios
= tty
->termios
;
236 u16 baud
, divisor
, remainder
;
237 unsigned int cflag
= termios
->c_cflag
;
238 u16 urb_value
= 0; /* will hold the new flags */
243 if (cflag
& PARENB
) {
245 urb_value
|= UART_LCR_PARITY
;
247 urb_value
|= SERIAL_EVEN_PARITY
;
250 switch (cflag
& CSIZE
) {
252 urb_value
|= UART_LCR_WLEN5
;
255 urb_value
|= UART_LCR_WLEN6
;
258 urb_value
|= UART_LCR_WLEN7
;
262 urb_value
|= UART_LCR_WLEN8
;
266 baud
= tty_get_baud_rate(tty
);
270 dbg("%s - got baud = %d\n", __func__
, baud
);
273 divisor
= MAX_BAUD_RATE
/ baud
;
274 remainder
= MAX_BAUD_RATE
% baud
;
275 if (((remainder
* 2) >= baud
) && (baud
!= 110))
278 urb_value
= urb_value
<< 8;
280 result
= ssu100_control_msg(dev
, QT_GET_SET_UART
, divisor
, urb_value
);
282 dbg("%s - set uart failed", __func__
);
285 result
= ssu100_control_msg(dev
, QT_HW_FLOW_CONTROL_MASK
,
288 result
= ssu100_control_msg(dev
, QT_HW_FLOW_CONTROL_MASK
,
291 dbg("%s - set HW flow control failed", __func__
);
293 if (I_IXOFF(tty
) || I_IXON(tty
)) {
294 u16 x
= ((u16
)(START_CHAR(tty
) << 8) | (u16
)(STOP_CHAR(tty
)));
296 result
= ssu100_control_msg(dev
, QT_SW_FLOW_CONTROL_MASK
,
299 result
= ssu100_control_msg(dev
, QT_SW_FLOW_CONTROL_MASK
,
303 dbg("%s - set SW flow control failed", __func__
);
308 static int ssu100_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
310 struct usb_device
*dev
= port
->serial
->dev
;
311 struct ssu100_port_private
*priv
= usb_get_serial_port_data(port
);
316 dbg("%s - port %d", __func__
, port
->number
);
318 data
= kzalloc(2, GFP_KERNEL
);
322 result
= usb_control_msg(dev
, usb_rcvctrlpipe(dev
, 0),
323 QT_OPEN_CLOSE_CHANNEL
,
324 QT_TRANSFER_IN
, 0x01,
327 dbg("%s - open failed %i", __func__
, result
);
332 spin_lock_irqsave(&priv
->status_lock
, flags
);
333 priv
->shadowLSR
= data
[0] & (UART_LSR_OE
| UART_LSR_PE
|
334 UART_LSR_FE
| UART_LSR_BI
);
336 priv
->shadowMSR
= data
[1] & (UART_MSR_CTS
| UART_MSR_DSR
|
337 UART_MSR_RI
| UART_MSR_DCD
);
338 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
343 result
= ssu100_control_msg(dev
, QT_GET_SET_UART
, 0x30, 0x0300);
345 dbg("%s - set uart failed", __func__
);
348 ssu100_set_termios(tty
, port
, tty
->termios
);
350 return usb_serial_generic_open(tty
, port
);
353 static void ssu100_close(struct usb_serial_port
*port
)
356 usb_serial_generic_close(port
);
359 static int get_serial_info(struct usb_serial_port
*port
,
360 struct serial_struct __user
*retinfo
)
362 struct serial_struct tmp
;
367 memset(&tmp
, 0, sizeof(tmp
));
368 tmp
.line
= port
->serial
->minor
;
371 tmp
.flags
= ASYNC_SKIP_TEST
| ASYNC_AUTO_IRQ
;
372 tmp
.xmit_fifo_size
= port
->bulk_out_size
;
373 tmp
.baud_base
= 9600;
374 tmp
.close_delay
= 5*HZ
;
375 tmp
.closing_wait
= 30*HZ
;
377 if (copy_to_user(retinfo
, &tmp
, sizeof(*retinfo
)))
382 static int ssu100_ioctl(struct tty_struct
*tty
, struct file
*file
,
383 unsigned int cmd
, unsigned long arg
)
385 struct usb_serial_port
*port
= tty
->driver_data
;
386 struct ssu100_port_private
*priv
= usb_get_serial_port_data(port
);
388 dbg("%s cmd 0x%04x", __func__
, cmd
);
392 return get_serial_info(port
,
393 (struct serial_struct __user
*) arg
);
396 while (priv
!= NULL
) {
397 u8 prevMSR
= priv
->shadowMSR
& SERIAL_MSR_MASK
;
398 interruptible_sleep_on(&priv
->delta_msr_wait
);
399 /* see if a signal did it */
400 if (signal_pending(current
))
403 u8 diff
= (priv
->shadowMSR
& SERIAL_MSR_MASK
) ^ prevMSR
;
405 return -EIO
; /* no change => error */
407 /* Return 0 if caller wanted to know about
410 if (((arg
& TIOCM_RNG
) && (diff
& UART_MSR_RI
)) ||
411 ((arg
& TIOCM_DSR
) && (diff
& UART_MSR_DSR
)) ||
412 ((arg
& TIOCM_CD
) && (diff
& UART_MSR_DCD
)) ||
413 ((arg
& TIOCM_CTS
) && (diff
& UART_MSR_CTS
)))
423 dbg("%s arg not supported", __func__
);
428 static void ssu100_set_max_packet_size(struct usb_serial_port
*port
)
430 struct ssu100_port_private
*priv
= usb_get_serial_port_data(port
);
431 struct usb_serial
*serial
= port
->serial
;
432 struct usb_device
*udev
= serial
->dev
;
434 struct usb_interface
*interface
= serial
->interface
;
435 struct usb_endpoint_descriptor
*ep_desc
= &interface
->cur_altsetting
->endpoint
[1].desc
;
437 unsigned num_endpoints
;
441 num_endpoints
= interface
->cur_altsetting
->desc
.bNumEndpoints
;
442 dev_info(&udev
->dev
, "Number of endpoints %d\n", num_endpoints
);
444 for (i
= 0; i
< num_endpoints
; i
++) {
445 dev_info(&udev
->dev
, "Endpoint %d MaxPacketSize %d\n", i
+1,
446 interface
->cur_altsetting
->endpoint
[i
].desc
.wMaxPacketSize
);
447 ep_desc
= &interface
->cur_altsetting
->endpoint
[i
].desc
;
450 /* set max packet size based on descriptor */
451 spin_lock_irqsave(&priv
->status_lock
, flags
);
452 priv
->max_packet_size
= ep_desc
->wMaxPacketSize
;
453 spin_unlock_irqrestore(&priv
->status_lock
, flags
);
455 dev_info(&udev
->dev
, "Setting MaxPacketSize %d\n", priv
->max_packet_size
);
458 static int ssu100_attach(struct usb_serial
*serial
)
460 struct ssu100_port_private
*priv
;
461 struct usb_serial_port
*port
= *serial
->port
;
465 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
467 dev_err(&port
->dev
, "%s- kmalloc(%Zd) failed.\n", __func__
,
472 spin_lock_init(&priv
->status_lock
);
473 init_waitqueue_head(&priv
->delta_msr_wait
);
474 usb_set_serial_port_data(port
, priv
);
475 ssu100_set_max_packet_size(port
);
477 return ssu100_initdevice(serial
->dev
);
480 static int ssu100_tiocmget(struct tty_struct
*tty
, struct file
*file
)
482 struct usb_serial_port
*port
= tty
->driver_data
;
483 struct usb_device
*dev
= port
->serial
->dev
;
487 dbg("%s\n", __func__
);
489 d
= kzalloc(2, GFP_KERNEL
);
493 r
= ssu100_getregister(dev
, 0, UART_MCR
, d
);
497 r
= ssu100_getregister(dev
, 0, UART_MSR
, d
+1);
501 r
= (d
[0] & UART_MCR_DTR
? TIOCM_DTR
: 0) |
502 (d
[0] & UART_MCR_RTS
? TIOCM_RTS
: 0) |
503 (d
[1] & UART_MSR_CTS
? TIOCM_CTS
: 0) |
504 (d
[1] & UART_MSR_DCD
? TIOCM_CAR
: 0) |
505 (d
[1] & UART_MSR_RI
? TIOCM_RI
: 0) |
506 (d
[1] & UART_MSR_DSR
? TIOCM_DSR
: 0);
513 static int ssu100_tiocmset(struct tty_struct
*tty
, struct file
*file
,
514 unsigned int set
, unsigned int clear
)
516 struct usb_serial_port
*port
= tty
->driver_data
;
517 struct usb_device
*dev
= port
->serial
->dev
;
519 dbg("%s\n", __func__
);
520 return update_mctrl(dev
, set
, clear
);
523 static void ssu100_dtr_rts(struct usb_serial_port
*port
, int on
)
525 struct usb_device
*dev
= port
->serial
->dev
;
527 dbg("%s\n", __func__
);
529 mutex_lock(&port
->serial
->disc_mutex
);
530 if (!port
->serial
->disconnected
) {
531 /* Disable flow control */
533 ssu100_setregister(dev
, 0, UART_MCR
, 0) < 0)
534 dev_err(&port
->dev
, "error from flowcontrol urb\n");
535 /* drop RTS and DTR */
537 set_mctrl(dev
, TIOCM_DTR
| TIOCM_RTS
);
539 clear_mctrl(dev
, TIOCM_DTR
| TIOCM_RTS
);
541 mutex_unlock(&port
->serial
->disc_mutex
);
544 static int ssu100_process_packet(struct tty_struct
*tty
,
545 struct usb_serial_port
*port
,
546 struct ssu100_port_private
*priv
,
547 char *packet
, int len
)
553 dbg("%s - port %d", __func__
, port
->number
);
556 (packet
[0] == 0x1b) && (packet
[1] == 0x1b) &&
557 ((packet
[2] == 0x00) || (packet
[2] == 0x01))) {
558 if (packet
[2] == 0x00)
559 priv
->shadowLSR
= packet
[3] & (UART_LSR_OE
|
564 if (packet
[2] == 0x01) {
565 priv
->shadowMSR
= packet
[3];
566 wake_up_interruptible(&priv
->delta_msr_wait
);
575 return 0; /* status only */
577 if (port
->port
.console
&& port
->sysrq
) {
578 for (i
= 0; i
< len
; i
++, ch
++) {
579 if (!usb_serial_handle_sysrq_char(tty
, port
, *ch
))
580 tty_insert_flip_char(tty
, *ch
, flag
);
583 tty_insert_flip_string_fixed_flag(tty
, ch
, flag
, len
);
588 static void ssu100_process_read_urb(struct urb
*urb
)
590 struct usb_serial_port
*port
= urb
->context
;
591 struct ssu100_port_private
*priv
= usb_get_serial_port_data(port
);
592 char *data
= (char *)urb
->transfer_buffer
;
593 struct tty_struct
*tty
;
600 tty
= tty_port_tty_get(&port
->port
);
604 for (i
= 0; i
< urb
->actual_length
; i
+= priv
->max_packet_size
) {
605 len
= min_t(int, urb
->actual_length
- i
, priv
->max_packet_size
);
606 count
+= ssu100_process_packet(tty
, port
, priv
, &data
[i
], len
);
610 tty_flip_buffer_push(tty
);
615 static struct usb_serial_driver ssu100_device
= {
617 .owner
= THIS_MODULE
,
620 .description
= DRIVER_DESC
,
621 .id_table
= id_table
,
622 .usb_driver
= &ssu100_driver
,
625 .bulk_out_size
= 256,
627 .close
= ssu100_close
,
628 .attach
= ssu100_attach
,
629 .release
= ssu100_release
,
630 .dtr_rts
= ssu100_dtr_rts
,
631 .process_read_urb
= ssu100_process_read_urb
,
632 .tiocmget
= ssu100_tiocmget
,
633 .tiocmset
= ssu100_tiocmset
,
634 .ioctl
= ssu100_ioctl
,
635 .set_termios
= ssu100_set_termios
,
638 static int __init
ssu100_init(void)
644 /* register with usb-serial */
645 retval
= usb_serial_register(&ssu100_device
);
648 goto failed_usb_sio_register
;
650 retval
= usb_register(&ssu100_driver
);
652 goto failed_usb_register
;
654 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
660 usb_serial_deregister(&ssu100_device
);
661 failed_usb_sio_register
:
665 static void __exit
ssu100_exit(void)
667 usb_deregister(&ssu100_driver
);
668 usb_serial_deregister(&ssu100_device
);
671 module_init(ssu100_init
);
672 module_exit(ssu100_exit
);
674 MODULE_DESCRIPTION(DRIVER_DESC
);
675 MODULE_LICENSE("GPL");
677 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
678 MODULE_PARM_DESC(debug
, "Debug enabled or not");