Release 4.7 drivers/usb/serial/pl2303.c

Directory: drivers/usb/serial
/*
 * Prolific PL2303 USB to serial adaptor driver
 *
 * Copyright (C) 2001-2007 Greg Kroah-Hartman (greg@kroah.com)
 * Copyright (C) 2003 IBM Corp.
 *
 * Original driver for 2.2.x by anonymous
 *
 *      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.
 *
 * See Documentation/usb/usb-serial.txt for more information on using this
 * driver
 */

#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>
#include <linux/uaccess.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>
#include <asm/unaligned.h>
#include "pl2303.h"



#define PL2303_QUIRK_UART_STATE_IDX0		BIT(0)

#define PL2303_QUIRK_LEGACY			BIT(1)


static const struct usb_device_id id_table[] = {
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_DCU11) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ3) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_PHAROS) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ALDIGA) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MMX) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_GPRS) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
	{ USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ZTEK) },
	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
	{ USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
	{ 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) },
	{ USB_DEVICE(ITEGNO_VENDOR_ID, ITEGNO_PRODUCT_ID_2080) },
	{ 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(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 },
	{ USB_DEVICE(SIEMENS_VENDOR_ID, SIEMENS_PRODUCT_ID_EF81) },
	{ USB_DEVICE(BENQ_VENDOR_ID, BENQ_PRODUCT_ID_S81) }, /* Benq/Siemens S81 */
	{ USB_DEVICE(SYNTECH_VENDOR_ID, SYNTECH_PRODUCT_ID) },
	{ USB_DEVICE(NOKIA_CA42_VENDOR_ID, NOKIA_CA42_PRODUCT_ID) },
	{ USB_DEVICE(CA_42_CA42_VENDOR_ID, CA_42_CA42_PRODUCT_ID) },
	{ USB_DEVICE(SAGEM_VENDOR_ID, SAGEM_PRODUCT_ID) },
	{ USB_DEVICE(LEADTEK_VENDOR_ID, LEADTEK_9531_PRODUCT_ID) },
	{ USB_DEVICE(SPEEDDRAGON_VENDOR_ID, SPEEDDRAGON_PRODUCT_ID) },
	{ USB_DEVICE(DATAPILOT_U2_VENDOR_ID, DATAPILOT_U2_PRODUCT_ID) },
	{ USB_DEVICE(BELKIN_VENDOR_ID, BELKIN_PRODUCT_ID) },
	{ USB_DEVICE(ALCOR_VENDOR_ID, ALCOR_PRODUCT_ID) },
	{ USB_DEVICE(WS002IN_VENDOR_ID, WS002IN_PRODUCT_ID) },
	{ USB_DEVICE(COREGA_VENDOR_ID, COREGA_PRODUCT_ID) },
	{ USB_DEVICE(YCCABLE_VENDOR_ID, YCCABLE_PRODUCT_ID) },
	{ USB_DEVICE(SUPERIAL_VENDOR_ID, SUPERIAL_PRODUCT_ID) },
	{ USB_DEVICE(HP_VENDOR_ID, HP_LD220_PRODUCT_ID) },
	{ 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) },
	{ USB_DEVICE(CRESSI_VENDOR_ID, CRESSI_EDY_PRODUCT_ID) },
	{ USB_DEVICE(ZEAGLE_VENDOR_ID, ZEAGLE_N2ITION3_PRODUCT_ID) },
	{ USB_DEVICE(SONY_VENDOR_ID, SONY_QN3USB_PRODUCT_ID) },
	{ USB_DEVICE(SANWA_VENDOR_ID, SANWA_PRODUCT_ID) },
	{ USB_DEVICE(ADLINK_VENDOR_ID, ADLINK_ND6530_PRODUCT_ID) },
	{ USB_DEVICE(SMART_VENDOR_ID, SMART_PRODUCT_ID) },
	{ }					/* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, id_table);


#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

#define BREAK_REQUEST			0x23

#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_INDEX		8

#define UART_STATE_MSR_MASK		0x8b

#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

static void pl2303_set_break(struct usb_serial_port *port, bool enable);


enum pl2303_type {
	
TYPE_01,	/* Type 0 and 1 (difference unknown) */
	
TYPE_HX,	/* HX version of the pl2303 chip */
	
TYPE_COUNT
};


struct pl2303_type_data {
	
speed_t max_baud_rate;
	
unsigned long quirks;
};


struct pl2303_serial_private {
	
const struct pl2303_type_data *type;
	
unsigned long quirks;
};


struct pl2303_private {
	
spinlock_t lock;
	
u8 line_control;
	
u8 line_status;

	
u8 line_settings[7];
};


static const struct pl2303_type_data pl2303_type_data[TYPE_COUNT] = {
	[TYPE_01] = {
		.max_baud_rate =	1228800,
		.quirks =		PL2303_QUIRK_LEGACY,
        },
	[TYPE_HX] = {
		.max_baud_rate =	12000000,
        },
};



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

	res = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
			VENDOR_READ_REQUEST, VENDOR_READ_REQUEST_TYPE,
			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;
	}

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

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 102 83.61% 3 42.86%
thiago galesi thiago galesi 13 10.66% 1 14.29%
greg kroah-hartman greg kroah-hartman 5 4.10% 2 28.57%
linus torvalds linus torvalds 2 1.64% 1 14.29%
Total 122 100.00% 7 100.00%



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

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

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

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 89 87.25% 3 50.00%
thiago galesi thiago galesi 7 6.86% 1 16.67%
al borchers al borchers 4 3.92% 1 16.67%
greg kroah-hartman greg kroah-hartman 2 1.96% 1 16.67%
Total 102 100.00% 6 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 33 100.00% 1 100.00%
Total 33 100.00% 1 100.00%



static int pl2303_startup(struct usb_serial *serial)
{
	struct pl2303_serial_private *spriv;
	enum pl2303_type type = TYPE_01;
	unsigned char *buf;

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

	buf = kmalloc(1, GFP_KERNEL);
	if (!buf) {
		kfree(spriv);
		return -ENOMEM;
	}

	if (serial->dev->descriptor.bDeviceClass == 0x02)
		type = TYPE_01;		/* type 0 */
	else if (serial->dev->descriptor.bMaxPacketSize0 == 0x40)
		type = TYPE_HX;
	else if (serial->dev->descriptor.bDeviceClass == 0x00)
		type = TYPE_01;		/* type 1 */
	else if (serial->dev->descriptor.bDeviceClass == 0xFF)
		type = TYPE_01;		/* type 1 */
	dev_dbg(&serial->interface->dev, "device type: %d\n", type);

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

	usb_set_serial_data(serial, spriv);

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

	kfree(buf);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 234 72.45% 7 43.75%
al borchers al borchers 34 10.53% 2 12.50%
thiago galesi thiago galesi 21 6.50% 1 6.25%
greg kroah-hartman greg kroah-hartman 18 5.57% 4 25.00%
linus torvalds linus torvalds 16 4.95% 2 12.50%
Total 323 100.00% 16 100.00%



static void pl2303_release(struct usb_serial *serial)
{
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);

	kfree(spriv);
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 25 96.15% 3 75.00%
al borchers al borchers 1 3.85% 1 25.00%
Total 26 100.00% 4 100.00%



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

	port->port.drain_delay = 256;

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 57 89.06% 3 75.00%
al borchers al borchers 7 10.94% 1 25.00%
Total 64 100.00% 4 100.00%



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

	kfree(priv);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 26 89.66% 2 66.67%
al borchers al borchers 3 10.34% 1 33.33%
Total 29 100.00% 3 100.00%



static int pl2303_set_control_lines(struct usb_serial_port *port, u8 value)
{
	struct usb_device *dev = port->serial->dev;
	int retval;

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

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

	return retval;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 64 70.33% 3 50.00%
al borchers al borchers 22 24.18% 1 16.67%
greg kroah-hartman greg kroah-hartman 4 4.40% 1 16.67%
harvey harrison harvey harrison 1 1.10% 1 16.67%
Total 91 100.00% 6 100.00%

/*
 * Returns the nearest supported baud rate that can be set directly without
 * using divisors.
 */


static speed_t pl2303_get_supported_baud_rate(speed_t baud)
{
	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,
		614400, 921600, 1228800, 2457600, 3000000, 6000000
	};

	unsigned i;

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

	return baud;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 85 52.15% 4 50.00%
frank schaefer frank schaefer 57 34.97% 1 12.50%
linus torvalds linus torvalds 17 10.43% 2 25.00%
al borchers al borchers 4 2.45% 1 12.50%
Total 163 100.00% 8 100.00%

/*
 * 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;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 26 100.00% 1 100.00%
Total 26 100.00% 1 100.00%



static speed_t pl2303_encode_baud_rate_divisor(unsigned char buf[4],
								speed_t baud)
{
	unsigned int baseline, mantissa, exponent;

	/*
         * Apparently the formula is:
         *   baudrate = 12M * 32 / (mantissa * 4^exponent)
         * where
         *   mantissa = buf[8:0]
         *   exponent = buf[11:9]
         */
	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;
		}
	}

	buf[3] = 0x80;
	buf[2] = 0;
	buf[1] = exponent << 1 | mantissa >> 8;
	buf[0] = mantissa & 0xff;

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

	return baud;
}

Contributors
Person Tokens Prop Commits CommitProp
michal pecio michal pecio 83 59.71% 1 50.00%
johan hovold johan hovold 56 40.29% 1 50.00%
Total 139 100.00% 2 100.00%



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);
	speed_t	baud_sup;
	speed_t baud;

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

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

	if (baud == baud_sup)
		baud = pl2303_encode_baud_rate_direct(buf, baud);
	else
		baud = pl2303_encode_baud_rate_divisor(buf, baud);

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

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 126 84.00% 9 56.25%
frank schaefer frank schaefer 7 4.67% 3 18.75%
greg kroah-hartman greg kroah-hartman 7 4.67% 2 12.50%
lauri hintsala lauri hintsala 5 3.33% 1 6.25%
linus torvalds linus torvalds 5 3.33% 1 6.25%
Total 150 100.00% 16 100.00%



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

		if (ret > 0)
			ret = -EIO;

		return ret;
	}

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

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 113 100.00% 1 100.00%
Total 113 100.00% 1 100.00%



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);
	if (ret != 7) {
		dev_err(&port->dev, "%s - failed: %d\n", __func__, ret);

		if (ret > 0)
			ret = -EIO;

		return ret;
	}

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

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 113 100.00% 1 100.00%
Total 113 100.00% 1 100.00%



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 ret;
	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;
	}

	pl2303_get_line_request(port, buf);

	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;
	}
	dev_dbg(&port->dev, "data bits = %d\n", buf[6]);

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

	/* 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 */
	if (C_CSTOPB(tty)) {
		/*
                 * NOTE: Comply with "real" UARTs / RS232:
                 *       use 1.5 instead of 2 stop bits with 5 data bits
                 */
		if (C_CSIZE(tty) == CS5) {
			buf[4] = 1;
			dev_dbg(&port->dev, "stop bits = 1.5\n");
		} else {
			buf[4] = 2;
			dev_dbg(&port->dev, "stop bits = 2\n");
		}
	} else {
		buf[4] = 0;
		dev_dbg(&port->dev, "stop bits = 1\n");
	}

	if (C_PARENB(tty)) {
		/* 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 */
		if (C_PARODD(tty)) {
			if (C_CMSPAR(tty)) {
				buf[5] = 3;
				dev_dbg(&port->dev, "parity = mark\n");
			} else {
				buf[5] = 1;
				dev_dbg(&port->dev, "parity = odd\n");
			}
		} else {
			if (C_CMSPAR(tty)) {
				buf[5] = 4;
				dev_dbg(&port->dev, "parity = space\n");
			} else {
				buf[5] = 2;
				dev_dbg(&port->dev, "parity = even\n");
			}
		}
	} else {
		buf[5] = 0;
		dev_dbg(&port->dev, "parity = none\n");
	}

	/*
         * 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)) {
		ret = pl2303_set_line_request(port, buf);
		if (!ret)
			memcpy(priv->line_settings, buf, 7);
	}

	/* change control lines if we are switching to or from B0 */
	spin_lock_irqsave(&priv->lock, flags);
	control = priv->line_control;
	if (C_BAUD(tty) == B0)
		priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
	else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
		priv->line_control |= (CONTROL_DTR | CONTROL_RTS);
	if (control != priv->line_control) {
		control = priv->line_control;
		spin_unlock_irqrestore(&priv->lock, flags);
		pl2303_set_control_lines(port, control);
	} else {
		spin_unlock_irqrestore(&priv->lock, flags);
	}

	if (C_CRTSCTS(tty)) {
		if (spriv->quirks & PL2303_QUIRK_LEGACY)
			pl2303_vendor_write(serial, 0x0, 0x41);
		else
			pl2303_vendor_write(serial, 0x0, 0x61);
	} else {
		pl2303_vendor_write(serial, 0x0, 0x0);
	}

	kfree(buf);
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 252 40.45% 13 43.33%
linus torvalds linus torvalds 142 22.79% 4 13.33%
greg kroah-hartman greg kroah-hartman 121 19.42% 7 23.33%
frank schaefer frank schaefer 73 11.72% 3 10.00%
michal sroczynski michal sroczynski 21 3.37% 1 3.33%
t. sefzick t. sefzick 9 1.44% 1 3.33%
sarah sharp sarah sharp 5 0.80% 1 3.33%
Total 623 100.00% 30 100.00%



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

	pl2303_set_control_lines(port, control);
}

Contributors
Person Tokens Prop Commits CommitProp
alan cox alan cox 33 36.67% 1 16.67%
greg kroah-hartman greg kroah-hartman 26 28.89% 2 33.33%
thiago galesi thiago galesi 17 18.89% 1 16.67%
linus torvalds linus torvalds 13 14.44% 1 16.67%
johan hovold johan hovold 1 1.11% 1 16.67%
Total 90 100.00% 6 100.00%



static void pl2303_close(struct usb_serial_port *port)
{
	usb_serial_generic_close(port);
	usb_kill_urb(port->interrupt_in_urb);
	pl2303_set_break(port, false);
}

Contributors
Person Tokens Prop Commits CommitProp
alan cox alan cox 10 33.33% 1 16.67%
johan hovold johan hovold 8 26.67% 2 33.33%
thiago galesi thiago galesi 8 26.67% 1 16.67%
linus torvalds linus torvalds 4 13.33% 2 33.33%
Total 30 100.00% 6 100.00%



static int pl2303_open(struct tty_struct *tty, struct usb_serial_port *port)
{
	struct usb_serial *serial = port->serial;
	struct pl2303_serial_private *spriv = usb_get_serial_data(serial);
	int result;

	if (spriv->quirks & PL2303_QUIRK_LEGACY) {
		usb_clear_halt(serial->dev, port->write_urb->pipe);
		usb_clear_halt(serial->dev, port->read_urb->pipe);
	} else {
		/* reset upstream data pipes */
		pl2303_vendor_write(serial, 8, 0);
		pl2303_vendor_write(serial, 9, 0);
	}

	/* Setup termios */
	if (tty)
		pl2303_set_termios(tty, port, NULL);

	result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
	if (result) {
		dev_err(&port->dev, "failed to submit interrupt urb: %d\n",
			result);
		return result;
	}

	result = usb_serial_generic_open(tty, port);
	if (result) {
		usb_kill_urb(port->interrupt_in_urb);
		return result;
	}

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
thiago galesi thiago galesi 75 44.12% 1 5.88%
johan hovold johan hovold 31 18.24% 8 47.06%
al borchers al borchers 30 17.65% 1 5.88%
linus torvalds linus torvalds 13 7.65% 3 17.65%
greg kroah-hartman greg kroah-hartman 11 6.47% 1 5.88%
alan cox alan cox 7 4.12% 1 5.88%
sarah sharp sarah sharp 3 1.76% 2 11.76%
Total 170 100.00% 17 100.00%



static int pl2303_tiocmset(struct tty_struct *tty,
			   unsigned int set, unsigned int clear)
{
	struct usb_serial_port *port = tty->driver_data;
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	u8 control;
	int ret;

	spin_lock_irqsave(&priv->lock, flags);
	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;
	spin_unlock_irqrestore(&priv->lock, flags);

	ret = pl2303_set_control_lines(port, control);
	if (ret)
		return usb_translate_errors(ret);

	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 70 47.95% 1 10.00%
greg kroah-hartman greg kroah-hartman 44 30.14% 4 40.00%
johan hovold johan hovold 21 14.38% 4 40.00%
alan cox alan cox 11 7.53% 1 10.00%
Total 146 100.00% 10 100.00%



static int pl2303_tiocmget(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	unsigned int mcr;
	unsigned int status;
	unsigned int result;

	spin_lock_irqsave(&priv->lock, flags);
	mcr = priv->line_control;
	status = priv->line_status;
	spin_unlock_irqrestore(&priv->lock, flags);

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

	dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);

	return result;
}

Contributors
Person Tokens Prop Commits CommitProp
greg kroah-hartman greg kroah-hartman 101 59.76% 8 72.73%
linus torvalds linus torvalds 56 33.14% 1 9.09%
alan cox alan cox 11 6.51% 1 9.09%
harvey harrison harvey harrison 1 0.59% 1 9.09%
Total 169 100.00% 11 100.00%



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

Contributors
Person Tokens Prop Commits CommitProp
alan cox alan cox 35 100.00% 1 100.00%
Total 35 100.00% 1 100.00%



static int pl2303_ioctl(struct tty_struct *tty,
			unsigned int cmd, unsigned long arg)
{
	struct serial_struct ser;
	struct usb_serial_port *port = tty->driver_data;

	switch (cmd) {
	case TIOCGSERIAL:
		memset(&ser, 0, sizeof ser);
		ser.type = PORT_16654;
		ser.line = port->minor;
		ser.port = port->port_number;
		ser.baud_base = 460800;

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

		return 0;
	default:
		break;
	}

	return -ENOIOCTLCMD;
}

Contributors
Person Tokens Prop Commits CommitProp
john tsiombikas john tsiombikas 69 62.16% 1 16.67%
linus torvalds linus torvalds 29 26.13% 2 33.33%
alan cox alan cox 11 9.91% 1 16.67%
ahmon dancy ahmon dancy 1 0.90% 1 16.67%
greg kroah-hartman greg kroah-hartman 1 0.90% 1 16.67%
Total 111 100.00% 6 100.00%



static void pl2303_set_break(struct usb_serial_port *port, bool enable)
{
	struct usb_serial *serial = port->serial;
	u16 state;
	int result;

	if (enable)
		state = BREAK_ON;
	else
		state = BREAK_OFF;

	dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
			state == BREAK_OFF ? "off" : "on");

	result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
				 BREAK_REQUEST, BREAK_REQUEST_TYPE, state,
				 0, NULL, 0, 100);
	if (result)
		dev_err(&port->dev, "error sending break = %d\n", result);
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 85 77.27% 2 25.00%
greg kroah-hartman greg kroah-hartman 15 13.64% 3 37.50%
johan hovold johan hovold 8 7.27% 1 12.50%
phil dibowitz phil dibowitz 1 0.91% 1 12.50%
harvey harrison harvey harrison 1 0.91% 1 12.50%
Total 110 100.00% 8 100.00%



static void pl2303_break_ctl(struct tty_struct *tty, int state)
{
	struct usb_serial_port *port = tty->driver_data;

	pl2303_set_break(port, state);
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 30 100.00% 1 100.00%
Total 30 100.00% 1 100.00%



static void pl2303_update_line_status(struct usb_serial_port *port,
				      unsigned char *data,
				      unsigned int actual_length)
{
	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);
	struct tty_struct *tty;
	unsigned long flags;
	unsigned int status_idx = UART_STATE_INDEX;
	u8 status;
	u8 delta;

	if (spriv->quirks & PL2303_QUIRK_UART_STATE_IDX0)
		status_idx = 0;

	if (actual_length < status_idx + 1)
		return;

	status = data[status_idx];

	/* Save off the uart status for others to look at */
	spin_lock_irqsave(&priv->lock, flags);
	delta = priv->line_status ^ status;
	priv->line_status = status;
	spin_unlock_irqrestore(&priv->lock, flags);

	if (status & UART_BREAK_ERROR)
		usb_serial_handle_break(port);

	if (delta & UART_STATE_MSR_MASK) {
		if (delta & UART_CTS)
			port->icount.cts++;
		if (delta & UART_DSR)
			port->icount.dsr++;
		if (delta & UART_RING)
			port->icount.rng++;
		if (delta & UART_DCD) {
			port->icount.dcd++;
			tty = tty_port_tty_get(&port->port);
			if (tty) {
				usb_serial_handle_dcd_change(port, tty,
							status & UART_DCD);
				tty_kref_put(tty);
			}
		}

		wake_up_interruptible(&port->port.delta_msr_wait);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 120 48.39% 4 30.77%
libor pechacek libor pechacek 41 16.53% 1 7.69%
flavio leitner flavio leitner 36 14.52% 1 7.69%
thiago galesi thiago galesi 30 12.10% 2 15.38%
greg kroah-hartman greg kroah-hartman 10 4.03% 3 23.08%
jason wessel jason wessel 10 4.03% 1 7.69%
linus torvalds linus torvalds 1 0.40% 1 7.69%
Total 248 100.00% 13 100.00%



static void pl2303_read_int_callback(struct urb *urb)
{
	struct usb_serial_port *port =  urb->context;
	unsigned char *data = urb->transfer_buffer;
	unsigned int actual_length = urb->actual_length;
	int status = urb->status;
	int retval;

	switch (status) {
	case 0:
		/* success */
		break;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
			__func__, status);
		return;
	default:
		dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
			__func__, status);
		goto exit;
	}

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

	pl2303_update_line_status(port, data, actual_length);

exit:
	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval) {
		dev_err(&port->dev,
			"%s - usb_submit_urb failed with result %d\n",
			__func__, retval);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
linus torvalds linus torvalds 72 44.44% 3 18.75%
greg kroah-hartman greg kroah-hartman 43 26.54% 8 50.00%
thiago galesi thiago galesi 38 23.46% 1 6.25%
harvey harrison harvey harrison 4 2.47% 1 6.25%
johan hovold johan hovold 2 1.23% 1 6.25%
alan cox alan cox 2 1.23% 1 6.25%
ganesh varadarajan ganesh varadarajan 1 0.62% 1 6.25%
Total 162 100.00% 16 100.00%



static void pl2303_process_read_urb(struct urb *urb)
{
	struct usb_serial_port *port = urb->context;
	struct pl2303_private *priv = usb_get_serial_port_data(port);
	unsigned char *data = urb->transfer_buffer;
	char tty_flag = TTY_NORMAL;
	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;

	/*
         * 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;

	if (tty_flag != TTY_NORMAL)
		dev_dbg(&port->dev, "%s - tty_flag = %d\n", __func__,
								tty_flag);
	/* overrun is special, not associated with a char */
	if (line_status & UART_OVERRUN_ERROR)
		tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);

	if (port->port.console && port->sysrq) {
		for (i = 0; i < urb->actual_length; ++i)
			if (!usb_serial_handle_sysrq_char(port, data[i]))
				tty_insert_flip_char(&port->port, data[i],
						tty_flag);
	} else {
		tty_insert_flip_string_fixed_flag(&port->port, data, tty_flag,
							urb->actual_length);
	}

	tty_flip_buffer_push(&port->port);
}

Contributors
Person Tokens Prop Commits CommitProp
alan cox alan cox 134 53.17% 2 16.67%
johan hovold johan hovold 92 36.51% 4 33.33%
jiri slaby jiri slaby 16 6.35% 3 25.00%
greg kroah-hartman greg kroah-hartman 7 2.78% 1 8.33%
jason wessel jason wessel 2 0.79% 1 8.33%
al borchers al borchers 1 0.40% 1 8.33%
Total 252 100.00% 12 100.00%


static struct usb_serial_driver pl2303_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"pl2303",
        },
	.id_table =		id_table,
	.num_ports =		1,
	.bulk_in_size =		256,
	.bulk_out_size =	256,
	.open =			pl2303_open,
	.close =		pl2303_close,
	.dtr_rts =		pl2303_dtr_rts,
	.carrier_raised =	pl2303_carrier_raised,
	.ioctl =		pl2303_ioctl,
	.break_ctl =		pl2303_break_ctl,
	.set_termios =		pl2303_set_termios,
	.tiocmget =		pl2303_tiocmget,
	.tiocmset =		pl2303_tiocmset,
	.tiocmiwait =		usb_serial_generic_tiocmiwait,
	.process_read_urb =	pl2303_process_read_urb,
	.read_int_callback =	pl2303_read_int_callback,
	.probe =		pl2303_probe,
	.attach =		pl2303_startup,
	.release =		pl2303_release,
	.port_probe =		pl2303_port_probe,
	.port_remove =		pl2303_port_remove,
};


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

module_usb_serial_driver(serial_drivers, id_table);

MODULE_DESCRIPTION("Prolific PL2303 USB to serial adaptor driver");
MODULE_LICENSE("GPL");
Overall Contributors
Person Tokens Prop Commits CommitProp
johan hovold johan hovold 1865 40.33% 44 26.19%
linus torvalds linus torvalds 686 14.84% 5 2.98%
greg kroah-hartman greg kroah-hartman 566 12.24% 43 25.60%
thiago galesi thiago galesi 313 6.77% 2 1.19%
alan cox alan cox 275 5.95% 7 4.17%
frank schaefer frank schaefer 137 2.96% 5 2.98%
al borchers al borchers 106 2.29% 2 1.19%
michal pecio michal pecio 83 1.79% 1 0.60%
john tsiombikas john tsiombikas 69 1.49% 1 0.60%
libor pechacek libor pechacek 41 0.89% 1 0.60%
flavio leitner flavio leitner 36 0.78% 1 0.60%
aaron sanders aaron sanders 27 0.58% 1 0.60%
michal sroczynski michal sroczynski 21 0.45% 1 0.60%
masaki chikama masaki chikama 18 0.39% 1 0.60%
alan stern alan stern 18 0.39% 2 1.19%
jiri slaby jiri slaby 16 0.35% 3 1.79%
lauri hintsala lauri hintsala 16 0.35% 1 0.60%
luiz fernando capitulino luiz fernando capitulino 14 0.30% 1 0.60%
jason wessel jason wessel 12 0.26% 2 1.19%
peter favrholdt peter favrholdt 9 0.19% 1 0.60%
christian lindner christian lindner 9 0.19% 1 0.60%
matthew arnold matthew arnold 9 0.19% 1 0.60%
johannes steingraeber johannes steingraeber 9 0.19% 1 0.60%
robert spanton robert spanton 9 0.19% 1 0.60%
mokuno masakazu mokuno masakazu 9 0.19% 1 0.60%
wang jun wang jun 9 0.19% 1 0.60%
gianpaolo cugola gianpaolo cugola 9 0.19% 1 0.60%
simone contini simone contini 9 0.19% 1 0.60%
max arnold max arnold 9 0.19% 1 0.60%
peter moulder peter moulder 9 0.19% 1 0.60%
khanh-dang nguyen thu lam khanh-dang nguyen thu lam 9 0.19% 1 0.60%
pawel ludwikow pawel ludwikow 9 0.19% 1 0.60%
sepp wijnands sepp wijnands 9 0.19% 1 0.60%
dario lombardo dario lombardo 9 0.19% 1 0.60%
dana lacoste dana lacoste 9 0.19% 1 0.60%
mike provencher mike provencher 9 0.19% 1 0.60%
jef driesen jef driesen 9 0.19% 1 0.60%
dick streefland dick streefland 9 0.19% 1 0.60%
steve murphy steve murphy 9 0.19% 1 0.60%
manuel jander manuel jander 9 0.19% 1 0.60%
t. sefzick t. sefzick 9 0.19% 1 0.60%
kim oldfield kim oldfield 9 0.19% 1 0.60%
denis monterrat denis monterrat 9 0.19% 1 0.60%
martin gingras martin gingras 9 0.19% 1 0.60%
andreas loibl andreas loibl 9 0.19% 1 0.60%
magnus damm magnus damm 9 0.19% 1 0.60%
sarah sharp sarah sharp 8 0.17% 2 1.19%
harvey harrison harvey harrison 7 0.15% 1 0.60%
eric benoit eric benoit 6 0.13% 1 0.60%
damien stuart damien stuart 6 0.13% 1 0.60%
matthew meno matthew meno 6 0.13% 1 0.60%
hideaki yoshifuji hideaki yoshifuji 6 0.13% 1 0.60%
arnaldo carvalho de melo arnaldo carvalho de melo 4 0.09% 1 0.60%
wesley pa4wdh wesley pa4wdh 3 0.06% 1 0.60%
wolfgang denk wolfgang denk 3 0.06% 1 0.60%
tomasz kazmierczak tomasz kazmierczak 3 0.06% 1 0.60%
piotr roszatycki piotr roszatycki 3 0.06% 1 0.60%
petr slansky petr slansky 3 0.06% 1 0.60%
ahmon dancy ahmon dancy 1 0.02% 1 0.60%
marton nemeth marton nemeth 1 0.02% 1 0.60%
phil dibowitz phil dibowitz 1 0.02% 1 0.60%
ganesh varadarajan ganesh varadarajan 1 0.02% 1 0.60%
Total 4624 100.00% 168 100.00%
  Directory: drivers/usb/serial

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
johan hovold	johan hovold	102	83.61%	3	42.86%
thiago galesi	thiago galesi	13	10.66%	1	14.29%
greg kroah-hartman	greg kroah-hartman	5	4.10%	2	28.57%
linus torvalds	linus torvalds	2	1.64%	1	14.29%
	Total	122	100.00%	7	100.00%
cregit-Linux how code gets into the kernel

Release 4.7 drivers/usb/serial/pl2303.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
