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(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
69 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
70 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
71 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
72 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
73 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
74 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
75 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
76 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
77 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
78 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
79 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
80 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
81 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
82 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
83 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
84 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
85 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
86 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
87 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
88 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
89 { USB_DEVICE(HL340_VENDOR_ID, HL340_PRODUCT_ID) },
90 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
91 { } /* Terminating entry */
94 MODULE_DEVICE_TABLE(usb, id_table);
96 static struct usb_driver pl2303_driver = {
98 .probe = usb_serial_probe,
99 .disconnect = usb_serial_disconnect,
100 .id_table = id_table,
104 #define SET_LINE_REQUEST_TYPE 0x21
105 #define SET_LINE_REQUEST 0x20
107 #define SET_CONTROL_REQUEST_TYPE 0x21
108 #define SET_CONTROL_REQUEST 0x22
109 #define CONTROL_DTR 0x01
110 #define CONTROL_RTS 0x02
112 #define BREAK_REQUEST_TYPE 0x21
113 #define BREAK_REQUEST 0x23
114 #define BREAK_ON 0xffff
115 #define BREAK_OFF 0x0000
117 #define GET_LINE_REQUEST_TYPE 0xa1
118 #define GET_LINE_REQUEST 0x21
120 #define VENDOR_WRITE_REQUEST_TYPE 0x40
121 #define VENDOR_WRITE_REQUEST 0x01
123 #define VENDOR_READ_REQUEST_TYPE 0xc0
124 #define VENDOR_READ_REQUEST 0x01
126 #define UART_STATE 0x08
127 #define UART_STATE_TRANSIENT_MASK 0x74
128 #define UART_DCD 0x01
129 #define UART_DSR 0x02
130 #define UART_BREAK_ERROR 0x04
131 #define UART_RING 0x08
132 #define UART_FRAME_ERROR 0x10
133 #define UART_PARITY_ERROR 0x20
134 #define UART_OVERRUN_ERROR 0x40
135 #define UART_CTS 0x80
139 type_0, /* don't know the difference between type 0 and */
140 type_1, /* type 1, until someone from prolific tells us... */
141 HX, /* HX version of the pl2303 chip */
144 struct pl2303_private {
146 struct pl2303_buf *buf;
147 int write_urb_in_use;
148 wait_queue_head_t delta_msr_wait;
151 u8 termios_initialized;
152 enum pl2303_type type;
158 * Allocate a circular buffer and all associated memory.
160 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
162 struct pl2303_buf *pb;
167 pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
171 pb->buf_buf = kmalloc(size, GFP_KERNEL);
172 if (pb->buf_buf == NULL) {
178 pb->buf_get = pb->buf_put = pb->buf_buf;
186 * Free the buffer and all associated memory.
188 static void pl2303_buf_free(struct pl2303_buf *pb)
199 * Clear out all data in the circular buffer.
201 static void pl2303_buf_clear(struct pl2303_buf *pb)
204 pb->buf_get = pb->buf_put;
205 /* equivalent to a get of all data available */
209 * pl2303_buf_data_avail
211 * Return the number of bytes of data available in the circular
214 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
219 return ((pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size);
223 * pl2303_buf_space_avail
225 * Return the number of bytes of space available in the circular
228 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
233 return ((pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size);
239 * Copy data data from a user buffer and put it into the circular buffer.
240 * Restrict to the amount of space available.
242 * Return the number of bytes copied.
244 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
252 len = pl2303_buf_space_avail(pb);
259 len = pb->buf_buf + pb->buf_size - pb->buf_put;
261 memcpy(pb->buf_put, buf, len);
262 memcpy(pb->buf_buf, buf+len, count - len);
263 pb->buf_put = pb->buf_buf + count - len;
265 memcpy(pb->buf_put, buf, count);
267 pb->buf_put += count;
268 else /* count == len */
269 pb->buf_put = pb->buf_buf;
278 * Get data from the circular buffer and copy to the given buffer.
279 * Restrict to the amount of data available.
281 * Return the number of bytes copied.
283 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
291 len = pl2303_buf_data_avail(pb);
298 len = pb->buf_buf + pb->buf_size - pb->buf_get;
300 memcpy(buf, pb->buf_get, len);
301 memcpy(buf+len, pb->buf_buf, count - len);
302 pb->buf_get = pb->buf_buf + count - len;
304 memcpy(buf, pb->buf_get, count);
306 pb->buf_get += count;
307 else /* count == len */
308 pb->buf_get = pb->buf_buf;
314 static int pl2303_startup(struct usb_serial *serial)
316 struct pl2303_private *priv;
317 enum pl2303_type type = type_0;
320 if (serial->dev->descriptor.bDeviceClass == 0x02)
322 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
324 else if (serial->dev->descriptor.bDeviceClass == 0x00)
326 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
328 dbg("device type: %d", type);
330 for (i = 0; i < serial->num_ports; ++i) {
331 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
334 spin_lock_init(&priv->lock);
335 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
336 if (priv->buf == NULL) {
340 init_waitqueue_head(&priv->delta_msr_wait);
342 usb_set_serial_port_data(serial->port[i], priv);
347 for (--i; i>=0; --i) {
348 priv = usb_get_serial_port_data(serial->port[i]);
349 pl2303_buf_free(priv->buf);
351 usb_set_serial_port_data(serial->port[i], NULL);
356 static int set_control_lines(struct usb_device *dev, u8 value)
360 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
361 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
362 value, 0, NULL, 0, 100);
363 dbg("%s - value = %d, retval = %d", __FUNCTION__, value, retval);
367 static void pl2303_send(struct usb_serial_port *port)
370 struct pl2303_private *priv = usb_get_serial_port_data(port);
373 dbg("%s - port %d", __FUNCTION__, port->number);
375 spin_lock_irqsave(&priv->lock, flags);
377 if (priv->write_urb_in_use) {
378 spin_unlock_irqrestore(&priv->lock, flags);
382 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
383 port->bulk_out_size);
386 spin_unlock_irqrestore(&priv->lock, flags);
390 priv->write_urb_in_use = 1;
392 spin_unlock_irqrestore(&priv->lock, flags);
394 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count,
395 port->write_urb->transfer_buffer);
397 port->write_urb->transfer_buffer_length = count;
398 port->write_urb->dev = port->serial->dev;
399 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
401 dev_err(&port->dev, "%s - failed submitting write urb,"
402 " error %d\n", __FUNCTION__, result);
403 priv->write_urb_in_use = 0;
404 // TODO: reschedule pl2303_send
407 usb_serial_port_softint(port);
410 static int pl2303_write(struct usb_serial_port *port, const unsigned char *buf,
413 struct pl2303_private *priv = usb_get_serial_port_data(port);
416 dbg("%s - port %d, %d bytes", __FUNCTION__, port->number, count);
421 spin_lock_irqsave(&priv->lock, flags);
422 count = pl2303_buf_put(priv->buf, buf, count);
423 spin_unlock_irqrestore(&priv->lock, flags);
430 static int pl2303_write_room(struct usb_serial_port *port)
432 struct pl2303_private *priv = usb_get_serial_port_data(port);
436 dbg("%s - port %d", __FUNCTION__, port->number);
438 spin_lock_irqsave(&priv->lock, flags);
439 room = pl2303_buf_space_avail(priv->buf);
440 spin_unlock_irqrestore(&priv->lock, flags);
442 dbg("%s - returns %d", __FUNCTION__, room);
446 static int pl2303_chars_in_buffer(struct usb_serial_port *port)
448 struct pl2303_private *priv = usb_get_serial_port_data(port);
452 dbg("%s - port %d", __FUNCTION__, port->number);
454 spin_lock_irqsave(&priv->lock, flags);
455 chars = pl2303_buf_data_avail(priv->buf);
456 spin_unlock_irqrestore(&priv->lock, flags);
458 dbg("%s - returns %d", __FUNCTION__, chars);
462 static void pl2303_set_termios(struct usb_serial_port *port,
463 struct ktermios *old_termios)
465 struct usb_serial *serial = port->serial;
466 struct pl2303_private *priv = usb_get_serial_port_data(port);
474 dbg("%s - port %d", __FUNCTION__, port->number);
476 spin_lock_irqsave(&priv->lock, flags);
477 if (!priv->termios_initialized) {
478 *(port->tty->termios) = tty_std_termios;
479 port->tty->termios->c_cflag = B9600 | CS8 | CREAD |
481 port->tty->termios->c_ispeed = 9600;
482 port->tty->termios->c_ospeed = 9600;
483 priv->termios_initialized = 1;
485 spin_unlock_irqrestore(&priv->lock, flags);
487 /* The PL2303 is reported to lose bytes if you change
488 serial settings even to the same values as before. Thus
489 we actually need to filter in this specific case */
491 if (!tty_termios_hw_change(port->tty->termios, old_termios))
494 cflag = port->tty->termios->c_cflag;
496 buf = kzalloc(7, GFP_KERNEL);
498 dev_err(&port->dev, "%s - out of memory.\n", __FUNCTION__);
502 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
503 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
505 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
506 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
509 switch (cflag & CSIZE) {
510 case CS5: buf[6] = 5; break;
511 case CS6: buf[6] = 6; break;
512 case CS7: buf[6] = 7; break;
514 case CS8: buf[6] = 8; break;
516 dbg("%s - data bits = %d", __FUNCTION__, buf[6]);
519 baud = tty_get_baud_rate(port->tty);;
520 dbg("%s - baud = %d", __FUNCTION__, baud);
522 buf[0] = baud & 0xff;
523 buf[1] = (baud >> 8) & 0xff;
524 buf[2] = (baud >> 16) & 0xff;
525 buf[3] = (baud >> 24) & 0xff;
528 /* For reference buf[4]=0 is 1 stop bits */
529 /* For reference buf[4]=1 is 1.5 stop bits */
530 /* For reference buf[4]=2 is 2 stop bits */
531 if (cflag & CSTOPB) {
533 dbg("%s - stop bits = 2", __FUNCTION__);
536 dbg("%s - stop bits = 1", __FUNCTION__);
539 if (cflag & PARENB) {
540 /* For reference buf[5]=0 is none parity */
541 /* For reference buf[5]=1 is odd parity */
542 /* For reference buf[5]=2 is even parity */
543 /* For reference buf[5]=3 is mark parity */
544 /* For reference buf[5]=4 is space parity */
545 if (cflag & PARODD) {
547 dbg("%s - parity = odd", __FUNCTION__);
550 dbg("%s - parity = even", __FUNCTION__);
554 dbg("%s - parity = none", __FUNCTION__);
557 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
558 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
560 dbg("0x21:0x20:0:0 %d", i);
562 /* change control lines if we are switching to or from B0 */
563 spin_lock_irqsave(&priv->lock, flags);
564 control = priv->line_control;
565 if ((cflag & CBAUD) == B0)
566 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
568 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
569 if (control != priv->line_control) {
570 control = priv->line_control;
571 spin_unlock_irqrestore(&priv->lock, flags);
572 set_control_lines(serial->dev, control);
574 spin_unlock_irqrestore(&priv->lock, flags);
577 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
579 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
580 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
582 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
583 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
585 if (cflag & CRTSCTS) {
587 if (priv->type == HX)
591 i = usb_control_msg(serial->dev,
592 usb_sndctrlpipe(serial->dev, 0),
593 VENDOR_WRITE_REQUEST,
594 VENDOR_WRITE_REQUEST_TYPE,
595 0x0, index, NULL, 0, 100);
596 dbg("0x40:0x1:0x0:0x%x %d", index, i);
598 i = usb_control_msg(serial->dev,
599 usb_sndctrlpipe(serial->dev, 0),
600 VENDOR_WRITE_REQUEST,
601 VENDOR_WRITE_REQUEST_TYPE,
602 0x0, 0x0, NULL, 0, 100);
603 dbg ("0x40:0x1:0x0:0x0 %d", i);
606 /* FIXME: Need to read back resulting baud rate */
608 tty_encode_baud_rate(port->tty, baud, baud);
613 static void pl2303_close(struct usb_serial_port *port, struct file *filp)
615 struct pl2303_private *priv = usb_get_serial_port_data(port);
617 unsigned int c_cflag;
622 dbg("%s - port %d", __FUNCTION__, port->number);
624 /* wait for data to drain from the buffer */
625 spin_lock_irqsave(&priv->lock, flags);
626 timeout = PL2303_CLOSING_WAIT;
627 init_waitqueue_entry(&wait, current);
628 add_wait_queue(&port->tty->write_wait, &wait);
630 set_current_state(TASK_INTERRUPTIBLE);
631 if (pl2303_buf_data_avail(priv->buf) == 0 ||
632 timeout == 0 || signal_pending(current) ||
633 !usb_get_intfdata(port->serial->interface)) /* disconnect */
635 spin_unlock_irqrestore(&priv->lock, flags);
636 timeout = schedule_timeout(timeout);
637 spin_lock_irqsave(&priv->lock, flags);
639 set_current_state(TASK_RUNNING);
640 remove_wait_queue(&port->tty->write_wait, &wait);
641 /* clear out any remaining data in the buffer */
642 pl2303_buf_clear(priv->buf);
643 spin_unlock_irqrestore(&priv->lock, flags);
645 /* wait for characters to drain from the device */
646 /* (this is long enough for the entire 256 byte */
647 /* pl2303 hardware buffer to drain with no flow */
648 /* control for data rates of 1200 bps or more, */
649 /* for lower rates we should really know how much */
650 /* data is in the buffer to compute a delay */
651 /* that is not unnecessarily long) */
652 bps = tty_get_baud_rate(port->tty);
654 timeout = max((HZ*2560)/bps,HZ/10);
657 schedule_timeout_interruptible(timeout);
659 /* shutdown our urbs */
660 dbg("%s - shutting down urbs", __FUNCTION__);
661 usb_kill_urb(port->write_urb);
662 usb_kill_urb(port->read_urb);
663 usb_kill_urb(port->interrupt_in_urb);
666 c_cflag = port->tty->termios->c_cflag;
667 if (c_cflag & HUPCL) {
668 /* drop DTR and RTS */
669 spin_lock_irqsave(&priv->lock, flags);
670 priv->line_control = 0;
671 spin_unlock_irqrestore(&priv->lock, flags);
672 set_control_lines(port->serial->dev, 0);
677 static int pl2303_open(struct usb_serial_port *port, struct file *filp)
679 struct ktermios tmp_termios;
680 struct usb_serial *serial = port->serial;
681 struct pl2303_private *priv = usb_get_serial_port_data(port);
685 dbg("%s - port %d", __FUNCTION__, port->number);
687 if (priv->type != HX) {
688 usb_clear_halt(serial->dev, port->write_urb->pipe);
689 usb_clear_halt(serial->dev, port->read_urb->pipe);
692 buf = kmalloc(10, GFP_KERNEL);
696 #define FISH(a,b,c,d) \
697 result=usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev,0), \
698 b, a, c, d, buf, 1, 100); \
699 dbg("0x%x:0x%x:0x%x:0x%x %d - %x",a,b,c,d,result,buf[0]);
701 #define SOUP(a,b,c,d) \
702 result=usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev,0), \
703 b, a, c, d, NULL, 0, 100); \
704 dbg("0x%x:0x%x:0x%x:0x%x %d",a,b,c,d,result);
706 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
707 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 0);
708 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
709 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
710 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
711 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0x0404, 1);
712 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8484, 0);
713 FISH (VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, 0x8383, 0);
714 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 0, 1);
715 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 1, 0);
717 if (priv->type == HX) {
719 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x44);
720 /* reset upstream data pipes */
721 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 8, 0);
722 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 9, 0);
724 SOUP (VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, 2, 0x24);
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");