pl2303.c 28.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3
/*
 * Prolific PL2303 USB to serial adaptor driver
 *
4
 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
L
Linus Torvalds 已提交
5 6
 * Copyright (C) 2003 IBM Corp.
 *
7 8 9 10 11
 * Copyright (C) 2009, 2013 Frank Schäfer <fschaefer.oss@googlemail.com>
 *  - fixes, improvements and documentation for the baud rate encoding methods
 * Copyright (C) 2013 Reinhard Max <max@suse.de>
 *  - fixes and improvements for the divisor based baud rate encoding method
 *
L
Linus Torvalds 已提交
12 13
 * Original driver for 2.2.x by anonymous
 *
14 15 16
 *	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.
L
Linus Torvalds 已提交
17
 *
A
Alan Cox 已提交
18 19
 * See Documentation/usb/usb-serial.txt for more information on using this
 * driver
L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28 29 30 31 32 33
 *
 */

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.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>
A
Alan Cox 已提交
34
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
35
#include <linux/usb.h>
36
#include <linux/usb/serial.h>
37
#include <asm/unaligned.h>
L
Linus Torvalds 已提交
38 39 40 41 42 43 44
#include "pl2303.h"

/*
 * Version Information
 */
#define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"

45
static const struct usb_device_id id_table[] = {
L
Linus Torvalds 已提交
46 47
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
48
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
L
Linus Torvalds 已提交
49 50
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
M
Max Arnold 已提交
51
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
S
Steve Murphy 已提交
52
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
G
Greg Kroah-Hartman 已提交
53
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
54
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
55
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
L
Linus Torvalds 已提交
56
	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
57
	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
L
Linus Torvalds 已提交
58 59 60 61 62
	{ USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID) },
	{ 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) },
63
	{ USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
L
Linus Torvalds 已提交
64 65 66 67 68 69 70 71
	{ 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) },
	{ USB_DEVICE(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_ID) },
72
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_SX1) },
L
Linus Torvalds 已提交
73
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X65) },
74
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_X75) },
75
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
76
	{ USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
77
	{ USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
78 79
	{ USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
	{ USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
80
	{ USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
81
	{ USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
82
	{ USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
83
	{ USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
84
	{ USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
85
	{ USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
86
	{ USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
87
	{ USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
88
	{ USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
M
Matthew Arnold 已提交
89
	{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
90
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
91
	{ USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
92
	{ USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
93
	{ USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
94
	{ USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
95
	{ USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
96
	{ USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
L
Linus Torvalds 已提交
97 98 99
	{ }					/* Terminating entry */
};

100
MODULE_DEVICE_TABLE(usb, id_table);
L
Linus Torvalds 已提交
101 102 103 104 105 106 107 108 109 110

#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
A
Alan Cox 已提交
111
#define BREAK_REQUEST			0x23
L
Linus Torvalds 已提交
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
#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

#define UART_STATE			0x08
#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


enum pl2303_type {
137 138 139 140 141
	type_0,		/* H version ? */
	type_1,		/* H version ? */
	HX_TA,		/* HX(A) / X(A) / TA version  */ /* TODO: improve */
	HXD_EA_RA_SA,	/* HXD / EA / RA / SA version */ /* TODO: improve */
	TB,		/* TB version */
L
Linus Torvalds 已提交
142
};
143 144 145 146 147
/*
 * NOTE: don't know the difference between type 0 and type 1,
 * until someone from Prolific tells us...
 * TODO: distinguish between X/HX, TA and HXD, EA, RA, SA variants
 */
L
Linus Torvalds 已提交
148

149 150 151 152
struct pl2303_serial_private {
	enum pl2303_type type;
};

L
Linus Torvalds 已提交
153 154 155 156 157 158
struct pl2303_private {
	spinlock_t lock;
	u8 line_control;
	u8 line_status;
};

159 160 161 162 163 164
static int pl2303_vendor_read(__u16 value, __u16 index,
		struct usb_serial *serial, unsigned char *buf)
{
	int res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
			VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
			value, index, buf, 1, 100);
165
	dev_dbg(&serial->interface->dev, "0x%x:0x%x:0x%x:0x%x  %d - %x\n",
166 167
		VENDOR_READ_REQUEST_TYPE, VENDOR_READ_REQUEST, value, index,
		res, buf[0]);
168 169 170 171 172 173 174 175 176
	return res;
}

static int pl2303_vendor_write(__u16 value, __u16 index,
		struct usb_serial *serial)
{
	int res = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
			VENDOR_WRITE_REQUEST, VENDOR_WRITE_REQUEST_TYPE,
			value, index, NULL, 0, 100);
177
	dev_dbg(&serial->interface->dev, "0x%x:0x%x:0x%x:0x%x  %d\n",
178 179
		VENDOR_WRITE_REQUEST_TYPE, VENDOR_WRITE_REQUEST, value, index,
		res);
180 181 182
	return res;
}

183
static int pl2303_startup(struct usb_serial *serial)
L
Linus Torvalds 已提交
184
{
185
	struct pl2303_serial_private *spriv;
L
Linus Torvalds 已提交
186
	enum pl2303_type type = type_0;
187
	char *type_str = "unknown (treating as type_0)";
188
	unsigned char *buf;
189 190 191 192

	spriv = kzalloc(sizeof(*spriv), GFP_KERNEL);
	if (!spriv)
		return -ENOMEM;
L
Linus Torvalds 已提交
193

194
	buf = kmalloc(10, GFP_KERNEL);
195 196
	if (!buf) {
		kfree(spriv);
197
		return -ENOMEM;
198
	}
199

200
	if (serial->dev->descriptor.bDeviceClass == 0x02) {
L
Linus Torvalds 已提交
201
		type = type_0;
202 203
		type_str = "type_0";
	} else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40) {
204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
		/*
		 * NOTE: The bcdDevice version is the only difference between
		 * the device descriptors of the X/HX, HXD, EA, RA, SA, TA, TB
		 */
		if (le16_to_cpu(serial->dev->descriptor.bcdDevice) == 0x300) {
			type = HX_TA;
			type_str = "X/HX/TA";
		} else if (le16_to_cpu(serial->dev->descriptor.bcdDevice)
								     == 0x400) {
			type = HXD_EA_RA_SA;
			type_str = "HXD/EA/RA/SA";
		} else if (le16_to_cpu(serial->dev->descriptor.bcdDevice)
								     == 0x500) {
			type = TB;
			type_str = "TB";
		} else {
			dev_info(&serial->interface->dev,
					   "unknown/unsupported device type\n");
			kfree(spriv);
			kfree(buf);
			return -ENODEV;
		}
226 227
	} else if (serial->dev->descriptor.bDeviceClass == 0x00
		   || serial->dev->descriptor.bDeviceClass == 0xFF) {
L
Linus Torvalds 已提交
228
		type = type_1;
229 230 231
		type_str = "type_1";
	}
	dev_dbg(&serial->interface->dev, "device type: %s\n", type_str);
L
Linus Torvalds 已提交
232

233 234
	spriv->type = type;
	usb_set_serial_data(serial, spriv);
235 236 237 238 239 240 241 242 243 244 245

	pl2303_vendor_read(0x8484, 0, serial, buf);
	pl2303_vendor_write(0x0404, 0, serial);
	pl2303_vendor_read(0x8484, 0, serial, buf);
	pl2303_vendor_read(0x8383, 0, serial, buf);
	pl2303_vendor_read(0x8484, 0, serial, buf);
	pl2303_vendor_write(0x0404, 1, serial);
	pl2303_vendor_read(0x8484, 0, serial, buf);
	pl2303_vendor_read(0x8383, 0, serial, buf);
	pl2303_vendor_write(0, 1, serial);
	pl2303_vendor_write(1, 0, serial);
246
	if (type == type_0 || type == type_1)
247
		pl2303_vendor_write(2, 0x24, serial);
248 249
	else
		pl2303_vendor_write(2, 0x44, serial);
250 251

	kfree(buf);
L
Linus Torvalds 已提交
252
	return 0;
253
}
L
Linus Torvalds 已提交
254

255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274
static void pl2303_release(struct usb_serial *serial)
{
	struct pl2303_serial_private *spriv;

	spriv = usb_get_serial_data(serial);
	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);

275 276
	port->port.drain_delay = 256;

277 278 279 280 281 282 283 284 285 286 287
	return 0;
}

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

	priv = usb_get_serial_port_data(port);
	kfree(priv);

	return 0;
L
Linus Torvalds 已提交
288 289
}

290
static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
L
Linus Torvalds 已提交
291
{
292
	struct usb_device *dev = port->serial->dev;
L
Linus Torvalds 已提交
293
	int retval;
A
Alan Cox 已提交
294

295 296 297
	retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
				 SET_CONTROL_REQUEST, SET_CONTROL_REQUEST_TYPE,
				 value, 0, NULL, 0, 100);
298
	dev_dbg(&port->dev, "%s - value = %d, retval = %d\n", __func__,
299
		value, retval);
L
Linus Torvalds 已提交
300 301 302
	return retval;
}

303 304 305 306 307 308 309 310 311 312 313
static int pl2303_baudrate_encode_direct(int baud, enum pl2303_type type,
								      u8 buf[4])
{
	/*
	 * NOTE: Only the values defined in baud_sup are supported !
	 *       => if unsupported values are set, the PL2303 seems to
	 *	    use 9600 baud (at least my PL2303X always does)
	 */
	const int baud_sup[] = { 75, 150, 300, 600, 1200, 1800, 2400, 3600,
				 4800, 7200, 9600, 14400, 19200, 28800, 38400,
				 57600, 115200, 230400, 460800, 614400, 921600,
314
				 1228800, 2457600, 3000000, 6000000, 12000000 };
315
	/*
316 317 318 319 320 321 322 323 324 325 326
	 * NOTE: With the exception of type_0/1 devices, the following
	 * additional baud rates are supported (tested with HX rev. 3A only):
	 * 110*, 56000*, 128000, 134400, 161280, 201600, 256000*, 268800,
	 * 403200, 806400.	(*: not HX)
	 *
	 * Maximum values: HXD, TB: 12000000; HX, TA: 6000000;
	 *                 type_0+1: 1228800; RA: 921600; SA: 115200
	 *
	 * As long as we are not using this encoding method for anything else
	 * than the type_0+1 and HX chips, there is no point in complicating
	 * the code to support them.
327
	 */
328 329 330 331 332 333 334 335 336 337 338 339 340
	int i;

	/* Set baudrate to nearest supported value */
	for (i = 0; i < ARRAY_SIZE(baud_sup); ++i) {
		if (baud_sup[i] > baud)
			break;
	}
	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];
341 342 343 344 345 346 347 348
	/* Respect the chip type specific baud rate limits */
	/*
	 * FIXME: as long as we don't know how to distinguish between the
	 * HXD, EA, RA, and SA chip variants, allow the max. value of 12M.
	 */
	if (type == HX_TA)
		baud = min_t(int, baud, 6000000);
	else if (type == type_0 || type == type_1)
349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376
		baud = min_t(int, baud, 1228800);
	/* Direct (standard) baud rate encoding method */
	put_unaligned_le32(baud, buf);

	return baud;
}

static int pl2303_baudrate_encode_divisor(int baud, enum pl2303_type type,
								      u8 buf[4])
{
	/*
	 * Divisor based baud rate encoding method
	 *
	 * NOTE: it's not clear if the type_0/1 chips support this method
	 *
	 * divisor = 12MHz * 32 / baudrate = 2^A * B
	 *
	 * with
	 *
	 * A = buf[1] & 0x0e
	 * B = buf[0]  +  (buf[1] & 0x01) << 8
	 *
	 * Special cases:
	 * => 8 < B < 16: device seems to work not properly
	 * => B <= 8: device uses the max. value B = 512 instead
	 */
	unsigned int A, B;

377 378 379 380 381 382 383 384 385 386
	/*
	 * NOTE: The Windows driver allows maximum baud rates of 110% of the
	 * specified maximium value.
	 * Quick tests with early (2004) HX (rev. A) chips suggest, that even
	 * higher baud rates (up to the maximum of 24M baud !) are working fine,
	 * but that should really be tested carefully in "real life" scenarios
	 * before removing the upper limit completely.
	 * Baud rates smaller than the specified 75 baud are definitely working
	 * fine.
	 */
387
	if (type == type_0 || type == type_1)
388
		baud = min_t(int, baud, 1228800 * 1.1);
389 390 391 392 393 394 395 396 397 398 399
	else if (type == HX_TA)
		baud = min_t(int, baud, 6000000 * 1.1);
	else if (type == HXD_EA_RA_SA)
		/* HXD, EA: 12Mbps; RA: 1Mbps; SA: 115200 bps */
		/*
		 * FIXME: as long as we don't know how to distinguish between
		 * these chip variants, allow the max. of these values
		 */
		baud = min_t(int, baud, 12000000 * 1.1);
	else if (type == TB)
		baud = min_t(int, baud, 12000000 * 1.1);
400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
	/* Determine factors A and B */
	A = 0;
	B = 12000000 * 32 / baud;  /* 12MHz */
	B <<= 1; /* Add one bit for rounding */
	while (B > (512 << 1) && A <= 14) {
		A += 2;
		B >>= 2;
	}
	if (A > 14) { /* max. divisor = min. baudrate reached */
		A = 14;
		B = 512;
		/* => ~45.78 baud */
	} else {
		B = (B + 1) >> 1; /* Round the last bit */
	}
	/* Handle special cases */
	if (B == 512)
		B = 0; /* also: 1 to 8 */
	else if (B < 16)
		/*
		 * NOTE: With the current algorithm this happens
		 * only for A=0 and means that the min. divisor
		 * (respectively: the max. baudrate) is reached.
		 */
		B = 16;		/* => 24 MBaud */
	/* Encode the baud rate */
	buf[3] = 0x80;     /* Select divisor encoding method */
	buf[2] = 0;
	buf[1] = (A & 0x0e);		/* A */
	buf[1] |= ((B & 0x100) >> 8);	/* MSB of B */
	buf[0] = B & 0xff;		/* 8 LSBs of B */
	/* Calculate the actual/resulting baud rate */
	if (B <= 8)
		B = 512;
	baud = 12000000 * 32 / ((1 << A) * B);

	return baud;
}

439 440
static void pl2303_encode_baudrate(struct tty_struct *tty,
					struct usb_serial_port *port,
441
					enum pl2303_type type,
442
					u8 buf[4])
L
Linus Torvalds 已提交
443
{
444
	int baud;
L
Linus Torvalds 已提交
445

A
Alan Cox 已提交
446
	baud = tty_get_baud_rate(tty);
447
	dev_dbg(&port->dev, "baud requested = %d\n", baud);
448 449
	if (!baud)
		return;
450 451 452 453 454 455
	/*
	 * There are two methods for setting/encoding the baud rate
	 * 1) Direct method: encodes the baud rate value directly
	 *    => supported by all chip types
	 * 2) Divisor based method: encodes a divisor to a base value (12MHz*32)
	 *    => supported by HX chips (and likely not by type_0/1 chips)
456 457 458 459 460 461
	 *
	 * NOTE: Although the divisor based baud rate encoding method is much
	 * more flexible, some of the standard baud rate values can not be
	 * realized exactly. But the difference is very small (max. 0.2%) and
	 * the device likely uses the same baud rate generator for both methods
	 * so that there is likley no difference.
462
	 */
463
	if (type == type_0 || type == type_1)
464 465 466
		baud = pl2303_baudrate_encode_direct(baud, type, buf);
	else
		baud = pl2303_baudrate_encode_divisor(baud, type, buf);
467
	/* Save resulting baud rate */
468 469
	tty_encode_baud_rate(tty, baud, baud);
	dev_dbg(&port->dev, "baud set = %d\n", baud);
470 471 472 473 474 475 476 477 478 479 480 481 482
}

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;
	int i;
	u8 control;

J
Johan Hovold 已提交
483 484 485 486 487
	/*
	 * The PL2303 is reported 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.
	 */
488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
	if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
		return;

	buf = kzalloc(7, GFP_KERNEL);
	if (!buf) {
		dev_err(&port->dev, "%s - out of memory.\n", __func__);
		/* Report back no change occurred */
		if (old_termios)
			tty->termios = *old_termios;
		return;
	}

	i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
			    GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
			    0, 0, buf, 7, 100);
	dev_dbg(&port->dev, "0xa1:0x21:0:0  %d - %7ph\n", i, buf);

J
Johan Hovold 已提交
505 506
	if (C_CSIZE(tty)) {
		switch (C_CSIZE(tty)) {
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
		case CS5:
			buf[6] = 5;
			break;
		case CS6:
			buf[6] = 6;
			break;
		case CS7:
			buf[6] = 7;
			break;
		default:
		case CS8:
			buf[6] = 8;
		}
		dev_dbg(&port->dev, "data bits = %d\n", buf[6]);
	}

523 524
	/* For reference:   buf[0]:buf[3] baud rate value */
	pl2303_encode_baudrate(tty, port, spriv->type, buf);
525

L
Linus Torvalds 已提交
526 527 528
	/* 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 */
J
Johan Hovold 已提交
529 530 531
	if (C_CSTOPB(tty)) {
		/*
		 * NOTE: Comply with "real" UARTs / RS232:
532 533
		 *       use 1.5 instead of 2 stop bits with 5 data bits
		 */
J
Johan Hovold 已提交
534
		if (C_CSIZE(tty) == CS5) {
535
			buf[4] = 1;
536
			dev_dbg(&port->dev, "stop bits = 1.5\n");
537 538
		} else {
			buf[4] = 2;
539
			dev_dbg(&port->dev, "stop bits = 2\n");
540
		}
L
Linus Torvalds 已提交
541 542
	} else {
		buf[4] = 0;
543
		dev_dbg(&port->dev, "stop bits = 1\n");
L
Linus Torvalds 已提交
544 545
	}

J
Johan Hovold 已提交
546
	if (C_PARENB(tty)) {
L
Linus Torvalds 已提交
547 548 549 550 551
		/* 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 */
J
Johan Hovold 已提交
552 553
		if (C_PARODD(tty)) {
			if (tty->termios.c_cflag & CMSPAR) {
554
				buf[5] = 3;
555
				dev_dbg(&port->dev, "parity = mark\n");
556 557
			} else {
				buf[5] = 1;
558
				dev_dbg(&port->dev, "parity = odd\n");
559
			}
L
Linus Torvalds 已提交
560
		} else {
J
Johan Hovold 已提交
561
			if (tty->termios.c_cflag & CMSPAR) {
562
				buf[5] = 4;
563
				dev_dbg(&port->dev, "parity = space\n");
564 565
			} else {
				buf[5] = 2;
566
				dev_dbg(&port->dev, "parity = even\n");
567
			}
L
Linus Torvalds 已提交
568 569 570
		}
	} else {
		buf[5] = 0;
571
		dev_dbg(&port->dev, "parity = none\n");
L
Linus Torvalds 已提交
572 573
	}

574 575 576
	i = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
			    SET_LINE_REQUEST, SET_LINE_REQUEST_TYPE,
			    0, 0, buf, 7, 100);
577
	dev_dbg(&port->dev, "0x21:0x20:0:0  %d\n", i);
L
Linus Torvalds 已提交
578 579 580 581

	/* change control lines if we are switching to or from B0 */
	spin_lock_irqsave(&priv->lock, flags);
	control = priv->line_control;
J
Johan Hovold 已提交
582
	if (C_BAUD(tty) == B0)
L
Linus Torvalds 已提交
583
		priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
584
	else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
L
Linus Torvalds 已提交
585 586 587 588
		priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
	if (control != priv->line_control) {
		control = priv->line_control;
		spin_unlock_irqrestore(&priv->lock, flags);
589
		pl2303_set_control_lines(port, control);
L
Linus Torvalds 已提交
590 591 592
	} else {
		spin_unlock_irqrestore(&priv->lock, flags);
	}
593

J
Johan Hovold 已提交
594
	memset(buf, 0, 7);
595 596 597
	i = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
			    GET_LINE_REQUEST, GET_LINE_REQUEST_TYPE,
			    0, 0, buf, 7, 100);
598
	dev_dbg(&port->dev, "0xa1:0x21:0:0  %d - %7ph\n", i, buf);
L
Linus Torvalds 已提交
599

J
Johan Hovold 已提交
600
	if (C_CRTSCTS(tty)) {
601
		if (spriv->type == type_0 || spriv->type == type_1)
602
			pl2303_vendor_write(0x0, 0x41, serial);
603 604
		else
			pl2303_vendor_write(0x0, 0x61, serial);
T
t.sefzick 已提交
605
	} else {
606
		pl2303_vendor_write(0x0, 0x0, serial);
L
Linus Torvalds 已提交
607
	}
608 609 610 611

	kfree(buf);
}

612 613 614 615 616 617 618 619 620 621 622 623 624 625
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);
	/* Change DTR and RTS */
	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);
626
	pl2303_set_control_lines(port, control);
627 628 629
}

static void pl2303_close(struct usb_serial_port *port)
630
{
J
Johan Hovold 已提交
631
	usb_serial_generic_close(port);
632
	usb_kill_urb(port->interrupt_in_urb);
L
Linus Torvalds 已提交
633 634
}

635
static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
L
Linus Torvalds 已提交
636 637
{
	struct usb_serial *serial = port->serial;
638
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
L
Linus Torvalds 已提交
639 640
	int result;

641
	if (spriv->type == type_0 || spriv->type == type_1) {
642 643
		usb_clear_halt(serial->dev, port->write_urb->pipe);
		usb_clear_halt(serial->dev, port->read_urb->pipe);
644
	} else {
L
Linus Torvalds 已提交
645
		/* reset upstream data pipes */
646 647
		pl2303_vendor_write(8, 0, serial);
		pl2303_vendor_write(9, 0, serial);
L
Linus Torvalds 已提交
648 649 650
	}

	/* Setup termios */
A
Alan Cox 已提交
651
	if (tty)
652
		pl2303_set_termios(tty, port, NULL);
L
Linus Torvalds 已提交
653

654
	result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
L
Linus Torvalds 已提交
655
	if (result) {
656
		dev_err(&port->dev, "%s - failed submitting interrupt urb,"
657
			" error %d\n", __func__, result);
658
		return result;
L
Linus Torvalds 已提交
659
	}
660

661
	result = usb_serial_generic_open(tty, port);
662 663 664 665 666
	if (result) {
		usb_kill_urb(port->interrupt_in_urb);
		return result;
	}

L
Linus Torvalds 已提交
667 668 669
	return 0;
}

670
static int pl2303_tiocmset(struct tty_struct *tty,
671
			   unsigned int set, unsigned int clear)
L
Linus Torvalds 已提交
672
{
A
Alan Cox 已提交
673
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
674 675 676
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	u8 control;
677
	int ret;
F
Flavio Leitner 已提交
678

679
	spin_lock_irqsave(&priv->lock, flags);
L
Linus Torvalds 已提交
680 681 682 683 684 685 686 687 688
	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;
689
	spin_unlock_irqrestore(&priv->lock, flags);
L
Linus Torvalds 已提交
690

691 692 693
	ret = pl2303_set_control_lines(port, control);
	if (ret)
		return usb_translate_errors(ret);
694

695
	return 0;
L
Linus Torvalds 已提交
696 697
}

698
static int pl2303_tiocmget(struct tty_struct *tty)
L
Linus Torvalds 已提交
699
{
A
Alan Cox 已提交
700
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
701 702 703 704 705 706
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	unsigned int mcr;
	unsigned int status;
	unsigned int result;

707
	spin_lock_irqsave(&priv->lock, flags);
L
Linus Torvalds 已提交
708 709
	mcr = priv->line_control;
	status = priv->line_status;
710
	spin_unlock_irqrestore(&priv->lock, flags);
L
Linus Torvalds 已提交
711 712 713 714 715 716 717 718

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

719
	dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
L
Linus Torvalds 已提交
720 721 722 723

	return result;
}

724 725 726 727 728 729 730 731
static int pl2303_carrier_raised(struct usb_serial_port *port)
{
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	if (priv->line_status & UART_DCD)
		return 1;
	return 0;
}

732
static int pl2303_tiocmiwait(struct tty_struct *tty, unsigned long arg)
L
Linus Torvalds 已提交
733
{
734
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
735 736 737 738 739 740
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	unsigned int prevstatus;
	unsigned int status;
	unsigned int changed;

741
	spin_lock_irqsave(&priv->lock, flags);
L
Linus Torvalds 已提交
742
	prevstatus = priv->line_status;
743
	spin_unlock_irqrestore(&priv->lock, flags);
L
Linus Torvalds 已提交
744 745

	while (1) {
746
		interruptible_sleep_on(&port->port.delta_msr_wait);
L
Linus Torvalds 已提交
747 748 749
		/* see if a signal did it */
		if (signal_pending(current))
			return -ERESTARTSYS;
750

751 752 753
		if (port->serial->disconnected)
			return -EIO;

754
		spin_lock_irqsave(&priv->lock, flags);
L
Linus Torvalds 已提交
755
		status = priv->line_status;
756 757
		spin_unlock_irqrestore(&priv->lock, flags);

A
Alan Cox 已提交
758
		changed = prevstatus ^ status;
759

L
Linus Torvalds 已提交
760 761 762
		if (((arg & TIOCM_RNG) && (changed & UART_RING)) ||
		    ((arg & TIOCM_DSR) && (changed & UART_DSR)) ||
		    ((arg & TIOCM_CD)  && (changed & UART_DCD)) ||
A
Alan Cox 已提交
763
		    ((arg & TIOCM_CTS) && (changed & UART_CTS))) {
L
Linus Torvalds 已提交
764 765 766 767 768 769 770 771
			return 0;
		}
		prevstatus = status;
	}
	/* NOTREACHED */
	return 0;
}

772
static int pl2303_ioctl(struct tty_struct *tty,
773
			unsigned int cmd, unsigned long arg)
L
Linus Torvalds 已提交
774
{
775
	struct serial_struct ser;
A
Alan Cox 已提交
776
	struct usb_serial_port *port = tty->driver_data;
777 778

	dev_dbg(&port->dev, "%s cmd = 0x%04x\n", __func__, cmd);
L
Linus Torvalds 已提交
779 780

	switch (cmd) {
781 782 783
	case TIOCGSERIAL:
		memset(&ser, 0, sizeof ser);
		ser.type = PORT_16654;
784
		ser.line = port->minor;
785
		ser.port = port->port_number;
786 787 788 789 790 791
		ser.baud_base = 460800;

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

		return 0;
A
Alan Cox 已提交
792
	default:
793
		dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
A
Alan Cox 已提交
794
		break;
L
Linus Torvalds 已提交
795 796 797 798
	}
	return -ENOIOCTLCMD;
}

A
Alan Cox 已提交
799
static void pl2303_break_ctl(struct tty_struct *tty, int break_state)
L
Linus Torvalds 已提交
800
{
A
Alan Cox 已提交
801
	struct usb_serial_port *port = tty->driver_data;
L
Linus Torvalds 已提交
802 803 804 805 806 807 808 809
	struct usb_serial *serial = port->serial;
	u16 state;
	int result;

	if (break_state == 0)
		state = BREAK_OFF;
	else
		state = BREAK_ON;
810
	dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
A
Alan Cox 已提交
811
			state == BREAK_OFF ? "off" : "on");
L
Linus Torvalds 已提交
812

813 814 815
	result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
				 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
				 0, NULL, 0, 100);
L
Linus Torvalds 已提交
816
	if (result)
817
		dev_err(&port->dev, "error sending break = %d\n", result);
L
Linus Torvalds 已提交
818 819
}

F
Flavio Leitner 已提交
820 821 822 823 824 825
static void pl2303_update_line_status(struct usb_serial_port *port,
				      unsigned char *data,
				      unsigned int actual_length)
{

	struct pl2303_private *priv = usb_get_serial_port_data(port);
826
	struct tty_struct *tty;
F
Flavio Leitner 已提交
827 828
	unsigned long flags;
	u8 status_idx = UART_STATE;
829
	u8 length = UART_STATE + 1;
830
	u8 prev_line_status;
831
	u16 idv, idp;
F
Flavio Leitner 已提交
832

833 834 835 836 837 838 839 840 841 842 843 844
	idv = le16_to_cpu(port->serial->dev->descriptor.idVendor);
	idp = le16_to_cpu(port->serial->dev->descriptor.idProduct);


	if (idv == SIEMENS_VENDOR_ID) {
		if (idp == SIEMENS_PRODUCT_ID_X65 ||
		    idp == SIEMENS_PRODUCT_ID_SX1 ||
		    idp == SIEMENS_PRODUCT_ID_X75) {

			length = 1;
			status_idx = 0;
		}
F
Flavio Leitner 已提交
845 846 847
	}

	if (actual_length < length)
848
		return;
F
Flavio Leitner 已提交
849

A
Alan Cox 已提交
850
	/* Save off the uart status for others to look at */
F
Flavio Leitner 已提交
851
	spin_lock_irqsave(&priv->lock, flags);
852
	prev_line_status = priv->line_status;
F
Flavio Leitner 已提交
853 854
	priv->line_status = data[status_idx];
	spin_unlock_irqrestore(&priv->lock, flags);
855 856
	if (priv->line_status & UART_BREAK_ERROR)
		usb_serial_handle_break(port);
857
	wake_up_interruptible(&port->port.delta_msr_wait);
858 859 860 861 862 863 864 865

	tty = tty_port_tty_get(&port->port);
	if (!tty)
		return;
	if ((priv->line_status ^ prev_line_status) & UART_DCD)
		usb_serial_handle_dcd_change(port, tty,
				priv->line_status & UART_DCD);
	tty_kref_put(tty);
F
Flavio Leitner 已提交
866
}
L
Linus Torvalds 已提交
867

868
static void pl2303_read_int_callback(struct urb *urb)
L
Linus Torvalds 已提交
869
{
870
	struct usb_serial_port *port =  urb->context;
L
Linus Torvalds 已提交
871
	unsigned char *data = urb->transfer_buffer;
F
Flavio Leitner 已提交
872
	unsigned int actual_length = urb->actual_length;
873 874
	int status = urb->status;
	int retval;
L
Linus Torvalds 已提交
875

876
	switch (status) {
L
Linus Torvalds 已提交
877 878 879 880 881 882 883
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
884 885
		dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
			__func__, status);
L
Linus Torvalds 已提交
886 887
		return;
	default:
888 889
		dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
			__func__, status);
L
Linus Torvalds 已提交
890 891 892
		goto exit;
	}

893
	usb_serial_debug_data(&port->dev, __func__,
894 895
			      urb->actual_length, urb->transfer_buffer);

F
Flavio Leitner 已提交
896
	pl2303_update_line_status(port, data, actual_length);
L
Linus Torvalds 已提交
897 898

exit:
899 900
	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval)
901
		dev_err(&port->dev,
902
			"%s - usb_submit_urb failed with result %d\n",
903
			__func__, retval);
L
Linus Torvalds 已提交
904 905
}

906
static void pl2303_process_read_urb(struct urb *urb)
907
{
908 909
	struct usb_serial_port *port = urb->context;
	struct pl2303_private *priv = usb_get_serial_port_data(port);
910 911
	unsigned char *data = urb->transfer_buffer;
	char tty_flag = TTY_NORMAL;
912 913 914 915 916 917 918 919 920
	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);
921
	wake_up_interruptible(&port->port.delta_msr_wait);
922 923 924 925

	if (!urb->actual_length)
		return;

926 927 928 929 930 931 932 933 934
	/* break takes precedence over parity, */
	/* which takes precedence over framing errors */
	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;

935 936 937
	if (tty_flag != TTY_NORMAL)
		dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
								tty_flag);
938 939
	/* overrun is special, not associated with a char */
	if (line_status & UART_OVERRUN_ERROR)
J
Jiri Slaby 已提交
940
		tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
941

942
	if (port->port.console && port->sysrq) {
943
		for (i = 0; i < urb->actual_length; ++i)
944
			if (!usb_serial_handle_sysrq_char(port, data[i]))
J
Jiri Slaby 已提交
945 946
				tty_insert_flip_char(&port->port, data[i],
						tty_flag);
947
	} else {
948
		tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
949
							urb->actual_length);
950
	}
L
Linus Torvalds 已提交
951

J
Jiri Slaby 已提交
952
	tty_flip_buffer_push(&port->port);
L
Linus Torvalds 已提交
953 954
}

955 956 957 958 959 960 961 962
/* All of the device info needed for the PL2303 SIO serial converter */
static struct usb_serial_driver pl2303_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"pl2303",
	},
	.id_table =		id_table,
	.num_ports =		1,
963
	.bulk_in_size =		256,
964
	.bulk_out_size =	256,
965 966
	.open =			pl2303_open,
	.close =		pl2303_close,
967 968
	.dtr_rts = 		pl2303_dtr_rts,
	.carrier_raised =	pl2303_carrier_raised,
969 970 971 972 973
	.ioctl =		pl2303_ioctl,
	.break_ctl =		pl2303_break_ctl,
	.set_termios =		pl2303_set_termios,
	.tiocmget =		pl2303_tiocmget,
	.tiocmset =		pl2303_tiocmset,
974
	.tiocmiwait =		pl2303_tiocmiwait,
975
	.process_read_urb =	pl2303_process_read_urb,
976 977
	.read_int_callback =	pl2303_read_int_callback,
	.attach =		pl2303_startup,
978
	.release =		pl2303_release,
979 980
	.port_probe =		pl2303_port_probe,
	.port_remove =		pl2303_port_remove,
981
};
L
Linus Torvalds 已提交
982

983 984 985 986
static struct usb_serial_driver * const serial_drivers[] = {
	&pl2303_device, NULL
};

987
module_usb_serial_driver(serial_drivers, id_table);
L
Linus Torvalds 已提交
988 989 990

MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");