[deliverable/linux.git] / drivers / input / joystick / iforce / iforce-main.c

/*
 * $Id: iforce-main.c,v 1.19 2002/07/07 10:22:50 jdeneux Exp $
 *
 *  Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz>
 *  Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.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"

MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>, Johann Deneux <johann.deneux@gmail.com>");
MODULE_DESCRIPTION("USB/RS232 I-Force joysticks and wheels driver");
MODULE_LICENSE("GPL");

static signed short btn_joystick[] =
{ BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
  BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, -1 };

static signed short btn_avb_pegasus[] =
{ BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
  BTN_BASE2, BTN_BASE3, BTN_BASE4, -1 };

static signed short btn_wheel[] =
{ BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
  BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, -1 };

static signed short btn_avb_tw[] =
{ BTN_TRIGGER, BTN_THUMB, BTN_TOP, BTN_TOP2, BTN_BASE,
  BTN_BASE2, BTN_BASE3, BTN_BASE4, -1 };

static signed short btn_avb_wheel[] =
{ BTN_GEAR_DOWN, BTN_GEAR_UP, BTN_BASE, BTN_BASE2, BTN_BASE3,
  BTN_BASE4, BTN_BASE5, BTN_BASE6, -1 };

static signed short abs_joystick[] =
{ ABS_X, ABS_Y, ABS_THROTTLE, ABS_HAT0X, ABS_HAT0Y, -1 };

static signed short abs_avb_pegasus[] =
{ ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, ABS_HAT0X, ABS_HAT0Y,
  ABS_HAT1X, ABS_HAT1Y, -1 };

static signed short abs_wheel[] =
{ ABS_WHEEL, ABS_GAS, ABS_BRAKE, ABS_HAT0X, ABS_HAT0Y, -1 };

static signed short ff_iforce[] =
{ FF_PERIODIC, FF_CONSTANT, FF_SPRING, FF_DAMPER,
  FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP, FF_SAW_DOWN, FF_GAIN,
  FF_AUTOCENTER, -1 };

static struct iforce_device iforce_device[] = {
	{ 0x044f, 0xa01c, "Thrustmaster Motor Sport GT",		btn_wheel, abs_wheel, ff_iforce },
	{ 0x046d, 0xc281, "Logitech WingMan Force",			btn_joystick, abs_joystick, ff_iforce },
	{ 0x046d, 0xc291, "Logitech WingMan Formula Force",		btn_wheel, abs_wheel, ff_iforce },
	{ 0x05ef, 0x020a, "AVB Top Shot Pegasus",			btn_avb_pegasus, abs_avb_pegasus, ff_iforce },
	{ 0x05ef, 0x8884, "AVB Mag Turbo Force",			btn_avb_wheel, abs_wheel, ff_iforce },
	{ 0x05ef, 0x8888, "AVB Top Shot Force Feedback Racing Wheel",	btn_avb_tw, abs_wheel, ff_iforce }, //?
	{ 0x061c, 0xc0a4, "ACT LABS Force RS",                          btn_wheel, abs_wheel, ff_iforce }, //?
	{ 0x06f8, 0x0001, "Guillemot Race Leader Force Feedback",	btn_wheel, abs_wheel, ff_iforce }, //?
	{ 0x06f8, 0x0004, "Guillemot Force Feedback Racing Wheel",	btn_wheel, abs_wheel, ff_iforce }, //?
	{ 0x06f8, 0x0004, "Gullemot Jet Leader 3D",			btn_joystick, abs_joystick, ff_iforce }, //?
	{ 0x06d6, 0x29bc, "Trust Force Feedback Race Master",		btn_wheel, abs_wheel, ff_iforce },
	{ 0x0000, 0x0000, "Unknown I-Force Device [%04x:%04x]",		btn_joystick, abs_joystick, ff_iforce }
};

static int iforce_playback(struct input_dev *dev, int effect_id, int value)
{
	struct iforce* iforce = dev->private;
	struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];

	if (value > 0)
		set_bit(FF_CORE_SHOULD_PLAY, core_effect->flags);
	else
		clear_bit(FF_CORE_SHOULD_PLAY, core_effect->flags);

	iforce_control_playback(iforce, effect_id, value);
	return 0;
}

static void iforce_set_gain(struct input_dev *dev, u16 gain)
{
	struct iforce* iforce = dev->private;
	unsigned char data[3];

	data[0] = gain >> 9;
	iforce_send_packet(iforce, FF_CMD_GAIN, data);
}

static void iforce_set_autocenter(struct input_dev *dev, u16 magnitude)
{
	struct iforce* iforce = dev->private;
	unsigned char data[3];

	data[0] = 0x03;
	data[1] = magnitude >> 9;
	iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);

	data[0] = 0x04;
	data[1] = 0x01;
	iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
}

/*
 * Function called when an ioctl is performed on the event dev entry.
 * It uploads an effect to the device
 */
static int iforce_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
{
	struct iforce* iforce = dev->private;
	struct iforce_core_effect *core_effect = &iforce->core_effects[effect->id];
	int ret;

	if (__test_and_set_bit(FF_CORE_IS_USED, core_effect->flags)) {
		/* Check the effect is not already being updated */
		if (test_bit(FF_CORE_UPDATE, core_effect->flags))
			return -EAGAIN;
	}

/*
 * Upload the effect
 */
	switch (effect->type) {

		case FF_PERIODIC:
			ret = iforce_upload_periodic(iforce, effect, old);
			break;

		case FF_CONSTANT:
			ret = iforce_upload_constant(iforce, effect, old);
			break;

		case FF_SPRING:
		case FF_DAMPER:
			ret = iforce_upload_condition(iforce, effect, old);
			break;

		default:
			return -EINVAL;
	}

	if (ret == 0) {
		/* A packet was sent, forbid new updates until we are notified
		 * that the packet was updated
		 */
		set_bit(FF_CORE_UPDATE, core_effect->flags);
	}
	return ret;
}

/*
 * Erases an effect: it frees the effect id and mark as unused the memory
 * allocated for the parameters
 */
static int iforce_erase_effect(struct input_dev *dev, int effect_id)
{
	struct iforce *iforce = dev->private;
	struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];
	int err = 0;

	if (test_bit(FF_MOD1_IS_USED, core_effect->flags))
		err = release_resource(&core_effect->mod1_chunk);

	if (!err && test_bit(FF_MOD2_IS_USED, core_effect->flags))
		err = release_resource(&core_effect->mod2_chunk);

	/* TODO: remember to change that if more FF_MOD* bits are added */
	core_effect->flags[0] = 0;

	return err;
}

static int iforce_open(struct input_dev *dev)
{
	struct iforce *iforce = dev->private;

	switch (iforce->bus) {
#ifdef CONFIG_JOYSTICK_IFORCE_USB
		case IFORCE_USB:
			iforce->irq->dev = iforce->usbdev;
			if (usb_submit_urb(iforce->irq, GFP_KERNEL))
				return -EIO;
			break;
#endif
	}

	if (test_bit(EV_FF, dev->evbit)) {
		/* Enable force feedback */
		iforce_send_packet(iforce, FF_CMD_ENABLE, "\004");
	}

	return 0;
}

static void iforce_release(struct input_dev *dev)
{
	struct iforce *iforce = dev->private;
	int i;

	if (test_bit(EV_FF, dev->evbit)) {
		/* Check: no effects should be present in memory */
		for (i = 0; i < dev->ff->max_effects; i++) {
			if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags)) {
				warn("iforce_release: Device still owns effects");
				break;
			}
		}

		/* Disable force feedback playback */
		iforce_send_packet(iforce, FF_CMD_ENABLE, "\001");
	}

	switch (iforce->bus) {
#ifdef CONFIG_JOYSTICK_IFORCE_USB
		case IFORCE_USB:
			usb_kill_urb(iforce->irq);

			/* The device was unplugged before the file
			 * was released */
			if (iforce->usbdev == NULL) {
				iforce_delete_device(iforce);
				kfree(iforce);
			}
		break;
#endif
	}
}

void iforce_delete_device(struct iforce *iforce)
{
	switch (iforce->bus) {
#ifdef CONFIG_JOYSTICK_IFORCE_USB
	case IFORCE_USB:
		iforce_usb_delete(iforce);
		break;
#endif
#ifdef CONFIG_JOYSTICK_IFORCE_232
	case IFORCE_232:
		//TODO: Wait for the last packets to be sent
		break;
#endif
	}
}

int iforce_init_device(struct iforce *iforce)
{
	struct input_dev *input_dev;
	struct ff_device *ff;
	unsigned char c[] = "CEOV";
	int i, error;
	int ff_effects = 0;

	input_dev = input_allocate_device();
	if (!input_dev)
		return -ENOMEM;

	init_waitqueue_head(&iforce->wait);
	spin_lock_init(&iforce->xmit_lock);
	mutex_init(&iforce->mem_mutex);
	iforce->xmit.buf = iforce->xmit_data;
	iforce->dev = input_dev;

/*
 * Input device fields.
 */

	switch (iforce->bus) {
#ifdef CONFIG_JOYSTICK_IFORCE_USB
	case IFORCE_USB:
		input_dev->id.bustype = BUS_USB;
		input_dev->dev.parent = &iforce->usbdev->dev;
		break;
#endif
#ifdef CONFIG_JOYSTICK_IFORCE_232
	case IFORCE_232:
		input_dev->id.bustype = BUS_RS232;
		input_dev->dev.parent = &iforce->serio->dev;
		break;
#endif
	}

	input_dev->private = iforce;
	input_dev->name = "Unknown I-Force device";
	input_dev->open = iforce_open;
	input_dev->close = iforce_release;

/*
 * On-device memory allocation.
 */

	iforce->device_memory.name = "I-Force device effect memory";
	iforce->device_memory.start = 0;
	iforce->device_memory.end = 200;
	iforce->device_memory.flags = IORESOURCE_MEM;
	iforce->device_memory.parent = NULL;
	iforce->device_memory.child = NULL;
	iforce->device_memory.sibling = NULL;

/*
 * Wait until device ready - until it sends its first response.
 */

	for (i = 0; i < 20; i++)
		if (!iforce_get_id_packet(iforce, "O"))
			break;

	if (i == 20) { /* 5 seconds */
		err("Timeout waiting for response from device.");
		error = -ENODEV;
		goto fail;
	}

/*
 * Get device info.
 */

	if (!iforce_get_id_packet(iforce, "M"))
		input_dev->id.vendor = (iforce->edata[2] << 8) | iforce->edata[1];
	else
		warn("Device does not respond to id packet M");

	if (!iforce_get_id_packet(iforce, "P"))
		input_dev->id.product = (iforce->edata[2] << 8) | iforce->edata[1];
	else
		warn("Device does not respond to id packet P");

	if (!iforce_get_id_packet(iforce, "B"))
		iforce->device_memory.end = (iforce->edata[2] << 8) | iforce->edata[1];
	else
		warn("Device does not respond to id packet B");

	if (!iforce_get_id_packet(iforce, "N"))
		ff_effects = iforce->edata[1];
	else
		warn("Device does not respond to id packet N");

	/* Check if the device can store more effects than the driver can really handle */
	if (ff_effects > IFORCE_EFFECTS_MAX) {
		warn("Limiting number of effects to %d (device reports %d)",
		       IFORCE_EFFECTS_MAX, ff_effects);
		ff_effects = IFORCE_EFFECTS_MAX;
	}

/*
 * Display additional info.
 */

	for (i = 0; c[i]; i++)
		if (!iforce_get_id_packet(iforce, c + i))
			iforce_dump_packet("info", iforce->ecmd, iforce->edata);

/*
 * Disable spring, enable force feedback.
 * FIXME: We should use iforce_set_autocenter() et al here.
 */

	iforce_send_packet(iforce, FF_CMD_AUTOCENTER, "\004\000");

/*
 * Find appropriate device entry
 */

	for (i = 0; iforce_device[i].idvendor; i++)
		if (iforce_device[i].idvendor == input_dev->id.vendor &&
		    iforce_device[i].idproduct == input_dev->id.product)
			break;

	iforce->type = iforce_device + i;
	input_dev->name = iforce->type->name;

/*
 * Set input device bitfields and ranges.
 */

	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_FF_STATUS);

	for (i = 0; iforce->type->btn[i] >= 0; i++)
		set_bit(iforce->type->btn[i], input_dev->keybit);
	set_bit(BTN_DEAD, input_dev->keybit);

	for (i = 0; iforce->type->abs[i] >= 0; i++) {

		signed short t = iforce->type->abs[i];

		switch (t) {

			case ABS_X:
			case ABS_Y:
			case ABS_WHEEL:

				input_set_abs_params(input_dev, t, -1920, 1920, 16, 128);
				set_bit(t, input_dev->ffbit);
				break;

			case ABS_THROTTLE:
			case ABS_GAS:
			case ABS_BRAKE:

				input_set_abs_params(input_dev, t, 0, 255, 0, 0);
				break;

			case ABS_RUDDER:

				input_set_abs_params(input_dev, t, -128, 127, 0, 0);
				break;

			case ABS_HAT0X:
			case ABS_HAT0Y:
		        case ABS_HAT1X:
		        case ABS_HAT1Y:

				input_set_abs_params(input_dev, t, -1, 1, 0, 0);
				break;
		}
	}

	if (ff_effects) {

		for (i = 0; iforce->type->ff[i] >= 0; i++)
			set_bit(iforce->type->ff[i], input_dev->ffbit);

		error = input_ff_create(input_dev, ff_effects);
		if (error)
			goto fail;

		ff = input_dev->ff;
		ff->upload = iforce_upload_effect;
		ff->erase = iforce_erase_effect;
		ff->set_gain = iforce_set_gain;
		ff->set_autocenter = iforce_set_autocenter;
		ff->playback = iforce_playback;
	}
/*
 * Register input device.
 */

	error = input_register_device(iforce->dev);
	if (error)
		goto fail;

	return 0;

 fail:	input_free_device(input_dev);
	return error;
}

static int __init iforce_init(void)
{
	int err = 0;

#ifdef CONFIG_JOYSTICK_IFORCE_USB
	err = usb_register(&iforce_usb_driver);
	if (err)
		return err;
#endif
#ifdef CONFIG_JOYSTICK_IFORCE_232
	err = serio_register_driver(&iforce_serio_drv);
#ifdef CONFIG_JOYSTICK_IFORCE_USB
	if (err)
		usb_deregister(&iforce_usb_driver);
#endif
#endif
	return err;
}

static void __exit iforce_exit(void)
{
#ifdef CONFIG_JOYSTICK_IFORCE_USB
	usb_deregister(&iforce_usb_driver);
#endif
#ifdef CONFIG_JOYSTICK_IFORCE_232
	serio_unregister_driver(&iforce_serio_drv);
#endif
}

module_init(iforce_init);
module_exit(iforce_exit);
Commit	Line	Data
1da177e4 LT	1	/*
	2	* $Id: iforce-main.c,v 1.19 2002/07/07 10:22:50 jdeneux Exp $
	3	*
	4	* Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz>
598972d4	5	* Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.com>
1da177e4 LT	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
598972d4	32	MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>, Johann Deneux <johann.deneux@gmail.com>");
1da177e4 LT	33	MODULE_DESCRIPTION("USB/RS232 I-Force joysticks and wheels driver");
	34	MODULE_LICENSE("GPL");
	35
	36	static signed short btn_joystick[] =
	37	{ BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
	38	BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, -1 };
	39
	40	static signed short btn_avb_pegasus[] =
	41	{ BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
	42	BTN_BASE2, BTN_BASE3, BTN_BASE4, -1 };
	43
	44	static signed short btn_wheel[] =
	45	{ BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
	46	BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, -1 };
	47
	48	static signed short btn_avb_tw[] =
	49	{ BTN_TRIGGER, BTN_THUMB, BTN_TOP, BTN_TOP2, BTN_BASE,
	50	BTN_BASE2, BTN_BASE3, BTN_BASE4, -1 };
	51
	52	static signed short btn_avb_wheel[] =
	53	{ BTN_GEAR_DOWN, BTN_GEAR_UP, BTN_BASE, BTN_BASE2, BTN_BASE3,
	54	BTN_BASE4, BTN_BASE5, BTN_BASE6, -1 };
	55
	56	static signed short abs_joystick[] =
	57	{ ABS_X, ABS_Y, ABS_THROTTLE, ABS_HAT0X, ABS_HAT0Y, -1 };
	58
	59	static signed short abs_avb_pegasus[] =
	60	{ ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, ABS_HAT0X, ABS_HAT0Y,
	61	ABS_HAT1X, ABS_HAT1Y, -1 };
	62
	63	static signed short abs_wheel[] =
	64	{ ABS_WHEEL, ABS_GAS, ABS_BRAKE, ABS_HAT0X, ABS_HAT0Y, -1 };
	65
	66	static signed short ff_iforce[] =
	67	{ FF_PERIODIC, FF_CONSTANT, FF_SPRING, FF_DAMPER,
	68	FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP, FF_SAW_DOWN, FF_GAIN,
	69	FF_AUTOCENTER, -1 };
	70
	71	static struct iforce_device iforce_device[] = {
	72	{ 0x044f, 0xa01c, "Thrustmaster Motor Sport GT", btn_wheel, abs_wheel, ff_iforce },
	73	{ 0x046d, 0xc281, "Logitech WingMan Force", btn_joystick, abs_joystick, ff_iforce },
	74	{ 0x046d, 0xc291, "Logitech WingMan Formula Force", btn_wheel, abs_wheel, ff_iforce },
	75	{ 0x05ef, 0x020a, "AVB Top Shot Pegasus", btn_avb_pegasus, abs_avb_pegasus, ff_iforce },
	76	{ 0x05ef, 0x8884, "AVB Mag Turbo Force", btn_avb_wheel, abs_wheel, ff_iforce },
	77	{ 0x05ef, 0x8888, "AVB Top Shot Force Feedback Racing Wheel", btn_avb_tw, abs_wheel, ff_iforce }, //?
	78	{ 0x061c, 0xc0a4, "ACT LABS Force RS", btn_wheel, abs_wheel, ff_iforce }, //?
	79	{ 0x06f8, 0x0001, "Guillemot Race Leader Force Feedback", btn_wheel, abs_wheel, ff_iforce }, //?
	80	{ 0x06f8, 0x0004, "Guillemot Force Feedback Racing Wheel", btn_wheel, abs_wheel, ff_iforce }, //?
18098a6c	81	{ 0x06f8, 0x0004, "Gullemot Jet Leader 3D", btn_joystick, abs_joystick, ff_iforce }, //?
b53174fb	82	{ 0x06d6, 0x29bc, "Trust Force Feedback Race Master", btn_wheel, abs_wheel, ff_iforce },
1da177e4 LT	83	{ 0x0000, 0x0000, "Unknown I-Force Device [%04x:%04x]", btn_joystick, abs_joystick, ff_iforce }
	84	};
	85
f6a01c85	86	static int iforce_playback(struct input_dev *dev, int effect_id, int value)
1da177e4	87	{
e2e8115b	88	struct iforce* iforce = dev->private;
f6a01c85	89	struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];
1da177e4	90
f6a01c85 AH	91	if (value > 0)
	92	set_bit(FF_CORE_SHOULD_PLAY, core_effect->flags);
	93	else
	94	clear_bit(FF_CORE_SHOULD_PLAY, core_effect->flags);
1da177e4	95
f6a01c85 AH	96	iforce_control_playback(iforce, effect_id, value);
	97	return 0;
	98	}
1da177e4	99
f6a01c85 AH	100	static void iforce_set_gain(struct input_dev *dev, u16 gain)
	101	{
	102	struct iforce* iforce = dev->private;
	103	unsigned char data[3];
1da177e4	104
f6a01c85 AH	105	data[0] = gain >> 9;
	106	iforce_send_packet(iforce, FF_CMD_GAIN, data);
	107	}
1da177e4	108
f6a01c85 AH	109	static void iforce_set_autocenter(struct input_dev *dev, u16 magnitude)
	110	{
	111	struct iforce* iforce = dev->private;
	112	unsigned char data[3];
1da177e4	113
f6a01c85 AH	114	data[0] = 0x03;
	115	data[1] = magnitude >> 9;
	116	iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
1da177e4	117
f6a01c85 AH	118	data[0] = 0x04;
	119	data[1] = 0x01;
	120	iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
1da177e4 LT	121	}
	122
	123	/*
	124	* Function called when an ioctl is performed on the event dev entry.
	125	* It uploads an effect to the device
	126	*/
f6a01c85	127	static int iforce_upload_effect(struct input_dev dev, struct ff_effect effect, struct ff_effect *old)
1da177e4	128	{
e2e8115b	129	struct iforce* iforce = dev->private;
f6a01c85	130	struct iforce_core_effect *core_effect = &iforce->core_effects[effect->id];
1da177e4	131	int ret;
1da177e4	132
f6a01c85	133	if (__test_and_set_bit(FF_CORE_IS_USED, core_effect->flags)) {
1da177e4	134	/* Check the effect is not already being updated */
f6a01c85	135	if (test_bit(FF_CORE_UPDATE, core_effect->flags))
1da177e4	136	return -EAGAIN;
1da177e4 LT	137	}
	138
	139	/*
	140	* Upload the effect
	141	*/
	142	switch (effect->type) {
	143
	144	case FF_PERIODIC:
f6a01c85	145	ret = iforce_upload_periodic(iforce, effect, old);
1da177e4 LT	146	break;
	147
	148	case FF_CONSTANT:
f6a01c85	149	ret = iforce_upload_constant(iforce, effect, old);
1da177e4 LT	150	break;
	151
	152	case FF_SPRING:
	153	case FF_DAMPER:
f6a01c85	154	ret = iforce_upload_condition(iforce, effect, old);
1da177e4 LT	155	break;
	156
	157	default:
	158	return -EINVAL;
	159	}
f6a01c85	160
1da177e4 LT	161	if (ret == 0) {
	162	/* A packet was sent, forbid new updates until we are notified
	163	* that the packet was updated
	164	*/
f6a01c85	165	set_bit(FF_CORE_UPDATE, core_effect->flags);
1da177e4	166	}
1da177e4 LT	167	return ret;
	168	}
	169
	170	/*
	171	* Erases an effect: it frees the effect id and mark as unused the memory
	172	* allocated for the parameters
	173	*/
	174	static int iforce_erase_effect(struct input_dev *dev, int effect_id)
	175	{
f6a01c85 AH	176	struct iforce *iforce = dev->private;
f6a01c85 AH	177	struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];
1da177e4	178	int err = 0;
1da177e4 LT	179
1da177e4 LT	180	if (test_bit(FF_MOD1_IS_USED, core_effect->flags))
8d64d372	181	err = release_resource(&core_effect->mod1_chunk);
1da177e4 LT	182
1da177e4 LT	183	if (!err && test_bit(FF_MOD2_IS_USED, core_effect->flags))
8d64d372	184	err = release_resource(&core_effect->mod2_chunk);
1da177e4	185
f6a01c85	186	/* TODO: remember to change that if more FF_MOD* bits are added */
1da177e4 LT	187	core_effect->flags[0] = 0;
	188
	189	return err;
	190	}
	191
	192	static int iforce_open(struct input_dev *dev)
	193	{
	194	struct iforce *iforce = dev->private;
	195
	196	switch (iforce->bus) {
	197	#ifdef CONFIG_JOYSTICK_IFORCE_USB
	198	case IFORCE_USB:
	199	iforce->irq->dev = iforce->usbdev;
	200	if (usb_submit_urb(iforce->irq, GFP_KERNEL))
	201	return -EIO;
	202	break;
	203	#endif
	204	}
	205
f6a01c85 AH	206	if (test_bit(EV_FF, dev->evbit)) {
	207	/* Enable force feedback */
	208	iforce_send_packet(iforce, FF_CMD_ENABLE, "\004");
	209	}
1da177e4 LT	210
	211	return 0;
	212	}
	213
f6a01c85	214	static void iforce_release(struct input_dev *dev)
1da177e4 LT	215	{
	216	struct iforce *iforce = dev->private;
	217	int i;
	218
f6a01c85 AH	219	if (test_bit(EV_FF, dev->evbit)) {
	220	/* Check: no effects should be present in memory */
	221	for (i = 0; i < dev->ff->max_effects; i++) {
	222	if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags)) {
598972d4	223	warn("iforce_release: Device still owns effects");
f6a01c85	224	break;
1da177e4 LT	225	}
	226	}
	227
f6a01c85 AH	228	/* Disable force feedback playback */
f6a01c85 AH	229	iforce_send_packet(iforce, FF_CMD_ENABLE, "\001");
1da177e4	230	}
1da177e4 LT	231
	232	switch (iforce->bus) {
	233	#ifdef CONFIG_JOYSTICK_IFORCE_USB
	234	case IFORCE_USB:
598972d4	235	usb_kill_urb(iforce->irq);
1da177e4 LT	236
	237	/* The device was unplugged before the file
	238	* was released */
	239	if (iforce->usbdev == NULL) {
	240	iforce_delete_device(iforce);
	241	kfree(iforce);
	242	}
	243	break;
	244	#endif
	245	}
	246	}
	247
	248	void iforce_delete_device(struct iforce *iforce)
	249	{
	250	switch (iforce->bus) {
	251	#ifdef CONFIG_JOYSTICK_IFORCE_USB
	252	case IFORCE_USB:
	253	iforce_usb_delete(iforce);
	254	break;
	255	#endif
	256	#ifdef CONFIG_JOYSTICK_IFORCE_232
	257	case IFORCE_232:
	258	//TODO: Wait for the last packets to be sent
	259	break;
	260	#endif
	261	}
	262	}
	263
	264	int iforce_init_device(struct iforce *iforce)
	265	{
17dd3f0f	266	struct input_dev *input_dev;
f6a01c85	267	struct ff_device *ff;
1da177e4	268	unsigned char c[] = "CEOV";
f6a01c85 AH	269	int i, error;
f6a01c85 AH	270	int ff_effects = 0;
1da177e4	271
17dd3f0f	272	input_dev = input_allocate_device();
5ae08f80	273	if (!input_dev)
17dd3f0f DT	274	return -ENOMEM;
17dd3f0f DT	275
1da177e4 LT	276	init_waitqueue_head(&iforce->wait);
1da177e4 LT	277	spin_lock_init(&iforce->xmit_lock);
72ba9f0c	278	mutex_init(&iforce->mem_mutex);
1da177e4	279	iforce->xmit.buf = iforce->xmit_data;
17dd3f0f	280	iforce->dev = input_dev;
1da177e4 LT	281
	282	/*
	283	* Input device fields.
	284	*/
	285
	286	switch (iforce->bus) {
	287	#ifdef CONFIG_JOYSTICK_IFORCE_USB
	288	case IFORCE_USB:
17dd3f0f	289	input_dev->id.bustype = BUS_USB;
935e658e	290	input_dev->dev.parent = &iforce->usbdev->dev;
1da177e4 LT	291	break;
	292	#endif
	293	#ifdef CONFIG_JOYSTICK_IFORCE_232
	294	case IFORCE_232:
17dd3f0f	295	input_dev->id.bustype = BUS_RS232;
935e658e	296	input_dev->dev.parent = &iforce->serio->dev;
1da177e4 LT	297	break;
	298	#endif
	299	}
	300
17dd3f0f DT	301	input_dev->private = iforce;
	302	input_dev->name = "Unknown I-Force device";
	303	input_dev->open = iforce_open;
	304	input_dev->close = iforce_release;
1da177e4 LT	305
	306	/*
	307	* On-device memory allocation.
	308	*/
	309
	310	iforce->device_memory.name = "I-Force device effect memory";
	311	iforce->device_memory.start = 0;
	312	iforce->device_memory.end = 200;
	313	iforce->device_memory.flags = IORESOURCE_MEM;
	314	iforce->device_memory.parent = NULL;
	315	iforce->device_memory.child = NULL;
	316	iforce->device_memory.sibling = NULL;
	317
	318	/*
	319	* Wait until device ready - until it sends its first response.
	320	*/
	321
	322	for (i = 0; i < 20; i++)
	323	if (!iforce_get_id_packet(iforce, "O"))
	324	break;
	325
	326	if (i == 20) { /* 5 seconds */
598972d4	327	err("Timeout waiting for response from device.");
127278ce DT	328	error = -ENODEV;
127278ce DT	329	goto fail;
1da177e4 LT	330	}
	331
	332	/*
	333	* Get device info.
	334	*/
	335
	336	if (!iforce_get_id_packet(iforce, "M"))
17dd3f0f	337	input_dev->id.vendor = (iforce->edata[2] << 8) \| iforce->edata[1];
1da177e4	338	else
598972d4	339	warn("Device does not respond to id packet M");
1da177e4 LT	340
1da177e4 LT	341	if (!iforce_get_id_packet(iforce, "P"))
17dd3f0f	342	input_dev->id.product = (iforce->edata[2] << 8) \| iforce->edata[1];
1da177e4	343	else
598972d4	344	warn("Device does not respond to id packet P");
1da177e4 LT	345
	346	if (!iforce_get_id_packet(iforce, "B"))
	347	iforce->device_memory.end = (iforce->edata[2] << 8) \| iforce->edata[1];
	348	else
598972d4	349	warn("Device does not respond to id packet B");
1da177e4 LT	350
1da177e4 LT	351	if (!iforce_get_id_packet(iforce, "N"))
f6a01c85	352	ff_effects = iforce->edata[1];
1da177e4	353	else
598972d4	354	warn("Device does not respond to id packet N");
1da177e4 LT	355
1da177e4 LT	356	/* Check if the device can store more effects than the driver can really handle */
f6a01c85	357	if (ff_effects > IFORCE_EFFECTS_MAX) {
598972d4	358	warn("Limiting number of effects to %d (device reports %d)",
f6a01c85 AH	359	IFORCE_EFFECTS_MAX, ff_effects);
f6a01c85 AH	360	ff_effects = IFORCE_EFFECTS_MAX;
1da177e4 LT	361	}
	362
	363	/*
	364	* Display additional info.
	365	*/
	366
	367	for (i = 0; c[i]; i++)
	368	if (!iforce_get_id_packet(iforce, c + i))
	369	iforce_dump_packet("info", iforce->ecmd, iforce->edata);
	370
	371	/*
	372	* Disable spring, enable force feedback.
	373	* FIXME: We should use iforce_set_autocenter() et al here.
	374	*/
	375
	376	iforce_send_packet(iforce, FF_CMD_AUTOCENTER, "\004\000");
	377
	378	/*
	379	* Find appropriate device entry
	380	*/
	381
	382	for (i = 0; iforce_device[i].idvendor; i++)
17dd3f0f DT	383	if (iforce_device[i].idvendor == input_dev->id.vendor &&
17dd3f0f DT	384	iforce_device[i].idproduct == input_dev->id.product)
1da177e4 LT	385	break;
	386
	387	iforce->type = iforce_device + i;
17dd3f0f	388	input_dev->name = iforce->type->name;
1da177e4 LT	389
	390	/*
	391	* Set input device bitfields and ranges.
	392	*/
	393
f6a01c85	394	input_dev->evbit[0] = BIT(EV_KEY) \| BIT(EV_ABS) \| BIT(EV_FF_STATUS);
1da177e4	395
f6a01c85 AH	396	for (i = 0; iforce->type->btn[i] >= 0; i++)
f6a01c85 AH	397	set_bit(iforce->type->btn[i], input_dev->keybit);
17dd3f0f	398	set_bit(BTN_DEAD, input_dev->keybit);
1da177e4 LT	399
	400	for (i = 0; iforce->type->abs[i] >= 0; i++) {
	401
	402	signed short t = iforce->type->abs[i];
1da177e4 LT	403
	404	switch (t) {
	405
	406	case ABS_X:
	407	case ABS_Y:
	408	case ABS_WHEEL:
	409
17dd3f0f DT	410	input_set_abs_params(input_dev, t, -1920, 1920, 16, 128);
17dd3f0f DT	411	set_bit(t, input_dev->ffbit);
1da177e4 LT	412	break;
	413
	414	case ABS_THROTTLE:
	415	case ABS_GAS:
	416	case ABS_BRAKE:
	417
17dd3f0f	418	input_set_abs_params(input_dev, t, 0, 255, 0, 0);
1da177e4 LT	419	break;
	420
	421	case ABS_RUDDER:
	422
17dd3f0f	423	input_set_abs_params(input_dev, t, -128, 127, 0, 0);
1da177e4 LT	424	break;
	425
	426	case ABS_HAT0X:
	427	case ABS_HAT0Y:
	428	case ABS_HAT1X:
	429	case ABS_HAT1Y:
17dd3f0f DT	430
17dd3f0f DT	431	input_set_abs_params(input_dev, t, -1, 1, 0, 0);
1da177e4 LT	432	break;
	433	}
	434	}
	435
f6a01c85	436	if (ff_effects) {
1da177e4	437
f6a01c85 AH	438	for (i = 0; iforce->type->ff[i] >= 0; i++)
	439	set_bit(iforce->type->ff[i], input_dev->ffbit);
	440
	441	error = input_ff_create(input_dev, ff_effects);
127278ce DT	442	if (error)
127278ce DT	443	goto fail;
f6a01c85 AH	444
	445	ff = input_dev->ff;
	446	ff->upload = iforce_upload_effect;
	447	ff->erase = iforce_erase_effect;
	448	ff->set_gain = iforce_set_gain;
	449	ff->set_autocenter = iforce_set_autocenter;
	450	ff->playback = iforce_playback;
	451	}
1da177e4 LT	452	/*
	453	* Register input device.
	454	*/
	455
127278ce DT	456	error = input_register_device(iforce->dev);
	457	if (error)
	458	goto fail;
1da177e4	459
1da177e4	460	return 0;
127278ce DT	461
	462	fail: input_free_device(input_dev);
	463	return error;
1da177e4 LT	464	}
	465
	466	static int __init iforce_init(void)
	467	{
153a9df0 AM	468	int err = 0;
153a9df0 AM	469
1da177e4	470	#ifdef CONFIG_JOYSTICK_IFORCE_USB
153a9df0 AM	471	err = usb_register(&iforce_usb_driver);
	472	if (err)
	473	return err;
1da177e4 LT	474	#endif
1da177e4 LT	475	#ifdef CONFIG_JOYSTICK_IFORCE_232
153a9df0 AM	476	err = serio_register_driver(&iforce_serio_drv);
	477	#ifdef CONFIG_JOYSTICK_IFORCE_USB
	478	if (err)
	479	usb_deregister(&iforce_usb_driver);
1da177e4	480	#endif
153a9df0 AM	481	#endif
153a9df0 AM	482	return err;
1da177e4 LT	483	}
	484
	485	static void __exit iforce_exit(void)
	486	{
	487	#ifdef CONFIG_JOYSTICK_IFORCE_USB
	488	usb_deregister(&iforce_usb_driver);
	489	#endif
	490	#ifdef CONFIG_JOYSTICK_IFORCE_232
	491	serio_unregister_driver(&iforce_serio_drv);
	492	#endif
	493	}
	494
	495	module_init(iforce_init);
	496	module_exit(iforce_exit);