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
32 * - implement correct flushing for ioctls and oti6858_close()
33 * - check how errors (rx overflow, parity error, framing error) are reported
34 * - implement oti6858_break_ctl()
35 * - implement more ioctls
36 * - test/implement flow control
37 * - allow setting custom baud rates
40 #include <linux/kernel.h>
41 #include <linux/errno.h>
42 #include <linux/init.h>
43 #include <linux/slab.h>
44 #include <linux/tty.h>
45 #include <linux/tty_driver.h>
46 #include <linux/tty_flip.h>
47 #include <linux/serial.h>
48 #include <linux/module.h>
49 #include <linux/moduleparam.h>
50 #include <linux/spinlock.h>
51 #include <linux/usb.h>
52 #include <linux/usb/serial.h>
53 #include <linux/uaccess.h>
54 #include <linux/kfifo.h>
57 #define OTI6858_DESCRIPTION \
58 "Ours Technology Inc. OTi-6858 USB to serial adapter driver"
59 #define OTI6858_AUTHOR "Tomasz Michal Lukaszewski <FIXME@FIXME>"
60 #define OTI6858_VERSION "0.2"
62 static const struct usb_device_id id_table
[] = {
63 { USB_DEVICE(OTI6858_VENDOR_ID
, OTI6858_PRODUCT_ID
) },
67 MODULE_DEVICE_TABLE(usb
, id_table
);
69 static struct usb_driver oti6858_driver
= {
71 .probe
= usb_serial_probe
,
72 .disconnect
= usb_serial_disconnect
,
80 #define OTI6858_REQ_GET_STATUS (USB_DIR_IN | USB_TYPE_VENDOR | 0x00)
81 #define OTI6858_REQ_T_GET_STATUS 0x01
83 #define OTI6858_REQ_SET_LINE (USB_DIR_OUT | USB_TYPE_VENDOR | 0x00)
84 #define OTI6858_REQ_T_SET_LINE 0x00
86 #define OTI6858_REQ_CHECK_TXBUFF (USB_DIR_IN | USB_TYPE_VENDOR | 0x01)
87 #define OTI6858_REQ_T_CHECK_TXBUFF 0x00
89 /* format of the control packet */
90 struct oti6858_control_pkt
{
91 __le16 divisor
; /* baud rate = 96000000 / (16 * divisor), LE */
92 #define OTI6858_MAX_BAUD_RATE 3000000
94 #define FMT_STOP_BITS_MASK 0xc0
95 #define FMT_STOP_BITS_1 0x00
96 #define FMT_STOP_BITS_2 0x40 /* 1.5 stop bits if FMT_DATA_BITS_5 */
97 #define FMT_PARITY_MASK 0x38
98 #define FMT_PARITY_NONE 0x00
99 #define FMT_PARITY_ODD 0x08
100 #define FMT_PARITY_EVEN 0x18
101 #define FMT_PARITY_MARK 0x28
102 #define FMT_PARITY_SPACE 0x38
103 #define FMT_DATA_BITS_MASK 0x03
104 #define FMT_DATA_BITS_5 0x00
105 #define FMT_DATA_BITS_6 0x01
106 #define FMT_DATA_BITS_7 0x02
107 #define FMT_DATA_BITS_8 0x03
108 u8 something
; /* always equals 0x43 */
109 u8 control
; /* settings of flow control lines */
110 #define CONTROL_MASK 0x0c
111 #define CONTROL_DTR_HIGH 0x08
112 #define CONTROL_RTS_HIGH 0x04
114 #define TX_BUFFER_EMPTIED 0x09
116 #define PIN_MASK 0x3f
117 #define PIN_RTS 0x20 /* output pin */
118 #define PIN_CTS 0x10 /* input pin, active low */
119 #define PIN_DSR 0x08 /* input pin, active low */
120 #define PIN_DTR 0x04 /* output pin */
121 #define PIN_RI 0x02 /* input pin, active low */
122 #define PIN_DCD 0x01 /* input pin, active low */
123 u8 rx_bytes_avail
; /* number of bytes in rx buffer */;
126 #define OTI6858_CTRL_PKT_SIZE sizeof(struct oti6858_control_pkt)
127 #define OTI6858_CTRL_EQUALS_PENDING(a, priv) \
128 (((a)->divisor == (priv)->pending_setup.divisor) \
129 && ((a)->control == (priv)->pending_setup.control) \
130 && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt))
132 /* function prototypes */
133 static int oti6858_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
134 static void oti6858_close(struct usb_serial_port
*port
);
135 static void oti6858_set_termios(struct tty_struct
*tty
,
136 struct usb_serial_port
*port
, struct ktermios
*old
);
137 static void oti6858_init_termios(struct tty_struct
*tty
);
138 static int oti6858_ioctl(struct tty_struct
*tty
, struct file
*file
,
139 unsigned int cmd
, unsigned long arg
);
140 static void oti6858_read_int_callback(struct urb
*urb
);
141 static void oti6858_read_bulk_callback(struct urb
*urb
);
142 static void oti6858_write_bulk_callback(struct urb
*urb
);
143 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
144 const unsigned char *buf
, int count
);
145 static int oti6858_write_room(struct tty_struct
*tty
);
146 static int oti6858_chars_in_buffer(struct tty_struct
*tty
);
147 static int oti6858_tiocmget(struct tty_struct
*tty
, struct file
*file
);
148 static int oti6858_tiocmset(struct tty_struct
*tty
, struct file
*file
,
149 unsigned int set
, unsigned int clear
);
150 static int oti6858_startup(struct usb_serial
*serial
);
151 static void oti6858_release(struct usb_serial
*serial
);
154 static struct usb_serial_driver oti6858_device
= {
156 .owner
= THIS_MODULE
,
159 .id_table
= id_table
,
161 .open
= oti6858_open
,
162 .close
= oti6858_close
,
163 .write
= oti6858_write
,
164 .ioctl
= oti6858_ioctl
,
165 .set_termios
= oti6858_set_termios
,
166 .init_termios
= oti6858_init_termios
,
167 .tiocmget
= oti6858_tiocmget
,
168 .tiocmset
= oti6858_tiocmset
,
169 .read_bulk_callback
= oti6858_read_bulk_callback
,
170 .read_int_callback
= oti6858_read_int_callback
,
171 .write_bulk_callback
= oti6858_write_bulk_callback
,
172 .write_room
= oti6858_write_room
,
173 .chars_in_buffer
= oti6858_chars_in_buffer
,
174 .attach
= oti6858_startup
,
175 .release
= oti6858_release
,
178 struct oti6858_private
{
181 struct oti6858_control_pkt status
;
187 struct delayed_work delayed_write_work
;
196 struct delayed_work delayed_setup_work
;
198 wait_queue_head_t intr_wait
;
199 struct usb_serial_port
*port
; /* USB port with which associated */
202 static void setup_line(struct work_struct
*work
)
204 struct oti6858_private
*priv
= container_of(work
,
205 struct oti6858_private
, delayed_setup_work
.work
);
206 struct usb_serial_port
*port
= priv
->port
;
207 struct oti6858_control_pkt
*new_setup
;
211 dbg("%s(port = %d)", __func__
, port
->number
);
213 new_setup
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
214 if (new_setup
== NULL
) {
215 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
216 /* we will try again */
217 schedule_delayed_work(&priv
->delayed_setup_work
,
218 msecs_to_jiffies(2));
222 result
= usb_control_msg(port
->serial
->dev
,
223 usb_rcvctrlpipe(port
->serial
->dev
, 0),
224 OTI6858_REQ_T_GET_STATUS
,
225 OTI6858_REQ_GET_STATUS
,
227 new_setup
, OTI6858_CTRL_PKT_SIZE
,
230 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
231 dev_err(&port
->dev
, "%s(): error reading status\n", __func__
);
233 /* we will try again */
234 schedule_delayed_work(&priv
->delayed_setup_work
,
235 msecs_to_jiffies(2));
239 spin_lock_irqsave(&priv
->lock
, flags
);
240 if (!OTI6858_CTRL_EQUALS_PENDING(new_setup
, priv
)) {
241 new_setup
->divisor
= priv
->pending_setup
.divisor
;
242 new_setup
->control
= priv
->pending_setup
.control
;
243 new_setup
->frame_fmt
= priv
->pending_setup
.frame_fmt
;
245 spin_unlock_irqrestore(&priv
->lock
, flags
);
246 result
= usb_control_msg(port
->serial
->dev
,
247 usb_sndctrlpipe(port
->serial
->dev
, 0),
248 OTI6858_REQ_T_SET_LINE
,
249 OTI6858_REQ_SET_LINE
,
251 new_setup
, OTI6858_CTRL_PKT_SIZE
,
254 spin_unlock_irqrestore(&priv
->lock
, flags
);
259 spin_lock_irqsave(&priv
->lock
, flags
);
260 if (result
!= OTI6858_CTRL_PKT_SIZE
)
262 priv
->setup_done
= 1;
263 spin_unlock_irqrestore(&priv
->lock
, flags
);
265 dbg("%s(): submitting interrupt urb", __func__
);
266 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
267 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
269 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
270 " with error %d\n", __func__
, result
);
274 static void send_data(struct work_struct
*work
)
276 struct oti6858_private
*priv
= container_of(work
,
277 struct oti6858_private
, delayed_write_work
.work
);
278 struct usb_serial_port
*port
= priv
->port
;
279 int count
= 0, result
;
283 dbg("%s(port = %d)", __func__
, port
->number
);
285 spin_lock_irqsave(&priv
->lock
, flags
);
286 if (priv
->flags
.write_urb_in_use
) {
287 spin_unlock_irqrestore(&priv
->lock
, flags
);
288 schedule_delayed_work(&priv
->delayed_write_work
,
289 msecs_to_jiffies(2));
292 priv
->flags
.write_urb_in_use
= 1;
293 spin_unlock_irqrestore(&priv
->lock
, flags
);
295 spin_lock_irqsave(&port
->lock
, flags
);
296 count
= kfifo_len(&port
->write_fifo
);
297 spin_unlock_irqrestore(&port
->lock
, flags
);
299 if (count
> port
->bulk_out_size
)
300 count
= port
->bulk_out_size
;
303 allow
= kmalloc(1, GFP_KERNEL
);
305 dev_err(&port
->dev
, "%s(): kmalloc failed\n",
309 result
= usb_control_msg(port
->serial
->dev
,
310 usb_rcvctrlpipe(port
->serial
->dev
, 0),
311 OTI6858_REQ_T_CHECK_TXBUFF
,
312 OTI6858_REQ_CHECK_TXBUFF
,
313 count
, 0, allow
, 1, 100);
314 if (result
!= 1 || *allow
!= 0)
320 priv
->flags
.write_urb_in_use
= 0;
322 dbg("%s(): submitting interrupt urb", __func__
);
323 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
324 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_NOIO
);
326 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
327 " with error %d\n", __func__
, result
);
332 count
= kfifo_out_locked(&port
->write_fifo
,
333 port
->write_urb
->transfer_buffer
,
335 port
->write_urb
->transfer_buffer_length
= count
;
336 port
->write_urb
->dev
= port
->serial
->dev
;
337 result
= usb_submit_urb(port
->write_urb
, GFP_NOIO
);
339 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
340 " with error %d\n", __func__
, result
);
341 priv
->flags
.write_urb_in_use
= 0;
344 usb_serial_port_softint(port
);
347 static int oti6858_startup(struct usb_serial
*serial
)
349 struct usb_serial_port
*port
= serial
->port
[0];
350 struct oti6858_private
*priv
;
353 for (i
= 0; i
< serial
->num_ports
; ++i
) {
354 priv
= kzalloc(sizeof(struct oti6858_private
), GFP_KERNEL
);
358 spin_lock_init(&priv
->lock
);
359 init_waitqueue_head(&priv
->intr_wait
);
360 /* INIT_WORK(&priv->setup_work, setup_line, serial->port[i]); */
361 /* INIT_WORK(&priv->write_work, send_data, serial->port[i]); */
363 INIT_DELAYED_WORK(&priv
->delayed_setup_work
, setup_line
);
364 INIT_DELAYED_WORK(&priv
->delayed_write_work
, send_data
);
366 usb_set_serial_port_data(serial
->port
[i
], priv
);
368 if (i
== serial
->num_ports
)
371 for (--i
; i
>= 0; --i
) {
372 priv
= usb_get_serial_port_data(serial
->port
[i
]);
374 usb_set_serial_port_data(serial
->port
[i
], NULL
);
379 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
380 const unsigned char *buf
, int count
)
382 dbg("%s(port = %d, count = %d)", __func__
, port
->number
, count
);
387 count
= kfifo_in_locked(&port
->write_fifo
, buf
, count
, &port
->lock
);
392 static int oti6858_write_room(struct tty_struct
*tty
)
394 struct usb_serial_port
*port
= tty
->driver_data
;
398 dbg("%s(port = %d)", __func__
, port
->number
);
400 spin_lock_irqsave(&port
->lock
, flags
);
401 room
= kfifo_avail(&port
->write_fifo
);
402 spin_unlock_irqrestore(&port
->lock
, flags
);
407 static int oti6858_chars_in_buffer(struct tty_struct
*tty
)
409 struct usb_serial_port
*port
= tty
->driver_data
;
413 dbg("%s(port = %d)", __func__
, port
->number
);
415 spin_lock_irqsave(&port
->lock
, flags
);
416 chars
= kfifo_len(&port
->write_fifo
);
417 spin_unlock_irqrestore(&port
->lock
, flags
);
422 static void oti6858_init_termios(struct tty_struct
*tty
)
424 *(tty
->termios
) = tty_std_termios
;
425 tty
->termios
->c_cflag
= B38400
| CS8
| CREAD
| HUPCL
| CLOCAL
;
426 tty
->termios
->c_ispeed
= 38400;
427 tty
->termios
->c_ospeed
= 38400;
430 static void oti6858_set_termios(struct tty_struct
*tty
,
431 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
433 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
436 u8 frame_fmt
, control
;
440 dbg("%s(port = %d)", __func__
, port
->number
);
443 dbg("%s(): no tty structures", __func__
);
447 cflag
= tty
->termios
->c_cflag
;
449 spin_lock_irqsave(&priv
->lock
, flags
);
450 divisor
= priv
->pending_setup
.divisor
;
451 frame_fmt
= priv
->pending_setup
.frame_fmt
;
452 control
= priv
->pending_setup
.control
;
453 spin_unlock_irqrestore(&priv
->lock
, flags
);
455 frame_fmt
&= ~FMT_DATA_BITS_MASK
;
456 switch (cflag
& CSIZE
) {
458 frame_fmt
|= FMT_DATA_BITS_5
;
461 frame_fmt
|= FMT_DATA_BITS_6
;
464 frame_fmt
|= FMT_DATA_BITS_7
;
468 frame_fmt
|= FMT_DATA_BITS_8
;
472 /* manufacturer claims that this device can work with baud rates
473 * up to 3 Mbps; I've tested it only on 115200 bps, so I can't
474 * guarantee that any other baud rate will work (especially
477 br
= tty_get_baud_rate(tty
);
483 br
= min(br
, OTI6858_MAX_BAUD_RATE
);
485 new_divisor
= (96000000 + 8 * br
) / (16 * br
);
486 real_br
= 96000000 / (16 * new_divisor
);
487 divisor
= cpu_to_le16(new_divisor
);
488 tty_encode_baud_rate(tty
, real_br
, real_br
);
491 frame_fmt
&= ~FMT_STOP_BITS_MASK
;
492 if ((cflag
& CSTOPB
) != 0)
493 frame_fmt
|= FMT_STOP_BITS_2
;
495 frame_fmt
|= FMT_STOP_BITS_1
;
497 frame_fmt
&= ~FMT_PARITY_MASK
;
498 if ((cflag
& PARENB
) != 0) {
499 if ((cflag
& PARODD
) != 0)
500 frame_fmt
|= FMT_PARITY_ODD
;
502 frame_fmt
|= FMT_PARITY_EVEN
;
504 frame_fmt
|= FMT_PARITY_NONE
;
507 control
&= ~CONTROL_MASK
;
508 if ((cflag
& CRTSCTS
) != 0)
509 control
|= (CONTROL_DTR_HIGH
| CONTROL_RTS_HIGH
);
511 /* change control lines if we are switching to or from B0 */
513 spin_lock_irqsave(&priv->lock, flags);
514 control = priv->line_control;
515 if ((cflag & CBAUD) == B0)
516 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
518 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
519 if (control != priv->line_control) {
520 control = priv->line_control;
521 spin_unlock_irqrestore(&priv->lock, flags);
522 set_control_lines(serial->dev, control);
524 spin_unlock_irqrestore(&priv->lock, flags);
528 spin_lock_irqsave(&priv
->lock
, flags
);
529 if (divisor
!= priv
->pending_setup
.divisor
530 || control
!= priv
->pending_setup
.control
531 || frame_fmt
!= priv
->pending_setup
.frame_fmt
) {
532 priv
->pending_setup
.divisor
= divisor
;
533 priv
->pending_setup
.control
= control
;
534 priv
->pending_setup
.frame_fmt
= frame_fmt
;
536 spin_unlock_irqrestore(&priv
->lock
, flags
);
539 static int oti6858_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
541 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
542 struct ktermios tmp_termios
;
543 struct usb_serial
*serial
= port
->serial
;
544 struct oti6858_control_pkt
*buf
;
548 dbg("%s(port = %d)", __func__
, port
->number
);
550 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
551 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
553 buf
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
555 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
559 result
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
560 OTI6858_REQ_T_GET_STATUS
,
561 OTI6858_REQ_GET_STATUS
,
563 buf
, OTI6858_CTRL_PKT_SIZE
,
565 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
566 /* assume default (after power-on reset) values */
567 buf
->divisor
= cpu_to_le16(0x009c); /* 38400 bps */
568 buf
->frame_fmt
= 0x03; /* 8N1 */
569 buf
->something
= 0x43;
570 buf
->control
= 0x4c; /* DTR, RTS */
571 buf
->tx_status
= 0x00;
572 buf
->pin_state
= 0x5b; /* RTS, CTS, DSR, DTR, RI, DCD */
573 buf
->rx_bytes_avail
= 0x00;
576 spin_lock_irqsave(&priv
->lock
, flags
);
577 memcpy(&priv
->status
, buf
, OTI6858_CTRL_PKT_SIZE
);
578 priv
->pending_setup
.divisor
= buf
->divisor
;
579 priv
->pending_setup
.frame_fmt
= buf
->frame_fmt
;
580 priv
->pending_setup
.control
= buf
->control
;
581 spin_unlock_irqrestore(&priv
->lock
, flags
);
584 dbg("%s(): submitting interrupt urb", __func__
);
585 port
->interrupt_in_urb
->dev
= serial
->dev
;
586 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
588 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
589 " with error %d\n", __func__
, result
);
596 oti6858_set_termios(tty
, port
, &tmp_termios
);
597 port
->port
.drain_delay
= 256; /* FIXME: check the FIFO length */
601 static void oti6858_close(struct usb_serial_port
*port
)
603 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
606 dbg("%s(port = %d)", __func__
, port
->number
);
608 spin_lock_irqsave(&port
->lock
, flags
);
609 /* clear out any remaining data in the buffer */
610 kfifo_reset_out(&port
->write_fifo
);
611 spin_unlock_irqrestore(&port
->lock
, flags
);
613 dbg("%s(): after buf_clear()", __func__
);
615 /* cancel scheduled setup */
616 cancel_delayed_work(&priv
->delayed_setup_work
);
617 cancel_delayed_work(&priv
->delayed_write_work
);
618 flush_scheduled_work();
620 /* shutdown our urbs */
621 dbg("%s(): shutting down urbs", __func__
);
622 usb_kill_urb(port
->write_urb
);
623 usb_kill_urb(port
->read_urb
);
624 usb_kill_urb(port
->interrupt_in_urb
);
627 static int oti6858_tiocmset(struct tty_struct
*tty
, struct file
*file
,
628 unsigned int set
, unsigned int clear
)
630 struct usb_serial_port
*port
= tty
->driver_data
;
631 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
635 dbg("%s(port = %d, set = 0x%08x, clear = 0x%08x)",
636 __func__
, port
->number
, set
, clear
);
638 if (!usb_get_intfdata(port
->serial
->interface
))
641 /* FIXME: check if this is correct (active high/low) */
642 spin_lock_irqsave(&priv
->lock
, flags
);
643 control
= priv
->pending_setup
.control
;
644 if ((set
& TIOCM_RTS
) != 0)
645 control
|= CONTROL_RTS_HIGH
;
646 if ((set
& TIOCM_DTR
) != 0)
647 control
|= CONTROL_DTR_HIGH
;
648 if ((clear
& TIOCM_RTS
) != 0)
649 control
&= ~CONTROL_RTS_HIGH
;
650 if ((clear
& TIOCM_DTR
) != 0)
651 control
&= ~CONTROL_DTR_HIGH
;
653 if (control
!= priv
->pending_setup
.control
)
654 priv
->pending_setup
.control
= control
;
656 spin_unlock_irqrestore(&priv
->lock
, flags
);
660 static int oti6858_tiocmget(struct tty_struct
*tty
, struct file
*file
)
662 struct usb_serial_port
*port
= tty
->driver_data
;
663 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
668 dbg("%s(port = %d)", __func__
, port
->number
);
670 if (!usb_get_intfdata(port
->serial
->interface
))
673 spin_lock_irqsave(&priv
->lock
, flags
);
674 pin_state
= priv
->status
.pin_state
& PIN_MASK
;
675 spin_unlock_irqrestore(&priv
->lock
, flags
);
677 /* FIXME: check if this is correct (active high/low) */
678 if ((pin_state
& PIN_RTS
) != 0)
680 if ((pin_state
& PIN_CTS
) != 0)
682 if ((pin_state
& PIN_DSR
) != 0)
684 if ((pin_state
& PIN_DTR
) != 0)
686 if ((pin_state
& PIN_RI
) != 0)
688 if ((pin_state
& PIN_DCD
) != 0)
691 dbg("%s() = 0x%08x", __func__
, result
);
696 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
698 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
700 unsigned int prev
, status
;
701 unsigned int changed
;
703 spin_lock_irqsave(&priv
->lock
, flags
);
704 prev
= priv
->status
.pin_state
;
705 spin_unlock_irqrestore(&priv
->lock
, flags
);
708 wait_event_interruptible(priv
->intr_wait
,
709 priv
->status
.pin_state
!= prev
);
710 if (signal_pending(current
))
713 spin_lock_irqsave(&priv
->lock
, flags
);
714 status
= priv
->status
.pin_state
& PIN_MASK
;
715 spin_unlock_irqrestore(&priv
->lock
, flags
);
717 changed
= prev
^ status
;
718 /* FIXME: check if this is correct (active high/low) */
719 if (((arg
& TIOCM_RNG
) && (changed
& PIN_RI
)) ||
720 ((arg
& TIOCM_DSR
) && (changed
& PIN_DSR
)) ||
721 ((arg
& TIOCM_CD
) && (changed
& PIN_DCD
)) ||
722 ((arg
& TIOCM_CTS
) && (changed
& PIN_CTS
)))
731 static int oti6858_ioctl(struct tty_struct
*tty
, struct file
*file
,
732 unsigned int cmd
, unsigned long arg
)
734 struct usb_serial_port
*port
= tty
->driver_data
;
736 dbg("%s(port = %d, cmd = 0x%04x, arg = 0x%08lx)",
737 __func__
, port
->number
, cmd
, arg
);
741 dbg("%s(): TIOCMIWAIT", __func__
);
742 return wait_modem_info(port
, arg
);
744 dbg("%s(): 0x%04x not supported", __func__
, cmd
);
751 static void oti6858_release(struct usb_serial
*serial
)
755 dbg("%s()", __func__
);
757 for (i
= 0; i
< serial
->num_ports
; ++i
)
758 kfree(usb_get_serial_port_data(serial
->port
[i
]));
761 static void oti6858_read_int_callback(struct urb
*urb
)
763 struct usb_serial_port
*port
= urb
->context
;
764 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
765 int transient
= 0, can_recv
= 0, resubmit
= 1;
766 int status
= urb
->status
;
768 dbg("%s(port = %d, status = %d)",
769 __func__
, port
->number
, status
);
778 /* this urb is terminated, clean up */
779 dbg("%s(): urb shutting down with status: %d",
783 dbg("%s(): nonzero urb status received: %d",
788 if (status
== 0 && urb
->actual_length
== OTI6858_CTRL_PKT_SIZE
) {
789 struct oti6858_control_pkt
*xs
= urb
->transfer_buffer
;
792 spin_lock_irqsave(&priv
->lock
, flags
);
794 if (!priv
->transient
) {
795 if (!OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
796 if (xs
->rx_bytes_avail
== 0) {
798 priv
->setup_done
= 0;
800 dbg("%s(): scheduling setup_line()",
802 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
806 if (OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
808 } else if (!priv
->setup_done
) {
810 } else if (--priv
->transient
== 0) {
811 if (xs
->rx_bytes_avail
== 0) {
813 priv
->setup_done
= 0;
815 dbg("%s(): scheduling setup_line()",
817 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
822 if (!priv
->transient
) {
823 if (xs
->pin_state
!= priv
->status
.pin_state
)
824 wake_up_interruptible(&priv
->intr_wait
);
825 memcpy(&priv
->status
, xs
, OTI6858_CTRL_PKT_SIZE
);
828 if (!priv
->transient
&& xs
->rx_bytes_avail
!= 0) {
829 can_recv
= xs
->rx_bytes_avail
;
830 priv
->flags
.read_urb_in_use
= 1;
833 transient
= priv
->transient
;
834 spin_unlock_irqrestore(&priv
->lock
, flags
);
840 port
->read_urb
->dev
= port
->serial
->dev
;
841 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
843 priv
->flags
.read_urb_in_use
= 0;
844 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
845 " error %d\n", __func__
, result
);
849 } else if (!transient
) {
853 spin_lock_irqsave(&port
->lock
, flags
);
854 count
= kfifo_len(&port
->write_fifo
);
855 spin_unlock_irqrestore(&port
->lock
, flags
);
857 spin_lock_irqsave(&priv
->lock
, flags
);
858 if (priv
->flags
.write_urb_in_use
== 0 && count
!= 0) {
859 schedule_delayed_work(&priv
->delayed_write_work
, 0);
862 spin_unlock_irqrestore(&priv
->lock
, flags
);
868 /* dbg("%s(): submitting interrupt urb", __func__); */
869 urb
->dev
= port
->serial
->dev
;
870 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
872 dev_err(&urb
->dev
->dev
,
873 "%s(): usb_submit_urb() failed with"
874 " error %d\n", __func__
, result
);
879 static void oti6858_read_bulk_callback(struct urb
*urb
)
881 struct usb_serial_port
*port
= urb
->context
;
882 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
883 struct tty_struct
*tty
;
884 unsigned char *data
= urb
->transfer_buffer
;
886 int status
= urb
->status
;
889 dbg("%s(port = %d, status = %d)",
890 __func__
, port
->number
, status
);
892 spin_lock_irqsave(&priv
->lock
, flags
);
893 priv
->flags
.read_urb_in_use
= 0;
894 spin_unlock_irqrestore(&priv
->lock
, flags
);
898 if (status == -EPROTO) {
899 * PL2303 mysteriously fails with -EPROTO reschedule
901 dbg("%s - caught -EPROTO, resubmitting the urb",
903 result = usb_submit_urb(urb, GFP_ATOMIC);
905 dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __func__, result);
909 dbg("%s(): unable to handle the error, exiting", __func__
);
913 tty
= tty_port_tty_get(&port
->port
);
914 if (tty
!= NULL
&& urb
->actual_length
> 0) {
915 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
916 tty_flip_buffer_push(tty
);
920 /* schedule the interrupt urb */
921 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
922 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
923 if (result
!= 0 && result
!= -EPERM
) {
924 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
925 " error %d\n", __func__
, result
);
929 static void oti6858_write_bulk_callback(struct urb
*urb
)
931 struct usb_serial_port
*port
= urb
->context
;
932 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
933 int status
= urb
->status
;
936 dbg("%s(port = %d, status = %d)",
937 __func__
, port
->number
, status
);
946 /* this urb is terminated, clean up */
947 dbg("%s(): urb shutting down with status: %d",
949 priv
->flags
.write_urb_in_use
= 0;
952 /* error in the urb, so we have to resubmit it */
953 dbg("%s(): nonzero write bulk status received: %d",
955 dbg("%s(): overflow in write", __func__
);
957 port
->write_urb
->transfer_buffer_length
= 1;
958 port
->write_urb
->dev
= port
->serial
->dev
;
959 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
961 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
962 " error %d\n", __func__
, result
);
968 priv
->flags
.write_urb_in_use
= 0;
970 /* schedule the interrupt urb if we are still open */
971 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
972 dbg("%s(): submitting interrupt urb", __func__
);
973 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
975 dev_err(&port
->dev
, "%s(): failed submitting int urb,"
976 " error %d\n", __func__
, result
);
980 /* module description and (de)initialization */
982 static int __init
oti6858_init(void)
986 retval
= usb_serial_register(&oti6858_device
);
988 retval
= usb_register(&oti6858_driver
);
990 usb_serial_deregister(&oti6858_device
);
995 static void __exit
oti6858_exit(void)
997 usb_deregister(&oti6858_driver
);
998 usb_serial_deregister(&oti6858_device
);
1001 module_init(oti6858_init
);
1002 module_exit(oti6858_exit
);
1004 MODULE_DESCRIPTION(OTI6858_DESCRIPTION
);
1005 MODULE_AUTHOR(OTI6858_AUTHOR
);
1006 MODULE_VERSION(OTI6858_VERSION
);
1007 MODULE_LICENSE("GPL");
1009 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1010 MODULE_PARM_DESC(debug
, "enable debug output");