[mirror_ubuntu-bionic-kernel.git] / drivers / usb / serial / cyberjack.c

/*
 *  REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver
 *
 *  Copyright (C) 2001  REINER SCT
 *  Author: Matthias Bruestle
 *
 *  Contact: support@reiner-sct.com (see MAINTAINERS)
 *
 *  This program is largely derived from work by the linux-usb group
 *  and associated source files.  Please see the usb/serial files for
 *  individual credits and copyrights.
 *
 *  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.
 *
 *  Thanks to Greg Kroah-Hartman (greg@kroah.com) for his help and
 *  patience.
 *
 *  In case of problems, please write to the contact e-mail address
 *  mentioned above.
 *
 *  Please note that later models of the cyberjack reader family are
 *  supported by a libusb-based userspace device driver.
 *
 *  Homepage: http://www.reiner-sct.de/support/treiber_cyberjack.php#linux
 */


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

#define CYBERJACK_LOCAL_BUF_SIZE 32

static bool debug;

/*
 * Version Information
 */
#define DRIVER_VERSION "v1.01"
#define DRIVER_AUTHOR "Matthias Bruestle"
#define DRIVER_DESC "REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver"


#define CYBERJACK_VENDOR_ID	0x0C4B
#define CYBERJACK_PRODUCT_ID	0x0100

/* Function prototypes */
static int cyberjack_startup(struct usb_serial *serial);
static void cyberjack_disconnect(struct usb_serial *serial);
static void cyberjack_release(struct usb_serial *serial);
static int  cyberjack_open(struct tty_struct *tty,
	struct usb_serial_port *port);
static void cyberjack_close(struct usb_serial_port *port);
static int cyberjack_write(struct tty_struct *tty,
	struct usb_serial_port *port, const unsigned char *buf, int count);
static int cyberjack_write_room(struct tty_struct *tty);
static void cyberjack_read_int_callback(struct urb *urb);
static void cyberjack_read_bulk_callback(struct urb *urb);
static void cyberjack_write_bulk_callback(struct urb *urb);

static const struct usb_device_id id_table[] = {
	{ USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) },
	{ }			/* Terminating entry */
};

MODULE_DEVICE_TABLE(usb, id_table);

static struct usb_serial_driver cyberjack_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"cyberjack",
	},
	.description =		"Reiner SCT Cyberjack USB card reader",
	.id_table =		id_table,
	.num_ports =		1,
	.attach =		cyberjack_startup,
	.disconnect =		cyberjack_disconnect,
	.release =		cyberjack_release,
	.open =			cyberjack_open,
	.close =		cyberjack_close,
	.write =		cyberjack_write,
	.write_room =		cyberjack_write_room,
	.read_int_callback =	cyberjack_read_int_callback,
	.read_bulk_callback =	cyberjack_read_bulk_callback,
	.write_bulk_callback =	cyberjack_write_bulk_callback,
};

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

struct cyberjack_private {
	spinlock_t	lock;		/* Lock for SMP */
	short		rdtodo;		/* Bytes still to read */
	unsigned char	wrbuf[5*64];	/* Buffer for collecting data to write */
	short		wrfilled;	/* Overall data size we already got */
	short		wrsent;		/* Data already sent */
};

/* do some startup allocations not currently performed by usb_serial_probe() */
static int cyberjack_startup(struct usb_serial *serial)
{
	struct cyberjack_private *priv;
	int i;

	/* allocate the private data structure */
	priv = kmalloc(sizeof(struct cyberjack_private), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	/* set initial values */
	spin_lock_init(&priv->lock);
	priv->rdtodo = 0;
	priv->wrfilled = 0;
	priv->wrsent = 0;
	usb_set_serial_port_data(serial->port[0], priv);

	init_waitqueue_head(&serial->port[0]->write_wait);

	for (i = 0; i < serial->num_ports; ++i) {
		int result;
		result = usb_submit_urb(serial->port[i]->interrupt_in_urb,
					GFP_KERNEL);
		if (result)
			dev_err(&serial->dev->dev,
				"usb_submit_urb(read int) failed\n");
		dbg("%s - usb_submit_urb(int urb)", __func__);
	}

	return 0;
}

static void cyberjack_disconnect(struct usb_serial *serial)
{
	int i;

	for (i = 0; i < serial->num_ports; ++i)
		usb_kill_urb(serial->port[i]->interrupt_in_urb);
}

static void cyberjack_release(struct usb_serial *serial)
{
	int i;

	for (i = 0; i < serial->num_ports; ++i) {
		/* My special items, the standard routines free my urbs */
		kfree(usb_get_serial_port_data(serial->port[i]));
	}
}

static int  cyberjack_open(struct tty_struct *tty,
					struct usb_serial_port *port)
{
	struct cyberjack_private *priv;
	unsigned long flags;
	int result = 0;

	dbg("%s - usb_clear_halt", __func__);
	usb_clear_halt(port->serial->dev, port->write_urb->pipe);

	priv = usb_get_serial_port_data(port);
	spin_lock_irqsave(&priv->lock, flags);
	priv->rdtodo = 0;
	priv->wrfilled = 0;
	priv->wrsent = 0;
	spin_unlock_irqrestore(&priv->lock, flags);

	return result;
}

static void cyberjack_close(struct usb_serial_port *port)
{
	if (port->serial->dev) {
		/* shutdown any bulk reads that might be going on */
		usb_kill_urb(port->write_urb);
		usb_kill_urb(port->read_urb);
	}
}

static int cyberjack_write(struct tty_struct *tty,
	struct usb_serial_port *port, const unsigned char *buf, int count)
{
	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	int result;
	int wrexpected;

	if (count == 0) {
		dbg("%s - write request of 0 bytes", __func__);
		return 0;
	}

	if (!test_and_clear_bit(0, &port->write_urbs_free)) {
		dbg("%s - already writing", __func__);
		return 0;
	}

	spin_lock_irqsave(&priv->lock, flags);

	if (count+priv->wrfilled > sizeof(priv->wrbuf)) {
		/* To much data for buffer. Reset buffer. */
		priv->wrfilled = 0;
		spin_unlock_irqrestore(&priv->lock, flags);
		set_bit(0, &port->write_urbs_free);
		return 0;
	}

	/* Copy data */
	memcpy(priv->wrbuf + priv->wrfilled, buf, count);

	usb_serial_debug_data(debug, &port->dev, __func__, count,
		priv->wrbuf + priv->wrfilled);
	priv->wrfilled += count;

	if (priv->wrfilled >= 3) {
		wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
		dbg("%s - expected data: %d", __func__, wrexpected);
	} else
		wrexpected = sizeof(priv->wrbuf);

	if (priv->wrfilled >= wrexpected) {
		/* We have enough data to begin transmission */
		int length;

		dbg("%s - transmitting data (frame 1)", __func__);
		length = (wrexpected > port->bulk_out_size) ?
					port->bulk_out_size : wrexpected;

		memcpy(port->write_urb->transfer_buffer, priv->wrbuf, length);
		priv->wrsent = length;

		/* set up our urb */
		port->write_urb->transfer_buffer_length = length;

		/* send the data out the bulk port */
		result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
		if (result) {
			dev_err(&port->dev,
				"%s - failed submitting write urb, error %d",
				__func__, result);
			/* Throw away data. No better idea what to do with it. */
			priv->wrfilled = 0;
			priv->wrsent = 0;
			spin_unlock_irqrestore(&priv->lock, flags);
			set_bit(0, &port->write_urbs_free);
			return 0;
		}

		dbg("%s - priv->wrsent=%d", __func__, priv->wrsent);
		dbg("%s - priv->wrfilled=%d", __func__, priv->wrfilled);

		if (priv->wrsent >= priv->wrfilled) {
			dbg("%s - buffer cleaned", __func__);
			memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
			priv->wrfilled = 0;
			priv->wrsent = 0;
		}
	}

	spin_unlock_irqrestore(&priv->lock, flags);

	return count;
}

static int cyberjack_write_room(struct tty_struct *tty)
{
	/* FIXME: .... */
	return CYBERJACK_LOCAL_BUF_SIZE;
}

static void cyberjack_read_int_callback(struct urb *urb)
{
	struct usb_serial_port *port = urb->context;
	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	unsigned char *data = urb->transfer_buffer;
	int status = urb->status;
	int result;

	/* the urb might have been killed. */
	if (status)
		return;

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

	/* React only to interrupts signaling a bulk_in transfer */
	if (urb->actual_length == 4 && data[0] == 0x01) {
		short old_rdtodo;

		/* This is a announcement of coming bulk_ins. */
		unsigned short size = ((unsigned short)data[3]<<8)+data[2]+3;

		spin_lock(&priv->lock);

		old_rdtodo = priv->rdtodo;

		if (old_rdtodo + size < old_rdtodo) {
			dbg("To many bulk_in urbs to do.");
			spin_unlock(&priv->lock);
			goto resubmit;
		}

		/* "+=" is probably more fault tollerant than "=" */
		priv->rdtodo += size;

		dbg("%s - rdtodo: %d", __func__, priv->rdtodo);

		spin_unlock(&priv->lock);

		if (!old_rdtodo) {
			result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
			if (result)
				dev_err(&port->dev, "%s - failed resubmitting "
					"read urb, error %d\n",
					__func__, result);
			dbg("%s - usb_submit_urb(read urb)", __func__);
		}
	}

resubmit:
	result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
	if (result)
		dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
	dbg("%s - usb_submit_urb(int urb)", __func__);
}

static void cyberjack_read_bulk_callback(struct urb *urb)
{
	struct usb_serial_port *port = urb->context;
	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	struct tty_struct *tty;
	unsigned char *data = urb->transfer_buffer;
	short todo;
	int result;
	int status = urb->status;

	usb_serial_debug_data(debug, &port->dev, __func__,
						urb->actual_length, data);
	if (status) {
		dbg("%s - nonzero read bulk status received: %d",
		    __func__, status);
		return;
	}

	tty = tty_port_tty_get(&port->port);
	if (!tty) {
		dbg("%s - ignoring since device not open", __func__);
		return;
	}
	if (urb->actual_length) {
		tty_insert_flip_string(tty, data, urb->actual_length);
		tty_flip_buffer_push(tty);
	}
	tty_kref_put(tty);

	spin_lock(&priv->lock);

	/* Reduce urbs to do by one. */
	priv->rdtodo -= urb->actual_length;
	/* Just to be sure */
	if (priv->rdtodo < 0)
		priv->rdtodo = 0;
	todo = priv->rdtodo;

	spin_unlock(&priv->lock);

	dbg("%s - rdtodo: %d", __func__, todo);

	/* Continue to read if we have still urbs to do. */
	if (todo /* || (urb->actual_length==port->bulk_in_endpointAddress)*/) {
		result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
		if (result)
			dev_err(&port->dev, "%s - failed resubmitting read "
				"urb, error %d\n", __func__, result);
		dbg("%s - usb_submit_urb(read urb)", __func__);
	}
}

static void cyberjack_write_bulk_callback(struct urb *urb)
{
	struct usb_serial_port *port = urb->context;
	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	int status = urb->status;

	set_bit(0, &port->write_urbs_free);
	if (status) {
		dbg("%s - nonzero write bulk status received: %d",
		    __func__, status);
		return;
	}

	spin_lock(&priv->lock);

	/* only do something if we have more data to send */
	if (priv->wrfilled) {
		int length, blksize, result;

		dbg("%s - transmitting data (frame n)", __func__);

		length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ?
			port->bulk_out_size : (priv->wrfilled - priv->wrsent);

		memcpy(port->write_urb->transfer_buffer,
					priv->wrbuf + priv->wrsent, length);
		priv->wrsent += length;

		/* set up our urb */
		port->write_urb->transfer_buffer_length = length;

		/* send the data out the bulk port */
		result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
		if (result) {
			dev_err(&port->dev,
				"%s - failed submitting write urb, error %d\n",
				__func__, result);
			/* Throw away data. No better idea what to do with it. */
			priv->wrfilled = 0;
			priv->wrsent = 0;
			goto exit;
		}

		dbg("%s - priv->wrsent=%d", __func__, priv->wrsent);
		dbg("%s - priv->wrfilled=%d", __func__, priv->wrfilled);

		blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;

		if (priv->wrsent >= priv->wrfilled ||
					priv->wrsent >= blksize) {
			dbg("%s - buffer cleaned", __func__);
			memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
			priv->wrfilled = 0;
			priv->wrsent = 0;
		}
	}

exit:
	spin_unlock(&priv->lock);
	usb_serial_port_softint(port);
}

module_usb_serial_driver(serial_drivers, id_table);

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

module_param(debug, bool, S_IRUGO | S_IWUSR);
MODULE_PARM_DESC(debug, "Debug enabled or not");
Commit	Line	Data
1da177e4 LT	1	/*
	2	* REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver
	3	*
	4	* Copyright (C) 2001 REINER SCT
	5	* Author: Matthias Bruestle
	6	*
	7	* Contact: support@reiner-sct.com (see MAINTAINERS)
	8	*
	9	* This program is largely derived from work by the linux-usb group
	10	* and associated source files. Please see the usb/serial files for
	11	* individual credits and copyrights.
	12	*
	13	* This program is free software; you can redistribute it and/or modify
	14	* it under the terms of the GNU General Public License as published by
	15	* the Free Software Foundation; either version 2 of the License, or
	16	* (at your option) any later version.
	17	*
	18	* Thanks to Greg Kroah-Hartman (greg@kroah.com) for his help and
	19	* patience.
	20	*
	21	* In case of problems, please write to the contact e-mail address
	22	* mentioned above.
	23	*
	24	* Please note that later models of the cyberjack reader family are
	25	* supported by a libusb-based userspace device driver.
	26	*
	27	* Homepage: http://www.reiner-sct.de/support/treiber_cyberjack.php#linux
	28	*/
	29
	30
1da177e4 LT	31	#include <linux/kernel.h>
	32	#include <linux/errno.h>
	33	#include <linux/init.h>
	34	#include <linux/slab.h>
	35	#include <linux/tty.h>
	36	#include <linux/tty_driver.h>
	37	#include <linux/tty_flip.h>
	38	#include <linux/module.h>
	39	#include <linux/spinlock.h>
b9c52f15	40	#include <linux/uaccess.h>
1da177e4	41	#include <linux/usb.h>
a969888c	42	#include <linux/usb/serial.h>
1da177e4 LT	43
	44	#define CYBERJACK_LOCAL_BUF_SIZE 32
	45
90ab5ee9	46	static bool debug;
1da177e4 LT	47
	48	/*
	49	* Version Information
	50	*/
	51	#define DRIVER_VERSION "v1.01"
	52	#define DRIVER_AUTHOR "Matthias Bruestle"
	53	#define DRIVER_DESC "REINER SCT cyberJack pinpad/e-com USB Chipcard Reader Driver"
	54
	55
	56	#define CYBERJACK_VENDOR_ID 0x0C4B
	57	#define CYBERJACK_PRODUCT_ID 0x0100
	58
	59	/* Function prototypes */
95da310e	60	static int cyberjack_startup(struct usb_serial *serial);
f9c99bb8 AS	61	static void cyberjack_disconnect(struct usb_serial *serial);
f9c99bb8 AS	62	static void cyberjack_release(struct usb_serial *serial);
95da310e	63	static int cyberjack_open(struct tty_struct *tty,
a509a7e4	64	struct usb_serial_port *port);
335f8514	65	static void cyberjack_close(struct usb_serial_port *port);
95da310e AC	66	static int cyberjack_write(struct tty_struct *tty,
95da310e AC	67	struct usb_serial_port port, const unsigned char buf, int count);
b9c52f15	68	static int cyberjack_write_room(struct tty_struct *tty);
95da310e AC	69	static void cyberjack_read_int_callback(struct urb *urb);
	70	static void cyberjack_read_bulk_callback(struct urb *urb);
	71	static void cyberjack_write_bulk_callback(struct urb *urb);
1da177e4	72
7d40d7e8	73	static const struct usb_device_id id_table[] = {
1da177e4 LT	74	{ USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) },
	75	{ } /* Terminating entry */
	76	};
	77
b9c52f15	78	MODULE_DEVICE_TABLE(usb, id_table);
1da177e4	79
ea65370d	80	static struct usb_serial_driver cyberjack_device = {
18fcac35 GKH	81	.driver = {
18fcac35 GKH	82	.owner = THIS_MODULE,
269bda1c	83	.name = "cyberjack",
18fcac35	84	},
269bda1c	85	.description = "Reiner SCT Cyberjack USB card reader",
1da177e4	86	.id_table = id_table,
1da177e4 LT	87	.num_ports = 1,
1da177e4 LT	88	.attach = cyberjack_startup,
f9c99bb8 AS	89	.disconnect = cyberjack_disconnect,
f9c99bb8 AS	90	.release = cyberjack_release,
1da177e4 LT	91	.open = cyberjack_open,
	92	.close = cyberjack_close,
	93	.write = cyberjack_write,
d9b1b787	94	.write_room = cyberjack_write_room,
1da177e4 LT	95	.read_int_callback = cyberjack_read_int_callback,
	96	.read_bulk_callback = cyberjack_read_bulk_callback,
	97	.write_bulk_callback = cyberjack_write_bulk_callback,
	98	};
	99
08a4f6bc AS	100	static struct usb_serial_driver * const serial_drivers[] = {
	101	&cyberjack_device, NULL
	102	};
	103
1da177e4 LT	104	struct cyberjack_private {
	105	spinlock_t lock; /* Lock for SMP */
	106	short rdtodo; /* Bytes still to read */
	107	unsigned char wrbuf[564]; / Buffer for collecting data to write */
	108	short wrfilled; /* Overall data size we already got */
	109	short wrsent; /* Data already sent */
	110	};
	111
	112	/* do some startup allocations not currently performed by usb_serial_probe() */
95da310e	113	static int cyberjack_startup(struct usb_serial *serial)
1da177e4 LT	114	{
	115	struct cyberjack_private *priv;
	116	int i;
	117
1da177e4 LT	118	/* allocate the private data structure */
	119	priv = kmalloc(sizeof(struct cyberjack_private), GFP_KERNEL);
	120	if (!priv)
	121	return -ENOMEM;
	122
	123	/* set initial values */
	124	spin_lock_init(&priv->lock);
	125	priv->rdtodo = 0;
	126	priv->wrfilled = 0;
	127	priv->wrsent = 0;
	128	usb_set_serial_port_data(serial->port[0], priv);
	129
	130	init_waitqueue_head(&serial->port[0]->write_wait);
	131
	132	for (i = 0; i < serial->num_ports; ++i) {
	133	int result;
b9c52f15	134	result = usb_submit_urb(serial->port[i]->interrupt_in_urb,
1da177e4 LT	135	GFP_KERNEL);
1da177e4 LT	136	if (result)
194343d9 GKH	137	dev_err(&serial->dev->dev,
194343d9 GKH	138	"usb_submit_urb(read int) failed\n");
441b62c1	139	dbg("%s - usb_submit_urb(int urb)", __func__);
1da177e4 LT	140	}
1da177e4 LT	141
b9c52f15	142	return 0;
1da177e4 LT	143	}
1da177e4 LT	144
f9c99bb8	145	static void cyberjack_disconnect(struct usb_serial *serial)
1da177e4 LT	146	{
1da177e4 LT	147	int i;
b9c52f15	148
f9c99bb8	149	for (i = 0; i < serial->num_ports; ++i)
1da177e4	150	usb_kill_urb(serial->port[i]->interrupt_in_urb);
f9c99bb8 AS	151	}
	152
	153	static void cyberjack_release(struct usb_serial *serial)
	154	{
	155	int i;
	156
f9c99bb8	157	for (i = 0; i < serial->num_ports; ++i) {
1da177e4 LT	158	/* My special items, the standard routines free my urbs */
1da177e4 LT	159	kfree(usb_get_serial_port_data(serial->port[i]));
1da177e4 LT	160	}
1da177e4 LT	161	}
b9c52f15	162
95da310e	163	static int cyberjack_open(struct tty_struct *tty,
a509a7e4	164	struct usb_serial_port *port)
1da177e4 LT	165	{
	166	struct cyberjack_private *priv;
	167	unsigned long flags;
	168	int result = 0;
	169
b9c52f15	170	dbg("%s - usb_clear_halt", __func__);
1da177e4 LT	171	usb_clear_halt(port->serial->dev, port->write_urb->pipe);
1da177e4 LT	172
1da177e4 LT	173	priv = usb_get_serial_port_data(port);
	174	spin_lock_irqsave(&priv->lock, flags);
	175	priv->rdtodo = 0;
	176	priv->wrfilled = 0;
	177	priv->wrsent = 0;
	178	spin_unlock_irqrestore(&priv->lock, flags);
	179
	180	return result;
	181	}
	182
335f8514	183	static void cyberjack_close(struct usb_serial_port *port)
1da177e4	184	{
1da177e4 LT	185	if (port->serial->dev) {
	186	/* shutdown any bulk reads that might be going on */
	187	usb_kill_urb(port->write_urb);
	188	usb_kill_urb(port->read_urb);
	189	}
	190	}
	191
95da310e AC	192	static int cyberjack_write(struct tty_struct *tty,
95da310e AC	193	struct usb_serial_port port, const unsigned char buf, int count)
1da177e4	194	{
1da177e4 LT	195	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	196	unsigned long flags;
	197	int result;
	198	int wrexpected;
	199
1da177e4	200	if (count == 0) {
441b62c1	201	dbg("%s - write request of 0 bytes", __func__);
a5b6f60c	202	return 0;
1da177e4 LT	203	}
1da177e4 LT	204
c1cac10c	205	if (!test_and_clear_bit(0, &port->write_urbs_free)) {
441b62c1	206	dbg("%s - already writing", __func__);
507ca9bc	207	return 0;
1da177e4 LT	208	}
	209
	210	spin_lock_irqsave(&priv->lock, flags);
	211
b9c52f15	212	if (count+priv->wrfilled > sizeof(priv->wrbuf)) {
1da177e4	213	/* To much data for buffer. Reset buffer. */
a5b6f60c	214	priv->wrfilled = 0;
a5b6f60c	215	spin_unlock_irqrestore(&priv->lock, flags);
c1cac10c	216	set_bit(0, &port->write_urbs_free);
a5b6f60c	217	return 0;
1da177e4 LT	218	}
	219
	220	/* Copy data */
b9c52f15	221	memcpy(priv->wrbuf + priv->wrfilled, buf, count);
1da177e4	222
441b62c1	223	usb_serial_debug_data(debug, &port->dev, __func__, count,
b9c52f15	224	priv->wrbuf + priv->wrfilled);
1da177e4 LT	225	priv->wrfilled += count;
1da177e4 LT	226
b9c52f15	227	if (priv->wrfilled >= 3) {
1da177e4	228	wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
441b62c1	229	dbg("%s - expected data: %d", __func__, wrexpected);
b9c52f15	230	} else
1da177e4	231	wrexpected = sizeof(priv->wrbuf);
1da177e4	232
b9c52f15	233	if (priv->wrfilled >= wrexpected) {
1da177e4 LT	234	/* We have enough data to begin transmission */
	235	int length;
	236
441b62c1	237	dbg("%s - transmitting data (frame 1)", __func__);
b9c52f15 AC	238	length = (wrexpected > port->bulk_out_size) ?
b9c52f15 AC	239	port->bulk_out_size : wrexpected;
1da177e4	240
b9c52f15 AC	241	memcpy(port->write_urb->transfer_buffer, priv->wrbuf, length);
b9c52f15 AC	242	priv->wrsent = length;
1da177e4 LT	243
1da177e4 LT	244	/* set up our urb */
fd11961a	245	port->write_urb->transfer_buffer_length = length;
1da177e4 LT	246
	247	/* send the data out the bulk port */
	248	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
	249	if (result) {
194343d9 GKH	250	dev_err(&port->dev,
	251	"%s - failed submitting write urb, error %d",
	252	__func__, result);
1da177e4	253	/* Throw away data. No better idea what to do with it. */
a5b6f60c AC	254	priv->wrfilled = 0;
a5b6f60c AC	255	priv->wrsent = 0;
1da177e4	256	spin_unlock_irqrestore(&priv->lock, flags);
c1cac10c	257	set_bit(0, &port->write_urbs_free);
1da177e4 LT	258	return 0;
	259	}
	260
b9c52f15 AC	261	dbg("%s - priv->wrsent=%d", __func__, priv->wrsent);
b9c52f15 AC	262	dbg("%s - priv->wrfilled=%d", __func__, priv->wrfilled);
1da177e4	263
b9c52f15	264	if (priv->wrsent >= priv->wrfilled) {
441b62c1	265	dbg("%s - buffer cleaned", __func__);
b9c52f15	266	memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
a5b6f60c AC	267	priv->wrfilled = 0;
a5b6f60c AC	268	priv->wrsent = 0;
1da177e4 LT	269	}
	270	}
	271
	272	spin_unlock_irqrestore(&priv->lock, flags);
	273
b9c52f15 AC	274	return count;
b9c52f15 AC	275	}
1da177e4	276
95da310e	277	static int cyberjack_write_room(struct tty_struct *tty)
1da177e4	278	{
a5b6f60c	279	/* FIXME: .... */
1da177e4 LT	280	return CYBERJACK_LOCAL_BUF_SIZE;
	281	}
	282
95da310e	283	static void cyberjack_read_int_callback(struct urb *urb)
1da177e4	284	{
cdc97792	285	struct usb_serial_port *port = urb->context;
1da177e4 LT	286	struct cyberjack_private *priv = usb_get_serial_port_data(port);
1da177e4 LT	287	unsigned char *data = urb->transfer_buffer;
7dcc85cd	288	int status = urb->status;
1da177e4 LT	289	int result;
1da177e4 LT	290
1da177e4	291	/* the urb might have been killed. */
7dcc85cd	292	if (status)
1da177e4 LT	293	return;
1da177e4 LT	294
b9c52f15 AC	295	usb_serial_debug_data(debug, &port->dev, __func__,
b9c52f15 AC	296	urb->actual_length, data);
1da177e4 LT	297
1da177e4 LT	298	/* React only to interrupts signaling a bulk_in transfer */
b9c52f15	299	if (urb->actual_length == 4 && data[0] == 0x01) {
1da177e4	300	short old_rdtodo;
1da177e4 LT	301
	302	/* This is a announcement of coming bulk_ins. */
	303	unsigned short size = ((unsigned short)data[3]<<8)+data[2]+3;
	304
	305	spin_lock(&priv->lock);
	306
	307	old_rdtodo = priv->rdtodo;
	308
b9c52f15 AC	309	if (old_rdtodo + size < old_rdtodo) {
b9c52f15 AC	310	dbg("To many bulk_in urbs to do.");
1da177e4 LT	311	spin_unlock(&priv->lock);
	312	goto resubmit;
	313	}
	314
	315	/* "+=" is probably more fault tollerant than "=" */
	316	priv->rdtodo += size;
	317
441b62c1	318	dbg("%s - rdtodo: %d", __func__, priv->rdtodo);
1da177e4 LT	319
	320	spin_unlock(&priv->lock);
	321
b9c52f15	322	if (!old_rdtodo) {
1da177e4	323	result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
b9c52f15	324	if (result)
194343d9 GKH	325	dev_err(&port->dev, "%s - failed resubmitting "
	326	"read urb, error %d\n",
	327	__func__, result);
441b62c1	328	dbg("%s - usb_submit_urb(read urb)", __func__);
1da177e4 LT	329	}
	330	}
	331
	332	resubmit:
1da177e4 LT	333	result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
1da177e4 LT	334	if (result)
194343d9	335	dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
441b62c1	336	dbg("%s - usb_submit_urb(int urb)", __func__);
1da177e4 LT	337	}
1da177e4 LT	338
95da310e	339	static void cyberjack_read_bulk_callback(struct urb *urb)
1da177e4	340	{
cdc97792	341	struct usb_serial_port *port = urb->context;
1da177e4 LT	342	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	343	struct tty_struct *tty;
	344	unsigned char *data = urb->transfer_buffer;
	345	short todo;
1da177e4	346	int result;
7dcc85cd	347	int status = urb->status;
1da177e4	348
b9c52f15 AC	349	usb_serial_debug_data(debug, &port->dev, __func__,
b9c52f15 AC	350	urb->actual_length, data);
7dcc85cd GKH	351	if (status) {
7dcc85cd GKH	352	dbg("%s - nonzero read bulk status received: %d",
441b62c1	353	__func__, status);
1da177e4 LT	354	return;
	355	}
	356
4a90f09b	357	tty = tty_port_tty_get(&port->port);
1da177e4	358	if (!tty) {
759f3634	359	dbg("%s - ignoring since device not open", __func__);
1da177e4 LT	360	return;
	361	}
	362	if (urb->actual_length) {
33f0f88f	363	tty_insert_flip_string(tty, data, urb->actual_length);
b9c52f15	364	tty_flip_buffer_push(tty);
1da177e4	365	}
4a90f09b	366	tty_kref_put(tty);
1da177e4 LT	367
	368	spin_lock(&priv->lock);
	369
	370	/* Reduce urbs to do by one. */
b9c52f15	371	priv->rdtodo -= urb->actual_length;
1da177e4	372	/* Just to be sure */
b9c52f15 AC	373	if (priv->rdtodo < 0)
b9c52f15 AC	374	priv->rdtodo = 0;
1da177e4 LT	375	todo = priv->rdtodo;
	376
	377	spin_unlock(&priv->lock);
	378
441b62c1	379	dbg("%s - rdtodo: %d", __func__, todo);
1da177e4 LT	380
1da177e4 LT	381	/* Continue to read if we have still urbs to do. */
b9c52f15	382	if (todo /* \|\| (urb->actual_length==port->bulk_in_endpointAddress)*/) {
1da177e4 LT	383	result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1da177e4 LT	384	if (result)
194343d9 GKH	385	dev_err(&port->dev, "%s - failed resubmitting read "
194343d9 GKH	386	"urb, error %d\n", __func__, result);
441b62c1	387	dbg("%s - usb_submit_urb(read urb)", __func__);
1da177e4 LT	388	}
	389	}
	390
95da310e	391	static void cyberjack_write_bulk_callback(struct urb *urb)
1da177e4	392	{
cdc97792	393	struct usb_serial_port *port = urb->context;
1da177e4	394	struct cyberjack_private *priv = usb_get_serial_port_data(port);
7dcc85cd	395	int status = urb->status;
1da177e4	396
c1cac10c	397	set_bit(0, &port->write_urbs_free);
7dcc85cd GKH	398	if (status) {
7dcc85cd GKH	399	dbg("%s - nonzero write bulk status received: %d",
441b62c1	400	__func__, status);
1da177e4 LT	401	return;
	402	}
	403
	404	spin_lock(&priv->lock);
	405
	406	/* only do something if we have more data to send */
b9c52f15	407	if (priv->wrfilled) {
1da177e4 LT	408	int length, blksize, result;
1da177e4 LT	409
441b62c1	410	dbg("%s - transmitting data (frame n)", __func__);
1da177e4 LT	411
	412	length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ?
	413	port->bulk_out_size : (priv->wrfilled - priv->wrsent);
	414
b9c52f15 AC	415	memcpy(port->write_urb->transfer_buffer,
	416	priv->wrbuf + priv->wrsent, length);
	417	priv->wrsent += length;
1da177e4 LT	418
1da177e4 LT	419	/* set up our urb */
fd11961a	420	port->write_urb->transfer_buffer_length = length;
1da177e4 LT	421
	422	/* send the data out the bulk port */
	423	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
	424	if (result) {
194343d9 GKH	425	dev_err(&port->dev,
	426	"%s - failed submitting write urb, error %d\n",
	427	__func__, result);
1da177e4	428	/* Throw away data. No better idea what to do with it. */
a5b6f60c AC	429	priv->wrfilled = 0;
a5b6f60c AC	430	priv->wrsent = 0;
1da177e4 LT	431	goto exit;
	432	}
	433
b9c52f15 AC	434	dbg("%s - priv->wrsent=%d", __func__, priv->wrsent);
b9c52f15 AC	435	dbg("%s - priv->wrfilled=%d", __func__, priv->wrfilled);
1da177e4 LT	436
	437	blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
	438
b9c52f15 AC	439	if (priv->wrsent >= priv->wrfilled \|\|
b9c52f15 AC	440	priv->wrsent >= blksize) {
441b62c1	441	dbg("%s - buffer cleaned", __func__);
b9c52f15	442	memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
a5b6f60c AC	443	priv->wrfilled = 0;
a5b6f60c AC	444	priv->wrsent = 0;
1da177e4 LT	445	}
	446	}
	447
	448	exit:
	449	spin_unlock(&priv->lock);
cf2c7481	450	usb_serial_port_softint(port);
1da177e4 LT	451	}
1da177e4 LT	452
68e24113	453	module_usb_serial_driver(serial_drivers, id_table);
1da177e4	454
b9c52f15 AC	455	MODULE_AUTHOR(DRIVER_AUTHOR);
	456	MODULE_DESCRIPTION(DRIVER_DESC);
	457	MODULE_VERSION(DRIVER_VERSION);
1da177e4 LT	458	MODULE_LICENSE("GPL");
	459
	460	module_param(debug, bool, S_IRUGO \| S_IWUSR);
	461	MODULE_PARM_DESC(debug, "Debug enabled or not");