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

#define CYBERJACK_LOCAL_BUF_SIZE 32

static int 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_shutdown (struct usb_serial *serial);
static int  cyberjack_open (struct usb_serial_port *port, struct file *filp);
static void cyberjack_close (struct usb_serial_port *port, struct file *filp);
static int cyberjack_write (struct usb_serial_port *port, const unsigned char *buf, int count);
static int cyberjack_write_room( struct usb_serial_port *port );
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 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_driver cyberjack_driver = {
	.name =		"cyberjack",
	.probe =	usb_serial_probe,
	.disconnect =	usb_serial_disconnect,
	.id_table =	id_table,
	.no_dynamic_id = 	1,
};

static struct usb_serial_driver cyberjack_device = {
	.driver = {
		.owner =	THIS_MODULE,
		.name =		"cyberjack",
	},
	.description =		"Reiner SCT Cyberjack USB card reader",
	.usb_driver = 		&cyberjack_driver,
	.id_table =		id_table,
	.num_ports =		1,
	.attach =		cyberjack_startup,
	.shutdown =		cyberjack_shutdown,
	.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,
};

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;

	dbg("%s", __func__);

	/* 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;
		serial->port[i]->interrupt_in_urb->dev = serial->dev;
		result = usb_submit_urb(serial->port[i]->interrupt_in_urb, 
					GFP_KERNEL);
		if (result)
			err(" usb_submit_urb(read int) failed");
		dbg("%s - usb_submit_urb(int urb)", __func__);
	}

	return( 0 );
}

static void cyberjack_shutdown (struct usb_serial *serial)
{
	int i;
	
	dbg("%s", __func__);

	for (i=0; i < serial->num_ports; ++i) {
		usb_kill_urb(serial->port[i]->interrupt_in_urb);
		/* My special items, the standard routines free my urbs */
		kfree(usb_get_serial_port_data(serial->port[i]));
		usb_set_serial_port_data(serial->port[i], NULL);
	}
}
	
static int  cyberjack_open (struct usb_serial_port *port, struct file *filp)
{
	struct cyberjack_private *priv;
	unsigned long flags;
	int result = 0;

	dbg("%s - port %d", __func__, port->number);

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

	/* force low_latency on so that our tty_push actually forces
	 * the data through, otherwise it is scheduled, and with high
	 * data rates (like with OHCI) data can get lost.
	 */
	port->tty->low_latency = 1;

	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, struct file *filp)
{
	dbg("%s - port %d", __func__, port->number);

	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 usb_serial_port *port, const unsigned char *buf, int count)
{
	struct usb_serial *serial = port->serial;
	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	unsigned long flags;
	int result;
	int wrexpected;

	dbg("%s - port %d", __func__, port->number);

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

	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);
		port->write_urb_busy = 0;
		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 */
		usb_fill_bulk_urb(port->write_urb, serial->dev, 
			      usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),
			      port->write_urb->transfer_buffer, length,
			      ((serial->type->write_bulk_callback) ? 
			       serial->type->write_bulk_callback : 
			       cyberjack_write_bulk_callback), 
			      port);

		/* send the data out the bulk port */
		result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
		if (result) {
			err("%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);
			port->write_urb_busy = 0;
			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 usb_serial_port *port )
{
	return CYBERJACK_LOCAL_BUF_SIZE;
}

static void cyberjack_read_int_callback( struct urb *urb )
{
	struct usb_serial_port *port = (struct usb_serial_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;

	dbg("%s - port %d", __func__, port->number);

	/* 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 ) {
			port->read_urb->dev = port->serial->dev;
			result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
			if( result )
				err("%s - failed resubmitting read urb, error %d", __func__, result);
			dbg("%s - usb_submit_urb(read urb)", __func__);
		}
	}

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

static void cyberjack_read_bulk_callback (struct urb *urb)
{
	struct usb_serial_port *port = (struct usb_serial_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;

	dbg("%s - port %d", __func__, port->number);

	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 = port->tty;
	if (!tty) {
		dbg("%s - ignoring since device not open\n", __func__);
		return;
	}
	if (urb->actual_length) {
		tty_buffer_request_room(tty, urb->actual_length);
		tty_insert_flip_string(tty, data, urb->actual_length);
	  	tty_flip_buffer_push(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)*/ ) {
		port->read_urb->dev = port->serial->dev;
		result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
		if (result)
			err("%s - failed resubmitting read urb, error %d", __func__, result);
		dbg("%s - usb_submit_urb(read urb)", __func__);
	}
}

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

	dbg("%s - port %d", __func__, port->number);

	port->write_urb_busy = 0;
	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 */
		usb_fill_bulk_urb(port->write_urb, port->serial->dev, 
			      usb_sndbulkpipe(port->serial->dev, port->bulk_out_endpointAddress),
			      port->write_urb->transfer_buffer, length,
			      ((port->serial->type->write_bulk_callback) ? 
			       port->serial->type->write_bulk_callback : 
			       cyberjack_write_bulk_callback), 
			      port);

		/* send the data out the bulk port */
		result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
		if (result) {
			err("%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;
			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);
}

static int __init cyberjack_init (void)
{
	int retval;
	retval  = usb_serial_register(&cyberjack_device);
	if (retval)
		goto failed_usb_serial_register;
	retval = usb_register(&cyberjack_driver);
	if (retval) 
		goto failed_usb_register;

	info(DRIVER_VERSION " " DRIVER_AUTHOR);
	info(DRIVER_DESC);

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

static void __exit cyberjack_exit (void)
{
	usb_deregister (&cyberjack_driver);
	usb_serial_deregister (&cyberjack_device);
}

module_init(cyberjack_init);
module_exit(cyberjack_exit);

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>
	40	#include <asm/uaccess.h>
	41	#include <linux/usb.h>
a969888c	42	#include <linux/usb/serial.h>
1da177e4 LT	43
	44	#define CYBERJACK_LOCAL_BUF_SIZE 32
	45
	46	static int debug;
	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 */
	60	static int cyberjack_startup (struct usb_serial *serial);
	61	static void cyberjack_shutdown (struct usb_serial *serial);
	62	static int cyberjack_open (struct usb_serial_port port, struct file filp);
	63	static void cyberjack_close (struct usb_serial_port port, struct file filp);
	64	static int cyberjack_write (struct usb_serial_port port, const unsigned char buf, int count);
	65	static int cyberjack_write_room( struct usb_serial_port *port );
7d12e780 DH	66	static void cyberjack_read_int_callback (struct urb *urb);
	67	static void cyberjack_read_bulk_callback (struct urb *urb);
	68	static void cyberjack_write_bulk_callback (struct urb *urb);
1da177e4 LT	69
	70	static struct usb_device_id id_table [] = {
	71	{ USB_DEVICE(CYBERJACK_VENDOR_ID, CYBERJACK_PRODUCT_ID) },
	72	{ } /* Terminating entry */
	73	};
	74
	75	MODULE_DEVICE_TABLE (usb, id_table);
	76
	77	static struct usb_driver cyberjack_driver = {
1da177e4 LT	78	.name = "cyberjack",
	79	.probe = usb_serial_probe,
	80	.disconnect = usb_serial_disconnect,
	81	.id_table = id_table,
ba9dc657	82	.no_dynamic_id = 1,
1da177e4 LT	83	};
1da177e4 LT	84
ea65370d	85	static struct usb_serial_driver cyberjack_device = {
18fcac35 GKH	86	.driver = {
18fcac35 GKH	87	.owner = THIS_MODULE,
269bda1c	88	.name = "cyberjack",
18fcac35	89	},
269bda1c	90	.description = "Reiner SCT Cyberjack USB card reader",
d9b1b787	91	.usb_driver = &cyberjack_driver,
1da177e4	92	.id_table = id_table,
1da177e4 LT	93	.num_ports = 1,
	94	.attach = cyberjack_startup,
	95	.shutdown = cyberjack_shutdown,
	96	.open = cyberjack_open,
	97	.close = cyberjack_close,
	98	.write = cyberjack_write,
d9b1b787	99	.write_room = cyberjack_write_room,
1da177e4 LT	100	.read_int_callback = cyberjack_read_int_callback,
	101	.read_bulk_callback = cyberjack_read_bulk_callback,
	102	.write_bulk_callback = cyberjack_write_bulk_callback,
	103	};
	104
	105	struct cyberjack_private {
	106	spinlock_t lock; /* Lock for SMP */
	107	short rdtodo; /* Bytes still to read */
	108	unsigned char wrbuf[564]; / Buffer for collecting data to write */
	109	short wrfilled; /* Overall data size we already got */
	110	short wrsent; /* Data already sent */
	111	};
	112
	113	/* do some startup allocations not currently performed by usb_serial_probe() */
	114	static int cyberjack_startup (struct usb_serial *serial)
	115	{
	116	struct cyberjack_private *priv;
	117	int i;
	118
441b62c1	119	dbg("%s", __func__);
1da177e4 LT	120
	121	/* allocate the private data structure */
	122	priv = kmalloc(sizeof(struct cyberjack_private), GFP_KERNEL);
	123	if (!priv)
	124	return -ENOMEM;
	125
	126	/* set initial values */
	127	spin_lock_init(&priv->lock);
	128	priv->rdtodo = 0;
	129	priv->wrfilled = 0;
	130	priv->wrsent = 0;
	131	usb_set_serial_port_data(serial->port[0], priv);
	132
	133	init_waitqueue_head(&serial->port[0]->write_wait);
	134
	135	for (i = 0; i < serial->num_ports; ++i) {
	136	int result;
	137	serial->port[i]->interrupt_in_urb->dev = serial->dev;
	138	result = usb_submit_urb(serial->port[i]->interrupt_in_urb,
	139	GFP_KERNEL);
	140	if (result)
	141	err(" usb_submit_urb(read int) failed");
441b62c1	142	dbg("%s - usb_submit_urb(int urb)", __func__);
1da177e4 LT	143	}
	144
	145	return( 0 );
	146	}
	147
	148	static void cyberjack_shutdown (struct usb_serial *serial)
	149	{
	150	int i;
	151
441b62c1	152	dbg("%s", __func__);
1da177e4 LT	153
	154	for (i=0; i < serial->num_ports; ++i) {
	155	usb_kill_urb(serial->port[i]->interrupt_in_urb);
	156	/* My special items, the standard routines free my urbs */
	157	kfree(usb_get_serial_port_data(serial->port[i]));
	158	usb_set_serial_port_data(serial->port[i], NULL);
	159	}
	160	}
	161
	162	static int cyberjack_open (struct usb_serial_port port, struct file filp)
	163	{
	164	struct cyberjack_private *priv;
	165	unsigned long flags;
	166	int result = 0;
	167
441b62c1	168	dbg("%s - port %d", __func__, port->number);
1da177e4	169
441b62c1	170	dbg("%s - usb_clear_halt", __func__ );
1da177e4 LT	171	usb_clear_halt(port->serial->dev, port->write_urb->pipe);
	172
	173	/* force low_latency on so that our tty_push actually forces
	174	* the data through, otherwise it is scheduled, and with high
	175	* data rates (like with OHCI) data can get lost.
	176	*/
	177	port->tty->low_latency = 1;
	178
	179	priv = usb_get_serial_port_data(port);
	180	spin_lock_irqsave(&priv->lock, flags);
	181	priv->rdtodo = 0;
	182	priv->wrfilled = 0;
	183	priv->wrsent = 0;
	184	spin_unlock_irqrestore(&priv->lock, flags);
	185
	186	return result;
	187	}
	188
	189	static void cyberjack_close (struct usb_serial_port port, struct file filp)
	190	{
441b62c1	191	dbg("%s - port %d", __func__, port->number);
1da177e4 LT	192
	193	if (port->serial->dev) {
	194	/* shutdown any bulk reads that might be going on */
	195	usb_kill_urb(port->write_urb);
	196	usb_kill_urb(port->read_urb);
	197	}
	198	}
	199
	200	static int cyberjack_write (struct usb_serial_port port, const unsigned char buf, int count)
	201	{
	202	struct usb_serial *serial = port->serial;
	203	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	204	unsigned long flags;
	205	int result;
	206	int wrexpected;
	207
441b62c1	208	dbg("%s - port %d", __func__, port->number);
1da177e4 LT	209
1da177e4 LT	210	if (count == 0) {
441b62c1	211	dbg("%s - write request of 0 bytes", __func__);
1da177e4 LT	212	return (0);
	213	}
	214
e81ee637	215	spin_lock_bh(&port->lock);
507ca9bc	216	if (port->write_urb_busy) {
e81ee637	217	spin_unlock_bh(&port->lock);
441b62c1	218	dbg("%s - already writing", __func__);
507ca9bc	219	return 0;
1da177e4	220	}
507ca9bc	221	port->write_urb_busy = 1;
e81ee637	222	spin_unlock_bh(&port->lock);
1da177e4 LT	223
	224	spin_lock_irqsave(&priv->lock, flags);
	225
	226	if( (count+priv->wrfilled)>sizeof(priv->wrbuf) ) {
	227	/* To much data for buffer. Reset buffer. */
	228	priv->wrfilled=0;
	229	spin_unlock_irqrestore(&priv->lock, flags);
507ca9bc	230	port->write_urb_busy = 0;
1da177e4 LT	231	return (0);
	232	}
	233
	234	/* Copy data */
	235	memcpy (priv->wrbuf+priv->wrfilled, buf, count);
	236
441b62c1	237	usb_serial_debug_data(debug, &port->dev, __func__, count,
1da177e4 LT	238	priv->wrbuf+priv->wrfilled);
	239	priv->wrfilled += count;
	240
	241	if( priv->wrfilled >= 3 ) {
	242	wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
441b62c1	243	dbg("%s - expected data: %d", __func__, wrexpected);
1da177e4 LT	244	} else {
	245	wrexpected = sizeof(priv->wrbuf);
	246	}
	247
	248	if( priv->wrfilled >= wrexpected ) {
	249	/* We have enough data to begin transmission */
	250	int length;
	251
441b62c1	252	dbg("%s - transmitting data (frame 1)", __func__);
1da177e4 LT	253	length = (wrexpected > port->bulk_out_size) ? port->bulk_out_size : wrexpected;
	254
	255	memcpy (port->write_urb->transfer_buffer, priv->wrbuf, length );
	256	priv->wrsent=length;
	257
	258	/* set up our urb */
	259	usb_fill_bulk_urb(port->write_urb, serial->dev,
	260	usb_sndbulkpipe(serial->dev, port->bulk_out_endpointAddress),
	261	port->write_urb->transfer_buffer, length,
	262	((serial->type->write_bulk_callback) ?
	263	serial->type->write_bulk_callback :
	264	cyberjack_write_bulk_callback),
	265	port);
	266
	267	/* send the data out the bulk port */
	268	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
	269	if (result) {
441b62c1	270	err("%s - failed submitting write urb, error %d", __func__, result);
1da177e4 LT	271	/* Throw away data. No better idea what to do with it. */
	272	priv->wrfilled=0;
	273	priv->wrsent=0;
	274	spin_unlock_irqrestore(&priv->lock, flags);
507ca9bc	275	port->write_urb_busy = 0;
1da177e4 LT	276	return 0;
	277	}
	278
441b62c1 HH	279	dbg("%s - priv->wrsent=%d", __func__,priv->wrsent);
441b62c1 HH	280	dbg("%s - priv->wrfilled=%d", __func__,priv->wrfilled);
1da177e4 LT	281
1da177e4 LT	282	if( priv->wrsent>=priv->wrfilled ) {
441b62c1	283	dbg("%s - buffer cleaned", __func__);
1da177e4 LT	284	memset( priv->wrbuf, 0, sizeof(priv->wrbuf) );
	285	priv->wrfilled=0;
	286	priv->wrsent=0;
	287	}
	288	}
	289
	290	spin_unlock_irqrestore(&priv->lock, flags);
	291
	292	return (count);
	293	}
	294
	295	static int cyberjack_write_room( struct usb_serial_port *port )
	296	{
	297	return CYBERJACK_LOCAL_BUF_SIZE;
	298	}
	299
7d12e780	300	static void cyberjack_read_int_callback( struct urb *urb )
1da177e4 LT	301	{
	302	struct usb_serial_port port = (struct usb_serial_port )urb->context;
	303	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	304	unsigned char *data = urb->transfer_buffer;
7dcc85cd	305	int status = urb->status;
1da177e4 LT	306	int result;
1da177e4 LT	307
441b62c1	308	dbg("%s - port %d", __func__, port->number);
1da177e4 LT	309
1da177e4 LT	310	/* the urb might have been killed. */
7dcc85cd	311	if (status)
1da177e4 LT	312	return;
1da177e4 LT	313
441b62c1	314	usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
1da177e4 LT	315
	316	/* React only to interrupts signaling a bulk_in transfer */
	317	if( (urb->actual_length==4) && (data[0]==0x01) ) {
	318	short old_rdtodo;
1da177e4 LT	319
	320	/* This is a announcement of coming bulk_ins. */
	321	unsigned short size = ((unsigned short)data[3]<<8)+data[2]+3;
	322
	323	spin_lock(&priv->lock);
	324
	325	old_rdtodo = priv->rdtodo;
	326
	327	if( (old_rdtodo+size)<(old_rdtodo) ) {
	328	dbg( "To many bulk_in urbs to do." );
	329	spin_unlock(&priv->lock);
	330	goto resubmit;
	331	}
	332
	333	/* "+=" is probably more fault tollerant than "=" */
	334	priv->rdtodo += size;
	335
441b62c1	336	dbg("%s - rdtodo: %d", __func__, priv->rdtodo);
1da177e4 LT	337
	338	spin_unlock(&priv->lock);
	339
	340	if( !old_rdtodo ) {
	341	port->read_urb->dev = port->serial->dev;
	342	result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
	343	if( result )
441b62c1 HH	344	err("%s - failed resubmitting read urb, error %d", __func__, result);
441b62c1 HH	345	dbg("%s - usb_submit_urb(read urb)", __func__);
1da177e4 LT	346	}
	347	}
	348
	349	resubmit:
	350	port->interrupt_in_urb->dev = port->serial->dev;
	351	result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
	352	if (result)
	353	err(" usb_submit_urb(read int) failed");
441b62c1	354	dbg("%s - usb_submit_urb(int urb)", __func__);
1da177e4 LT	355	}
1da177e4 LT	356
7d12e780	357	static void cyberjack_read_bulk_callback (struct urb *urb)
1da177e4 LT	358	{
	359	struct usb_serial_port port = (struct usb_serial_port )urb->context;
	360	struct cyberjack_private *priv = usb_get_serial_port_data(port);
	361	struct tty_struct *tty;
	362	unsigned char *data = urb->transfer_buffer;
	363	short todo;
1da177e4	364	int result;
7dcc85cd	365	int status = urb->status;
1da177e4	366
441b62c1	367	dbg("%s - port %d", __func__, port->number);
7dcc85cd	368
441b62c1	369	usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length, data);
7dcc85cd GKH	370	if (status) {
7dcc85cd GKH	371	dbg("%s - nonzero read bulk status received: %d",
441b62c1	372	__func__, status);
1da177e4 LT	373	return;
	374	}
	375
	376	tty = port->tty;
	377	if (!tty) {
441b62c1	378	dbg("%s - ignoring since device not open\n", __func__);
1da177e4 LT	379	return;
	380	}
	381	if (urb->actual_length) {
33f0f88f AC	382	tty_buffer_request_room(tty, urb->actual_length);
33f0f88f AC	383	tty_insert_flip_string(tty, data, urb->actual_length);
1da177e4 LT	384	tty_flip_buffer_push(tty);
	385	}
	386
	387	spin_lock(&priv->lock);
	388
	389	/* Reduce urbs to do by one. */
	390	priv->rdtodo-=urb->actual_length;
	391	/* Just to be sure */
	392	if ( priv->rdtodo<0 ) priv->rdtodo = 0;
	393	todo = priv->rdtodo;
	394
	395	spin_unlock(&priv->lock);
	396
441b62c1	397	dbg("%s - rdtodo: %d", __func__, todo);
1da177e4 LT	398
	399	/* Continue to read if we have still urbs to do. */
	400	if( todo /* \|\| (urb->actual_length==port->bulk_in_endpointAddress)*/ ) {
	401	port->read_urb->dev = port->serial->dev;
	402	result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
	403	if (result)
441b62c1 HH	404	err("%s - failed resubmitting read urb, error %d", __func__, result);
441b62c1 HH	405	dbg("%s - usb_submit_urb(read urb)", __func__);
1da177e4 LT	406	}
	407	}
	408
7d12e780	409	static void cyberjack_write_bulk_callback (struct urb *urb)
1da177e4 LT	410	{
	411	struct usb_serial_port port = (struct usb_serial_port )urb->context;
	412	struct cyberjack_private *priv = usb_get_serial_port_data(port);
7dcc85cd	413	int status = urb->status;
1da177e4	414
441b62c1	415	dbg("%s - port %d", __func__, port->number);
507ca9bc GKH	416
507ca9bc GKH	417	port->write_urb_busy = 0;
7dcc85cd GKH	418	if (status) {
7dcc85cd GKH	419	dbg("%s - nonzero write bulk status received: %d",
441b62c1	420	__func__, status);
1da177e4 LT	421	return;
	422	}
	423
	424	spin_lock(&priv->lock);
	425
	426	/* only do something if we have more data to send */
	427	if( priv->wrfilled ) {
	428	int length, blksize, result;
	429
441b62c1	430	dbg("%s - transmitting data (frame n)", __func__);
1da177e4 LT	431
	432	length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ?
	433	port->bulk_out_size : (priv->wrfilled - priv->wrsent);
	434
	435	memcpy (port->write_urb->transfer_buffer, priv->wrbuf + priv->wrsent,
	436	length );
	437	priv->wrsent+=length;
	438
	439	/* set up our urb */
	440	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
	441	usb_sndbulkpipe(port->serial->dev, port->bulk_out_endpointAddress),
	442	port->write_urb->transfer_buffer, length,
	443	((port->serial->type->write_bulk_callback) ?
	444	port->serial->type->write_bulk_callback :
	445	cyberjack_write_bulk_callback),
	446	port);
	447
	448	/* send the data out the bulk port */
	449	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
	450	if (result) {
441b62c1	451	err("%s - failed submitting write urb, error %d", __func__, result);
1da177e4 LT	452	/* Throw away data. No better idea what to do with it. */
	453	priv->wrfilled=0;
	454	priv->wrsent=0;
	455	goto exit;
	456	}
	457
441b62c1 HH	458	dbg("%s - priv->wrsent=%d", __func__,priv->wrsent);
441b62c1 HH	459	dbg("%s - priv->wrfilled=%d", __func__,priv->wrfilled);
1da177e4 LT	460
	461	blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
	462
	463	if( (priv->wrsent>=priv->wrfilled) \|\| (priv->wrsent>=blksize) ) {
441b62c1	464	dbg("%s - buffer cleaned", __func__);
1da177e4 LT	465	memset( priv->wrbuf, 0, sizeof(priv->wrbuf) );
	466	priv->wrfilled=0;
	467	priv->wrsent=0;
	468	}
	469	}
	470
	471	exit:
	472	spin_unlock(&priv->lock);
cf2c7481	473	usb_serial_port_softint(port);
1da177e4 LT	474	}
	475
	476	static int __init cyberjack_init (void)
	477	{
	478	int retval;
	479	retval = usb_serial_register(&cyberjack_device);
	480	if (retval)
	481	goto failed_usb_serial_register;
	482	retval = usb_register(&cyberjack_driver);
	483	if (retval)
	484	goto failed_usb_register;
	485
	486	info(DRIVER_VERSION " " DRIVER_AUTHOR);
	487	info(DRIVER_DESC);
	488
	489	return 0;
	490	failed_usb_register:
	491	usb_serial_deregister(&cyberjack_device);
	492	failed_usb_serial_register:
	493	return retval;
	494	}
	495
	496	static void __exit cyberjack_exit (void)
	497	{
	498	usb_deregister (&cyberjack_driver);
	499	usb_serial_deregister (&cyberjack_device);
	500	}
	501
	502	module_init(cyberjack_init);
	503	module_exit(cyberjack_exit);
	504
	505	MODULE_AUTHOR( DRIVER_AUTHOR );
	506	MODULE_DESCRIPTION( DRIVER_DESC );
	507	MODULE_VERSION( DRIVER_VERSION );
	508	MODULE_LICENSE("GPL");
	509
	510	module_param(debug, bool, S_IRUGO \| S_IWUSR);
	511	MODULE_PARM_DESC(debug, "Debug enabled or not");