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
18 #include <linux/kernel.h>
19 #include <linux/errno.h>
20 #include <linux/init.h>
21 #include <linux/slab.h>
22 #include <linux/tty.h>
23 #include <linux/tty_driver.h>
24 #include <linux/tty_flip.h>
25 #include <linux/serial.h>
26 #include <linux/module.h>
27 #include <linux/moduleparam.h>
28 #include <linux/spinlock.h>
29 #include <linux/uaccess.h>
30 #include <linux/usb.h>
31 #include <linux/usb/serial.h>
37 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
41 #define PL2303_CLOSING_WAIT (30*HZ)
43 #define PL2303_BUF_SIZE 1024
44 #define PL2303_TMP_BUF_SIZE 1024
47 unsigned int buf_size;
53 static struct usb_device_id id_table [] = {
54 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
55 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
56 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
57 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
58 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
59 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
60 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
61 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
62 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
63 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
64 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
65 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
66 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
67 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
68 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
69 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
70 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
71 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
72 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
73 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
74 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
75 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
76 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
77 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
78 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
79 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
80 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
81 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
82 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
83 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
84 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
85 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
86 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
87 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
88 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
89 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
90 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
91 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
92 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
93 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
94 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
95 { } /* Terminating entry */
98 MODULE_DEVICE_TABLE(usb, id_table);
100 static struct usb_driver pl2303_driver = {
102 .probe = usb_serial_probe,
103 .disconnect = usb_serial_disconnect,
104 .id_table = id_table,
105 .suspend = usb_serial_suspend,
106 .resume = usb_serial_resume,
108 .supports_autosuspend = 1,
111 #define SET_LINE_REQUEST_TYPE 0x21
112 #define SET_LINE_REQUEST 0x20
114 #define SET_CONTROL_REQUEST_TYPE 0x21
115 #define SET_CONTROL_REQUEST 0x22
116 #define CONTROL_DTR 0x01
117 #define CONTROL_RTS 0x02
119 #define BREAK_REQUEST_TYPE 0x21
120 #define BREAK_REQUEST 0x23
121 #define BREAK_ON 0xffff
122 #define BREAK_OFF 0x0000
124 #define GET_LINE_REQUEST_TYPE 0xa1
125 #define GET_LINE_REQUEST 0x21
127 #define VENDOR_WRITE_REQUEST_TYPE 0x40
128 #define VENDOR_WRITE_REQUEST 0x01
130 #define VENDOR_READ_REQUEST_TYPE 0xc0
131 #define VENDOR_READ_REQUEST 0x01
133 #define UART_STATE 0x08
134 #define UART_STATE_TRANSIENT_MASK 0x74
135 #define UART_DCD 0x01
136 #define UART_DSR 0x02
137 #define UART_BREAK_ERROR 0x04
138 #define UART_RING 0x08
139 #define UART_FRAME_ERROR 0x10
140 #define UART_PARITY_ERROR 0x20
141 #define UART_OVERRUN_ERROR 0x40
142 #define UART_CTS 0x80
146 type_0, /* don't know the difference between type 0 and */
147 type_1, /* type 1, until someone from prolific tells us... */
148 HX, /* HX version of the pl2303 chip */
151 struct pl2303_private {
153 struct pl2303_buf *buf;
154 int write_urb_in_use;
155 wait_queue_head_t delta_msr_wait;
158 enum pl2303_type type;
164 * Allocate a circular buffer and all associated memory.
166 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
168 struct pl2303_buf *pb;
173 pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
177 pb->buf_buf = kmalloc(size, GFP_KERNEL);
178 if (pb->buf_buf == NULL) {
184 pb->buf_get = pb->buf_put = pb->buf_buf;
192 * Free the buffer and all associated memory.
194 static void pl2303_buf_free(struct pl2303_buf *pb)
205 * Clear out all data in the circular buffer.
207 static void pl2303_buf_clear(struct pl2303_buf *pb)
210 pb->buf_get = pb->buf_put;
211 /* equivalent to a get of all data available */
215 * pl2303_buf_data_avail
217 * Return the number of bytes of data available in the circular
220 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
225 return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size;
229 * pl2303_buf_space_avail
231 * Return the number of bytes of space available in the circular
234 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
239 return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size;
245 * Copy data data from a user buffer and put it into the circular buffer.
246 * Restrict to the amount of space available.
248 * Return the number of bytes copied.
250 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
258 len = pl2303_buf_space_avail(pb);
265 len = pb->buf_buf + pb->buf_size - pb->buf_put;
267 memcpy(pb->buf_put, buf, len);
268 memcpy(pb->buf_buf, buf+len, count - len);
269 pb->buf_put = pb->buf_buf + count - len;
271 memcpy(pb->buf_put, buf, count);
273 pb->buf_put += count;
274 else /* count == len */
275 pb->buf_put = pb->buf_buf;
284 * Get data from the circular buffer and copy to the given buffer.
285 * Restrict to the amount of data available.
287 * Return the number of bytes copied.
289 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
297 len = pl2303_buf_data_avail(pb);
304 len = pb->buf_buf + pb->buf_size - pb->buf_get;
306 memcpy(buf, pb->buf_get, len);
307 memcpy(buf+len, pb->buf_buf, count - len);
308 pb->buf_get = pb->buf_buf + count - len;
310 memcpy(buf, pb->buf_get, count);
312 pb->buf_get += count;
313 else /* count == len */
314 pb->buf_get = pb->buf_buf;
320 static int pl2303_vendor_read(__u16 value, __u16 index,
321 struct usb_serial *serial, unsigned char *buf)
323 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
324 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
325 value, index, buf, 1, 100);
326 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
327 VENDOR_READ_REQUEST, value, index, res, buf[0]);
331 static int pl2303_vendor_write(__u16 value, __u16 index,
332 struct usb_serial *serial)
334 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
335 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
336 value, index, NULL, 0, 100);
337 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
338 VENDOR_WRITE_REQUEST, value, index, res);
342 static int pl2303_startup(struct usb_serial *serial)
344 struct pl2303_private *priv;
345 enum pl2303_type type = type_0;
349 buf = kmalloc(10, GFP_KERNEL);
353 if (serial->dev->descriptor.bDeviceClass == 0x02)
355 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
357 else if (serial->dev->descriptor.bDeviceClass == 0x00)
359 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
361 dbg("device type: %d", type);
363 for (i = 0; i < serial->num_ports; ++i) {
364 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
367 spin_lock_init(&priv->lock);
368 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
369 if (priv->buf == NULL) {
373 init_waitqueue_head(&priv->delta_msr_wait);
375 usb_set_serial_port_data(serial->port[i], priv);
378 pl2303_vendor_read(0x8484, 0, serial, buf);
379 pl2303_vendor_write(0x0404, 0, serial);
380 pl2303_vendor_read(0x8484, 0, serial, buf);
381 pl2303_vendor_read(0x8383, 0, serial, buf);
382 pl2303_vendor_read(0x8484, 0, serial, buf);
383 pl2303_vendor_write(0x0404, 1, serial);
384 pl2303_vendor_read(0x8484, 0, serial, buf);
385 pl2303_vendor_read(0x8383, 0, serial, buf);
386 pl2303_vendor_write(0, 1, serial);
387 pl2303_vendor_write(1, 0, serial);
389 pl2303_vendor_write(2, 0x44, serial);
391 pl2303_vendor_write(2, 0x24, serial);
398 for (--i; i >= 0; --i) {
399 priv = usb_get_serial_port_data(serial->port[i]);
400 pl2303_buf_free(priv->buf);
402 usb_set_serial_port_data(serial->port[i], NULL);
407 static int set_control_lines(struct usb_device *dev, u8 value)
411 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
412 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
413 value, 0, NULL, 0, 100);
414 dbg("%s - value = %d, retval = %d", __func__, value, retval);
418 static void pl2303_send(struct usb_serial_port *port)
421 struct pl2303_private *priv = usb_get_serial_port_data(port);
424 dbg("%s - port %d", __func__, port->number);
426 spin_lock_irqsave(&priv->lock, flags);
428 if (priv->write_urb_in_use) {
429 spin_unlock_irqrestore(&priv->lock, flags);
433 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
434 port->bulk_out_size);
437 spin_unlock_irqrestore(&priv->lock, flags);
441 priv->write_urb_in_use = 1;
443 spin_unlock_irqrestore(&priv->lock, flags);
445 usb_serial_debug_data(debug, &port->dev, __func__, count,
446 port->write_urb->transfer_buffer);
448 port->write_urb->transfer_buffer_length = count;
449 port->write_urb->dev = port->serial->dev;
450 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
452 dev_err(&port->dev, "%s - failed submitting write urb,"
453 " error %d\n", __func__, result);
454 priv->write_urb_in_use = 0;
455 /* TODO: reschedule pl2303_send */
458 usb_serial_port_softint(port);
461 static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port,
462 const unsigned char *buf, int count)
464 struct pl2303_private *priv = usb_get_serial_port_data(port);
467 dbg("%s - port %d, %d bytes", __func__, port->number, count);
472 spin_lock_irqsave(&priv->lock, flags);
473 count = pl2303_buf_put(priv->buf, buf, count);
474 spin_unlock_irqrestore(&priv->lock, flags);
481 static int pl2303_write_room(struct tty_struct *tty)
483 struct usb_serial_port *port = tty->driver_data;
484 struct pl2303_private *priv = usb_get_serial_port_data(port);
488 dbg("%s - port %d", __func__, port->number);
490 spin_lock_irqsave(&priv->lock, flags);
491 room = pl2303_buf_space_avail(priv->buf);
492 spin_unlock_irqrestore(&priv->lock, flags);
494 dbg("%s - returns %d", __func__, room);
498 static int pl2303_chars_in_buffer(struct tty_struct *tty)
500 struct usb_serial_port *port = tty->driver_data;
501 struct pl2303_private *priv = usb_get_serial_port_data(port);
505 dbg("%s - port %d", __func__, port->number);
507 spin_lock_irqsave(&priv->lock, flags);
508 chars = pl2303_buf_data_avail(priv->buf);
509 spin_unlock_irqrestore(&priv->lock, flags);
511 dbg("%s - returns %d", __func__, chars);
515 static void pl2303_set_termios(struct tty_struct *tty,
516 struct usb_serial_port *port, struct ktermios *old_termios)
518 struct usb_serial *serial = port->serial;
519 struct pl2303_private *priv = usb_get_serial_port_data(port);
527 dbg("%s - port %d", __func__, port->number);
529 /* The PL2303 is reported to lose bytes if you change
530 serial settings even to the same values as before. Thus
531 we actually need to filter in this specific case */
533 if (!tty_termios_hw_change(tty->termios, old_termios))
536 cflag = tty->termios->c_cflag;
538 buf = kzalloc(7, GFP_KERNEL);
540 dev_err(&port->dev, "%s - out of memory.\n", __func__);
541 /* Report back no change occurred */
542 *tty->termios = *old_termios;
546 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
547 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
549 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
550 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
553 switch (cflag & CSIZE) {
568 dbg("%s - data bits = %d", __func__, buf[6]);
571 baud = tty_get_baud_rate(tty);
572 dbg("%s - baud = %d", __func__, baud);
574 buf[0] = baud & 0xff;
575 buf[1] = (baud >> 8) & 0xff;
576 buf[2] = (baud >> 16) & 0xff;
577 buf[3] = (baud >> 24) & 0xff;
580 /* For reference buf[4]=0 is 1 stop bits */
581 /* For reference buf[4]=1 is 1.5 stop bits */
582 /* For reference buf[4]=2 is 2 stop bits */
583 if (cflag & CSTOPB) {
585 dbg("%s - stop bits = 2", __func__);
588 dbg("%s - stop bits = 1", __func__);
591 if (cflag & PARENB) {
592 /* For reference buf[5]=0 is none parity */
593 /* For reference buf[5]=1 is odd parity */
594 /* For reference buf[5]=2 is even parity */
595 /* For reference buf[5]=3 is mark parity */
596 /* For reference buf[5]=4 is space parity */
597 if (cflag & PARODD) {
599 dbg("%s - parity = odd", __func__);
602 dbg("%s - parity = even", __func__);
606 dbg("%s - parity = none", __func__);
609 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
610 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
612 dbg("0x21:0x20:0:0 %d", i);
614 /* change control lines if we are switching to or from B0 */
615 spin_lock_irqsave(&priv->lock, flags);
616 control = priv->line_control;
617 if ((cflag & CBAUD) == B0)
618 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
620 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
621 if (control != priv->line_control) {
622 control = priv->line_control;
623 spin_unlock_irqrestore(&priv->lock, flags);
624 set_control_lines(serial->dev, control);
626 spin_unlock_irqrestore(&priv->lock, flags);
629 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
631 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
632 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
634 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
635 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
637 if (cflag & CRTSCTS) {
638 if (priv->type == HX)
639 pl2303_vendor_write(0x0, 0x61, serial);
641 pl2303_vendor_write(0x0, 0x41, serial);
643 pl2303_vendor_write(0x0, 0x0, serial);
646 /* FIXME: Need to read back resulting baud rate */
648 tty_encode_baud_rate(tty, baud, baud);
653 static void pl2303_close(struct tty_struct *tty,
654 struct usb_serial_port *port, struct file *filp)
656 struct pl2303_private *priv = usb_get_serial_port_data(port);
658 unsigned int c_cflag;
663 dbg("%s - port %d", __func__, port->number);
665 /* wait for data to drain from the buffer */
666 spin_lock_irqsave(&priv->lock, flags);
667 timeout = PL2303_CLOSING_WAIT;
668 init_waitqueue_entry(&wait, current);
669 add_wait_queue(&tty->write_wait, &wait);
671 set_current_state(TASK_INTERRUPTIBLE);
672 if (pl2303_buf_data_avail(priv->buf) == 0 ||
673 timeout == 0 || signal_pending(current) ||
674 port->serial->disconnected)
676 spin_unlock_irqrestore(&priv->lock, flags);
677 timeout = schedule_timeout(timeout);
678 spin_lock_irqsave(&priv->lock, flags);
680 set_current_state(TASK_RUNNING);
681 remove_wait_queue(&tty->write_wait, &wait);
682 /* clear out any remaining data in the buffer */
683 pl2303_buf_clear(priv->buf);
684 spin_unlock_irqrestore(&priv->lock, flags);
686 /* wait for characters to drain from the device */
687 /* (this is long enough for the entire 256 byte */
688 /* pl2303 hardware buffer to drain with no flow */
689 /* control for data rates of 1200 bps or more, */
690 /* for lower rates we should really know how much */
691 /* data is in the buffer to compute a delay */
692 /* that is not unnecessarily long) */
693 bps = tty_get_baud_rate(tty);
695 timeout = max((HZ*2560)/bps, HZ/10);
698 schedule_timeout_interruptible(timeout);
700 /* shutdown our urbs */
701 dbg("%s - shutting down urbs", __func__);
702 usb_kill_urb(port->write_urb);
703 usb_kill_urb(port->read_urb);
704 usb_kill_urb(port->interrupt_in_urb);
707 c_cflag = tty->termios->c_cflag;
708 if (c_cflag & HUPCL) {
709 /* drop DTR and RTS */
710 spin_lock_irqsave(&priv->lock, flags);
711 priv->line_control = 0;
712 spin_unlock_irqrestore(&priv->lock, flags);
713 set_control_lines(port->serial->dev, 0);
718 static int pl2303_open(struct tty_struct *tty,
719 struct usb_serial_port *port, struct file *filp)
721 struct ktermios tmp_termios;
722 struct usb_serial *serial = port->serial;
723 struct pl2303_private *priv = usb_get_serial_port_data(port);
726 dbg("%s - port %d", __func__, port->number);
728 if (priv->type != HX) {
729 usb_clear_halt(serial->dev, port->write_urb->pipe);
730 usb_clear_halt(serial->dev, port->read_urb->pipe);
732 /* reset upstream data pipes */
733 pl2303_vendor_write(8, 0, serial);
734 pl2303_vendor_write(9, 0, serial);
739 pl2303_set_termios(tty, port, &tmp_termios);
741 /* FIXME: need to assert RTS and DTR if CRTSCTS off */
743 dbg("%s - submitting read urb", __func__);
744 port->read_urb->dev = serial->dev;
745 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
747 dev_err(&port->dev, "%s - failed submitting read urb,"
748 " error %d\n", __func__, result);
749 pl2303_close(tty, port, NULL);
753 dbg("%s - submitting interrupt urb", __func__);
754 port->interrupt_in_urb->dev = serial->dev;
755 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
757 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
758 " error %d\n", __func__, result);
759 pl2303_close(tty, port, NULL);
765 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
766 unsigned int set, unsigned int clear)
768 struct usb_serial_port *port = tty->driver_data;
769 struct pl2303_private *priv = usb_get_serial_port_data(port);
773 if (!usb_get_intfdata(port->serial->interface))
776 spin_lock_irqsave(&priv->lock, flags);
778 priv->line_control |= CONTROL_RTS;
780 priv->line_control |= CONTROL_DTR;
781 if (clear & TIOCM_RTS)
782 priv->line_control &= ~CONTROL_RTS;
783 if (clear & TIOCM_DTR)
784 priv->line_control &= ~CONTROL_DTR;
785 control = priv->line_control;
786 spin_unlock_irqrestore(&priv->lock, flags);
788 return set_control_lines(port->serial->dev, control);
791 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
793 struct usb_serial_port *port = tty->driver_data;
794 struct pl2303_private *priv = usb_get_serial_port_data(port);
800 dbg("%s (%d)", __func__, port->number);
802 if (!usb_get_intfdata(port->serial->interface))
805 spin_lock_irqsave(&priv->lock, flags);
806 mcr = priv->line_control;
807 status = priv->line_status;
808 spin_unlock_irqrestore(&priv->lock, flags);
810 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
811 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
812 | ((status & UART_CTS) ? TIOCM_CTS : 0)
813 | ((status & UART_DSR) ? TIOCM_DSR : 0)
814 | ((status & UART_RING) ? TIOCM_RI : 0)
815 | ((status & UART_DCD) ? TIOCM_CD : 0);
817 dbg("%s - result = %x", __func__, result);
822 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
824 struct pl2303_private *priv = usb_get_serial_port_data(port);
826 unsigned int prevstatus;
828 unsigned int changed;
830 spin_lock_irqsave(&priv->lock, flags);
831 prevstatus = priv->line_status;
832 spin_unlock_irqrestore(&priv->lock, flags);
835 interruptible_sleep_on(&priv->delta_msr_wait);
836 /* see if a signal did it */
837 if (signal_pending(current))
840 spin_lock_irqsave(&priv->lock, flags);
841 status = priv->line_status;
842 spin_unlock_irqrestore(&priv->lock, flags);
844 changed = prevstatus ^ status;
846 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
847 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
848 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
849 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
858 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
859 unsigned int cmd, unsigned long arg)
861 struct usb_serial_port *port = tty->driver_data;
862 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
866 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
867 return wait_modem_info(port, arg);
869 dbg("%s not supported = 0x%04x", __func__, cmd);
875 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
877 struct usb_serial_port *port = tty->driver_data;
878 struct usb_serial *serial = port->serial;
882 dbg("%s - port %d", __func__, port->number);
884 if (break_state == 0)
888 dbg("%s - turning break %s", __func__,
889 state == BREAK_OFF ? "off" : "on");
891 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
892 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
895 dbg("%s - error sending break = %d", __func__, result);
898 static void pl2303_shutdown(struct usb_serial *serial)
901 struct pl2303_private *priv;
905 for (i = 0; i < serial->num_ports; ++i) {
906 priv = usb_get_serial_port_data(serial->port[i]);
908 pl2303_buf_free(priv->buf);
910 usb_set_serial_port_data(serial->port[i], NULL);
915 static void pl2303_update_line_status(struct usb_serial_port *port,
917 unsigned int actual_length)
920 struct pl2303_private *priv = usb_get_serial_port_data(port);
922 u8 status_idx = UART_STATE;
923 u8 length = UART_STATE + 1;
926 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
927 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
930 if (idv == SIEMENS_VENDOR_ID) {
931 if (idp == SIEMENS_PRODUCT_ID_X65 ||
932 idp == SIEMENS_PRODUCT_ID_SX1 ||
933 idp == SIEMENS_PRODUCT_ID_X75) {
940 if (actual_length < length)
943 /* Save off the uart status for others to look at */
944 spin_lock_irqsave(&priv->lock, flags);
945 priv->line_status = data[status_idx];
946 spin_unlock_irqrestore(&priv->lock, flags);
947 wake_up_interruptible(&priv->delta_msr_wait);
950 static void pl2303_read_int_callback(struct urb *urb)
952 struct usb_serial_port *port = urb->context;
953 unsigned char *data = urb->transfer_buffer;
954 unsigned int actual_length = urb->actual_length;
955 int status = urb->status;
958 dbg("%s (%d)", __func__, port->number);
967 /* this urb is terminated, clean up */
968 dbg("%s - urb shutting down with status: %d", __func__,
972 dbg("%s - nonzero urb status received: %d", __func__,
977 usb_serial_debug_data(debug, &port->dev, __func__,
978 urb->actual_length, urb->transfer_buffer);
980 pl2303_update_line_status(port, data, actual_length);
983 retval = usb_submit_urb(urb, GFP_ATOMIC);
985 dev_err(&urb->dev->dev,
986 "%s - usb_submit_urb failed with result %d\n",
990 static void pl2303_read_bulk_callback(struct urb *urb)
992 struct usb_serial_port *port = urb->context;
993 struct pl2303_private *priv = usb_get_serial_port_data(port);
994 struct tty_struct *tty;
995 unsigned char *data = urb->transfer_buffer;
999 int status = urb->status;
1003 dbg("%s - port %d", __func__, port->number);
1006 dbg("%s - urb status = %d", __func__, status);
1007 if (!port->port.count) {
1008 dbg("%s - port is closed, exiting.", __func__);
1011 if (status == -EPROTO) {
1012 /* PL2303 mysteriously fails with -EPROTO reschedule
1014 dbg("%s - caught -EPROTO, resubmitting the urb",
1016 urb->dev = port->serial->dev;
1017 result = usb_submit_urb(urb, GFP_ATOMIC);
1019 dev_err(&urb->dev->dev, "%s - failed"
1020 " resubmitting read urb, error %d\n",
1024 dbg("%s - unable to handle the error, exiting.", __func__);
1028 usb_serial_debug_data(debug, &port->dev, __func__,
1029 urb->actual_length, data);
1031 /* get tty_flag from status */
1032 tty_flag = TTY_NORMAL;
1034 spin_lock_irqsave(&priv->lock, flags);
1035 line_status = priv->line_status;
1036 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1037 spin_unlock_irqrestore(&priv->lock, flags);
1038 wake_up_interruptible(&priv->delta_msr_wait);
1040 /* break takes precedence over parity, */
1041 /* which takes precedence over framing errors */
1042 if (line_status & UART_BREAK_ERROR)
1043 tty_flag = TTY_BREAK;
1044 else if (line_status & UART_PARITY_ERROR)
1045 tty_flag = TTY_PARITY;
1046 else if (line_status & UART_FRAME_ERROR)
1047 tty_flag = TTY_FRAME;
1048 dbg("%s - tty_flag = %d", __func__, tty_flag);
1050 tty = tty_port_tty_get(&port->port);
1051 if (tty && urb->actual_length) {
1052 tty_buffer_request_room(tty, urb->actual_length + 1);
1053 /* overrun is special, not associated with a char */
1054 if (line_status & UART_OVERRUN_ERROR)
1055 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1056 for (i = 0; i < urb->actual_length; ++i)
1057 tty_insert_flip_char(tty, data[i], tty_flag);
1058 tty_flip_buffer_push(tty);
1061 /* Schedule the next read _if_ we are still open */
1062 if (port->port.count) {
1063 urb->dev = port->serial->dev;
1064 result = usb_submit_urb(urb, GFP_ATOMIC);
1066 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1067 " read urb, error %d\n", __func__, result);
1073 static void pl2303_write_bulk_callback(struct urb *urb)
1075 struct usb_serial_port *port = urb->context;
1076 struct pl2303_private *priv = usb_get_serial_port_data(port);
1078 int status = urb->status;
1080 dbg("%s - port %d", __func__, port->number);
1089 /* this urb is terminated, clean up */
1090 dbg("%s - urb shutting down with status: %d", __func__,
1092 priv->write_urb_in_use = 0;
1095 /* error in the urb, so we have to resubmit it */
1096 dbg("%s - Overflow in write", __func__);
1097 dbg("%s - nonzero write bulk status received: %d", __func__,
1099 port->write_urb->transfer_buffer_length = 1;
1100 port->write_urb->dev = port->serial->dev;
1101 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1103 dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1104 " urb, error %d\n", __func__, result);
1109 priv->write_urb_in_use = 0;
1111 /* send any buffered data */
1115 /* All of the device info needed for the PL2303 SIO serial converter */
1116 static struct usb_serial_driver pl2303_device = {
1118 .owner = THIS_MODULE,
1121 .id_table = id_table,
1122 .usb_driver = &pl2303_driver,
1124 .open = pl2303_open,
1125 .close = pl2303_close,
1126 .write = pl2303_write,
1127 .ioctl = pl2303_ioctl,
1128 .break_ctl = pl2303_break_ctl,
1129 .set_termios = pl2303_set_termios,
1130 .tiocmget = pl2303_tiocmget,
1131 .tiocmset = pl2303_tiocmset,
1132 .read_bulk_callback = pl2303_read_bulk_callback,
1133 .read_int_callback = pl2303_read_int_callback,
1134 .write_bulk_callback = pl2303_write_bulk_callback,
1135 .write_room = pl2303_write_room,
1136 .chars_in_buffer = pl2303_chars_in_buffer,
1137 .attach = pl2303_startup,
1138 .shutdown = pl2303_shutdown,
1141 static int __init pl2303_init(void)
1145 retval = usb_serial_register(&pl2303_device);
1147 goto failed_usb_serial_register;
1148 retval = usb_register(&pl2303_driver);
1150 goto failed_usb_register;
1151 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1153 failed_usb_register:
1154 usb_serial_deregister(&pl2303_device);
1155 failed_usb_serial_register:
1159 static void __exit pl2303_exit(void)
1161 usb_deregister(&pl2303_driver);
1162 usb_serial_deregister(&pl2303_device);
1165 module_init(pl2303_init);
1166 module_exit(pl2303_exit);
1168 MODULE_DESCRIPTION(DRIVER_DESC);
1169 MODULE_LICENSE("GPL");
1171 module_param(debug, bool, S_IRUGO | S_IWUSR);
1172 MODULE_PARM_DESC(debug, "Debug enabled or not");