[net-next-2.6.git] / drivers / input / joystick / iforce / iforce-serio.c

/*
 * $Id: iforce-serio.c,v 1.4 2002/01/28 22:45:00 jdeneux Exp $
 *
 *  Copyright (c) 2000-2001 Vojtech Pavlik <vojtech@ucw.cz>
 *  Copyright (c) 2001 Johann Deneux <deneux@ifrance.com>
 *
 *  USB/RS232 I-Force joysticks and wheels.
 */

/*
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Should you need to contact me, the author, you can do so either by
 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
 */

#include "iforce.h"

void iforce_serial_xmit(struct iforce *iforce)
{
	unsigned char cs;
	int i;
	unsigned long flags;

	if (test_and_set_bit(IFORCE_XMIT_RUNNING, iforce->xmit_flags)) {
		set_bit(IFORCE_XMIT_AGAIN, iforce->xmit_flags);
		return;
	}

	spin_lock_irqsave(&iforce->xmit_lock, flags);

again:
	if (iforce->xmit.head == iforce->xmit.tail) {
		clear_bit(IFORCE_XMIT_RUNNING, iforce->xmit_flags);
		spin_unlock_irqrestore(&iforce->xmit_lock, flags);
		return;
	}

	cs = 0x2b;

	serio_write(iforce->serio, 0x2b);

	serio_write(iforce->serio, iforce->xmit.buf[iforce->xmit.tail]);
	cs ^= iforce->xmit.buf[iforce->xmit.tail];
	XMIT_INC(iforce->xmit.tail, 1);

	for (i=iforce->xmit.buf[iforce->xmit.tail]; i >= 0; --i) {
		serio_write(iforce->serio, iforce->xmit.buf[iforce->xmit.tail]);
		cs ^= iforce->xmit.buf[iforce->xmit.tail];
		XMIT_INC(iforce->xmit.tail, 1);
	}

	serio_write(iforce->serio, cs);

	if (test_and_clear_bit(IFORCE_XMIT_AGAIN, iforce->xmit_flags))
		goto again;

	clear_bit(IFORCE_XMIT_RUNNING, iforce->xmit_flags);

	spin_unlock_irqrestore(&iforce->xmit_lock, flags);
}

static void iforce_serio_write_wakeup(struct serio *serio)
{
	struct iforce *iforce = serio_get_drvdata(serio);

	iforce_serial_xmit(iforce);
}

static irqreturn_t iforce_serio_irq(struct serio *serio,
		unsigned char data, unsigned int flags)
{
	struct iforce *iforce = serio_get_drvdata(serio);

	if (!iforce->pkt) {
		if (data == 0x2b)
			iforce->pkt = 1;
		goto out;
	}

	if (!iforce->id) {
		if (data > 3 && data != 0xff)
			iforce->pkt = 0;
		else
			iforce->id = data;
		goto out;
	}

	if (!iforce->len) {
		if (data > IFORCE_MAX_LENGTH) {
			iforce->pkt = 0;
			iforce->id = 0;
		} else {
			iforce->len = data;
		}
		goto out;
	}

	if (iforce->idx < iforce->len) {
		iforce->csum += iforce->data[iforce->idx++] = data;
		goto out;
	}

	if (iforce->idx == iforce->len) {
		iforce_process_packet(iforce, (iforce->id << 8) | iforce->idx, iforce->data);
		iforce->pkt = 0;
		iforce->id  = 0;
		iforce->len = 0;
		iforce->idx = 0;
		iforce->csum = 0;
	}
out:
	return IRQ_HANDLED;
}

static int iforce_serio_connect(struct serio *serio, struct serio_driver *drv)
{
	struct iforce *iforce;
	int err;

	iforce = kzalloc(sizeof(struct iforce), GFP_KERNEL);
	if (!iforce)
		return -ENOMEM;

	iforce->bus = IFORCE_232;
	iforce->serio = serio;

	serio_set_drvdata(serio, iforce);

	err = serio_open(serio, drv);
	if (err) {
		serio_set_drvdata(serio, NULL);
		kfree(iforce);
		return err;
	}

	err = iforce_init_device(iforce);
	if (err) {
		serio_close(serio);
		serio_set_drvdata(serio, NULL);
		kfree(iforce);
		return -ENODEV;
	}

	return 0;
}

static void iforce_serio_disconnect(struct serio *serio)
{
	struct iforce *iforce = serio_get_drvdata(serio);

	input_unregister_device(iforce->dev);
	serio_close(serio);
	serio_set_drvdata(serio, NULL);
	kfree(iforce);
}

static struct serio_device_id iforce_serio_ids[] = {
	{
		.type	= SERIO_RS232,
		.proto	= SERIO_IFORCE,
		.id	= SERIO_ANY,
		.extra	= SERIO_ANY,
	},
	{ 0 }
};

MODULE_DEVICE_TABLE(serio, iforce_serio_ids);

struct serio_driver iforce_serio_drv = {
	.driver		= {
		.name	= "iforce",
	},
	.description	= "RS232 I-Force joysticks and wheels driver",
	.id_table	= iforce_serio_ids,
	.write_wakeup	= iforce_serio_write_wakeup,
	.interrupt	= iforce_serio_irq,
	.connect	= iforce_serio_connect,
	.disconnect	= iforce_serio_disconnect,
};
Commit	Line	Data
1da177e4 LT	1	/*
	2	* $Id: iforce-serio.c,v 1.4 2002/01/28 22:45:00 jdeneux Exp $
	3	*
	4	* Copyright (c) 2000-2001 Vojtech Pavlik <vojtech@ucw.cz>
	5	* Copyright (c) 2001 Johann Deneux <deneux@ifrance.com>
	6	*
	7	* USB/RS232 I-Force joysticks and wheels.
	8	*/
	9
	10	/*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
	23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	24	*
	25	* Should you need to contact me, the author, you can do so either by
	26	* e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
	27	* Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
	28	*/
	29
	30	#include "iforce.h"
	31
	32	void iforce_serial_xmit(struct iforce *iforce)
	33	{
	34	unsigned char cs;
	35	int i;
	36	unsigned long flags;
	37
	38	if (test_and_set_bit(IFORCE_XMIT_RUNNING, iforce->xmit_flags)) {
	39	set_bit(IFORCE_XMIT_AGAIN, iforce->xmit_flags);
	40	return;
	41	}
	42
	43	spin_lock_irqsave(&iforce->xmit_lock, flags);
	44
	45	again:
	46	if (iforce->xmit.head == iforce->xmit.tail) {
	47	clear_bit(IFORCE_XMIT_RUNNING, iforce->xmit_flags);
	48	spin_unlock_irqrestore(&iforce->xmit_lock, flags);
	49	return;
	50	}
	51
	52	cs = 0x2b;
	53
	54	serio_write(iforce->serio, 0x2b);
	55
	56	serio_write(iforce->serio, iforce->xmit.buf[iforce->xmit.tail]);
	57	cs ^= iforce->xmit.buf[iforce->xmit.tail];
	58	XMIT_INC(iforce->xmit.tail, 1);
	59
	60	for (i=iforce->xmit.buf[iforce->xmit.tail]; i >= 0; --i) {
	61	serio_write(iforce->serio, iforce->xmit.buf[iforce->xmit.tail]);
	62	cs ^= iforce->xmit.buf[iforce->xmit.tail];
	63	XMIT_INC(iforce->xmit.tail, 1);
	64	}
65
66	serio_write(iforce->serio, cs);
67
68	if (test_and_clear_bit(IFORCE_XMIT_AGAIN, iforce->xmit_flags))
69	goto again;
70
71	clear_bit(IFORCE_XMIT_RUNNING, iforce->xmit_flags);
72
73	spin_unlock_irqrestore(&iforce->xmit_lock, flags);
74	}
75
76	static void iforce_serio_write_wakeup(struct serio *serio)
77	{
78	struct iforce *iforce = serio_get_drvdata(serio);
79
80	iforce_serial_xmit(iforce);
81	}
82
83	static irqreturn_t iforce_serio_irq(struct serio *serio,
7d12e780	84	unsigned char data, unsigned int flags)
1da177e4 LT	85	{
	86	struct iforce *iforce = serio_get_drvdata(serio);
	87
	88	if (!iforce->pkt) {
	89	if (data == 0x2b)
	90	iforce->pkt = 1;
	91	goto out;
	92	}
	93
	94	if (!iforce->id) {
	95	if (data > 3 && data != 0xff)
	96	iforce->pkt = 0;
	97	else
	98	iforce->id = data;
	99	goto out;
	100	}
	101
	102	if (!iforce->len) {
	103	if (data > IFORCE_MAX_LENGTH) {
	104	iforce->pkt = 0;
	105	iforce->id = 0;
	106	} else {
	107	iforce->len = data;
	108	}
	109	goto out;
	110	}
	111
	112	if (iforce->idx < iforce->len) {
	113	iforce->csum += iforce->data[iforce->idx++] = data;
	114	goto out;
	115	}
	116
	117	if (iforce->idx == iforce->len) {
7d12e780	118	iforce_process_packet(iforce, (iforce->id << 8) \| iforce->idx, iforce->data);
1da177e4 LT	119	iforce->pkt = 0;
	120	iforce->id = 0;
	121	iforce->len = 0;
	122	iforce->idx = 0;
	123	iforce->csum = 0;
	124	}
	125	out:
	126	return IRQ_HANDLED;
	127	}
	128
	129	static int iforce_serio_connect(struct serio serio, struct serio_driver drv)
	130	{
	131	struct iforce *iforce;
	132	int err;
	133
17dd3f0f DT	134	iforce = kzalloc(sizeof(struct iforce), GFP_KERNEL);
17dd3f0f DT	135	if (!iforce)
1da177e4 LT	136	return -ENOMEM;
1da177e4 LT	137
1da177e4 LT	138	iforce->bus = IFORCE_232;
	139	iforce->serio = serio;
	140
	141	serio_set_drvdata(serio, iforce);
	142
	143	err = serio_open(serio, drv);
	144	if (err) {
	145	serio_set_drvdata(serio, NULL);
	146	kfree(iforce);
	147	return err;
	148	}
	149
17dd3f0f DT	150	err = iforce_init_device(iforce);
17dd3f0f DT	151	if (err) {
1da177e4 LT	152	serio_close(serio);
	153	serio_set_drvdata(serio, NULL);
	154	kfree(iforce);
	155	return -ENODEV;
	156	}
	157
	158	return 0;
	159	}
	160
	161	static void iforce_serio_disconnect(struct serio *serio)
	162	{
	163	struct iforce *iforce = serio_get_drvdata(serio);
	164
17dd3f0f	165	input_unregister_device(iforce->dev);
1da177e4 LT	166	serio_close(serio);
	167	serio_set_drvdata(serio, NULL);
	168	kfree(iforce);
	169	}
	170
	171	static struct serio_device_id iforce_serio_ids[] = {
	172	{
	173	.type = SERIO_RS232,
	174	.proto = SERIO_IFORCE,
	175	.id = SERIO_ANY,
	176	.extra = SERIO_ANY,
	177	},
	178	{ 0 }
	179	};
	180
	181	MODULE_DEVICE_TABLE(serio, iforce_serio_ids);
	182
	183	struct serio_driver iforce_serio_drv = {
	184	.driver = {
	185	.name = "iforce",
	186	},
	187	.description = "RS232 I-Force joysticks and wheels driver",
	188	.id_table = iforce_serio_ids,
	189	.write_wakeup = iforce_serio_write_wakeup,
	190	.interrupt = iforce_serio_irq,
	191	.connect = iforce_serio_connect,
	192	.disconnect = iforce_serio_disconnect,
	193	};