2 * Prolific PL2303 USB to serial adaptor driver
4 * Copyright (C) 2001-2004 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 modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License.
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(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
60 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
61 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
62 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
63 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
64 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
65 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
66 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
67 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
68 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
69 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
70 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
71 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
72 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
73 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
74 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
75 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
76 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
77 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
78 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
79 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
80 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
81 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
82 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
83 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
84 { } /* Terminating entry */
87 MODULE_DEVICE_TABLE(usb, id_table);
89 static struct usb_driver pl2303_driver = {
91 .probe = usb_serial_probe,
92 .disconnect = usb_serial_disconnect,
97 #define SET_LINE_REQUEST_TYPE 0x21
98 #define SET_LINE_REQUEST 0x20
100 #define SET_CONTROL_REQUEST_TYPE 0x21
101 #define SET_CONTROL_REQUEST 0x22
102 #define CONTROL_DTR 0x01
103 #define CONTROL_RTS 0x02
105 #define BREAK_REQUEST_TYPE 0x21
106 #define BREAK_REQUEST 0x23
107 #define BREAK_ON 0xffff
108 #define BREAK_OFF 0x0000
110 #define GET_LINE_REQUEST_TYPE 0xa1
111 #define GET_LINE_REQUEST 0x21
113 #define VENDOR_WRITE_REQUEST_TYPE 0x40
114 #define VENDOR_WRITE_REQUEST 0x01
116 #define VENDOR_READ_REQUEST_TYPE 0xc0
117 #define VENDOR_READ_REQUEST 0x01
119 #define UART_STATE 0x08
120 #define UART_STATE_TRANSIENT_MASK 0x74
121 #define UART_DCD 0x01
122 #define UART_DSR 0x02
123 #define UART_BREAK_ERROR 0x04
124 #define UART_RING 0x08
125 #define UART_FRAME_ERROR 0x10
126 #define UART_PARITY_ERROR 0x20
127 #define UART_OVERRUN_ERROR 0x40
128 #define UART_CTS 0x80
132 type_0, /* don't know the difference between type 0 and */
133 type_1, /* type 1, until someone from prolific tells us... */
134 HX, /* HX version of the pl2303 chip */
137 struct pl2303_private {
139 struct pl2303_buf *buf;
140 int write_urb_in_use;
141 wait_queue_head_t delta_msr_wait;
144 u8 termios_initialized;
145 enum pl2303_type type;
151 * Allocate a circular buffer and all associated memory.
153 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
155 struct pl2303_buf *pb;
160 pb = (struct pl2303_buf *)kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
164 pb->buf_buf = kmalloc(size, GFP_KERNEL);
165 if (pb->buf_buf == NULL) {
171 pb->buf_get = pb->buf_put = pb->buf_buf;
179 * Free the buffer and all associated memory.
181 static void pl2303_buf_free(struct pl2303_buf *pb)
192 * Clear out all data in the circular buffer.
194 static void pl2303_buf_clear(struct pl2303_buf *pb)
197 pb->buf_get = pb->buf_put;
198 /* equivalent to a get of all data available */
202 * pl2303_buf_data_avail
204 * Return the number of bytes of data available in the circular
207 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
212 return ((pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size);
216 * pl2303_buf_space_avail
218 * Return the number of bytes of space available in the circular
221 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
226 return ((pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size);
232 * Copy data data from a user buffer and put it into the circular buffer.
233 * Restrict to the amount of space available.
235 * Return the number of bytes copied.
237 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
245 len = pl2303_buf_space_avail(pb);
252 len = pb->buf_buf + pb->buf_size - pb->buf_put;
254 memcpy(pb->buf_put, buf, len);
255 memcpy(pb->buf_buf, buf+len, count - len);
256 pb->buf_put = pb->buf_buf + count - len;
258 memcpy(pb->buf_put, buf, count);
260 pb->buf_put += count;
261 else /* count == len */
262 pb->buf_put = pb->buf_buf;
271 * Get data from the circular buffer and copy to the given buffer.
272 * Restrict to the amount of data available.
274 * Return the number of bytes copied.
276 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
284 len = pl2303_buf_data_avail(pb);
291 len = pb->buf_buf + pb->buf_size - pb->buf_get;
293 memcpy(buf, pb->buf_get, len);
294 memcpy(buf+len, pb->buf_buf, count - len);
295 pb->buf_get = pb->buf_buf + count - len;
297 memcpy(buf, pb->buf_get, count);
299 pb->buf_get += count;
300 else /* count == len */
301 pb->buf_get = pb->buf_buf;
307 static int pl2303_startup(struct usb_serial *serial)
309 struct pl2303_private *priv;
310 enum pl2303_type type = type_0;
313 if (serial->dev->descriptor.bDeviceClass == 0x02)
315 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
317 else if (serial->dev->descriptor.bDeviceClass == 0x00)
319 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
321 dbg("device type: %d", type);
323 for (i = 0; i < serial->num_ports; ++i) {
324 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
327 spin_lock_init(&priv->lock);
328 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
329 if (priv->buf == NULL) {
333 init_waitqueue_head(&priv->delta_msr_wait);
335 usb_set_serial_port_data(serial->port[i], priv);
340 for (--i; i>=0; --i) {
341 priv = usb_get_serial_port_data(serial->port[i]);
342 pl2303_buf_free(priv->buf);
344 usb_set_serial_port_data(serial->port[i], NULL);
349 static int set_control_lines(struct usb_device *dev, u8 value)
353 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
354 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
355 value, 0, NULL, 0, 100);
356 dbg("%s - value = %d, retval = %d", __FUNCTION__, value, retval);
360 static void pl2303_send(struct usb_serial_port *port)
363 struct pl2303_private *priv = usb_get_serial_port_data(port);
366 dbg("%s - port %d", __FUNCTION__, port->number);
368 spin_lock_irqsave(&priv->lock, flags);
370 if (priv->write_urb_in_use) {
371 spin_unlock_irqrestore(&priv->lock, flags);
375 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
376 port->bulk_out_size);
379 spin_unlock_irqrestore(&priv->lock, flags);
383 priv->write_urb_in_use = 1;
385 spin_unlock_irqrestore(&priv->lock, flags);
387 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count,
388 port->write_urb->transfer_buffer);
390 port->write_urb->transfer_buffer_length = count;
391 port->write_urb->dev = port->serial->dev;
392 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
394 dev_err(&port->dev, "%s - failed submitting write urb,"
395 " error %d\n", __FUNCTION__, result);
396 priv->write_urb_in_use = 0;
397 // TODO: reschedule pl2303_send
400 usb_serial_port_softint(port);
403 static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
406 struct pl2303_private *priv = usb_get_serial_port_data(port);
409 dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count);
414 spin_lock_irqsave(&priv->lock, flags);
415 count = pl2303_buf_put(priv->buf, buf, count);
416 spin_unlock_irqrestore(&priv->lock, flags);
423 static int pl2303_write_room(struct usb_serial_port *port)
425 struct pl2303_private *priv = usb_get_serial_port_data(port);
429 dbg("%s - port %d", __FUNCTION__, port->number);
431 spin_lock_irqsave(&priv->lock, flags);
432 room = pl2303_buf_space_avail(priv->buf);
433 spin_unlock_irqrestore(&priv->lock, flags);
435 dbg("%s - returns %d", __FUNCTION__, room);
439 static int pl2303_chars_in_buffer(struct usb_serial_port *port)
441 struct pl2303_private *priv = usb_get_serial_port_data(port);
445 dbg("%s - port %d", __FUNCTION__, port->number);
447 spin_lock_irqsave(&priv->lock, flags);
448 chars = pl2303_buf_data_avail(priv->buf);
449 spin_unlock_irqrestore(&priv->lock, flags);
451 dbg("%s - returns %d", __FUNCTION__, chars);
455 static void pl2303_set_termios(struct usb_serial_port *port,
456 struct termios *old_termios)
458 struct usb_serial *serial = port->serial;
459 struct pl2303_private *priv = usb_get_serial_port_data(port);
467 dbg("%s - port %d", __FUNCTION__, port->number);
469 if ((!port->tty) || (!port->tty->termios)) {
470 dbg("%s - no tty structures", __FUNCTION__);
474 spin_lock_irqsave(&priv->lock, flags);
475 if (!priv->termios_initialized) {
476 *(port->tty->termios) = tty_std_termios;
477 port->tty->termios->c_cflag = B9600 | CS8 | CREAD |
479 priv->termios_initialized = 1;
481 spin_unlock_irqrestore(&priv->lock, flags);
483 cflag = port->tty->termios->c_cflag;
484 /* check that they really want us to change something */
486 if ((cflag == old_termios->c_cflag) &&
487 (RELEVANT_IFLAG(port->tty->termios->c_iflag) ==
488 RELEVANT_IFLAG(old_termios->c_iflag))) {
489 dbg("%s - nothing to change...", __FUNCTION__);
494 buf = kzalloc(7, GFP_KERNEL);
496 dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
500 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
501 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
503 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
504 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
507 switch (cflag & CSIZE) {
508 case CS5: buf[6] = 5; break;
509 case CS6: buf[6] = 6; break;
510 case CS7: buf[6] = 7; break;
512 case CS8: buf[6] = 8; break;
514 dbg("%s - data bits = %d", __FUNCTION__, buf[6]);
518 switch (cflag & CBAUD) {
519 case B0: baud = 0; break;
520 case B75: baud = 75; break;
521 case B150: baud = 150; break;
522 case B300: baud = 300; break;
523 case B600: baud = 600; break;
524 case B1200: baud = 1200; break;
525 case B1800: baud = 1800; break;
526 case B2400: baud = 2400; break;
527 case B4800: baud = 4800; break;
528 case B9600: baud = 9600; break;
529 case B19200: baud = 19200; break;
530 case B38400: baud = 38400; break;
531 case B57600: baud = 57600; break;
532 case B115200: baud = 115200; break;
533 case B230400: baud = 230400; break;
534 case B460800: baud = 460800; break;
536 dev_err(&port->dev, "pl2303 driver does not support"
537 " the baudrate requested (fix it)\n");
540 dbg("%s - baud = %d", __FUNCTION__, baud);
542 buf[0] = baud & 0xff;
543 buf[1] = (baud >> 8) & 0xff;
544 buf[2] = (baud >> 16) & 0xff;
545 buf[3] = (baud >> 24) & 0xff;
548 /* For reference buf[4]=0 is 1 stop bits */
549 /* For reference buf[4]=1 is 1.5 stop bits */
550 /* For reference buf[4]=2 is 2 stop bits */
551 if (cflag & CSTOPB) {
553 dbg("%s - stop bits = 2", __FUNCTION__);
556 dbg("%s - stop bits = 1", __FUNCTION__);
559 if (cflag & PARENB) {
560 /* For reference buf[5]=0 is none parity */
561 /* For reference buf[5]=1 is odd parity */
562 /* For reference buf[5]=2 is even parity */
563 /* For reference buf[5]=3 is mark parity */
564 /* For reference buf[5]=4 is space parity */
565 if (cflag & PARODD) {
567 dbg("%s - parity = odd", __FUNCTION__);
570 dbg("%s - parity = even", __FUNCTION__);
574 dbg("%s - parity = none", __FUNCTION__);
577 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
578 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
580 dbg("0x21:0x20:0:0 %d", i);
582 /* change control lines if we are switching to or from B0 */
583 spin_lock_irqsave(&priv->lock, flags);
584 control = priv->line_control;
585 if ((cflag & CBAUD) == B0)
586 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
588 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
589 if (control != priv->line_control) {
590 control = priv->line_control;
591 spin_unlock_irqrestore(&priv->lock, flags);
592 set_control_lines(serial->dev, control);
594 spin_unlock_irqrestore(&priv->lock, flags);
597 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
599 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
600 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
602 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
603 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
605 if (cflag & CRTSCTS) {
607 if (priv->type == HX)
611 i = usb_control_msg(serial->dev,
612 usb_sndctrlpipe(serial->dev, 0),
613 VENDOR_WRITE_REQUEST,
614 VENDOR_WRITE_REQUEST_TYPE,
615 0x0, index, NULL, 0, 100);
616 dbg("0x40:0x1:0x0:0x%x %d", index, i);
622 static void pl2303_close(struct usb_serial_port *port, struct file *filp)
624 struct pl2303_private *priv = usb_get_serial_port_data(port);
626 unsigned int c_cflag;
631 dbg("%s - port %d", __FUNCTION__, port->number);
633 /* wait for data to drain from the buffer */
634 spin_lock_irqsave(&priv->lock, flags);
635 timeout = PL2303_CLOSING_WAIT;
636 init_waitqueue_entry(&wait, current);
637 add_wait_queue(&port->tty->write_wait, &wait);
639 set_current_state(TASK_INTERRUPTIBLE);
640 if (pl2303_buf_data_avail(priv->buf) == 0 ||
641 timeout == 0 || signal_pending(current) ||
642 !usb_get_intfdata(port->serial->interface)) /* disconnect */
644 spin_unlock_irqrestore(&priv->lock, flags);
645 timeout = schedule_timeout(timeout);
646 spin_lock_irqsave(&priv->lock, flags);
648 set_current_state(TASK_RUNNING);
649 remove_wait_queue(&port->tty->write_wait, &wait);
650 /* clear out any remaining data in the buffer */
651 pl2303_buf_clear(priv->buf);
652 spin_unlock_irqrestore(&priv->lock, flags);
654 /* wait for characters to drain from the device */
655 /* (this is long enough for the entire 256 byte */
656 /* pl2303 hardware buffer to drain with no flow */
657 /* control for data rates of 1200 bps or more, */
658 /* for lower rates we should really know how much */
659 /* data is in the buffer to compute a delay */
660 /* that is not unnecessarily long) */
661 bps = tty_get_baud_rate(port->tty);
663 timeout = max((HZ*2560)/bps,HZ/10);
666 schedule_timeout_interruptible(timeout);
668 /* shutdown our urbs */
669 dbg("%s - shutting down urbs", __FUNCTION__);
670 usb_kill_urb(port->write_urb);
671 usb_kill_urb(port->read_urb);
672 usb_kill_urb(port->interrupt_in_urb);
675 c_cflag = port->tty->termios->c_cflag;
676 if (c_cflag & HUPCL) {
677 /* drop DTR and RTS */
678 spin_lock_irqsave(&priv->lock, flags);
679 priv->line_control = 0;
680 spin_unlock_irqrestore(&priv->lock, flags);
681 set_control_lines(port->serial->dev, 0);
686 static int pl2303_open(struct usb_serial_port *port, struct file *filp)
688 struct termios tmp_termios;
689 struct usb_serial *serial = port->serial;
690 struct pl2303_private *priv = usb_get_serial_port_data(port);
694 dbg("%s - port %d", __FUNCTION__, port->number);
696 if (priv->type != HX) {
697 usb_clear_halt(serial->dev, port->write_urb->pipe);
698 usb_clear_halt(serial->dev, port->read_urb->pipe);
701 buf = kmalloc(10, GFP_KERNEL);
705 #define FISH(a,b,c,d) \
706 result=usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev,0), \
707 b, a, c, d, buf, 1, 100); \
708 dbg("0x%x:0x%x:0x%x:0x%x %d - %x",a,b,c,d,result,buf[0]);
710 #define SOUP(a,b,c,d) \
711 result=usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev,0), \
712 b, a, c, d, NULL, 0, 100); \
713 dbg("0x%x:0x%x:0x%x:0x%x %d",a,b,c,d,result);
715 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
716 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 0);
717 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
718 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
719 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
720 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 1);
721 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
722 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
723 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0, 1);
724 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 1, 0);
726 if (priv->type == HX) {
728 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x44);
729 /* reset upstream data pipes */
730 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 8, 0);
731 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 9, 0);
733 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x24);
740 pl2303_set_termios(port, &tmp_termios);
743 //FIXME: need to assert RTS and DTR if CRTSCTS off
745 dbg("%s - submitting read urb", __FUNCTION__);
746 port->read_urb->dev = serial->dev;
747 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
749 dev_err(&port->dev, "%s - failed submitting read urb,"
750 " error %d\n", __FUNCTION__, result);
751 pl2303_close(port, NULL);
755 dbg("%s - submitting interrupt urb", __FUNCTION__);
756 port->interrupt_in_urb->dev = serial->dev;
757 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
759 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
760 " error %d\n", __FUNCTION__, result);
761 pl2303_close(port, NULL);
767 static int pl2303_tiocmset(struct usb_serial_port *port, struct file *file,
768 unsigned int set, unsigned int clear)
770 struct pl2303_private *priv = usb_get_serial_port_data(port);
774 if (!usb_get_intfdata(port->serial->interface))
777 spin_lock_irqsave(&priv->lock, flags);
779 priv->line_control |= CONTROL_RTS;
781 priv->line_control |= CONTROL_DTR;
782 if (clear & TIOCM_RTS)
783 priv->line_control &= ~CONTROL_RTS;
784 if (clear & TIOCM_DTR)
785 priv->line_control &= ~CONTROL_DTR;
786 control = priv->line_control;
787 spin_unlock_irqrestore(&priv->lock, flags);
789 return set_control_lines(port->serial->dev, control);
792 static int pl2303_tiocmget(struct usb_serial_port *port, struct file *file)
794 struct pl2303_private *priv = usb_get_serial_port_data(port);
800 dbg("%s (%d)", __FUNCTION__, 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", __FUNCTION__, 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 usb_serial_port *port, struct file *file,
859 unsigned int cmd, unsigned long arg)
861 dbg("%s (%d) cmd = 0x%04x", __FUNCTION__, port->number, cmd);
865 dbg("%s (%d) TIOCMIWAIT", __FUNCTION__, port->number);
866 return wait_modem_info(port, arg);
869 dbg("%s not supported = 0x%04x", __FUNCTION__, cmd);
876 static void pl2303_break_ctl(struct usb_serial_port *port, int break_state)
878 struct usb_serial *serial = port->serial;
882 dbg("%s - port %d", __FUNCTION__, port->number);
884 if (break_state == 0)
888 dbg("%s - turning break %s", __FUNCTION__, state==BREAK_OFF ? "off" : "on");
890 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
891 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
894 dbg("%s - error sending break = %d", __FUNCTION__, result);
897 static void pl2303_shutdown(struct usb_serial *serial)
900 struct pl2303_private *priv;
902 dbg("%s", __FUNCTION__);
904 for (i = 0; i < serial->num_ports; ++i) {
905 priv = usb_get_serial_port_data(serial->port[i]);
907 pl2303_buf_free(priv->buf);
909 usb_set_serial_port_data(serial->port[i], NULL);
914 static void pl2303_update_line_status(struct usb_serial_port *port,
916 unsigned int actual_length)
919 struct pl2303_private *priv = usb_get_serial_port_data(port);
921 u8 status_idx = UART_STATE;
922 u8 length = UART_STATE + 1;
924 if ((le16_to_cpu(port->serial->dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
925 (le16_to_cpu(port->serial->dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_X65 ||
926 le16_to_cpu(port->serial->dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_SX1 ||
927 le16_to_cpu(port->serial->dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_X75)) {
932 if (actual_length < length)
935 /* Save off the uart status for others to look at */
936 spin_lock_irqsave(&priv->lock, flags);
937 priv->line_status = data[status_idx];
938 spin_unlock_irqrestore(&priv->lock, flags);
939 wake_up_interruptible(&priv->delta_msr_wait);
942 static void pl2303_read_int_callback(struct urb *urb, struct pt_regs *regs)
944 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
945 unsigned char *data = urb->transfer_buffer;
946 unsigned int actual_length = urb->actual_length;
949 dbg("%s (%d)", __FUNCTION__, port->number);
951 switch (urb->status) {
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 status = usb_submit_urb(urb, GFP_ATOMIC);
976 dev_err(&urb->dev->dev,
977 "%s - usb_submit_urb failed with result %d\n",
978 __FUNCTION__, status);
981 static void pl2303_read_bulk_callback(struct urb *urb, struct pt_regs *regs)
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;
993 dbg("%s - port %d", __FUNCTION__, port->number);
996 dbg("%s - urb->status = %d", __FUNCTION__, urb->status);
997 if (!port->open_count) {
998 dbg("%s - port is closed, exiting.", __FUNCTION__);
1001 if (urb->status == -EPROTO) {
1002 /* PL2303 mysteriously fails with -EPROTO reschedule
1004 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 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 (status & UART_BREAK_ERROR )
1034 tty_flag = TTY_BREAK;
1035 else if (status & UART_PARITY_ERROR)
1036 tty_flag = TTY_PARITY;
1037 else if (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 (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, struct pt_regs *regs)
1066 struct usb_serial_port *port = (struct usb_serial_port *) urb->context;
1067 struct pl2303_private *priv = usb_get_serial_port_data(port);
1070 dbg("%s - port %d", __FUNCTION__, port->number);
1072 switch (urb->status) {
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 .num_interrupt_in = NUM_DONT_CARE,
1116 .open = pl2303_open,
1117 .close = pl2303_close,
1118 .write = pl2303_write,
1119 .ioctl = pl2303_ioctl,
1120 .break_ctl = pl2303_break_ctl,
1121 .set_termios = pl2303_set_termios,
1122 .tiocmget = pl2303_tiocmget,
1123 .tiocmset = pl2303_tiocmset,
1124 .read_bulk_callback = pl2303_read_bulk_callback,
1125 .read_int_callback = pl2303_read_int_callback,
1126 .write_bulk_callback = pl2303_write_bulk_callback,
1127 .write_room = pl2303_write_room,
1128 .chars_in_buffer = pl2303_chars_in_buffer,
1129 .attach = pl2303_startup,
1130 .shutdown = pl2303_shutdown,
1133 static int __init pl2303_init(void)
1137 retval = usb_serial_register(&pl2303_device);
1139 goto failed_usb_serial_register;
1140 retval = usb_register(&pl2303_driver);
1142 goto failed_usb_register;
1145 failed_usb_register:
1146 usb_serial_deregister(&pl2303_device);
1147 failed_usb_serial_register:
1151 static void __exit pl2303_exit(void)
1153 usb_deregister(&pl2303_driver);
1154 usb_serial_deregister(&pl2303_device);
1157 module_init(pl2303_init);
1158 module_exit(pl2303_exit);
1160 MODULE_DESCRIPTION(DRIVER_DESC);
1161 MODULE_LICENSE("GPL");
1163 module_param(debug, bool, S_IRUGO | S_IWUSR);
1164 MODULE_PARM_DESC(debug, "Debug enabled or not");