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