1
2
3
4
5
6
7
8
9
10
11
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) },
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 { }
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
334
335
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
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
407
408 if (desc->bDeviceClass == 0x02)
409 return TYPE_H;
410
411 if (desc->bMaxPacketSize0 != 0x40) {
412 if (desc->bDeviceClass == 0x00 || desc->bDeviceClass == 0xff)
413 return TYPE_H;
414
415 return TYPE_H;
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
439
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
558
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
587
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
604
605
606
607
608
609 baseline = 12000000 * 32;
610 mantissa = baseline / baud;
611 if (mantissa == 0)
612 mantissa = 1;
613 exponent = 0;
614 while (mantissa >= 512) {
615 if (exponent < 7) {
616 mantissa >>= 2;
617 exponent++;
618 } else {
619
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
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
643
644
645
646
647
648 baseline = 12000000 * 32;
649 mantissa = baseline / baud;
650 if (mantissa == 0)
651 mantissa = 1;
652 exponent = 0;
653 while (mantissa >= 2048) {
654 if (exponent < 15) {
655 mantissa >>= 1;
656 exponent++;
657 } else {
658
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
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
693
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
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
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
807 pl2303_encode_baud_rate(tty, port, &buf[0]);
808
809
810
811
812 if (C_CSTOPB(tty)) {
813
814
815
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
831
832
833
834
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
859
860
861
862
863
864
865
866
867
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
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
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
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
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
1140 break;
1141 case -ECONNRESET:
1142 case -ENOENT:
1143 case -ESHUTDOWN:
1144
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
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
1189
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
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,
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");
1256
