pl2303.c 27.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
/*
 * Prolific PL2303 USB to serial adaptor driver
 *
4
 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
Linus Torvalds's avatar
Linus Torvalds committed
5
6
7
8
 * Copyright (C) 2003 IBM Corp.
 *
 * Original driver for 2.2.x by anonymous
 *
9
10
11
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License version
 *	2 as published by the Free Software Foundation.
Linus Torvalds's avatar
Linus Torvalds committed
12
 *
Alan Cox's avatar
Alan Cox committed
13
14
 * See Documentation/usb/usb-serial.txt for more information on using this
 * driver
Linus Torvalds's avatar
Linus Torvalds committed
15
16
17
18
19
20
21
22
23
24
25
26
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/serial.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/spinlock.h>
Alan Cox's avatar
Alan Cox committed
27
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
28
#include <linux/usb.h>
29
#include <linux/usb/serial.h>
30
#include <asm/unaligned.h>
Linus Torvalds's avatar
Linus Torvalds committed
31
32
#include "pl2303.h"

33
34

#define PL2303_QUIRK_UART_STATE_IDX0		BIT(0)
35
#define PL2303_QUIRK_LEGACY			BIT(1)
36

37
static const struct usb_device_id id_table[] = {
Linus Torvalds's avatar
Linus Torvalds committed
38
39
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
40
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
Linus Torvalds's avatar
Linus Torvalds committed
41
42
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
Max Arnold's avatar
Max Arnold committed
43
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
Steve Murphy's avatar
Steve Murphy committed
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) },
Linus Torvalds's avatar
Linus Torvalds committed
49
	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
50
	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
Linus Torvalds's avatar
Linus Torvalds committed
51
	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
52
	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
Linus Torvalds's avatar
Linus Torvalds committed
53
54
55
56
	{ USB_DEVICE(ATEN_VENDOR_ID2, ATEN_PRODUCT_ID) },
	{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID) },
	{ USB_DEVICE(ELCOM_VENDOR_ID, ELCOM_PRODUCT_ID_UCSGT) },
	{ USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID) },
57
	{ USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
Linus Torvalds's avatar
Linus Torvalds committed
58
59
60
61
62
63
64
	{ USB_DEVICE(MA620_VENDOR_ID, MA620_PRODUCT_ID) },
	{ USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID) },
	{ USB_DEVICE(TRIPP_VENDOR_ID, TRIPP_PRODUCT_ID) },
	{ USB_DEVICE(RADIOSHACK_VENDOR_ID, RADIOSHACK_PRODUCT_ID) },
	{ USB_DEVICE(DCU10_VENDOR_ID, DCU10_PRODUCT_ID) },
	{ USB_DEVICE(SITECOM_VENDOR_ID, SITECOM_PRODUCT_ID) },
	{ USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_ID) },
65
66
67
68
69
70
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1),
		.driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65),
		.driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75),
		.driver_info = PL2303_QUIRK_UART_STATE_IDX0 },
71
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
72
	{ USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
73
	{ USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
74
75
	{ USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
	{ USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
76
	{ USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
77
	{ USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
78
	{ USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
79
	{ USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
80
	{ USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
81
	{ USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
82
	{ USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
83
	{ USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
84
	{ USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
Matthew Arnold's avatar
Matthew Arnold committed
85
	{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
86
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
87
88
89
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
	{ USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
	{ USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
90
	{ USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
91
	{ USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
92
	{ USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
93
	{ USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
94
	{ USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
95
	{ USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
Linus Torvalds's avatar
Linus Torvalds committed
96
97
98
	{ }					/* Terminating entry */
};

99
MODULE_DEVICE_TABLE(usb, id_table);
Linus Torvalds's avatar
Linus Torvalds committed
100
101
102
103
104
105
106
107
108
109

#define SET_LINE_REQUEST_TYPE		0x21
#define SET_LINE_REQUEST		0x20

#define SET_CONTROL_REQUEST_TYPE	0x21
#define SET_CONTROL_REQUEST		0x22
#define CONTROL_DTR			0x01
#define CONTROL_RTS			0x02

#define BREAK_REQUEST_TYPE		0x21
Alan Cox's avatar
Alan Cox committed
110
#define BREAK_REQUEST			0x23
Linus Torvalds's avatar
Linus Torvalds committed
111
112
113
114
115
116
117
118
119
120
121
122
#define BREAK_ON			0xffff
#define BREAK_OFF			0x0000

#define GET_LINE_REQUEST_TYPE		0xa1
#define GET_LINE_REQUEST		0x21

#define VENDOR_WRITE_REQUEST_TYPE	0x40
#define VENDOR_WRITE_REQUEST		0x01

#define VENDOR_READ_REQUEST_TYPE	0xc0
#define VENDOR_READ_REQUEST		0x01

123
#define UART_STATE_INDEX		8
124
#define UART_STATE_MSR_MASK		0x8b
Linus Torvalds's avatar
Linus Torvalds committed
125
126
127
128
129
130
131
132
133
134
#define UART_STATE_TRANSIENT_MASK	0x74
#define UART_DCD			0x01
#define UART_DSR			0x02
#define UART_BREAK_ERROR		0x04
#define UART_RING			0x08
#define UART_FRAME_ERROR		0x10
#define UART_PARITY_ERROR		0x20
#define UART_OVERRUN_ERROR		0x40
#define UART_CTS			0x80

135
static void pl2303_set_break(struct usb_serial_port *port, bool enable);
Linus Torvalds's avatar
Linus Torvalds committed
136
137

enum pl2303_type {
138
139
	TYPE_01,	/* Type 0 and 1 (difference unknown) */
	TYPE_HX,	/* HX version of the pl2303 chip */
140
141
142
143
144
145
	TYPE_COUNT
};

struct pl2303_type_data {
	speed_t max_baud_rate;
	unsigned long quirks;
Linus Torvalds's avatar
Linus Torvalds committed
146
147
};

148
struct pl2303_serial_private {
149
	const struct pl2303_type_data *type;
150
	unsigned long quirks;
151
152
};

Linus Torvalds's avatar
Linus Torvalds committed
153
154
155
156
struct pl2303_private {
	spinlock_t lock;
	u8 line_control;
	u8 line_status;
157
158

	u8 line_settings[7];
Linus Torvalds's avatar
Linus Torvalds committed
159
160
};

161
static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
162
163
164
165
	[TYPE_01] = {
		.max_baud_rate =	1228800,
		.quirks =		PL2303_QUIRK_LEGACY,
	},
166
167
168
	[TYPE_HX] = {
		.max_baud_rate =	12000000,
	},
169
170
};

171
172
static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
							unsigned char buf[1])
173
{
174
	struct device *dev = &serial->interface->dev;
175
176
177
	int res;

	res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
178
			VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
179
180
181
182
183
184
185
186
187
			value, 0, buf, 1, 100);
	if (res != 1) {
		dev_err(dev, "%s - failed to read [%04x]: %d\n", __func__,
								value, res);
		if (res >= 0)
			res = -EIO;

		return res;
	}
188

189
	dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, buf[0]);
190

191
	return 0;
192
193
}

194
static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
195
{
196
	struct device *dev = &serial->interface->dev;
197
198
	int res;

199
200
	dev_dbg(dev, "%s - [%04x] = %02x\n", __func__, value, index);

201
	res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
202
203
			VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
			value, index, NULL, 0, 100);
204
205
206
207
208
	if (res) {
		dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
								value, res);
		return res;
	}
209

210
	return 0;
211
212
}

213
214
215
216
217
218
219
220
static int pl2303_probe(struct usb_serial *serial,
					const struct usb_device_id *id)
{
	usb_set_serial_data(serial, (void *)id->driver_info);

	return 0;
}

221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
static int pl2303_calc_num_ports(struct usb_serial *serial,
					struct usb_serial_endpoints *epds)
{
	struct usb_interface *interface = serial->interface;
	struct usb_device *dev = serial->dev;
	struct device *ddev = &interface->dev;
	struct usb_host_interface *iface_desc;
	struct usb_endpoint_descriptor *endpoint;
	unsigned int i;

	/* BEGIN HORRIBLE HACK FOR PL2303 */
	/* this is needed due to the looney way its endpoints are set up */
	if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
	     (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
	    ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
	     (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
	    ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
	     (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
	    ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
	     (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
		if (interface != dev->actconfig->interface[0]) {
			/* check out the endpoints of the other interface*/
			iface_desc = dev->actconfig->interface[0]->cur_altsetting;
			for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
				endpoint = &iface_desc->endpoint[i].desc;
				if (usb_endpoint_is_int_in(endpoint)) {
					/* we found a interrupt in endpoint */
					dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
					if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
						epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
				}
			}
		}

		/* Now make sure the PL-2303 is configured correctly.
		 * If not, give up now and hope this hack will work
		 * properly during a later invocation of usb_serial_probe
		 */
		if (epds->num_bulk_in == 0 || epds->num_bulk_out == 0) {
			dev_info(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
			return -ENODEV;
		}
	}
	/* END HORRIBLE HACK FOR PL2303 */

	if (epds->num_interrupt_in < 1) {
		dev_err(ddev, "required interrupt-in endpoint missing\n");
		return -ENODEV;
	}

	return 1;
}

274
static int pl2303_startup(struct usb_serial *serial)
Linus Torvalds's avatar
Linus Torvalds committed
275
{
276
	struct pl2303_serial_private *spriv;
277
	enum pl2303_type type = TYPE_01;
278
	unsigned char *buf;
279
280
281
282

	spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
	if (!spriv)
		return -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
283

284
	buf = kmalloc(1, GFP_KERNEL);
285
286
	if (!buf) {
		kfree(spriv);
287
		return -ENOMEM;
288
	}
289

290
	if (serial->dev->descriptor.bDeviceClass == 0x02)
291
		type = TYPE_01;		/* type 0 */
292
	else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
293
		type = TYPE_HX;
294
	else if (serial->dev->descriptor.bDeviceClass == 0x00)
295
		type = TYPE_01;		/* type 1 */
296
	else if (serial->dev->descriptor.bDeviceClass == 0xFF)
297
		type = TYPE_01;		/* type 1 */
298
	dev_dbg(&serial->interface->dev, "device type: %d\n", type);
Linus Torvalds's avatar
Linus Torvalds committed
299

300
	spriv->type = &pl2303_type_data[type];
301
	spriv->quirks = (unsigned long)usb_get_serial_data(serial);
302
	spriv->quirks |= spriv->type->quirks;
303

304
	usb_set_serial_data(serial, spriv);
305

306
307
308
309
310
311
312
313
314
315
	pl2303_vendor_read(serial, 0x8484, buf);
	pl2303_vendor_write(serial, 0x0404, 0);
	pl2303_vendor_read(serial, 0x8484, buf);
	pl2303_vendor_read(serial, 0x8383, buf);
	pl2303_vendor_read(serial, 0x8484, buf);
	pl2303_vendor_write(serial, 0x0404, 1);
	pl2303_vendor_read(serial, 0x8484, buf);
	pl2303_vendor_read(serial, 0x8383, buf);
	pl2303_vendor_write(serial, 0, 1);
	pl2303_vendor_write(serial, 1, 0);
316
	if (spriv->quirks & PL2303_QUIRK_LEGACY)
317
		pl2303_vendor_write(serial, 2, 0x24);
318
319
	else
		pl2303_vendor_write(serial, 2, 0x44);
320
321

	kfree(buf);
322

Linus Torvalds's avatar
Linus Torvalds committed
323
	return 0;
324
}
Linus Torvalds's avatar
Linus Torvalds committed
325

326
327
static void pl2303_release(struct usb_serial *serial)
{
328
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344

	kfree(spriv);
}

static int pl2303_port_probe(struct usb_serial_port *port)
{
	struct pl2303_private *priv;

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	spin_lock_init(&priv->lock);

	usb_set_serial_port_data(port, priv);

345
346
	port->port.drain_delay = 256;

347
348
349
350
351
	return 0;
}

static int pl2303_port_remove(struct usb_serial_port *port)
{
352
	struct pl2303_private *priv = usb_get_serial_port_data(port);
353
354
355
356

	kfree(priv);

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
357
358
}

359
static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
Linus Torvalds's avatar
Linus Torvalds committed
360
{
361
	struct usb_device *dev = port->serial->dev;
Linus Torvalds's avatar
Linus Torvalds committed
362
	int retval;
Alan Cox's avatar
Alan Cox committed
363

364
365
	dev_dbg(&port->dev, "%s - %02x\n", __func__, value);

366
367
368
	retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
				 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
				 value, 0, NULL, 0, 100);
369
370
	if (retval)
		dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
371

Linus Torvalds's avatar
Linus Torvalds committed
372
373
374
	return retval;
}

375
/*
376
377
 * Returns the nearest supported baud rate that can be set directly without
 * using divisors.
378
379
 */
static speed_t pl2303_get_supported_baud_rate(speed_t baud)
Linus Torvalds's avatar
Linus Torvalds committed
380
{
381
382
383
	static const speed_t baud_sup[] = {
		75, 150, 300, 600, 1200, 1800, 2400, 3600, 4800, 7200, 9600,
		14400, 19200, 28800, 38400, 57600, 115200, 230400, 460800,
384
		614400, 921600, 1228800, 2457600, 3000000, 6000000
385
	};
Linus Torvalds's avatar
Linus Torvalds committed
386

387
	unsigned i;
388

389
390
391
392
	for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
		if (baud_sup[i] > baud)
			break;
	}
393

394
395
396
397
398
399
	if (i == ARRAY_SIZE(baud_sup))
		baud = baud_sup[i - 1];
	else if (i > 0 && (baud_sup[i] - baud) > (baud - baud_sup[i - 1]))
		baud = baud_sup[i - 1];
	else
		baud = baud_sup[i];
400

401
402
403
	return baud;
}

404
405
406
407
408
409
410
411
412
413
414
415
/*
 * NOTE: If unsupported baud rates are set directly, the PL2303 seems to
 *       use 9600 baud.
 */
static speed_t pl2303_encode_baud_rate_direct(unsigned char buf[4],
								speed_t baud)
{
	put_unaligned_le32(baud, buf);

	return baud;
}

416
417
418
static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
								speed_t baud)
{
419
	unsigned int baseline, mantissa, exponent;
420
421
422

	/*
	 * Apparently the formula is:
423
424
425
426
	 *   baudrate = 12M * 32 / (mantissa * 4^exponent)
	 * where
	 *   mantissa = buf[8:0]
	 *   exponent = buf[11:9]
427
	 */
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
	baseline = 12000000 * 32;
	mantissa = baseline / baud;
	if (mantissa == 0)
		mantissa = 1;	/* Avoid dividing by zero if baud > 32*12M. */
	exponent = 0;
	while (mantissa >= 512) {
		if (exponent < 7) {
			mantissa >>= 2;	/* divide by 4 */
			exponent++;
		} else {
			/* Exponent is maxed. Trim mantissa and leave. */
			mantissa = 511;
			break;
		}
	}

444
445
	buf[3] = 0x80;
	buf[2] = 0;
446
447
448
449
450
	buf[1] = exponent << 1 | mantissa >> 8;
	buf[0] = mantissa & 0xff;

	/* Calculate and return the exact baud rate. */
	baud = (baseline / mantissa) >> (exponent << 1);
451
452
453
454

	return baud;
}

455
456
457
458
459
460
static void pl2303_encode_baud_rate(struct tty_struct *tty,
					struct usb_serial_port *port,
					u8 buf[4])
{
	struct usb_serial *serial = port->serial;
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
461
	speed_t	baud_sup;
462
463
464
465
466
467
	speed_t baud;

	baud = tty_get_baud_rate(tty);
	dev_dbg(&port->dev, "baud requested = %u\n", baud);
	if (!baud)
		return;
468
469
470

	if (spriv->type->max_baud_rate)
		baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
471
	/*
472
	 * Use direct method for supported baud rates, otherwise use divisors.
473
474
	 */
	baud_sup = pl2303_get_supported_baud_rate(baud);
475

476
477
	if (baud == baud_sup)
		baud = pl2303_encode_baud_rate_direct(buf, baud);
478
	else
479
		baud = pl2303_encode_baud_rate_divisor(buf, baud);
480

481
	/* Save resulting baud rate */
482
	tty_encode_baud_rate(tty, baud, baud);
483
	dev_dbg(&port->dev, "baud set = %u\n", baud);
484
485
}

486
487
488
489
490
491
492
493
494
495
496
497
static int pl2303_get_line_request(struct usb_serial_port *port,
							unsigned char buf[7])
{
	struct usb_device *udev = port->serial->dev;
	int ret;

	ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
				GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
				0, 0, buf, 7, 100);
	if (ret != 7) {
		dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);

498
		if (ret >= 0)
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
			ret = -EIO;

		return ret;
	}

	dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);

	return 0;
}

static int pl2303_set_line_request(struct usb_serial_port *port,
							unsigned char buf[7])
{
	struct usb_device *udev = port->serial->dev;
	int ret;

	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
				SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
				0, 0, buf, 7, 100);
518
	if (ret < 0) {
519
520
521
522
523
524
525
526
527
		dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
		return ret;
	}

	dev_dbg(&port->dev, "%s - %7ph\n", __func__, buf);

	return 0;
}

528
529
530
531
532
533
534
535
static void pl2303_set_termios(struct tty_struct *tty,
		struct usb_serial_port *port, struct ktermios *old_termios)
{
	struct usb_serial *serial = port->serial;
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	unsigned char *buf;
536
	int ret;
537
538
539
540
541
542
543
544
545
546
547
548
549
	u8 control;

	if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
		return;

	buf = kzalloc(7, GFP_KERNEL);
	if (!buf) {
		/* Report back no change occurred */
		if (old_termios)
			tty->termios = *old_termios;
		return;
	}

550
	pl2303_get_line_request(port, buf);
551

552
553
554
555
556
557
558
559
560
561
562
563
564
	switch (C_CSIZE(tty)) {
	case CS5:
		buf[6] = 5;
		break;
	case CS6:
		buf[6] = 6;
		break;
	case CS7:
		buf[6] = 7;
		break;
	default:
	case CS8:
		buf[6] = 8;
565
	}
566
	dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
567

568
	/* For reference buf[0]:buf[3] baud rate value */
569
	pl2303_encode_baud_rate(tty, port, &buf[0]);
570

Linus Torvalds's avatar
Linus Torvalds committed
571
572
573
	/* For reference buf[4]=0 is 1 stop bits */
	/* For reference buf[4]=1 is 1.5 stop bits */
	/* For reference buf[4]=2 is 2 stop bits */
574
575
576
	if (C_CSTOPB(tty)) {
		/*
		 * NOTE: Comply with "real" UARTs / RS232:
577
578
		 *       use 1.5 instead of 2 stop bits with 5 data bits
		 */
579
		if (C_CSIZE(tty) == CS5) {
580
			buf[4] = 1;
581
			dev_dbg(&port->dev, "stop bits = 1.5\n");
582
583
		} else {
			buf[4] = 2;
584
			dev_dbg(&port->dev, "stop bits = 2\n");
585
		}
Linus Torvalds's avatar
Linus Torvalds committed
586
587
	} else {
		buf[4] = 0;
588
		dev_dbg(&port->dev, "stop bits = 1\n");
Linus Torvalds's avatar
Linus Torvalds committed
589
590
	}

591
	if (C_PARENB(tty)) {
Linus Torvalds's avatar
Linus Torvalds committed
592
593
594
595
596
		/* For reference buf[5]=0 is none parity */
		/* For reference buf[5]=1 is odd parity */
		/* For reference buf[5]=2 is even parity */
		/* For reference buf[5]=3 is mark parity */
		/* For reference buf[5]=4 is space parity */
597
		if (C_PARODD(tty)) {
Johan Hovold's avatar
Johan Hovold committed
598
			if (C_CMSPAR(tty)) {
599
				buf[5] = 3;
600
				dev_dbg(&port->dev, "parity = mark\n");
601
602
			} else {
				buf[5] = 1;
603
				dev_dbg(&port->dev, "parity = odd\n");
604
			}
Linus Torvalds's avatar
Linus Torvalds committed
605
		} else {
Johan Hovold's avatar
Johan Hovold committed
606
			if (C_CMSPAR(tty)) {
607
				buf[5] = 4;
608
				dev_dbg(&port->dev, "parity = space\n");
609
610
			} else {
				buf[5] = 2;
611
				dev_dbg(&port->dev, "parity = even\n");
612
			}
Linus Torvalds's avatar
Linus Torvalds committed
613
614
615
		}
	} else {
		buf[5] = 0;
616
		dev_dbg(&port->dev, "parity = none\n");
Linus Torvalds's avatar
Linus Torvalds committed
617
618
	}

619
620
621
622
623
624
625
626
627
628
629
630
631
	/*
	 * Some PL2303 are known to lose bytes if you change serial settings
	 * even to the same values as before. Thus we actually need to filter
	 * in this specific case.
	 *
	 * Note that the tty_termios_hw_change check above is not sufficient
	 * as a previously requested baud rate may differ from the one
	 * actually used (and stored in old_termios).
	 *
	 * NOTE: No additional locking needed for line_settings as it is
	 *       only used in set_termios, which is serialised against itself.
	 */
	if (!old_termios || memcmp(buf, priv->line_settings, 7)) {
632
633
		ret = pl2303_set_line_request(port, buf);
		if (!ret)
634
635
			memcpy(priv->line_settings, buf, 7);
	}
Linus Torvalds's avatar
Linus Torvalds committed
636
637
638
639

	/* change control lines if we are switching to or from B0 */
	spin_lock_irqsave(&priv->lock, flags);
	control = priv->line_control;
640
	if (C_BAUD(tty) == B0)
Linus Torvalds's avatar
Linus Torvalds committed
641
		priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
642
	else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
Linus Torvalds's avatar
Linus Torvalds committed
643
644
645
646
		priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
	if (control != priv->line_control) {
		control = priv->line_control;
		spin_unlock_irqrestore(&priv->lock, flags);
647
		pl2303_set_control_lines(port, control);
Linus Torvalds's avatar
Linus Torvalds committed
648
649
650
	} else {
		spin_unlock_irqrestore(&priv->lock, flags);
	}
651

652
	if (C_CRTSCTS(tty)) {
653
		if (spriv->quirks & PL2303_QUIRK_LEGACY)
654
			pl2303_vendor_write(serial, 0x0, 0x41);
655
656
		else
			pl2303_vendor_write(serial, 0x0, 0x61);
t.sefzick's avatar
t.sefzick committed
657
	} else {
658
		pl2303_vendor_write(serial, 0x0, 0x0);
Linus Torvalds's avatar
Linus Torvalds committed
659
	}
660
661
662
663

	kfree(buf);
}

664
665
666
667
668
669
670
671
672
673
674
675
676
static void pl2303_dtr_rts(struct usb_serial_port *port, int on)
{
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	u8 control;

	spin_lock_irqsave(&priv->lock, flags);
	if (on)
		priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
	else
		priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
	control = priv->line_control;
	spin_unlock_irqrestore(&priv->lock, flags);
677

678
	pl2303_set_control_lines(port, control);
679
680
681
}

static void pl2303_close(struct usb_serial_port *port)
682
{
Johan Hovold's avatar
Johan Hovold committed
683
	usb_serial_generic_close(port);
684
	usb_kill_urb(port->interrupt_in_urb);
685
	pl2303_set_break(port, false);
Linus Torvalds's avatar
Linus Torvalds committed
686
687
}

688
static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds's avatar
Linus Torvalds committed
689
690
{
	struct usb_serial *serial = port->serial;
691
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
Linus Torvalds's avatar
Linus Torvalds committed
692
693
	int result;

694
	if (spriv->quirks & PL2303_QUIRK_LEGACY) {
695
696
		usb_clear_halt(serial->dev, port->write_urb->pipe);
		usb_clear_halt(serial->dev, port->read_urb->pipe);
697
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
698
		/* reset upstream data pipes */
699
700
		pl2303_vendor_write(serial, 8, 0);
		pl2303_vendor_write(serial, 9, 0);
Linus Torvalds's avatar
Linus Torvalds committed
701
702
703
	}

	/* Setup termios */
Alan Cox's avatar
Alan Cox committed
704
	if (tty)
705
		pl2303_set_termios(tty, port, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
706

707
	result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
708
	if (result) {
709
710
		dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
			result);
711
		return result;
Linus Torvalds's avatar
Linus Torvalds committed
712
	}
713

714
	result = usb_serial_generic_open(tty, port);
715
716
717
718
719
	if (result) {
		usb_kill_urb(port->interrupt_in_urb);
		return result;
	}

Linus Torvalds's avatar
Linus Torvalds committed
720
721
722
	return 0;
}

723
static int pl2303_tiocmset(struct tty_struct *tty,
724
			   unsigned int set, unsigned int clear)
Linus Torvalds's avatar
Linus Torvalds committed
725
{
Alan Cox's avatar
Alan Cox committed
726
	struct usb_serial_port *port = tty->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
727
728
729
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	u8 control;
730
	int ret;
731

732
	spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
733
734
735
736
737
738
739
740
741
	if (set & TIOCM_RTS)
		priv->line_control |= CONTROL_RTS;
	if (set & TIOCM_DTR)
		priv->line_control |= CONTROL_DTR;
	if (clear & TIOCM_RTS)
		priv->line_control &= ~CONTROL_RTS;
	if (clear & TIOCM_DTR)
		priv->line_control &= ~CONTROL_DTR;
	control = priv->line_control;
742
	spin_unlock_irqrestore(&priv->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
743

744
745
746
	ret = pl2303_set_control_lines(port, control);
	if (ret)
		return usb_translate_errors(ret);
747

748
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
749
750
}

751
static int pl2303_tiocmget(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
752
{
Alan Cox's avatar
Alan Cox committed
753
	struct usb_serial_port *port = tty->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
754
755
756
757
758
759
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	unsigned int mcr;
	unsigned int status;
	unsigned int result;

760
	spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
761
762
	mcr = priv->line_control;
	status = priv->line_status;
763
	spin_unlock_irqrestore(&priv->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
764
765
766
767
768
769
770
771

	result = ((mcr & CONTROL_DTR)		? TIOCM_DTR : 0)
		  | ((mcr & CONTROL_RTS)	? TIOCM_RTS : 0)
		  | ((status & UART_CTS)	? TIOCM_CTS : 0)
		  | ((status & UART_DSR)	? TIOCM_DSR : 0)
		  | ((status & UART_RING)	? TIOCM_RI  : 0)
		  | ((status & UART_DCD)	? TIOCM_CD  : 0);

772
	dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
Linus Torvalds's avatar
Linus Torvalds committed
773
774
775
776

	return result;
}

777
778
779
static int pl2303_carrier_raised(struct usb_serial_port *port)
{
	struct pl2303_private *priv = usb_get_serial_port_data(port);
780

781
782
	if (priv->line_status & UART_DCD)
		return 1;
783

784
785
786
	return 0;
}

787
static int pl2303_ioctl(struct tty_struct *tty,
788
			unsigned int cmd, unsigned long arg)
Linus Torvalds's avatar
Linus Torvalds committed
789
{
790
	struct serial_struct ser;
Alan Cox's avatar
Alan Cox committed
791
	struct usb_serial_port *port = tty->driver_data;
792

Linus Torvalds's avatar
Linus Torvalds committed
793
	switch (cmd) {
794
795
796
	case TIOCGSERIAL:
		memset(&ser, 0, sizeof ser);
		ser.type = PORT_16654;
797
		ser.line = port->minor;
798
		ser.port = port->port_number;
799
800
801
802
803
804
		ser.baud_base = 460800;

		if (copy_to_user((void __user *)arg, &ser, sizeof ser))
			return -EFAULT;

		return 0;
Alan Cox's avatar
Alan Cox committed
805
806
	default:
		break;
Linus Torvalds's avatar
Linus Torvalds committed
807
	}
808

Linus Torvalds's avatar
Linus Torvalds committed
809
810
811
	return -ENOIOCTLCMD;
}

812
static void pl2303_set_break(struct usb_serial_port *port, bool enable)
Linus Torvalds's avatar
Linus Torvalds committed
813
814
815
816
817
{
	struct usb_serial *serial = port->serial;
	u16 state;
	int result;

818
	if (enable)
Linus Torvalds's avatar
Linus Torvalds committed
819
		state = BREAK_ON;
820
821
	else
		state = BREAK_OFF;
822

823
	dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
Alan Cox's avatar
Alan Cox committed
824
			state == BREAK_OFF ? "off" : "on");
Linus Torvalds's avatar
Linus Torvalds committed
825

826
827
828
	result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
				 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
				 0, NULL, 0, 100);
Linus Torvalds's avatar
Linus Torvalds committed
829
	if (result)
830
		dev_err(&port->dev, "error sending break = %d\n", result);
Linus Torvalds's avatar
Linus Torvalds committed
831
832
}

833
834
835
836
837
838
839
static void pl2303_break_ctl(struct tty_struct *tty, int state)
{
	struct usb_serial_port *port = tty->driver_data;

	pl2303_set_break(port, state);
}

Flavio Leitner's avatar
Flavio Leitner committed
840
841
842
843
static void pl2303_update_line_status(struct usb_serial_port *port,
				      unsigned char *data,
				      unsigned int actual_length)
{
844
845
	struct usb_serial *serial = port->serial;
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
Flavio Leitner's avatar
Flavio Leitner committed
846
	struct pl2303_private *priv = usb_get_serial_port_data(port);
847
	struct tty_struct *tty;
Flavio Leitner's avatar
Flavio Leitner committed
848
	unsigned long flags;
849
	unsigned int status_idx = UART_STATE_INDEX;
850
851
	u8 status;
	u8 delta;
Flavio Leitner's avatar
Flavio Leitner committed
852

853
854
	if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
		status_idx = 0;
Flavio Leitner's avatar
Flavio Leitner committed
855

856
	if (actual_length < status_idx + 1)
857
		return;
Flavio Leitner's avatar
Flavio Leitner committed
858

859
860
	status = data[status_idx];

Alan Cox's avatar
Alan Cox committed
861
	/* Save off the uart status for others to look at */
Flavio Leitner's avatar
Flavio Leitner committed
862
	spin_lock_irqsave(&priv->lock, flags);
863
864
	delta = priv->line_status ^ status;
	priv->line_status = status;
Flavio Leitner's avatar
Flavio Leitner committed
865
	spin_unlock_irqrestore(&priv->lock, flags);
866

867
	if (status & UART_BREAK_ERROR)
868
		usb_serial_handle_break(port);
869

870
	if (delta & UART_STATE_MSR_MASK) {
871
872
873
874
875
876
		if (delta & UART_CTS)
			port->icount.cts++;
		if (delta & UART_DSR)
			port->icount.dsr++;
		if (delta & UART_RING)
			port->icount.rng++;
877
		if (delta & UART_DCD) {
878
			port->icount.dcd++;
879
880
881
			tty = tty_port_tty_get(&port->port);
			if (tty) {
				usb_serial_handle_dcd_change(port, tty,
882
							status & UART_DCD);
883
884
				tty_kref_put(tty);
			}
885
		}
886
887

		wake_up_interruptible(&port->port.delta_msr_wait);
888
	}
Flavio Leitner's avatar
Flavio Leitner committed
889
}
Linus Torvalds's avatar
Linus Torvalds committed
890

891
static void pl2303_read_int_callback(struct urb *urb)
Linus Torvalds's avatar
Linus Torvalds committed
892
{
893
	struct usb_serial_port *port =  urb->context;
Linus Torvalds's avatar
Linus Torvalds committed
894
	unsigned char *data = urb->transfer_buffer;
Flavio Leitner's avatar
Flavio Leitner committed
895
	unsigned int actual_length = urb->actual_length;
896
897
	int status = urb->status;
	int retval;
Linus Torvalds's avatar
Linus Torvalds committed
898

899
	switch (status) {
Linus Torvalds's avatar
Linus Torvalds committed
900
901
902
903
904
905
906
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
907
908
		dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
909
910
		return;
	default:
911
912
		dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
			__func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
913
914
915
		goto exit;
	}

916
	usb_serial_debug_data(&port->dev, __func__,
917
918
			      urb->actual_length, urb->transfer_buffer);

Flavio Leitner's avatar
Flavio Leitner committed
919
	pl2303_update_line_status(port, data, actual_length);
Linus Torvalds's avatar
Linus Torvalds committed
920
921

exit:
922
	retval = usb_submit_urb(urb, GFP_ATOMIC);
923
	if (retval) {
924
		dev_err(&port->dev,
925
			"%s - usb_submit_urb failed with result %d\n",
926
			__func__, retval);
927
	}
Linus Torvalds's avatar
Linus Torvalds committed
928
929
}

930
static void pl2303_process_read_urb(struct urb *urb)
931
{
932
933
	struct usb_serial_port *port = urb->context;
	struct pl2303_private *priv = usb_get_serial_port_data(port);
934
935
	unsigned char *data = urb->transfer_buffer;
	char tty_flag = TTY_NORMAL;
936
937
938
939
940
941
942
943
944
945
946
947
948
	unsigned long flags;
	u8 line_status;
	int i;

	/* update line status */
	spin_lock_irqsave(&priv->lock, flags);
	line_status = priv->line_status;
	priv->line_status &= ~UART_STATE_TRANSIENT_MASK;
	spin_unlock_irqrestore(&priv->lock, flags);

	if (!urb->actual_length)
		return;

949
950
951
952
	/*
	 * Break takes precedence over parity, which takes precedence over
	 * framing errors.
	 */
953
954
955
956
957
958
959
	if (line_status & UART_BREAK_ERROR)
		tty_flag = TTY_BREAK;
	else if (line_status & UART_PARITY_ERROR)
		tty_flag = TTY_PARITY;
	else if (line_status & UART_FRAME_ERROR)
		tty_flag = TTY_FRAME;

960
961
962
	if (tty_flag != TTY_NORMAL)
		dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
								tty_flag);
963
964
	/* overrun is special, not associated with a char */
	if (line_status & UART_OVERRUN_ERROR)
Jiri Slaby's avatar
Jiri Slaby committed
965
		tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
966

967
	if (port->port.console && port->sysrq) {
968
		for (i = 0; i < urb->actual_length; ++i)
969
			if (!usb_serial_handle_sysrq_char(port, data[i]))
Jiri Slaby's avatar
Jiri Slaby committed
970
971
				tty_insert_flip_char(&port->port, data[i],
						tty_flag);
972
	} else {
973
		tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
974
							urb->actual_length);
975
	}
Linus Torvalds's avatar
Linus Torvalds committed
976

Jiri Slaby's avatar
Jiri Slaby committed
977
	tty_flip_buffer_push(&port->port);
Linus Torvalds's avatar
Linus Torvalds committed
978
979
}

980
981
982
983
984
985
static struct usb_serial_driver pl2303_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"pl2303",
	},
	.id_table =		id_table,
986
987
	.num_bulk_in =		1,
	.num_bulk_out =		1,
988
	.num_interrupt_in =	0,	/* see pl2303_calc_num_ports */
989
	.bulk_in_size =		256,
990
	.bulk_out_size =	256,
991
992
	.open