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_vendor_read(__u16 value, __u16 index,
316 struct usb_serial *serial, unsigned char *buf)
318 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
319 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
320 value, index, buf, 1, 100);
321 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
322 VENDOR_READ_REQUEST, value, index, res, buf[0]);
326 static int pl2303_vendor_write(__u16 value, __u16 index,
327 struct usb_serial *serial)
329 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
330 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
331 value, index, NULL, 0, 100);
332 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
333 VENDOR_WRITE_REQUEST, value, index, res);
337 static int pl2303_startup(struct usb_serial *serial)
339 struct pl2303_private *priv;
340 enum pl2303_type type = type_0;
344 buf = kmalloc(10, GFP_KERNEL);
348 if (serial->dev->descriptor.bDeviceClass == 0x02)
350 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
352 else if (serial->dev->descriptor.bDeviceClass == 0x00)
354 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
356 dbg("device type: %d", type);
358 for (i = 0; i < serial->num_ports; ++i) {
359 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
362 spin_lock_init(&priv->lock);
363 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
364 if (priv->buf == NULL) {
368 init_waitqueue_head(&priv->delta_msr_wait);
370 usb_set_serial_port_data(serial->port[i], priv);
373 pl2303_vendor_read(0x8484, 0, serial, buf);
374 pl2303_vendor_write(0x0404, 0, serial);
375 pl2303_vendor_read(0x8484, 0, serial, buf);
376 pl2303_vendor_read(0x8383, 0, serial, buf);
377 pl2303_vendor_read(0x8484, 0, serial, buf);
378 pl2303_vendor_write(0x0404, 1, serial);
379 pl2303_vendor_read(0x8484, 0, serial, buf);
380 pl2303_vendor_read(0x8383, 0, serial, buf);
381 pl2303_vendor_write(0, 1, serial);
382 pl2303_vendor_write(1, 0, serial);
384 pl2303_vendor_write(2, 0x44, serial);
386 pl2303_vendor_write(2, 0x24, serial);
393 for (--i; i>=0; --i) {
394 priv = usb_get_serial_port_data(serial->port[i]);
395 pl2303_buf_free(priv->buf);
397 usb_set_serial_port_data(serial->port[i], NULL);
402 static int set_control_lines(struct usb_device *dev, u8 value)
406 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
407 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
408 value, 0, NULL, 0, 100);
409 dbg("%s - value = %d, retval = %d", __FUNCTION__, value, retval);
413 static void pl2303_send(struct usb_serial_port *port)
416 struct pl2303_private *priv = usb_get_serial_port_data(port);
419 dbg("%s - port %d", __FUNCTION__, port->number);
421 spin_lock_irqsave(&priv->lock, flags);
423 if (priv->write_urb_in_use) {
424 spin_unlock_irqrestore(&priv->lock, flags);
428 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
429 port->bulk_out_size);
432 spin_unlock_irqrestore(&priv->lock, flags);
436 priv->write_urb_in_use = 1;
438 spin_unlock_irqrestore(&priv->lock, flags);
440 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count,
441 port->write_urb->transfer_buffer);
443 port->write_urb->transfer_buffer_length = count;
444 port->write_urb->dev = port->serial->dev;
445 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
447 dev_err(&port->dev, "%s - failed submitting write urb,"
448 " error %d\n", __FUNCTION__, result);
449 priv->write_urb_in_use = 0;
450 // TODO: reschedule pl2303_send
453 usb_serial_port_softint(port);
456 static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
459 struct pl2303_private *priv = usb_get_serial_port_data(port);
462 dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count);
467 spin_lock_irqsave(&priv->lock, flags);
468 count = pl2303_buf_put(priv->buf, buf, count);
469 spin_unlock_irqrestore(&priv->lock, flags);
476 static int pl2303_write_room(struct usb_serial_port *port)
478 struct pl2303_private *priv = usb_get_serial_port_data(port);
482 dbg("%s - port %d", __FUNCTION__, port->number);
484 spin_lock_irqsave(&priv->lock, flags);
485 room = pl2303_buf_space_avail(priv->buf);
486 spin_unlock_irqrestore(&priv->lock, flags);
488 dbg("%s - returns %d", __FUNCTION__, room);
492 static int pl2303_chars_in_buffer(struct usb_serial_port *port)
494 struct pl2303_private *priv = usb_get_serial_port_data(port);
498 dbg("%s - port %d", __FUNCTION__, port->number);
500 spin_lock_irqsave(&priv->lock, flags);
501 chars = pl2303_buf_data_avail(priv->buf);
502 spin_unlock_irqrestore(&priv->lock, flags);
504 dbg("%s - returns %d", __FUNCTION__, chars);
508 static void pl2303_set_termios(struct usb_serial_port *port,
509 struct ktermios *old_termios)
511 struct usb_serial *serial = port->serial;
512 struct pl2303_private *priv = usb_get_serial_port_data(port);
520 dbg("%s - port %d", __FUNCTION__, port->number);
522 spin_lock_irqsave(&priv->lock, flags);
523 if (!priv->termios_initialized) {
524 *(port->tty->termios) = tty_std_termios;
525 port->tty->termios->c_cflag = B9600 | CS8 | CREAD |
527 port->tty->termios->c_ispeed = 9600;
528 port->tty->termios->c_ospeed = 9600;
529 priv->termios_initialized = 1;
531 spin_unlock_irqrestore(&priv->lock, flags);
533 /* The PL2303 is reported to lose bytes if you change
534 serial settings even to the same values as before. Thus
535 we actually need to filter in this specific case */
537 if (!tty_termios_hw_change(port->tty->termios, old_termios))
540 cflag = port->tty->termios->c_cflag;
542 buf = kzalloc(7, GFP_KERNEL);
544 dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
548 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
549 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
551 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
552 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
555 switch (cflag & CSIZE) {
556 case CS5: buf[6] = 5; break;
557 case CS6: buf[6] = 6; break;
558 case CS7: buf[6] = 7; break;
560 case CS8: buf[6] = 8; break;
562 dbg("%s - data bits = %d", __FUNCTION__, buf[6]);
565 baud = tty_get_baud_rate(port->tty);;
566 dbg("%s - baud = %d", __FUNCTION__, baud);
568 buf[0] = baud & 0xff;
569 buf[1] = (baud >> 8) & 0xff;
570 buf[2] = (baud >> 16) & 0xff;
571 buf[3] = (baud >> 24) & 0xff;
574 /* For reference buf[4]=0 is 1 stop bits */
575 /* For reference buf[4]=1 is 1.5 stop bits */
576 /* For reference buf[4]=2 is 2 stop bits */
577 if (cflag & CSTOPB) {
579 dbg("%s - stop bits = 2", __FUNCTION__);
582 dbg("%s - stop bits = 1", __FUNCTION__);
585 if (cflag & PARENB) {
586 /* For reference buf[5]=0 is none parity */
587 /* For reference buf[5]=1 is odd parity */
588 /* For reference buf[5]=2 is even parity */
589 /* For reference buf[5]=3 is mark parity */
590 /* For reference buf[5]=4 is space parity */
591 if (cflag & PARODD) {
593 dbg("%s - parity = odd", __FUNCTION__);
596 dbg("%s - parity = even", __FUNCTION__);
600 dbg("%s - parity = none", __FUNCTION__);
603 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
604 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
606 dbg("0x21:0x20:0:0 %d", i);
608 /* change control lines if we are switching to or from B0 */
609 spin_lock_irqsave(&priv->lock, flags);
610 control = priv->line_control;
611 if ((cflag & CBAUD) == B0)
612 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
614 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
615 if (control != priv->line_control) {
616 control = priv->line_control;
617 spin_unlock_irqrestore(&priv->lock, flags);
618 set_control_lines(serial->dev, control);
620 spin_unlock_irqrestore(&priv->lock, flags);
623 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
625 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
626 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
628 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
629 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
631 if (cflag & CRTSCTS) {
632 if (priv->type == HX)
633 pl2303_vendor_write(0x0, 0x61, serial);
635 pl2303_vendor_write(0x0, 0x41, serial);
637 pl2303_vendor_write(0x0, 0x0, serial);
640 /* FIXME: Need to read back resulting baud rate */
642 tty_encode_baud_rate(port->tty, baud, baud);
647 static void pl2303_close(struct usb_serial_port *port, struct file *filp)
649 struct pl2303_private *priv = usb_get_serial_port_data(port);
651 unsigned int c_cflag;
656 dbg("%s - port %d", __FUNCTION__, port->number);
658 /* wait for data to drain from the buffer */
659 spin_lock_irqsave(&priv->lock, flags);
660 timeout = PL2303_CLOSING_WAIT;
661 init_waitqueue_entry(&wait, current);
662 add_wait_queue(&port->tty->write_wait, &wait);
664 set_current_state(TASK_INTERRUPTIBLE);
665 if (pl2303_buf_data_avail(priv->buf) == 0 ||
666 timeout == 0 || signal_pending(current) ||
667 !usb_get_intfdata(port->serial->interface)) /* disconnect */
669 spin_unlock_irqrestore(&priv->lock, flags);
670 timeout = schedule_timeout(timeout);
671 spin_lock_irqsave(&priv->lock, flags);
673 set_current_state(TASK_RUNNING);
674 remove_wait_queue(&port->tty->write_wait, &wait);
675 /* clear out any remaining data in the buffer */
676 pl2303_buf_clear(priv->buf);
677 spin_unlock_irqrestore(&priv->lock, flags);
679 /* wait for characters to drain from the device */
680 /* (this is long enough for the entire 256 byte */
681 /* pl2303 hardware buffer to drain with no flow */
682 /* control for data rates of 1200 bps or more, */
683 /* for lower rates we should really know how much */
684 /* data is in the buffer to compute a delay */
685 /* that is not unnecessarily long) */
686 bps = tty_get_baud_rate(port->tty);
688 timeout = max((HZ*2560)/bps,HZ/10);
691 schedule_timeout_interruptible(timeout);
693 /* shutdown our urbs */
694 dbg("%s - shutting down urbs", __FUNCTION__);
695 usb_kill_urb(port->write_urb);
696 usb_kill_urb(port->read_urb);
697 usb_kill_urb(port->interrupt_in_urb);
700 c_cflag = port->tty->termios->c_cflag;
701 if (c_cflag & HUPCL) {
702 /* drop DTR and RTS */
703 spin_lock_irqsave(&priv->lock, flags);
704 priv->line_control = 0;
705 spin_unlock_irqrestore(&priv->lock, flags);
706 set_control_lines(port->serial->dev, 0);
711 static int pl2303_open(struct usb_serial_port *port, struct file *filp)
713 struct ktermios tmp_termios;
714 struct usb_serial *serial = port->serial;
715 struct pl2303_private *priv = usb_get_serial_port_data(port);
718 dbg("%s - port %d", __FUNCTION__, port->number);
720 if (priv->type != HX) {
721 usb_clear_halt(serial->dev, port->write_urb->pipe);
722 usb_clear_halt(serial->dev, port->read_urb->pipe);
724 /* reset upstream data pipes */
725 pl2303_vendor_write(8, 0, serial);
726 pl2303_vendor_write(9, 0, serial);
731 pl2303_set_termios(port, &tmp_termios);
734 //FIXME: need to assert RTS and DTR if CRTSCTS off
736 dbg("%s - submitting read urb", __FUNCTION__);
737 port->read_urb->dev = serial->dev;
738 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
740 dev_err(&port->dev, "%s - failed submitting read urb,"
741 " error %d\n", __FUNCTION__, result);
742 pl2303_close(port, NULL);
746 dbg("%s - submitting interrupt urb", __FUNCTION__);
747 port->interrupt_in_urb->dev = serial->dev;
748 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
750 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
751 " error %d\n", __FUNCTION__, result);
752 pl2303_close(port, NULL);
758 static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
759 unsigned int set, unsigned int clear)
761 struct pl2303_private *priv = usb_get_serial_port_data(port);
765 if (!usb_get_intfdata(port->serial->interface))
768 spin_lock_irqsave(&priv->lock, flags);
770 priv->line_control |= CONTROL_RTS;
772 priv->line_control |= CONTROL_DTR;
773 if (clear & TIOCM_RTS)
774 priv->line_control &= ~CONTROL_RTS;
775 if (clear & TIOCM_DTR)
776 priv->line_control &= ~CONTROL_DTR;
777 control = priv->line_control;
778 spin_unlock_irqrestore(&priv->lock, flags);
780 return set_control_lines(port->serial->dev, control);
783 static int pl2303_tiocmget(struct usb_serial_port *port, struct file *file)
785 struct pl2303_private *priv = usb_get_serial_port_data(port);
791 dbg("%s (%d)", __FUNCTION__, port->number);
793 if (!usb_get_intfdata(port->serial->interface))
796 spin_lock_irqsave(&priv->lock, flags);
797 mcr = priv->line_control;
798 status = priv->line_status;
799 spin_unlock_irqrestore(&priv->lock, flags);
801 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
802 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
803 | ((status & UART_CTS) ? TIOCM_CTS : 0)
804 | ((status & UART_DSR) ? TIOCM_DSR : 0)
805 | ((status & UART_RING) ? TIOCM_RI : 0)
806 | ((status & UART_DCD) ? TIOCM_CD : 0);
808 dbg("%s - result = %x", __FUNCTION__, result);
813 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
815 struct pl2303_private *priv = usb_get_serial_port_data(port);
817 unsigned int prevstatus;
819 unsigned int changed;
821 spin_lock_irqsave(&priv->lock, flags);
822 prevstatus = priv->line_status;
823 spin_unlock_irqrestore(&priv->lock, flags);
826 interruptible_sleep_on(&priv->delta_msr_wait);
827 /* see if a signal did it */
828 if (signal_pending(current))
831 spin_lock_irqsave(&priv->lock, flags);
832 status = priv->line_status;
833 spin_unlock_irqrestore(&priv->lock, flags);
835 changed=prevstatus^status;
837 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
838 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
839 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
840 ((arg & TIOCM_CTS) && (changed & UART_CTS)) ) {
849 static int pl2303_ioctl(struct usb_serial_port *port, struct file *file,
850 unsigned int cmd, unsigned long arg)
852 dbg("%s (%d) cmd = 0x%04x", __FUNCTION__, port->number, cmd);
856 dbg("%s (%d) TIOCMIWAIT", __FUNCTION__, port->number);
857 return wait_modem_info(port, arg);
860 dbg("%s not supported = 0x%04x", __FUNCTION__, cmd);
867 static void pl2303_break_ctl(struct usb_serial_port *port, int break_state)
869 struct usb_serial *serial = port->serial;
873 dbg("%s - port %d", __FUNCTION__, port->number);
875 if (break_state == 0)
879 dbg("%s - turning break %s", __FUNCTION__, state==BREAK_OFF ? "off" : "on");
881 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
882 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
885 dbg("%s - error sending break = %d", __FUNCTION__, result);
888 static void pl2303_shutdown(struct usb_serial *serial)
891 struct pl2303_private *priv;
893 dbg("%s", __FUNCTION__);
895 for (i = 0; i < serial->num_ports; ++i) {
896 priv = usb_get_serial_port_data(serial->port[i]);
898 pl2303_buf_free(priv->buf);
900 usb_set_serial_port_data(serial->port[i], NULL);
905 static void pl2303_update_line_status(struct usb_serial_port *port,
907 unsigned int actual_length)
910 struct pl2303_private *priv = usb_get_serial_port_data(port);
912 u8 status_idx = UART_STATE;
913 u8 length = UART_STATE + 1;
916 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
917 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
920 if (idv == SIEMENS_VENDOR_ID) {
921 if (idp == SIEMENS_PRODUCT_ID_X65 ||
922 idp == SIEMENS_PRODUCT_ID_SX1 ||
923 idp == SIEMENS_PRODUCT_ID_X75) {
930 if (actual_length < length)
933 /* Save off the uart status for others to look at */
934 spin_lock_irqsave(&priv->lock, flags);
935 priv->line_status = data[status_idx];
936 spin_unlock_irqrestore(&priv->lock, flags);
937 wake_up_interruptible(&priv->delta_msr_wait);
940 static void pl2303_read_int_callback(struct urb *urb)
942 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
943 unsigned char *data = urb->transfer_buffer;
944 unsigned int actual_length = urb->actual_length;
945 int status = urb->status;
948 dbg("%s (%d)", __FUNCTION__, port->number);
957 /* this urb is terminated, clean up */
958 dbg("%s - urb shutting down with status: %d", __FUNCTION__,
962 dbg("%s - nonzero urb status received: %d", __FUNCTION__,
967 usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
968 urb->actual_length, urb->transfer_buffer);
970 pl2303_update_line_status(port, data, actual_length);
973 retval = usb_submit_urb(urb, GFP_ATOMIC);
975 dev_err(&urb->dev->dev,
976 "%s - usb_submit_urb failed with result %d\n",
977 __FUNCTION__, retval);
980 static void pl2303_read_bulk_callback(struct urb *urb)
982 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
983 struct pl2303_private *priv = usb_get_serial_port_data(port);
984 struct tty_struct *tty;
985 unsigned char *data = urb->transfer_buffer;
989 int status = urb->status;
993 dbg("%s - port %d", __FUNCTION__, port->number);
996 dbg("%s - urb status = %d", __FUNCTION__, status);
997 if (!port->open_count) {
998 dbg("%s - port is closed, exiting.", __FUNCTION__);
1001 if (status == -EPROTO) {
1002 /* PL2303 mysteriously fails with -EPROTO reschedule
1004 dbg("%s - caught -EPROTO, resubmitting the urb",
1006 urb->dev = port->serial->dev;
1007 result = usb_submit_urb(urb, GFP_ATOMIC);
1009 dev_err(&urb->dev->dev, "%s - failed"
1010 " resubmitting read urb, error %d\n",
1011 __FUNCTION__, result);
1014 dbg("%s - unable to handle the error, exiting.", __FUNCTION__);
1018 usb_serial_debug_data(debug, &port->dev, __FUNCTION__,
1019 urb->actual_length, data);
1021 /* get tty_flag from status */
1022 tty_flag = TTY_NORMAL;
1024 spin_lock_irqsave(&priv->lock, flags);
1025 line_status = priv->line_status;
1026 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1027 spin_unlock_irqrestore(&priv->lock, flags);
1028 wake_up_interruptible(&priv->delta_msr_wait);
1030 /* break takes precedence over parity, */
1031 /* which takes precedence over framing errors */
1032 if (line_status & UART_BREAK_ERROR )
1033 tty_flag = TTY_BREAK;
1034 else if (line_status & UART_PARITY_ERROR)
1035 tty_flag = TTY_PARITY;
1036 else if (line_status & UART_FRAME_ERROR)
1037 tty_flag = TTY_FRAME;
1038 dbg("%s - tty_flag = %d", __FUNCTION__, tty_flag);
1041 if (tty && urb->actual_length) {
1042 tty_buffer_request_room(tty, urb->actual_length + 1);
1043 /* overrun is special, not associated with a char */
1044 if (line_status & UART_OVERRUN_ERROR)
1045 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1046 for (i = 0; i < urb->actual_length; ++i)
1047 tty_insert_flip_char(tty, data[i], tty_flag);
1048 tty_flip_buffer_push(tty);
1051 /* Schedule the next read _if_ we are still open */
1052 if (port->open_count) {
1053 urb->dev = port->serial->dev;
1054 result = usb_submit_urb(urb, GFP_ATOMIC);
1056 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1057 " read urb, error %d\n", __FUNCTION__, result);
1063 static void pl2303_write_bulk_callback(struct urb *urb)
1065 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
1066 struct pl2303_private *priv = usb_get_serial_port_data(port);
1068 int status = urb->status;
1070 dbg("%s - port %d", __FUNCTION__, port->number);
1079 /* this urb is terminated, clean up */
1080 dbg("%s - urb shutting down with status: %d", __FUNCTION__,
1082 priv->write_urb_in_use = 0;
1085 /* error in the urb, so we have to resubmit it */
1086 dbg("%s - Overflow in write", __FUNCTION__);
1087 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__,
1089 port->write_urb->transfer_buffer_length = 1;
1090 port->write_urb->dev = port->serial->dev;
1091 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1093 dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1094 " urb, error %d\n", __FUNCTION__, result);
1099 priv->write_urb_in_use = 0;
1101 /* send any buffered data */
1105 /* All of the device info needed for the PL2303 SIO serial converter */
1106 static struct usb_serial_driver pl2303_device = {
1108 .owner = THIS_MODULE,
1111 .id_table = id_table,
1112 .usb_driver = &pl2303_driver,
1113 .num_interrupt_in = NUM_DONT_CARE,
1117 .open = pl2303_open,
1118 .close = pl2303_close,
1119 .write = pl2303_write,
1120 .ioctl = pl2303_ioctl,
1121 .break_ctl = pl2303_break_ctl,
1122 .set_termios = pl2303_set_termios,
1123 .tiocmget = pl2303_tiocmget,
1124 .tiocmset = pl2303_tiocmset,
1125 .read_bulk_callback = pl2303_read_bulk_callback,
1126 .read_int_callback = pl2303_read_int_callback,
1127 .write_bulk_callback = pl2303_write_bulk_callback,
1128 .write_room = pl2303_write_room,
1129 .chars_in_buffer = pl2303_chars_in_buffer,
1130 .attach = pl2303_startup,
1131 .shutdown = pl2303_shutdown,
1134 static int __init pl2303_init(void)
1138 retval = usb_serial_register(&pl2303_device);
1140 goto failed_usb_serial_register;
1141 retval = usb_register(&pl2303_driver);
1143 goto failed_usb_register;
1146 failed_usb_register:
1147 usb_serial_deregister(&pl2303_device);
1148 failed_usb_serial_register:
1152 static void __exit pl2303_exit(void)
1154 usb_deregister(&pl2303_driver);
1155 usb_serial_deregister(&pl2303_device);
1158 module_init(pl2303_init);
1159 module_exit(pl2303_exit);
1161 MODULE_DESCRIPTION(DRIVER_DESC);
1162 MODULE_LICENSE("GPL");
1164 module_param(debug, bool, S_IRUGO | S_IWUSR);
1165 MODULE_PARM_DESC(debug, "Debug enabled or not");