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