tty: Bring the usb tty port structure into more use
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / usb / serial / pl2303.c
blobe02dc3d643c7ae1279f467b21584e2899a82dfb7
1 /*
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
14 * driver
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>
32 #include "pl2303.h"
35 * Version Information
37 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
39 static int debug;
41 #define PL2303_CLOSING_WAIT (30*HZ)
43 #define PL2303_BUF_SIZE 1024
44 #define PL2303_TMP_BUF_SIZE 1024
46 struct pl2303_buf {
47 unsigned int buf_size;
48 char *buf_buf;
49 char *buf_get;
50 char *buf_put;
53 static struct usb_device_id id_table [] = {
54 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
55 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
56 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
57 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
58 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
59 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
60 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
61 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
62 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
63 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
64 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
65 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
66 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
67 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
68 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
69 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
70 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
71 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
72 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
73 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
74 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
75 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
76 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
77 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
78 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
79 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
80 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
81 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
82 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
83 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
84 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
85 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
86 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
87 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
88 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
89 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
90 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
91 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
92 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
93 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
94 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
95 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
96 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
97 { } /* Terminating entry */
100 MODULE_DEVICE_TABLE(usb, id_table);
102 static struct usb_driver pl2303_driver = {
103 .name = "pl2303",
104 .probe = usb_serial_probe,
105 .disconnect = usb_serial_disconnect,
106 .id_table = id_table,
107 .suspend = usb_serial_suspend,
108 .resume = usb_serial_resume,
109 .no_dynamic_id = 1,
110 .supports_autosuspend = 1,
113 #define SET_LINE_REQUEST_TYPE 0x21
114 #define SET_LINE_REQUEST 0x20
116 #define SET_CONTROL_REQUEST_TYPE 0x21
117 #define SET_CONTROL_REQUEST 0x22
118 #define CONTROL_DTR 0x01
119 #define CONTROL_RTS 0x02
121 #define BREAK_REQUEST_TYPE 0x21
122 #define BREAK_REQUEST 0x23
123 #define BREAK_ON 0xffff
124 #define BREAK_OFF 0x0000
126 #define GET_LINE_REQUEST_TYPE 0xa1
127 #define GET_LINE_REQUEST 0x21
129 #define VENDOR_WRITE_REQUEST_TYPE 0x40
130 #define VENDOR_WRITE_REQUEST 0x01
132 #define VENDOR_READ_REQUEST_TYPE 0xc0
133 #define VENDOR_READ_REQUEST 0x01
135 #define UART_STATE 0x08
136 #define UART_STATE_TRANSIENT_MASK 0x74
137 #define UART_DCD 0x01
138 #define UART_DSR 0x02
139 #define UART_BREAK_ERROR 0x04
140 #define UART_RING 0x08
141 #define UART_FRAME_ERROR 0x10
142 #define UART_PARITY_ERROR 0x20
143 #define UART_OVERRUN_ERROR 0x40
144 #define UART_CTS 0x80
147 enum pl2303_type {
148 type_0, /* don't know the difference between type 0 and */
149 type_1, /* type 1, until someone from prolific tells us... */
150 HX, /* HX version of the pl2303 chip */
153 struct pl2303_private {
154 spinlock_t lock;
155 struct pl2303_buf *buf;
156 int write_urb_in_use;
157 wait_queue_head_t delta_msr_wait;
158 u8 line_control;
159 u8 line_status;
160 enum pl2303_type type;
164 * pl2303_buf_alloc
166 * Allocate a circular buffer and all associated memory.
168 static struct pl2303_buf *pl2303_buf_alloc(unsigned int size)
170 struct pl2303_buf *pb;
172 if (size == 0)
173 return NULL;
175 pb = kmalloc(sizeof(struct pl2303_buf), GFP_KERNEL);
176 if (pb == NULL)
177 return NULL;
179 pb->buf_buf = kmalloc(size, GFP_KERNEL);
180 if (pb->buf_buf == NULL) {
181 kfree(pb);
182 return NULL;
185 pb->buf_size = size;
186 pb->buf_get = pb->buf_put = pb->buf_buf;
188 return pb;
192 * pl2303_buf_free
194 * Free the buffer and all associated memory.
196 static void pl2303_buf_free(struct pl2303_buf *pb)
198 if (pb) {
199 kfree(pb->buf_buf);
200 kfree(pb);
205 * pl2303_buf_clear
207 * Clear out all data in the circular buffer.
209 static void pl2303_buf_clear(struct pl2303_buf *pb)
211 if (pb != NULL)
212 pb->buf_get = pb->buf_put;
213 /* equivalent to a get of all data available */
217 * pl2303_buf_data_avail
219 * Return the number of bytes of data available in the circular
220 * buffer.
222 static unsigned int pl2303_buf_data_avail(struct pl2303_buf *pb)
224 if (pb == NULL)
225 return 0;
227 return (pb->buf_size + pb->buf_put - pb->buf_get) % pb->buf_size;
231 * pl2303_buf_space_avail
233 * Return the number of bytes of space available in the circular
234 * buffer.
236 static unsigned int pl2303_buf_space_avail(struct pl2303_buf *pb)
238 if (pb == NULL)
239 return 0;
241 return (pb->buf_size + pb->buf_get - pb->buf_put - 1) % pb->buf_size;
245 * pl2303_buf_put
247 * Copy data data from a user buffer and put it into the circular buffer.
248 * Restrict to the amount of space available.
250 * Return the number of bytes copied.
252 static unsigned int pl2303_buf_put(struct pl2303_buf *pb, const char *buf,
253 unsigned int count)
255 unsigned int len;
257 if (pb == NULL)
258 return 0;
260 len = pl2303_buf_space_avail(pb);
261 if (count > len)
262 count = len;
264 if (count == 0)
265 return 0;
267 len = pb->buf_buf + pb->buf_size - pb->buf_put;
268 if (count > len) {
269 memcpy(pb->buf_put, buf, len);
270 memcpy(pb->buf_buf, buf+len, count - len);
271 pb->buf_put = pb->buf_buf + count - len;
272 } else {
273 memcpy(pb->buf_put, buf, count);
274 if (count < len)
275 pb->buf_put += count;
276 else /* count == len */
277 pb->buf_put = pb->buf_buf;
280 return count;
284 * pl2303_buf_get
286 * Get data from the circular buffer and copy to the given buffer.
287 * Restrict to the amount of data available.
289 * Return the number of bytes copied.
291 static unsigned int pl2303_buf_get(struct pl2303_buf *pb, char *buf,
292 unsigned int count)
294 unsigned int len;
296 if (pb == NULL)
297 return 0;
299 len = pl2303_buf_data_avail(pb);
300 if (count > len)
301 count = len;
303 if (count == 0)
304 return 0;
306 len = pb->buf_buf + pb->buf_size - pb->buf_get;
307 if (count > len) {
308 memcpy(buf, pb->buf_get, len);
309 memcpy(buf+len, pb->buf_buf, count - len);
310 pb->buf_get = pb->buf_buf + count - len;
311 } else {
312 memcpy(buf, pb->buf_get, count);
313 if (count < len)
314 pb->buf_get += count;
315 else /* count == len */
316 pb->buf_get = pb->buf_buf;
319 return count;
322 static int pl2303_vendor_read(__u16 value, __u16 index,
323 struct usb_serial *serial, unsigned char *buf)
325 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
326 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
327 value, index, buf, 1, 100);
328 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
329 VENDOR_READ_REQUEST, value, index, res, buf[0]);
330 return res;
333 static int pl2303_vendor_write(__u16 value, __u16 index,
334 struct usb_serial *serial)
336 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
337 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
338 value, index, NULL, 0, 100);
339 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
340 VENDOR_WRITE_REQUEST, value, index, res);
341 return res;
344 static int pl2303_startup(struct usb_serial *serial)
346 struct pl2303_private *priv;
347 enum pl2303_type type = type_0;
348 unsigned char *buf;
349 int i;
351 buf = kmalloc(10, GFP_KERNEL);
352 if (buf == NULL)
353 return -ENOMEM;
355 if (serial->dev->descriptor.bDeviceClass == 0x02)
356 type = type_0;
357 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
358 type = HX;
359 else if (serial->dev->descriptor.bDeviceClass == 0x00)
360 type = type_1;
361 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
362 type = type_1;
363 dbg("device type: %d", type);
365 for (i = 0; i < serial->num_ports; ++i) {
366 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
367 if (!priv)
368 goto cleanup;
369 spin_lock_init(&priv->lock);
370 priv->buf = pl2303_buf_alloc(PL2303_BUF_SIZE);
371 if (priv->buf == NULL) {
372 kfree(priv);
373 goto cleanup;
375 init_waitqueue_head(&priv->delta_msr_wait);
376 priv->type = type;
377 usb_set_serial_port_data(serial->port[i], priv);
380 pl2303_vendor_read(0x8484, 0, serial, buf);
381 pl2303_vendor_write(0x0404, 0, serial);
382 pl2303_vendor_read(0x8484, 0, serial, buf);
383 pl2303_vendor_read(0x8383, 0, serial, buf);
384 pl2303_vendor_read(0x8484, 0, serial, buf);
385 pl2303_vendor_write(0x0404, 1, serial);
386 pl2303_vendor_read(0x8484, 0, serial, buf);
387 pl2303_vendor_read(0x8383, 0, serial, buf);
388 pl2303_vendor_write(0, 1, serial);
389 pl2303_vendor_write(1, 0, serial);
390 if (type == HX)
391 pl2303_vendor_write(2, 0x44, serial);
392 else
393 pl2303_vendor_write(2, 0x24, serial);
395 kfree(buf);
396 return 0;
398 cleanup:
399 kfree(buf);
400 for (--i; i >= 0; --i) {
401 priv = usb_get_serial_port_data(serial->port[i]);
402 pl2303_buf_free(priv->buf);
403 kfree(priv);
404 usb_set_serial_port_data(serial->port[i], NULL);
406 return -ENOMEM;
409 static int set_control_lines(struct usb_device *dev, u8 value)
411 int retval;
413 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
414 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
415 value, 0, NULL, 0, 100);
416 dbg("%s - value = %d, retval = %d", __func__, value, retval);
417 return retval;
420 static void pl2303_send(struct usb_serial_port *port)
422 int count, result;
423 struct pl2303_private *priv = usb_get_serial_port_data(port);
424 unsigned long flags;
426 dbg("%s - port %d", __func__, port->number);
428 spin_lock_irqsave(&priv->lock, flags);
430 if (priv->write_urb_in_use) {
431 spin_unlock_irqrestore(&priv->lock, flags);
432 return;
435 count = pl2303_buf_get(priv->buf, port->write_urb->transfer_buffer,
436 port->bulk_out_size);
438 if (count == 0) {
439 spin_unlock_irqrestore(&priv->lock, flags);
440 return;
443 priv->write_urb_in_use = 1;
445 spin_unlock_irqrestore(&priv->lock, flags);
447 usb_serial_debug_data(debug, &port->dev, __func__, count,
448 port->write_urb->transfer_buffer);
450 port->write_urb->transfer_buffer_length = count;
451 port->write_urb->dev = port->serial->dev;
452 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
453 if (result) {
454 dev_err(&port->dev, "%s - failed submitting write urb,"
455 " error %d\n", __func__, result);
456 priv->write_urb_in_use = 0;
457 /* TODO: reschedule pl2303_send */
460 usb_serial_port_softint(port);
463 static int pl2303_write(struct tty_struct *tty, struct usb_serial_port *port,
464 const unsigned char *buf, int count)
466 struct pl2303_private *priv = usb_get_serial_port_data(port);
467 unsigned long flags;
469 dbg("%s - port %d, %d bytes", __func__, port->number, count);
471 if (!count)
472 return count;
474 spin_lock_irqsave(&priv->lock, flags);
475 count = pl2303_buf_put(priv->buf, buf, count);
476 spin_unlock_irqrestore(&priv->lock, flags);
478 pl2303_send(port);
480 return count;
483 static int pl2303_write_room(struct tty_struct *tty)
485 struct usb_serial_port *port = tty->driver_data;
486 struct pl2303_private *priv = usb_get_serial_port_data(port);
487 int room = 0;
488 unsigned long flags;
490 dbg("%s - port %d", __func__, port->number);
492 spin_lock_irqsave(&priv->lock, flags);
493 room = pl2303_buf_space_avail(priv->buf);
494 spin_unlock_irqrestore(&priv->lock, flags);
496 dbg("%s - returns %d", __func__, room);
497 return room;
500 static int pl2303_chars_in_buffer(struct tty_struct *tty)
502 struct usb_serial_port *port = tty->driver_data;
503 struct pl2303_private *priv = usb_get_serial_port_data(port);
504 int chars = 0;
505 unsigned long flags;
507 dbg("%s - port %d", __func__, port->number);
509 spin_lock_irqsave(&priv->lock, flags);
510 chars = pl2303_buf_data_avail(priv->buf);
511 spin_unlock_irqrestore(&priv->lock, flags);
513 dbg("%s - returns %d", __func__, chars);
514 return chars;
517 static void pl2303_set_termios(struct tty_struct *tty,
518 struct usb_serial_port *port, struct ktermios *old_termios)
520 struct usb_serial *serial = port->serial;
521 struct pl2303_private *priv = usb_get_serial_port_data(port);
522 unsigned long flags;
523 unsigned int cflag;
524 unsigned char *buf;
525 int baud;
526 int i;
527 u8 control;
529 dbg("%s - port %d", __func__, port->number);
531 /* The PL2303 is reported to lose bytes if you change
532 serial settings even to the same values as before. Thus
533 we actually need to filter in this specific case */
535 if (!tty_termios_hw_change(tty->termios, old_termios))
536 return;
538 cflag = tty->termios->c_cflag;
540 buf = kzalloc(7, GFP_KERNEL);
541 if (!buf) {
542 dev_err(&port->dev, "%s - out of memory.\n", __func__);
543 /* Report back no change occurred */
544 *tty->termios = *old_termios;
545 return;
548 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
549 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
550 0, 0, buf, 7, 100);
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]);
554 if (cflag & CSIZE) {
555 switch (cflag & CSIZE) {
556 case CS5:
557 buf[6] = 5;
558 break;
559 case CS6:
560 buf[6] = 6;
561 break;
562 case CS7:
563 buf[6] = 7;
564 break;
565 default:
566 case CS8:
567 buf[6] = 8;
568 break;
570 dbg("%s - data bits = %d", __func__, buf[6]);
573 baud = tty_get_baud_rate(tty);
574 dbg("%s - baud = %d", __func__, baud);
575 if (baud) {
576 buf[0] = baud & 0xff;
577 buf[1] = (baud >> 8) & 0xff;
578 buf[2] = (baud >> 16) & 0xff;
579 buf[3] = (baud >> 24) & 0xff;
582 /* For reference buf[4]=0 is 1 stop bits */
583 /* For reference buf[4]=1 is 1.5 stop bits */
584 /* For reference buf[4]=2 is 2 stop bits */
585 if (cflag & CSTOPB) {
586 buf[4] = 2;
587 dbg("%s - stop bits = 2", __func__);
588 } else {
589 buf[4] = 0;
590 dbg("%s - stop bits = 1", __func__);
593 if (cflag & PARENB) {
594 /* For reference buf[5]=0 is none parity */
595 /* For reference buf[5]=1 is odd parity */
596 /* For reference buf[5]=2 is even parity */
597 /* For reference buf[5]=3 is mark parity */
598 /* For reference buf[5]=4 is space parity */
599 if (cflag & PARODD) {
600 buf[5] = 1;
601 dbg("%s - parity = odd", __func__);
602 } else {
603 buf[5] = 2;
604 dbg("%s - parity = even", __func__);
606 } else {
607 buf[5] = 0;
608 dbg("%s - parity = none", __func__);
611 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
612 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
613 0, 0, buf, 7, 100);
614 dbg("0x21:0x20:0:0 %d", i);
616 /* change control lines if we are switching to or from B0 */
617 spin_lock_irqsave(&priv->lock, flags);
618 control = priv->line_control;
619 if ((cflag & CBAUD) == B0)
620 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
621 else
622 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
623 if (control != priv->line_control) {
624 control = priv->line_control;
625 spin_unlock_irqrestore(&priv->lock, flags);
626 set_control_lines(serial->dev, control);
627 } else {
628 spin_unlock_irqrestore(&priv->lock, flags);
631 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
633 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
634 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
635 0, 0, buf, 7, 100);
636 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
637 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
639 if (cflag & CRTSCTS) {
640 if (priv->type == HX)
641 pl2303_vendor_write(0x0, 0x61, serial);
642 else
643 pl2303_vendor_write(0x0, 0x41, serial);
644 } else {
645 pl2303_vendor_write(0x0, 0x0, serial);
648 /* FIXME: Need to read back resulting baud rate */
649 if (baud)
650 tty_encode_baud_rate(tty, baud, baud);
652 kfree(buf);
655 static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
657 struct pl2303_private *priv = usb_get_serial_port_data(port);
658 unsigned long flags;
659 u8 control;
661 spin_lock_irqsave(&priv->lock, flags);
662 /* Change DTR and RTS */
663 if (on)
664 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
665 else
666 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
667 control = priv->line_control;
668 spin_unlock_irqrestore(&priv->lock, flags);
669 set_control_lines(port->serial->dev, control);
672 static void pl2303_close(struct usb_serial_port *port)
674 struct pl2303_private *priv = usb_get_serial_port_data(port);
675 unsigned long flags;
677 dbg("%s - port %d", __func__, port->number);
679 spin_lock_irqsave(&priv->lock, flags);
680 /* clear out any remaining data in the buffer */
681 pl2303_buf_clear(priv->buf);
682 spin_unlock_irqrestore(&priv->lock, flags);
684 /* shutdown our urbs */
685 dbg("%s - shutting down urbs", __func__);
686 usb_kill_urb(port->write_urb);
687 usb_kill_urb(port->read_urb);
688 usb_kill_urb(port->interrupt_in_urb);
692 static int pl2303_open(struct tty_struct *tty,
693 struct usb_serial_port *port, struct file *filp)
695 struct ktermios tmp_termios;
696 struct usb_serial *serial = port->serial;
697 struct pl2303_private *priv = usb_get_serial_port_data(port);
698 int result;
700 dbg("%s - port %d", __func__, port->number);
702 if (priv->type != HX) {
703 usb_clear_halt(serial->dev, port->write_urb->pipe);
704 usb_clear_halt(serial->dev, port->read_urb->pipe);
705 } else {
706 /* reset upstream data pipes */
707 pl2303_vendor_write(8, 0, serial);
708 pl2303_vendor_write(9, 0, serial);
711 /* Setup termios */
712 if (tty)
713 pl2303_set_termios(tty, port, &tmp_termios);
715 /* FIXME: need to assert RTS and DTR if CRTSCTS off */
717 dbg("%s - submitting read urb", __func__);
718 port->read_urb->dev = serial->dev;
719 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
720 if (result) {
721 dev_err(&port->dev, "%s - failed submitting read urb,"
722 " error %d\n", __func__, result);
723 pl2303_close(port);
724 return -EPROTO;
727 dbg("%s - submitting interrupt urb", __func__);
728 port->interrupt_in_urb->dev = serial->dev;
729 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
730 if (result) {
731 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
732 " error %d\n", __func__, result);
733 pl2303_close(port);
734 return -EPROTO;
736 port->port.drain_delay = 256;
737 return 0;
740 static int pl2303_tiocmset(struct tty_struct *tty, struct file *file,
741 unsigned int set, unsigned int clear)
743 struct usb_serial_port *port = tty->driver_data;
744 struct pl2303_private *priv = usb_get_serial_port_data(port);
745 unsigned long flags;
746 u8 control;
748 if (!usb_get_intfdata(port->serial->interface))
749 return -ENODEV;
751 spin_lock_irqsave(&priv->lock, flags);
752 if (set & TIOCM_RTS)
753 priv->line_control |= CONTROL_RTS;
754 if (set & TIOCM_DTR)
755 priv->line_control |= CONTROL_DTR;
756 if (clear & TIOCM_RTS)
757 priv->line_control &= ~CONTROL_RTS;
758 if (clear & TIOCM_DTR)
759 priv->line_control &= ~CONTROL_DTR;
760 control = priv->line_control;
761 spin_unlock_irqrestore(&priv->lock, flags);
763 return set_control_lines(port->serial->dev, control);
766 static int pl2303_tiocmget(struct tty_struct *tty, struct file *file)
768 struct usb_serial_port *port = tty->driver_data;
769 struct pl2303_private *priv = usb_get_serial_port_data(port);
770 unsigned long flags;
771 unsigned int mcr;
772 unsigned int status;
773 unsigned int result;
775 dbg("%s (%d)", __func__, port->number);
777 if (!usb_get_intfdata(port->serial->interface))
778 return -ENODEV;
780 spin_lock_irqsave(&priv->lock, flags);
781 mcr = priv->line_control;
782 status = priv->line_status;
783 spin_unlock_irqrestore(&priv->lock, flags);
785 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
786 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
787 | ((status & UART_CTS) ? TIOCM_CTS : 0)
788 | ((status & UART_DSR) ? TIOCM_DSR : 0)
789 | ((status & UART_RING) ? TIOCM_RI : 0)
790 | ((status & UART_DCD) ? TIOCM_CD : 0);
792 dbg("%s - result = %x", __func__, result);
794 return result;
797 static int pl2303_carrier_raised(struct usb_serial_port *port)
799 struct pl2303_private *priv = usb_get_serial_port_data(port);
800 if (priv->line_status & UART_DCD)
801 return 1;
802 return 0;
805 static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
807 struct pl2303_private *priv = usb_get_serial_port_data(port);
808 unsigned long flags;
809 unsigned int prevstatus;
810 unsigned int status;
811 unsigned int changed;
813 spin_lock_irqsave(&priv->lock, flags);
814 prevstatus = priv->line_status;
815 spin_unlock_irqrestore(&priv->lock, flags);
817 while (1) {
818 interruptible_sleep_on(&priv->delta_msr_wait);
819 /* see if a signal did it */
820 if (signal_pending(current))
821 return -ERESTARTSYS;
823 spin_lock_irqsave(&priv->lock, flags);
824 status = priv->line_status;
825 spin_unlock_irqrestore(&priv->lock, flags);
827 changed = prevstatus ^ status;
829 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
830 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
831 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
832 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
833 return 0;
835 prevstatus = status;
837 /* NOTREACHED */
838 return 0;
841 static int pl2303_ioctl(struct tty_struct *tty, struct file *file,
842 unsigned int cmd, unsigned long arg)
844 struct usb_serial_port *port = tty->driver_data;
845 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
847 switch (cmd) {
848 case TIOCMIWAIT:
849 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
850 return wait_modem_info(port, arg);
851 default:
852 dbg("%s not supported = 0x%04x", __func__, cmd);
853 break;
855 return -ENOIOCTLCMD;
858 static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
860 struct usb_serial_port *port = tty->driver_data;
861 struct usb_serial *serial = port->serial;
862 u16 state;
863 int result;
865 dbg("%s - port %d", __func__, port->number);
867 if (break_state == 0)
868 state = BREAK_OFF;
869 else
870 state = BREAK_ON;
871 dbg("%s - turning break %s", __func__,
872 state == BREAK_OFF ? "off" : "on");
874 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
875 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
876 0, NULL, 0, 100);
877 if (result)
878 dbg("%s - error sending break = %d", __func__, result);
881 static void pl2303_shutdown(struct usb_serial *serial)
883 int i;
884 struct pl2303_private *priv;
886 dbg("%s", __func__);
888 for (i = 0; i < serial->num_ports; ++i) {
889 priv = usb_get_serial_port_data(serial->port[i]);
890 if (priv) {
891 pl2303_buf_free(priv->buf);
892 kfree(priv);
893 usb_set_serial_port_data(serial->port[i], NULL);
898 static void pl2303_update_line_status(struct usb_serial_port *port,
899 unsigned char *data,
900 unsigned int actual_length)
903 struct pl2303_private *priv = usb_get_serial_port_data(port);
904 unsigned long flags;
905 u8 status_idx = UART_STATE;
906 u8 length = UART_STATE + 1;
907 u16 idv, idp;
909 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
910 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
913 if (idv == SIEMENS_VENDOR_ID) {
914 if (idp == SIEMENS_PRODUCT_ID_X65 ||
915 idp == SIEMENS_PRODUCT_ID_SX1 ||
916 idp == SIEMENS_PRODUCT_ID_X75) {
918 length = 1;
919 status_idx = 0;
923 if (actual_length < length)
924 return;
926 /* Save off the uart status for others to look at */
927 spin_lock_irqsave(&priv->lock, flags);
928 priv->line_status = data[status_idx];
929 spin_unlock_irqrestore(&priv->lock, flags);
930 wake_up_interruptible(&priv->delta_msr_wait);
933 static void pl2303_read_int_callback(struct urb *urb)
935 struct usb_serial_port *port = urb->context;
936 unsigned char *data = urb->transfer_buffer;
937 unsigned int actual_length = urb->actual_length;
938 int status = urb->status;
939 int retval;
941 dbg("%s (%d)", __func__, port->number);
943 switch (status) {
944 case 0:
945 /* success */
946 break;
947 case -ECONNRESET:
948 case -ENOENT:
949 case -ESHUTDOWN:
950 /* this urb is terminated, clean up */
951 dbg("%s - urb shutting down with status: %d", __func__,
952 status);
953 return;
954 default:
955 dbg("%s - nonzero urb status received: %d", __func__,
956 status);
957 goto exit;
960 usb_serial_debug_data(debug, &port->dev, __func__,
961 urb->actual_length, urb->transfer_buffer);
963 pl2303_update_line_status(port, data, actual_length);
965 exit:
966 retval = usb_submit_urb(urb, GFP_ATOMIC);
967 if (retval)
968 dev_err(&urb->dev->dev,
969 "%s - usb_submit_urb failed with result %d\n",
970 __func__, retval);
973 static void pl2303_read_bulk_callback(struct urb *urb)
975 struct usb_serial_port *port = urb->context;
976 struct pl2303_private *priv = usb_get_serial_port_data(port);
977 struct tty_struct *tty;
978 unsigned char *data = urb->transfer_buffer;
979 unsigned long flags;
980 int i;
981 int result;
982 int status = urb->status;
983 u8 line_status;
984 char tty_flag;
986 dbg("%s - port %d", __func__, port->number);
988 if (status) {
989 dbg("%s - urb status = %d", __func__, status);
990 if (!port->port.count) {
991 dbg("%s - port is closed, exiting.", __func__);
992 return;
994 if (status == -EPROTO) {
995 /* PL2303 mysteriously fails with -EPROTO reschedule
996 * the read */
997 dbg("%s - caught -EPROTO, resubmitting the urb",
998 __func__);
999 urb->dev = port->serial->dev;
1000 result = usb_submit_urb(urb, GFP_ATOMIC);
1001 if (result)
1002 dev_err(&urb->dev->dev, "%s - failed"
1003 " resubmitting read urb, error %d\n",
1004 __func__, result);
1005 return;
1007 dbg("%s - unable to handle the error, exiting.", __func__);
1008 return;
1011 usb_serial_debug_data(debug, &port->dev, __func__,
1012 urb->actual_length, data);
1014 /* get tty_flag from status */
1015 tty_flag = TTY_NORMAL;
1017 spin_lock_irqsave(&priv->lock, flags);
1018 line_status = priv->line_status;
1019 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1020 spin_unlock_irqrestore(&priv->lock, flags);
1021 wake_up_interruptible(&priv->delta_msr_wait);
1023 /* break takes precedence over parity, */
1024 /* which takes precedence over framing errors */
1025 if (line_status & UART_BREAK_ERROR)
1026 tty_flag = TTY_BREAK;
1027 else if (line_status & UART_PARITY_ERROR)
1028 tty_flag = TTY_PARITY;
1029 else if (line_status & UART_FRAME_ERROR)
1030 tty_flag = TTY_FRAME;
1031 dbg("%s - tty_flag = %d", __func__, tty_flag);
1033 tty = tty_port_tty_get(&port->port);
1034 if (tty && urb->actual_length) {
1035 tty_buffer_request_room(tty, urb->actual_length + 1);
1036 /* overrun is special, not associated with a char */
1037 if (line_status & UART_OVERRUN_ERROR)
1038 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1039 for (i = 0; i < urb->actual_length; ++i)
1040 tty_insert_flip_char(tty, data[i], tty_flag);
1041 tty_flip_buffer_push(tty);
1043 tty_kref_put(tty);
1044 /* Schedule the next read _if_ we are still open */
1045 if (port->port.count) {
1046 urb->dev = port->serial->dev;
1047 result = usb_submit_urb(urb, GFP_ATOMIC);
1048 if (result)
1049 dev_err(&urb->dev->dev, "%s - failed resubmitting"
1050 " read urb, error %d\n", __func__, result);
1053 return;
1056 static void pl2303_write_bulk_callback(struct urb *urb)
1058 struct usb_serial_port *port = urb->context;
1059 struct pl2303_private *priv = usb_get_serial_port_data(port);
1060 int result;
1061 int status = urb->status;
1063 dbg("%s - port %d", __func__, port->number);
1065 switch (status) {
1066 case 0:
1067 /* success */
1068 break;
1069 case -ECONNRESET:
1070 case -ENOENT:
1071 case -ESHUTDOWN:
1072 /* this urb is terminated, clean up */
1073 dbg("%s - urb shutting down with status: %d", __func__,
1074 status);
1075 priv->write_urb_in_use = 0;
1076 return;
1077 default:
1078 /* error in the urb, so we have to resubmit it */
1079 dbg("%s - Overflow in write", __func__);
1080 dbg("%s - nonzero write bulk status received: %d", __func__,
1081 status);
1082 port->write_urb->transfer_buffer_length = 1;
1083 port->write_urb->dev = port->serial->dev;
1084 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1085 if (result)
1086 dev_err(&urb->dev->dev, "%s - failed resubmitting write"
1087 " urb, error %d\n", __func__, result);
1088 else
1089 return;
1092 priv->write_urb_in_use = 0;
1094 /* send any buffered data */
1095 pl2303_send(port);
1098 /* All of the device info needed for the PL2303 SIO serial converter */
1099 static struct usb_serial_driver pl2303_device = {
1100 .driver = {
1101 .owner = THIS_MODULE,
1102 .name = "pl2303",
1104 .id_table = id_table,
1105 .usb_driver = &pl2303_driver,
1106 .num_ports = 1,
1107 .open = pl2303_open,
1108 .close = pl2303_close,
1109 .dtr_rts = pl2303_dtr_rts,
1110 .carrier_raised = pl2303_carrier_raised,
1111 .write = pl2303_write,
1112 .ioctl = pl2303_ioctl,
1113 .break_ctl = pl2303_break_ctl,
1114 .set_termios = pl2303_set_termios,
1115 .tiocmget = pl2303_tiocmget,
1116 .tiocmset = pl2303_tiocmset,
1117 .read_bulk_callback = pl2303_read_bulk_callback,
1118 .read_int_callback = pl2303_read_int_callback,
1119 .write_bulk_callback = pl2303_write_bulk_callback,
1120 .write_room = pl2303_write_room,
1121 .chars_in_buffer = pl2303_chars_in_buffer,
1122 .attach = pl2303_startup,
1123 .shutdown = pl2303_shutdown,
1126 static int __init pl2303_init(void)
1128 int retval;
1130 retval = usb_serial_register(&pl2303_device);
1131 if (retval)
1132 goto failed_usb_serial_register;
1133 retval = usb_register(&pl2303_driver);
1134 if (retval)
1135 goto failed_usb_register;
1136 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1137 return 0;
1138 failed_usb_register:
1139 usb_serial_deregister(&pl2303_device);
1140 failed_usb_serial_register:
1141 return retval;
1144 static void __exit pl2303_exit(void)
1146 usb_deregister(&pl2303_driver);
1147 usb_serial_deregister(&pl2303_device);
1150 module_init(pl2303_init);
1151 module_exit(pl2303_exit);
1153 MODULE_DESCRIPTION(DRIVER_DESC);
1154 MODULE_LICENSE("GPL");
1156 module_param(debug, bool, S_IRUGO | S_IWUSR);
1157 MODULE_PARM_DESC(debug, "Debug enabled or not");