Loading...
1/*
2 * Prolific PL2303 USB to serial adaptor driver
3 *
4 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2003 IBM Corp.
6 *
7 * Original driver for 2.2.x by anonymous
8 *
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.
12 *
13 * See Documentation/usb/usb-serial.txt for more information on using this
14 * driver
15 *
16 */
17
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"
33
34/*
35 * Version Information
36 */
37#define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
38
39static int debug;
40
41#define PL2303_CLOSING_WAIT (30*HZ)
42
43static const struct usb_device_id id_table[] = {
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
49 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
50 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
51 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
52 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
53 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
54 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
55 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
56 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
57 { USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
58 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
59 { USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
60 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
61 { USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
62 { USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
63 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
64 { USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
65 { USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
66 { USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
67 { USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
68 { USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
69 { USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
70 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
71 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
72 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
73 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
74 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
75 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
76 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
77 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
78 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
79 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
80 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
81 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
82 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
83 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
84 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
85 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
86 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
87 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
88 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
89 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
90 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
91 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
92 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
93 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
94 { USB_DEVICE(WINCHIPHEAD_VENDOR_ID, WINCHIPHEAD_USBSER_PRODUCT_ID) },
95 { } /* Terminating entry */
96};
97
98MODULE_DEVICE_TABLE(usb, id_table);
99
100static struct usb_driver pl2303_driver = {
101 .name = "pl2303",
102 .probe = usb_serial_probe,
103 .disconnect = usb_serial_disconnect,
104 .id_table = id_table,
105 .suspend = usb_serial_suspend,
106 .resume = usb_serial_resume,
107 .no_dynamic_id = 1,
108 .supports_autosuspend = 1,
109};
110
111#define SET_LINE_REQUEST_TYPE 0x21
112#define SET_LINE_REQUEST 0x20
113
114#define SET_CONTROL_REQUEST_TYPE 0x21
115#define SET_CONTROL_REQUEST 0x22
116#define CONTROL_DTR 0x01
117#define CONTROL_RTS 0x02
118
119#define BREAK_REQUEST_TYPE 0x21
120#define BREAK_REQUEST 0x23
121#define BREAK_ON 0xffff
122#define BREAK_OFF 0x0000
123
124#define GET_LINE_REQUEST_TYPE 0xa1
125#define GET_LINE_REQUEST 0x21
126
127#define VENDOR_WRITE_REQUEST_TYPE 0x40
128#define VENDOR_WRITE_REQUEST 0x01
129
130#define VENDOR_READ_REQUEST_TYPE 0xc0
131#define VENDOR_READ_REQUEST 0x01
132
133#define UART_STATE 0x08
134#define UART_STATE_TRANSIENT_MASK 0x74
135#define UART_DCD 0x01
136#define UART_DSR 0x02
137#define UART_BREAK_ERROR 0x04
138#define UART_RING 0x08
139#define UART_FRAME_ERROR 0x10
140#define UART_PARITY_ERROR 0x20
141#define UART_OVERRUN_ERROR 0x40
142#define UART_CTS 0x80
143
144
145enum pl2303_type {
146 type_0, /* don't know the difference between type 0 and */
147 type_1, /* type 1, until someone from prolific tells us... */
148 HX, /* HX version of the pl2303 chip */
149};
150
151struct pl2303_private {
152 spinlock_t lock;
153 wait_queue_head_t delta_msr_wait;
154 u8 line_control;
155 u8 line_status;
156 enum pl2303_type type;
157};
158
159static int pl2303_vendor_read(__u16 value, __u16 index,
160 struct usb_serial *serial, unsigned char *buf)
161{
162 int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
163 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
164 value, index, buf, 1, 100);
165 dbg("0x%x:0x%x:0x%x:0x%x %d - %x", VENDOR_READ_REQUEST_TYPE,
166 VENDOR_READ_REQUEST, value, index, res, buf[0]);
167 return res;
168}
169
170static int pl2303_vendor_write(__u16 value, __u16 index,
171 struct usb_serial *serial)
172{
173 int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
174 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
175 value, index, NULL, 0, 100);
176 dbg("0x%x:0x%x:0x%x:0x%x %d", VENDOR_WRITE_REQUEST_TYPE,
177 VENDOR_WRITE_REQUEST, value, index, res);
178 return res;
179}
180
181static int pl2303_startup(struct usb_serial *serial)
182{
183 struct pl2303_private *priv;
184 enum pl2303_type type = type_0;
185 unsigned char *buf;
186 int i;
187
188 buf = kmalloc(10, GFP_KERNEL);
189 if (buf == NULL)
190 return -ENOMEM;
191
192 if (serial->dev->descriptor.bDeviceClass == 0x02)
193 type = type_0;
194 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
195 type = HX;
196 else if (serial->dev->descriptor.bDeviceClass == 0x00)
197 type = type_1;
198 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
199 type = type_1;
200 dbg("device type: %d", type);
201
202 for (i = 0; i < serial->num_ports; ++i) {
203 priv = kzalloc(sizeof(struct pl2303_private), GFP_KERNEL);
204 if (!priv)
205 goto cleanup;
206 spin_lock_init(&priv->lock);
207 init_waitqueue_head(&priv->delta_msr_wait);
208 priv->type = type;
209 usb_set_serial_port_data(serial->port[i], priv);
210 }
211
212 pl2303_vendor_read(0x8484, 0, serial, buf);
213 pl2303_vendor_write(0x0404, 0, serial);
214 pl2303_vendor_read(0x8484, 0, serial, buf);
215 pl2303_vendor_read(0x8383, 0, serial, buf);
216 pl2303_vendor_read(0x8484, 0, serial, buf);
217 pl2303_vendor_write(0x0404, 1, serial);
218 pl2303_vendor_read(0x8484, 0, serial, buf);
219 pl2303_vendor_read(0x8383, 0, serial, buf);
220 pl2303_vendor_write(0, 1, serial);
221 pl2303_vendor_write(1, 0, serial);
222 if (type == HX)
223 pl2303_vendor_write(2, 0x44, serial);
224 else
225 pl2303_vendor_write(2, 0x24, serial);
226
227 kfree(buf);
228 return 0;
229
230cleanup:
231 kfree(buf);
232 for (--i; i >= 0; --i) {
233 priv = usb_get_serial_port_data(serial->port[i]);
234 kfree(priv);
235 usb_set_serial_port_data(serial->port[i], NULL);
236 }
237 return -ENOMEM;
238}
239
240static int set_control_lines(struct usb_device *dev, u8 value)
241{
242 int retval;
243
244 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
245 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
246 value, 0, NULL, 0, 100);
247 dbg("%s - value = %d, retval = %d", __func__, value, retval);
248 return retval;
249}
250
251static void pl2303_set_termios(struct tty_struct *tty,
252 struct usb_serial_port *port, struct ktermios *old_termios)
253{
254 struct usb_serial *serial = port->serial;
255 struct pl2303_private *priv = usb_get_serial_port_data(port);
256 unsigned long flags;
257 unsigned int cflag;
258 unsigned char *buf;
259 int baud;
260 int i;
261 u8 control;
262 const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
263 4800, 7200, 9600, 14400, 19200, 28800, 38400,
264 57600, 115200, 230400, 460800, 614400,
265 921600, 1228800, 2457600, 3000000, 6000000 };
266 int baud_floor, baud_ceil;
267 int k;
268
269 dbg("%s - port %d", __func__, port->number);
270
271 /* The PL2303 is reported to lose bytes if you change
272 serial settings even to the same values as before. Thus
273 we actually need to filter in this specific case */
274
275 if (!tty_termios_hw_change(tty->termios, old_termios))
276 return;
277
278 cflag = tty->termios->c_cflag;
279
280 buf = kzalloc(7, GFP_KERNEL);
281 if (!buf) {
282 dev_err(&port->dev, "%s - out of memory.\n", __func__);
283 /* Report back no change occurred */
284 *tty->termios = *old_termios;
285 return;
286 }
287
288 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
289 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
290 0, 0, buf, 7, 100);
291 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
292 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
293
294 if (cflag & CSIZE) {
295 switch (cflag & CSIZE) {
296 case CS5:
297 buf[6] = 5;
298 break;
299 case CS6:
300 buf[6] = 6;
301 break;
302 case CS7:
303 buf[6] = 7;
304 break;
305 default:
306 case CS8:
307 buf[6] = 8;
308 break;
309 }
310 dbg("%s - data bits = %d", __func__, buf[6]);
311 }
312
313 /* For reference buf[0]:buf[3] baud rate value */
314 /* NOTE: Only the values defined in baud_sup are supported !
315 * => if unsupported values are set, the PL2303 seems to use
316 * 9600 baud (at least my PL2303X always does)
317 */
318 baud = tty_get_baud_rate(tty);
319 dbg("%s - baud requested = %d", __func__, baud);
320 if (baud) {
321 /* Set baudrate to nearest supported value */
322 for (k=0; k<ARRAY_SIZE(baud_sup); k++) {
323 if (baud_sup[k] / baud) {
324 baud_ceil = baud_sup[k];
325 if (k==0) {
326 baud = baud_ceil;
327 } else {
328 baud_floor = baud_sup[k-1];
329 if ((baud_ceil % baud)
330 > (baud % baud_floor))
331 baud = baud_floor;
332 else
333 baud = baud_ceil;
334 }
335 break;
336 }
337 }
338 if (baud > 1228800) {
339 /* type_0, type_1 only support up to 1228800 baud */
340 if (priv->type != HX)
341 baud = 1228800;
342 else if (baud > 6000000)
343 baud = 6000000;
344 }
345 dbg("%s - baud set = %d", __func__, baud);
346 if (baud <= 115200) {
347 buf[0] = baud & 0xff;
348 buf[1] = (baud >> 8) & 0xff;
349 buf[2] = (baud >> 16) & 0xff;
350 buf[3] = (baud >> 24) & 0xff;
351 } else {
352 /* apparently the formula for higher speeds is:
353 * baudrate = 12M * 32 / (2^buf[1]) / buf[0]
354 */
355 unsigned tmp = 12*1000*1000*32 / baud;
356 buf[3] = 0x80;
357 buf[2] = 0;
358 buf[1] = (tmp >= 256);
359 while (tmp >= 256) {
360 tmp >>= 2;
361 buf[1] <<= 1;
362 }
363 if (tmp > 256) {
364 tmp %= 256;
365 }
366 buf[0] = tmp;
367 }
368 }
369
370 /* For reference buf[4]=0 is 1 stop bits */
371 /* For reference buf[4]=1 is 1.5 stop bits */
372 /* For reference buf[4]=2 is 2 stop bits */
373 if (cflag & CSTOPB) {
374 /* NOTE: Comply with "real" UARTs / RS232:
375 * use 1.5 instead of 2 stop bits with 5 data bits
376 */
377 if ((cflag & CSIZE) == CS5) {
378 buf[4] = 1;
379 dbg("%s - stop bits = 1.5", __func__);
380 } else {
381 buf[4] = 2;
382 dbg("%s - stop bits = 2", __func__);
383 }
384 } else {
385 buf[4] = 0;
386 dbg("%s - stop bits = 1", __func__);
387 }
388
389 if (cflag & PARENB) {
390 /* For reference buf[5]=0 is none parity */
391 /* For reference buf[5]=1 is odd parity */
392 /* For reference buf[5]=2 is even parity */
393 /* For reference buf[5]=3 is mark parity */
394 /* For reference buf[5]=4 is space parity */
395 if (cflag & PARODD) {
396 if (cflag & CMSPAR) {
397 buf[5] = 3;
398 dbg("%s - parity = mark", __func__);
399 } else {
400 buf[5] = 1;
401 dbg("%s - parity = odd", __func__);
402 }
403 } else {
404 if (cflag & CMSPAR) {
405 buf[5] = 4;
406 dbg("%s - parity = space", __func__);
407 } else {
408 buf[5] = 2;
409 dbg("%s - parity = even", __func__);
410 }
411 }
412 } else {
413 buf[5] = 0;
414 dbg("%s - parity = none", __func__);
415 }
416
417 i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
418 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
419 0, 0, buf, 7, 100);
420 dbg("0x21:0x20:0:0 %d", i);
421
422 /* change control lines if we are switching to or from B0 */
423 spin_lock_irqsave(&priv->lock, flags);
424 control = priv->line_control;
425 if ((cflag & CBAUD) == B0)
426 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
427 else
428 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
429 if (control != priv->line_control) {
430 control = priv->line_control;
431 spin_unlock_irqrestore(&priv->lock, flags);
432 set_control_lines(serial->dev, control);
433 } else {
434 spin_unlock_irqrestore(&priv->lock, flags);
435 }
436
437 buf[0] = buf[1] = buf[2] = buf[3] = buf[4] = buf[5] = buf[6] = 0;
438
439 i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
440 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
441 0, 0, buf, 7, 100);
442 dbg("0xa1:0x21:0:0 %d - %x %x %x %x %x %x %x", i,
443 buf[0], buf[1], buf[2], buf[3], buf[4], buf[5], buf[6]);
444
445 if (cflag & CRTSCTS) {
446 if (priv->type == HX)
447 pl2303_vendor_write(0x0, 0x61, serial);
448 else
449 pl2303_vendor_write(0x0, 0x41, serial);
450 } else {
451 pl2303_vendor_write(0x0, 0x0, serial);
452 }
453
454 /* Save resulting baud rate */
455 if (baud)
456 tty_encode_baud_rate(tty, baud, baud);
457
458 kfree(buf);
459}
460
461static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
462{
463 struct pl2303_private *priv = usb_get_serial_port_data(port);
464 unsigned long flags;
465 u8 control;
466
467 spin_lock_irqsave(&priv->lock, flags);
468 /* Change DTR and RTS */
469 if (on)
470 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
471 else
472 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
473 control = priv->line_control;
474 spin_unlock_irqrestore(&priv->lock, flags);
475 set_control_lines(port->serial->dev, control);
476}
477
478static void pl2303_close(struct usb_serial_port *port)
479{
480 dbg("%s - port %d", __func__, port->number);
481
482 usb_serial_generic_close(port);
483 usb_kill_urb(port->interrupt_in_urb);
484}
485
486static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
487{
488 struct ktermios tmp_termios;
489 struct usb_serial *serial = port->serial;
490 struct pl2303_private *priv = usb_get_serial_port_data(port);
491 int result;
492
493 dbg("%s - port %d", __func__, port->number);
494
495 if (priv->type != HX) {
496 usb_clear_halt(serial->dev, port->write_urb->pipe);
497 usb_clear_halt(serial->dev, port->read_urb->pipe);
498 } else {
499 /* reset upstream data pipes */
500 pl2303_vendor_write(8, 0, serial);
501 pl2303_vendor_write(9, 0, serial);
502 }
503
504 /* Setup termios */
505 if (tty)
506 pl2303_set_termios(tty, port, &tmp_termios);
507
508 dbg("%s - submitting read urb", __func__);
509 result = usb_serial_generic_submit_read_urb(port, GFP_KERNEL);
510 if (result) {
511 pl2303_close(port);
512 return -EPROTO;
513 }
514
515 dbg("%s - submitting interrupt urb", __func__);
516 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
517 if (result) {
518 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
519 " error %d\n", __func__, result);
520 pl2303_close(port);
521 return -EPROTO;
522 }
523 port->port.drain_delay = 256;
524 return 0;
525}
526
527static int pl2303_tiocmset(struct tty_struct *tty,
528 unsigned int set, unsigned int clear)
529{
530 struct usb_serial_port *port = tty->driver_data;
531 struct pl2303_private *priv = usb_get_serial_port_data(port);
532 unsigned long flags;
533 u8 control;
534
535 if (!usb_get_intfdata(port->serial->interface))
536 return -ENODEV;
537
538 spin_lock_irqsave(&priv->lock, flags);
539 if (set & TIOCM_RTS)
540 priv->line_control |= CONTROL_RTS;
541 if (set & TIOCM_DTR)
542 priv->line_control |= CONTROL_DTR;
543 if (clear & TIOCM_RTS)
544 priv->line_control &= ~CONTROL_RTS;
545 if (clear & TIOCM_DTR)
546 priv->line_control &= ~CONTROL_DTR;
547 control = priv->line_control;
548 spin_unlock_irqrestore(&priv->lock, flags);
549
550 return set_control_lines(port->serial->dev, control);
551}
552
553static int pl2303_tiocmget(struct tty_struct *tty)
554{
555 struct usb_serial_port *port = tty->driver_data;
556 struct pl2303_private *priv = usb_get_serial_port_data(port);
557 unsigned long flags;
558 unsigned int mcr;
559 unsigned int status;
560 unsigned int result;
561
562 dbg("%s (%d)", __func__, port->number);
563
564 if (!usb_get_intfdata(port->serial->interface))
565 return -ENODEV;
566
567 spin_lock_irqsave(&priv->lock, flags);
568 mcr = priv->line_control;
569 status = priv->line_status;
570 spin_unlock_irqrestore(&priv->lock, flags);
571
572 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
573 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
574 | ((status & UART_CTS) ? TIOCM_CTS : 0)
575 | ((status & UART_DSR) ? TIOCM_DSR : 0)
576 | ((status & UART_RING) ? TIOCM_RI : 0)
577 | ((status & UART_DCD) ? TIOCM_CD : 0);
578
579 dbg("%s - result = %x", __func__, result);
580
581 return result;
582}
583
584static int pl2303_carrier_raised(struct usb_serial_port *port)
585{
586 struct pl2303_private *priv = usb_get_serial_port_data(port);
587 if (priv->line_status & UART_DCD)
588 return 1;
589 return 0;
590}
591
592static int wait_modem_info(struct usb_serial_port *port, unsigned int arg)
593{
594 struct pl2303_private *priv = usb_get_serial_port_data(port);
595 unsigned long flags;
596 unsigned int prevstatus;
597 unsigned int status;
598 unsigned int changed;
599
600 spin_lock_irqsave(&priv->lock, flags);
601 prevstatus = priv->line_status;
602 spin_unlock_irqrestore(&priv->lock, flags);
603
604 while (1) {
605 interruptible_sleep_on(&priv->delta_msr_wait);
606 /* see if a signal did it */
607 if (signal_pending(current))
608 return -ERESTARTSYS;
609
610 spin_lock_irqsave(&priv->lock, flags);
611 status = priv->line_status;
612 spin_unlock_irqrestore(&priv->lock, flags);
613
614 changed = prevstatus ^ status;
615
616 if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
617 ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
618 ((arg & TIOCM_CD) && (changed & UART_DCD)) ||
619 ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
620 return 0;
621 }
622 prevstatus = status;
623 }
624 /* NOTREACHED */
625 return 0;
626}
627
628static int pl2303_ioctl(struct tty_struct *tty,
629 unsigned int cmd, unsigned long arg)
630{
631 struct serial_struct ser;
632 struct usb_serial_port *port = tty->driver_data;
633 dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
634
635 switch (cmd) {
636 case TIOCGSERIAL:
637 memset(&ser, 0, sizeof ser);
638 ser.type = PORT_16654;
639 ser.line = port->serial->minor;
640 ser.port = port->number;
641 ser.baud_base = 460800;
642
643 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
644 return -EFAULT;
645
646 return 0;
647
648 case TIOCMIWAIT:
649 dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
650 return wait_modem_info(port, arg);
651 default:
652 dbg("%s not supported = 0x%04x", __func__, cmd);
653 break;
654 }
655 return -ENOIOCTLCMD;
656}
657
658static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
659{
660 struct usb_serial_port *port = tty->driver_data;
661 struct usb_serial *serial = port->serial;
662 u16 state;
663 int result;
664
665 dbg("%s - port %d", __func__, port->number);
666
667 if (break_state == 0)
668 state = BREAK_OFF;
669 else
670 state = BREAK_ON;
671 dbg("%s - turning break %s", __func__,
672 state == BREAK_OFF ? "off" : "on");
673
674 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
675 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
676 0, NULL, 0, 100);
677 if (result)
678 dbg("%s - error sending break = %d", __func__, result);
679}
680
681static void pl2303_release(struct usb_serial *serial)
682{
683 int i;
684 struct pl2303_private *priv;
685
686 dbg("%s", __func__);
687
688 for (i = 0; i < serial->num_ports; ++i) {
689 priv = usb_get_serial_port_data(serial->port[i]);
690 kfree(priv);
691 }
692}
693
694static void pl2303_update_line_status(struct usb_serial_port *port,
695 unsigned char *data,
696 unsigned int actual_length)
697{
698
699 struct pl2303_private *priv = usb_get_serial_port_data(port);
700 struct tty_struct *tty;
701 unsigned long flags;
702 u8 status_idx = UART_STATE;
703 u8 length = UART_STATE + 1;
704 u8 prev_line_status;
705 u16 idv, idp;
706
707 idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
708 idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);
709
710
711 if (idv == SIEMENS_VENDOR_ID) {
712 if (idp == SIEMENS_PRODUCT_ID_X65 ||
713 idp == SIEMENS_PRODUCT_ID_SX1 ||
714 idp == SIEMENS_PRODUCT_ID_X75) {
715
716 length = 1;
717 status_idx = 0;
718 }
719 }
720
721 if (actual_length < length)
722 return;
723
724 /* Save off the uart status for others to look at */
725 spin_lock_irqsave(&priv->lock, flags);
726 prev_line_status = priv->line_status;
727 priv->line_status = data[status_idx];
728 spin_unlock_irqrestore(&priv->lock, flags);
729 if (priv->line_status & UART_BREAK_ERROR)
730 usb_serial_handle_break(port);
731 wake_up_interruptible(&priv->delta_msr_wait);
732
733 tty = tty_port_tty_get(&port->port);
734 if (!tty)
735 return;
736 if ((priv->line_status ^ prev_line_status) & UART_DCD)
737 usb_serial_handle_dcd_change(port, tty,
738 priv->line_status & UART_DCD);
739 tty_kref_put(tty);
740}
741
742static void pl2303_read_int_callback(struct urb *urb)
743{
744 struct usb_serial_port *port = urb->context;
745 unsigned char *data = urb->transfer_buffer;
746 unsigned int actual_length = urb->actual_length;
747 int status = urb->status;
748 int retval;
749
750 dbg("%s (%d)", __func__, port->number);
751
752 switch (status) {
753 case 0:
754 /* success */
755 break;
756 case -ECONNRESET:
757 case -ENOENT:
758 case -ESHUTDOWN:
759 /* this urb is terminated, clean up */
760 dbg("%s - urb shutting down with status: %d", __func__,
761 status);
762 return;
763 default:
764 dbg("%s - nonzero urb status received: %d", __func__,
765 status);
766 goto exit;
767 }
768
769 usb_serial_debug_data(debug, &port->dev, __func__,
770 urb->actual_length, urb->transfer_buffer);
771
772 pl2303_update_line_status(port, data, actual_length);
773
774exit:
775 retval = usb_submit_urb(urb, GFP_ATOMIC);
776 if (retval)
777 dev_err(&urb->dev->dev,
778 "%s - usb_submit_urb failed with result %d\n",
779 __func__, retval);
780}
781
782static void pl2303_process_read_urb(struct urb *urb)
783{
784 struct usb_serial_port *port = urb->context;
785 struct pl2303_private *priv = usb_get_serial_port_data(port);
786 struct tty_struct *tty;
787 unsigned char *data = urb->transfer_buffer;
788 char tty_flag = TTY_NORMAL;
789 unsigned long flags;
790 u8 line_status;
791 int i;
792
793 /* update line status */
794 spin_lock_irqsave(&priv->lock, flags);
795 line_status = priv->line_status;
796 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
797 spin_unlock_irqrestore(&priv->lock, flags);
798 wake_up_interruptible(&priv->delta_msr_wait);
799
800 if (!urb->actual_length)
801 return;
802
803 tty = tty_port_tty_get(&port->port);
804 if (!tty)
805 return;
806
807 /* break takes precedence over parity, */
808 /* which takes precedence over framing errors */
809 if (line_status & UART_BREAK_ERROR)
810 tty_flag = TTY_BREAK;
811 else if (line_status & UART_PARITY_ERROR)
812 tty_flag = TTY_PARITY;
813 else if (line_status & UART_FRAME_ERROR)
814 tty_flag = TTY_FRAME;
815 dbg("%s - tty_flag = %d", __func__, tty_flag);
816
817 /* overrun is special, not associated with a char */
818 if (line_status & UART_OVERRUN_ERROR)
819 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
820
821 if (port->port.console && port->sysrq) {
822 for (i = 0; i < urb->actual_length; ++i)
823 if (!usb_serial_handle_sysrq_char(port, data[i]))
824 tty_insert_flip_char(tty, data[i], tty_flag);
825 } else {
826 tty_insert_flip_string_fixed_flag(tty, data, tty_flag,
827 urb->actual_length);
828 }
829
830 tty_flip_buffer_push(tty);
831 tty_kref_put(tty);
832}
833
834/* All of the device info needed for the PL2303 SIO serial converter */
835static struct usb_serial_driver pl2303_device = {
836 .driver = {
837 .owner = THIS_MODULE,
838 .name = "pl2303",
839 },
840 .id_table = id_table,
841 .usb_driver = &pl2303_driver,
842 .num_ports = 1,
843 .bulk_in_size = 256,
844 .bulk_out_size = 256,
845 .open = pl2303_open,
846 .close = pl2303_close,
847 .dtr_rts = pl2303_dtr_rts,
848 .carrier_raised = pl2303_carrier_raised,
849 .ioctl = pl2303_ioctl,
850 .break_ctl = pl2303_break_ctl,
851 .set_termios = pl2303_set_termios,
852 .tiocmget = pl2303_tiocmget,
853 .tiocmset = pl2303_tiocmset,
854 .process_read_urb = pl2303_process_read_urb,
855 .read_int_callback = pl2303_read_int_callback,
856 .attach = pl2303_startup,
857 .release = pl2303_release,
858};
859
860static int __init pl2303_init(void)
861{
862 int retval;
863
864 retval = usb_serial_register(&pl2303_device);
865 if (retval)
866 goto failed_usb_serial_register;
867 retval = usb_register(&pl2303_driver);
868 if (retval)
869 goto failed_usb_register;
870 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
871 return 0;
872failed_usb_register:
873 usb_serial_deregister(&pl2303_device);
874failed_usb_serial_register:
875 return retval;
876}
877
878static void __exit pl2303_exit(void)
879{
880 usb_deregister(&pl2303_driver);
881 usb_serial_deregister(&pl2303_device);
882}
883
884module_init(pl2303_init);
885module_exit(pl2303_exit);
886
887MODULE_DESCRIPTION(DRIVER_DESC);
888MODULE_LICENSE("GPL");
889
890module_param(debug, bool, S_IRUGO | S_IWUSR);
891MODULE_PARM_DESC(debug, "Debug enabled or not");
892
1/*
2 * Prolific PL2303 USB to serial adaptor driver
3 *
4 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2003 IBM Corp.
6 *
7 * Original driver for 2.2.x by anonymous
8 *
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.
12 *
13 * See Documentation/usb/usb-serial.txt for more information on using this
14 * driver
15 */
16
17#include <linux/kernel.h>
18#include <linux/errno.h>
19#include <linux/slab.h>
20#include <linux/tty.h>
21#include <linux/tty_driver.h>
22#include <linux/tty_flip.h>
23#include <linux/serial.h>
24#include <linux/module.h>
25#include <linux/moduleparam.h>
26#include <linux/spinlock.h>
27#include <linux/uaccess.h>
28#include <linux/usb.h>
29#include <linux/usb/serial.h>
30#include <asm/unaligned.h>
31#include "pl2303.h"
32
33
34#define PL2303_QUIRK_UART_STATE_IDX0 BIT(0)
35#define PL2303_QUIRK_LEGACY BIT(1)
36
37static const struct usb_device_id id_table[] = {
38 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
39 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
40 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
42 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
43 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
44 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
45 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
46 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
47 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
48 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ZTEK) },
49 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
50 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
51 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
52 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
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(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
66 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
67 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
68 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
69 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
70 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
71 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
72 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
73 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
74 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
75 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
76 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
77 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
78 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
79 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
80 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
81 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
82 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
83 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
84 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
85 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
86 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
87 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
88 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
89 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
90 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
91 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
92 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
93 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
94 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
95 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
96 { } /* Terminating entry */
97};
98
99MODULE_DEVICE_TABLE(usb, id_table);
100
101#define SET_LINE_REQUEST_TYPE 0x21
102#define SET_LINE_REQUEST 0x20
103
104#define SET_CONTROL_REQUEST_TYPE 0x21
105#define SET_CONTROL_REQUEST 0x22
106#define CONTROL_DTR 0x01
107#define CONTROL_RTS 0x02
108
109#define BREAK_REQUEST_TYPE 0x21
110#define BREAK_REQUEST 0x23
111#define BREAK_ON 0xffff
112#define BREAK_OFF 0x0000
113
114#define GET_LINE_REQUEST_TYPE 0xa1
115#define GET_LINE_REQUEST 0x21
116
117#define VENDOR_WRITE_REQUEST_TYPE 0x40
118#define VENDOR_WRITE_REQUEST 0x01
119
120#define VENDOR_READ_REQUEST_TYPE 0xc0
121#define VENDOR_READ_REQUEST 0x01
122
123#define UART_STATE_INDEX 8
124#define UART_STATE_MSR_MASK 0x8b
125#define UART_STATE_TRANSIENT_MASK 0x74
126#define UART_DCD 0x01
127#define UART_DSR 0x02
128#define UART_BREAK_ERROR 0x04
129#define UART_RING 0x08
130#define UART_FRAME_ERROR 0x10
131#define UART_PARITY_ERROR 0x20
132#define UART_OVERRUN_ERROR 0x40
133#define UART_CTS 0x80
134
135static void pl2303_set_break(struct usb_serial_port *port, bool enable);
136
137enum pl2303_type {
138 TYPE_01, /* Type 0 and 1 (difference unknown) */
139 TYPE_HX, /* HX version of the pl2303 chip */
140 TYPE_COUNT
141};
142
143struct pl2303_type_data {
144 speed_t max_baud_rate;
145 unsigned long quirks;
146};
147
148struct pl2303_serial_private {
149 const struct pl2303_type_data *type;
150 unsigned long quirks;
151};
152
153struct pl2303_private {
154 spinlock_t lock;
155 u8 line_control;
156 u8 line_status;
157
158 u8 line_settings[7];
159};
160
161static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
162 [TYPE_01] = {
163 .max_baud_rate = 1228800,
164 .quirks = PL2303_QUIRK_LEGACY,
165 },
166 [TYPE_HX] = {
167 .max_baud_rate = 12000000,
168 },
169};
170
171static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
172 unsigned char buf[1])
173{
174 struct device *dev = &serial->interface->dev;
175 int res;
176
177 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
178 VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
179 value, 0, buf, 1, 100);
180 if (res != 1) {
181 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
182 value, res);
183 if (res >= 0)
184 res = -EIO;
185
186 return res;
187 }
188
189 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
190
191 return 0;
192}
193
194static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
195{
196 struct device *dev = &serial->interface->dev;
197 int res;
198
199 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
200
201 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
202 VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
203 value, index, NULL, 0, 100);
204 if (res) {
205 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
206 value, res);
207 return res;
208 }
209
210 return 0;
211}
212
213static int pl2303_probe(struct usb_serial *serial,
214 const struct usb_device_id *id)
215{
216 usb_set_serial_data(serial, (void *)id->driver_info);
217
218 return 0;
219}
220
221static int pl2303_startup(struct usb_serial *serial)
222{
223 struct pl2303_serial_private *spriv;
224 unsigned char num_ports = serial->num_ports;
225 enum pl2303_type type = TYPE_01;
226 unsigned char *buf;
227
228 if (serial->num_bulk_in < num_ports ||
229 serial->num_bulk_out < num_ports ||
230 serial->num_interrupt_in < num_ports) {
231 dev_err(&serial->interface->dev, "missing endpoints\n");
232 return -ENODEV;
233 }
234
235 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
236 if (!spriv)
237 return -ENOMEM;
238
239 buf = kmalloc(1, GFP_KERNEL);
240 if (!buf) {
241 kfree(spriv);
242 return -ENOMEM;
243 }
244
245 if (serial->dev->descriptor.bDeviceClass == 0x02)
246 type = TYPE_01; /* type 0 */
247 else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
248 type = TYPE_HX;
249 else if (serial->dev->descriptor.bDeviceClass == 0x00)
250 type = TYPE_01; /* type 1 */
251 else if (serial->dev->descriptor.bDeviceClass == 0xFF)
252 type = TYPE_01; /* type 1 */
253 dev_dbg(&serial->interface->dev, "device type: %d\n", type);
254
255 spriv->type = &pl2303_type_data[type];
256 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
257 spriv->quirks |= spriv->type->quirks;
258
259 usb_set_serial_data(serial, spriv);
260
261 pl2303_vendor_read(serial, 0x8484, buf);
262 pl2303_vendor_write(serial, 0x0404, 0);
263 pl2303_vendor_read(serial, 0x8484, buf);
264 pl2303_vendor_read(serial, 0x8383, buf);
265 pl2303_vendor_read(serial, 0x8484, buf);
266 pl2303_vendor_write(serial, 0x0404, 1);
267 pl2303_vendor_read(serial, 0x8484, buf);
268 pl2303_vendor_read(serial, 0x8383, buf);
269 pl2303_vendor_write(serial, 0, 1);
270 pl2303_vendor_write(serial, 1, 0);
271 if (spriv->quirks & PL2303_QUIRK_LEGACY)
272 pl2303_vendor_write(serial, 2, 0x24);
273 else
274 pl2303_vendor_write(serial, 2, 0x44);
275
276 kfree(buf);
277
278 return 0;
279}
280
281static void pl2303_release(struct usb_serial *serial)
282{
283 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
284
285 kfree(spriv);
286}
287
288static int pl2303_port_probe(struct usb_serial_port *port)
289{
290 struct pl2303_private *priv;
291
292 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
293 if (!priv)
294 return -ENOMEM;
295
296 spin_lock_init(&priv->lock);
297
298 usb_set_serial_port_data(port, priv);
299
300 port->port.drain_delay = 256;
301
302 return 0;
303}
304
305static int pl2303_port_remove(struct usb_serial_port *port)
306{
307 struct pl2303_private *priv = usb_get_serial_port_data(port);
308
309 kfree(priv);
310
311 return 0;
312}
313
314static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
315{
316 struct usb_device *dev = port->serial->dev;
317 int retval;
318
319 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
320
321 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
322 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
323 value, 0, NULL, 0, 100);
324 if (retval)
325 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
326
327 return retval;
328}
329
330/*
331 * Returns the nearest supported baud rate that can be set directly without
332 * using divisors.
333 */
334static speed_t pl2303_get_supported_baud_rate(speed_t baud)
335{
336 static const speed_t baud_sup[] = {
337 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
338 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
339 614400, 921600, 1228800, 2457600, 3000000, 6000000
340 };
341
342 unsigned i;
343
344 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
345 if (baud_sup[i] > baud)
346 break;
347 }
348
349 if (i == ARRAY_SIZE(baud_sup))
350 baud = baud_sup[i - 1];
351 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
352 baud = baud_sup[i - 1];
353 else
354 baud = baud_sup[i];
355
356 return baud;
357}
358
359/*
360 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
361 * use 9600 baud.
362 */
363static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
364 speed_t baud)
365{
366 put_unaligned_le32(baud, buf);
367
368 return baud;
369}
370
371static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
372 speed_t baud)
373{
374 unsigned int baseline, mantissa, exponent;
375
376 /*
377 * Apparently the formula is:
378 * baudrate = 12M * 32 / (mantissa * 4^exponent)
379 * where
380 * mantissa = buf[8:0]
381 * exponent = buf[11:9]
382 */
383 baseline = 12000000 * 32;
384 mantissa = baseline / baud;
385 if (mantissa == 0)
386 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
387 exponent = 0;
388 while (mantissa >= 512) {
389 if (exponent < 7) {
390 mantissa >>= 2; /* divide by 4 */
391 exponent++;
392 } else {
393 /* Exponent is maxed. Trim mantissa and leave. */
394 mantissa = 511;
395 break;
396 }
397 }
398
399 buf[3] = 0x80;
400 buf[2] = 0;
401 buf[1] = exponent << 1 | mantissa >> 8;
402 buf[0] = mantissa & 0xff;
403
404 /* Calculate and return the exact baud rate. */
405 baud = (baseline / mantissa) >> (exponent << 1);
406
407 return baud;
408}
409
410static void pl2303_encode_baud_rate(struct tty_struct *tty,
411 struct usb_serial_port *port,
412 u8 buf[4])
413{
414 struct usb_serial *serial = port->serial;
415 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
416 speed_t baud_sup;
417 speed_t baud;
418
419 baud = tty_get_baud_rate(tty);
420 dev_dbg(&port->dev, "baud requested = %u\n", baud);
421 if (!baud)
422 return;
423
424 if (spriv->type->max_baud_rate)
425 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
426 /*
427 * Use direct method for supported baud rates, otherwise use divisors.
428 */
429 baud_sup = pl2303_get_supported_baud_rate(baud);
430
431 if (baud == baud_sup)
432 baud = pl2303_encode_baud_rate_direct(buf, baud);
433 else
434 baud = pl2303_encode_baud_rate_divisor(buf, baud);
435
436 /* Save resulting baud rate */
437 tty_encode_baud_rate(tty, baud, baud);
438 dev_dbg(&port->dev, "baud set = %u\n", baud);
439}
440
441static int pl2303_get_line_request(struct usb_serial_port *port,
442 unsigned char buf[7])
443{
444 struct usb_device *udev = port->serial->dev;
445 int ret;
446
447 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
448 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
449 0, 0, buf, 7, 100);
450 if (ret != 7) {
451 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
452
453 if (ret > 0)
454 ret = -EIO;
455
456 return ret;
457 }
458
459 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
460
461 return 0;
462}
463
464static int pl2303_set_line_request(struct usb_serial_port *port,
465 unsigned char buf[7])
466{
467 struct usb_device *udev = port->serial->dev;
468 int ret;
469
470 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
471 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
472 0, 0, buf, 7, 100);
473 if (ret != 7) {
474 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
475
476 if (ret > 0)
477 ret = -EIO;
478
479 return ret;
480 }
481
482 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
483
484 return 0;
485}
486
487static void pl2303_set_termios(struct tty_struct *tty,
488 struct usb_serial_port *port, struct ktermios *old_termios)
489{
490 struct usb_serial *serial = port->serial;
491 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
492 struct pl2303_private *priv = usb_get_serial_port_data(port);
493 unsigned long flags;
494 unsigned char *buf;
495 int ret;
496 u8 control;
497
498 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
499 return;
500
501 buf = kzalloc(7, GFP_KERNEL);
502 if (!buf) {
503 /* Report back no change occurred */
504 if (old_termios)
505 tty->termios = *old_termios;
506 return;
507 }
508
509 pl2303_get_line_request(port, buf);
510
511 switch (C_CSIZE(tty)) {
512 case CS5:
513 buf[6] = 5;
514 break;
515 case CS6:
516 buf[6] = 6;
517 break;
518 case CS7:
519 buf[6] = 7;
520 break;
521 default:
522 case CS8:
523 buf[6] = 8;
524 }
525 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
526
527 /* For reference buf[0]:buf[3] baud rate value */
528 pl2303_encode_baud_rate(tty, port, &buf[0]);
529
530 /* For reference buf[4]=0 is 1 stop bits */
531 /* For reference buf[4]=1 is 1.5 stop bits */
532 /* For reference buf[4]=2 is 2 stop bits */
533 if (C_CSTOPB(tty)) {
534 /*
535 * NOTE: Comply with "real" UARTs / RS232:
536 * use 1.5 instead of 2 stop bits with 5 data bits
537 */
538 if (C_CSIZE(tty) == CS5) {
539 buf[4] = 1;
540 dev_dbg(&port->dev, "stop bits = 1.5\n");
541 } else {
542 buf[4] = 2;
543 dev_dbg(&port->dev, "stop bits = 2\n");
544 }
545 } else {
546 buf[4] = 0;
547 dev_dbg(&port->dev, "stop bits = 1\n");
548 }
549
550 if (C_PARENB(tty)) {
551 /* For reference buf[5]=0 is none parity */
552 /* For reference buf[5]=1 is odd parity */
553 /* For reference buf[5]=2 is even parity */
554 /* For reference buf[5]=3 is mark parity */
555 /* For reference buf[5]=4 is space parity */
556 if (C_PARODD(tty)) {
557 if (C_CMSPAR(tty)) {
558 buf[5] = 3;
559 dev_dbg(&port->dev, "parity = mark\n");
560 } else {
561 buf[5] = 1;
562 dev_dbg(&port->dev, "parity = odd\n");
563 }
564 } else {
565 if (C_CMSPAR(tty)) {
566 buf[5] = 4;
567 dev_dbg(&port->dev, "parity = space\n");
568 } else {
569 buf[5] = 2;
570 dev_dbg(&port->dev, "parity = even\n");
571 }
572 }
573 } else {
574 buf[5] = 0;
575 dev_dbg(&port->dev, "parity = none\n");
576 }
577
578 /*
579 * Some PL2303 are known to lose bytes if you change serial settings
580 * even to the same values as before. Thus we actually need to filter
581 * in this specific case.
582 *
583 * Note that the tty_termios_hw_change check above is not sufficient
584 * as a previously requested baud rate may differ from the one
585 * actually used (and stored in old_termios).
586 *
587 * NOTE: No additional locking needed for line_settings as it is
588 * only used in set_termios, which is serialised against itself.
589 */
590 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
591 ret = pl2303_set_line_request(port, buf);
592 if (!ret)
593 memcpy(priv->line_settings, buf, 7);
594 }
595
596 /* change control lines if we are switching to or from B0 */
597 spin_lock_irqsave(&priv->lock, flags);
598 control = priv->line_control;
599 if (C_BAUD(tty) == B0)
600 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
601 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
602 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
603 if (control != priv->line_control) {
604 control = priv->line_control;
605 spin_unlock_irqrestore(&priv->lock, flags);
606 pl2303_set_control_lines(port, control);
607 } else {
608 spin_unlock_irqrestore(&priv->lock, flags);
609 }
610
611 if (C_CRTSCTS(tty)) {
612 if (spriv->quirks & PL2303_QUIRK_LEGACY)
613 pl2303_vendor_write(serial, 0x0, 0x41);
614 else
615 pl2303_vendor_write(serial, 0x0, 0x61);
616 } else {
617 pl2303_vendor_write(serial, 0x0, 0x0);
618 }
619
620 kfree(buf);
621}
622
623static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
624{
625 struct pl2303_private *priv = usb_get_serial_port_data(port);
626 unsigned long flags;
627 u8 control;
628
629 spin_lock_irqsave(&priv->lock, flags);
630 if (on)
631 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
632 else
633 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
634 control = priv->line_control;
635 spin_unlock_irqrestore(&priv->lock, flags);
636
637 pl2303_set_control_lines(port, control);
638}
639
640static void pl2303_close(struct usb_serial_port *port)
641{
642 usb_serial_generic_close(port);
643 usb_kill_urb(port->interrupt_in_urb);
644 pl2303_set_break(port, false);
645}
646
647static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
648{
649 struct usb_serial *serial = port->serial;
650 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
651 int result;
652
653 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
654 usb_clear_halt(serial->dev, port->write_urb->pipe);
655 usb_clear_halt(serial->dev, port->read_urb->pipe);
656 } else {
657 /* reset upstream data pipes */
658 pl2303_vendor_write(serial, 8, 0);
659 pl2303_vendor_write(serial, 9, 0);
660 }
661
662 /* Setup termios */
663 if (tty)
664 pl2303_set_termios(tty, port, NULL);
665
666 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
667 if (result) {
668 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
669 result);
670 return result;
671 }
672
673 result = usb_serial_generic_open(tty, port);
674 if (result) {
675 usb_kill_urb(port->interrupt_in_urb);
676 return result;
677 }
678
679 return 0;
680}
681
682static int pl2303_tiocmset(struct tty_struct *tty,
683 unsigned int set, unsigned int clear)
684{
685 struct usb_serial_port *port = tty->driver_data;
686 struct pl2303_private *priv = usb_get_serial_port_data(port);
687 unsigned long flags;
688 u8 control;
689 int ret;
690
691 spin_lock_irqsave(&priv->lock, flags);
692 if (set & TIOCM_RTS)
693 priv->line_control |= CONTROL_RTS;
694 if (set & TIOCM_DTR)
695 priv->line_control |= CONTROL_DTR;
696 if (clear & TIOCM_RTS)
697 priv->line_control &= ~CONTROL_RTS;
698 if (clear & TIOCM_DTR)
699 priv->line_control &= ~CONTROL_DTR;
700 control = priv->line_control;
701 spin_unlock_irqrestore(&priv->lock, flags);
702
703 ret = pl2303_set_control_lines(port, control);
704 if (ret)
705 return usb_translate_errors(ret);
706
707 return 0;
708}
709
710static int pl2303_tiocmget(struct tty_struct *tty)
711{
712 struct usb_serial_port *port = tty->driver_data;
713 struct pl2303_private *priv = usb_get_serial_port_data(port);
714 unsigned long flags;
715 unsigned int mcr;
716 unsigned int status;
717 unsigned int result;
718
719 spin_lock_irqsave(&priv->lock, flags);
720 mcr = priv->line_control;
721 status = priv->line_status;
722 spin_unlock_irqrestore(&priv->lock, flags);
723
724 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
725 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
726 | ((status & UART_CTS) ? TIOCM_CTS : 0)
727 | ((status & UART_DSR) ? TIOCM_DSR : 0)
728 | ((status & UART_RING) ? TIOCM_RI : 0)
729 | ((status & UART_DCD) ? TIOCM_CD : 0);
730
731 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
732
733 return result;
734}
735
736static int pl2303_carrier_raised(struct usb_serial_port *port)
737{
738 struct pl2303_private *priv = usb_get_serial_port_data(port);
739
740 if (priv->line_status & UART_DCD)
741 return 1;
742
743 return 0;
744}
745
746static int pl2303_ioctl(struct tty_struct *tty,
747 unsigned int cmd, unsigned long arg)
748{
749 struct serial_struct ser;
750 struct usb_serial_port *port = tty->driver_data;
751
752 switch (cmd) {
753 case TIOCGSERIAL:
754 memset(&ser, 0, sizeof ser);
755 ser.type = PORT_16654;
756 ser.line = port->minor;
757 ser.port = port->port_number;
758 ser.baud_base = 460800;
759
760 if (copy_to_user((void __user *)arg, &ser, sizeof ser))
761 return -EFAULT;
762
763 return 0;
764 default:
765 break;
766 }
767
768 return -ENOIOCTLCMD;
769}
770
771static void pl2303_set_break(struct usb_serial_port *port, bool enable)
772{
773 struct usb_serial *serial = port->serial;
774 u16 state;
775 int result;
776
777 if (enable)
778 state = BREAK_ON;
779 else
780 state = BREAK_OFF;
781
782 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
783 state == BREAK_OFF ? "off" : "on");
784
785 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
786 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
787 0, NULL, 0, 100);
788 if (result)
789 dev_err(&port->dev, "error sending break = %d\n", result);
790}
791
792static void pl2303_break_ctl(struct tty_struct *tty, int state)
793{
794 struct usb_serial_port *port = tty->driver_data;
795
796 pl2303_set_break(port, state);
797}
798
799static void pl2303_update_line_status(struct usb_serial_port *port,
800 unsigned char *data,
801 unsigned int actual_length)
802{
803 struct usb_serial *serial = port->serial;
804 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
805 struct pl2303_private *priv = usb_get_serial_port_data(port);
806 struct tty_struct *tty;
807 unsigned long flags;
808 unsigned int status_idx = UART_STATE_INDEX;
809 u8 status;
810 u8 delta;
811
812 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
813 status_idx = 0;
814
815 if (actual_length < status_idx + 1)
816 return;
817
818 status = data[status_idx];
819
820 /* Save off the uart status for others to look at */
821 spin_lock_irqsave(&priv->lock, flags);
822 delta = priv->line_status ^ status;
823 priv->line_status = status;
824 spin_unlock_irqrestore(&priv->lock, flags);
825
826 if (status & UART_BREAK_ERROR)
827 usb_serial_handle_break(port);
828
829 if (delta & UART_STATE_MSR_MASK) {
830 if (delta & UART_CTS)
831 port->icount.cts++;
832 if (delta & UART_DSR)
833 port->icount.dsr++;
834 if (delta & UART_RING)
835 port->icount.rng++;
836 if (delta & UART_DCD) {
837 port->icount.dcd++;
838 tty = tty_port_tty_get(&port->port);
839 if (tty) {
840 usb_serial_handle_dcd_change(port, tty,
841 status & UART_DCD);
842 tty_kref_put(tty);
843 }
844 }
845
846 wake_up_interruptible(&port->port.delta_msr_wait);
847 }
848}
849
850static void pl2303_read_int_callback(struct urb *urb)
851{
852 struct usb_serial_port *port = urb->context;
853 unsigned char *data = urb->transfer_buffer;
854 unsigned int actual_length = urb->actual_length;
855 int status = urb->status;
856 int retval;
857
858 switch (status) {
859 case 0:
860 /* success */
861 break;
862 case -ECONNRESET:
863 case -ENOENT:
864 case -ESHUTDOWN:
865 /* this urb is terminated, clean up */
866 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
867 __func__, status);
868 return;
869 default:
870 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
871 __func__, status);
872 goto exit;
873 }
874
875 usb_serial_debug_data(&port->dev, __func__,
876 urb->actual_length, urb->transfer_buffer);
877
878 pl2303_update_line_status(port, data, actual_length);
879
880exit:
881 retval = usb_submit_urb(urb, GFP_ATOMIC);
882 if (retval) {
883 dev_err(&port->dev,
884 "%s - usb_submit_urb failed with result %d\n",
885 __func__, retval);
886 }
887}
888
889static void pl2303_process_read_urb(struct urb *urb)
890{
891 struct usb_serial_port *port = urb->context;
892 struct pl2303_private *priv = usb_get_serial_port_data(port);
893 unsigned char *data = urb->transfer_buffer;
894 char tty_flag = TTY_NORMAL;
895 unsigned long flags;
896 u8 line_status;
897 int i;
898
899 /* update line status */
900 spin_lock_irqsave(&priv->lock, flags);
901 line_status = priv->line_status;
902 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
903 spin_unlock_irqrestore(&priv->lock, flags);
904
905 if (!urb->actual_length)
906 return;
907
908 /*
909 * Break takes precedence over parity, which takes precedence over
910 * framing errors.
911 */
912 if (line_status & UART_BREAK_ERROR)
913 tty_flag = TTY_BREAK;
914 else if (line_status & UART_PARITY_ERROR)
915 tty_flag = TTY_PARITY;
916 else if (line_status & UART_FRAME_ERROR)
917 tty_flag = TTY_FRAME;
918
919 if (tty_flag != TTY_NORMAL)
920 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
921 tty_flag);
922 /* overrun is special, not associated with a char */
923 if (line_status & UART_OVERRUN_ERROR)
924 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
925
926 if (port->port.console && port->sysrq) {
927 for (i = 0; i < urb->actual_length; ++i)
928 if (!usb_serial_handle_sysrq_char(port, data[i]))
929 tty_insert_flip_char(&port->port, data[i],
930 tty_flag);
931 } else {
932 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
933 urb->actual_length);
934 }
935
936 tty_flip_buffer_push(&port->port);
937}
938
939static struct usb_serial_driver pl2303_device = {
940 .driver = {
941 .owner = THIS_MODULE,
942 .name = "pl2303",
943 },
944 .id_table = id_table,
945 .num_ports = 1,
946 .bulk_in_size = 256,
947 .bulk_out_size = 256,
948 .open = pl2303_open,
949 .close = pl2303_close,
950 .dtr_rts = pl2303_dtr_rts,
951 .carrier_raised = pl2303_carrier_raised,
952 .ioctl = pl2303_ioctl,
953 .break_ctl = pl2303_break_ctl,
954 .set_termios = pl2303_set_termios,
955 .tiocmget = pl2303_tiocmget,
956 .tiocmset = pl2303_tiocmset,
957 .tiocmiwait = usb_serial_generic_tiocmiwait,
958 .process_read_urb = pl2303_process_read_urb,
959 .read_int_callback = pl2303_read_int_callback,
960 .probe = pl2303_probe,
961 .attach = pl2303_startup,
962 .release = pl2303_release,
963 .port_probe = pl2303_port_probe,
964 .port_remove = pl2303_port_remove,
965};
966
967static struct usb_serial_driver * const serial_drivers[] = {
968 &pl2303_device, NULL
969};
970
971module_usb_serial_driver(serial_drivers, id_table);
972
973MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
974MODULE_LICENSE("GPL");