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
,
145 struct usb_serial_port
*port
, struct file
*filp
);
146 static void oti6858_close(struct tty_struct
*tty
,
147 struct usb_serial_port
*port
, struct file
*filp
);
148 static void oti6858_set_termios(struct tty_struct
*tty
,
149 struct usb_serial_port
*port
, struct ktermios
*old
);
150 static int oti6858_ioctl(struct tty_struct
*tty
, struct file
*file
,
151 unsigned int cmd
, unsigned long arg
);
152 static void oti6858_read_int_callback(struct urb
*urb
);
153 static void oti6858_read_bulk_callback(struct urb
*urb
);
154 static void oti6858_write_bulk_callback(struct urb
*urb
);
155 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
156 const unsigned char *buf
, int count
);
157 static int oti6858_write_room(struct tty_struct
*tty
);
158 static int oti6858_chars_in_buffer(struct tty_struct
*tty
);
159 static int oti6858_tiocmget(struct tty_struct
*tty
, struct file
*file
);
160 static int oti6858_tiocmset(struct tty_struct
*tty
, struct file
*file
,
161 unsigned int set
, unsigned int clear
);
162 static int oti6858_startup(struct usb_serial
*serial
);
163 static void oti6858_shutdown(struct usb_serial
*serial
);
165 /* functions operating on buffers */
166 static struct oti6858_buf
*oti6858_buf_alloc(unsigned int size
);
167 static void oti6858_buf_free(struct oti6858_buf
*pb
);
168 static void oti6858_buf_clear(struct oti6858_buf
*pb
);
169 static unsigned int oti6858_buf_data_avail(struct oti6858_buf
*pb
);
170 static unsigned int oti6858_buf_space_avail(struct oti6858_buf
*pb
);
171 static unsigned int oti6858_buf_put(struct oti6858_buf
*pb
, const char *buf
,
173 static unsigned int oti6858_buf_get(struct oti6858_buf
*pb
, char *buf
,
178 static struct usb_serial_driver oti6858_device
= {
180 .owner
= THIS_MODULE
,
183 .id_table
= id_table
,
185 .open
= oti6858_open
,
186 .close
= oti6858_close
,
187 .write
= oti6858_write
,
188 .ioctl
= oti6858_ioctl
,
189 .set_termios
= oti6858_set_termios
,
190 .tiocmget
= oti6858_tiocmget
,
191 .tiocmset
= oti6858_tiocmset
,
192 .read_bulk_callback
= oti6858_read_bulk_callback
,
193 .read_int_callback
= oti6858_read_int_callback
,
194 .write_bulk_callback
= oti6858_write_bulk_callback
,
195 .write_room
= oti6858_write_room
,
196 .chars_in_buffer
= oti6858_chars_in_buffer
,
197 .attach
= oti6858_startup
,
198 .shutdown
= oti6858_shutdown
,
201 struct oti6858_private
{
204 struct oti6858_buf
*buf
;
205 struct oti6858_control_pkt status
;
210 u8 termios_initialized
;
212 struct delayed_work delayed_write_work
;
221 struct delayed_work delayed_setup_work
;
223 wait_queue_head_t intr_wait
;
224 struct usb_serial_port
*port
; /* USB port with which associated */
227 static void setup_line(struct work_struct
*work
)
229 struct oti6858_private
*priv
= container_of(work
,
230 struct oti6858_private
, delayed_setup_work
.work
);
231 struct usb_serial_port
*port
= priv
->port
;
232 struct oti6858_control_pkt
*new_setup
;
236 dbg("%s(port = %d)", __func__
, port
->number
);
238 new_setup
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
239 if (new_setup
== NULL
) {
240 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
241 /* we will try again */
242 schedule_delayed_work(&priv
->delayed_setup_work
,
243 msecs_to_jiffies(2));
247 result
= usb_control_msg(port
->serial
->dev
,
248 usb_rcvctrlpipe(port
->serial
->dev
, 0),
249 OTI6858_REQ_T_GET_STATUS
,
250 OTI6858_REQ_GET_STATUS
,
252 new_setup
, OTI6858_CTRL_PKT_SIZE
,
255 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
256 dev_err(&port
->dev
, "%s(): error reading status\n", __func__
);
258 /* we will try again */
259 schedule_delayed_work(&priv
->delayed_setup_work
,
260 msecs_to_jiffies(2));
264 spin_lock_irqsave(&priv
->lock
, flags
);
265 if (!OTI6858_CTRL_EQUALS_PENDING(new_setup
, priv
)) {
266 new_setup
->divisor
= priv
->pending_setup
.divisor
;
267 new_setup
->control
= priv
->pending_setup
.control
;
268 new_setup
->frame_fmt
= priv
->pending_setup
.frame_fmt
;
270 spin_unlock_irqrestore(&priv
->lock
, flags
);
271 result
= usb_control_msg(port
->serial
->dev
,
272 usb_sndctrlpipe(port
->serial
->dev
, 0),
273 OTI6858_REQ_T_SET_LINE
,
274 OTI6858_REQ_SET_LINE
,
276 new_setup
, OTI6858_CTRL_PKT_SIZE
,
279 spin_unlock_irqrestore(&priv
->lock
, flags
);
284 spin_lock_irqsave(&priv
->lock
, flags
);
285 if (result
!= OTI6858_CTRL_PKT_SIZE
)
287 priv
->setup_done
= 1;
288 spin_unlock_irqrestore(&priv
->lock
, flags
);
290 dbg("%s(): submitting interrupt urb", __func__
);
291 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
292 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
294 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
295 " with error %d\n", __func__
, result
);
299 void send_data(struct work_struct
*work
)
301 struct oti6858_private
*priv
= container_of(work
,
302 struct oti6858_private
, delayed_write_work
.work
);
303 struct usb_serial_port
*port
= priv
->port
;
304 int count
= 0, result
;
308 dbg("%s(port = %d)", __func__
, port
->number
);
310 spin_lock_irqsave(&priv
->lock
, flags
);
311 if (priv
->flags
.write_urb_in_use
) {
312 spin_unlock_irqrestore(&priv
->lock
, flags
);
313 schedule_delayed_work(&priv
->delayed_write_work
,
314 msecs_to_jiffies(2));
317 priv
->flags
.write_urb_in_use
= 1;
319 count
= oti6858_buf_data_avail(priv
->buf
);
320 spin_unlock_irqrestore(&priv
->lock
, flags
);
321 if (count
> port
->bulk_out_size
)
322 count
= port
->bulk_out_size
;
325 result
= usb_control_msg(port
->serial
->dev
,
326 usb_rcvctrlpipe(port
->serial
->dev
, 0),
327 OTI6858_REQ_T_CHECK_TXBUFF
,
328 OTI6858_REQ_CHECK_TXBUFF
,
329 count
, 0, &allow
, 1, 100);
330 if (result
!= 1 || allow
!= 0)
335 priv
->flags
.write_urb_in_use
= 0;
337 dbg("%s(): submitting interrupt urb", __func__
);
338 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
339 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
341 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
342 " with error %d\n", __func__
, result
);
347 spin_lock_irqsave(&priv
->lock
, flags
);
348 oti6858_buf_get(priv
->buf
, port
->write_urb
->transfer_buffer
, count
);
349 spin_unlock_irqrestore(&priv
->lock
, flags
);
351 port
->write_urb
->transfer_buffer_length
= count
;
352 port
->write_urb
->dev
= port
->serial
->dev
;
353 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
355 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
356 " with error %d\n", __func__
, result
);
357 priv
->flags
.write_urb_in_use
= 0;
360 usb_serial_port_softint(port
);
363 static int oti6858_startup(struct usb_serial
*serial
)
365 struct usb_serial_port
*port
= serial
->port
[0];
366 struct oti6858_private
*priv
;
369 for (i
= 0; i
< serial
->num_ports
; ++i
) {
370 priv
= kzalloc(sizeof(struct oti6858_private
), GFP_KERNEL
);
373 priv
->buf
= oti6858_buf_alloc(PL2303_BUF_SIZE
);
374 if (priv
->buf
== NULL
) {
379 spin_lock_init(&priv
->lock
);
380 init_waitqueue_head(&priv
->intr_wait
);
381 /* INIT_WORK(&priv->setup_work, setup_line, serial->port[i]); */
382 /* INIT_WORK(&priv->write_work, send_data, serial->port[i]); */
384 INIT_DELAYED_WORK(&priv
->delayed_setup_work
, setup_line
);
385 INIT_DELAYED_WORK(&priv
->delayed_write_work
, send_data
);
387 usb_set_serial_port_data(serial
->port
[i
], priv
);
389 if (i
== serial
->num_ports
)
392 for (--i
; i
>= 0; --i
) {
393 priv
= usb_get_serial_port_data(serial
->port
[i
]);
394 oti6858_buf_free(priv
->buf
);
396 usb_set_serial_port_data(serial
->port
[i
], NULL
);
401 static int oti6858_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
402 const unsigned char *buf
, int count
)
404 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
407 dbg("%s(port = %d, count = %d)", __func__
, port
->number
, count
);
412 spin_lock_irqsave(&priv
->lock
, flags
);
413 count
= oti6858_buf_put(priv
->buf
, buf
, count
);
414 spin_unlock_irqrestore(&priv
->lock
, flags
);
419 static int oti6858_write_room(struct tty_struct
*tty
)
421 struct usb_serial_port
*port
= tty
->driver_data
;
422 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
426 dbg("%s(port = %d)", __func__
, port
->number
);
428 spin_lock_irqsave(&priv
->lock
, flags
);
429 room
= oti6858_buf_space_avail(priv
->buf
);
430 spin_unlock_irqrestore(&priv
->lock
, flags
);
435 static int oti6858_chars_in_buffer(struct tty_struct
*tty
)
437 struct usb_serial_port
*port
= tty
->driver_data
;
438 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
442 dbg("%s(port = %d)", __func__
, port
->number
);
444 spin_lock_irqsave(&priv
->lock
, flags
);
445 chars
= oti6858_buf_data_avail(priv
->buf
);
446 spin_unlock_irqrestore(&priv
->lock
, flags
);
451 static void oti6858_set_termios(struct tty_struct
*tty
,
452 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
454 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
457 u8 frame_fmt
, control
;
461 dbg("%s(port = %d)", __func__
, port
->number
);
464 dbg("%s(): no tty structures", __func__
);
468 spin_lock_irqsave(&priv
->lock
, flags
);
469 if (!priv
->flags
.termios_initialized
) {
470 *(tty
->termios
) = tty_std_termios
;
471 tty
->termios
->c_cflag
= B38400
| CS8
| CREAD
| HUPCL
| CLOCAL
;
472 tty
->termios
->c_ispeed
= 38400;
473 tty
->termios
->c_ospeed
= 38400;
474 priv
->flags
.termios_initialized
= 1;
476 spin_unlock_irqrestore(&priv
->lock
, flags
);
478 cflag
= tty
->termios
->c_cflag
;
480 spin_lock_irqsave(&priv
->lock
, flags
);
481 divisor
= priv
->pending_setup
.divisor
;
482 frame_fmt
= priv
->pending_setup
.frame_fmt
;
483 control
= priv
->pending_setup
.control
;
484 spin_unlock_irqrestore(&priv
->lock
, flags
);
486 frame_fmt
&= ~FMT_DATA_BITS_MASK
;
487 switch (cflag
& CSIZE
) {
489 frame_fmt
|= FMT_DATA_BITS_5
;
492 frame_fmt
|= FMT_DATA_BITS_6
;
495 frame_fmt
|= FMT_DATA_BITS_7
;
499 frame_fmt
|= FMT_DATA_BITS_8
;
503 /* manufacturer claims that this device can work with baud rates
504 * up to 3 Mbps; I've tested it only on 115200 bps, so I can't
505 * guarantee that any other baud rate will work (especially
508 br
= tty_get_baud_rate(tty
);
514 br
= min(br
, OTI6858_MAX_BAUD_RATE
);
516 new_divisor
= (96000000 + 8 * br
) / (16 * br
);
517 real_br
= 96000000 / (16 * new_divisor
);
518 divisor
= cpu_to_le16(new_divisor
);
519 tty_encode_baud_rate(tty
, real_br
, real_br
);
522 frame_fmt
&= ~FMT_STOP_BITS_MASK
;
523 if ((cflag
& CSTOPB
) != 0)
524 frame_fmt
|= FMT_STOP_BITS_2
;
526 frame_fmt
|= FMT_STOP_BITS_1
;
528 frame_fmt
&= ~FMT_PARITY_MASK
;
529 if ((cflag
& PARENB
) != 0) {
530 if ((cflag
& PARODD
) != 0)
531 frame_fmt
|= FMT_PARITY_ODD
;
533 frame_fmt
|= FMT_PARITY_EVEN
;
535 frame_fmt
|= FMT_PARITY_NONE
;
538 control
&= ~CONTROL_MASK
;
539 if ((cflag
& CRTSCTS
) != 0)
540 control
|= (CONTROL_DTR_HIGH
| CONTROL_RTS_HIGH
);
542 /* change control lines if we are switching to or from B0 */
544 spin_lock_irqsave(&priv->lock, flags);
545 control = priv->line_control;
546 if ((cflag & CBAUD) == B0)
547 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
549 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
550 if (control != priv->line_control) {
551 control = priv->line_control;
552 spin_unlock_irqrestore(&priv->lock, flags);
553 set_control_lines(serial->dev, control);
555 spin_unlock_irqrestore(&priv->lock, flags);
559 spin_lock_irqsave(&priv
->lock
, flags
);
560 if (divisor
!= priv
->pending_setup
.divisor
561 || control
!= priv
->pending_setup
.control
562 || frame_fmt
!= priv
->pending_setup
.frame_fmt
) {
563 priv
->pending_setup
.divisor
= divisor
;
564 priv
->pending_setup
.control
= control
;
565 priv
->pending_setup
.frame_fmt
= frame_fmt
;
567 spin_unlock_irqrestore(&priv
->lock
, flags
);
570 static int oti6858_open(struct tty_struct
*tty
,
571 struct usb_serial_port
*port
, struct file
*filp
)
573 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
574 struct ktermios tmp_termios
;
575 struct usb_serial
*serial
= port
->serial
;
576 struct oti6858_control_pkt
*buf
;
580 dbg("%s(port = %d)", __func__
, port
->number
);
582 usb_clear_halt(serial
->dev
, port
->write_urb
->pipe
);
583 usb_clear_halt(serial
->dev
, port
->read_urb
->pipe
);
585 if (port
->port
.count
!= 1)
588 buf
= kmalloc(OTI6858_CTRL_PKT_SIZE
, GFP_KERNEL
);
590 dev_err(&port
->dev
, "%s(): out of memory!\n", __func__
);
594 result
= usb_control_msg(serial
->dev
, usb_rcvctrlpipe(serial
->dev
, 0),
595 OTI6858_REQ_T_GET_STATUS
,
596 OTI6858_REQ_GET_STATUS
,
598 buf
, OTI6858_CTRL_PKT_SIZE
,
600 if (result
!= OTI6858_CTRL_PKT_SIZE
) {
601 /* assume default (after power-on reset) values */
602 buf
->divisor
= cpu_to_le16(0x009c); /* 38400 bps */
603 buf
->frame_fmt
= 0x03; /* 8N1 */
604 buf
->something
= 0x43;
605 buf
->control
= 0x4c; /* DTR, RTS */
606 buf
->tx_status
= 0x00;
607 buf
->pin_state
= 0x5b; /* RTS, CTS, DSR, DTR, RI, DCD */
608 buf
->rx_bytes_avail
= 0x00;
611 spin_lock_irqsave(&priv
->lock
, flags
);
612 memcpy(&priv
->status
, buf
, OTI6858_CTRL_PKT_SIZE
);
613 priv
->pending_setup
.divisor
= buf
->divisor
;
614 priv
->pending_setup
.frame_fmt
= buf
->frame_fmt
;
615 priv
->pending_setup
.control
= buf
->control
;
616 spin_unlock_irqrestore(&priv
->lock
, flags
);
619 dbg("%s(): submitting interrupt urb", __func__
);
620 port
->interrupt_in_urb
->dev
= serial
->dev
;
621 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
623 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed"
624 " with error %d\n", __func__
, result
);
625 oti6858_close(tty
, port
, NULL
);
631 oti6858_set_termios(tty
, port
, &tmp_termios
);
636 static void oti6858_close(struct tty_struct
*tty
,
637 struct usb_serial_port
*port
, struct file
*filp
)
639 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
644 dbg("%s(port = %d)", __func__
, port
->number
);
646 /* wait for data to drain from the buffer */
647 spin_lock_irqsave(&priv
->lock
, flags
);
648 timeout
= 30 * HZ
; /* PL2303_CLOSING_WAIT */
649 init_waitqueue_entry(&wait
, current
);
650 add_wait_queue(&tty
->write_wait
, &wait
);
651 dbg("%s(): entering wait loop", __func__
);
653 set_current_state(TASK_INTERRUPTIBLE
);
654 if (oti6858_buf_data_avail(priv
->buf
) == 0
655 || timeout
== 0 || signal_pending(current
)
656 || port
->serial
->disconnected
)
658 spin_unlock_irqrestore(&priv
->lock
, flags
);
659 timeout
= schedule_timeout(timeout
);
660 spin_lock_irqsave(&priv
->lock
, flags
);
662 set_current_state(TASK_RUNNING
);
663 remove_wait_queue(&tty
->write_wait
, &wait
);
664 dbg("%s(): after wait loop", __func__
);
666 /* clear out any remaining data in the buffer */
667 oti6858_buf_clear(priv
->buf
);
668 spin_unlock_irqrestore(&priv
->lock
, flags
);
670 /* wait for characters to drain from the device */
671 /* (this is long enough for the entire 256 byte */
672 /* pl2303 hardware buffer to drain with no flow */
673 /* control for data rates of 1200 bps or more, */
674 /* for lower rates we should really know how much */
675 /* data is in the buffer to compute a delay */
676 /* that is not unnecessarily long) */
678 bps = tty_get_baud_rate(tty);
680 timeout = max((HZ*2560)/bps,HZ/10);
684 schedule_timeout_interruptible(timeout
);
685 dbg("%s(): after schedule_timeout_interruptible()", __func__
);
687 /* cancel scheduled setup */
688 cancel_delayed_work(&priv
->delayed_setup_work
);
689 cancel_delayed_work(&priv
->delayed_write_work
);
690 flush_scheduled_work();
692 /* shutdown our urbs */
693 dbg("%s(): shutting down urbs", __func__
);
694 usb_kill_urb(port
->write_urb
);
695 usb_kill_urb(port
->read_urb
);
696 usb_kill_urb(port
->interrupt_in_urb
);
699 if (tty && (tty->termios->c_cflag) & HUPCL) {
701 spin_lock_irqsave(&priv->lock, flags);
702 priv->pending_setup.control &= ~CONTROL_MASK;
703 spin_unlock_irqrestore(&priv->lock, flags);
708 static int oti6858_tiocmset(struct tty_struct
*tty
, struct file
*file
,
709 unsigned int set
, unsigned int clear
)
711 struct usb_serial_port
*port
= tty
->driver_data
;
712 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
716 dbg("%s(port = %d, set = 0x%08x, clear = 0x%08x)",
717 __func__
, port
->number
, set
, clear
);
719 if (!usb_get_intfdata(port
->serial
->interface
))
722 /* FIXME: check if this is correct (active high/low) */
723 spin_lock_irqsave(&priv
->lock
, flags
);
724 control
= priv
->pending_setup
.control
;
725 if ((set
& TIOCM_RTS
) != 0)
726 control
|= CONTROL_RTS_HIGH
;
727 if ((set
& TIOCM_DTR
) != 0)
728 control
|= CONTROL_DTR_HIGH
;
729 if ((clear
& TIOCM_RTS
) != 0)
730 control
&= ~CONTROL_RTS_HIGH
;
731 if ((clear
& TIOCM_DTR
) != 0)
732 control
&= ~CONTROL_DTR_HIGH
;
734 if (control
!= priv
->pending_setup
.control
)
735 priv
->pending_setup
.control
= control
;
737 spin_unlock_irqrestore(&priv
->lock
, flags
);
741 static int oti6858_tiocmget(struct tty_struct
*tty
, struct file
*file
)
743 struct usb_serial_port
*port
= tty
->driver_data
;
744 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
749 dbg("%s(port = %d)", __func__
, port
->number
);
751 if (!usb_get_intfdata(port
->serial
->interface
))
754 spin_lock_irqsave(&priv
->lock
, flags
);
755 pin_state
= priv
->status
.pin_state
& PIN_MASK
;
756 spin_unlock_irqrestore(&priv
->lock
, flags
);
758 /* FIXME: check if this is correct (active high/low) */
759 if ((pin_state
& PIN_RTS
) != 0)
761 if ((pin_state
& PIN_CTS
) != 0)
763 if ((pin_state
& PIN_DSR
) != 0)
765 if ((pin_state
& PIN_DTR
) != 0)
767 if ((pin_state
& PIN_RI
) != 0)
769 if ((pin_state
& PIN_DCD
) != 0)
772 dbg("%s() = 0x%08x", __func__
, result
);
777 static int wait_modem_info(struct usb_serial_port
*port
, unsigned int arg
)
779 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
781 unsigned int prev
, status
;
782 unsigned int changed
;
784 spin_lock_irqsave(&priv
->lock
, flags
);
785 prev
= priv
->status
.pin_state
;
786 spin_unlock_irqrestore(&priv
->lock
, flags
);
789 wait_event_interruptible(priv
->intr_wait
,
790 priv
->status
.pin_state
!= prev
);
791 if (signal_pending(current
))
794 spin_lock_irqsave(&priv
->lock
, flags
);
795 status
= priv
->status
.pin_state
& PIN_MASK
;
796 spin_unlock_irqrestore(&priv
->lock
, flags
);
798 changed
= prev
^ status
;
799 /* FIXME: check if this is correct (active high/low) */
800 if (((arg
& TIOCM_RNG
) && (changed
& PIN_RI
)) ||
801 ((arg
& TIOCM_DSR
) && (changed
& PIN_DSR
)) ||
802 ((arg
& TIOCM_CD
) && (changed
& PIN_DCD
)) ||
803 ((arg
& TIOCM_CTS
) && (changed
& PIN_CTS
)))
812 static int oti6858_ioctl(struct tty_struct
*tty
, struct file
*file
,
813 unsigned int cmd
, unsigned long arg
)
815 struct usb_serial_port
*port
= tty
->driver_data
;
817 dbg("%s(port = %d, cmd = 0x%04x, arg = 0x%08lx)",
818 __func__
, port
->number
, cmd
, arg
);
822 dbg("%s(): TIOCMIWAIT", __func__
);
823 return wait_modem_info(port
, arg
);
825 dbg("%s(): 0x%04x not supported", __func__
, cmd
);
832 static void oti6858_shutdown(struct usb_serial
*serial
)
834 struct oti6858_private
*priv
;
837 dbg("%s()", __func__
);
839 for (i
= 0; i
< serial
->num_ports
; ++i
) {
840 priv
= usb_get_serial_port_data(serial
->port
[i
]);
842 oti6858_buf_free(priv
->buf
);
844 usb_set_serial_port_data(serial
->port
[i
], NULL
);
849 static void oti6858_read_int_callback(struct urb
*urb
)
851 struct usb_serial_port
*port
= urb
->context
;
852 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
853 int transient
= 0, can_recv
= 0, resubmit
= 1;
854 int status
= urb
->status
;
856 dbg("%s(port = %d, status = %d)",
857 __func__
, port
->number
, status
);
866 /* this urb is terminated, clean up */
867 dbg("%s(): urb shutting down with status: %d",
871 dbg("%s(): nonzero urb status received: %d",
876 if (status
== 0 && urb
->actual_length
== OTI6858_CTRL_PKT_SIZE
) {
877 struct oti6858_control_pkt
*xs
= urb
->transfer_buffer
;
880 spin_lock_irqsave(&priv
->lock
, flags
);
882 if (!priv
->transient
) {
883 if (!OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
884 if (xs
->rx_bytes_avail
== 0) {
886 priv
->setup_done
= 0;
888 dbg("%s(): scheduling setup_line()",
890 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
894 if (OTI6858_CTRL_EQUALS_PENDING(xs
, priv
)) {
896 } else if (!priv
->setup_done
) {
898 } else if (--priv
->transient
== 0) {
899 if (xs
->rx_bytes_avail
== 0) {
901 priv
->setup_done
= 0;
903 dbg("%s(): scheduling setup_line()",
905 schedule_delayed_work(&priv
->delayed_setup_work
, 0);
910 if (!priv
->transient
) {
911 if (xs
->pin_state
!= priv
->status
.pin_state
)
912 wake_up_interruptible(&priv
->intr_wait
);
913 memcpy(&priv
->status
, xs
, OTI6858_CTRL_PKT_SIZE
);
916 if (!priv
->transient
&& xs
->rx_bytes_avail
!= 0) {
917 can_recv
= xs
->rx_bytes_avail
;
918 priv
->flags
.read_urb_in_use
= 1;
921 transient
= priv
->transient
;
922 spin_unlock_irqrestore(&priv
->lock
, flags
);
928 port
->read_urb
->dev
= port
->serial
->dev
;
929 result
= usb_submit_urb(port
->read_urb
, GFP_ATOMIC
);
931 priv
->flags
.read_urb_in_use
= 0;
932 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
933 " error %d\n", __func__
, result
);
937 } else if (!transient
) {
940 spin_lock_irqsave(&priv
->lock
, flags
);
941 if (priv
->flags
.write_urb_in_use
== 0
942 && oti6858_buf_data_avail(priv
->buf
) != 0) {
943 schedule_delayed_work(&priv
->delayed_write_work
, 0);
946 spin_unlock_irqrestore(&priv
->lock
, flags
);
952 /* dbg("%s(): submitting interrupt urb", __func__); */
953 urb
->dev
= port
->serial
->dev
;
954 result
= usb_submit_urb(urb
, GFP_ATOMIC
);
956 dev_err(&urb
->dev
->dev
,
957 "%s(): usb_submit_urb() failed with"
958 " error %d\n", __func__
, result
);
963 static void oti6858_read_bulk_callback(struct urb
*urb
)
965 struct usb_serial_port
*port
= urb
->context
;
966 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
967 struct tty_struct
*tty
;
968 unsigned char *data
= urb
->transfer_buffer
;
970 int status
= urb
->status
;
973 dbg("%s(port = %d, status = %d)",
974 __func__
, port
->number
, status
);
976 spin_lock_irqsave(&priv
->lock
, flags
);
977 priv
->flags
.read_urb_in_use
= 0;
978 spin_unlock_irqrestore(&priv
->lock
, flags
);
981 if (!port
->port
.count
) {
982 dbg("%s(): port is closed, exiting", __func__
);
986 if (status == -EPROTO) {
987 * PL2303 mysteriously fails with -EPROTO reschedule
989 dbg("%s - caught -EPROTO, resubmitting the urb",
991 result = usb_submit_urb(urb, GFP_ATOMIC);
993 dev_err(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n", __func__, result);
997 dbg("%s(): unable to handle the error, exiting", __func__
);
1001 tty
= tty_port_tty_get(&port
->port
);
1002 if (tty
!= NULL
&& urb
->actual_length
> 0) {
1003 tty_insert_flip_string(tty
, data
, urb
->actual_length
);
1004 tty_flip_buffer_push(tty
);
1008 /* schedule the interrupt urb if we are still open */
1009 if (port
->port
.count
!= 0) {
1010 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1011 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1013 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
1014 " error %d\n", __func__
, result
);
1019 static void oti6858_write_bulk_callback(struct urb
*urb
)
1021 struct usb_serial_port
*port
= urb
->context
;
1022 struct oti6858_private
*priv
= usb_get_serial_port_data(port
);
1023 int status
= urb
->status
;
1026 dbg("%s(port = %d, status = %d)",
1027 __func__
, port
->number
, status
);
1036 /* this urb is terminated, clean up */
1037 dbg("%s(): urb shutting down with status: %d",
1039 priv
->flags
.write_urb_in_use
= 0;
1042 /* error in the urb, so we have to resubmit it */
1043 dbg("%s(): nonzero write bulk status received: %d",
1045 dbg("%s(): overflow in write", __func__
);
1047 port
->write_urb
->transfer_buffer_length
= 1;
1048 port
->write_urb
->dev
= port
->serial
->dev
;
1049 result
= usb_submit_urb(port
->write_urb
, GFP_ATOMIC
);
1051 dev_err(&port
->dev
, "%s(): usb_submit_urb() failed,"
1052 " error %d\n", __func__
, result
);
1058 priv
->flags
.write_urb_in_use
= 0;
1060 /* schedule the interrupt urb if we are still open */
1061 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1062 dbg("%s(): submitting interrupt urb", __func__
);
1063 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1065 dev_err(&port
->dev
, "%s(): failed submitting int urb,"
1066 " error %d\n", __func__
, result
);
1074 * Allocate a circular buffer and all associated memory.
1076 static struct oti6858_buf
*oti6858_buf_alloc(unsigned int size
)
1078 struct oti6858_buf
*pb
;
1083 pb
= kmalloc(sizeof(struct oti6858_buf
), GFP_KERNEL
);
1087 pb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
1088 if (pb
->buf_buf
== NULL
) {
1093 pb
->buf_size
= size
;
1094 pb
->buf_get
= pb
->buf_put
= pb
->buf_buf
;
1102 * Free the buffer and all associated memory.
1104 static void oti6858_buf_free(struct oti6858_buf
*pb
)
1115 * Clear out all data in the circular buffer.
1117 static void oti6858_buf_clear(struct oti6858_buf
*pb
)
1120 /* equivalent to a get of all data available */
1121 pb
->buf_get
= pb
->buf_put
;
1126 * oti6858_buf_data_avail
1128 * Return the number of bytes of data available in the circular
1131 static unsigned int oti6858_buf_data_avail(struct oti6858_buf
*pb
)
1135 return (pb
->buf_size
+ pb
->buf_put
- pb
->buf_get
) % pb
->buf_size
;
1139 * oti6858_buf_space_avail
1141 * Return the number of bytes of space available in the circular
1144 static unsigned int oti6858_buf_space_avail(struct oti6858_buf
*pb
)
1148 return (pb
->buf_size
+ pb
->buf_get
- pb
->buf_put
- 1) % pb
->buf_size
;
1154 * Copy data data from a user buffer and put it into the circular buffer.
1155 * Restrict to the amount of space available.
1157 * Return the number of bytes copied.
1159 static unsigned int oti6858_buf_put(struct oti6858_buf
*pb
, const char *buf
,
1167 len
= oti6858_buf_space_avail(pb
);
1174 len
= pb
->buf_buf
+ pb
->buf_size
- pb
->buf_put
;
1176 memcpy(pb
->buf_put
, buf
, len
);
1177 memcpy(pb
->buf_buf
, buf
+len
, count
- len
);
1178 pb
->buf_put
= pb
->buf_buf
+ count
- len
;
1180 memcpy(pb
->buf_put
, buf
, count
);
1182 pb
->buf_put
+= count
;
1183 else /* count == len */
1184 pb
->buf_put
= pb
->buf_buf
;
1193 * Get data from the circular buffer and copy to the given buffer.
1194 * Restrict to the amount of data available.
1196 * Return the number of bytes copied.
1198 static unsigned int oti6858_buf_get(struct oti6858_buf
*pb
, char *buf
,
1206 len
= oti6858_buf_data_avail(pb
);
1213 len
= pb
->buf_buf
+ pb
->buf_size
- pb
->buf_get
;
1215 memcpy(buf
, pb
->buf_get
, len
);
1216 memcpy(buf
+len
, pb
->buf_buf
, count
- len
);
1217 pb
->buf_get
= pb
->buf_buf
+ count
- len
;
1219 memcpy(buf
, pb
->buf_get
, count
);
1221 pb
->buf_get
+= count
;
1222 else /* count == len */
1223 pb
->buf_get
= pb
->buf_buf
;
1229 /* module description and (de)initialization */
1231 static int __init
oti6858_init(void)
1235 retval
= usb_serial_register(&oti6858_device
);
1237 retval
= usb_register(&oti6858_driver
);
1239 usb_serial_deregister(&oti6858_device
);
1244 static void __exit
oti6858_exit(void)
1246 usb_deregister(&oti6858_driver
);
1247 usb_serial_deregister(&oti6858_device
);
1250 module_init(oti6858_init
);
1251 module_exit(oti6858_exit
);
1253 MODULE_DESCRIPTION(OTI6858_DESCRIPTION
);
1254 MODULE_AUTHOR(OTI6858_AUTHOR
);
1255 MODULE_VERSION(OTI6858_VERSION
);
1256 MODULE_LICENSE("GPL");
1258 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1259 MODULE_PARM_DESC(debug
, "enable debug output");