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// SPDX-License-Identifier: GPL-2.0
2/*
3 * Prolific PL2303 USB to serial adaptor driver
4 *
5 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
6 * Copyright (C) 2003 IBM Corp.
7 *
8 * Original driver for 2.2.x by anonymous
9 *
10 * See Documentation/usb/usb-serial.rst for more information on using this
11 * driver
12 */
13
14#include <linux/kernel.h>
15#include <linux/errno.h>
16#include <linux/slab.h>
17#include <linux/tty.h>
18#include <linux/tty_driver.h>
19#include <linux/tty_flip.h>
20#include <linux/serial.h>
21#include <linux/module.h>
22#include <linux/moduleparam.h>
23#include <linux/spinlock.h>
24#include <linux/uaccess.h>
25#include <linux/usb.h>
26#include <linux/usb/serial.h>
27#include <asm/unaligned.h>
28#include "pl2303.h"
29
30
31#define PL2303_QUIRK_UART_STATE_IDX0 BIT(0)
32#define PL2303_QUIRK_LEGACY BIT(1)
33#define PL2303_QUIRK_ENDPOINT_HACK BIT(2)
34
35static const struct usb_device_id id_table[] = {
36 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID),
37 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
38 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
39 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
40 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
41 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_CHILITAG) },
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(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_TB) },
50 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GC) },
51 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GB) },
52 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GT) },
53 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GL) },
54 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GE) },
55 { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GS) },
56 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
57 { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
58 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID),
59 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
60 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC485),
61 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
62 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC232B),
63 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
64 { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
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(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
78 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
79 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
80 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
81 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
82 .driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
83 { USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81),
84 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
85 { USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
86 { USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
87 { USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
88 { USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
89 { USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
90 { USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
91 { USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
92 { USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
93 { USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
94 { USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID),
95 .driver_info = PL2303_QUIRK_ENDPOINT_HACK },
96 { USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
97 { USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
98 { USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
99 { USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
100 { USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
101 { USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
102 { USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
103 { USB_DEVICE(HP_VENDOR_ID, HP_LD381GC_PRODUCT_ID) },
104 { USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
105 { USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
106 { USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
107 { USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
108 { USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
109 { USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
110 { USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
111 { USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
112 { USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
113 { USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
114 { USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
115 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
116 { USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530GC_PRODUCT_ID) },
117 { USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
118 { USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
119 { } /* Terminating entry */
120};
121
122MODULE_DEVICE_TABLE(usb, id_table);
123
124#define SET_LINE_REQUEST_TYPE 0x21
125#define SET_LINE_REQUEST 0x20
126
127#define SET_CONTROL_REQUEST_TYPE 0x21
128#define SET_CONTROL_REQUEST 0x22
129#define CONTROL_DTR 0x01
130#define CONTROL_RTS 0x02
131
132#define BREAK_REQUEST_TYPE 0x21
133#define BREAK_REQUEST 0x23
134#define BREAK_ON 0xffff
135#define BREAK_OFF 0x0000
136
137#define GET_LINE_REQUEST_TYPE 0xa1
138#define GET_LINE_REQUEST 0x21
139
140#define VENDOR_WRITE_REQUEST_TYPE 0x40
141#define VENDOR_WRITE_REQUEST 0x01
142#define VENDOR_WRITE_NREQUEST 0x80
143
144#define VENDOR_READ_REQUEST_TYPE 0xc0
145#define VENDOR_READ_REQUEST 0x01
146#define VENDOR_READ_NREQUEST 0x81
147
148#define UART_STATE_INDEX 8
149#define UART_STATE_MSR_MASK 0x8b
150#define UART_STATE_TRANSIENT_MASK 0x74
151#define UART_DCD 0x01
152#define UART_DSR 0x02
153#define UART_BREAK_ERROR 0x04
154#define UART_RING 0x08
155#define UART_FRAME_ERROR 0x10
156#define UART_PARITY_ERROR 0x20
157#define UART_OVERRUN_ERROR 0x40
158#define UART_CTS 0x80
159
160#define PL2303_FLOWCTRL_MASK 0xf0
161
162#define PL2303_READ_TYPE_HX_STATUS 0x8080
163
164#define PL2303_HXN_RESET_REG 0x07
165#define PL2303_HXN_RESET_UPSTREAM_PIPE 0x02
166#define PL2303_HXN_RESET_DOWNSTREAM_PIPE 0x01
167
168#define PL2303_HXN_FLOWCTRL_REG 0x0a
169#define PL2303_HXN_FLOWCTRL_MASK 0x1c
170#define PL2303_HXN_FLOWCTRL_NONE 0x1c
171#define PL2303_HXN_FLOWCTRL_RTS_CTS 0x18
172#define PL2303_HXN_FLOWCTRL_XON_XOFF 0x0c
173
174static void pl2303_set_break(struct usb_serial_port *port, bool enable);
175
176enum pl2303_type {
177 TYPE_H,
178 TYPE_HX,
179 TYPE_TA,
180 TYPE_TB,
181 TYPE_HXD,
182 TYPE_HXN,
183 TYPE_COUNT
184};
185
186struct pl2303_type_data {
187 const char *name;
188 speed_t max_baud_rate;
189 unsigned long quirks;
190 unsigned int no_autoxonxoff:1;
191 unsigned int no_divisors:1;
192 unsigned int alt_divisors:1;
193};
194
195struct pl2303_serial_private {
196 const struct pl2303_type_data *type;
197 unsigned long quirks;
198};
199
200struct pl2303_private {
201 spinlock_t lock;
202 u8 line_control;
203 u8 line_status;
204
205 u8 line_settings[7];
206};
207
208static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
209 [TYPE_H] = {
210 .name = "H",
211 .max_baud_rate = 1228800,
212 .quirks = PL2303_QUIRK_LEGACY,
213 .no_autoxonxoff = true,
214 },
215 [TYPE_HX] = {
216 .name = "HX",
217 .max_baud_rate = 6000000,
218 },
219 [TYPE_TA] = {
220 .name = "TA",
221 .max_baud_rate = 6000000,
222 .alt_divisors = true,
223 },
224 [TYPE_TB] = {
225 .name = "TB",
226 .max_baud_rate = 12000000,
227 .alt_divisors = true,
228 },
229 [TYPE_HXD] = {
230 .name = "HXD",
231 .max_baud_rate = 12000000,
232 },
233 [TYPE_HXN] = {
234 .name = "G",
235 .max_baud_rate = 12000000,
236 .no_divisors = true,
237 },
238};
239
240static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
241 unsigned char buf[1])
242{
243 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
244 struct device *dev = &serial->interface->dev;
245 u8 request;
246 int res;
247
248 if (spriv->type == &pl2303_type_data[TYPE_HXN])
249 request = VENDOR_READ_NREQUEST;
250 else
251 request = VENDOR_READ_REQUEST;
252
253 res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
254 request, VENDOR_READ_REQUEST_TYPE,
255 value, 0, buf, 1, 100);
256 if (res != 1) {
257 dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
258 value, res);
259 if (res >= 0)
260 res = -EIO;
261
262 return res;
263 }
264
265 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
266
267 return 0;
268}
269
270static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
271{
272 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
273 struct device *dev = &serial->interface->dev;
274 u8 request;
275 int res;
276
277 dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);
278
279 if (spriv->type == &pl2303_type_data[TYPE_HXN])
280 request = VENDOR_WRITE_NREQUEST;
281 else
282 request = VENDOR_WRITE_REQUEST;
283
284 res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
285 request, VENDOR_WRITE_REQUEST_TYPE,
286 value, index, NULL, 0, 100);
287 if (res) {
288 dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
289 value, res);
290 return res;
291 }
292
293 return 0;
294}
295
296static int pl2303_update_reg(struct usb_serial *serial, u8 reg, u8 mask, u8 val)
297{
298 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
299 int ret = 0;
300 u8 *buf;
301
302 buf = kmalloc(1, GFP_KERNEL);
303 if (!buf)
304 return -ENOMEM;
305
306 if (spriv->type == &pl2303_type_data[TYPE_HXN])
307 ret = pl2303_vendor_read(serial, reg, buf);
308 else
309 ret = pl2303_vendor_read(serial, reg | 0x80, buf);
310
311 if (ret)
312 goto out_free;
313
314 *buf &= ~mask;
315 *buf |= val & mask;
316
317 ret = pl2303_vendor_write(serial, reg, *buf);
318out_free:
319 kfree(buf);
320
321 return ret;
322}
323
324static int pl2303_probe(struct usb_serial *serial,
325 const struct usb_device_id *id)
326{
327 usb_set_serial_data(serial, (void *)id->driver_info);
328
329 return 0;
330}
331
332/*
333 * Use interrupt endpoint from first interface if available.
334 *
335 * This is needed due to the looney way its endpoints are set up.
336 */
337static int pl2303_endpoint_hack(struct usb_serial *serial,
338 struct usb_serial_endpoints *epds)
339{
340 struct usb_interface *interface = serial->interface;
341 struct usb_device *dev = serial->dev;
342 struct device *ddev = &interface->dev;
343 struct usb_host_interface *iface_desc;
344 struct usb_endpoint_descriptor *endpoint;
345 unsigned int i;
346
347 if (interface == dev->actconfig->interface[0])
348 return 0;
349
350 /* check out the endpoints of the other interface */
351 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
352
353 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
354 endpoint = &iface_desc->endpoint[i].desc;
355
356 if (!usb_endpoint_is_int_in(endpoint))
357 continue;
358
359 dev_dbg(ddev, "found interrupt in on separate interface\n");
360 if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
361 epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
362 }
363
364 return 0;
365}
366
367static int pl2303_calc_num_ports(struct usb_serial *serial,
368 struct usb_serial_endpoints *epds)
369{
370 unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
371 struct device *dev = &serial->interface->dev;
372 int ret;
373
374 if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
375 ret = pl2303_endpoint_hack(serial, epds);
376 if (ret)
377 return ret;
378 }
379
380 if (epds->num_interrupt_in < 1) {
381 dev_err(dev, "required interrupt-in endpoint missing\n");
382 return -ENODEV;
383 }
384
385 return 1;
386}
387
388static bool pl2303_supports_hx_status(struct usb_serial *serial)
389{
390 int ret;
391 u8 buf;
392
393 ret = usb_control_msg_recv(serial->dev, 0, VENDOR_READ_REQUEST,
394 VENDOR_READ_REQUEST_TYPE, PL2303_READ_TYPE_HX_STATUS,
395 0, &buf, 1, 100, GFP_KERNEL);
396
397 return ret == 0;
398}
399
400static int pl2303_detect_type(struct usb_serial *serial)
401{
402 struct usb_device_descriptor *desc = &serial->dev->descriptor;
403 u16 bcdDevice, bcdUSB;
404
405 /*
406 * Legacy PL2303H, variants 0 and 1 (difference unknown).
407 */
408 if (desc->bDeviceClass == 0x02)
409 return TYPE_H; /* variant 0 */
410
411 if (desc->bMaxPacketSize0 != 0x40) {
412 if (desc->bDeviceClass == 0x00 || desc->bDeviceClass == 0xff)
413 return TYPE_H; /* variant 1 */
414
415 return TYPE_H; /* variant 0 */
416 }
417
418 bcdDevice = le16_to_cpu(desc->bcdDevice);
419 bcdUSB = le16_to_cpu(desc->bcdUSB);
420
421 switch (bcdUSB) {
422 case 0x110:
423 switch (bcdDevice) {
424 case 0x300:
425 return TYPE_HX;
426 case 0x400:
427 return TYPE_HXD;
428 default:
429 return TYPE_HX;
430 }
431 break;
432 case 0x200:
433 switch (bcdDevice) {
434 case 0x100:
435 case 0x305:
436 case 0x405:
437 /*
438 * Assume it's an HXN-type if the device doesn't
439 * support the old read request value.
440 */
441 if (!pl2303_supports_hx_status(serial))
442 return TYPE_HXN;
443 break;
444 case 0x300:
445 return TYPE_TA;
446 case 0x500:
447 return TYPE_TB;
448 }
449 break;
450 }
451
452 dev_err(&serial->interface->dev,
453 "unknown device type, please report to linux-usb@vger.kernel.org\n");
454 return -ENODEV;
455}
456
457static int pl2303_startup(struct usb_serial *serial)
458{
459 struct pl2303_serial_private *spriv;
460 enum pl2303_type type;
461 unsigned char *buf;
462 int ret;
463
464 ret = pl2303_detect_type(serial);
465 if (ret < 0)
466 return ret;
467
468 type = ret;
469 dev_dbg(&serial->interface->dev, "device type: %s\n", pl2303_type_data[type].name);
470
471 spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
472 if (!spriv)
473 return -ENOMEM;
474
475 spriv->type = &pl2303_type_data[type];
476 spriv->quirks = (unsigned long)usb_get_serial_data(serial);
477 spriv->quirks |= spriv->type->quirks;
478
479 usb_set_serial_data(serial, spriv);
480
481 if (type != TYPE_HXN) {
482 buf = kmalloc(1, GFP_KERNEL);
483 if (!buf) {
484 kfree(spriv);
485 return -ENOMEM;
486 }
487
488 pl2303_vendor_read(serial, 0x8484, buf);
489 pl2303_vendor_write(serial, 0x0404, 0);
490 pl2303_vendor_read(serial, 0x8484, buf);
491 pl2303_vendor_read(serial, 0x8383, buf);
492 pl2303_vendor_read(serial, 0x8484, buf);
493 pl2303_vendor_write(serial, 0x0404, 1);
494 pl2303_vendor_read(serial, 0x8484, buf);
495 pl2303_vendor_read(serial, 0x8383, buf);
496 pl2303_vendor_write(serial, 0, 1);
497 pl2303_vendor_write(serial, 1, 0);
498 if (spriv->quirks & PL2303_QUIRK_LEGACY)
499 pl2303_vendor_write(serial, 2, 0x24);
500 else
501 pl2303_vendor_write(serial, 2, 0x44);
502
503 kfree(buf);
504 }
505
506 return 0;
507}
508
509static void pl2303_release(struct usb_serial *serial)
510{
511 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
512
513 kfree(spriv);
514}
515
516static int pl2303_port_probe(struct usb_serial_port *port)
517{
518 struct pl2303_private *priv;
519
520 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
521 if (!priv)
522 return -ENOMEM;
523
524 spin_lock_init(&priv->lock);
525
526 usb_set_serial_port_data(port, priv);
527
528 port->port.drain_delay = 256;
529
530 return 0;
531}
532
533static void pl2303_port_remove(struct usb_serial_port *port)
534{
535 struct pl2303_private *priv = usb_get_serial_port_data(port);
536
537 kfree(priv);
538}
539
540static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
541{
542 struct usb_device *dev = port->serial->dev;
543 int retval;
544
545 dev_dbg(&port->dev, "%s - %02x\n", __func__, value);
546
547 retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
548 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
549 value, 0, NULL, 0, 100);
550 if (retval)
551 dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
552
553 return retval;
554}
555
556/*
557 * Returns the nearest supported baud rate that can be set directly without
558 * using divisors.
559 */
560static speed_t pl2303_get_supported_baud_rate(speed_t baud)
561{
562 static const speed_t baud_sup[] = {
563 75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
564 14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
565 614400, 921600, 1228800, 2457600, 3000000, 6000000
566 };
567
568 unsigned i;
569
570 for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
571 if (baud_sup[i] > baud)
572 break;
573 }
574
575 if (i == ARRAY_SIZE(baud_sup))
576 baud = baud_sup[i - 1];
577 else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
578 baud = baud_sup[i - 1];
579 else
580 baud = baud_sup[i];
581
582 return baud;
583}
584
585/*
586 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
587 * use 9600 baud.
588 */
589static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
590 speed_t baud)
591{
592 put_unaligned_le32(baud, buf);
593
594 return baud;
595}
596
597static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
598 speed_t baud)
599{
600 unsigned int baseline, mantissa, exponent;
601
602 /*
603 * Apparently the formula is:
604 * baudrate = 12M * 32 / (mantissa * 4^exponent)
605 * where
606 * mantissa = buf[8:0]
607 * exponent = buf[11:9]
608 */
609 baseline = 12000000 * 32;
610 mantissa = baseline / baud;
611 if (mantissa == 0)
612 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
613 exponent = 0;
614 while (mantissa >= 512) {
615 if (exponent < 7) {
616 mantissa >>= 2; /* divide by 4 */
617 exponent++;
618 } else {
619 /* Exponent is maxed. Trim mantissa and leave. */
620 mantissa = 511;
621 break;
622 }
623 }
624
625 buf[3] = 0x80;
626 buf[2] = 0;
627 buf[1] = exponent << 1 | mantissa >> 8;
628 buf[0] = mantissa & 0xff;
629
630 /* Calculate and return the exact baud rate. */
631 baud = (baseline / mantissa) >> (exponent << 1);
632
633 return baud;
634}
635
636static speed_t pl2303_encode_baud_rate_divisor_alt(unsigned char buf[4],
637 speed_t baud)
638{
639 unsigned int baseline, mantissa, exponent;
640
641 /*
642 * Apparently, for the TA version the formula is:
643 * baudrate = 12M * 32 / (mantissa * 2^exponent)
644 * where
645 * mantissa = buf[10:0]
646 * exponent = buf[15:13 16]
647 */
648 baseline = 12000000 * 32;
649 mantissa = baseline / baud;
650 if (mantissa == 0)
651 mantissa = 1; /* Avoid dividing by zero if baud > 32*12M. */
652 exponent = 0;
653 while (mantissa >= 2048) {
654 if (exponent < 15) {
655 mantissa >>= 1; /* divide by 2 */
656 exponent++;
657 } else {
658 /* Exponent is maxed. Trim mantissa and leave. */
659 mantissa = 2047;
660 break;
661 }
662 }
663
664 buf[3] = 0x80;
665 buf[2] = exponent & 0x01;
666 buf[1] = (exponent & ~0x01) << 4 | mantissa >> 8;
667 buf[0] = mantissa & 0xff;
668
669 /* Calculate and return the exact baud rate. */
670 baud = (baseline / mantissa) >> exponent;
671
672 return baud;
673}
674
675static void pl2303_encode_baud_rate(struct tty_struct *tty,
676 struct usb_serial_port *port,
677 u8 buf[4])
678{
679 struct usb_serial *serial = port->serial;
680 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
681 speed_t baud_sup;
682 speed_t baud;
683
684 baud = tty_get_baud_rate(tty);
685 dev_dbg(&port->dev, "baud requested = %u\n", baud);
686 if (!baud)
687 return;
688
689 if (spriv->type->max_baud_rate)
690 baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
691 /*
692 * Use direct method for supported baud rates, otherwise use divisors.
693 * Newer chip types do not support divisor encoding.
694 */
695 if (spriv->type->no_divisors)
696 baud_sup = baud;
697 else
698 baud_sup = pl2303_get_supported_baud_rate(baud);
699
700 if (baud == baud_sup)
701 baud = pl2303_encode_baud_rate_direct(buf, baud);
702 else if (spriv->type->alt_divisors)
703 baud = pl2303_encode_baud_rate_divisor_alt(buf, baud);
704 else
705 baud = pl2303_encode_baud_rate_divisor(buf, baud);
706
707 /* Save resulting baud rate */
708 tty_encode_baud_rate(tty, baud, baud);
709 dev_dbg(&port->dev, "baud set = %u\n", baud);
710}
711
712static int pl2303_get_line_request(struct usb_serial_port *port,
713 unsigned char buf[7])
714{
715 struct usb_device *udev = port->serial->dev;
716 int ret;
717
718 ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
719 GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
720 0, 0, buf, 7, 100);
721 if (ret != 7) {
722 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
723
724 if (ret >= 0)
725 ret = -EIO;
726
727 return ret;
728 }
729
730 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
731
732 return 0;
733}
734
735static int pl2303_set_line_request(struct usb_serial_port *port,
736 unsigned char buf[7])
737{
738 struct usb_device *udev = port->serial->dev;
739 int ret;
740
741 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
742 SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
743 0, 0, buf, 7, 100);
744 if (ret < 0) {
745 dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
746 return ret;
747 }
748
749 dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);
750
751 return 0;
752}
753
754static bool pl2303_termios_change(const struct ktermios *a, const struct ktermios *b)
755{
756 bool ixon_change;
757
758 ixon_change = ((a->c_iflag ^ b->c_iflag) & (IXON | IXANY)) ||
759 a->c_cc[VSTART] != b->c_cc[VSTART] ||
760 a->c_cc[VSTOP] != b->c_cc[VSTOP];
761
762 return tty_termios_hw_change(a, b) || ixon_change;
763}
764
765static bool pl2303_enable_xonxoff(struct tty_struct *tty, const struct pl2303_type_data *type)
766{
767 if (!I_IXON(tty) || I_IXANY(tty))
768 return false;
769
770 if (START_CHAR(tty) != 0x11 || STOP_CHAR(tty) != 0x13)
771 return false;
772
773 if (type->no_autoxonxoff)
774 return false;
775
776 return true;
777}
778
779static void pl2303_set_termios(struct tty_struct *tty,
780 struct usb_serial_port *port, struct ktermios *old_termios)
781{
782 struct usb_serial *serial = port->serial;
783 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
784 struct pl2303_private *priv = usb_get_serial_port_data(port);
785 unsigned long flags;
786 unsigned char *buf;
787 int ret;
788 u8 control;
789
790 if (old_termios && !pl2303_termios_change(&tty->termios, old_termios))
791 return;
792
793 buf = kzalloc(7, GFP_KERNEL);
794 if (!buf) {
795 /* Report back no change occurred */
796 if (old_termios)
797 tty->termios = *old_termios;
798 return;
799 }
800
801 pl2303_get_line_request(port, buf);
802
803 buf[6] = tty_get_char_size(tty->termios.c_cflag);
804 dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
805
806 /* For reference buf[0]:buf[3] baud rate value */
807 pl2303_encode_baud_rate(tty, port, &buf[0]);
808
809 /* For reference buf[4]=0 is 1 stop bits */
810 /* For reference buf[4]=1 is 1.5 stop bits */
811 /* For reference buf[4]=2 is 2 stop bits */
812 if (C_CSTOPB(tty)) {
813 /*
814 * NOTE: Comply with "real" UARTs / RS232:
815 * use 1.5 instead of 2 stop bits with 5 data bits
816 */
817 if (C_CSIZE(tty) == CS5) {
818 buf[4] = 1;
819 dev_dbg(&port->dev, "stop bits = 1.5\n");
820 } else {
821 buf[4] = 2;
822 dev_dbg(&port->dev, "stop bits = 2\n");
823 }
824 } else {
825 buf[4] = 0;
826 dev_dbg(&port->dev, "stop bits = 1\n");
827 }
828
829 if (C_PARENB(tty)) {
830 /* For reference buf[5]=0 is none parity */
831 /* For reference buf[5]=1 is odd parity */
832 /* For reference buf[5]=2 is even parity */
833 /* For reference buf[5]=3 is mark parity */
834 /* For reference buf[5]=4 is space parity */
835 if (C_PARODD(tty)) {
836 if (C_CMSPAR(tty)) {
837 buf[5] = 3;
838 dev_dbg(&port->dev, "parity = mark\n");
839 } else {
840 buf[5] = 1;
841 dev_dbg(&port->dev, "parity = odd\n");
842 }
843 } else {
844 if (C_CMSPAR(tty)) {
845 buf[5] = 4;
846 dev_dbg(&port->dev, "parity = space\n");
847 } else {
848 buf[5] = 2;
849 dev_dbg(&port->dev, "parity = even\n");
850 }
851 }
852 } else {
853 buf[5] = 0;
854 dev_dbg(&port->dev, "parity = none\n");
855 }
856
857 /*
858 * Some PL2303 are known to lose bytes if you change serial settings
859 * even to the same values as before. Thus we actually need to filter
860 * in this specific case.
861 *
862 * Note that the tty_termios_hw_change check above is not sufficient
863 * as a previously requested baud rate may differ from the one
864 * actually used (and stored in old_termios).
865 *
866 * NOTE: No additional locking needed for line_settings as it is
867 * only used in set_termios, which is serialised against itself.
868 */
869 if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
870 ret = pl2303_set_line_request(port, buf);
871 if (!ret)
872 memcpy(priv->line_settings, buf, 7);
873 }
874
875 /* change control lines if we are switching to or from B0 */
876 spin_lock_irqsave(&priv->lock, flags);
877 control = priv->line_control;
878 if (C_BAUD(tty) == B0)
879 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
880 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
881 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
882 if (control != priv->line_control) {
883 control = priv->line_control;
884 spin_unlock_irqrestore(&priv->lock, flags);
885 pl2303_set_control_lines(port, control);
886 } else {
887 spin_unlock_irqrestore(&priv->lock, flags);
888 }
889
890 if (C_CRTSCTS(tty)) {
891 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
892 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0x40);
893 } else if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
894 pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
895 PL2303_HXN_FLOWCTRL_MASK,
896 PL2303_HXN_FLOWCTRL_RTS_CTS);
897 } else {
898 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0x60);
899 }
900 } else if (pl2303_enable_xonxoff(tty, spriv->type)) {
901 if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
902 pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
903 PL2303_HXN_FLOWCTRL_MASK,
904 PL2303_HXN_FLOWCTRL_XON_XOFF);
905 } else {
906 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0xc0);
907 }
908 } else {
909 if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
910 pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
911 PL2303_HXN_FLOWCTRL_MASK,
912 PL2303_HXN_FLOWCTRL_NONE);
913 } else {
914 pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0);
915 }
916 }
917
918 kfree(buf);
919}
920
921static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
922{
923 struct pl2303_private *priv = usb_get_serial_port_data(port);
924 unsigned long flags;
925 u8 control;
926
927 spin_lock_irqsave(&priv->lock, flags);
928 if (on)
929 priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
930 else
931 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
932 control = priv->line_control;
933 spin_unlock_irqrestore(&priv->lock, flags);
934
935 pl2303_set_control_lines(port, control);
936}
937
938static void pl2303_close(struct usb_serial_port *port)
939{
940 usb_serial_generic_close(port);
941 usb_kill_urb(port->interrupt_in_urb);
942 pl2303_set_break(port, false);
943}
944
945static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
946{
947 struct usb_serial *serial = port->serial;
948 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
949 int result;
950
951 if (spriv->quirks & PL2303_QUIRK_LEGACY) {
952 usb_clear_halt(serial->dev, port->write_urb->pipe);
953 usb_clear_halt(serial->dev, port->read_urb->pipe);
954 } else {
955 /* reset upstream data pipes */
956 if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
957 pl2303_vendor_write(serial, PL2303_HXN_RESET_REG,
958 PL2303_HXN_RESET_UPSTREAM_PIPE |
959 PL2303_HXN_RESET_DOWNSTREAM_PIPE);
960 } else {
961 pl2303_vendor_write(serial, 8, 0);
962 pl2303_vendor_write(serial, 9, 0);
963 }
964 }
965
966 /* Setup termios */
967 if (tty)
968 pl2303_set_termios(tty, port, NULL);
969
970 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
971 if (result) {
972 dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
973 result);
974 return result;
975 }
976
977 result = usb_serial_generic_open(tty, port);
978 if (result) {
979 usb_kill_urb(port->interrupt_in_urb);
980 return result;
981 }
982
983 return 0;
984}
985
986static int pl2303_tiocmset(struct tty_struct *tty,
987 unsigned int set, unsigned int clear)
988{
989 struct usb_serial_port *port = tty->driver_data;
990 struct pl2303_private *priv = usb_get_serial_port_data(port);
991 unsigned long flags;
992 u8 control;
993 int ret;
994
995 spin_lock_irqsave(&priv->lock, flags);
996 if (set & TIOCM_RTS)
997 priv->line_control |= CONTROL_RTS;
998 if (set & TIOCM_DTR)
999 priv->line_control |= CONTROL_DTR;
1000 if (clear & TIOCM_RTS)
1001 priv->line_control &= ~CONTROL_RTS;
1002 if (clear & TIOCM_DTR)
1003 priv->line_control &= ~CONTROL_DTR;
1004 control = priv->line_control;
1005 spin_unlock_irqrestore(&priv->lock, flags);
1006
1007 ret = pl2303_set_control_lines(port, control);
1008 if (ret)
1009 return usb_translate_errors(ret);
1010
1011 return 0;
1012}
1013
1014static int pl2303_tiocmget(struct tty_struct *tty)
1015{
1016 struct usb_serial_port *port = tty->driver_data;
1017 struct pl2303_private *priv = usb_get_serial_port_data(port);
1018 unsigned long flags;
1019 unsigned int mcr;
1020 unsigned int status;
1021 unsigned int result;
1022
1023 spin_lock_irqsave(&priv->lock, flags);
1024 mcr = priv->line_control;
1025 status = priv->line_status;
1026 spin_unlock_irqrestore(&priv->lock, flags);
1027
1028 result = ((mcr & CONTROL_DTR) ? TIOCM_DTR : 0)
1029 | ((mcr & CONTROL_RTS) ? TIOCM_RTS : 0)
1030 | ((status & UART_CTS) ? TIOCM_CTS : 0)
1031 | ((status & UART_DSR) ? TIOCM_DSR : 0)
1032 | ((status & UART_RING) ? TIOCM_RI : 0)
1033 | ((status & UART_DCD) ? TIOCM_CD : 0);
1034
1035 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
1036
1037 return result;
1038}
1039
1040static int pl2303_carrier_raised(struct usb_serial_port *port)
1041{
1042 struct pl2303_private *priv = usb_get_serial_port_data(port);
1043
1044 if (priv->line_status & UART_DCD)
1045 return 1;
1046
1047 return 0;
1048}
1049
1050static void pl2303_set_break(struct usb_serial_port *port, bool enable)
1051{
1052 struct usb_serial *serial = port->serial;
1053 u16 state;
1054 int result;
1055
1056 if (enable)
1057 state = BREAK_ON;
1058 else
1059 state = BREAK_OFF;
1060
1061 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
1062 state == BREAK_OFF ? "off" : "on");
1063
1064 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
1065 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
1066 0, NULL, 0, 100);
1067 if (result)
1068 dev_err(&port->dev, "error sending break = %d\n", result);
1069}
1070
1071static void pl2303_break_ctl(struct tty_struct *tty, int state)
1072{
1073 struct usb_serial_port *port = tty->driver_data;
1074
1075 pl2303_set_break(port, state);
1076}
1077
1078static void pl2303_update_line_status(struct usb_serial_port *port,
1079 unsigned char *data,
1080 unsigned int actual_length)
1081{
1082 struct usb_serial *serial = port->serial;
1083 struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
1084 struct pl2303_private *priv = usb_get_serial_port_data(port);
1085 struct tty_struct *tty;
1086 unsigned long flags;
1087 unsigned int status_idx = UART_STATE_INDEX;
1088 u8 status;
1089 u8 delta;
1090
1091 if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
1092 status_idx = 0;
1093
1094 if (actual_length < status_idx + 1)
1095 return;
1096
1097 status = data[status_idx];
1098
1099 /* Save off the uart status for others to look at */
1100 spin_lock_irqsave(&priv->lock, flags);
1101 delta = priv->line_status ^ status;
1102 priv->line_status = status;
1103 spin_unlock_irqrestore(&priv->lock, flags);
1104
1105 if (status & UART_BREAK_ERROR)
1106 usb_serial_handle_break(port);
1107
1108 if (delta & UART_STATE_MSR_MASK) {
1109 if (delta & UART_CTS)
1110 port->icount.cts++;
1111 if (delta & UART_DSR)
1112 port->icount.dsr++;
1113 if (delta & UART_RING)
1114 port->icount.rng++;
1115 if (delta & UART_DCD) {
1116 port->icount.dcd++;
1117 tty = tty_port_tty_get(&port->port);
1118 if (tty) {
1119 usb_serial_handle_dcd_change(port, tty,
1120 status & UART_DCD);
1121 tty_kref_put(tty);
1122 }
1123 }
1124
1125 wake_up_interruptible(&port->port.delta_msr_wait);
1126 }
1127}
1128
1129static void pl2303_read_int_callback(struct urb *urb)
1130{
1131 struct usb_serial_port *port = urb->context;
1132 unsigned char *data = urb->transfer_buffer;
1133 unsigned int actual_length = urb->actual_length;
1134 int status = urb->status;
1135 int retval;
1136
1137 switch (status) {
1138 case 0:
1139 /* success */
1140 break;
1141 case -ECONNRESET:
1142 case -ENOENT:
1143 case -ESHUTDOWN:
1144 /* this urb is terminated, clean up */
1145 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
1146 __func__, status);
1147 return;
1148 default:
1149 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
1150 __func__, status);
1151 goto exit;
1152 }
1153
1154 usb_serial_debug_data(&port->dev, __func__,
1155 urb->actual_length, urb->transfer_buffer);
1156
1157 pl2303_update_line_status(port, data, actual_length);
1158
1159exit:
1160 retval = usb_submit_urb(urb, GFP_ATOMIC);
1161 if (retval) {
1162 dev_err(&port->dev,
1163 "%s - usb_submit_urb failed with result %d\n",
1164 __func__, retval);
1165 }
1166}
1167
1168static void pl2303_process_read_urb(struct urb *urb)
1169{
1170 struct usb_serial_port *port = urb->context;
1171 struct pl2303_private *priv = usb_get_serial_port_data(port);
1172 unsigned char *data = urb->transfer_buffer;
1173 char tty_flag = TTY_NORMAL;
1174 unsigned long flags;
1175 u8 line_status;
1176 int i;
1177
1178 /* update line status */
1179 spin_lock_irqsave(&priv->lock, flags);
1180 line_status = priv->line_status;
1181 priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
1182 spin_unlock_irqrestore(&priv->lock, flags);
1183
1184 if (!urb->actual_length)
1185 return;
1186
1187 /*
1188 * Break takes precedence over parity, which takes precedence over
1189 * framing errors.
1190 */
1191 if (line_status & UART_BREAK_ERROR)
1192 tty_flag = TTY_BREAK;
1193 else if (line_status & UART_PARITY_ERROR)
1194 tty_flag = TTY_PARITY;
1195 else if (line_status & UART_FRAME_ERROR)
1196 tty_flag = TTY_FRAME;
1197
1198 if (tty_flag != TTY_NORMAL)
1199 dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
1200 tty_flag);
1201 /* overrun is special, not associated with a char */
1202 if (line_status & UART_OVERRUN_ERROR)
1203 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
1204
1205 if (port->sysrq) {
1206 for (i = 0; i < urb->actual_length; ++i)
1207 if (!usb_serial_handle_sysrq_char(port, data[i]))
1208 tty_insert_flip_char(&port->port, data[i],
1209 tty_flag);
1210 } else {
1211 tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
1212 urb->actual_length);
1213 }
1214
1215 tty_flip_buffer_push(&port->port);
1216}
1217
1218static struct usb_serial_driver pl2303_device = {
1219 .driver = {
1220 .owner = THIS_MODULE,
1221 .name = "pl2303",
1222 },
1223 .id_table = id_table,
1224 .num_bulk_in = 1,
1225 .num_bulk_out = 1,
1226 .num_interrupt_in = 0, /* see pl2303_calc_num_ports */
1227 .bulk_in_size = 256,
1228 .bulk_out_size = 256,
1229 .open = pl2303_open,
1230 .close = pl2303_close,
1231 .dtr_rts = pl2303_dtr_rts,
1232 .carrier_raised = pl2303_carrier_raised,
1233 .break_ctl = pl2303_break_ctl,
1234 .set_termios = pl2303_set_termios,
1235 .tiocmget = pl2303_tiocmget,
1236 .tiocmset = pl2303_tiocmset,
1237 .tiocmiwait = usb_serial_generic_tiocmiwait,
1238 .process_read_urb = pl2303_process_read_urb,
1239 .read_int_callback = pl2303_read_int_callback,
1240 .probe = pl2303_probe,
1241 .calc_num_ports = pl2303_calc_num_ports,
1242 .attach = pl2303_startup,
1243 .release = pl2303_release,
1244 .port_probe = pl2303_port_probe,
1245 .port_remove = pl2303_port_remove,
1246};
1247
1248static struct usb_serial_driver * const serial_drivers[] = {
1249 &pl2303_device, NULL
1250};
1251
1252module_usb_serial_driver(serial_drivers, id_table);
1253
1254MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
1255MODULE_LICENSE("GPL v2");