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

/*
 *  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 }, //?
	{ 0x061c, 0xc084, "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 = input_get_drvdata(dev);
	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 = input_get_drvdata(dev);
	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 = input_get_drvdata(dev);
	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 = input_get_drvdata(dev);
	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 = input_get_drvdata(dev);
	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 = input_get_drvdata(dev);

	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_close(struct input_dev *dev)
{
	struct iforce *iforce = input_get_drvdata(dev);
	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)) {
				dev_warn(&dev->dev,
					"%s: Device still owns effects\n",
					__func__);
				break;
			}
		}

		/* Disable force feedback playback */
		iforce_send_packet(iforce, FF_CMD_ENABLE, "\001");
		/* Wait for the command to complete */
		wait_event_interruptible(iforce->wait,
			!test_bit(IFORCE_XMIT_RUNNING, iforce->xmit_flags));
	}

	switch (iforce->bus) {
#ifdef CONFIG_JOYSTICK_IFORCE_USB
	case IFORCE_USB:
		usb_kill_urb(iforce->irq);
		usb_kill_urb(iforce->out);
		usb_kill_urb(iforce->ctrl);
		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_set_drvdata(input_dev, iforce);

	input_dev->name = "Unknown I-Force device";
	input_dev->open = iforce_open;
	input_dev->close = iforce_close;

/*
 * 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
		dev_warn(&iforce->dev->dev, "Device does not respond to id packet M\n");

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

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

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

	/* Check if the device can store more effects than the driver can really handle */
	if (ff_effects > IFORCE_EFFECTS_MAX) {
		dev_warn(&iforce->dev->dev, "Limiting number of effects to %d (device reports %d)\n",
		       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.
 */
	iforce_set_autocenter(input_dev, 0);

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