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

/*
 * Safe Encapsulated USB Serial Driver
 *
 *      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.
 *
 */


#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/module.h>
#include <linux/spinlock.h>
#include <asm/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 int debug;
static int safe = 1;
static int padded = CONFIG_USB_SERIAL_SAFE_PADDED;

#define DRIVER_VERSION "v0.0b"
#define DRIVER_AUTHOR "sl@lineo.com, tbr@lineo.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(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");

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 struct usb_driver safe_driver = {
	.name =		"safe_serial",
	.probe =	usb_serial_probe,
	.disconnect =	usb_serial_disconnect,
	.id_table =	id_table,
	.no_dynamic_id = 	1,
};

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_read_bulk_callback (struct urb *urb)
{
	struct usb_serial_port *port =  urb->context;
	unsigned char *data = urb->transfer_buffer;
	unsigned char length = urb->actual_length;
	int result;
	int status = urb->status;

	dbg ("%s", __func__);

	if (status) {
		dbg("%s - nonzero read bulk status received: %d",
		    __func__, status);
		return;
	}

	dbg ("safe_read_bulk_callback length: %d", port->read_urb->actual_length);
#ifdef ECHO_RCV
	{
		int i;
		unsigned char *cp = port->read_urb->transfer_buffer;
		for (i = 0; i < port->read_urb->actual_length; i++) {
			if ((i % 32) == 0) {
				printk ("\nru[%02x] ", i);
			}
			printk ("%02x ", *cp++);
		}
		printk ("\n");
	}
#endif
	if (safe) {
		__u16 fcs;
		if (!(fcs = fcs_compute10 (data, length, CRC10_INITFCS))) {
			int actual_length = data[length - 2] >> 2;
			if (actual_length <= (length - 2)) {
				info ("%s - actual: %d", __func__, actual_length);
				tty_insert_flip_string(port->port.tty, data, actual_length);
				tty_flip_buffer_push (port->port.tty);
			} else {
				err ("%s - inconsistent lengths %d:%d", __func__,
				     actual_length, length);
			}
		} else {
			err ("%s - bad CRC %x", __func__, fcs);
		}
	} else {
		tty_insert_flip_string(port->port.tty, data, length);
		tty_flip_buffer_push (port->port.tty);
	}

	/* Continue trying to always read  */
	usb_fill_bulk_urb (urb, port->serial->dev,
		       usb_rcvbulkpipe (port->serial->dev, port->bulk_in_endpointAddress),
		       urb->transfer_buffer, urb->transfer_buffer_length,
		       safe_read_bulk_callback, port);

	if ((result = usb_submit_urb (urb, GFP_ATOMIC))) {
		err ("%s - failed resubmitting read urb, error %d", __func__, result);
		/* FIXME: Need a mechanism to retry later if this happens */
	}
}

static int safe_write(struct tty_struct *tty, struct usb_serial_port *port,
					const unsigned char *buf, int count)
{
	unsigned char *data;
	int result;
	int i;
	int packet_length;

	dbg ("safe_write port: %p %d urb: %p count: %d", port, port->number, port->write_urb,
	     count);

	if (!port->write_urb) {
		dbg ("%s - write urb NULL", __func__);
		return 0;
	}

	dbg ("safe_write write_urb: %d transfer_buffer_length",
	     port->write_urb->transfer_buffer_length);

	if (!port->write_urb->transfer_buffer_length) {
		dbg ("%s - write urb transfer_buffer_length zero", __func__);
		return 0;
	}
	if (count == 0) {
		dbg ("%s - write request of 0 bytes", __func__);
		return 0;
	}
	spin_lock_bh(&port->lock);
	if (port->write_urb_busy) {
		spin_unlock_bh(&port->lock);
		dbg("%s - already writing", __func__);
		return 0;
	}
	port->write_urb_busy = 1;
	spin_unlock_bh(&port->lock);

	packet_length = port->bulk_out_size;	// get max packetsize

	i = packet_length - (safe ? 2 : 0);	// get bytes to send
	count = (count > i) ? i : count;


	// get the data into the transfer buffer
	data = port->write_urb->transfer_buffer;
	memset (data, '0', packet_length);

	memcpy (data, buf, count);

	if (safe) {
		__u16 fcs;

		// pad if necessary
		if (!padded) {
			packet_length = count + 2;
		}
		// set count
		data[packet_length - 2] = count << 2;
		data[packet_length - 1] = 0;

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

		// set length to send
		port->write_urb->transfer_buffer_length = packet_length;
	} else {
		port->write_urb->transfer_buffer_length = count;
	}

	usb_serial_debug_data(debug, &port->dev, __func__, count, port->write_urb->transfer_buffer);
#ifdef ECHO_TX
	{
		int i;
		unsigned char *cp = port->write_urb->transfer_buffer;
		for (i = 0; i < port->write_urb->transfer_buffer_length; i++) {
			if ((i % 32) == 0) {
				printk ("\nsu[%02x] ", i);
			}
			printk ("%02x ", *cp++);
		}
		printk ("\n");
	}
#endif
	port->write_urb->dev = port->serial->dev;
	if ((result = usb_submit_urb (port->write_urb, GFP_KERNEL))) {
		port->write_urb_busy = 0;
		err ("%s - failed submitting write urb, error %d", __func__, result);
		return 0;
	}
	dbg ("%s urb: %p submitted", __func__, port->write_urb);

	return (count);
}

static int safe_write_room(struct tty_struct *tty)
{
	struct usb_serial_port *port = tty->driver_data;
	int room = 0;		/* Default: no room */
	unsigned long flags;

	dbg ("%s", __func__);

	spin_lock_irqsave(&port->lock, flags);
	if (port->write_urb_busy)
		room = port->bulk_out_size - (safe ? 2 : 0);
	spin_unlock_irqrestore(&port->lock, flags);

	if (room) {
		dbg ("safe_write_room returns %d", room);
	}

	return room;
}

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,
	.usb_driver =		&safe_driver,
	.num_ports =		1,
	.write =		safe_write,
	.write_room =		safe_write_room,
	.read_bulk_callback =	safe_read_bulk_callback,
	.attach =		safe_startup,
};

static int __init safe_init (void)
{
	int i, retval;

	info (DRIVER_VERSION " " DRIVER_AUTHOR);
	info (DRIVER_DESC);
	info ("vendor: %x product: %x safe: %d padded: %d\n", vendor, product, safe, padded);

	// if we have vendor / product parameters patch them into id list
	if (vendor || product) {
		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;
			}
		}
	}

	retval = usb_serial_register(&safe_device);
	if (retval)
		goto failed_usb_serial_register;
	retval = usb_register(&safe_driver);
	if (retval)
		goto failed_usb_register;

	return 0;
failed_usb_register:
	usb_serial_deregister(&safe_device);
failed_usb_serial_register:
	return retval;
}

static void __exit safe_exit (void)
{
	usb_deregister (&safe_driver);
	usb_serial_deregister (&safe_device);
}

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