2 * Prolific PL2303 USB to serial adaptor driver
4 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2003 IBM Corp.
7 * Original driver for 2.2.x by anonymous
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
13 * See Documentation/usb/usb-serial.txt for more information on using this driver
17 #include <linux/kernel.h>
18 #include <linux/errno.h>
19 #include <linux/init.h>
20 #include <linux/slab.h>
21 #include <linux/tty.h>
22 #include <linux/tty_driver.h>
23 #include <linux/tty_flip.h>
24 #include <linux/serial.h>
25 #include <linux/module.h>
26 #include <linux/moduleparam.h>
27 #include <linux/spinlock.h>
28 #include <asm/uaccess.h>
29 #include <linux/usb.h>
30 #include <linux/usb/serial.h>
36 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
40 #define PL2303_CLOSING_WAIT (30*HZ)
42 #define PL2303_BUF_SIZE 1024
43 #define PL2303_TMP_BUF_SIZE 1024
46 unsigned int buf_size;
52 static struct usb_device_id id_table [] = {
53 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
54 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
55 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
56 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
57 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
58 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
59 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
60 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
61 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
62 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
63 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
64 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
65 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
66 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
67 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
68 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
69 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
70 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
71 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
72 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
73 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
74 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
75 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
76 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
77 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
78 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
79 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
80 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
81 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
82 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
83 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
84 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
85 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
86 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
87 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
88 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
89 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
90 { USB_DEVICE(HL340_VENDOR_ID, HL340_PRODUCT_ID) },
91 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
92 { } /* Terminating entry */
95 MODULE_DEVICE_TABLE(usb, id_table);
97 static struct usb_driver pl2303_driver = {
99 .probe = usb_serial_probe,
100 .disconnect = usb_serial_disconnect,
101 .id_table = id_table,
105 #define SET_LINE_REQUEST_TYPE 0x21
106 #define SET_LINE_REQUEST 0x20
108 #define SET_CONTROL_REQUEST_TYPE 0x21
109 #define SET_CONTROL_REQUEST 0x22
110 #define CONTROL_DTR 0x01
111 #define CONTROL_RTS 0x02
113 #define BREAK_REQUEST_TYPE 0x21
114 #define BREAK_REQUEST 0x23
115 #define BREAK_ON 0xffff
116 #define BREAK_OFF 0x0000
118 #define GET_LINE_REQUEST_TYPE 0xa1
119 #define GET_LINE_REQUEST 0x21
121 #define VENDOR_WRITE_REQUEST_TYPE 0x40
122 #define VENDOR_WRITE_REQUEST 0x01
124 #define VENDOR_READ_REQUEST_TYPE 0xc0
125 #define VENDOR_READ_REQUEST 0x01
127 #define UART_STATE 0x08
128 #define UART_STATE_TRANSIENT_MASK 0x74
129 #define UART_DCD 0x01
130 #define UART_DSR 0x02
131 #define UART_BREAK_ERROR 0x04
132 #define UART_RING 0x08
133 #define UART_FRAME_ERROR 0x10
134 #define UART_PARITY_ERROR 0x20
135 #define UART_OVERRUN_ERROR 0x40
136 #define UART_CTS 0x80
140 type_0, /* don't know the difference between type 0 and */
141 type_1, /* type 1, until someone from prolific tells us... */
142 HX, /* HX version of the pl2303 chip */
145 struct pl2303_private {
147 struct pl2303_buf *buf;
148 int write_urb_in_use;
149 wait_queue_head_t delta_msr_wait;
152 u8 termios_initialized;
153 enum pl2303_type type;
159 * Allocate a circular buffer and all associated memory.
161 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
163 struct pl2303_buf *pb;
168 pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
172 pb->buf_buf = kmalloc(size, GFP_KERNEL);
173 if (pb->buf_buf == NULL) {
179 pb->buf_get = pb->buf_put = pb->buf_buf;
187 * Free the buffer and all associated memory.
189 static void pl2303_buf_free(struct pl2303_buf *pb)
200 * Clear out all data in the circular buffer.
202 static void pl2303_buf_clear(struct pl2303_buf *pb)
205 pb->buf_get = pb->buf_put;
206 /* equivalent to a get of all data available */
210 * pl2303_buf_data_avail
212 * Return the number of bytes of data available in the circular
215 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
220 return ((pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size);
224 * pl2303_buf_space_avail
226 * Return the number of bytes of space available in the circular
229 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
234 return ((pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size);
240 * Copy data data from a user buffer and put it into the circular buffer.
241 * Restrict to the amount of space available.
243 * Return the number of bytes copied.
245 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
253 len = pl2303_buf_space_avail(pb);
260 len = pb->buf_buf + pb->buf_size - pb->buf_put;
262 memcpy(pb->buf_put, buf, len);
263 memcpy(pb->buf_buf, buf+len, count - len);
264 pb->buf_put = pb->buf_buf + count - len;
266 memcpy(pb->buf_put, buf, count);
268 pb->buf_put += count;
269 else /* count == len */
270 pb->buf_put = pb->buf_buf;
279 * Get data from the circular buffer and copy to the given buffer.
280 * Restrict to the amount of data available.
282 * Return the number of bytes copied.
284 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
292 len = pl2303_buf_data_avail(pb);
299 len = pb->buf_buf + pb->buf_size - pb->buf_get;
301 memcpy(buf, pb->buf_get, len);
302 memcpy(buf+len, pb->buf_buf, count - len);
303 pb->buf_get = pb->buf_buf + count - len;
305 memcpy(buf, pb->buf_get, count);
307 pb->buf_get += count;
308 else /* count == len */
309 pb->buf_get = pb->buf_buf;
315 static int pl2303_startup(struct usb_serial *serial)
317 struct pl2303_private *priv;
318 enum pl2303_type type = type_0;
321 if (serial->dev->descriptor.bDeviceClass == 0x02)
323 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
325 else if (serial->dev->descriptor.bDeviceClass == 0x00)
327 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
329 dbg("device type: %d", type);
331 for (i = 0; i < serial->num_ports; ++i) {
332 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
335 spin_lock_init(&priv->lock);
336 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
337 if (priv->buf == NULL) {
341 init_waitqueue_head(&priv->delta_msr_wait);
343 usb_set_serial_port_data(serial->port[i], priv);
348 for (--i; i>=0; --i) {
349 priv = usb_get_serial_port_data(serial->port[i]);
350 pl2303_buf_free(priv->buf);
352 usb_set_serial_port_data(serial->port[i], NULL);
357 static int set_control_lines(struct usb_device *dev, u8 value)
361 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
362 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
363 value, 0, NULL, 0, 100);
364 dbg("%s - value = %d, retval = %d", __FUNCTION__, value, retval);
368 static void pl2303_send(struct usb_serial_port *port)
371 struct pl2303_private *priv = usb_get_serial_port_data(port);
374 dbg("%s - port %d", __FUNCTION__, port->number);
376 spin_lock_irqsave(&priv->lock, flags);
378 if (priv->write_urb_in_use) {
379 spin_unlock_irqrestore(&priv->lock, flags);
383 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
384 port->bulk_out_size);
387 spin_unlock_irqrestore(&priv->lock, flags);
391 priv->write_urb_in_use = 1;
393 spin_unlock_irqrestore(&priv->lock, flags);
395 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count,
396 port->write_urb->transfer_buffer);
398 port->write_urb->transfer_buffer_length = count;
399 port->write_urb->dev = port->serial->dev;
400 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
402 dev_err(&port->dev, "%s - failed submitting write urb,"
403 " error %d\n", __FUNCTION__, result);
404 priv->write_urb_in_use = 0;
405 // TODO: reschedule pl2303_send
408 usb_serial_port_softint(port);
411 static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
414 struct pl2303_private *priv = usb_get_serial_port_data(port);
417 dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count);
422 spin_lock_irqsave(&priv->lock, flags);
423 count = pl2303_buf_put(priv->buf, buf, count);
424 spin_unlock_irqrestore(&priv->lock, flags);
431 static int pl2303_write_room(struct usb_serial_port *port)
433 struct pl2303_private *priv = usb_get_serial_port_data(port);
437 dbg("%s - port %d", __FUNCTION__, port->number);
439 spin_lock_irqsave(&priv->lock, flags);
440 room = pl2303_buf_space_avail(priv->buf);
441 spin_unlock_irqrestore(&priv->lock, flags);
443 dbg("%s - returns %d", __FUNCTION__, room);
447 static int pl2303_chars_in_buffer(struct usb_serial_port *port)
449 struct pl2303_private *priv = usb_get_serial_port_data(port);
453 dbg("%s - port %d", __FUNCTION__, port->number);
455 spin_lock_irqsave(&priv->lock, flags);
456 chars = pl2303_buf_data_avail(priv->buf);
457 spin_unlock_irqrestore(&priv->lock, flags);
459 dbg("%s - returns %d", __FUNCTION__, chars);
463 static void pl2303_set_termios(struct usb_serial_port *port,
464 struct ktermios *old_termios)
466 struct usb_serial *serial = port->serial;
467 struct pl2303_private *priv = usb_get_serial_port_data(port);
475 dbg("%s - port %d", __FUNCTION__, port->number);
477 spin_lock_irqsave(&priv->lock, flags);
478 if (!priv->termios_initialized) {
479 *(port->tty->termios) = tty_std_termios;
480 port->tty->termios->c_cflag = B9600 | CS8 | CREAD |
482 port->tty->termios->c_ispeed = 9600;
483 port->tty->termios->c_ospeed = 9600;
484 priv->termios_initialized = 1;
486 spin_unlock_irqrestore(&priv->lock, flags);
488 /* The PL2303 is reported to lose bytes if you change
489 serial settings even to the same values as before. Thus
490 we actually need to filter in this specific case */
492 if (!tty_termios_hw_change(port->tty->termios, old_termios))
495 cflag = port->tty->termios->c_cflag;
497 buf = kzalloc(7, GFP_KERNEL);
499 dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
503 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
504 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
506 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
507 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
510 switch (cflag & CSIZE) {
511 case CS5: buf[6] = 5; break;
512 case CS6: buf[6] = 6; break;
513 case CS7: buf[6] = 7; break;
515 case CS8: buf[6] = 8; break;
517 dbg("%s - data bits = %d", __FUNCTION__, buf[6]);
520 baud = tty_get_baud_rate(port->tty);;
521 dbg("%s - baud = %d", __FUNCTION__, baud);
523 buf[0] = baud & 0xff;
524 buf[1] = (baud >> 8) & 0xff;
525 buf[2] = (baud >> 16) & 0xff;
526 buf[3] = (baud >> 24) & 0xff;
529 /* For reference buf[4]=0 is 1 stop bits */
530 /* For reference buf[4]=1 is 1.5 stop bits */
531 /* For reference buf[4]=2 is 2 stop bits */
532 if (cflag & CSTOPB) {
534 dbg("%s - stop bits = 2", __FUNCTION__);
537 dbg("%s - stop bits = 1", __FUNCTION__);
540 if (cflag & PARENB) {
541 /* For reference buf[5]=0 is none parity */
542 /* For reference buf[5]=1 is odd parity */
543 /* For reference buf[5]=2 is even parity */
544 /* For reference buf[5]=3 is mark parity */
545 /* For reference buf[5]=4 is space parity */
546 if (cflag & PARODD) {
548 dbg("%s - parity = odd", __FUNCTION__);
551 dbg("%s - parity = even", __FUNCTION__);
555 dbg("%s - parity = none", __FUNCTION__);
558 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
559 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
561 dbg("0x21:0x20:0:0 %d", i);
563 /* change control lines if we are switching to or from B0 */
564 spin_lock_irqsave(&priv->lock, flags);
565 control = priv->line_control;
566 if ((cflag & CBAUD) == B0)
567 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
569 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
570 if (control != priv->line_control) {
571 control = priv->line_control;
572 spin_unlock_irqrestore(&priv->lock, flags);
573 set_control_lines(serial->dev, control);
575 spin_unlock_irqrestore(&priv->lock, flags);
578 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
580 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
581 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
583 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
584 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
586 if (cflag & CRTSCTS) {
588 if (priv->type == HX)
592 i = usb_control_msg(serial->dev,
593 usb_sndctrlpipe(serial->dev, 0),
594 VENDOR_WRITE_REQUEST,
595 VENDOR_WRITE_REQUEST_TYPE,
596 0x0, index, NULL, 0, 100);
597 dbg("0x40:0x1:0x0:0x%x %d", index, i);
599 i = usb_control_msg(serial->dev,
600 usb_sndctrlpipe(serial->dev, 0),
601 VENDOR_WRITE_REQUEST,
602 VENDOR_WRITE_REQUEST_TYPE,
603 0x0, 0x0, NULL, 0, 100);
604 dbg ("0x40:0x1:0x0:0x0 %d", i);
607 /* FIXME: Need to read back resulting baud rate */
609 tty_encode_baud_rate(port->tty, baud, baud);
614 static void pl2303_close(struct usb_serial_port *port, struct file *filp)
616 struct pl2303_private *priv = usb_get_serial_port_data(port);
618 unsigned int c_cflag;
623 dbg("%s - port %d", __FUNCTION__, port->number);
625 /* wait for data to drain from the buffer */
626 spin_lock_irqsave(&priv->lock, flags);
627 timeout = PL2303_CLOSING_WAIT;
628 init_waitqueue_entry(&wait, current);
629 add_wait_queue(&port->tty->write_wait, &wait);
631 set_current_state(TASK_INTERRUPTIBLE);
632 if (pl2303_buf_data_avail(priv->buf) == 0 ||
633 timeout == 0 || signal_pending(current) ||
634 !usb_get_intfdata(port->serial->interface)) /* disconnect */
636 spin_unlock_irqrestore(&priv->lock, flags);
637 timeout = schedule_timeout(timeout);
638 spin_lock_irqsave(&priv->lock, flags);
640 set_current_state(TASK_RUNNING);
641 remove_wait_queue(&port->tty->write_wait, &wait);
642 /* clear out any remaining data in the buffer */
643 pl2303_buf_clear(priv->buf);
644 spin_unlock_irqrestore(&priv->lock, flags);
646 /* wait for characters to drain from the device */
647 /* (this is long enough for the entire 256 byte */
648 /* pl2303 hardware buffer to drain with no flow */
649 /* control for data rates of 1200 bps or more, */
650 /* for lower rates we should really know how much */
651 /* data is in the buffer to compute a delay */
652 /* that is not unnecessarily long) */
653 bps = tty_get_baud_rate(port->tty);
655 timeout = max((HZ*2560)/bps,HZ/10);
658 schedule_timeout_interruptible(timeout);
660 /* shutdown our urbs */
661 dbg("%s - shutting down urbs", __FUNCTION__);
662 usb_kill_urb(port->write_urb);
663 usb_kill_urb(port->read_urb);
664 usb_kill_urb(port->interrupt_in_urb);
667 c_cflag = port->tty->termios->c_cflag;
668 if (c_cflag & HUPCL) {
669 /* drop DTR and RTS */
670 spin_lock_irqsave(&priv->lock, flags);
671 priv->line_control = 0;
672 spin_unlock_irqrestore(&priv->lock, flags);
673 set_control_lines(port->serial->dev, 0);
678 static int pl2303_open(struct usb_serial_port *port, struct file *filp)
680 struct ktermios tmp_termios;
681 struct usb_serial *serial = port->serial;
682 struct pl2303_private *priv = usb_get_serial_port_data(port);
686 dbg("%s - port %d", __FUNCTION__, port->number);
688 if (priv->type != HX) {
689 usb_clear_halt(serial->dev, port->write_urb->pipe);
690 usb_clear_halt(serial->dev, port->read_urb->pipe);
693 buf = kmalloc(10, GFP_KERNEL);
697 #define FISH(a,b,c,d) \
698 result=usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev,0), \
699 b, a, c, d, buf, 1, 100); \
700 dbg("0x%x:0x%x:0x%x:0x%x %d - %x",a,b,c,d,result,buf[0]);
702 #define SOUP(a,b,c,d) \
703 result=usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev,0), \
704 b, a, c, d, NULL, 0, 100); \
705 dbg("0x%x:0x%x:0x%x:0x%x %d",a,b,c,d,result);
707 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
708 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 0);
709 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
710 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
711 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
712 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 1);
713 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
714 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
715 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0, 1);
716 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 1, 0);
718 if (priv->type == HX) {
720 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x44);
721 /* reset upstream data pipes */
722 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 8, 0);
723 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 9, 0);
725 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x24);
732 pl2303_set_termios(port, &tmp_termios);
735 //FIXME: need to assert RTS and DTR if CRTSCTS off
737 dbg("%s - submitting read urb", __FUNCTION__);
738 port->read_urb->dev = serial->dev;
739 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
741 dev_err(&port->dev, "%s - failed submitting read urb,"
742 " error %d\n", __FUNCTION__, result);
743 pl2303_close(port, NULL);
747 dbg("%s - submitting interrupt urb", __FUNCTION__);
748 port->interrupt_in_urb->dev = serial->dev;
749 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
751 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
752 " error %d\n", __FUNCTION__, result);
753 pl2303_close(port, NULL);
759 static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
760 unsigned int set, unsigned int clear)
762 struct pl2303_private *priv = usb_get_serial_port_data(port);
766 if (!usb_get_intfdata(port->serial->interface))
769 spin_lock_irqsave(&priv->lock, flags);
771 priv->line_control |= CONTROL_RTS;
773 priv->line_control |= CONTROL_DTR;
774 if (clear & TIOCM_RTS)
775 priv->line_control &= ~CONTROL_RTS;
776 if (clear & TIOCM_DTR)
777 priv->line_control &= ~CONTROL_DTR;
778 control = priv->line_control;
779 spin_unlock_irqrestore(&priv->lock, flags);
781 return set_control_lines(port->serial->dev, control);
784 static int pl2303_tiocmget(struct usb_serial_port *port, struct file *file)
786 struct pl2303_private *priv = usb_get_serial_port_data(port);
792 dbg("%s (%d)", __FUNCTION__, port->number);
794 if (!usb_get_intfdata(port->serial->interface))
797 spin_lock_irqsave(&priv->lock, flags);
798 mcr = priv->line_control;
799 status = priv->line_status;
800 spin_unlock_irqrestore(&priv->lock, flags);
802 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
803 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
804 | ((status & UART_CTS) ? TIOCM_CTS : 0)
805 | ((status & UART_DSR) ? TIOCM_DSR : 0)
806 | ((status & UART_RING) ? TIOCM_RI : 0)
807 | ((status & UART_DCD) ? TIOCM_CD : 0);
809 dbg("%s - result = %x", __FUNCTION__, result);
814 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
816 struct pl2303_private *priv = usb_get_serial_port_data(port);
818 unsigned int prevstatus;
820 unsigned int changed;
822 spin_lock_irqsave(&priv->lock, flags);
823 prevstatus = priv->line_status;
824 spin_unlock_irqrestore(&priv->lock, flags);
827 interruptible_sleep_on(&priv->delta_msr_wait);
828 /* see if a signal did it */
829 if (signal_pending(current))
832 spin_lock_irqsave(&priv->lock, flags);
833 status = priv->line_status;
834 spin_unlock_irqrestore(&priv->lock, flags);
836 changed=prevstatus^status;
838 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
839 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
840 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
841 ((arg & TIOCM_CTS) && (changed & UART_CTS)) ) {
850 static int pl2303_ioctl(struct usb_serial_port *port, struct file *file,
851 unsigned int cmd, unsigned long arg)
853 dbg("%s (%d) cmd = 0x%04x", __FUNCTION__, port->number, cmd);
857 dbg("%s (%d) TIOCMIWAIT", __FUNCTION__, port->number);
858 return wait_modem_info(port, arg);
861 dbg("%s not supported = 0x%04x", __FUNCTION__, cmd);
868 static void pl2303_break_ctl(struct usb_serial_port *port, int break_state)
870 struct usb_serial *serial = port->serial;
874 dbg("%s - port %d", __FUNCTION__, port->number);
876 if (break_state == 0)
880 dbg("%s - turning break %s", __FUNCTION__, state==BREAK_OFF ? "off" : "on");
882 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
883 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
886 dbg("%s - error sending break = %d", __FUNCTION__, result);
889 static void pl2303_shutdown(struct usb_serial *serial)
892 struct pl2303_private *priv;
894 dbg("%s", __FUNCTION__);
896 for (i = 0; i < serial->num_ports; ++i) {
897 priv = usb_get_serial_port_data(serial->port[i]);
899 pl2303_buf_free(priv->buf);
901 usb_set_serial_port_data(serial->port[i], NULL);
906 static void pl2303_update_line_status(struct usb_serial_port *port,
908 unsigned int actual_length)
911 struct pl2303_private *priv = usb_get_serial_port_data(port);
913 u8 status_idx = UART_STATE;
914 u8 length = UART_STATE + 1;
917 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
918 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
921 if (idv == SIEMENS_VENDOR_ID) {
922 if (idp == SIEMENS_PRODUCT_ID_X65 ||
923 idp == SIEMENS_PRODUCT_ID_SX1 ||
924 idp == SIEMENS_PRODUCT_ID_X75) {
931 if (actual_length < length)
934 /* Save off the uart status for others to look at */
935 spin_lock_irqsave(&priv->lock, flags);
936 priv->line_status = data[status_idx];
937 spin_unlock_irqrestore(&priv->lock, flags);
938 wake_up_interruptible(&priv->delta_msr_wait);
941 static void pl2303_read_int_callback(struct urb *urb)
943 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
944 unsigned char *data = urb->transfer_buffer;
945 unsigned int actual_length = urb->actual_length;
946 int status = urb->status;
949 dbg("%s (%d)", __FUNCTION__, port->number);
958 /* this urb is terminated, clean up */
959 dbg("%s - urb shutting down with status: %d", __FUNCTION__,
963 dbg("%s - nonzero urb status received: %d", __FUNCTION__,
968 usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
969 urb->actual_length, urb->transfer_buffer);
971 pl2303_update_line_status(port, data, actual_length);
974 retval = usb_submit_urb(urb, GFP_ATOMIC);
976 dev_err(&urb->dev->dev,
977 "%s - usb_submit_urb failed with result %d\n",
978 __FUNCTION__, retval);
981 static void pl2303_read_bulk_callback(struct urb *urb)
983 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
984 struct pl2303_private *priv = usb_get_serial_port_data(port);
985 struct tty_struct *tty;
986 unsigned char *data = urb->transfer_buffer;
990 int status = urb->status;
994 dbg("%s - port %d", __FUNCTION__, port->number);
997 dbg("%s - urb status = %d", __FUNCTION__, status);
998 if (!port->open_count) {
999 dbg("%s - port is closed, exiting.", __FUNCTION__);
1002 if (status == -EPROTO) {
1003 /* PL2303 mysteriously fails with -EPROTO reschedule
1005 dbg("%s - caught -EPROTO, resubmitting the urb",
1007 urb->dev = port->serial->dev;
1008 result = usb_submit_urb(urb, GFP_ATOMIC);
1010 dev_err(&urb->dev->dev, "%s - failed"
1011 " resubmitting read urb, error %d\n",
1012 __FUNCTION__, result);
1015 dbg("%s - unable to handle the error, exiting.", __FUNCTION__);
1019 usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
1020 urb->actual_length, data);
1022 /* get tty_flag from status */
1023 tty_flag = TTY_NORMAL;
1025 spin_lock_irqsave(&priv->lock, flags);
1026 line_status = priv->line_status;
1027 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1028 spin_unlock_irqrestore(&priv->lock, flags);
1029 wake_up_interruptible(&priv->delta_msr_wait);
1031 /* break takes precedence over parity, */
1032 /* which takes precedence over framing errors */
1033 if (line_status & UART_BREAK_ERROR )
1034 tty_flag = TTY_BREAK;
1035 else if (line_status & UART_PARITY_ERROR)
1036 tty_flag = TTY_PARITY;
1037 else if (line_status & UART_FRAME_ERROR)
1038 tty_flag = TTY_FRAME;
1039 dbg("%s - tty_flag = %d", __FUNCTION__, tty_flag);
1042 if (tty && urb->actual_length) {
1043 tty_buffer_request_room(tty, urb->actual_length + 1);
1044 /* overrun is special, not associated with a char */
1045 if (line_status & UART_OVERRUN_ERROR)
1046 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1047 for (i = 0; i < urb->actual_length; ++i)
1048 tty_insert_flip_char(tty, data[i], tty_flag);
1049 tty_flip_buffer_push(tty);
1052 /* Schedule the next read _if_ we are still open */
1053 if (port->open_count) {
1054 urb->dev = port->serial->dev;
1055 result = usb_submit_urb(urb, GFP_ATOMIC);
1057 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1058 " read urb, error %d\n", __FUNCTION__, result);
1064 static void pl2303_write_bulk_callback(struct urb *urb)
1066 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
1067 struct pl2303_private *priv = usb_get_serial_port_data(port);
1069 int status = urb->status;
1071 dbg("%s - port %d", __FUNCTION__, port->number);
1080 /* this urb is terminated, clean up */
1081 dbg("%s - urb shutting down with status: %d", __FUNCTION__,
1083 priv->write_urb_in_use = 0;
1086 /* error in the urb, so we have to resubmit it */
1087 dbg("%s - Overflow in write", __FUNCTION__);
1088 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__,
1090 port->write_urb->transfer_buffer_length = 1;
1091 port->write_urb->dev = port->serial->dev;
1092 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1094 dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1095 " urb, error %d\n", __FUNCTION__, result);
1100 priv->write_urb_in_use = 0;
1102 /* send any buffered data */
1106 /* All of the device info needed for the PL2303 SIO serial converter */
1107 static struct usb_serial_driver pl2303_device = {
1109 .owner = THIS_MODULE,
1112 .id_table = id_table,
1113 .usb_driver = &pl2303_driver,
1114 .num_interrupt_in = NUM_DONT_CARE,
1118 .open = pl2303_open,
1119 .close = pl2303_close,
1120 .write = pl2303_write,
1121 .ioctl = pl2303_ioctl,
1122 .break_ctl = pl2303_break_ctl,
1123 .set_termios = pl2303_set_termios,
1124 .tiocmget = pl2303_tiocmget,
1125 .tiocmset = pl2303_tiocmset,
1126 .read_bulk_callback = pl2303_read_bulk_callback,
1127 .read_int_callback = pl2303_read_int_callback,
1128 .write_bulk_callback = pl2303_write_bulk_callback,
1129 .write_room = pl2303_write_room,
1130 .chars_in_buffer = pl2303_chars_in_buffer,
1131 .attach = pl2303_startup,
1132 .shutdown = pl2303_shutdown,
1135 static int __init pl2303_init(void)
1139 retval = usb_serial_register(&pl2303_device);
1141 goto failed_usb_serial_register;
1142 retval = usb_register(&pl2303_driver);
1144 goto failed_usb_register;
1147 failed_usb_register:
1148 usb_serial_deregister(&pl2303_device);
1149 failed_usb_serial_register:
1153 static void __exit pl2303_exit(void)
1155 usb_deregister(&pl2303_driver);
1156 usb_serial_deregister(&pl2303_device);
1159 module_init(pl2303_init);
1160 module_exit(pl2303_exit);
1162 MODULE_DESCRIPTION(DRIVER_DESC);
1163 MODULE_LICENSE("GPL");
1165 module_param(debug, bool, S_IRUGO | S_IWUSR);
1166 MODULE_PARM_DESC(debug, "Debug enabled or not");