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");