pl2303.c 31.6 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
Linus Torvalds's avatar
Linus Torvalds committed
2
3
4
/*
 * Prolific PL2303 USB to serial adaptor driver
 *
5
 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
Linus Torvalds's avatar
Linus Torvalds committed
6
7
8
9
 * Copyright (C) 2003 IBM Corp.
 *
 * Original driver for 2.2.x by anonymous
 *
10
 * See Documentation/usb/usb-serial.rst for more information on using this
Alan Cox's avatar
Alan Cox committed
11
 * driver
Linus Torvalds's avatar
Linus Torvalds committed
12
13
14
15
16
17
18
19
20
21
22
23
 */

#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
24
#include <linux/uaccess.h>
Linus Torvalds's avatar
Linus Torvalds committed
25
#include <linux/usb.h>
26
#include <linux/usb/serial.h>
27
#include <asm/unaligned.h>
Linus Torvalds's avatar
Linus Torvalds committed
28
29
#include "pl2303.h"

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
37
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID),
		.driver_info = PL2303_QUIRK_ENDPOINT_HACK },
Linus Torvalds's avatar
Linus Torvalds committed
38
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
39
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
Linus Torvalds's avatar
Linus Torvalds committed
40
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
41
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_CHILITAG) },
Linus Torvalds's avatar
Linus Torvalds committed
42
	{ 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) },
49
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_TB) },
50
51
52
53
54
55
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GC) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GB) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GT) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GL) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GE) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GS) },
Linus Torvalds's avatar
Linus Torvalds committed
56
	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
57
	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
58
59
	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID),
		.driver_info = PL2303_QUIRK_ENDPOINT_HACK },
60
61
	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC485),
		.driver_info = PL2303_QUIRK_ENDPOINT_HACK },
62
63
	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_UC232B),
		.driver_info = PL2303_QUIRK_ENDPOINT_HACK },
64
	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID2) },
Linus Torvalds's avatar
Linus Torvalds committed
65
66
67
68
	{ 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) },
69
	{ USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
Linus Torvalds's avatar
Linus Torvalds committed
70
71
72
73
74
75
76
	{ 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) },
77
78
79
80
81
82
	{ 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 },
83
84
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81),
		.driver_info = PL2303_QUIRK_ENDPOINT_HACK },
85
	{ USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
86
	{ USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
87
88
	{ USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
	{ USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
89
	{ USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
90
	{ USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
91
	{ USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
92
	{ USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
93
	{ USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
94
95
	{ USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID),
		.driver_info = PL2303_QUIRK_ENDPOINT_HACK },
96
	{ USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
97
	{ USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
98
	{ USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
Matthew Arnold's avatar
Matthew Arnold committed
99
	{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
100
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
101
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220TA_PRODUCT_ID) },
102
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD381_PRODUCT_ID) },
103
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD381GC_PRODUCT_ID) },
104
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960_PRODUCT_ID) },
105
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD960TA_PRODUCT_ID) },
106
107
	{ USB_DEVICE(HP_VENDOR_ID, HP_LCM220_PRODUCT_ID) },
	{ USB_DEVICE(HP_VENDOR_ID, HP_LCM960_PRODUCT_ID) },
108
109
110
	{ USB_DEVICE(HP_VENDOR_ID, HP_LM920_PRODUCT_ID) },
	{ USB_DEVICE(HP_VENDOR_ID, HP_LM940_PRODUCT_ID) },
	{ USB_DEVICE(HP_VENDOR_ID, HP_TD620_PRODUCT_ID) },
111
	{ USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
112
	{ USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
113
	{ USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
114
	{ USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
115
	{ USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
116
	{ USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
117
	{ USB_DEVICE(AT_VENDOR_ID, AT_VTKIT3_PRODUCT_ID) },
Linus Torvalds's avatar
Linus Torvalds committed
118
119
120
	{ }					/* Terminating entry */
};

121
MODULE_DEVICE_TABLE(usb, id_table);
Linus Torvalds's avatar
Linus Torvalds committed
122
123
124
125
126
127
128
129
130
131

#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
132
#define BREAK_REQUEST			0x23
Linus Torvalds's avatar
Linus Torvalds committed
133
134
135
136
137
138
139
140
#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
141
#define VENDOR_WRITE_NREQUEST		0x80
Linus Torvalds's avatar
Linus Torvalds committed
142
143
144

#define VENDOR_READ_REQUEST_TYPE	0xc0
#define VENDOR_READ_REQUEST		0x01
145
#define VENDOR_READ_NREQUEST		0x81
Linus Torvalds's avatar
Linus Torvalds committed
146

147
#define UART_STATE_INDEX		8
148
#define UART_STATE_MSR_MASK		0x8b
Linus Torvalds's avatar
Linus Torvalds committed
149
150
151
152
153
154
155
156
157
158
#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

159
160
#define PL2303_FLOWCTRL_MASK		0xf0

161
162
163
164
165
166
167
168
169
170
171
172
#define PL2303_READ_TYPE_HX_STATUS	0x8080

#define PL2303_HXN_RESET_REG		0x07
#define PL2303_HXN_RESET_UPSTREAM_PIPE	0x02
#define PL2303_HXN_RESET_DOWNSTREAM_PIPE	0x01

#define PL2303_HXN_FLOWCTRL_REG		0x0a
#define PL2303_HXN_FLOWCTRL_MASK	0x1c
#define PL2303_HXN_FLOWCTRL_NONE	0x1c
#define PL2303_HXN_FLOWCTRL_RTS_CTS	0x18
#define PL2303_HXN_FLOWCTRL_XON_XOFF	0x0c

173
static void pl2303_set_break(struct usb_serial_port *port, bool enable);
Linus Torvalds's avatar
Linus Torvalds committed
174
175

enum pl2303_type {
176
	TYPE_H,
177
178
179
180
181
	TYPE_HX,
	TYPE_TA,
	TYPE_TB,
	TYPE_HXD,
	TYPE_HXN,
182
183
184
185
186
187
	TYPE_COUNT
};

struct pl2303_type_data {
	speed_t max_baud_rate;
	unsigned long quirks;
188
	unsigned int no_autoxonxoff:1;
189
	unsigned int no_divisors:1;
Linus Torvalds's avatar
Linus Torvalds committed
190
191
};

192
struct pl2303_serial_private {
193
	const struct pl2303_type_data *type;
194
	unsigned long quirks;
195
196
};

Linus Torvalds's avatar
Linus Torvalds committed
197
198
199
200
struct pl2303_private {
	spinlock_t lock;
	u8 line_control;
	u8 line_status;
201
202

	u8 line_settings[7];
Linus Torvalds's avatar
Linus Torvalds committed
203
204
};

205
static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
206
	[TYPE_H] = {
207
208
209
		.max_baud_rate		= 1228800,
		.quirks			= PL2303_QUIRK_LEGACY,
		.no_autoxonxoff		= true,
210
	},
211
	[TYPE_HX] = {
212
213
214
215
216
217
218
219
220
		.max_baud_rate		= 6000000,
	},
	[TYPE_TA] = {
		.max_baud_rate		= 6000000,
	},
	[TYPE_TB] = {
		.max_baud_rate		= 12000000,
	},
	[TYPE_HXD] = {
221
		.max_baud_rate		= 12000000,
222
	},
223
224
	[TYPE_HXN] = {
		.max_baud_rate		= 12000000,
225
		.no_divisors		= true,
226
	},
227
228
};

229
230
static int pl2303_vendor_read(struct usb_serial *serial, u16 value,
							unsigned char buf[1])
231
{
232
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
233
	struct device *dev = &serial->interface->dev;
234
	u8 request;
235
236
	int res;

237
238
239
240
241
	if (spriv->type == &pl2303_type_data[TYPE_HXN])
		request = VENDOR_READ_NREQUEST;
	else
		request = VENDOR_READ_REQUEST;

242
	res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
243
			request, VENDOR_READ_REQUEST_TYPE,
244
245
246
247
248
249
250
251
252
			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;
	}
253

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

256
	return 0;
257
258
}

259
static int pl2303_vendor_write(struct usb_serial *serial, u16 value, u16 index)
260
{
261
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
262
	struct device *dev = &serial->interface->dev;
263
	u8 request;
264
265
	int res;

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

268
269
270
271
272
	if (spriv->type == &pl2303_type_data[TYPE_HXN])
		request = VENDOR_WRITE_NREQUEST;
	else
		request = VENDOR_WRITE_REQUEST;

273
	res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
274
			request, VENDOR_WRITE_REQUEST_TYPE,
275
			value, index, NULL, 0, 100);
276
277
278
279
280
	if (res) {
		dev_err(dev, "%s - failed to write [%04x]: %d\n", __func__,
								value, res);
		return res;
	}
281

282
	return 0;
283
284
}

285
286
static int pl2303_update_reg(struct usb_serial *serial, u8 reg, u8 mask, u8 val)
{
287
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
288
289
290
291
292
293
294
	int ret = 0;
	u8 *buf;

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

295
296
297
298
299
	if (spriv->type == &pl2303_type_data[TYPE_HXN])
		ret = pl2303_vendor_read(serial, reg, buf);
	else
		ret = pl2303_vendor_read(serial, reg | 0x80, buf);

300
301
302
303
304
305
306
307
308
309
310
311
312
	if (ret)
		goto out_free;

	*buf &= ~mask;
	*buf |= val & mask;

	ret = pl2303_vendor_write(serial, reg, *buf);
out_free:
	kfree(buf);

	return ret;
}

313
314
315
316
317
318
319
320
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;
}

321
322
323
324
325
326
/*
 * Use interrupt endpoint from first interface if available.
 *
 * This is needed due to the looney way its endpoints are set up.
 */
static int pl2303_endpoint_hack(struct usb_serial *serial,
327
328
329
330
331
332
333
334
335
					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;

336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
	if (interface == dev->actconfig->interface[0])
		return 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))
			continue;

		dev_dbg(ddev, "found interrupt in on separate interface\n");
		if (epds->num_interrupt_in < ARRAY_SIZE(epds->interrupt_in))
			epds->interrupt_in[epds->num_interrupt_in++] = endpoint;
	}

	return 0;
}

static int pl2303_calc_num_ports(struct usb_serial *serial,
					struct usb_serial_endpoints *epds)
{
	unsigned long quirks = (unsigned long)usb_get_serial_data(serial);
	struct device *dev = &serial->interface->dev;
	int ret;

	if (quirks & PL2303_QUIRK_ENDPOINT_HACK) {
		ret = pl2303_endpoint_hack(serial, epds);
		if (ret)
			return ret;
367
368
369
	}

	if (epds->num_interrupt_in < 1) {
370
		dev_err(dev, "required interrupt-in endpoint missing\n");
371
372
373
374
375
376
		return -ENODEV;
	}

	return 1;
}

377
static int pl2303_detect_type(struct usb_serial *serial)
378
379
{
	struct usb_device_descriptor *desc = &serial->dev->descriptor;
380
	u16 bcdDevice, bcdUSB;
381
382
383
384
	int ret;
	u8 buf;

	/*
385
	 * Legacy PL2303H, variants 0 and 1 (difference unknown).
386
387
	 */
	if (desc->bDeviceClass == 0x02)
388
		return TYPE_H;		/* variant 0 */
389
390
391

	if (desc->bMaxPacketSize0 != 0x40) {
		if (desc->bDeviceClass == 0x00 || desc->bDeviceClass == 0xff)
392
			return TYPE_H;	/* variant 1 */
393

394
		return TYPE_H;		/* variant 0 */
395
396
397
398
399
400
401
402
403
404
405
406
	}

	/*
	 * Assume it's an HXN-type if the device doesn't support the old read
	 * request value.
	 */
	ret = usb_control_msg_recv(serial->dev, 0, VENDOR_READ_REQUEST,
			VENDOR_READ_REQUEST_TYPE, PL2303_READ_TYPE_HX_STATUS,
			0, &buf, 1, 100, GFP_KERNEL);
	if (ret)
		return TYPE_HXN;

407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
	bcdDevice = le16_to_cpu(desc->bcdDevice);
	bcdUSB = le16_to_cpu(desc->bcdUSB);

	switch (bcdDevice) {
	case 0x300:
		if (bcdUSB == 0x200)
			return TYPE_TA;

		return TYPE_HX;
	case 0x400:
		return TYPE_HXD;
	case 0x500:
		return TYPE_TB;
	}

	dev_err(&serial->interface->dev,
			"unknown device type, please report to linux-usb@vger.kernel.org\n");
	return -ENODEV;
425
426
}

427
static int pl2303_startup(struct usb_serial *serial)
Linus Torvalds's avatar
Linus Torvalds committed
428
{
429
	struct pl2303_serial_private *spriv;
430
	enum pl2303_type type;
431
	unsigned char *buf;
432
433
434
435
436
437
438
439
	int ret;

	ret = pl2303_detect_type(serial);
	if (ret < 0)
		return ret;

	type = ret;
	dev_dbg(&serial->interface->dev, "device type: %d\n", type);
440
441
442
443

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

445
	spriv->type = &pl2303_type_data[type];
446
	spriv->quirks = (unsigned long)usb_get_serial_data(serial);
447
	spriv->quirks |= spriv->type->quirks;
448

449
	usb_set_serial_data(serial, spriv);
450

451
	if (type != TYPE_HXN) {
452
453
454
455
456
457
		buf = kmalloc(1, GFP_KERNEL);
		if (!buf) {
			kfree(spriv);
			return -ENOMEM;
		}

458
459
460
461
462
463
464
465
466
467
468
469
470
471
		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);
		if (spriv->quirks & PL2303_QUIRK_LEGACY)
			pl2303_vendor_write(serial, 2, 0x24);
		else
			pl2303_vendor_write(serial, 2, 0x44);
472

473
474
		kfree(buf);
	}
475

Linus Torvalds's avatar
Linus Torvalds committed
476
	return 0;
477
}
Linus Torvalds's avatar
Linus Torvalds committed
478

479
480
static void pl2303_release(struct usb_serial *serial)
{
481
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497

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

498
499
	port->port.drain_delay = 256;

500
501
502
	return 0;
}

503
static void pl2303_port_remove(struct usb_serial_port *port)
504
{
505
	struct pl2303_private *priv = usb_get_serial_port_data(port);
506
507

	kfree(priv);
Linus Torvalds's avatar
Linus Torvalds committed
508
509
}

510
static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
Linus Torvalds's avatar
Linus Torvalds committed
511
{
512
	struct usb_device *dev = port->serial->dev;
Linus Torvalds's avatar
Linus Torvalds committed
513
	int retval;
Alan Cox's avatar
Alan Cox committed
514

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

517
518
519
	retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
				 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
				 value, 0, NULL, 0, 100);
520
521
	if (retval)
		dev_err(&port->dev, "%s - failed: %d\n", __func__, retval);
522

Linus Torvalds's avatar
Linus Torvalds committed
523
524
525
	return retval;
}

526
/*
527
528
 * Returns the nearest supported baud rate that can be set directly without
 * using divisors.
529
530
 */
static speed_t pl2303_get_supported_baud_rate(speed_t baud)
Linus Torvalds's avatar
Linus Torvalds committed
531
{
532
533
534
	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,
535
		614400, 921600, 1228800, 2457600, 3000000, 6000000
536
	};
Linus Torvalds's avatar
Linus Torvalds committed
537

538
	unsigned i;
539

540
541
542
543
	for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
		if (baud_sup[i] > baud)
			break;
	}
544

545
546
547
548
549
550
	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];
551

552
553
554
	return baud;
}

555
556
557
558
559
560
561
562
563
564
565
566
/*
 * 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;
}

567
568
569
static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
								speed_t baud)
{
570
	unsigned int baseline, mantissa, exponent;
571
572
573

	/*
	 * Apparently the formula is:
574
575
576
577
	 *   baudrate = 12M * 32 / (mantissa * 4^exponent)
	 * where
	 *   mantissa = buf[8:0]
	 *   exponent = buf[11:9]
578
	 */
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
	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;
		}
	}

595
596
	buf[3] = 0x80;
	buf[2] = 0;
597
598
599
600
601
	buf[1] = exponent << 1 | mantissa >> 8;
	buf[0] = mantissa & 0xff;

	/* Calculate and return the exact baud rate. */
	baud = (baseline / mantissa) >> (exponent << 1);
602
603
604
605

	return baud;
}

606
607
608
609
610
611
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);
612
	speed_t	baud_sup;
613
614
615
616
617
618
	speed_t baud;

	baud = tty_get_baud_rate(tty);
	dev_dbg(&port->dev, "baud requested = %u\n", baud);
	if (!baud)
		return;
619
620
621

	if (spriv->type->max_baud_rate)
		baud = min_t(speed_t, baud, spriv->type->max_baud_rate);
622
	/*
623
	 * Use direct method for supported baud rates, otherwise use divisors.
624
	 * Newer chip types do not support divisor encoding.
625
	 */
626
627
628
629
	if (spriv->type->no_divisors)
		baud_sup = baud;
	else
		baud_sup = pl2303_get_supported_baud_rate(baud);
630

631
632
	if (baud == baud_sup)
		baud = pl2303_encode_baud_rate_direct(buf, baud);
633
	else
634
		baud = pl2303_encode_baud_rate_divisor(buf, baud);
635

636
	/* Save resulting baud rate */
637
	tty_encode_baud_rate(tty, baud, baud);
638
	dev_dbg(&port->dev, "baud set = %u\n", baud);
639
640
}

641
642
643
644
645
646
647
648
649
650
651
652
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);

653
		if (ret >= 0)
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
			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);
673
	if (ret < 0) {
674
675
676
677
678
679
680
681
682
		dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);
		return ret;
	}

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

	return 0;
}

683
684
685
686
687
688
689
690
691
692
693
static bool pl2303_termios_change(const struct ktermios *a, const struct ktermios *b)
{
	bool ixon_change;

	ixon_change = ((a->c_iflag ^ b->c_iflag) & (IXON | IXANY)) ||
			a->c_cc[VSTART] != b->c_cc[VSTART] ||
			a->c_cc[VSTOP] != b->c_cc[VSTOP];

	return tty_termios_hw_change(a, b) || ixon_change;
}

694
695
696
697
698
699
700
701
702
703
704
705
706
707
static bool pl2303_enable_xonxoff(struct tty_struct *tty, const struct pl2303_type_data *type)
{
	if (!I_IXON(tty) || I_IXANY(tty))
		return false;

	if (START_CHAR(tty) != 0x11 || STOP_CHAR(tty) != 0x13)
		return false;

	if (type->no_autoxonxoff)
		return false;

	return true;
}

708
709
710
711
712
713
714
715
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;
716
	int ret;
717
718
	u8 control;

719
	if (old_termios && !pl2303_termios_change(&tty->termios, old_termios))
720
721
722
723
724
725
726
727
728
729
		return;

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

730
	pl2303_get_line_request(port, buf);
731

732
733
734
735
736
737
738
739
740
741
742
743
744
	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;
745
	}
746
	dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
747

748
	/* For reference buf[0]:buf[3] baud rate value */
749
	pl2303_encode_baud_rate(tty, port, &buf[0]);
750

Linus Torvalds's avatar
Linus Torvalds committed
751
752
753
	/* 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 */
754
755
756
	if (C_CSTOPB(tty)) {
		/*
		 * NOTE: Comply with "real" UARTs / RS232:
757
758
		 *       use 1.5 instead of 2 stop bits with 5 data bits
		 */
759
		if (C_CSIZE(tty) == CS5) {
760
			buf[4] = 1;
761
			dev_dbg(&port->dev, "stop bits = 1.5\n");
762
763
		} else {
			buf[4] = 2;
764
			dev_dbg(&port->dev, "stop bits = 2\n");
765
		}
Linus Torvalds's avatar
Linus Torvalds committed
766
767
	} else {
		buf[4] = 0;
768
		dev_dbg(&port->dev, "stop bits = 1\n");
Linus Torvalds's avatar
Linus Torvalds committed
769
770
	}

771
	if (C_PARENB(tty)) {
Linus Torvalds's avatar
Linus Torvalds committed
772
773
774
775
776
		/* 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 */
777
		if (C_PARODD(tty)) {
Johan Hovold's avatar
Johan Hovold committed
778
			if (C_CMSPAR(tty)) {
779
				buf[5] = 3;
780
				dev_dbg(&port->dev, "parity = mark\n");
781
782
			} else {
				buf[5] = 1;
783
				dev_dbg(&port->dev, "parity = odd\n");
784
			}
Linus Torvalds's avatar
Linus Torvalds committed
785
		} else {
Johan Hovold's avatar
Johan Hovold committed
786
			if (C_CMSPAR(tty)) {
787
				buf[5] = 4;
788
				dev_dbg(&port->dev, "parity = space\n");
789
790
			} else {
				buf[5] = 2;
791
				dev_dbg(&port->dev, "parity = even\n");
792
			}
Linus Torvalds's avatar
Linus Torvalds committed
793
794
795
		}
	} else {
		buf[5] = 0;
796
		dev_dbg(&port->dev, "parity = none\n");
Linus Torvalds's avatar
Linus Torvalds committed
797
798
	}

799
800
801
802
803
804
805
806
807
808
809
810
811
	/*
	 * 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)) {
812
813
		ret = pl2303_set_line_request(port, buf);
		if (!ret)
814
815
			memcpy(priv->line_settings, buf, 7);
	}
Linus Torvalds's avatar
Linus Torvalds committed
816
817
818
819

	/* change control lines if we are switching to or from B0 */
	spin_lock_irqsave(&priv->lock, flags);
	control = priv->line_control;
820
	if (C_BAUD(tty) == B0)
Linus Torvalds's avatar
Linus Torvalds committed
821
		priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
822
	else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
Linus Torvalds's avatar
Linus Torvalds committed
823
824
825
826
		priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
	if (control != priv->line_control) {
		control = priv->line_control;
		spin_unlock_irqrestore(&priv->lock, flags);
827
		pl2303_set_control_lines(port, control);
Linus Torvalds's avatar
Linus Torvalds committed
828
829
830
	} else {
		spin_unlock_irqrestore(&priv->lock, flags);
	}
831

832
	if (C_CRTSCTS(tty)) {
833
		if (spriv->quirks & PL2303_QUIRK_LEGACY) {
834
			pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0x40);
835
836
837
838
839
		} else if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
			pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
					PL2303_HXN_FLOWCTRL_MASK,
					PL2303_HXN_FLOWCTRL_RTS_CTS);
		} else {
840
			pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0x60);
841
		}
842
	} else if (pl2303_enable_xonxoff(tty, spriv->type)) {
843
844
845
846
847
848
849
		if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
			pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
					PL2303_HXN_FLOWCTRL_MASK,
					PL2303_HXN_FLOWCTRL_XON_XOFF);
		} else {
			pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0xc0);
		}
t.sefzick's avatar
t.sefzick committed
850
	} else {
851
852
853
854
855
856
857
		if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
			pl2303_update_reg(serial, PL2303_HXN_FLOWCTRL_REG,
					PL2303_HXN_FLOWCTRL_MASK,
					PL2303_HXN_FLOWCTRL_NONE);
		} else {
			pl2303_update_reg(serial, 0, PL2303_FLOWCTRL_MASK, 0);
		}
Linus Torvalds's avatar
Linus Torvalds committed
858
	}
859
860
861
862

	kfree(buf);
}

863
864
865
866
867
868
869
870
871
872
873
874
875
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);
876

877
	pl2303_set_control_lines(port, control);
878
879
880
}

static void pl2303_close(struct usb_serial_port *port)
881
{
Johan Hovold's avatar
Johan Hovold committed
882
	usb_serial_generic_close(port);
883
	usb_kill_urb(port->interrupt_in_urb);
884
	pl2303_set_break(port, false);
Linus Torvalds's avatar
Linus Torvalds committed
885
886
}

887
static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
Linus Torvalds's avatar
Linus Torvalds committed
888
889
{
	struct usb_serial *serial = port->serial;
890
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
Linus Torvalds's avatar
Linus Torvalds committed
891
892
	int result;

893
	if (spriv->quirks & PL2303_QUIRK_LEGACY) {
894
895
		usb_clear_halt(serial->dev, port->write_urb->pipe);
		usb_clear_halt(serial->dev, port->read_urb->pipe);
896
	} else {
Linus Torvalds's avatar
Linus Torvalds committed
897
		/* reset upstream data pipes */
898
899
900
901
902
903
904
905
		if (spriv->type == &pl2303_type_data[TYPE_HXN]) {
			pl2303_vendor_write(serial, PL2303_HXN_RESET_REG,
					PL2303_HXN_RESET_UPSTREAM_PIPE |
					PL2303_HXN_RESET_DOWNSTREAM_PIPE);
		} else {
			pl2303_vendor_write(serial, 8, 0);
			pl2303_vendor_write(serial, 9, 0);
		}
Linus Torvalds's avatar
Linus Torvalds committed
906
907
908
	}

	/* Setup termios */
Alan Cox's avatar
Alan Cox committed
909
	if (tty)
910
		pl2303_set_termios(tty, port, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
911

912
	result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
Linus Torvalds's avatar
Linus Torvalds committed
913
	if (result) {
914
915
		dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
			result);
916
		return result;
Linus Torvalds's avatar
Linus Torvalds committed
917
	}
918

919
	result = usb_serial_generic_open(tty, port);
920
921
922
923
924
	if (result) {
		usb_kill_urb(port->interrupt_in_urb);
		return result;
	}

Linus Torvalds's avatar
Linus Torvalds committed
925
926
927
	return 0;
}

928
static int pl2303_tiocmset(struct tty_struct *tty,
929
			   unsigned int set, unsigned int clear)
Linus Torvalds's avatar
Linus Torvalds committed
930
{
Alan Cox's avatar
Alan Cox committed
931
	struct usb_serial_port *port = tty->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
932
933
934
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	u8 control;
935
	int ret;
936

937
	spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
938
939
940
941
942
943
944
945
946
	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;
947
	spin_unlock_irqrestore(&priv->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
948

949
950
951
	ret = pl2303_set_control_lines(port, control);
	if (ret)
		return usb_translate_errors(ret);
952

953
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
954
955
}

956
static int pl2303_tiocmget(struct tty_struct *tty)
Linus Torvalds's avatar
Linus Torvalds committed
957
{
Alan Cox's avatar
Alan Cox committed
958
	struct usb_serial_port *port = tty->driver_data;
Linus Torvalds's avatar
Linus Torvalds committed
959
960
961
962
963
964
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	unsigned int mcr;
	unsigned int status;
	unsigned int result;

965
	spin_lock_irqsave(&priv->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
966
967
	mcr = priv->line_control;
	status = priv->line_status;
968
	spin_unlock_irqrestore(&priv->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
969
970
971
972
973
974
975
976

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

977
	dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
Linus Torvalds's avatar
Linus Torvalds committed
978
979
980
981

	return result;
}

982
983
984
static int pl2303_carrier_raised(struct usb_serial_port *port)
{
	struct pl2303_private *priv = usb_get_serial_port_data(port);
985

986
987
	if (priv->line_status & UART_DCD)
		return 1;
988

989
990
991
	return 0;
}

Al Viro's avatar
Al Viro committed
992
993
static int pl2303_get_serial(struct tty_struct *tty,
			struct serial_struct *ss)
Linus Torvalds's avatar
Linus Torvalds committed
994
{
Alan Cox's avatar
Alan Cox committed
995
	struct usb_serial_port *port = tty->driver_data;
996

Al Viro's avatar
Al Viro committed
997
998
999
1000
	ss->type = PORT_16654;
	ss->line = port->minor;
	ss->port = port->port_number;
	ss->baud_base = 460800;