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"
39 static const struct usb_device_id id_table[] = {
40 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
50 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
51 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
52 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
53 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
54 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
55 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
56 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
57 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
58 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
59 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
60 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
61 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
62 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
63 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
64 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
65 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
66 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
67 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
68 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
69 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
70 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
71 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
72 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
73 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
74 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
75 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
76 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
77 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
78 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
79 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
80 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
81 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
82 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
83 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
84 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
85 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
86 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
87 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
88 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
89 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
90 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
91 { } /* Terminating entry */
94 MODULE_DEVICE_TABLE(usb, id_table);
96 #define SET_LINE_REQUEST_TYPE 0x21
97 #define SET_LINE_REQUEST 0x20
99 #define SET_CONTROL_REQUEST_TYPE 0x21
100 #define SET_CONTROL_REQUEST 0x22
101 #define CONTROL_DTR 0x01
102 #define CONTROL_RTS 0x02
104 #define BREAK_REQUEST_TYPE 0x21
105 #define BREAK_REQUEST 0x23
106 #define BREAK_ON 0xffff
107 #define BREAK_OFF 0x0000
109 #define GET_LINE_REQUEST_TYPE 0xa1
110 #define GET_LINE_REQUEST 0x21
112 #define VENDOR_WRITE_REQUEST_TYPE 0x40
113 #define VENDOR_WRITE_REQUEST 0x01
115 #define VENDOR_READ_REQUEST_TYPE 0xc0
116 #define VENDOR_READ_REQUEST 0x01
118 #define UART_STATE 0x08
119 #define UART_STATE_TRANSIENT_MASK 0x74
120 #define UART_DCD 0x01
121 #define UART_DSR 0x02
122 #define UART_BREAK_ERROR 0x04
123 #define UART_RING 0x08
124 #define UART_FRAME_ERROR 0x10
125 #define UART_PARITY_ERROR 0x20
126 #define UART_OVERRUN_ERROR 0x40
127 #define UART_CTS 0x80
131 type_0, /* don't know the difference between type 0 and */
132 type_1, /* type 1, until someone from prolific tells us... */
133 HX, /* HX version of the pl2303 chip */
136 struct pl2303_private {
138 wait_queue_head_t delta_msr_wait;
141 enum pl2303_type type;
144 static int pl2303_vendor_read(__u16 value, __u16 index,
145 struct usb_serial *serial, unsigned char *buf)
147 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
148 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
149 value, index, buf, 1, 100);
150 dev_dbg(&serial->dev->dev, "0x%x:0x%x:0x%x:0x%x %d - %x\n",
151 VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, value, index,
156 static int pl2303_vendor_write(__u16 value, __u16 index,
157 struct usb_serial *serial)
159 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
160 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
161 value, index, NULL, 0, 100);
162 dev_dbg(&serial->dev->dev, "0x%x:0x%x:0x%x:0x%x %d\n",
163 VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, value, index,
168 static int pl2303_startup(struct usb_serial *serial)
170 struct pl2303_private *priv;
171 enum pl2303_type type = type_0;
175 buf = kmalloc(10, GFP_KERNEL);
179 if (serial->dev->descriptor.bDeviceClass == 0x02)
181 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
183 else if (serial->dev->descriptor.bDeviceClass == 0x00)
185 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
187 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
189 for (i = 0; i < serial->num_ports; ++i) {
190 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
193 spin_lock_init(&priv->lock);
194 init_waitqueue_head(&priv->delta_msr_wait);
196 usb_set_serial_port_data(serial->port[i], priv);
199 pl2303_vendor_read(0x8484, 0, serial, buf);
200 pl2303_vendor_write(0x0404, 0, serial);
201 pl2303_vendor_read(0x8484, 0, serial, buf);
202 pl2303_vendor_read(0x8383, 0, serial, buf);
203 pl2303_vendor_read(0x8484, 0, serial, buf);
204 pl2303_vendor_write(0x0404, 1, serial);
205 pl2303_vendor_read(0x8484, 0, serial, buf);
206 pl2303_vendor_read(0x8383, 0, serial, buf);
207 pl2303_vendor_write(0, 1, serial);
208 pl2303_vendor_write(1, 0, serial);
210 pl2303_vendor_write(2, 0x44, serial);
212 pl2303_vendor_write(2, 0x24, serial);
219 for (--i; i >= 0; --i) {
220 priv = usb_get_serial_port_data(serial->port[i]);
222 usb_set_serial_port_data(serial->port[i], NULL);
227 static int set_control_lines(struct usb_device *dev, u8 value)
231 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
232 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
233 value, 0, NULL, 0, 100);
234 dev_dbg(&dev->dev, "%s - value = %d, retval = %d\n", __func__,
239 static void pl2303_set_termios(struct tty_struct *tty,
240 struct usb_serial_port *port, struct ktermios *old_termios)
242 struct usb_serial *serial = port->serial;
243 struct pl2303_private *priv = usb_get_serial_port_data(port);
250 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
251 4800, 7200, 9600, 14400, 19200, 28800, 38400,
252 57600, 115200, 230400, 460800, 614400,
253 921600, 1228800, 2457600, 3000000, 6000000 };
254 int baud_floor, baud_ceil;
257 /* The PL2303 is reported to lose bytes if you change
258 serial settings even to the same values as before. Thus
259 we actually need to filter in this specific case */
261 if (!tty_termios_hw_change(&tty->termios, old_termios))
264 cflag = tty->termios.c_cflag;
266 buf = kzalloc(7, GFP_KERNEL);
268 dev_err(&port->dev, "%s - out of memory.\n", __func__);
269 /* Report back no change occurred */
270 tty->termios = *old_termios;
274 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
275 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
277 dev_dbg(&port->dev, "0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x\n", i,
278 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
281 switch (cflag & CSIZE) {
296 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
299 /* For reference buf[0]:buf[3] baud rate value */
300 /* NOTE: Only the values defined in baud_sup are supported !
301 * => if unsupported values are set, the PL2303 seems to use
302 * 9600 baud (at least my PL2303X always does)
304 baud = tty_get_baud_rate(tty);
305 dev_dbg(&port->dev, "baud requested = %d\n", baud);
307 /* Set baudrate to nearest supported value */
308 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
309 if (baud_sup[k] / baud) {
310 baud_ceil = baud_sup[k];
314 baud_floor = baud_sup[k-1];
315 if ((baud_ceil % baud)
316 > (baud % baud_floor))
324 if (baud > 1228800) {
325 /* type_0, type_1 only support up to 1228800 baud */
326 if (priv->type != HX)
328 else if (baud > 6000000)
331 dev_dbg(&port->dev, "baud set = %d\n", baud);
332 if (baud <= 115200) {
333 buf[0] = baud & 0xff;
334 buf[1] = (baud >> 8) & 0xff;
335 buf[2] = (baud >> 16) & 0xff;
336 buf[3] = (baud >> 24) & 0xff;
338 /* apparently the formula for higher speeds is:
339 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
341 unsigned tmp = 12*1000*1000*32 / baud;
344 buf[1] = (tmp >= 256);
353 /* For reference buf[4]=0 is 1 stop bits */
354 /* For reference buf[4]=1 is 1.5 stop bits */
355 /* For reference buf[4]=2 is 2 stop bits */
356 if (cflag & CSTOPB) {
357 /* NOTE: Comply with "real" UARTs / RS232:
358 * use 1.5 instead of 2 stop bits with 5 data bits
360 if ((cflag & CSIZE) == CS5) {
362 dev_dbg(&port->dev, "stop bits = 1.5\n");
365 dev_dbg(&port->dev, "stop bits = 2\n");
369 dev_dbg(&port->dev, "stop bits = 1\n");
372 if (cflag & PARENB) {
373 /* For reference buf[5]=0 is none parity */
374 /* For reference buf[5]=1 is odd parity */
375 /* For reference buf[5]=2 is even parity */
376 /* For reference buf[5]=3 is mark parity */
377 /* For reference buf[5]=4 is space parity */
378 if (cflag & PARODD) {
379 if (cflag & CMSPAR) {
381 dev_dbg(&port->dev, "parity = mark\n");
384 dev_dbg(&port->dev, "parity = odd\n");
387 if (cflag & CMSPAR) {
389 dev_dbg(&port->dev, "parity = space\n");
392 dev_dbg(&port->dev, "parity = even\n");
397 dev_dbg(&port->dev, "parity = none\n");
400 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
401 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
403 dev_dbg(&port->dev, "0x21:0x20:0:0 %d\n", i);
405 /* change control lines if we are switching to or from B0 */
406 spin_lock_irqsave(&priv->lock, flags);
407 control = priv->line_control;
408 if ((cflag & CBAUD) == B0)
409 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
410 else if ((old_termios->c_cflag & CBAUD) == B0)
411 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
412 if (control != priv->line_control) {
413 control = priv->line_control;
414 spin_unlock_irqrestore(&priv->lock, flags);
415 set_control_lines(serial->dev, control);
417 spin_unlock_irqrestore(&priv->lock, flags);
420 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
422 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
423 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
425 dev_dbg(&port->dev, "0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x\n", i,
426 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
428 if (cflag & CRTSCTS) {
429 if (priv->type == HX)
430 pl2303_vendor_write(0x0, 0x61, serial);
432 pl2303_vendor_write(0x0, 0x41, serial);
434 pl2303_vendor_write(0x0, 0x0, serial);
437 /* Save resulting baud rate */
439 tty_encode_baud_rate(tty, baud, baud);
444 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
446 struct pl2303_private *priv = usb_get_serial_port_data(port);
450 spin_lock_irqsave(&priv->lock, flags);
451 /* Change DTR and RTS */
453 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
455 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
456 control = priv->line_control;
457 spin_unlock_irqrestore(&priv->lock, flags);
458 set_control_lines(port->serial->dev, control);
461 static void pl2303_close(struct usb_serial_port *port)
463 usb_serial_generic_close(port);
464 usb_kill_urb(port->interrupt_in_urb);
467 static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
469 struct ktermios tmp_termios;
470 struct usb_serial *serial = port->serial;
471 struct pl2303_private *priv = usb_get_serial_port_data(port);
474 if (priv->type != HX) {
475 usb_clear_halt(serial->dev, port->write_urb->pipe);
476 usb_clear_halt(serial->dev, port->read_urb->pipe);
478 /* reset upstream data pipes */
479 pl2303_vendor_write(8, 0, serial);
480 pl2303_vendor_write(9, 0, serial);
485 pl2303_set_termios(tty, port, &tmp_termios);
487 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
489 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
490 " error %d\n", __func__, result);
494 result = usb_serial_generic_open(tty, port);
496 usb_kill_urb(port->interrupt_in_urb);
500 port->port.drain_delay = 256;
504 static int pl2303_tiocmset(struct tty_struct *tty,
505 unsigned int set, unsigned int clear)
507 struct usb_serial_port *port = tty->driver_data;
508 struct usb_serial *serial = port->serial;
509 struct pl2303_private *priv = usb_get_serial_port_data(port);
514 spin_lock_irqsave(&priv->lock, flags);
516 priv->line_control |= CONTROL_RTS;
518 priv->line_control |= CONTROL_DTR;
519 if (clear & TIOCM_RTS)
520 priv->line_control &= ~CONTROL_RTS;
521 if (clear & TIOCM_DTR)
522 priv->line_control &= ~CONTROL_DTR;
523 control = priv->line_control;
524 spin_unlock_irqrestore(&priv->lock, flags);
526 mutex_lock(&serial->disc_mutex);
527 if (!serial->disconnected)
528 ret = set_control_lines(serial->dev, control);
531 mutex_unlock(&serial->disc_mutex);
536 static int pl2303_tiocmget(struct tty_struct *tty)
538 struct usb_serial_port *port = tty->driver_data;
539 struct pl2303_private *priv = usb_get_serial_port_data(port);
545 spin_lock_irqsave(&priv->lock, flags);
546 mcr = priv->line_control;
547 status = priv->line_status;
548 spin_unlock_irqrestore(&priv->lock, flags);
550 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
551 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
552 | ((status & UART_CTS) ? TIOCM_CTS : 0)
553 | ((status & UART_DSR) ? TIOCM_DSR : 0)
554 | ((status & UART_RING) ? TIOCM_RI : 0)
555 | ((status & UART_DCD) ? TIOCM_CD : 0);
557 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
562 static int pl2303_carrier_raised(struct usb_serial_port *port)
564 struct pl2303_private *priv = usb_get_serial_port_data(port);
565 if (priv->line_status & UART_DCD)
570 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
572 struct pl2303_private *priv = usb_get_serial_port_data(port);
574 unsigned int prevstatus;
576 unsigned int changed;
578 spin_lock_irqsave(&priv->lock, flags);
579 prevstatus = priv->line_status;
580 spin_unlock_irqrestore(&priv->lock, flags);
583 interruptible_sleep_on(&priv->delta_msr_wait);
584 /* see if a signal did it */
585 if (signal_pending(current))
588 spin_lock_irqsave(&priv->lock, flags);
589 status = priv->line_status;
590 spin_unlock_irqrestore(&priv->lock, flags);
592 changed = prevstatus ^ status;
594 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
595 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
596 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
597 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
606 static int pl2303_ioctl(struct tty_struct *tty,
607 unsigned int cmd, unsigned long arg)
609 struct serial_struct ser;
610 struct usb_serial_port *port = tty->driver_data;
612 dev_dbg(&port->dev, "%s cmd = 0x%04x\n", __func__, cmd);
616 memset(&ser, 0, sizeof ser);
617 ser.type = PORT_16654;
618 ser.line = port->serial->minor;
619 ser.port = port->number;
620 ser.baud_base = 460800;
622 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
628 dev_dbg(&port->dev, "%s TIOCMIWAIT\n", __func__);
629 return wait_modem_info(port, arg);
631 dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
637 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
639 struct usb_serial_port *port = tty->driver_data;
640 struct usb_serial *serial = port->serial;
644 if (break_state == 0)
648 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
649 state == BREAK_OFF ? "off" : "on");
651 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
652 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
655 dev_err(&port->dev, "error sending break = %d\n", result);
658 static void pl2303_release(struct usb_serial *serial)
661 struct pl2303_private *priv;
663 for (i = 0; i < serial->num_ports; ++i) {
664 priv = usb_get_serial_port_data(serial->port[i]);
669 static void pl2303_update_line_status(struct usb_serial_port *port,
671 unsigned int actual_length)
674 struct pl2303_private *priv = usb_get_serial_port_data(port);
675 struct tty_struct *tty;
677 u8 status_idx = UART_STATE;
678 u8 length = UART_STATE + 1;
682 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
683 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
686 if (idv == SIEMENS_VENDOR_ID) {
687 if (idp == SIEMENS_PRODUCT_ID_X65 ||
688 idp == SIEMENS_PRODUCT_ID_SX1 ||
689 idp == SIEMENS_PRODUCT_ID_X75) {
696 if (actual_length < length)
699 /* Save off the uart status for others to look at */
700 spin_lock_irqsave(&priv->lock, flags);
701 prev_line_status = priv->line_status;
702 priv->line_status = data[status_idx];
703 spin_unlock_irqrestore(&priv->lock, flags);
704 if (priv->line_status & UART_BREAK_ERROR)
705 usb_serial_handle_break(port);
706 wake_up_interruptible(&priv->delta_msr_wait);
708 tty = tty_port_tty_get(&port->port);
711 if ((priv->line_status ^ prev_line_status) & UART_DCD)
712 usb_serial_handle_dcd_change(port, tty,
713 priv->line_status & UART_DCD);
717 static void pl2303_read_int_callback(struct urb *urb)
719 struct usb_serial_port *port = urb->context;
720 unsigned char *data = urb->transfer_buffer;
721 unsigned int actual_length = urb->actual_length;
722 int status = urb->status;
732 /* this urb is terminated, clean up */
733 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
737 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
742 usb_serial_debug_data(&port->dev, __func__,
743 urb->actual_length, urb->transfer_buffer);
745 pl2303_update_line_status(port, data, actual_length);
748 retval = usb_submit_urb(urb, GFP_ATOMIC);
751 "%s - usb_submit_urb failed with result %d\n",
755 static void pl2303_process_read_urb(struct urb *urb)
757 struct usb_serial_port *port = urb->context;
758 struct pl2303_private *priv = usb_get_serial_port_data(port);
759 struct tty_struct *tty;
760 unsigned char *data = urb->transfer_buffer;
761 char tty_flag = TTY_NORMAL;
766 /* update line status */
767 spin_lock_irqsave(&priv->lock, flags);
768 line_status = priv->line_status;
769 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
770 spin_unlock_irqrestore(&priv->lock, flags);
771 wake_up_interruptible(&priv->delta_msr_wait);
773 if (!urb->actual_length)
776 tty = tty_port_tty_get(&port->port);
780 /* break takes precedence over parity, */
781 /* which takes precedence over framing errors */
782 if (line_status & UART_BREAK_ERROR)
783 tty_flag = TTY_BREAK;
784 else if (line_status & UART_PARITY_ERROR)
785 tty_flag = TTY_PARITY;
786 else if (line_status & UART_FRAME_ERROR)
787 tty_flag = TTY_FRAME;
788 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__, tty_flag);
790 /* overrun is special, not associated with a char */
791 if (line_status & UART_OVERRUN_ERROR)
792 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
794 if (port->port.console && port->sysrq) {
795 for (i = 0; i < urb->actual_length; ++i)
796 if (!usb_serial_handle_sysrq_char(port, data[i]))
797 tty_insert_flip_char(tty, data[i], tty_flag);
799 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
803 tty_flip_buffer_push(tty);
807 /* All of the device info needed for the PL2303 SIO serial converter */
808 static struct usb_serial_driver pl2303_device = {
810 .owner = THIS_MODULE,
813 .id_table = id_table,
816 .bulk_out_size = 256,
818 .close = pl2303_close,
819 .dtr_rts = pl2303_dtr_rts,
820 .carrier_raised = pl2303_carrier_raised,
821 .ioctl = pl2303_ioctl,
822 .break_ctl = pl2303_break_ctl,
823 .set_termios = pl2303_set_termios,
824 .tiocmget = pl2303_tiocmget,
825 .tiocmset = pl2303_tiocmset,
826 .process_read_urb = pl2303_process_read_urb,
827 .read_int_callback = pl2303_read_int_callback,
828 .attach = pl2303_startup,
829 .release = pl2303_release,
832 static struct usb_serial_driver * const serial_drivers[] = {
836 module_usb_serial_driver(serial_drivers, id_table);
838 MODULE_DESCRIPTION(DRIVER_DESC);
839 MODULE_LICENSE("GPL");