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>"
61 static const struct usb_device_id id_table
[] = {
62 { USB_DEVICE(OTI6858_VENDOR_ID
, OTI6858_PRODUCT_ID
) },
66 MODULE_DEVICE_TABLE(usb
, id_table
);
69 #define OTI6858_REQ_GET_STATUS (USB_DIR_IN | USB_TYPE_VENDOR | 0x00)
70 #define OTI6858_REQ_T_GET_STATUS 0x01
72 #define OTI6858_REQ_SET_LINE (USB_DIR_OUT | USB_TYPE_VENDOR | 0x00)
73 #define OTI6858_REQ_T_SET_LINE 0x00
75 #define OTI6858_REQ_CHECK_TXBUFF (USB_DIR_IN | USB_TYPE_VENDOR | 0x01)
76 #define OTI6858_REQ_T_CHECK_TXBUFF 0x00
78 /* format of the control packet */
79 struct oti6858_control_pkt
{
80 __le16 divisor
; /* baud rate = 96000000 / (16 * divisor), LE */
81 #define OTI6858_MAX_BAUD_RATE 3000000
83 #define FMT_STOP_BITS_MASK 0xc0
84 #define FMT_STOP_BITS_1 0x00
85 #define FMT_STOP_BITS_2 0x40 /* 1.5 stop bits if FMT_DATA_BITS_5 */
86 #define FMT_PARITY_MASK 0x38
87 #define FMT_PARITY_NONE 0x00
88 #define FMT_PARITY_ODD 0x08
89 #define FMT_PARITY_EVEN 0x18
90 #define FMT_PARITY_MARK 0x28
91 #define FMT_PARITY_SPACE 0x38
92 #define FMT_DATA_BITS_MASK 0x03
93 #define FMT_DATA_BITS_5 0x00
94 #define FMT_DATA_BITS_6 0x01
95 #define FMT_DATA_BITS_7 0x02
96 #define FMT_DATA_BITS_8 0x03
97 u8 something
; /* always equals 0x43 */
98 u8 control
; /* settings of flow control lines */
99 #define CONTROL_MASK 0x0c
100 #define CONTROL_DTR_HIGH 0x08
101 #define CONTROL_RTS_HIGH 0x04
103 #define TX_BUFFER_EMPTIED 0x09
105 #define PIN_MASK 0x3f
106 #define PIN_RTS 0x20 /* output pin */
107 #define PIN_CTS 0x10 /* input pin, active low */
108 #define PIN_DSR 0x08 /* input pin, active low */
109 #define PIN_DTR 0x04 /* output pin */
110 #define PIN_RI 0x02 /* input pin, active low */
111 #define PIN_DCD 0x01 /* input pin, active low */
112 u8 rx_bytes_avail
; /* number of bytes in rx buffer */;
115 #define OTI6858_CTRL_PKT_SIZE sizeof(struct oti6858_control_pkt)
116 #define OTI6858_CTRL_EQUALS_PENDING(a, priv) \
117 (((a)->divisor == (priv)->pending_setup.divisor) \
118 && ((a)->control == (priv)->pending_setup.control) \
119 && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt))
121 /* function prototypes */
122 static int oti6858_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
123 static void oti6858_close(struct usb_serial_port
*port
);
124 static void oti6858_set_termios(struct tty_struct
*tty
,
125 struct usb_serial_port
*port
, struct ktermios
*old
);
126 static void oti6858_init_termios(struct tty_struct
*tty
);
127 static int oti6858_ioctl(struct tty_struct
*tty
,
128 unsigned int cmd
, unsigned long arg
);
129 static void oti6858_read_int_callback(struct urb
*urb
);
130 static void oti6858_read_bulk_callback(struct urb
*urb
);
131 static void oti6858_write_bulk_callback(struct urb
*urb
);
132 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
133 const unsigned char *buf
, int count
);
134 static int oti6858_write_room(struct tty_struct
*tty
);
135 static int oti6858_chars_in_buffer(struct tty_struct
*tty
);
136 static int oti6858_tiocmget(struct tty_struct
*tty
);
137 static int oti6858_tiocmset(struct tty_struct
*tty
,
138 unsigned int set
, unsigned int clear
);
139 static int oti6858_port_probe(struct usb_serial_port
*port
);
140 static int oti6858_port_remove(struct usb_serial_port
*port
);
143 static struct usb_serial_driver oti6858_device
= {
145 .owner
= THIS_MODULE
,
148 .id_table
= id_table
,
150 .open
= oti6858_open
,
151 .close
= oti6858_close
,
152 .write
= oti6858_write
,
153 .ioctl
= oti6858_ioctl
,
154 .set_termios
= oti6858_set_termios
,
155 .init_termios
= oti6858_init_termios
,
156 .tiocmget
= oti6858_tiocmget
,
157 .tiocmset
= oti6858_tiocmset
,
158 .read_bulk_callback
= oti6858_read_bulk_callback
,
159 .read_int_callback
= oti6858_read_int_callback
,
160 .write_bulk_callback
= oti6858_write_bulk_callback
,
161 .write_room
= oti6858_write_room
,
162 .chars_in_buffer
= oti6858_chars_in_buffer
,
163 .port_probe
= oti6858_port_probe
,
164 .port_remove
= oti6858_port_remove
,
167 static struct usb_serial_driver
* const serial_drivers
[] = {
168 &oti6858_device
, NULL
171 struct oti6858_private
{
174 struct oti6858_control_pkt status
;
180 struct delayed_work delayed_write_work
;
189 struct delayed_work delayed_setup_work
;
191 wait_queue_head_t intr_wait
;
192 struct usb_serial_port
*port
; /* USB port with which associated */
195 static void setup_line(struct work_struct
*work
)
197 struct oti6858_private
*priv
= container_of(work
,
198 struct oti6858_private
, delayed_setup_work
.work
);
199 struct usb_serial_port
*port
= priv
->port
;
200 struct oti6858_control_pkt
*new_setup
;
204 new_setup
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
205 if (new_setup
== NULL
) {
206 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
207 /* we will try again */
208 schedule_delayed_work(&priv
->delayed_setup_work
,
209 msecs_to_jiffies(2));
213 result
= usb_control_msg(port
->serial
->dev
,
214 usb_rcvctrlpipe(port
->serial
->dev
, 0),
215 OTI6858_REQ_T_GET_STATUS
,
216 OTI6858_REQ_GET_STATUS
,
218 new_setup
, OTI6858_CTRL_PKT_SIZE
,
221 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
222 dev_err(&port
->dev
, "%s(): error reading status\n", __func__
);
224 /* we will try again */
225 schedule_delayed_work(&priv
->delayed_setup_work
,
226 msecs_to_jiffies(2));
230 spin_lock_irqsave(&priv
->lock
, flags
);
231 if (!OTI6858_CTRL_EQUALS_PENDING(new_setup
, priv
)) {
232 new_setup
->divisor
= priv
->pending_setup
.divisor
;
233 new_setup
->control
= priv
->pending_setup
.control
;
234 new_setup
->frame_fmt
= priv
->pending_setup
.frame_fmt
;
236 spin_unlock_irqrestore(&priv
->lock
, flags
);
237 result
= usb_control_msg(port
->serial
->dev
,
238 usb_sndctrlpipe(port
->serial
->dev
, 0),
239 OTI6858_REQ_T_SET_LINE
,
240 OTI6858_REQ_SET_LINE
,
242 new_setup
, OTI6858_CTRL_PKT_SIZE
,
245 spin_unlock_irqrestore(&priv
->lock
, flags
);
250 spin_lock_irqsave(&priv
->lock
, flags
);
251 if (result
!= OTI6858_CTRL_PKT_SIZE
)
253 priv
->setup_done
= 1;
254 spin_unlock_irqrestore(&priv
->lock
, flags
);
256 dev_dbg(&port
->dev
, "%s(): submitting interrupt urb\n", __func__
);
257 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
259 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed with error %d\n",
264 static void send_data(struct work_struct
*work
)
266 struct oti6858_private
*priv
= container_of(work
,
267 struct oti6858_private
, delayed_write_work
.work
);
268 struct usb_serial_port
*port
= priv
->port
;
269 int count
= 0, result
;
273 spin_lock_irqsave(&priv
->lock
, flags
);
274 if (priv
->flags
.write_urb_in_use
) {
275 spin_unlock_irqrestore(&priv
->lock
, flags
);
276 schedule_delayed_work(&priv
->delayed_write_work
,
277 msecs_to_jiffies(2));
280 priv
->flags
.write_urb_in_use
= 1;
281 spin_unlock_irqrestore(&priv
->lock
, flags
);
283 spin_lock_irqsave(&port
->lock
, flags
);
284 count
= kfifo_len(&port
->write_fifo
);
285 spin_unlock_irqrestore(&port
->lock
, flags
);
287 if (count
> port
->bulk_out_size
)
288 count
= port
->bulk_out_size
;
291 allow
= kmalloc(1, GFP_KERNEL
);
293 dev_err_console(port
, "%s(): kmalloc failed\n",
297 result
= usb_control_msg(port
->serial
->dev
,
298 usb_rcvctrlpipe(port
->serial
->dev
, 0),
299 OTI6858_REQ_T_CHECK_TXBUFF
,
300 OTI6858_REQ_CHECK_TXBUFF
,
301 count
, 0, allow
, 1, 100);
302 if (result
!= 1 || *allow
!= 0)
308 priv
->flags
.write_urb_in_use
= 0;
310 dev_dbg(&port
->dev
, "%s(): submitting interrupt urb\n", __func__
);
311 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_NOIO
);
313 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed with error %d\n",
319 count
= kfifo_out_locked(&port
->write_fifo
,
320 port
->write_urb
->transfer_buffer
,
322 port
->write_urb
->transfer_buffer_length
= count
;
323 result
= usb_submit_urb(port
->write_urb
, GFP_NOIO
);
325 dev_err_console(port
, "%s(): usb_submit_urb() failed with error %d\n",
327 priv
->flags
.write_urb_in_use
= 0;
330 usb_serial_port_softint(port
);
333 static int oti6858_port_probe(struct usb_serial_port
*port
)
335 struct oti6858_private
*priv
;
337 priv
= kzalloc(sizeof(*priv
), GFP_KERNEL
);
341 spin_lock_init(&priv
->lock
);
342 init_waitqueue_head(&priv
->intr_wait
);
344 INIT_DELAYED_WORK(&priv
->delayed_setup_work
, setup_line
);
345 INIT_DELAYED_WORK(&priv
->delayed_write_work
, send_data
);
347 usb_set_serial_port_data(port
, priv
);
352 static int oti6858_port_remove(struct usb_serial_port
*port
)
354 struct oti6858_private
*priv
;
356 priv
= usb_get_serial_port_data(port
);
362 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
363 const unsigned char *buf
, int count
)
368 count
= kfifo_in_locked(&port
->write_fifo
, buf
, count
, &port
->lock
);
373 static int oti6858_write_room(struct tty_struct
*tty
)
375 struct usb_serial_port
*port
= tty
->driver_data
;
379 spin_lock_irqsave(&port
->lock
, flags
);
380 room
= kfifo_avail(&port
->write_fifo
);
381 spin_unlock_irqrestore(&port
->lock
, flags
);
386 static int oti6858_chars_in_buffer(struct tty_struct
*tty
)
388 struct usb_serial_port
*port
= tty
->driver_data
;
392 spin_lock_irqsave(&port
->lock
, flags
);
393 chars
= kfifo_len(&port
->write_fifo
);
394 spin_unlock_irqrestore(&port
->lock
, flags
);
399 static void oti6858_init_termios(struct tty_struct
*tty
)
401 tty
->termios
= tty_std_termios
;
402 tty
->termios
.c_cflag
= B38400
| CS8
| CREAD
| HUPCL
| CLOCAL
;
403 tty
->termios
.c_ispeed
= 38400;
404 tty
->termios
.c_ospeed
= 38400;
407 static void oti6858_set_termios(struct tty_struct
*tty
,
408 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
410 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
413 u8 frame_fmt
, control
;
420 cflag
= tty
->termios
.c_cflag
;
422 spin_lock_irqsave(&priv
->lock
, flags
);
423 divisor
= priv
->pending_setup
.divisor
;
424 frame_fmt
= priv
->pending_setup
.frame_fmt
;
425 control
= priv
->pending_setup
.control
;
426 spin_unlock_irqrestore(&priv
->lock
, flags
);
428 frame_fmt
&= ~FMT_DATA_BITS_MASK
;
429 switch (cflag
& CSIZE
) {
431 frame_fmt
|= FMT_DATA_BITS_5
;
434 frame_fmt
|= FMT_DATA_BITS_6
;
437 frame_fmt
|= FMT_DATA_BITS_7
;
441 frame_fmt
|= FMT_DATA_BITS_8
;
445 /* manufacturer claims that this device can work with baud rates
446 * up to 3 Mbps; I've tested it only on 115200 bps, so I can't
447 * guarantee that any other baud rate will work (especially
450 br
= tty_get_baud_rate(tty
);
456 br
= min(br
, OTI6858_MAX_BAUD_RATE
);
458 new_divisor
= (96000000 + 8 * br
) / (16 * br
);
459 real_br
= 96000000 / (16 * new_divisor
);
460 divisor
= cpu_to_le16(new_divisor
);
461 tty_encode_baud_rate(tty
, real_br
, real_br
);
464 frame_fmt
&= ~FMT_STOP_BITS_MASK
;
465 if ((cflag
& CSTOPB
) != 0)
466 frame_fmt
|= FMT_STOP_BITS_2
;
468 frame_fmt
|= FMT_STOP_BITS_1
;
470 frame_fmt
&= ~FMT_PARITY_MASK
;
471 if ((cflag
& PARENB
) != 0) {
472 if ((cflag
& PARODD
) != 0)
473 frame_fmt
|= FMT_PARITY_ODD
;
475 frame_fmt
|= FMT_PARITY_EVEN
;
477 frame_fmt
|= FMT_PARITY_NONE
;
480 control
&= ~CONTROL_MASK
;
481 if ((cflag
& CRTSCTS
) != 0)
482 control
|= (CONTROL_DTR_HIGH
| CONTROL_RTS_HIGH
);
484 /* change control lines if we are switching to or from B0 */
486 spin_lock_irqsave(&priv->lock, flags);
487 control = priv->line_control;
488 if ((cflag & CBAUD) == B0)
489 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
491 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
492 if (control != priv->line_control) {
493 control = priv->line_control;
494 spin_unlock_irqrestore(&priv->lock, flags);
495 set_control_lines(serial->dev, control);
497 spin_unlock_irqrestore(&priv->lock, flags);
501 spin_lock_irqsave(&priv
->lock
, flags
);
502 if (divisor
!= priv
->pending_setup
.divisor
503 || control
!= priv
->pending_setup
.control
504 || frame_fmt
!= priv
->pending_setup
.frame_fmt
) {
505 priv
->pending_setup
.divisor
= divisor
;
506 priv
->pending_setup
.control
= control
;
507 priv
->pending_setup
.frame_fmt
= frame_fmt
;
509 spin_unlock_irqrestore(&priv
->lock
, flags
);
512 static int oti6858_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
514 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
515 struct ktermios tmp_termios
;
516 struct usb_serial
*serial
= port
->serial
;
517 struct oti6858_control_pkt
*buf
;
521 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
522 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
524 buf
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
526 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
530 result
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
531 OTI6858_REQ_T_GET_STATUS
,
532 OTI6858_REQ_GET_STATUS
,
534 buf
, OTI6858_CTRL_PKT_SIZE
,
536 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
537 /* assume default (after power-on reset) values */
538 buf
->divisor
= cpu_to_le16(0x009c); /* 38400 bps */
539 buf
->frame_fmt
= 0x03; /* 8N1 */
540 buf
->something
= 0x43;
541 buf
->control
= 0x4c; /* DTR, RTS */
542 buf
->tx_status
= 0x00;
543 buf
->pin_state
= 0x5b; /* RTS, CTS, DSR, DTR, RI, DCD */
544 buf
->rx_bytes_avail
= 0x00;
547 spin_lock_irqsave(&priv
->lock
, flags
);
548 memcpy(&priv
->status
, buf
, OTI6858_CTRL_PKT_SIZE
);
549 priv
->pending_setup
.divisor
= buf
->divisor
;
550 priv
->pending_setup
.frame_fmt
= buf
->frame_fmt
;
551 priv
->pending_setup
.control
= buf
->control
;
552 spin_unlock_irqrestore(&priv
->lock
, flags
);
555 dev_dbg(&port
->dev
, "%s(): submitting interrupt urb\n", __func__
);
556 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
558 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed with error %d\n",
566 oti6858_set_termios(tty
, port
, &tmp_termios
);
567 port
->port
.drain_delay
= 256; /* FIXME: check the FIFO length */
571 static void oti6858_close(struct usb_serial_port
*port
)
573 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
576 spin_lock_irqsave(&port
->lock
, flags
);
577 /* clear out any remaining data in the buffer */
578 kfifo_reset_out(&port
->write_fifo
);
579 spin_unlock_irqrestore(&port
->lock
, flags
);
581 dev_dbg(&port
->dev
, "%s(): after buf_clear()\n", __func__
);
583 /* cancel scheduled setup */
584 cancel_delayed_work_sync(&priv
->delayed_setup_work
);
585 cancel_delayed_work_sync(&priv
->delayed_write_work
);
587 /* shutdown our urbs */
588 dev_dbg(&port
->dev
, "%s(): shutting down urbs\n", __func__
);
589 usb_kill_urb(port
->write_urb
);
590 usb_kill_urb(port
->read_urb
);
591 usb_kill_urb(port
->interrupt_in_urb
);
594 static int oti6858_tiocmset(struct tty_struct
*tty
,
595 unsigned int set
, unsigned int clear
)
597 struct usb_serial_port
*port
= tty
->driver_data
;
598 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
602 dev_dbg(&port
->dev
, "%s(set = 0x%08x, clear = 0x%08x)\n",
603 __func__
, set
, clear
);
605 /* FIXME: check if this is correct (active high/low) */
606 spin_lock_irqsave(&priv
->lock
, flags
);
607 control
= priv
->pending_setup
.control
;
608 if ((set
& TIOCM_RTS
) != 0)
609 control
|= CONTROL_RTS_HIGH
;
610 if ((set
& TIOCM_DTR
) != 0)
611 control
|= CONTROL_DTR_HIGH
;
612 if ((clear
& TIOCM_RTS
) != 0)
613 control
&= ~CONTROL_RTS_HIGH
;
614 if ((clear
& TIOCM_DTR
) != 0)
615 control
&= ~CONTROL_DTR_HIGH
;
617 if (control
!= priv
->pending_setup
.control
)
618 priv
->pending_setup
.control
= control
;
620 spin_unlock_irqrestore(&priv
->lock
, flags
);
624 static int oti6858_tiocmget(struct tty_struct
*tty
)
626 struct usb_serial_port
*port
= tty
->driver_data
;
627 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
632 spin_lock_irqsave(&priv
->lock
, flags
);
633 pin_state
= priv
->status
.pin_state
& PIN_MASK
;
634 spin_unlock_irqrestore(&priv
->lock
, flags
);
636 /* FIXME: check if this is correct (active high/low) */
637 if ((pin_state
& PIN_RTS
) != 0)
639 if ((pin_state
& PIN_CTS
) != 0)
641 if ((pin_state
& PIN_DSR
) != 0)
643 if ((pin_state
& PIN_DTR
) != 0)
645 if ((pin_state
& PIN_RI
) != 0)
647 if ((pin_state
& PIN_DCD
) != 0)
650 dev_dbg(&port
->dev
, "%s() = 0x%08x\n", __func__
, result
);
655 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
657 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
659 unsigned int prev
, status
;
660 unsigned int changed
;
662 spin_lock_irqsave(&priv
->lock
, flags
);
663 prev
= priv
->status
.pin_state
;
664 spin_unlock_irqrestore(&priv
->lock
, flags
);
667 wait_event_interruptible(priv
->intr_wait
,
668 priv
->status
.pin_state
!= prev
);
669 if (signal_pending(current
))
672 spin_lock_irqsave(&priv
->lock
, flags
);
673 status
= priv
->status
.pin_state
& PIN_MASK
;
674 spin_unlock_irqrestore(&priv
->lock
, flags
);
676 changed
= prev
^ status
;
677 /* FIXME: check if this is correct (active high/low) */
678 if (((arg
& TIOCM_RNG
) && (changed
& PIN_RI
)) ||
679 ((arg
& TIOCM_DSR
) && (changed
& PIN_DSR
)) ||
680 ((arg
& TIOCM_CD
) && (changed
& PIN_DCD
)) ||
681 ((arg
& TIOCM_CTS
) && (changed
& PIN_CTS
)))
690 static int oti6858_ioctl(struct tty_struct
*tty
,
691 unsigned int cmd
, unsigned long arg
)
693 struct usb_serial_port
*port
= tty
->driver_data
;
695 dev_dbg(&port
->dev
, "%s(cmd = 0x%04x, arg = 0x%08lx)\n", __func__
, cmd
, arg
);
699 dev_dbg(&port
->dev
, "%s(): TIOCMIWAIT\n", __func__
);
700 return wait_modem_info(port
, arg
);
702 dev_dbg(&port
->dev
, "%s(): 0x%04x not supported\n", __func__
, cmd
);
708 static void oti6858_read_int_callback(struct urb
*urb
)
710 struct usb_serial_port
*port
= urb
->context
;
711 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
712 int transient
= 0, can_recv
= 0, resubmit
= 1;
713 int status
= urb
->status
;
722 /* this urb is terminated, clean up */
723 dev_dbg(&urb
->dev
->dev
, "%s(): urb shutting down with status: %d\n",
727 dev_dbg(&urb
->dev
->dev
, "%s(): nonzero urb status received: %d\n",
732 if (status
== 0 && urb
->actual_length
== OTI6858_CTRL_PKT_SIZE
) {
733 struct oti6858_control_pkt
*xs
= urb
->transfer_buffer
;
736 spin_lock_irqsave(&priv
->lock
, flags
);
738 if (!priv
->transient
) {
739 if (!OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
740 if (xs
->rx_bytes_avail
== 0) {
742 priv
->setup_done
= 0;
744 dev_dbg(&port
->dev
, "%s(): scheduling setup_line()\n", __func__
);
745 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
749 if (OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
751 } else if (!priv
->setup_done
) {
753 } else if (--priv
->transient
== 0) {
754 if (xs
->rx_bytes_avail
== 0) {
756 priv
->setup_done
= 0;
758 dev_dbg(&port
->dev
, "%s(): scheduling setup_line()\n", __func__
);
759 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
764 if (!priv
->transient
) {
765 if (xs
->pin_state
!= priv
->status
.pin_state
)
766 wake_up_interruptible(&priv
->intr_wait
);
767 memcpy(&priv
->status
, xs
, OTI6858_CTRL_PKT_SIZE
);
770 if (!priv
->transient
&& xs
->rx_bytes_avail
!= 0) {
771 can_recv
= xs
->rx_bytes_avail
;
772 priv
->flags
.read_urb_in_use
= 1;
775 transient
= priv
->transient
;
776 spin_unlock_irqrestore(&priv
->lock
, flags
);
782 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
784 priv
->flags
.read_urb_in_use
= 0;
785 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
786 " error %d\n", __func__
, result
);
790 } else if (!transient
) {
794 spin_lock_irqsave(&port
->lock
, flags
);
795 count
= kfifo_len(&port
->write_fifo
);
796 spin_unlock_irqrestore(&port
->lock
, flags
);
798 spin_lock_irqsave(&priv
->lock
, flags
);
799 if (priv
->flags
.write_urb_in_use
== 0 && count
!= 0) {
800 schedule_delayed_work(&priv
->delayed_write_work
, 0);
803 spin_unlock_irqrestore(&priv
->lock
, flags
);
809 /* dev_dbg(&urb->dev->dev, "%s(): submitting interrupt urb\n", __func__); */
810 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
812 dev_err(&urb
->dev
->dev
,
813 "%s(): usb_submit_urb() failed with"
814 " error %d\n", __func__
, result
);
819 static void oti6858_read_bulk_callback(struct urb
*urb
)
821 struct usb_serial_port
*port
= urb
->context
;
822 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
823 unsigned char *data
= urb
->transfer_buffer
;
825 int status
= urb
->status
;
828 spin_lock_irqsave(&priv
->lock
, flags
);
829 priv
->flags
.read_urb_in_use
= 0;
830 spin_unlock_irqrestore(&priv
->lock
, flags
);
833 dev_dbg(&urb
->dev
->dev
, "%s(): unable to handle the error, exiting\n", __func__
);
837 if (urb
->actual_length
> 0) {
838 tty_insert_flip_string(&port
->port
, data
, urb
->actual_length
);
839 tty_flip_buffer_push(&port
->port
);
842 /* schedule the interrupt urb */
843 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
844 if (result
!= 0 && result
!= -EPERM
) {
845 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
846 " error %d\n", __func__
, result
);
850 static void oti6858_write_bulk_callback(struct urb
*urb
)
852 struct usb_serial_port
*port
= urb
->context
;
853 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
854 int status
= urb
->status
;
864 /* this urb is terminated, clean up */
865 dev_dbg(&urb
->dev
->dev
, "%s(): urb shutting down with status: %d\n", __func__
, status
);
866 priv
->flags
.write_urb_in_use
= 0;
869 /* error in the urb, so we have to resubmit it */
870 dev_dbg(&urb
->dev
->dev
, "%s(): nonzero write bulk status received: %d\n", __func__
, status
);
871 dev_dbg(&urb
->dev
->dev
, "%s(): overflow in write\n", __func__
);
873 port
->write_urb
->transfer_buffer_length
= 1;
874 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
876 dev_err_console(port
, "%s(): usb_submit_urb() failed,"
877 " error %d\n", __func__
, result
);
883 priv
->flags
.write_urb_in_use
= 0;
885 /* schedule the interrupt urb if we are still open */
886 dev_dbg(&port
->dev
, "%s(): submitting interrupt urb\n", __func__
);
887 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
889 dev_err(&port
->dev
, "%s(): failed submitting int urb,"
890 " error %d\n", __func__
, result
);
894 module_usb_serial_driver(serial_drivers
, id_table
);
896 MODULE_DESCRIPTION(OTI6858_DESCRIPTION
);
897 MODULE_AUTHOR(OTI6858_AUTHOR
);
898 MODULE_LICENSE("GPL");