[deliverable/linux.git] / drivers / usb / serial / safe_serial.c

/*
 * Safe Encapsulated USB Serial Driver
 *
 *      Copyright (C) 2010 Johan Hovold <jhovold@gmail.com>
 *      Copyright (C) 2001 Lineo
 *      Copyright (C) 2001 Hewlett-Packard
 *
 *	This program is free software; you can redistribute it and/or modify
 *	it under the terms of the GNU General Public License as published by
 *	the Free Software Foundation; either version 2 of the License, or
 *	(at your option) any later version.
 *
 * By:
 *      Stuart Lynne <sl@lineo.com>, Tom Rushworth <tbr@lineo.com>
 */

/*
 * The encapsultaion is designed to overcome difficulties with some USB
 * hardware.
 *
 * While the USB protocol has a CRC over the data while in transit, i.e. while
 * being carried over the bus, there is no end to end protection. If the
 * hardware has any problems getting the data into or out of the USB transmit
 * and receive FIFO's then data can be lost.
 *
 * This protocol adds a two byte trailer to each USB packet to specify the
 * number of bytes of valid data and a 10 bit CRC that will allow the receiver
 * to verify that the entire USB packet was received without error.
 *
 * Because in this case the sender and receiver are the class and function
 * drivers there is now end to end protection.
 *
 * There is an additional option that can be used to force all transmitted
 * packets to be padded to the maximum packet size. This provides a work
 * around for some devices which have problems with small USB packets.
 *
 * Assuming a packetsize of N:
 *
 *      0..N-2  data and optional padding
 *
 *      N-2     bits 7-2 - number of bytes of valid data
 *              bits 1-0 top two bits of 10 bit CRC
 *      N-1     bottom 8 bits of 10 bit CRC
 *
 *
 *      | Data Length       | 10 bit CRC                                |
 *      + 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 | 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 +
 *
 * The 10 bit CRC is computed across the sent data, followed by the trailer
 * with the length set and the CRC set to zero. The CRC is then OR'd into
 * the trailer.
 *
 * When received a 10 bit CRC is computed over the entire frame including
 * the trailer and should be equal to zero.
 *
 * Two module parameters are used to control the encapsulation, if both are
 * turned of the module works as a simple serial device with NO
 * encapsulation.
 *
 * See linux/drivers/usbd/serial_fd for a device function driver
 * implementation of this.
 *
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/gfp.h>
#include <linux/init.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/module.h>
#include <linux/spinlock.h>
#include <linux/uaccess.h>
#include <linux/usb.h>
#include <linux/usb/serial.h>


#ifndef CONFIG_USB_SERIAL_SAFE_PADDED
#define CONFIG_USB_SERIAL_SAFE_PADDED 0
#endif

static bool safe = 1;
static bool padded = CONFIG_USB_SERIAL_SAFE_PADDED;

#define DRIVER_AUTHOR "sl@lineo.com, tbr@lineo.com, Johan Hovold <jhovold@gmail.com>"
#define DRIVER_DESC "USB Safe Encapsulated Serial"

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

static __u16 vendor;		/* no default */
static __u16 product;		/* no default */
module_param(vendor, ushort, 0);
MODULE_PARM_DESC(vendor, "User specified USB idVendor (required)");
module_param(product, ushort, 0);
MODULE_PARM_DESC(product, "User specified USB idProduct (required)");

module_param(safe, bool, 0);
MODULE_PARM_DESC(safe, "Turn Safe Encapsulation On/Off");

module_param(padded, bool, 0);
MODULE_PARM_DESC(padded, "Pad to full wMaxPacketSize On/Off");

#define CDC_DEVICE_CLASS                        0x02

#define CDC_INTERFACE_CLASS                     0x02
#define CDC_INTERFACE_SUBCLASS                  0x06

#define LINEO_INTERFACE_CLASS                   0xff

#define LINEO_INTERFACE_SUBCLASS_SAFENET        0x01
#define LINEO_SAFENET_CRC                       0x01
#define LINEO_SAFENET_CRC_PADDED                0x02

#define LINEO_INTERFACE_SUBCLASS_SAFESERIAL     0x02
#define LINEO_SAFESERIAL_CRC                    0x01
#define LINEO_SAFESERIAL_CRC_PADDED             0x02


#define MY_USB_DEVICE(vend, prod, dc, ic, isc) \
	.match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
		       USB_DEVICE_ID_MATCH_DEV_CLASS | \
		       USB_DEVICE_ID_MATCH_INT_CLASS | \
		       USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
	.idVendor = (vend), \
	.idProduct = (prod),\
	.bDeviceClass = (dc),\
	.bInterfaceClass = (ic), \
	.bInterfaceSubClass = (isc),

static struct usb_device_id id_table[] = {
	{MY_USB_DEVICE(0x49f, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},	/* Itsy */
	{MY_USB_DEVICE(0x3f0, 0x2101, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},	/* Calypso */
	{MY_USB_DEVICE(0x4dd, 0x8001, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},	/* Iris */
	{MY_USB_DEVICE(0x4dd, 0x8002, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},	/* Collie */
	{MY_USB_DEVICE(0x4dd, 0x8003, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},	/* Collie */
	{MY_USB_DEVICE(0x4dd, 0x8004, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},	/* Collie */
	{MY_USB_DEVICE(0x5f9, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},	/* Sharp tmp */
	/* extra null entry for module vendor/produc parameters */
	{MY_USB_DEVICE(0, 0, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},
	{}			/* terminating entry  */
};

MODULE_DEVICE_TABLE(usb, id_table);

static const __u16 crc10_table[256] = {
	0x000, 0x233, 0x255, 0x066, 0x299, 0x0aa, 0x0cc, 0x2ff,
	0x301, 0x132, 0x154, 0x367, 0x198, 0x3ab, 0x3cd, 0x1fe,
	0x031, 0x202, 0x264, 0x057, 0x2a8, 0x09b, 0x0fd, 0x2ce,
	0x330, 0x103, 0x165, 0x356, 0x1a9, 0x39a, 0x3fc, 0x1cf,
	0x062, 0x251, 0x237, 0x004, 0x2fb, 0x0c8, 0x0ae, 0x29d,
	0x363, 0x150, 0x136, 0x305, 0x1fa, 0x3c9, 0x3af, 0x19c,
	0x053, 0x260, 0x206, 0x035, 0x2ca, 0x0f9, 0x09f, 0x2ac,
	0x352, 0x161, 0x107, 0x334, 0x1cb, 0x3f8, 0x39e, 0x1ad,
	0x0c4, 0x2f7, 0x291, 0x0a2, 0x25d, 0x06e, 0x008, 0x23b,
	0x3c5, 0x1f6, 0x190, 0x3a3, 0x15c, 0x36f, 0x309, 0x13a,
	0x0f5, 0x2c6, 0x2a0, 0x093, 0x26c, 0x05f, 0x039, 0x20a,
	0x3f4, 0x1c7, 0x1a1, 0x392, 0x16d, 0x35e, 0x338, 0x10b,
	0x0a6, 0x295, 0x2f3, 0x0c0, 0x23f, 0x00c, 0x06a, 0x259,
	0x3a7, 0x194, 0x1f2, 0x3c1, 0x13e, 0x30d, 0x36b, 0x158,
	0x097, 0x2a4, 0x2c2, 0x0f1, 0x20e, 0x03d, 0x05b, 0x268,
	0x396, 0x1a5, 0x1c3, 0x3f0, 0x10f, 0x33c, 0x35a, 0x169,
	0x188, 0x3bb, 0x3dd, 0x1ee, 0x311, 0x122, 0x144, 0x377,
	0x289, 0x0ba, 0x0dc, 0x2ef, 0x010, 0x223, 0x245, 0x076,
	0x1b9, 0x38a, 0x3ec, 0x1df, 0x320, 0x113, 0x175, 0x346,
	0x2b8, 0x08b, 0x0ed, 0x2de, 0x021, 0x212, 0x274, 0x047,
	0x1ea, 0x3d9, 0x3bf, 0x18c, 0x373, 0x140, 0x126, 0x315,
	0x2eb, 0x0d8, 0x0be, 0x28d, 0x072, 0x241, 0x227, 0x014,
	0x1db, 0x3e8, 0x38e, 0x1bd, 0x342, 0x171, 0x117, 0x324,
	0x2da, 0x0e9, 0x08f, 0x2bc, 0x043, 0x270, 0x216, 0x025,
	0x14c, 0x37f, 0x319, 0x12a, 0x3d5, 0x1e6, 0x180, 0x3b3,
	0x24d, 0x07e, 0x018, 0x22b, 0x0d4, 0x2e7, 0x281, 0x0b2,
	0x17d, 0x34e, 0x328, 0x11b, 0x3e4, 0x1d7, 0x1b1, 0x382,
	0x27c, 0x04f, 0x029, 0x21a, 0x0e5, 0x2d6, 0x2b0, 0x083,
	0x12e, 0x31d, 0x37b, 0x148, 0x3b7, 0x184, 0x1e2, 0x3d1,
	0x22f, 0x01c, 0x07a, 0x249, 0x0b6, 0x285, 0x2e3, 0x0d0,
	0x11f, 0x32c, 0x34a, 0x179, 0x386, 0x1b5, 0x1d3, 0x3e0,
	0x21e, 0x02d, 0x04b, 0x278, 0x087, 0x2b4, 0x2d2, 0x0e1,
};

#define CRC10_INITFCS     0x000	/* Initial FCS value */
#define CRC10_GOODFCS     0x000	/* Good final FCS value */
#define CRC10_FCS(fcs, c) ((((fcs) << 8) & 0x3ff) ^ crc10_table[((fcs) >> 2) & 0xff] ^ (c))

/**
 * fcs_compute10 - memcpy and calculate 10 bit CRC across buffer
 * @sp: pointer to buffer
 * @len: number of bytes
 * @fcs: starting FCS
 *
 * Perform a memcpy and calculate fcs using ppp 10bit CRC algorithm. Return
 * new 10 bit FCS.
 */
static __u16 __inline__ fcs_compute10(unsigned char *sp, int len, __u16 fcs)
{
	for (; len-- > 0; fcs = CRC10_FCS(fcs, *sp++));
	return fcs;
}

static void safe_process_read_urb(struct urb *urb)
{
	struct usb_serial_port *port = urb->context;
	unsigned char *data = urb->transfer_buffer;
	unsigned char length = urb->actual_length;
	int actual_length;
	struct tty_struct *tty;
	__u16 fcs;

	if (!length)
		return;

	tty = tty_port_tty_get(&port->port);
	if (!tty)
		return;

	if (!safe)
		goto out;

	fcs = fcs_compute10(data, length, CRC10_INITFCS);
	if (fcs) {
		dev_err(&port->dev, "%s - bad CRC %x\n", __func__, fcs);
		goto err;
	}

	actual_length = data[length - 2] >> 2;
	if (actual_length > (length - 2)) {
		dev_err(&port->dev, "%s - inconsistent lengths %d:%d\n",
				__func__, actual_length, length);
		goto err;
	}
	dev_info(&urb->dev->dev, "%s - actual: %d\n", __func__, actual_length);
	length = actual_length;
out:
	tty_insert_flip_string(tty, data, length);
	tty_flip_buffer_push(tty);
err:
	tty_kref_put(tty);
}

static int safe_prepare_write_buffer(struct usb_serial_port *port,
						void *dest, size_t size)
{
	unsigned char *buf = dest;
	int count;
	int trailer_len;
	int pkt_len;
	__u16 fcs;

	trailer_len = safe ? 2 : 0;

	count = kfifo_out_locked(&port->write_fifo, buf, size - trailer_len,
								&port->lock);
	if (!safe)
		return count;

	/* pad if necessary */
	if (padded) {
		pkt_len = size;
		memset(buf + count, '0', pkt_len - count - trailer_len);
	} else {
		pkt_len = count + trailer_len;
	}

	/* set count */
	buf[pkt_len - 2] = count << 2;
	buf[pkt_len - 1] = 0;

	/* compute fcs and insert into trailer */
	fcs = fcs_compute10(buf, pkt_len, CRC10_INITFCS);
	buf[pkt_len - 2] |= fcs >> 8;
	buf[pkt_len - 1] |= fcs & 0xff;

	return pkt_len;
}

static int safe_startup(struct usb_serial *serial)
{
	switch (serial->interface->cur_altsetting->desc.bInterfaceProtocol) {
	case LINEO_SAFESERIAL_CRC:
		break;
	case LINEO_SAFESERIAL_CRC_PADDED:
		padded = 1;
		break;
	default:
		return -EINVAL;
	}
	return 0;
}

static struct usb_serial_driver safe_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"safe_serial",
	},
	.id_table =		id_table,
	.num_ports =		1,
	.process_read_urb =	safe_process_read_urb,
	.prepare_write_buffer =	safe_prepare_write_buffer,
	.attach =		safe_startup,
};

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

static int __init safe_init(void)
{
	int i;

	/* if we have vendor / product parameters patch them into id list */
	if (vendor || product) {
		pr_info("vendor: %x product: %x\n", vendor, product);

		for (i = 0; i < ARRAY_SIZE(id_table); i++) {
			if (!id_table[i].idVendor && !id_table[i].idProduct) {
				id_table[i].idVendor = vendor;
				id_table[i].idProduct = product;
				break;
			}
		}
	}

	return usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, id_table);
}

static void __exit safe_exit(void)
{
	usb_serial_deregister_drivers(serial_drivers);
}

module_init(safe_init);
module_exit(safe_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Safe Encapsulated USB Serial Driver
	3	*
241c80ea	4	* Copyright (C) 2010 Johan Hovold <jhovold@gmail.com>
1da177e4 LT	5	* Copyright (C) 2001 Lineo
	6	* Copyright (C) 2001 Hewlett-Packard
	7	*
	8	* This program is free software; you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation; either version 2 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* By:
	14	* Stuart Lynne <sl@lineo.com>, Tom Rushworth <tbr@lineo.com>
	15	*/
	16
43c8f435 AC	17	/*
	18	* The encapsultaion is designed to overcome difficulties with some USB
	19	* hardware.
1da177e4 LT	20	*
1da177e4 LT	21	* While the USB protocol has a CRC over the data while in transit, i.e. while
43c8f435 AC	22	* being carried over the bus, there is no end to end protection. If the
	23	* hardware has any problems getting the data into or out of the USB transmit
	24	* and receive FIFO's then data can be lost.
1da177e4	25	*
43c8f435 AC	26	* This protocol adds a two byte trailer to each USB packet to specify the
	27	* number of bytes of valid data and a 10 bit CRC that will allow the receiver
	28	* to verify that the entire USB packet was received without error.
1da177e4	29	*
43c8f435 AC	30	* Because in this case the sender and receiver are the class and function
43c8f435 AC	31	* drivers there is now end to end protection.
1da177e4	32	*
43c8f435 AC	33	* There is an additional option that can be used to force all transmitted
	34	* packets to be padded to the maximum packet size. This provides a work
	35	* around for some devices which have problems with small USB packets.
1da177e4 LT	36	*
	37	* Assuming a packetsize of N:
	38	*
	39	* 0..N-2 data and optional padding
	40	*
	41	* N-2 bits 7-2 - number of bytes of valid data
	42	* bits 1-0 top two bits of 10 bit CRC
	43	* N-1 bottom 8 bits of 10 bit CRC
	44	*
	45	*
	46	* \| Data Length \| 10 bit CRC \|
	47	* + 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 \| 7 . 6 . 5 . 4 . 3 . 2 . 1 . 0 +
	48	*
43c8f435 AC	49	* The 10 bit CRC is computed across the sent data, followed by the trailer
	50	* with the length set and the CRC set to zero. The CRC is then OR'd into
	51	* the trailer.
1da177e4	52	*
43c8f435 AC	53	* When received a 10 bit CRC is computed over the entire frame including
43c8f435 AC	54	* the trailer and should be equal to zero.
1da177e4 LT	55	*
	56	* Two module parameters are used to control the encapsulation, if both are
	57	* turned of the module works as a simple serial device with NO
	58	* encapsulation.
	59	*
	60	* See linux/drivers/usbd/serial_fd for a device function driver
	61	* implementation of this.
	62	*
	63	*/
	64
93ba0f03	65	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
1da177e4	66
1da177e4 LT	67	#include <linux/kernel.h>
1da177e4 LT	68	#include <linux/errno.h>
5a0e3ad6	69	#include <linux/gfp.h>
1da177e4	70	#include <linux/init.h>
1da177e4 LT	71	#include <linux/tty.h>
	72	#include <linux/tty_driver.h>
	73	#include <linux/tty_flip.h>
	74	#include <linux/module.h>
	75	#include <linux/spinlock.h>
43c8f435	76	#include <linux/uaccess.h>
1da177e4	77	#include <linux/usb.h>
a969888c	78	#include <linux/usb/serial.h>
1da177e4 LT	79
1da177e4 LT	80
3aec6e26 RD	81	#ifndef CONFIG_USB_SERIAL_SAFE_PADDED
3aec6e26 RD	82	#define CONFIG_USB_SERIAL_SAFE_PADDED 0
1da177e4 LT	83	#endif
1da177e4 LT	84
90ab5ee9 RR	85	static bool safe = 1;
90ab5ee9 RR	86	static bool padded = CONFIG_USB_SERIAL_SAFE_PADDED;
1da177e4	87
241c80ea	88	#define DRIVER_AUTHOR "sl@lineo.com, tbr@lineo.com, Johan Hovold <jhovold@gmail.com>"
1da177e4 LT	89	#define DRIVER_DESC "USB Safe Encapsulated Serial"
1da177e4 LT	90
43c8f435 AC	91	MODULE_AUTHOR(DRIVER_AUTHOR);
43c8f435 AC	92	MODULE_DESCRIPTION(DRIVER_DESC);
1da177e4 LT	93	MODULE_LICENSE("GPL");
1da177e4 LT	94
43c8f435 AC	95	static __u16 vendor; /* no default */
43c8f435 AC	96	static __u16 product; /* no default */
1da177e4 LT	97	module_param(vendor, ushort, 0);
	98	MODULE_PARM_DESC(vendor, "User specified USB idVendor (required)");
	99	module_param(product, ushort, 0);
	100	MODULE_PARM_DESC(product, "User specified USB idProduct (required)");
1da177e4	101
1da177e4 LT	102	module_param(safe, bool, 0);
	103	MODULE_PARM_DESC(safe, "Turn Safe Encapsulation On/Off");
	104
	105	module_param(padded, bool, 0);
	106	MODULE_PARM_DESC(padded, "Pad to full wMaxPacketSize On/Off");
	107
	108	#define CDC_DEVICE_CLASS 0x02
	109
	110	#define CDC_INTERFACE_CLASS 0x02
	111	#define CDC_INTERFACE_SUBCLASS 0x06
	112
	113	#define LINEO_INTERFACE_CLASS 0xff
	114
	115	#define LINEO_INTERFACE_SUBCLASS_SAFENET 0x01
	116	#define LINEO_SAFENET_CRC 0x01
	117	#define LINEO_SAFENET_CRC_PADDED 0x02
	118
	119	#define LINEO_INTERFACE_SUBCLASS_SAFESERIAL 0x02
	120	#define LINEO_SAFESERIAL_CRC 0x01
	121	#define LINEO_SAFESERIAL_CRC_PADDED 0x02
	122
	123
43c8f435 AC	124	#define MY_USB_DEVICE(vend, prod, dc, ic, isc) \
	125	.match_flags = USB_DEVICE_ID_MATCH_DEVICE \| \
	126	USB_DEVICE_ID_MATCH_DEV_CLASS \| \
	127	USB_DEVICE_ID_MATCH_INT_CLASS \| \
	128	USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
	129	.idVendor = (vend), \
	130	.idProduct = (prod),\
	131	.bDeviceClass = (dc),\
	132	.bInterfaceClass = (ic), \
	133	.bInterfaceSubClass = (isc),
1da177e4 LT	134
1da177e4 LT	135	static struct usb_device_id id_table[] = {
43c8f435 AC	136	{MY_USB_DEVICE(0x49f, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Itsy */
	137	{MY_USB_DEVICE(0x3f0, 0x2101, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Calypso */
	138	{MY_USB_DEVICE(0x4dd, 0x8001, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Iris */
	139	{MY_USB_DEVICE(0x4dd, 0x8002, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Collie */
	140	{MY_USB_DEVICE(0x4dd, 0x8003, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Collie */
	141	{MY_USB_DEVICE(0x4dd, 0x8004, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Collie */
	142	{MY_USB_DEVICE(0x5f9, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Sharp tmp */
	143	/* extra null entry for module vendor/produc parameters */
	144	{MY_USB_DEVICE(0, 0, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)},
	145	{} /* terminating entry */
1da177e4 LT	146	};
1da177e4 LT	147
43c8f435	148	MODULE_DEVICE_TABLE(usb, id_table);
1da177e4	149
4c4c9432	150	static const __u16 crc10_table[256] = {
43c8f435 AC	151	0x000, 0x233, 0x255, 0x066, 0x299, 0x0aa, 0x0cc, 0x2ff,
	152	0x301, 0x132, 0x154, 0x367, 0x198, 0x3ab, 0x3cd, 0x1fe,
	153	0x031, 0x202, 0x264, 0x057, 0x2a8, 0x09b, 0x0fd, 0x2ce,
	154	0x330, 0x103, 0x165, 0x356, 0x1a9, 0x39a, 0x3fc, 0x1cf,
	155	0x062, 0x251, 0x237, 0x004, 0x2fb, 0x0c8, 0x0ae, 0x29d,
	156	0x363, 0x150, 0x136, 0x305, 0x1fa, 0x3c9, 0x3af, 0x19c,
	157	0x053, 0x260, 0x206, 0x035, 0x2ca, 0x0f9, 0x09f, 0x2ac,
	158	0x352, 0x161, 0x107, 0x334, 0x1cb, 0x3f8, 0x39e, 0x1ad,
	159	0x0c4, 0x2f7, 0x291, 0x0a2, 0x25d, 0x06e, 0x008, 0x23b,
	160	0x3c5, 0x1f6, 0x190, 0x3a3, 0x15c, 0x36f, 0x309, 0x13a,
	161	0x0f5, 0x2c6, 0x2a0, 0x093, 0x26c, 0x05f, 0x039, 0x20a,
	162	0x3f4, 0x1c7, 0x1a1, 0x392, 0x16d, 0x35e, 0x338, 0x10b,
	163	0x0a6, 0x295, 0x2f3, 0x0c0, 0x23f, 0x00c, 0x06a, 0x259,
	164	0x3a7, 0x194, 0x1f2, 0x3c1, 0x13e, 0x30d, 0x36b, 0x158,
	165	0x097, 0x2a4, 0x2c2, 0x0f1, 0x20e, 0x03d, 0x05b, 0x268,
	166	0x396, 0x1a5, 0x1c3, 0x3f0, 0x10f, 0x33c, 0x35a, 0x169,
	167	0x188, 0x3bb, 0x3dd, 0x1ee, 0x311, 0x122, 0x144, 0x377,
	168	0x289, 0x0ba, 0x0dc, 0x2ef, 0x010, 0x223, 0x245, 0x076,
	169	0x1b9, 0x38a, 0x3ec, 0x1df, 0x320, 0x113, 0x175, 0x346,
	170	0x2b8, 0x08b, 0x0ed, 0x2de, 0x021, 0x212, 0x274, 0x047,
	171	0x1ea, 0x3d9, 0x3bf, 0x18c, 0x373, 0x140, 0x126, 0x315,
	172	0x2eb, 0x0d8, 0x0be, 0x28d, 0x072, 0x241, 0x227, 0x014,
	173	0x1db, 0x3e8, 0x38e, 0x1bd, 0x342, 0x171, 0x117, 0x324,
	174	0x2da, 0x0e9, 0x08f, 0x2bc, 0x043, 0x270, 0x216, 0x025,
	175	0x14c, 0x37f, 0x319, 0x12a, 0x3d5, 0x1e6, 0x180, 0x3b3,
	176	0x24d, 0x07e, 0x018, 0x22b, 0x0d4, 0x2e7, 0x281, 0x0b2,
	177	0x17d, 0x34e, 0x328, 0x11b, 0x3e4, 0x1d7, 0x1b1, 0x382,
	178	0x27c, 0x04f, 0x029, 0x21a, 0x0e5, 0x2d6, 0x2b0, 0x083,
	179	0x12e, 0x31d, 0x37b, 0x148, 0x3b7, 0x184, 0x1e2, 0x3d1,
	180	0x22f, 0x01c, 0x07a, 0x249, 0x0b6, 0x285, 0x2e3, 0x0d0,
	181	0x11f, 0x32c, 0x34a, 0x179, 0x386, 0x1b5, 0x1d3, 0x3e0,
	182	0x21e, 0x02d, 0x04b, 0x278, 0x087, 0x2b4, 0x2d2, 0x0e1,
1da177e4 LT	183	};
1da177e4 LT	184
43c8f435 AC	185	#define CRC10_INITFCS 0x000 /* Initial FCS value */
	186	#define CRC10_GOODFCS 0x000 /* Good final FCS value */
	187	#define CRC10_FCS(fcs, c) ((((fcs) << 8) & 0x3ff) ^ crc10_table[((fcs) >> 2) & 0xff] ^ (c))
1da177e4	188
43c8f435	189	/**
1da177e4 LT	190	* fcs_compute10 - memcpy and calculate 10 bit CRC across buffer
	191	* @sp: pointer to buffer
	192	* @len: number of bytes
	193	* @fcs: starting FCS
	194	*
	195	* Perform a memcpy and calculate fcs using ppp 10bit CRC algorithm. Return
	196	* new 10 bit FCS.
	197	*/
43c8f435	198	static __u16 __inline__ fcs_compute10(unsigned char *sp, int len, __u16 fcs)
1da177e4	199	{
43c8f435	200	for (; len-- > 0; fcs = CRC10_FCS(fcs, *sp++));
1da177e4 LT	201	return fcs;
	202	}
	203
12e2e52c	204	static void safe_process_read_urb(struct urb *urb)
1da177e4	205	{
12e2e52c	206	struct usb_serial_port *port = urb->context;
1da177e4 LT	207	unsigned char *data = urb->transfer_buffer;
1da177e4 LT	208	unsigned char length = urb->actual_length;
6d1bf48e	209	int actual_length;
4a90f09b	210	struct tty_struct *tty;
6d1bf48e	211	__u16 fcs;
1da177e4	212
12e2e52c	213	if (!length)
1da177e4	214	return;
1da177e4	215
4a90f09b	216	tty = tty_port_tty_get(&port->port);
12e2e52c JH	217	if (!tty)
	218	return;
	219
6d1bf48e JH	220	if (!safe)
	221	goto out;
	222
	223	fcs = fcs_compute10(data, length, CRC10_INITFCS);
	224	if (fcs) {
	225	dev_err(&port->dev, "%s - bad CRC %x\n", __func__, fcs);
	226	goto err;
1da177e4 LT	227	}
1da177e4 LT	228
6d1bf48e JH	229	actual_length = data[length - 2] >> 2;
	230	if (actual_length > (length - 2)) {
	231	dev_err(&port->dev, "%s - inconsistent lengths %d:%d\n",
	232	__func__, actual_length, length);
	233	goto err;
	234	}
	235	dev_info(&urb->dev->dev, "%s - actual: %d\n", __func__, actual_length);
	236	length = actual_length;
	237	out:
	238	tty_insert_flip_string(tty, data, length);
	239	tty_flip_buffer_push(tty);
	240	err:
12e2e52c	241	tty_kref_put(tty);
1da177e4 LT	242	}
1da177e4 LT	243
241c80ea JH	244	static int safe_prepare_write_buffer(struct usb_serial_port *port,
241c80ea JH	245	void *dest, size_t size)
1da177e4	246	{
241c80ea JH	247	unsigned char *buf = dest;
	248	int count;
	249	int trailer_len;
	250	int pkt_len;
	251	__u16 fcs;
	252
	253	trailer_len = safe ? 2 : 0;
	254
	255	count = kfifo_out_locked(&port->write_fifo, buf, size - trailer_len,
	256	&port->lock);
	257	if (!safe)
	258	return count;
	259
	260	/* pad if necessary */
	261	if (padded) {
	262	pkt_len = size;
	263	memset(buf + count, '0', pkt_len - count - trailer_len);
1da177e4	264	} else {
241c80ea	265	pkt_len = count + trailer_len;
1da177e4	266	}
1da177e4	267
241c80ea JH	268	/* set count */
	269	buf[pkt_len - 2] = count << 2;
	270	buf[pkt_len - 1] = 0;
1da177e4	271
241c80ea JH	272	/* compute fcs and insert into trailer */
	273	fcs = fcs_compute10(buf, pkt_len, CRC10_INITFCS);
	274	buf[pkt_len - 2] \|= fcs >> 8;
	275	buf[pkt_len - 1] \|= fcs & 0xff;
1da177e4	276
241c80ea	277	return pkt_len;
1da177e4 LT	278	}
1da177e4 LT	279
43c8f435	280	static int safe_startup(struct usb_serial *serial)
1da177e4 LT	281	{
	282	switch (serial->interface->cur_altsetting->desc.bInterfaceProtocol) {
	283	case LINEO_SAFESERIAL_CRC:
	284	break;
	285	case LINEO_SAFESERIAL_CRC_PADDED:
	286	padded = 1;
	287	break;
	288	default:
	289	return -EINVAL;
	290	}
	291	return 0;
	292	}
	293
ea65370d	294	static struct usb_serial_driver safe_device = {
18fcac35 GKH	295	.driver = {
18fcac35 GKH	296	.owner = THIS_MODULE,
269bda1c	297	.name = "safe_serial",
18fcac35	298	},
1da177e4	299	.id_table = id_table,
1da177e4	300	.num_ports = 1,
12e2e52c	301	.process_read_urb = safe_process_read_urb,
241c80ea	302	.prepare_write_buffer = safe_prepare_write_buffer,
1da177e4 LT	303	.attach = safe_startup,
	304	};
	305
d860322f AS	306	static struct usb_serial_driver * const serial_drivers[] = {
	307	&safe_device, NULL
	308	};
	309
43c8f435	310	static int __init safe_init(void)
1da177e4	311	{
d860322f	312	int i;
1da177e4	313
43c8f435	314	/* if we have vendor / product parameters patch them into id list */
1da177e4	315	if (vendor \|\| product) {
93ba0f03	316	pr_info("vendor: %x product: %x\n", vendor, product);
1da177e4	317
52950ed4	318	for (i = 0; i < ARRAY_SIZE(id_table); i++) {
1da177e4 LT	319	if (!id_table[i].idVendor && !id_table[i].idProduct) {
	320	id_table[i].idVendor = vendor;
	321	id_table[i].idProduct = product;
	322	break;
	323	}
	324	}
	325	}
	326
68e24113	327	return usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, id_table);
1da177e4 LT	328	}
1da177e4 LT	329
43c8f435	330	static void __exit safe_exit(void)
1da177e4	331	{
68e24113	332	usb_serial_deregister_drivers(serial_drivers);
1da177e4 LT	333	}
1da177e4 LT	334
43c8f435 AC	335	module_init(safe_init);
43c8f435 AC	336	module_exit(safe_exit);