2 * Ours Technology Inc. OTi-6858 USB to serial adapter driver.
4 * Copyleft (C) 2007 Kees Lemmens (adapted for kernel 2.6.20)
5 * Copyright (C) 2006 Tomasz Michal Lukaszewski (FIXME: add e-mail)
6 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com)
7 * Copyright (C) 2003 IBM Corp.
9 * Many thanks to the authors of pl2303 driver: all functions in this file
10 * are heavily based on pl2303 code, buffering code is a 1-to-1 copy.
12 * Warning! You use this driver on your own risk! The only official
13 * description of this device I have is datasheet from manufacturer,
14 * and it doesn't contain almost any information needed to write a driver.
15 * Almost all knowlegde used while writing this driver was gathered by:
16 * - analyzing traffic between device and the M$ Windows 2000 driver,
17 * - trying different bit combinations and checking pin states
19 * - receiving malformed frames and producing buffer overflows
20 * to learn how errors are reported,
21 * So, THIS CODE CAN DESTROY OTi-6858 AND ANY OTHER DEVICES, THAT ARE
24 * This program is free software; you can redistribute it and/or modify
25 * it under the terms of the GNU General Public License as published by
26 * the Free Software Foundation; either version 2 of the License.
28 * See Documentation/usb/usb-serial.txt for more information on using this driver
31 * - implement correct flushing for ioctls and oti6858_close()
32 * - check how errors (rx overflow, parity error, framing error) are reported
33 * - implement oti6858_break_ctl()
34 * - implement more ioctls
35 * - test/implement flow control
36 * - allow setting custom baud rates
39 #include <linux/kernel.h>
40 #include <linux/errno.h>
41 #include <linux/init.h>
42 #include <linux/slab.h>
43 #include <linux/tty.h>
44 #include <linux/tty_driver.h>
45 #include <linux/tty_flip.h>
46 #include <linux/serial.h>
47 #include <linux/module.h>
48 #include <linux/moduleparam.h>
49 #include <linux/spinlock.h>
50 #include <linux/usb.h>
51 #include <linux/usb/serial.h>
52 #include <asm/uaccess.h>
55 #define OTI6858_DESCRIPTION \
56 "Ours Technology Inc. OTi-6858 USB to serial adapter driver"
57 #define OTI6858_AUTHOR "Tomasz Michal Lukaszewski <FIXME@FIXME>"
58 #define OTI6858_VERSION "0.1"
60 static struct usb_device_id id_table
[] = {
61 { USB_DEVICE(OTI6858_VENDOR_ID
, OTI6858_PRODUCT_ID
) },
65 MODULE_DEVICE_TABLE(usb
, id_table
);
67 static struct usb_driver oti6858_driver
= {
69 .probe
= usb_serial_probe
,
70 .disconnect
= usb_serial_disconnect
,
78 /* buffering code, copied from pl2303 driver */
79 #define PL2303_BUF_SIZE 1024
80 #define PL2303_TMP_BUF_SIZE 1024
83 unsigned int buf_size
;
90 #define OTI6858_REQ_GET_STATUS (USB_DIR_IN | USB_TYPE_VENDOR | 0x00)
91 #define OTI6858_REQ_T_GET_STATUS 0x01
93 #define OTI6858_REQ_SET_LINE (USB_DIR_OUT | USB_TYPE_VENDOR | 0x00)
94 #define OTI6858_REQ_T_SET_LINE 0x00
96 #define OTI6858_REQ_CHECK_TXBUFF (USB_DIR_IN | USB_TYPE_VENDOR | 0x01)
97 #define OTI6858_REQ_T_CHECK_TXBUFF 0x00
99 /* format of the control packet */
100 struct oti6858_control_pkt
{
101 u16 divisor
; /* baud rate = 96000000 / (16 * divisor), LE */
102 #define OTI6858_MAX_BAUD_RATE 3000000
104 #define FMT_STOP_BITS_MASK 0xc0
105 #define FMT_STOP_BITS_1 0x00
106 #define FMT_STOP_BITS_2 0x40 /* 1.5 stop bits if FMT_DATA_BITS_5 */
107 #define FMT_PARITY_MASK 0x38
108 #define FMT_PARITY_NONE 0x00
109 #define FMT_PARITY_ODD 0x08
110 #define FMT_PARITY_EVEN 0x18
111 #define FMT_PARITY_MARK 0x28
112 #define FMT_PARITY_SPACE 0x38
113 #define FMT_DATA_BITS_MASK 0x03
114 #define FMT_DATA_BITS_5 0x00
115 #define FMT_DATA_BITS_6 0x01
116 #define FMT_DATA_BITS_7 0x02
117 #define FMT_DATA_BITS_8 0x03
118 u8 something
; /* always equals 0x43 */
119 u8 control
; /* settings of flow control lines */
120 #define CONTROL_MASK 0x0c
121 #define CONTROL_DTR_HIGH 0x08
122 #define CONTROL_RTS_HIGH 0x04
124 #define TX_BUFFER_EMPTIED 0x09
126 #define PIN_MASK 0x3f
127 #define PIN_RTS 0x20 /* output pin */
128 #define PIN_CTS 0x10 /* input pin, active low */
129 #define PIN_DSR 0x08 /* input pin, active low */
130 #define PIN_DTR 0x04 /* output pin */
131 #define PIN_RI 0x02 /* input pin, active low */
132 #define PIN_DCD 0x01 /* input pin, active low */
133 u8 rx_bytes_avail
; /* number of bytes in rx buffer */;
136 #define OTI6858_CTRL_PKT_SIZE sizeof(struct oti6858_control_pkt)
137 #define OTI6858_CTRL_EQUALS_PENDING(a, priv) \
138 ( ((a)->divisor == (priv)->pending_setup.divisor) \
139 && ((a)->control == (priv)->pending_setup.control) \
140 && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt) )
142 /* function prototypes */
143 static int oti6858_open(struct usb_serial_port
*port
, struct file
*filp
);
144 static void oti6858_close(struct usb_serial_port
*port
, struct file
*filp
);
145 static void oti6858_set_termios(struct usb_serial_port
*port
,
146 struct ktermios
*old
);
147 static int oti6858_ioctl(struct usb_serial_port
*port
, struct file
*file
,
148 unsigned int cmd
, unsigned long arg
);
149 static void oti6858_read_int_callback(struct urb
*urb
);
150 static void oti6858_read_bulk_callback(struct urb
*urb
);
151 static void oti6858_write_bulk_callback(struct urb
*urb
);
152 static int oti6858_write(struct usb_serial_port
*port
,
153 const unsigned char *buf
, int count
);
154 static int oti6858_write_room(struct usb_serial_port
*port
);
155 static void oti6858_break_ctl(struct usb_serial_port
*port
, int break_state
);
156 static int oti6858_chars_in_buffer(struct usb_serial_port
*port
);
157 static int oti6858_tiocmget(struct usb_serial_port
*port
, struct file
*file
);
158 static int oti6858_tiocmset(struct usb_serial_port
*port
, struct file
*file
,
159 unsigned int set
, unsigned int clear
);
160 static int oti6858_startup(struct usb_serial
*serial
);
161 static void oti6858_shutdown(struct usb_serial
*serial
);
163 /* functions operating on buffers */
164 static struct oti6858_buf
*oti6858_buf_alloc(unsigned int size
);
165 static void oti6858_buf_free(struct oti6858_buf
*pb
);
166 static void oti6858_buf_clear(struct oti6858_buf
*pb
);
167 static unsigned int oti6858_buf_data_avail(struct oti6858_buf
*pb
);
168 static unsigned int oti6858_buf_space_avail(struct oti6858_buf
*pb
);
169 static unsigned int oti6858_buf_put(struct oti6858_buf
*pb
, const char *buf
,
171 static unsigned int oti6858_buf_get(struct oti6858_buf
*pb
, char *buf
,
176 static struct usb_serial_driver oti6858_device
= {
178 .owner
= THIS_MODULE
,
181 .id_table
= id_table
,
182 .num_interrupt_in
= 1,
186 .open
= oti6858_open
,
187 .close
= oti6858_close
,
188 .write
= oti6858_write
,
189 .ioctl
= oti6858_ioctl
,
190 .break_ctl
= oti6858_break_ctl
,
191 .set_termios
= oti6858_set_termios
,
192 .tiocmget
= oti6858_tiocmget
,
193 .tiocmset
= oti6858_tiocmset
,
194 .read_bulk_callback
= oti6858_read_bulk_callback
,
195 .read_int_callback
= oti6858_read_int_callback
,
196 .write_bulk_callback
= oti6858_write_bulk_callback
,
197 .write_room
= oti6858_write_room
,
198 .chars_in_buffer
= oti6858_chars_in_buffer
,
199 .attach
= oti6858_startup
,
200 .shutdown
= oti6858_shutdown
,
203 struct oti6858_private
{
206 struct oti6858_buf
*buf
;
207 struct oti6858_control_pkt status
;
212 u8 termios_initialized
;
214 struct delayed_work delayed_write_work
;
223 struct delayed_work delayed_setup_work
;
225 wait_queue_head_t intr_wait
;
226 struct usb_serial_port
*port
; /* USB port with which associated */
230 /* #define dbg(format, arg...) printk(KERN_INFO "%s: " format "\n", __FILE__, ## arg) */
231 #define dbg(format, arg...) printk(KERN_INFO "" format "\n", ## arg)
233 static void setup_line(struct work_struct
*work
)
235 struct oti6858_private
*priv
= container_of(work
, struct oti6858_private
, delayed_setup_work
.work
);
236 struct usb_serial_port
*port
= priv
->port
;
237 struct oti6858_control_pkt
*new_setup
;
241 dbg("%s(port = %d)", __FUNCTION__
, port
->number
);
243 if ((new_setup
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
)) == NULL
) {
244 dev_err(&port
->dev
, "%s(): out of memory!\n", __FUNCTION__
);
245 /* we will try again */
246 schedule_delayed_work(&priv
->delayed_setup_work
, msecs_to_jiffies(2));
250 result
= usb_control_msg(port
->serial
->dev
,
251 usb_rcvctrlpipe(port
->serial
->dev
, 0),
252 OTI6858_REQ_T_GET_STATUS
,
253 OTI6858_REQ_GET_STATUS
,
255 new_setup
, OTI6858_CTRL_PKT_SIZE
,
258 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
259 dev_err(&port
->dev
, "%s(): error reading status\n", __FUNCTION__
);
261 /* we will try again */
262 schedule_delayed_work(&priv
->delayed_setup_work
, msecs_to_jiffies(2));
266 spin_lock_irqsave(&priv
->lock
, flags
);
267 if (!OTI6858_CTRL_EQUALS_PENDING(new_setup
, priv
)) {
268 new_setup
->divisor
= priv
->pending_setup
.divisor
;
269 new_setup
->control
= priv
->pending_setup
.control
;
270 new_setup
->frame_fmt
= priv
->pending_setup
.frame_fmt
;
272 spin_unlock_irqrestore(&priv
->lock
, flags
);
273 result
= usb_control_msg(port
->serial
->dev
,
274 usb_sndctrlpipe(port
->serial
->dev
, 0),
275 OTI6858_REQ_T_SET_LINE
,
276 OTI6858_REQ_SET_LINE
,
278 new_setup
, OTI6858_CTRL_PKT_SIZE
,
281 spin_unlock_irqrestore(&priv
->lock
, flags
);
286 spin_lock_irqsave(&priv
->lock
, flags
);
287 if (result
!= OTI6858_CTRL_PKT_SIZE
)
289 priv
->setup_done
= 1;
290 spin_unlock_irqrestore(&priv
->lock
, flags
);
292 dbg("%s(): submitting interrupt urb", __FUNCTION__
);
293 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
294 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
296 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
297 " with error %d\n", __FUNCTION__
, result
);
301 void send_data(struct work_struct
*work
)
303 struct oti6858_private
*priv
= container_of(work
, struct oti6858_private
, delayed_write_work
.work
);
304 struct usb_serial_port
*port
= priv
->port
;
305 int count
= 0, result
;
309 dbg("%s(port = %d)", __FUNCTION__
, port
->number
);
311 spin_lock_irqsave(&priv
->lock
, flags
);
312 if (priv
->flags
.write_urb_in_use
) {
313 spin_unlock_irqrestore(&priv
->lock
, flags
);
314 schedule_delayed_work(&priv
->delayed_write_work
, msecs_to_jiffies(2));
317 priv
->flags
.write_urb_in_use
= 1;
319 count
= oti6858_buf_data_avail(priv
->buf
);
320 spin_unlock_irqrestore(&priv
->lock
, flags
);
321 if (count
> port
->bulk_out_size
)
322 count
= port
->bulk_out_size
;
325 result
= usb_control_msg(port
->serial
->dev
,
326 usb_rcvctrlpipe(port
->serial
->dev
, 0),
327 OTI6858_REQ_T_CHECK_TXBUFF
,
328 OTI6858_REQ_CHECK_TXBUFF
,
329 count
, 0, &allow
, 1, 100);
330 if (result
!= 1 || allow
!= 0)
335 priv
->flags
.write_urb_in_use
= 0;
337 dbg("%s(): submitting interrupt urb", __FUNCTION__
);
338 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
339 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
341 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
342 " with error %d\n", __FUNCTION__
, result
);
347 spin_lock_irqsave(&priv
->lock
, flags
);
348 oti6858_buf_get(priv
->buf
, port
->write_urb
->transfer_buffer
, count
);
349 spin_unlock_irqrestore(&priv
->lock
, flags
);
351 port
->write_urb
->transfer_buffer_length
= count
;
352 port
->write_urb
->dev
= port
->serial
->dev
;
353 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
355 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
356 " with error %d\n", __FUNCTION__
, result
);
357 priv
->flags
.write_urb_in_use
= 0;
360 usb_serial_port_softint(port
);
363 static int oti6858_startup(struct usb_serial
*serial
)
365 struct usb_serial_port
*port
= serial
->port
[0];
366 struct oti6858_private
*priv
;
369 for (i
= 0; i
< serial
->num_ports
; ++i
) {
370 priv
= kzalloc(sizeof(struct oti6858_private
), GFP_KERNEL
);
373 priv
->buf
= oti6858_buf_alloc(PL2303_BUF_SIZE
);
374 if (priv
->buf
== NULL
) {
379 spin_lock_init(&priv
->lock
);
380 init_waitqueue_head(&priv
->intr_wait
);
381 // INIT_WORK(&priv->setup_work, setup_line, serial->port[i]);
382 // INIT_WORK(&priv->write_work, send_data, serial->port[i]);
384 INIT_DELAYED_WORK(&priv
->delayed_setup_work
, setup_line
);
385 INIT_DELAYED_WORK(&priv
->delayed_write_work
, send_data
);
387 usb_set_serial_port_data(serial
->port
[i
], priv
);
389 if (i
== serial
->num_ports
)
392 for (--i
; i
>= 0; --i
) {
393 priv
= usb_get_serial_port_data(serial
->port
[i
]);
394 oti6858_buf_free(priv
->buf
);
396 usb_set_serial_port_data(serial
->port
[i
], NULL
);
401 static int oti6858_write(struct usb_serial_port
*port
,
402 const unsigned char *buf
, int count
)
404 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
407 dbg("%s(port = %d, count = %d)", __FUNCTION__
, port
->number
, count
);
412 spin_lock_irqsave(&priv
->lock
, flags
);
413 count
= oti6858_buf_put(priv
->buf
, buf
, count
);
414 spin_unlock_irqrestore(&priv
->lock
, flags
);
419 static int oti6858_write_room(struct usb_serial_port
*port
)
421 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
425 dbg("%s(port = %d)", __FUNCTION__
, port
->number
);
427 spin_lock_irqsave(&priv
->lock
, flags
);
428 room
= oti6858_buf_space_avail(priv
->buf
);
429 spin_unlock_irqrestore(&priv
->lock
, flags
);
434 static int oti6858_chars_in_buffer(struct usb_serial_port
*port
)
436 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
440 dbg("%s(port = %d)", __FUNCTION__
, port
->number
);
442 spin_lock_irqsave(&priv
->lock
, flags
);
443 chars
= oti6858_buf_data_avail(priv
->buf
);
444 spin_unlock_irqrestore(&priv
->lock
, flags
);
449 static void oti6858_set_termios(struct usb_serial_port
*port
,
450 struct ktermios
*old_termios
)
452 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
455 u8 frame_fmt
, control
;
459 dbg("%s(port = %d)", __FUNCTION__
, port
->number
);
461 if (!port
->tty
|| !port
->tty
->termios
) {
462 dbg("%s(): no tty structures", __FUNCTION__
);
466 spin_lock_irqsave(&priv
->lock
, flags
);
467 if (!priv
->flags
.termios_initialized
) {
468 *(port
->tty
->termios
) = tty_std_termios
;
469 port
->tty
->termios
->c_cflag
= B38400
| CS8
| CREAD
| HUPCL
| CLOCAL
;
470 priv
->flags
.termios_initialized
= 1;
471 port
->tty
->termios
->c_ispeed
= 38400;
472 port
->tty
->termios
->c_ospeed
= 38400;
474 spin_unlock_irqrestore(&priv
->lock
, flags
);
476 cflag
= port
->tty
->termios
->c_cflag
;
478 spin_lock_irqsave(&priv
->lock
, flags
);
479 divisor
= priv
->pending_setup
.divisor
;
480 frame_fmt
= priv
->pending_setup
.frame_fmt
;
481 control
= priv
->pending_setup
.control
;
482 spin_unlock_irqrestore(&priv
->lock
, flags
);
484 frame_fmt
&= ~FMT_DATA_BITS_MASK
;
485 switch (cflag
& CSIZE
) {
487 frame_fmt
|= FMT_DATA_BITS_5
;
490 frame_fmt
|= FMT_DATA_BITS_6
;
493 frame_fmt
|= FMT_DATA_BITS_7
;
497 frame_fmt
|= FMT_DATA_BITS_8
;
501 /* manufacturer claims that this device can work with baud rates
502 * up to 3 Mbps; I've tested it only on 115200 bps, so I can't
503 * guarantee that any other baud rate will work (especially
506 br
= tty_get_baud_rate(port
->tty
);
511 br
= min(br
, OTI6858_MAX_BAUD_RATE
);
513 divisor
= (96000000 + 8 * br
) / (16 * br
);
514 real_br
= 96000000 / (16 * divisor
);
515 divisor
= cpu_to_le16(divisor
);
516 tty_encode_baud_rate(port
->tty
, real_br
, real_br
);
519 frame_fmt
&= ~FMT_STOP_BITS_MASK
;
520 if ((cflag
& CSTOPB
) != 0) {
521 frame_fmt
|= FMT_STOP_BITS_2
;
523 frame_fmt
|= FMT_STOP_BITS_1
;
526 frame_fmt
&= ~FMT_PARITY_MASK
;
527 if ((cflag
& PARENB
) != 0) {
528 if ((cflag
& PARODD
) != 0) {
529 frame_fmt
|= FMT_PARITY_ODD
;
531 frame_fmt
|= FMT_PARITY_EVEN
;
534 frame_fmt
|= FMT_PARITY_NONE
;
537 control
&= ~CONTROL_MASK
;
538 if ((cflag
& CRTSCTS
) != 0)
539 control
|= (CONTROL_DTR_HIGH
| CONTROL_RTS_HIGH
);
541 /* change control lines if we are switching to or from B0 */
543 spin_lock_irqsave(&priv->lock, flags);
544 control = priv->line_control;
545 if ((cflag & CBAUD) == B0)
546 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
548 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
549 if (control != priv->line_control) {
550 control = priv->line_control;
551 spin_unlock_irqrestore(&priv->lock, flags);
552 set_control_lines(serial->dev, control);
554 spin_unlock_irqrestore(&priv->lock, flags);
558 spin_lock_irqsave(&priv
->lock
, flags
);
559 if (divisor
!= priv
->pending_setup
.divisor
560 || control
!= priv
->pending_setup
.control
561 || frame_fmt
!= priv
->pending_setup
.frame_fmt
) {
562 priv
->pending_setup
.divisor
= divisor
;
563 priv
->pending_setup
.control
= control
;
564 priv
->pending_setup
.frame_fmt
= frame_fmt
;
566 spin_unlock_irqrestore(&priv
->lock
, flags
);
569 static int oti6858_open(struct usb_serial_port
*port
, struct file
*filp
)
571 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
572 struct ktermios tmp_termios
;
573 struct usb_serial
*serial
= port
->serial
;
574 struct oti6858_control_pkt
*buf
;
578 dbg("%s(port = %d)", __FUNCTION__
, port
->number
);
580 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
581 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
583 if (port
->open_count
!= 1)
586 if ((buf
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
)) == NULL
) {
587 dev_err(&port
->dev
, "%s(): out of memory!\n", __FUNCTION__
);
591 result
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
592 OTI6858_REQ_T_GET_STATUS
,
593 OTI6858_REQ_GET_STATUS
,
595 buf
, OTI6858_CTRL_PKT_SIZE
,
597 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
598 /* assume default (after power-on reset) values */
599 buf
->divisor
= cpu_to_le16(0x009c); /* 38400 bps */
600 buf
->frame_fmt
= 0x03; /* 8N1 */
601 buf
->something
= 0x43;
602 buf
->control
= 0x4c; /* DTR, RTS */
603 buf
->tx_status
= 0x00;
604 buf
->pin_state
= 0x5b; /* RTS, CTS, DSR, DTR, RI, DCD */
605 buf
->rx_bytes_avail
= 0x00;
608 spin_lock_irqsave(&priv
->lock
, flags
);
609 memcpy(&priv
->status
, buf
, OTI6858_CTRL_PKT_SIZE
);
610 priv
->pending_setup
.divisor
= buf
->divisor
;
611 priv
->pending_setup
.frame_fmt
= buf
->frame_fmt
;
612 priv
->pending_setup
.control
= buf
->control
;
613 spin_unlock_irqrestore(&priv
->lock
, flags
);
616 dbg("%s(): submitting interrupt urb", __FUNCTION__
);
617 port
->interrupt_in_urb
->dev
= serial
->dev
;
618 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
620 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
621 " with error %d\n", __FUNCTION__
, result
);
622 oti6858_close(port
, NULL
);
628 oti6858_set_termios(port
, &tmp_termios
);
633 static void oti6858_close(struct usb_serial_port
*port
, struct file
*filp
)
635 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
640 dbg("%s(port = %d)", __FUNCTION__
, port
->number
);
642 /* wait for data to drain from the buffer */
643 spin_lock_irqsave(&priv
->lock
, flags
);
644 timeout
= 30 * HZ
; /* PL2303_CLOSING_WAIT */
645 init_waitqueue_entry(&wait
, current
);
646 add_wait_queue(&port
->tty
->write_wait
, &wait
);
647 dbg("%s(): entering wait loop", __FUNCTION__
);
649 set_current_state(TASK_INTERRUPTIBLE
);
650 if (oti6858_buf_data_avail(priv
->buf
) == 0
651 || timeout
== 0 || signal_pending(current
)
652 || port
->serial
->disconnected
)
654 spin_unlock_irqrestore(&priv
->lock
, flags
);
655 timeout
= schedule_timeout(timeout
);
656 spin_lock_irqsave(&priv
->lock
, flags
);
658 set_current_state(TASK_RUNNING
);
659 remove_wait_queue(&port
->tty
->write_wait
, &wait
);
660 dbg("%s(): after wait loop", __FUNCTION__
);
662 /* clear out any remaining data in the buffer */
663 oti6858_buf_clear(priv
->buf
);
664 spin_unlock_irqrestore(&priv
->lock
, flags
);
666 /* wait for characters to drain from the device */
667 /* (this is long enough for the entire 256 byte */
668 /* pl2303 hardware buffer to drain with no flow */
669 /* control for data rates of 1200 bps or more, */
670 /* for lower rates we should really know how much */
671 /* data is in the buffer to compute a delay */
672 /* that is not unnecessarily long) */
674 bps = tty_get_baud_rate(port->tty);
676 timeout = max((HZ*2560)/bps,HZ/10);
680 schedule_timeout_interruptible(timeout
);
681 dbg("%s(): after schedule_timeout_interruptible()", __FUNCTION__
);
683 /* cancel scheduled setup */
684 cancel_delayed_work(&priv
->delayed_setup_work
);
685 cancel_delayed_work(&priv
->delayed_write_work
);
686 flush_scheduled_work();
688 /* shutdown our urbs */
689 dbg("%s(): shutting down urbs", __FUNCTION__
);
690 usb_kill_urb(port
->write_urb
);
691 usb_kill_urb(port
->read_urb
);
692 usb_kill_urb(port
->interrupt_in_urb
);
695 if (port->tty && (port->tty->termios->c_cflag) & HUPCL) {
697 spin_lock_irqsave(&priv->lock, flags);
698 priv->pending_setup.control &= ~CONTROL_MASK;
699 spin_unlock_irqrestore(&priv->lock, flags);
704 static int oti6858_tiocmset(struct usb_serial_port
*port
, struct file
*file
,
705 unsigned int set
, unsigned int clear
)
707 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
711 dbg("%s(port = %d, set = 0x%08x, clear = 0x%08x)",
712 __FUNCTION__
, port
->number
, set
, clear
);
714 if (!usb_get_intfdata(port
->serial
->interface
))
717 /* FIXME: check if this is correct (active high/low) */
718 spin_lock_irqsave(&priv
->lock
, flags
);
719 control
= priv
->pending_setup
.control
;
720 if ((set
& TIOCM_RTS
) != 0)
721 control
|= CONTROL_RTS_HIGH
;
722 if ((set
& TIOCM_DTR
) != 0)
723 control
|= CONTROL_DTR_HIGH
;
724 if ((clear
& TIOCM_RTS
) != 0)
725 control
&= ~CONTROL_RTS_HIGH
;
726 if ((clear
& TIOCM_DTR
) != 0)
727 control
&= ~CONTROL_DTR_HIGH
;
729 if (control
!= priv
->pending_setup
.control
) {
730 priv
->pending_setup
.control
= control
;
732 spin_unlock_irqrestore(&priv
->lock
, flags
);
737 static int oti6858_tiocmget(struct usb_serial_port
*port
, struct file
*file
)
739 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
744 dbg("%s(port = %d)", __FUNCTION__
, port
->number
);
746 if (!usb_get_intfdata(port
->serial
->interface
))
749 spin_lock_irqsave(&priv
->lock
, flags
);
750 pin_state
= priv
->status
.pin_state
& PIN_MASK
;
751 spin_unlock_irqrestore(&priv
->lock
, flags
);
753 /* FIXME: check if this is correct (active high/low) */
754 if ((pin_state
& PIN_RTS
) != 0)
756 if ((pin_state
& PIN_CTS
) != 0)
758 if ((pin_state
& PIN_DSR
) != 0)
760 if ((pin_state
& PIN_DTR
) != 0)
762 if ((pin_state
& PIN_RI
) != 0)
764 if ((pin_state
& PIN_DCD
) != 0)
767 dbg("%s() = 0x%08x", __FUNCTION__
, result
);
772 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
774 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
776 unsigned int prev
, status
;
777 unsigned int changed
;
779 spin_lock_irqsave(&priv
->lock
, flags
);
780 prev
= priv
->status
.pin_state
;
781 spin_unlock_irqrestore(&priv
->lock
, flags
);
784 wait_event_interruptible(priv
->intr_wait
, priv
->status
.pin_state
!= prev
);
785 if (signal_pending(current
))
788 spin_lock_irqsave(&priv
->lock
, flags
);
789 status
= priv
->status
.pin_state
& PIN_MASK
;
790 spin_unlock_irqrestore(&priv
->lock
, flags
);
792 changed
= prev
^ status
;
793 /* FIXME: check if this is correct (active high/low) */
794 if ( ((arg
& TIOCM_RNG
) && (changed
& PIN_RI
)) ||
795 ((arg
& TIOCM_DSR
) && (changed
& PIN_DSR
)) ||
796 ((arg
& TIOCM_CD
) && (changed
& PIN_DCD
)) ||
797 ((arg
& TIOCM_CTS
) && (changed
& PIN_CTS
))) {
807 static int oti6858_ioctl(struct usb_serial_port
*port
, struct file
*file
,
808 unsigned int cmd
, unsigned long arg
)
810 void __user
*user_arg
= (void __user
*) arg
;
813 dbg("%s(port = %d, cmd = 0x%04x, arg = 0x%08lx)",
814 __FUNCTION__
, port
->number
, cmd
, arg
);
818 if (copy_from_user(&x
, user_arg
, sizeof(x
)))
820 return oti6858_tiocmset(port
, NULL
, x
, 0);
823 if (copy_from_user(&x
, user_arg
, sizeof(x
)))
825 return oti6858_tiocmset(port
, NULL
, 0, x
);
828 dbg("%s(): TIOCMIWAIT", __FUNCTION__
);
829 return wait_modem_info(port
, arg
);
832 dbg("%s(): 0x%04x not supported", __FUNCTION__
, cmd
);
839 static void oti6858_break_ctl(struct usb_serial_port
*port
, int break_state
)
843 dbg("%s(port = %d)", __FUNCTION__
, port
->number
);
845 state
= (break_state
== 0) ? 0 : 1;
846 dbg("%s(): turning break %s", __FUNCTION__
, state
? "on" : "off");
850 result = usb_control_msg (serial->dev, usb_sndctrlpipe (serial->dev, 0),
851 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
854 dbg("%s(): error sending break", __FUNCTION__);
858 static void oti6858_shutdown(struct usb_serial
*serial
)
860 struct oti6858_private
*priv
;
863 dbg("%s()", __FUNCTION__
);
865 for (i
= 0; i
< serial
->num_ports
; ++i
) {
866 priv
= usb_get_serial_port_data(serial
->port
[i
]);
868 oti6858_buf_free(priv
->buf
);
870 usb_set_serial_port_data(serial
->port
[i
], NULL
);
875 static void oti6858_read_int_callback(struct urb
*urb
)
877 struct usb_serial_port
*port
= (struct usb_serial_port
*) urb
->context
;
878 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
879 int transient
= 0, can_recv
= 0, resubmit
= 1;
880 int status
= urb
->status
;
882 dbg("%s(port = %d, status = %d)",
883 __FUNCTION__
, port
->number
, status
);
892 /* this urb is terminated, clean up */
893 dbg("%s(): urb shutting down with status: %d",
894 __FUNCTION__
, status
);
897 dbg("%s(): nonzero urb status received: %d",
898 __FUNCTION__
, status
);
902 if (status
== 0 && urb
->actual_length
== OTI6858_CTRL_PKT_SIZE
) {
903 struct oti6858_control_pkt
*xs
= urb
->transfer_buffer
;
906 spin_lock_irqsave(&priv
->lock
, flags
);
908 if (!priv
->transient
) {
909 if (!OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
910 if (xs
->rx_bytes_avail
== 0) {
912 priv
->setup_done
= 0;
914 dbg("%s(): scheduling setup_line()",
916 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
920 if (OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
922 } else if (!priv
->setup_done
) {
924 } else if (--priv
->transient
== 0) {
925 if (xs
->rx_bytes_avail
== 0) {
927 priv
->setup_done
= 0;
929 dbg("%s(): scheduling setup_line()",
931 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
936 if (!priv
->transient
) {
937 if (xs
->pin_state
!= priv
->status
.pin_state
)
938 wake_up_interruptible(&priv
->intr_wait
);
939 memcpy(&priv
->status
, xs
, OTI6858_CTRL_PKT_SIZE
);
942 if (!priv
->transient
&& xs
->rx_bytes_avail
!= 0) {
943 can_recv
= xs
->rx_bytes_avail
;
944 priv
->flags
.read_urb_in_use
= 1;
947 transient
= priv
->transient
;
948 spin_unlock_irqrestore(&priv
->lock
, flags
);
954 port
->read_urb
->dev
= port
->serial
->dev
;
955 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
957 priv
->flags
.read_urb_in_use
= 0;
958 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
959 " error %d\n", __FUNCTION__
, result
);
963 } else if (!transient
) {
966 spin_lock_irqsave(&priv
->lock
, flags
);
967 if (priv
->flags
.write_urb_in_use
== 0
968 && oti6858_buf_data_avail(priv
->buf
) != 0) {
969 schedule_delayed_work(&priv
->delayed_write_work
,0);
972 spin_unlock_irqrestore(&priv
->lock
, flags
);
978 // dbg("%s(): submitting interrupt urb", __FUNCTION__);
979 urb
->dev
= port
->serial
->dev
;
980 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
982 dev_err(&urb
->dev
->dev
,
983 "%s(): usb_submit_urb() failed with"
984 " error %d\n", __FUNCTION__
, result
);
989 static void oti6858_read_bulk_callback(struct urb
*urb
)
991 struct usb_serial_port
*port
= (struct usb_serial_port
*) urb
->context
;
992 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
993 struct tty_struct
*tty
;
994 unsigned char *data
= urb
->transfer_buffer
;
996 int status
= urb
->status
;
999 dbg("%s(port = %d, status = %d)",
1000 __FUNCTION__
, port
->number
, status
);
1002 spin_lock_irqsave(&priv
->lock
, flags
);
1003 priv
->flags
.read_urb_in_use
= 0;
1004 spin_unlock_irqrestore(&priv
->lock
, flags
);
1007 if (!port
->open_count
) {
1008 dbg("%s(): port is closed, exiting", __FUNCTION__
);
1012 if (status == -EPROTO) {
1013 // PL2303 mysteriously fails with -EPROTO reschedule the read
1014 dbg("%s - caught -EPROTO, resubmitting the urb", __FUNCTION__);
1015 result = usb_submit_urb(urb, GFP_ATOMIC);
1017 dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result);
1021 dbg("%s(): unable to handle the error, exiting", __FUNCTION__
);
1026 if (tty
!= NULL
&& urb
->actual_length
> 0) {
1027 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
1028 tty_flip_buffer_push(tty
);
1031 // schedule the interrupt urb if we are still open */
1032 if (port
->open_count
!= 0) {
1033 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1034 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1036 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
1037 " error %d\n", __FUNCTION__
, result
);
1042 static void oti6858_write_bulk_callback(struct urb
*urb
)
1044 struct usb_serial_port
*port
= (struct usb_serial_port
*) urb
->context
;
1045 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
1046 int status
= urb
->status
;
1049 dbg("%s(port = %d, status = %d)",
1050 __FUNCTION__
, port
->number
, status
);
1059 /* this urb is terminated, clean up */
1060 dbg("%s(): urb shutting down with status: %d",
1061 __FUNCTION__
, status
);
1062 priv
->flags
.write_urb_in_use
= 0;
1065 /* error in the urb, so we have to resubmit it */
1066 dbg("%s(): nonzero write bulk status received: %d",
1067 __FUNCTION__
, status
);
1068 dbg("%s(): overflow in write", __FUNCTION__
);
1070 port
->write_urb
->transfer_buffer_length
= 1;
1071 port
->write_urb
->dev
= port
->serial
->dev
;
1072 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
1074 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
1075 " error %d\n", __FUNCTION__
, result
);
1081 priv
->flags
.write_urb_in_use
= 0;
1083 // schedule the interrupt urb if we are still open */
1084 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1085 dbg("%s(): submitting interrupt urb", __FUNCTION__
);
1086 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1088 dev_err(&port
->dev
, "%s(): failed submitting int urb,"
1089 " error %d\n", __FUNCTION__
, result
);
1097 * Allocate a circular buffer and all associated memory.
1099 static struct oti6858_buf
*oti6858_buf_alloc(unsigned int size
)
1101 struct oti6858_buf
*pb
;
1106 pb
= kmalloc(sizeof(struct oti6858_buf
), GFP_KERNEL
);
1110 pb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
1111 if (pb
->buf_buf
== NULL
) {
1116 pb
->buf_size
= size
;
1117 pb
->buf_get
= pb
->buf_put
= pb
->buf_buf
;
1125 * Free the buffer and all associated memory.
1127 static void oti6858_buf_free(struct oti6858_buf
*pb
)
1138 * Clear out all data in the circular buffer.
1140 static void oti6858_buf_clear(struct oti6858_buf
*pb
)
1143 /* equivalent to a get of all data available */
1144 pb
->buf_get
= pb
->buf_put
;
1149 * oti6858_buf_data_avail
1151 * Return the number of bytes of data available in the circular
1154 static unsigned int oti6858_buf_data_avail(struct oti6858_buf
*pb
)
1158 return ((pb
->buf_size
+ pb
->buf_put
- pb
->buf_get
) % pb
->buf_size
);
1162 * oti6858_buf_space_avail
1164 * Return the number of bytes of space available in the circular
1167 static unsigned int oti6858_buf_space_avail(struct oti6858_buf
*pb
)
1171 return ((pb
->buf_size
+ pb
->buf_get
- pb
->buf_put
- 1) % pb
->buf_size
);
1177 * Copy data data from a user buffer and put it into the circular buffer.
1178 * Restrict to the amount of space available.
1180 * Return the number of bytes copied.
1182 static unsigned int oti6858_buf_put(struct oti6858_buf
*pb
, const char *buf
,
1190 len
= oti6858_buf_space_avail(pb
);
1197 len
= pb
->buf_buf
+ pb
->buf_size
- pb
->buf_put
;
1199 memcpy(pb
->buf_put
, buf
, len
);
1200 memcpy(pb
->buf_buf
, buf
+len
, count
- len
);
1201 pb
->buf_put
= pb
->buf_buf
+ count
- len
;
1203 memcpy(pb
->buf_put
, buf
, count
);
1205 pb
->buf_put
+= count
;
1206 else /* count == len */
1207 pb
->buf_put
= pb
->buf_buf
;
1216 * Get data from the circular buffer and copy to the given buffer.
1217 * Restrict to the amount of data available.
1219 * Return the number of bytes copied.
1221 static unsigned int oti6858_buf_get(struct oti6858_buf
*pb
, char *buf
,
1229 len
= oti6858_buf_data_avail(pb
);
1236 len
= pb
->buf_buf
+ pb
->buf_size
- pb
->buf_get
;
1238 memcpy(buf
, pb
->buf_get
, len
);
1239 memcpy(buf
+len
, pb
->buf_buf
, count
- len
);
1240 pb
->buf_get
= pb
->buf_buf
+ count
- len
;
1242 memcpy(buf
, pb
->buf_get
, count
);
1244 pb
->buf_get
+= count
;
1245 else /* count == len */
1246 pb
->buf_get
= pb
->buf_buf
;
1252 /* module description and (de)initialization */
1254 static int __init
oti6858_init(void)
1258 if ((retval
= usb_serial_register(&oti6858_device
)) == 0) {
1259 if ((retval
= usb_register(&oti6858_driver
)) != 0)
1260 usb_serial_deregister(&oti6858_device
);
1268 static void __exit
oti6858_exit(void)
1270 usb_deregister(&oti6858_driver
);
1271 usb_serial_deregister(&oti6858_device
);
1274 module_init(oti6858_init
);
1275 module_exit(oti6858_exit
);
1277 MODULE_DESCRIPTION(OTI6858_DESCRIPTION
);
1278 MODULE_AUTHOR(OTI6858_AUTHOR
);
1279 MODULE_VERSION(OTI6858_VERSION
);
1280 MODULE_LICENSE("GPL");
1282 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1283 MODULE_PARM_DESC(debug
, "enable debug output");