[mirror_ubuntu-bionic-kernel.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/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>

static bool safe = true;
static bool padded = IS_ENABLED(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");

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 const 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 */
	{}			/* 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;
	__u16 fcs;

	if (!length)
		return;

	if (!safe)
		goto out;

	if (length < 2) {
		dev_err(&port->dev, "malformed packet\n");
		return;
	}

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

	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);
		return;
	}
	dev_info(&urb->dev->dev, "%s - actual: %d\n", __func__, actual_length);
	length = actual_length;
out:
	tty_insert_flip_string(&port->port, data, length);
	tty_flip_buffer_push(&port->port);
}

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)
{
	struct usb_interface_descriptor	*desc;

	if (serial->dev->descriptor.bDeviceClass != CDC_DEVICE_CLASS)
		return -ENODEV;

	desc = &serial->interface->cur_altsetting->desc;

	if (desc->bInterfaceClass != LINEO_INTERFACE_CLASS)
		return -ENODEV;
	if (desc->bInterfaceSubClass != LINEO_INTERFACE_SUBCLASS_SAFESERIAL)
		return -ENODEV;

	switch (desc->bInterfaceProtocol) {
	case LINEO_SAFESERIAL_CRC:
		break;
	case LINEO_SAFESERIAL_CRC_PADDED:
		padded = true;
		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
};

module_usb_serial_driver(serial_drivers, id_table);
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 LT	70	#include <linux/tty.h>
	71	#include <linux/tty_driver.h>
	72	#include <linux/tty_flip.h>
	73	#include <linux/module.h>
	74	#include <linux/spinlock.h>
43c8f435	75	#include <linux/uaccess.h>
1da177e4	76	#include <linux/usb.h>
a969888c	77	#include <linux/usb/serial.h>
1da177e4	78
ce9d8562 MO	79	static bool safe = true;
ce9d8562 MO	80	static bool padded = IS_ENABLED(CONFIG_USB_SERIAL_SAFE_PADDED);
1da177e4	81
241c80ea	82	#define DRIVER_AUTHOR "sl@lineo.com, tbr@lineo.com, Johan Hovold <jhovold@gmail.com>"
1da177e4 LT	83	#define DRIVER_DESC "USB Safe Encapsulated Serial"
1da177e4 LT	84
43c8f435 AC	85	MODULE_AUTHOR(DRIVER_AUTHOR);
43c8f435 AC	86	MODULE_DESCRIPTION(DRIVER_DESC);
1da177e4 LT	87	MODULE_LICENSE("GPL");
1da177e4 LT	88
1da177e4 LT	89	module_param(safe, bool, 0);
	90	MODULE_PARM_DESC(safe, "Turn Safe Encapsulation On/Off");
	91
	92	module_param(padded, bool, 0);
	93	MODULE_PARM_DESC(padded, "Pad to full wMaxPacketSize On/Off");
	94
	95	#define CDC_DEVICE_CLASS 0x02
	96
	97	#define CDC_INTERFACE_CLASS 0x02
	98	#define CDC_INTERFACE_SUBCLASS 0x06
	99
	100	#define LINEO_INTERFACE_CLASS 0xff
	101
	102	#define LINEO_INTERFACE_SUBCLASS_SAFENET 0x01
	103	#define LINEO_SAFENET_CRC 0x01
	104	#define LINEO_SAFENET_CRC_PADDED 0x02
	105
	106	#define LINEO_INTERFACE_SUBCLASS_SAFESERIAL 0x02
	107	#define LINEO_SAFESERIAL_CRC 0x01
	108	#define LINEO_SAFESERIAL_CRC_PADDED 0x02
	109
	110
43c8f435 AC	111	#define MY_USB_DEVICE(vend, prod, dc, ic, isc) \
	112	.match_flags = USB_DEVICE_ID_MATCH_DEVICE \| \
	113	USB_DEVICE_ID_MATCH_DEV_CLASS \| \
	114	USB_DEVICE_ID_MATCH_INT_CLASS \| \
	115	USB_DEVICE_ID_MATCH_INT_SUBCLASS, \
	116	.idVendor = (vend), \
	117	.idProduct = (prod),\
	118	.bDeviceClass = (dc),\
	119	.bInterfaceClass = (ic), \
	120	.bInterfaceSubClass = (isc),
1da177e4	121
5c6b98dd	122	static const struct usb_device_id id_table[] = {
43c8f435 AC	123	{MY_USB_DEVICE(0x49f, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Itsy */
	124	{MY_USB_DEVICE(0x3f0, 0x2101, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Calypso */
	125	{MY_USB_DEVICE(0x4dd, 0x8001, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Iris */
	126	{MY_USB_DEVICE(0x4dd, 0x8002, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Collie */
	127	{MY_USB_DEVICE(0x4dd, 0x8003, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Collie */
	128	{MY_USB_DEVICE(0x4dd, 0x8004, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Collie */
	129	{MY_USB_DEVICE(0x5f9, 0xffff, CDC_DEVICE_CLASS, LINEO_INTERFACE_CLASS, LINEO_INTERFACE_SUBCLASS_SAFESERIAL)}, /* Sharp tmp */
43c8f435	130	{} /* terminating entry */
1da177e4 LT	131	};
1da177e4 LT	132
43c8f435	133	MODULE_DEVICE_TABLE(usb, id_table);
1da177e4	134
4c4c9432	135	static const __u16 crc10_table[256] = {
43c8f435 AC	136	0x000, 0x233, 0x255, 0x066, 0x299, 0x0aa, 0x0cc, 0x2ff,
	137	0x301, 0x132, 0x154, 0x367, 0x198, 0x3ab, 0x3cd, 0x1fe,
	138	0x031, 0x202, 0x264, 0x057, 0x2a8, 0x09b, 0x0fd, 0x2ce,
	139	0x330, 0x103, 0x165, 0x356, 0x1a9, 0x39a, 0x3fc, 0x1cf,
	140	0x062, 0x251, 0x237, 0x004, 0x2fb, 0x0c8, 0x0ae, 0x29d,
	141	0x363, 0x150, 0x136, 0x305, 0x1fa, 0x3c9, 0x3af, 0x19c,
	142	0x053, 0x260, 0x206, 0x035, 0x2ca, 0x0f9, 0x09f, 0x2ac,
	143	0x352, 0x161, 0x107, 0x334, 0x1cb, 0x3f8, 0x39e, 0x1ad,
	144	0x0c4, 0x2f7, 0x291, 0x0a2, 0x25d, 0x06e, 0x008, 0x23b,
	145	0x3c5, 0x1f6, 0x190, 0x3a3, 0x15c, 0x36f, 0x309, 0x13a,
	146	0x0f5, 0x2c6, 0x2a0, 0x093, 0x26c, 0x05f, 0x039, 0x20a,
	147	0x3f4, 0x1c7, 0x1a1, 0x392, 0x16d, 0x35e, 0x338, 0x10b,
	148	0x0a6, 0x295, 0x2f3, 0x0c0, 0x23f, 0x00c, 0x06a, 0x259,
	149	0x3a7, 0x194, 0x1f2, 0x3c1, 0x13e, 0x30d, 0x36b, 0x158,
	150	0x097, 0x2a4, 0x2c2, 0x0f1, 0x20e, 0x03d, 0x05b, 0x268,
	151	0x396, 0x1a5, 0x1c3, 0x3f0, 0x10f, 0x33c, 0x35a, 0x169,
	152	0x188, 0x3bb, 0x3dd, 0x1ee, 0x311, 0x122, 0x144, 0x377,
	153	0x289, 0x0ba, 0x0dc, 0x2ef, 0x010, 0x223, 0x245, 0x076,
	154	0x1b9, 0x38a, 0x3ec, 0x1df, 0x320, 0x113, 0x175, 0x346,
	155	0x2b8, 0x08b, 0x0ed, 0x2de, 0x021, 0x212, 0x274, 0x047,
	156	0x1ea, 0x3d9, 0x3bf, 0x18c, 0x373, 0x140, 0x126, 0x315,
	157	0x2eb, 0x0d8, 0x0be, 0x28d, 0x072, 0x241, 0x227, 0x014,
	158	0x1db, 0x3e8, 0x38e, 0x1bd, 0x342, 0x171, 0x117, 0x324,
	159	0x2da, 0x0e9, 0x08f, 0x2bc, 0x043, 0x270, 0x216, 0x025,
	160	0x14c, 0x37f, 0x319, 0x12a, 0x3d5, 0x1e6, 0x180, 0x3b3,
	161	0x24d, 0x07e, 0x018, 0x22b, 0x0d4, 0x2e7, 0x281, 0x0b2,
	162	0x17d, 0x34e, 0x328, 0x11b, 0x3e4, 0x1d7, 0x1b1, 0x382,
	163	0x27c, 0x04f, 0x029, 0x21a, 0x0e5, 0x2d6, 0x2b0, 0x083,
	164	0x12e, 0x31d, 0x37b, 0x148, 0x3b7, 0x184, 0x1e2, 0x3d1,
	165	0x22f, 0x01c, 0x07a, 0x249, 0x0b6, 0x285, 0x2e3, 0x0d0,
	166	0x11f, 0x32c, 0x34a, 0x179, 0x386, 0x1b5, 0x1d3, 0x3e0,
	167	0x21e, 0x02d, 0x04b, 0x278, 0x087, 0x2b4, 0x2d2, 0x0e1,
1da177e4 LT	168	};
1da177e4 LT	169
43c8f435 AC	170	#define CRC10_INITFCS 0x000 /* Initial FCS value */
	171	#define CRC10_GOODFCS 0x000 /* Good final FCS value */
	172	#define CRC10_FCS(fcs, c) ((((fcs) << 8) & 0x3ff) ^ crc10_table[((fcs) >> 2) & 0xff] ^ (c))
1da177e4	173
43c8f435	174	/**
1da177e4 LT	175	* fcs_compute10 - memcpy and calculate 10 bit CRC across buffer
	176	* @sp: pointer to buffer
	177	* @len: number of bytes
	178	* @fcs: starting FCS
	179	*
	180	* Perform a memcpy and calculate fcs using ppp 10bit CRC algorithm. Return
	181	* new 10 bit FCS.
	182	*/
43c8f435	183	static __u16 __inline__ fcs_compute10(unsigned char *sp, int len, __u16 fcs)
1da177e4	184	{
43c8f435	185	for (; len-- > 0; fcs = CRC10_FCS(fcs, *sp++));
1da177e4 LT	186	return fcs;
	187	}
	188
12e2e52c	189	static void safe_process_read_urb(struct urb *urb)
1da177e4	190	{
12e2e52c	191	struct usb_serial_port *port = urb->context;
1da177e4 LT	192	unsigned char *data = urb->transfer_buffer;
1da177e4 LT	193	unsigned char length = urb->actual_length;
6d1bf48e	194	int actual_length;
6d1bf48e	195	__u16 fcs;
1da177e4	196
12e2e52c	197	if (!length)
1da177e4	198	return;
1da177e4	199
6d1bf48e JH	200	if (!safe)
	201	goto out;
	202
8c76d7cd JH	203	if (length < 2) {
	204	dev_err(&port->dev, "malformed packet\n");
	205	return;
	206	}
	207
6d1bf48e JH	208	fcs = fcs_compute10(data, length, CRC10_INITFCS);
	209	if (fcs) {
	210	dev_err(&port->dev, "%s - bad CRC %x\n", __func__, fcs);
2e124b4a	211	return;
1da177e4 LT	212	}
1da177e4 LT	213
6d1bf48e JH	214	actual_length = data[length - 2] >> 2;
	215	if (actual_length > (length - 2)) {
	216	dev_err(&port->dev, "%s - inconsistent lengths %d:%d\n",
	217	__func__, actual_length, length);
2e124b4a	218	return;
6d1bf48e JH	219	}
	220	dev_info(&urb->dev->dev, "%s - actual: %d\n", __func__, actual_length);
	221	length = actual_length;
	222	out:
05c7cd39	223	tty_insert_flip_string(&port->port, data, length);
2e124b4a	224	tty_flip_buffer_push(&port->port);
1da177e4 LT	225	}
1da177e4 LT	226
241c80ea JH	227	static int safe_prepare_write_buffer(struct usb_serial_port *port,
241c80ea JH	228	void *dest, size_t size)
1da177e4	229	{
241c80ea JH	230	unsigned char *buf = dest;
	231	int count;
	232	int trailer_len;
	233	int pkt_len;
	234	__u16 fcs;
	235
	236	trailer_len = safe ? 2 : 0;
	237
	238	count = kfifo_out_locked(&port->write_fifo, buf, size - trailer_len,
	239	&port->lock);
	240	if (!safe)
	241	return count;
	242
	243	/* pad if necessary */
	244	if (padded) {
	245	pkt_len = size;
	246	memset(buf + count, '0', pkt_len - count - trailer_len);
1da177e4	247	} else {
241c80ea	248	pkt_len = count + trailer_len;
1da177e4	249	}
1da177e4	250
241c80ea JH	251	/* set count */
	252	buf[pkt_len - 2] = count << 2;
	253	buf[pkt_len - 1] = 0;
1da177e4	254
241c80ea JH	255	/* compute fcs and insert into trailer */
	256	fcs = fcs_compute10(buf, pkt_len, CRC10_INITFCS);
	257	buf[pkt_len - 2] \|= fcs >> 8;
	258	buf[pkt_len - 1] \|= fcs & 0xff;
1da177e4	259
241c80ea	260	return pkt_len;
1da177e4 LT	261	}
1da177e4 LT	262
43c8f435	263	static int safe_startup(struct usb_serial *serial)
1da177e4	264	{
8b61d927 JH	265	struct usb_interface_descriptor *desc;
	266
	267	if (serial->dev->descriptor.bDeviceClass != CDC_DEVICE_CLASS)
	268	return -ENODEV;
	269
	270	desc = &serial->interface->cur_altsetting->desc;
	271
	272	if (desc->bInterfaceClass != LINEO_INTERFACE_CLASS)
	273	return -ENODEV;
	274	if (desc->bInterfaceSubClass != LINEO_INTERFACE_SUBCLASS_SAFESERIAL)
	275	return -ENODEV;
	276
	277	switch (desc->bInterfaceProtocol) {
1da177e4 LT	278	case LINEO_SAFESERIAL_CRC:
	279	break;
	280	case LINEO_SAFESERIAL_CRC_PADDED:
ce9d8562	281	padded = true;
1da177e4 LT	282	break;
	283	default:
	284	return -EINVAL;
	285	}
	286	return 0;
	287	}
	288
ea65370d	289	static struct usb_serial_driver safe_device = {
18fcac35 GKH	290	.driver = {
18fcac35 GKH	291	.owner = THIS_MODULE,
269bda1c	292	.name = "safe_serial",
18fcac35	293	},
1da177e4	294	.id_table = id_table,
1da177e4	295	.num_ports = 1,
12e2e52c	296	.process_read_urb = safe_process_read_urb,
241c80ea	297	.prepare_write_buffer = safe_prepare_write_buffer,
1da177e4 LT	298	.attach = safe_startup,
	299	};
	300
d860322f AS	301	static struct usb_serial_driver * const serial_drivers[] = {
	302	&safe_device, NULL
	303	};
	304
8b61d927	305	module_usb_serial_driver(serial_drivers, id_table);