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>
56 #define OTI6858_DESCRIPTION \
57 "Ours Technology Inc. OTi-6858 USB to serial adapter driver"
58 #define OTI6858_AUTHOR "Tomasz Michal Lukaszewski <FIXME@FIXME>"
59 #define OTI6858_VERSION "0.1"
61 static struct usb_device_id id_table
[] = {
62 { USB_DEVICE(OTI6858_VENDOR_ID
, OTI6858_PRODUCT_ID
) },
66 MODULE_DEVICE_TABLE(usb
, id_table
);
68 static struct usb_driver oti6858_driver
= {
70 .probe
= usb_serial_probe
,
71 .disconnect
= usb_serial_disconnect
,
79 /* buffering code, copied from pl2303 driver */
80 #define PL2303_BUF_SIZE 1024
81 #define PL2303_TMP_BUF_SIZE 1024
84 unsigned int buf_size
;
91 #define OTI6858_REQ_GET_STATUS (USB_DIR_IN | USB_TYPE_VENDOR | 0x00)
92 #define OTI6858_REQ_T_GET_STATUS 0x01
94 #define OTI6858_REQ_SET_LINE (USB_DIR_OUT | USB_TYPE_VENDOR | 0x00)
95 #define OTI6858_REQ_T_SET_LINE 0x00
97 #define OTI6858_REQ_CHECK_TXBUFF (USB_DIR_IN | USB_TYPE_VENDOR | 0x01)
98 #define OTI6858_REQ_T_CHECK_TXBUFF 0x00
100 /* format of the control packet */
101 struct oti6858_control_pkt
{
102 __le16 divisor
; /* baud rate = 96000000 / (16 * divisor), LE */
103 #define OTI6858_MAX_BAUD_RATE 3000000
105 #define FMT_STOP_BITS_MASK 0xc0
106 #define FMT_STOP_BITS_1 0x00
107 #define FMT_STOP_BITS_2 0x40 /* 1.5 stop bits if FMT_DATA_BITS_5 */
108 #define FMT_PARITY_MASK 0x38
109 #define FMT_PARITY_NONE 0x00
110 #define FMT_PARITY_ODD 0x08
111 #define FMT_PARITY_EVEN 0x18
112 #define FMT_PARITY_MARK 0x28
113 #define FMT_PARITY_SPACE 0x38
114 #define FMT_DATA_BITS_MASK 0x03
115 #define FMT_DATA_BITS_5 0x00
116 #define FMT_DATA_BITS_6 0x01
117 #define FMT_DATA_BITS_7 0x02
118 #define FMT_DATA_BITS_8 0x03
119 u8 something
; /* always equals 0x43 */
120 u8 control
; /* settings of flow control lines */
121 #define CONTROL_MASK 0x0c
122 #define CONTROL_DTR_HIGH 0x08
123 #define CONTROL_RTS_HIGH 0x04
125 #define TX_BUFFER_EMPTIED 0x09
127 #define PIN_MASK 0x3f
128 #define PIN_RTS 0x20 /* output pin */
129 #define PIN_CTS 0x10 /* input pin, active low */
130 #define PIN_DSR 0x08 /* input pin, active low */
131 #define PIN_DTR 0x04 /* output pin */
132 #define PIN_RI 0x02 /* input pin, active low */
133 #define PIN_DCD 0x01 /* input pin, active low */
134 u8 rx_bytes_avail
; /* number of bytes in rx buffer */;
137 #define OTI6858_CTRL_PKT_SIZE sizeof(struct oti6858_control_pkt)
138 #define OTI6858_CTRL_EQUALS_PENDING(a, priv) \
139 (((a)->divisor == (priv)->pending_setup.divisor) \
140 && ((a)->control == (priv)->pending_setup.control) \
141 && ((a)->frame_fmt == (priv)->pending_setup.frame_fmt))
143 /* function prototypes */
144 static int oti6858_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
145 static void oti6858_close(struct usb_serial_port
*port
);
146 static void oti6858_set_termios(struct tty_struct
*tty
,
147 struct usb_serial_port
*port
, struct ktermios
*old
);
148 static int oti6858_ioctl(struct tty_struct
*tty
, struct file
*file
,
149 unsigned int cmd
, unsigned long arg
);
150 static void oti6858_read_int_callback(struct urb
*urb
);
151 static void oti6858_read_bulk_callback(struct urb
*urb
);
152 static void oti6858_write_bulk_callback(struct urb
*urb
);
153 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
154 const unsigned char *buf
, int count
);
155 static int oti6858_write_room(struct tty_struct
*tty
);
156 static int oti6858_chars_in_buffer(struct tty_struct
*tty
);
157 static int oti6858_tiocmget(struct tty_struct
*tty
, struct file
*file
);
158 static int oti6858_tiocmset(struct tty_struct
*tty
, struct file
*file
,
159 unsigned int set
, unsigned int clear
);
160 static int oti6858_startup(struct usb_serial
*serial
);
161 static void oti6858_release(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
,
183 .open
= oti6858_open
,
184 .close
= oti6858_close
,
185 .write
= oti6858_write
,
186 .ioctl
= oti6858_ioctl
,
187 .set_termios
= oti6858_set_termios
,
188 .tiocmget
= oti6858_tiocmget
,
189 .tiocmset
= oti6858_tiocmset
,
190 .read_bulk_callback
= oti6858_read_bulk_callback
,
191 .read_int_callback
= oti6858_read_int_callback
,
192 .write_bulk_callback
= oti6858_write_bulk_callback
,
193 .write_room
= oti6858_write_room
,
194 .chars_in_buffer
= oti6858_chars_in_buffer
,
195 .attach
= oti6858_startup
,
196 .release
= oti6858_release
,
199 struct oti6858_private
{
202 struct oti6858_buf
*buf
;
203 struct oti6858_control_pkt status
;
208 u8 termios_initialized
;
210 struct delayed_work delayed_write_work
;
219 struct delayed_work delayed_setup_work
;
221 wait_queue_head_t intr_wait
;
222 struct usb_serial_port
*port
; /* USB port with which associated */
225 static void setup_line(struct work_struct
*work
)
227 struct oti6858_private
*priv
= container_of(work
,
228 struct oti6858_private
, delayed_setup_work
.work
);
229 struct usb_serial_port
*port
= priv
->port
;
230 struct oti6858_control_pkt
*new_setup
;
234 dbg("%s(port = %d)", __func__
, port
->number
);
236 new_setup
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
237 if (new_setup
== NULL
) {
238 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
239 /* we will try again */
240 schedule_delayed_work(&priv
->delayed_setup_work
,
241 msecs_to_jiffies(2));
245 result
= usb_control_msg(port
->serial
->dev
,
246 usb_rcvctrlpipe(port
->serial
->dev
, 0),
247 OTI6858_REQ_T_GET_STATUS
,
248 OTI6858_REQ_GET_STATUS
,
250 new_setup
, OTI6858_CTRL_PKT_SIZE
,
253 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
254 dev_err(&port
->dev
, "%s(): error reading status\n", __func__
);
256 /* we will try again */
257 schedule_delayed_work(&priv
->delayed_setup_work
,
258 msecs_to_jiffies(2));
262 spin_lock_irqsave(&priv
->lock
, flags
);
263 if (!OTI6858_CTRL_EQUALS_PENDING(new_setup
, priv
)) {
264 new_setup
->divisor
= priv
->pending_setup
.divisor
;
265 new_setup
->control
= priv
->pending_setup
.control
;
266 new_setup
->frame_fmt
= priv
->pending_setup
.frame_fmt
;
268 spin_unlock_irqrestore(&priv
->lock
, flags
);
269 result
= usb_control_msg(port
->serial
->dev
,
270 usb_sndctrlpipe(port
->serial
->dev
, 0),
271 OTI6858_REQ_T_SET_LINE
,
272 OTI6858_REQ_SET_LINE
,
274 new_setup
, OTI6858_CTRL_PKT_SIZE
,
277 spin_unlock_irqrestore(&priv
->lock
, flags
);
282 spin_lock_irqsave(&priv
->lock
, flags
);
283 if (result
!= OTI6858_CTRL_PKT_SIZE
)
285 priv
->setup_done
= 1;
286 spin_unlock_irqrestore(&priv
->lock
, flags
);
288 dbg("%s(): submitting interrupt urb", __func__
);
289 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
290 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
292 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
293 " with error %d\n", __func__
, result
);
297 void send_data(struct work_struct
*work
)
299 struct oti6858_private
*priv
= container_of(work
,
300 struct oti6858_private
, delayed_write_work
.work
);
301 struct usb_serial_port
*port
= priv
->port
;
302 int count
= 0, result
;
306 dbg("%s(port = %d)", __func__
, port
->number
);
308 spin_lock_irqsave(&priv
->lock
, flags
);
309 if (priv
->flags
.write_urb_in_use
) {
310 spin_unlock_irqrestore(&priv
->lock
, flags
);
311 schedule_delayed_work(&priv
->delayed_write_work
,
312 msecs_to_jiffies(2));
315 priv
->flags
.write_urb_in_use
= 1;
317 count
= oti6858_buf_data_avail(priv
->buf
);
318 spin_unlock_irqrestore(&priv
->lock
, flags
);
319 if (count
> port
->bulk_out_size
)
320 count
= port
->bulk_out_size
;
323 result
= usb_control_msg(port
->serial
->dev
,
324 usb_rcvctrlpipe(port
->serial
->dev
, 0),
325 OTI6858_REQ_T_CHECK_TXBUFF
,
326 OTI6858_REQ_CHECK_TXBUFF
,
327 count
, 0, &allow
, 1, 100);
328 if (result
!= 1 || allow
!= 0)
333 priv
->flags
.write_urb_in_use
= 0;
335 dbg("%s(): submitting interrupt urb", __func__
);
336 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
337 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
339 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
340 " with error %d\n", __func__
, result
);
345 spin_lock_irqsave(&priv
->lock
, flags
);
346 oti6858_buf_get(priv
->buf
, port
->write_urb
->transfer_buffer
, count
);
347 spin_unlock_irqrestore(&priv
->lock
, flags
);
349 port
->write_urb
->transfer_buffer_length
= count
;
350 port
->write_urb
->dev
= port
->serial
->dev
;
351 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
353 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
354 " with error %d\n", __func__
, result
);
355 priv
->flags
.write_urb_in_use
= 0;
358 usb_serial_port_softint(port
);
361 static int oti6858_startup(struct usb_serial
*serial
)
363 struct usb_serial_port
*port
= serial
->port
[0];
364 struct oti6858_private
*priv
;
367 for (i
= 0; i
< serial
->num_ports
; ++i
) {
368 priv
= kzalloc(sizeof(struct oti6858_private
), GFP_KERNEL
);
371 priv
->buf
= oti6858_buf_alloc(PL2303_BUF_SIZE
);
372 if (priv
->buf
== NULL
) {
377 spin_lock_init(&priv
->lock
);
378 init_waitqueue_head(&priv
->intr_wait
);
379 /* INIT_WORK(&priv->setup_work, setup_line, serial->port[i]); */
380 /* INIT_WORK(&priv->write_work, send_data, serial->port[i]); */
382 INIT_DELAYED_WORK(&priv
->delayed_setup_work
, setup_line
);
383 INIT_DELAYED_WORK(&priv
->delayed_write_work
, send_data
);
385 usb_set_serial_port_data(serial
->port
[i
], priv
);
387 if (i
== serial
->num_ports
)
390 for (--i
; i
>= 0; --i
) {
391 priv
= usb_get_serial_port_data(serial
->port
[i
]);
392 oti6858_buf_free(priv
->buf
);
394 usb_set_serial_port_data(serial
->port
[i
], NULL
);
399 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
400 const unsigned char *buf
, int count
)
402 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
405 dbg("%s(port = %d, count = %d)", __func__
, port
->number
, count
);
410 spin_lock_irqsave(&priv
->lock
, flags
);
411 count
= oti6858_buf_put(priv
->buf
, buf
, count
);
412 spin_unlock_irqrestore(&priv
->lock
, flags
);
417 static int oti6858_write_room(struct tty_struct
*tty
)
419 struct usb_serial_port
*port
= tty
->driver_data
;
420 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
424 dbg("%s(port = %d)", __func__
, port
->number
);
426 spin_lock_irqsave(&priv
->lock
, flags
);
427 room
= oti6858_buf_space_avail(priv
->buf
);
428 spin_unlock_irqrestore(&priv
->lock
, flags
);
433 static int oti6858_chars_in_buffer(struct tty_struct
*tty
)
435 struct usb_serial_port
*port
= tty
->driver_data
;
436 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
440 dbg("%s(port = %d)", __func__
, 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 tty_struct
*tty
,
450 struct usb_serial_port
*port
, 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)", __func__
, port
->number
);
462 dbg("%s(): no tty structures", __func__
);
466 spin_lock_irqsave(&priv
->lock
, flags
);
467 if (!priv
->flags
.termios_initialized
) {
468 *(tty
->termios
) = tty_std_termios
;
469 tty
->termios
->c_cflag
= B38400
| CS8
| CREAD
| HUPCL
| CLOCAL
;
470 tty
->termios
->c_ispeed
= 38400;
471 tty
->termios
->c_ospeed
= 38400;
472 priv
->flags
.termios_initialized
= 1;
474 spin_unlock_irqrestore(&priv
->lock
, flags
);
476 cflag
= 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(tty
);
512 br
= min(br
, OTI6858_MAX_BAUD_RATE
);
514 new_divisor
= (96000000 + 8 * br
) / (16 * br
);
515 real_br
= 96000000 / (16 * new_divisor
);
516 divisor
= cpu_to_le16(new_divisor
);
517 tty_encode_baud_rate(tty
, real_br
, real_br
);
520 frame_fmt
&= ~FMT_STOP_BITS_MASK
;
521 if ((cflag
& CSTOPB
) != 0)
522 frame_fmt
|= FMT_STOP_BITS_2
;
524 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
;
533 frame_fmt
|= FMT_PARITY_NONE
;
536 control
&= ~CONTROL_MASK
;
537 if ((cflag
& CRTSCTS
) != 0)
538 control
|= (CONTROL_DTR_HIGH
| CONTROL_RTS_HIGH
);
540 /* change control lines if we are switching to or from B0 */
542 spin_lock_irqsave(&priv->lock, flags);
543 control = priv->line_control;
544 if ((cflag & CBAUD) == B0)
545 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
547 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
548 if (control != priv->line_control) {
549 control = priv->line_control;
550 spin_unlock_irqrestore(&priv->lock, flags);
551 set_control_lines(serial->dev, control);
553 spin_unlock_irqrestore(&priv->lock, flags);
557 spin_lock_irqsave(&priv
->lock
, flags
);
558 if (divisor
!= priv
->pending_setup
.divisor
559 || control
!= priv
->pending_setup
.control
560 || frame_fmt
!= priv
->pending_setup
.frame_fmt
) {
561 priv
->pending_setup
.divisor
= divisor
;
562 priv
->pending_setup
.control
= control
;
563 priv
->pending_setup
.frame_fmt
= frame_fmt
;
565 spin_unlock_irqrestore(&priv
->lock
, flags
);
568 static int oti6858_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
570 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
571 struct ktermios tmp_termios
;
572 struct usb_serial
*serial
= port
->serial
;
573 struct oti6858_control_pkt
*buf
;
577 dbg("%s(port = %d)", __func__
, port
->number
);
579 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
580 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
582 if (port
->port
.count
!= 1)
585 buf
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
587 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
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", __func__
);
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", __func__
, result
);
628 oti6858_set_termios(tty
, port
, &tmp_termios
);
629 port
->port
.drain_delay
= 256; /* FIXME: check the FIFO length */
633 static void oti6858_close(struct usb_serial_port
*port
)
635 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
638 dbg("%s(port = %d)", __func__
, port
->number
);
640 spin_lock_irqsave(&priv
->lock
, flags
);
641 /* clear out any remaining data in the buffer */
642 oti6858_buf_clear(priv
->buf
);
643 spin_unlock_irqrestore(&priv
->lock
, flags
);
645 dbg("%s(): after buf_clear()", __func__
);
647 /* cancel scheduled setup */
648 cancel_delayed_work(&priv
->delayed_setup_work
);
649 cancel_delayed_work(&priv
->delayed_write_work
);
650 flush_scheduled_work();
652 /* shutdown our urbs */
653 dbg("%s(): shutting down urbs", __func__
);
654 usb_kill_urb(port
->write_urb
);
655 usb_kill_urb(port
->read_urb
);
656 usb_kill_urb(port
->interrupt_in_urb
);
659 static int oti6858_tiocmset(struct tty_struct
*tty
, struct file
*file
,
660 unsigned int set
, unsigned int clear
)
662 struct usb_serial_port
*port
= tty
->driver_data
;
663 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
667 dbg("%s(port = %d, set = 0x%08x, clear = 0x%08x)",
668 __func__
, port
->number
, set
, clear
);
670 if (!usb_get_intfdata(port
->serial
->interface
))
673 /* FIXME: check if this is correct (active high/low) */
674 spin_lock_irqsave(&priv
->lock
, flags
);
675 control
= priv
->pending_setup
.control
;
676 if ((set
& TIOCM_RTS
) != 0)
677 control
|= CONTROL_RTS_HIGH
;
678 if ((set
& TIOCM_DTR
) != 0)
679 control
|= CONTROL_DTR_HIGH
;
680 if ((clear
& TIOCM_RTS
) != 0)
681 control
&= ~CONTROL_RTS_HIGH
;
682 if ((clear
& TIOCM_DTR
) != 0)
683 control
&= ~CONTROL_DTR_HIGH
;
685 if (control
!= priv
->pending_setup
.control
)
686 priv
->pending_setup
.control
= control
;
688 spin_unlock_irqrestore(&priv
->lock
, flags
);
692 static int oti6858_tiocmget(struct tty_struct
*tty
, struct file
*file
)
694 struct usb_serial_port
*port
= tty
->driver_data
;
695 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
700 dbg("%s(port = %d)", __func__
, port
->number
);
702 if (!usb_get_intfdata(port
->serial
->interface
))
705 spin_lock_irqsave(&priv
->lock
, flags
);
706 pin_state
= priv
->status
.pin_state
& PIN_MASK
;
707 spin_unlock_irqrestore(&priv
->lock
, flags
);
709 /* FIXME: check if this is correct (active high/low) */
710 if ((pin_state
& PIN_RTS
) != 0)
712 if ((pin_state
& PIN_CTS
) != 0)
714 if ((pin_state
& PIN_DSR
) != 0)
716 if ((pin_state
& PIN_DTR
) != 0)
718 if ((pin_state
& PIN_RI
) != 0)
720 if ((pin_state
& PIN_DCD
) != 0)
723 dbg("%s() = 0x%08x", __func__
, result
);
728 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
730 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
732 unsigned int prev
, status
;
733 unsigned int changed
;
735 spin_lock_irqsave(&priv
->lock
, flags
);
736 prev
= priv
->status
.pin_state
;
737 spin_unlock_irqrestore(&priv
->lock
, flags
);
740 wait_event_interruptible(priv
->intr_wait
,
741 priv
->status
.pin_state
!= prev
);
742 if (signal_pending(current
))
745 spin_lock_irqsave(&priv
->lock
, flags
);
746 status
= priv
->status
.pin_state
& PIN_MASK
;
747 spin_unlock_irqrestore(&priv
->lock
, flags
);
749 changed
= prev
^ status
;
750 /* FIXME: check if this is correct (active high/low) */
751 if (((arg
& TIOCM_RNG
) && (changed
& PIN_RI
)) ||
752 ((arg
& TIOCM_DSR
) && (changed
& PIN_DSR
)) ||
753 ((arg
& TIOCM_CD
) && (changed
& PIN_DCD
)) ||
754 ((arg
& TIOCM_CTS
) && (changed
& PIN_CTS
)))
763 static int oti6858_ioctl(struct tty_struct
*tty
, struct file
*file
,
764 unsigned int cmd
, unsigned long arg
)
766 struct usb_serial_port
*port
= tty
->driver_data
;
768 dbg("%s(port = %d, cmd = 0x%04x, arg = 0x%08lx)",
769 __func__
, port
->number
, cmd
, arg
);
773 dbg("%s(): TIOCMIWAIT", __func__
);
774 return wait_modem_info(port
, arg
);
776 dbg("%s(): 0x%04x not supported", __func__
, cmd
);
783 static void oti6858_release(struct usb_serial
*serial
)
785 struct oti6858_private
*priv
;
788 dbg("%s()", __func__
);
790 for (i
= 0; i
< serial
->num_ports
; ++i
) {
791 priv
= usb_get_serial_port_data(serial
->port
[i
]);
793 oti6858_buf_free(priv
->buf
);
799 static void oti6858_read_int_callback(struct urb
*urb
)
801 struct usb_serial_port
*port
= urb
->context
;
802 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
803 int transient
= 0, can_recv
= 0, resubmit
= 1;
804 int status
= urb
->status
;
806 dbg("%s(port = %d, status = %d)",
807 __func__
, port
->number
, status
);
816 /* this urb is terminated, clean up */
817 dbg("%s(): urb shutting down with status: %d",
821 dbg("%s(): nonzero urb status received: %d",
826 if (status
== 0 && urb
->actual_length
== OTI6858_CTRL_PKT_SIZE
) {
827 struct oti6858_control_pkt
*xs
= urb
->transfer_buffer
;
830 spin_lock_irqsave(&priv
->lock
, flags
);
832 if (!priv
->transient
) {
833 if (!OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
834 if (xs
->rx_bytes_avail
== 0) {
836 priv
->setup_done
= 0;
838 dbg("%s(): scheduling setup_line()",
840 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
844 if (OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
846 } else if (!priv
->setup_done
) {
848 } else if (--priv
->transient
== 0) {
849 if (xs
->rx_bytes_avail
== 0) {
851 priv
->setup_done
= 0;
853 dbg("%s(): scheduling setup_line()",
855 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
860 if (!priv
->transient
) {
861 if (xs
->pin_state
!= priv
->status
.pin_state
)
862 wake_up_interruptible(&priv
->intr_wait
);
863 memcpy(&priv
->status
, xs
, OTI6858_CTRL_PKT_SIZE
);
866 if (!priv
->transient
&& xs
->rx_bytes_avail
!= 0) {
867 can_recv
= xs
->rx_bytes_avail
;
868 priv
->flags
.read_urb_in_use
= 1;
871 transient
= priv
->transient
;
872 spin_unlock_irqrestore(&priv
->lock
, flags
);
878 port
->read_urb
->dev
= port
->serial
->dev
;
879 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
881 priv
->flags
.read_urb_in_use
= 0;
882 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
883 " error %d\n", __func__
, result
);
887 } else if (!transient
) {
890 spin_lock_irqsave(&priv
->lock
, flags
);
891 if (priv
->flags
.write_urb_in_use
== 0
892 && oti6858_buf_data_avail(priv
->buf
) != 0) {
893 schedule_delayed_work(&priv
->delayed_write_work
, 0);
896 spin_unlock_irqrestore(&priv
->lock
, flags
);
902 /* dbg("%s(): submitting interrupt urb", __func__); */
903 urb
->dev
= port
->serial
->dev
;
904 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
906 dev_err(&urb
->dev
->dev
,
907 "%s(): usb_submit_urb() failed with"
908 " error %d\n", __func__
, result
);
913 static void oti6858_read_bulk_callback(struct urb
*urb
)
915 struct usb_serial_port
*port
= urb
->context
;
916 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
917 struct tty_struct
*tty
;
918 unsigned char *data
= urb
->transfer_buffer
;
920 int status
= urb
->status
;
923 dbg("%s(port = %d, status = %d)",
924 __func__
, port
->number
, status
);
926 spin_lock_irqsave(&priv
->lock
, flags
);
927 priv
->flags
.read_urb_in_use
= 0;
928 spin_unlock_irqrestore(&priv
->lock
, flags
);
931 if (!port
->port
.count
) {
932 dbg("%s(): port is closed, exiting", __func__
);
936 if (status == -EPROTO) {
937 * PL2303 mysteriously fails with -EPROTO reschedule
939 dbg("%s - caught -EPROTO, resubmitting the urb",
941 result = usb_submit_urb(urb, GFP_ATOMIC);
943 dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __func__, result);
947 dbg("%s(): unable to handle the error, exiting", __func__
);
951 tty
= tty_port_tty_get(&port
->port
);
952 if (tty
!= NULL
&& urb
->actual_length
> 0) {
953 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
954 tty_flip_buffer_push(tty
);
958 /* schedule the interrupt urb if we are still open */
959 if (port
->port
.count
!= 0) {
960 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
961 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
963 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
964 " error %d\n", __func__
, result
);
969 static void oti6858_write_bulk_callback(struct urb
*urb
)
971 struct usb_serial_port
*port
= urb
->context
;
972 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
973 int status
= urb
->status
;
976 dbg("%s(port = %d, status = %d)",
977 __func__
, port
->number
, status
);
986 /* this urb is terminated, clean up */
987 dbg("%s(): urb shutting down with status: %d",
989 priv
->flags
.write_urb_in_use
= 0;
992 /* error in the urb, so we have to resubmit it */
993 dbg("%s(): nonzero write bulk status received: %d",
995 dbg("%s(): overflow in write", __func__
);
997 port
->write_urb
->transfer_buffer_length
= 1;
998 port
->write_urb
->dev
= port
->serial
->dev
;
999 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
1001 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
1002 " error %d\n", __func__
, result
);
1008 priv
->flags
.write_urb_in_use
= 0;
1010 /* schedule the interrupt urb if we are still open */
1011 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1012 dbg("%s(): submitting interrupt urb", __func__
);
1013 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1015 dev_err(&port
->dev
, "%s(): failed submitting int urb,"
1016 " error %d\n", __func__
, result
);
1024 * Allocate a circular buffer and all associated memory.
1026 static struct oti6858_buf
*oti6858_buf_alloc(unsigned int size
)
1028 struct oti6858_buf
*pb
;
1033 pb
= kmalloc(sizeof(struct oti6858_buf
), GFP_KERNEL
);
1037 pb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
1038 if (pb
->buf_buf
== NULL
) {
1043 pb
->buf_size
= size
;
1044 pb
->buf_get
= pb
->buf_put
= pb
->buf_buf
;
1052 * Free the buffer and all associated memory.
1054 static void oti6858_buf_free(struct oti6858_buf
*pb
)
1065 * Clear out all data in the circular buffer.
1067 static void oti6858_buf_clear(struct oti6858_buf
*pb
)
1070 /* equivalent to a get of all data available */
1071 pb
->buf_get
= pb
->buf_put
;
1076 * oti6858_buf_data_avail
1078 * Return the number of bytes of data available in the circular
1081 static unsigned int oti6858_buf_data_avail(struct oti6858_buf
*pb
)
1085 return (pb
->buf_size
+ pb
->buf_put
- pb
->buf_get
) % pb
->buf_size
;
1089 * oti6858_buf_space_avail
1091 * Return the number of bytes of space available in the circular
1094 static unsigned int oti6858_buf_space_avail(struct oti6858_buf
*pb
)
1098 return (pb
->buf_size
+ pb
->buf_get
- pb
->buf_put
- 1) % pb
->buf_size
;
1104 * Copy data data from a user buffer and put it into the circular buffer.
1105 * Restrict to the amount of space available.
1107 * Return the number of bytes copied.
1109 static unsigned int oti6858_buf_put(struct oti6858_buf
*pb
, const char *buf
,
1117 len
= oti6858_buf_space_avail(pb
);
1124 len
= pb
->buf_buf
+ pb
->buf_size
- pb
->buf_put
;
1126 memcpy(pb
->buf_put
, buf
, len
);
1127 memcpy(pb
->buf_buf
, buf
+len
, count
- len
);
1128 pb
->buf_put
= pb
->buf_buf
+ count
- len
;
1130 memcpy(pb
->buf_put
, buf
, count
);
1132 pb
->buf_put
+= count
;
1133 else /* count == len */
1134 pb
->buf_put
= pb
->buf_buf
;
1143 * Get data from the circular buffer and copy to the given buffer.
1144 * Restrict to the amount of data available.
1146 * Return the number of bytes copied.
1148 static unsigned int oti6858_buf_get(struct oti6858_buf
*pb
, char *buf
,
1156 len
= oti6858_buf_data_avail(pb
);
1163 len
= pb
->buf_buf
+ pb
->buf_size
- pb
->buf_get
;
1165 memcpy(buf
, pb
->buf_get
, len
);
1166 memcpy(buf
+len
, pb
->buf_buf
, count
- len
);
1167 pb
->buf_get
= pb
->buf_buf
+ count
- len
;
1169 memcpy(buf
, pb
->buf_get
, count
);
1171 pb
->buf_get
+= count
;
1172 else /* count == len */
1173 pb
->buf_get
= pb
->buf_buf
;
1179 /* module description and (de)initialization */
1181 static int __init
oti6858_init(void)
1185 retval
= usb_serial_register(&oti6858_device
);
1187 retval
= usb_register(&oti6858_driver
);
1189 usb_serial_deregister(&oti6858_device
);
1194 static void __exit
oti6858_exit(void)
1196 usb_deregister(&oti6858_driver
);
1197 usb_serial_deregister(&oti6858_device
);
1200 module_init(oti6858_init
);
1201 module_exit(oti6858_exit
);
1203 MODULE_DESCRIPTION(OTI6858_DESCRIPTION
);
1204 MODULE_AUTHOR(OTI6858_AUTHOR
);
1205 MODULE_VERSION(OTI6858_VERSION
);
1206 MODULE_LICENSE("GPL");
1208 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1209 MODULE_PARM_DESC(debug
, "enable debug output");