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
);
72 #define OTI6858_REQ_GET_STATUS (USB_DIR_IN | USB_TYPE_VENDOR | 0x00)
73 #define OTI6858_REQ_T_GET_STATUS 0x01
75 #define OTI6858_REQ_SET_LINE (USB_DIR_OUT | USB_TYPE_VENDOR | 0x00)
76 #define OTI6858_REQ_T_SET_LINE 0x00
78 #define OTI6858_REQ_CHECK_TXBUFF (USB_DIR_IN | USB_TYPE_VENDOR | 0x01)
79 #define OTI6858_REQ_T_CHECK_TXBUFF 0x00
81 /* format of the control packet */
82 struct oti6858_control_pkt
{
83 __le16 divisor
; /* baud rate = 96000000 / (16 * divisor), LE */
84 #define OTI6858_MAX_BAUD_RATE 3000000
86 #define FMT_STOP_BITS_MASK 0xc0
87 #define FMT_STOP_BITS_1 0x00
88 #define FMT_STOP_BITS_2 0x40 /* 1.5 stop bits if FMT_DATA_BITS_5 */
89 #define FMT_PARITY_MASK 0x38
90 #define FMT_PARITY_NONE 0x00
91 #define FMT_PARITY_ODD 0x08
92 #define FMT_PARITY_EVEN 0x18
93 #define FMT_PARITY_MARK 0x28
94 #define FMT_PARITY_SPACE 0x38
95 #define FMT_DATA_BITS_MASK 0x03
96 #define FMT_DATA_BITS_5 0x00
97 #define FMT_DATA_BITS_6 0x01
98 #define FMT_DATA_BITS_7 0x02
99 #define FMT_DATA_BITS_8 0x03
100 u8 something
; /* always equals 0x43 */
101 u8 control
; /* settings of flow control lines */
102 #define CONTROL_MASK 0x0c
103 #define CONTROL_DTR_HIGH 0x08
104 #define CONTROL_RTS_HIGH 0x04
106 #define TX_BUFFER_EMPTIED 0x09
108 #define PIN_MASK 0x3f
109 #define PIN_RTS 0x20 /* output pin */
110 #define PIN_CTS 0x10 /* input pin, active low */
111 #define PIN_DSR 0x08 /* input pin, active low */
112 #define PIN_DTR 0x04 /* output pin */
113 #define PIN_RI 0x02 /* input pin, active low */
114 #define PIN_DCD 0x01 /* input pin, active low */
115 u8 rx_bytes_avail
; /* number of bytes in rx buffer */;
118 #define OTI6858_CTRL_PKT_SIZE sizeof(struct oti6858_control_pkt)
119 #define OTI6858_CTRL_EQUALS_PENDING(a, priv) \
120 (((a)->divisor == (priv)->pending_setup.divisor) \
121 && ((a)->control == (priv)->pending_setup.control) \
122 && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt))
124 /* function prototypes */
125 static int oti6858_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
126 static void oti6858_close(struct usb_serial_port
*port
);
127 static void oti6858_set_termios(struct tty_struct
*tty
,
128 struct usb_serial_port
*port
, struct ktermios
*old
);
129 static void oti6858_init_termios(struct tty_struct
*tty
);
130 static int oti6858_ioctl(struct tty_struct
*tty
,
131 unsigned int cmd
, unsigned long arg
);
132 static void oti6858_read_int_callback(struct urb
*urb
);
133 static void oti6858_read_bulk_callback(struct urb
*urb
);
134 static void oti6858_write_bulk_callback(struct urb
*urb
);
135 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
136 const unsigned char *buf
, int count
);
137 static int oti6858_write_room(struct tty_struct
*tty
);
138 static int oti6858_chars_in_buffer(struct tty_struct
*tty
);
139 static int oti6858_tiocmget(struct tty_struct
*tty
);
140 static int oti6858_tiocmset(struct tty_struct
*tty
,
141 unsigned int set
, unsigned int clear
);
142 static int oti6858_startup(struct usb_serial
*serial
);
143 static void oti6858_release(struct usb_serial
*serial
);
146 static struct usb_serial_driver oti6858_device
= {
148 .owner
= THIS_MODULE
,
151 .id_table
= id_table
,
153 .open
= oti6858_open
,
154 .close
= oti6858_close
,
155 .write
= oti6858_write
,
156 .ioctl
= oti6858_ioctl
,
157 .set_termios
= oti6858_set_termios
,
158 .init_termios
= oti6858_init_termios
,
159 .tiocmget
= oti6858_tiocmget
,
160 .tiocmset
= oti6858_tiocmset
,
161 .read_bulk_callback
= oti6858_read_bulk_callback
,
162 .read_int_callback
= oti6858_read_int_callback
,
163 .write_bulk_callback
= oti6858_write_bulk_callback
,
164 .write_room
= oti6858_write_room
,
165 .chars_in_buffer
= oti6858_chars_in_buffer
,
166 .attach
= oti6858_startup
,
167 .release
= oti6858_release
,
170 static struct usb_serial_driver
* const serial_drivers
[] = {
171 &oti6858_device
, NULL
174 struct oti6858_private
{
177 struct oti6858_control_pkt status
;
183 struct delayed_work delayed_write_work
;
192 struct delayed_work delayed_setup_work
;
194 wait_queue_head_t intr_wait
;
195 struct usb_serial_port
*port
; /* USB port with which associated */
198 static void setup_line(struct work_struct
*work
)
200 struct oti6858_private
*priv
= container_of(work
,
201 struct oti6858_private
, delayed_setup_work
.work
);
202 struct usb_serial_port
*port
= priv
->port
;
203 struct oti6858_control_pkt
*new_setup
;
207 new_setup
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
208 if (new_setup
== NULL
) {
209 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
210 /* we will try again */
211 schedule_delayed_work(&priv
->delayed_setup_work
,
212 msecs_to_jiffies(2));
216 result
= usb_control_msg(port
->serial
->dev
,
217 usb_rcvctrlpipe(port
->serial
->dev
, 0),
218 OTI6858_REQ_T_GET_STATUS
,
219 OTI6858_REQ_GET_STATUS
,
221 new_setup
, OTI6858_CTRL_PKT_SIZE
,
224 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
225 dev_err(&port
->dev
, "%s(): error reading status\n", __func__
);
227 /* we will try again */
228 schedule_delayed_work(&priv
->delayed_setup_work
,
229 msecs_to_jiffies(2));
233 spin_lock_irqsave(&priv
->lock
, flags
);
234 if (!OTI6858_CTRL_EQUALS_PENDING(new_setup
, priv
)) {
235 new_setup
->divisor
= priv
->pending_setup
.divisor
;
236 new_setup
->control
= priv
->pending_setup
.control
;
237 new_setup
->frame_fmt
= priv
->pending_setup
.frame_fmt
;
239 spin_unlock_irqrestore(&priv
->lock
, flags
);
240 result
= usb_control_msg(port
->serial
->dev
,
241 usb_sndctrlpipe(port
->serial
->dev
, 0),
242 OTI6858_REQ_T_SET_LINE
,
243 OTI6858_REQ_SET_LINE
,
245 new_setup
, OTI6858_CTRL_PKT_SIZE
,
248 spin_unlock_irqrestore(&priv
->lock
, flags
);
253 spin_lock_irqsave(&priv
->lock
, flags
);
254 if (result
!= OTI6858_CTRL_PKT_SIZE
)
256 priv
->setup_done
= 1;
257 spin_unlock_irqrestore(&priv
->lock
, flags
);
259 dbg("%s(): submitting interrupt urb", __func__
);
260 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
262 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
263 " with error %d\n", __func__
, result
);
267 static void send_data(struct work_struct
*work
)
269 struct oti6858_private
*priv
= container_of(work
,
270 struct oti6858_private
, delayed_write_work
.work
);
271 struct usb_serial_port
*port
= priv
->port
;
272 int count
= 0, result
;
276 spin_lock_irqsave(&priv
->lock
, flags
);
277 if (priv
->flags
.write_urb_in_use
) {
278 spin_unlock_irqrestore(&priv
->lock
, flags
);
279 schedule_delayed_work(&priv
->delayed_write_work
,
280 msecs_to_jiffies(2));
283 priv
->flags
.write_urb_in_use
= 1;
284 spin_unlock_irqrestore(&priv
->lock
, flags
);
286 spin_lock_irqsave(&port
->lock
, flags
);
287 count
= kfifo_len(&port
->write_fifo
);
288 spin_unlock_irqrestore(&port
->lock
, flags
);
290 if (count
> port
->bulk_out_size
)
291 count
= port
->bulk_out_size
;
294 allow
= kmalloc(1, GFP_KERNEL
);
296 dev_err_console(port
, "%s(): kmalloc failed\n",
300 result
= usb_control_msg(port
->serial
->dev
,
301 usb_rcvctrlpipe(port
->serial
->dev
, 0),
302 OTI6858_REQ_T_CHECK_TXBUFF
,
303 OTI6858_REQ_CHECK_TXBUFF
,
304 count
, 0, allow
, 1, 100);
305 if (result
!= 1 || *allow
!= 0)
311 priv
->flags
.write_urb_in_use
= 0;
313 dbg("%s(): submitting interrupt urb", __func__
);
314 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_NOIO
);
316 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
317 " with error %d\n", __func__
, result
);
322 count
= kfifo_out_locked(&port
->write_fifo
,
323 port
->write_urb
->transfer_buffer
,
325 port
->write_urb
->transfer_buffer_length
= count
;
326 result
= usb_submit_urb(port
->write_urb
, GFP_NOIO
);
328 dev_err_console(port
, "%s(): usb_submit_urb() failed"
329 " with error %d\n", __func__
, result
);
330 priv
->flags
.write_urb_in_use
= 0;
333 usb_serial_port_softint(port
);
336 static int oti6858_startup(struct usb_serial
*serial
)
338 struct usb_serial_port
*port
= serial
->port
[0];
339 struct oti6858_private
*priv
;
342 for (i
= 0; i
< serial
->num_ports
; ++i
) {
343 priv
= kzalloc(sizeof(struct oti6858_private
), GFP_KERNEL
);
347 spin_lock_init(&priv
->lock
);
348 init_waitqueue_head(&priv
->intr_wait
);
349 /* INIT_WORK(&priv->setup_work, setup_line, serial->port[i]); */
350 /* INIT_WORK(&priv->write_work, send_data, serial->port[i]); */
352 INIT_DELAYED_WORK(&priv
->delayed_setup_work
, setup_line
);
353 INIT_DELAYED_WORK(&priv
->delayed_write_work
, send_data
);
355 usb_set_serial_port_data(serial
->port
[i
], priv
);
357 if (i
== serial
->num_ports
)
360 for (--i
; i
>= 0; --i
) {
361 priv
= usb_get_serial_port_data(serial
->port
[i
]);
363 usb_set_serial_port_data(serial
->port
[i
], NULL
);
368 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
369 const unsigned char *buf
, int count
)
374 count
= kfifo_in_locked(&port
->write_fifo
, buf
, count
, &port
->lock
);
379 static int oti6858_write_room(struct tty_struct
*tty
)
381 struct usb_serial_port
*port
= tty
->driver_data
;
385 spin_lock_irqsave(&port
->lock
, flags
);
386 room
= kfifo_avail(&port
->write_fifo
);
387 spin_unlock_irqrestore(&port
->lock
, flags
);
392 static int oti6858_chars_in_buffer(struct tty_struct
*tty
)
394 struct usb_serial_port
*port
= tty
->driver_data
;
398 spin_lock_irqsave(&port
->lock
, flags
);
399 chars
= kfifo_len(&port
->write_fifo
);
400 spin_unlock_irqrestore(&port
->lock
, flags
);
405 static void oti6858_init_termios(struct tty_struct
*tty
)
407 *(tty
->termios
) = tty_std_termios
;
408 tty
->termios
->c_cflag
= B38400
| CS8
| CREAD
| HUPCL
| CLOCAL
;
409 tty
->termios
->c_ispeed
= 38400;
410 tty
->termios
->c_ospeed
= 38400;
413 static void oti6858_set_termios(struct tty_struct
*tty
,
414 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
416 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
419 u8 frame_fmt
, control
;
424 dbg("%s(): no tty structures", __func__
);
428 cflag
= tty
->termios
->c_cflag
;
430 spin_lock_irqsave(&priv
->lock
, flags
);
431 divisor
= priv
->pending_setup
.divisor
;
432 frame_fmt
= priv
->pending_setup
.frame_fmt
;
433 control
= priv
->pending_setup
.control
;
434 spin_unlock_irqrestore(&priv
->lock
, flags
);
436 frame_fmt
&= ~FMT_DATA_BITS_MASK
;
437 switch (cflag
& CSIZE
) {
439 frame_fmt
|= FMT_DATA_BITS_5
;
442 frame_fmt
|= FMT_DATA_BITS_6
;
445 frame_fmt
|= FMT_DATA_BITS_7
;
449 frame_fmt
|= FMT_DATA_BITS_8
;
453 /* manufacturer claims that this device can work with baud rates
454 * up to 3 Mbps; I've tested it only on 115200 bps, so I can't
455 * guarantee that any other baud rate will work (especially
458 br
= tty_get_baud_rate(tty
);
464 br
= min(br
, OTI6858_MAX_BAUD_RATE
);
466 new_divisor
= (96000000 + 8 * br
) / (16 * br
);
467 real_br
= 96000000 / (16 * new_divisor
);
468 divisor
= cpu_to_le16(new_divisor
);
469 tty_encode_baud_rate(tty
, real_br
, real_br
);
472 frame_fmt
&= ~FMT_STOP_BITS_MASK
;
473 if ((cflag
& CSTOPB
) != 0)
474 frame_fmt
|= FMT_STOP_BITS_2
;
476 frame_fmt
|= FMT_STOP_BITS_1
;
478 frame_fmt
&= ~FMT_PARITY_MASK
;
479 if ((cflag
& PARENB
) != 0) {
480 if ((cflag
& PARODD
) != 0)
481 frame_fmt
|= FMT_PARITY_ODD
;
483 frame_fmt
|= FMT_PARITY_EVEN
;
485 frame_fmt
|= FMT_PARITY_NONE
;
488 control
&= ~CONTROL_MASK
;
489 if ((cflag
& CRTSCTS
) != 0)
490 control
|= (CONTROL_DTR_HIGH
| CONTROL_RTS_HIGH
);
492 /* change control lines if we are switching to or from B0 */
494 spin_lock_irqsave(&priv->lock, flags);
495 control = priv->line_control;
496 if ((cflag & CBAUD) == B0)
497 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
499 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
500 if (control != priv->line_control) {
501 control = priv->line_control;
502 spin_unlock_irqrestore(&priv->lock, flags);
503 set_control_lines(serial->dev, control);
505 spin_unlock_irqrestore(&priv->lock, flags);
509 spin_lock_irqsave(&priv
->lock
, flags
);
510 if (divisor
!= priv
->pending_setup
.divisor
511 || control
!= priv
->pending_setup
.control
512 || frame_fmt
!= priv
->pending_setup
.frame_fmt
) {
513 priv
->pending_setup
.divisor
= divisor
;
514 priv
->pending_setup
.control
= control
;
515 priv
->pending_setup
.frame_fmt
= frame_fmt
;
517 spin_unlock_irqrestore(&priv
->lock
, flags
);
520 static int oti6858_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
522 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
523 struct ktermios tmp_termios
;
524 struct usb_serial
*serial
= port
->serial
;
525 struct oti6858_control_pkt
*buf
;
529 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
530 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
532 buf
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
534 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
538 result
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
539 OTI6858_REQ_T_GET_STATUS
,
540 OTI6858_REQ_GET_STATUS
,
542 buf
, OTI6858_CTRL_PKT_SIZE
,
544 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
545 /* assume default (after power-on reset) values */
546 buf
->divisor
= cpu_to_le16(0x009c); /* 38400 bps */
547 buf
->frame_fmt
= 0x03; /* 8N1 */
548 buf
->something
= 0x43;
549 buf
->control
= 0x4c; /* DTR, RTS */
550 buf
->tx_status
= 0x00;
551 buf
->pin_state
= 0x5b; /* RTS, CTS, DSR, DTR, RI, DCD */
552 buf
->rx_bytes_avail
= 0x00;
555 spin_lock_irqsave(&priv
->lock
, flags
);
556 memcpy(&priv
->status
, buf
, OTI6858_CTRL_PKT_SIZE
);
557 priv
->pending_setup
.divisor
= buf
->divisor
;
558 priv
->pending_setup
.frame_fmt
= buf
->frame_fmt
;
559 priv
->pending_setup
.control
= buf
->control
;
560 spin_unlock_irqrestore(&priv
->lock
, flags
);
563 dbg("%s(): submitting interrupt urb", __func__
);
564 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
566 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
567 " with error %d\n", __func__
, result
);
574 oti6858_set_termios(tty
, port
, &tmp_termios
);
575 port
->port
.drain_delay
= 256; /* FIXME: check the FIFO length */
579 static void oti6858_close(struct usb_serial_port
*port
)
581 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
584 spin_lock_irqsave(&port
->lock
, flags
);
585 /* clear out any remaining data in the buffer */
586 kfifo_reset_out(&port
->write_fifo
);
587 spin_unlock_irqrestore(&port
->lock
, flags
);
589 dbg("%s(): after buf_clear()", __func__
);
591 /* cancel scheduled setup */
592 cancel_delayed_work_sync(&priv
->delayed_setup_work
);
593 cancel_delayed_work_sync(&priv
->delayed_write_work
);
595 /* shutdown our urbs */
596 dbg("%s(): shutting down urbs", __func__
);
597 usb_kill_urb(port
->write_urb
);
598 usb_kill_urb(port
->read_urb
);
599 usb_kill_urb(port
->interrupt_in_urb
);
602 static int oti6858_tiocmset(struct tty_struct
*tty
,
603 unsigned int set
, unsigned int clear
)
605 struct usb_serial_port
*port
= tty
->driver_data
;
606 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
610 dbg("%s(port = %d, set = 0x%08x, clear = 0x%08x)",
611 __func__
, port
->number
, set
, clear
);
613 /* FIXME: check if this is correct (active high/low) */
614 spin_lock_irqsave(&priv
->lock
, flags
);
615 control
= priv
->pending_setup
.control
;
616 if ((set
& TIOCM_RTS
) != 0)
617 control
|= CONTROL_RTS_HIGH
;
618 if ((set
& TIOCM_DTR
) != 0)
619 control
|= CONTROL_DTR_HIGH
;
620 if ((clear
& TIOCM_RTS
) != 0)
621 control
&= ~CONTROL_RTS_HIGH
;
622 if ((clear
& TIOCM_DTR
) != 0)
623 control
&= ~CONTROL_DTR_HIGH
;
625 if (control
!= priv
->pending_setup
.control
)
626 priv
->pending_setup
.control
= control
;
628 spin_unlock_irqrestore(&priv
->lock
, flags
);
632 static int oti6858_tiocmget(struct tty_struct
*tty
)
634 struct usb_serial_port
*port
= tty
->driver_data
;
635 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
640 spin_lock_irqsave(&priv
->lock
, flags
);
641 pin_state
= priv
->status
.pin_state
& PIN_MASK
;
642 spin_unlock_irqrestore(&priv
->lock
, flags
);
644 /* FIXME: check if this is correct (active high/low) */
645 if ((pin_state
& PIN_RTS
) != 0)
647 if ((pin_state
& PIN_CTS
) != 0)
649 if ((pin_state
& PIN_DSR
) != 0)
651 if ((pin_state
& PIN_DTR
) != 0)
653 if ((pin_state
& PIN_RI
) != 0)
655 if ((pin_state
& PIN_DCD
) != 0)
658 dbg("%s() = 0x%08x", __func__
, result
);
663 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
665 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
667 unsigned int prev
, status
;
668 unsigned int changed
;
670 spin_lock_irqsave(&priv
->lock
, flags
);
671 prev
= priv
->status
.pin_state
;
672 spin_unlock_irqrestore(&priv
->lock
, flags
);
675 wait_event_interruptible(priv
->intr_wait
,
676 priv
->status
.pin_state
!= prev
);
677 if (signal_pending(current
))
680 spin_lock_irqsave(&priv
->lock
, flags
);
681 status
= priv
->status
.pin_state
& PIN_MASK
;
682 spin_unlock_irqrestore(&priv
->lock
, flags
);
684 changed
= prev
^ status
;
685 /* FIXME: check if this is correct (active high/low) */
686 if (((arg
& TIOCM_RNG
) && (changed
& PIN_RI
)) ||
687 ((arg
& TIOCM_DSR
) && (changed
& PIN_DSR
)) ||
688 ((arg
& TIOCM_CD
) && (changed
& PIN_DCD
)) ||
689 ((arg
& TIOCM_CTS
) && (changed
& PIN_CTS
)))
698 static int oti6858_ioctl(struct tty_struct
*tty
,
699 unsigned int cmd
, unsigned long arg
)
701 struct usb_serial_port
*port
= tty
->driver_data
;
703 dbg("%s(port = %d, cmd = 0x%04x, arg = 0x%08lx)",
704 __func__
, port
->number
, cmd
, arg
);
708 dbg("%s(): TIOCMIWAIT", __func__
);
709 return wait_modem_info(port
, arg
);
711 dbg("%s(): 0x%04x not supported", __func__
, cmd
);
718 static void oti6858_release(struct usb_serial
*serial
)
722 for (i
= 0; i
< serial
->num_ports
; ++i
)
723 kfree(usb_get_serial_port_data(serial
->port
[i
]));
726 static void oti6858_read_int_callback(struct urb
*urb
)
728 struct usb_serial_port
*port
= urb
->context
;
729 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
730 int transient
= 0, can_recv
= 0, resubmit
= 1;
731 int status
= urb
->status
;
740 /* this urb is terminated, clean up */
741 dbg("%s(): urb shutting down with status: %d",
745 dbg("%s(): nonzero urb status received: %d",
750 if (status
== 0 && urb
->actual_length
== OTI6858_CTRL_PKT_SIZE
) {
751 struct oti6858_control_pkt
*xs
= urb
->transfer_buffer
;
754 spin_lock_irqsave(&priv
->lock
, flags
);
756 if (!priv
->transient
) {
757 if (!OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
758 if (xs
->rx_bytes_avail
== 0) {
760 priv
->setup_done
= 0;
762 dbg("%s(): scheduling setup_line()",
764 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
768 if (OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
770 } else if (!priv
->setup_done
) {
772 } else if (--priv
->transient
== 0) {
773 if (xs
->rx_bytes_avail
== 0) {
775 priv
->setup_done
= 0;
777 dbg("%s(): scheduling setup_line()",
779 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
784 if (!priv
->transient
) {
785 if (xs
->pin_state
!= priv
->status
.pin_state
)
786 wake_up_interruptible(&priv
->intr_wait
);
787 memcpy(&priv
->status
, xs
, OTI6858_CTRL_PKT_SIZE
);
790 if (!priv
->transient
&& xs
->rx_bytes_avail
!= 0) {
791 can_recv
= xs
->rx_bytes_avail
;
792 priv
->flags
.read_urb_in_use
= 1;
795 transient
= priv
->transient
;
796 spin_unlock_irqrestore(&priv
->lock
, flags
);
802 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
804 priv
->flags
.read_urb_in_use
= 0;
805 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
806 " error %d\n", __func__
, result
);
810 } else if (!transient
) {
814 spin_lock_irqsave(&port
->lock
, flags
);
815 count
= kfifo_len(&port
->write_fifo
);
816 spin_unlock_irqrestore(&port
->lock
, flags
);
818 spin_lock_irqsave(&priv
->lock
, flags
);
819 if (priv
->flags
.write_urb_in_use
== 0 && count
!= 0) {
820 schedule_delayed_work(&priv
->delayed_write_work
, 0);
823 spin_unlock_irqrestore(&priv
->lock
, flags
);
829 /* dbg("%s(): submitting interrupt urb", __func__); */
830 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
832 dev_err(&urb
->dev
->dev
,
833 "%s(): usb_submit_urb() failed with"
834 " error %d\n", __func__
, result
);
839 static void oti6858_read_bulk_callback(struct urb
*urb
)
841 struct usb_serial_port
*port
= urb
->context
;
842 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
843 struct tty_struct
*tty
;
844 unsigned char *data
= urb
->transfer_buffer
;
846 int status
= urb
->status
;
849 spin_lock_irqsave(&priv
->lock
, flags
);
850 priv
->flags
.read_urb_in_use
= 0;
851 spin_unlock_irqrestore(&priv
->lock
, flags
);
854 dbg("%s(): unable to handle the error, exiting", __func__
);
858 tty
= tty_port_tty_get(&port
->port
);
859 if (tty
!= NULL
&& urb
->actual_length
> 0) {
860 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
861 tty_flip_buffer_push(tty
);
865 /* schedule the interrupt urb */
866 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
867 if (result
!= 0 && result
!= -EPERM
) {
868 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
869 " error %d\n", __func__
, result
);
873 static void oti6858_write_bulk_callback(struct urb
*urb
)
875 struct usb_serial_port
*port
= urb
->context
;
876 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
877 int status
= urb
->status
;
887 /* this urb is terminated, clean up */
888 dbg("%s(): urb shutting down with status: %d",
890 priv
->flags
.write_urb_in_use
= 0;
893 /* error in the urb, so we have to resubmit it */
894 dbg("%s(): nonzero write bulk status received: %d",
896 dbg("%s(): overflow in write", __func__
);
898 port
->write_urb
->transfer_buffer_length
= 1;
899 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
901 dev_err_console(port
, "%s(): usb_submit_urb() failed,"
902 " error %d\n", __func__
, result
);
908 priv
->flags
.write_urb_in_use
= 0;
910 /* schedule the interrupt urb if we are still open */
911 dbg("%s(): submitting interrupt urb", __func__
);
912 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
914 dev_err(&port
->dev
, "%s(): failed submitting int urb,"
915 " error %d\n", __func__
, result
);
919 module_usb_serial_driver(serial_drivers
, id_table
);
921 MODULE_DESCRIPTION(OTI6858_DESCRIPTION
);
922 MODULE_AUTHOR(OTI6858_AUTHOR
);
923 MODULE_VERSION(OTI6858_VERSION
);
924 MODULE_LICENSE("GPL");
926 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
927 MODULE_PARM_DESC(debug
, "enable debug output");