Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d20e6336 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge master.kernel.org:/pub/scm/linux/kernel/git/dtor/input

parents fa3c791d 6dea9347

drivers/input/joystick/a3d.c

+46 −42
Original line number Diff line number Diff line
@@ -57,7 +57,7 @@ static char *a3d_names[] = { NULL, "FP-Gaming Assassin 3D", "MadCatz Panther", " 
struct a3d {

	struct gameport *gameport;

	struct gameport *adc;

	struct input_dev dev;

	struct input_dev *dev;

	int axes[4];

	int buttons;

	int mode;
@@ -115,7 +115,7 @@ static int a3d_csum(char *data, int count) 


static void a3d_read(struct a3d *a3d, unsigned char *data)

{

	struct input_dev *dev = &a3d->dev;

	struct input_dev *dev = a3d->dev;



	switch (a3d->mode) {
@@ -265,14 +265,20 @@ static void a3d_close(struct input_dev *dev) 
static int a3d_connect(struct gameport *gameport, struct gameport_driver *drv)

{

	struct a3d *a3d;

	struct input_dev *input_dev;

	struct gameport *adc;

	unsigned char data[A3D_MAX_LENGTH];

	int i;

	int err;



	if (!(a3d = kzalloc(sizeof(struct a3d), GFP_KERNEL)))

		return -ENOMEM;

	a3d = kzalloc(sizeof(struct a3d), GFP_KERNEL);

	input_dev = input_allocate_device();

	if (!a3d || !input_dev) {

		err = -ENOMEM;

		goto fail1;

	}



	a3d->dev = input_dev;

	a3d->gameport = gameport;



	gameport_set_drvdata(gameport, a3d);
@@ -302,42 +308,48 @@ static int a3d_connect(struct gameport *gameport, struct gameport_driver *drv) 


	sprintf(a3d->phys, "%s/input0", gameport->phys);



	input_dev->name = a3d_names[a3d->mode];

	input_dev->phys = a3d->phys;

	input_dev->id.bustype = BUS_GAMEPORT;

	input_dev->id.vendor = GAMEPORT_ID_VENDOR_MADCATZ;

	input_dev->id.product = a3d->mode;

	input_dev->id.version = 0x0100;

	input_dev->cdev.dev = &gameport->dev;

	input_dev->private = a3d;

	input_dev->open = a3d_open;

	input_dev->close = a3d_close;



	if (a3d->mode == A3D_MODE_PXL) {



		int axes[] = { ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER };



		a3d->length = 33;



		init_input_dev(&a3d->dev);



		a3d->dev.evbit[0] |= BIT(EV_ABS) | BIT(EV_KEY) | BIT(EV_REL);

		a3d->dev.relbit[0] |= BIT(REL_X) | BIT(REL_Y);

		a3d->dev.absbit[0] |= BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_THROTTLE) | BIT(ABS_RUDDER)

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

		input_dev->relbit[0] |= BIT(REL_X) | BIT(REL_Y);

		input_dev->absbit[0] |= BIT(ABS_X) | BIT(ABS_Y) | BIT(ABS_THROTTLE) | BIT(ABS_RUDDER)

					| BIT(ABS_HAT0X) | BIT(ABS_HAT0Y) | BIT(ABS_HAT1X) | BIT(ABS_HAT1Y);



		a3d->dev.keybit[LONG(BTN_MOUSE)] |= BIT(BTN_RIGHT) | BIT(BTN_LEFT) | BIT(BTN_MIDDLE)

		input_dev->keybit[LONG(BTN_MOUSE)] |= BIT(BTN_RIGHT) | BIT(BTN_LEFT) | BIT(BTN_MIDDLE)

							| BIT(BTN_SIDE) | BIT(BTN_EXTRA);



		a3d->dev.keybit[LONG(BTN_JOYSTICK)] |= BIT(BTN_TRIGGER) | BIT(BTN_THUMB) | BIT(BTN_TOP) | BIT(BTN_PINKIE);

		input_dev->keybit[LONG(BTN_JOYSTICK)] |= BIT(BTN_TRIGGER) | BIT(BTN_THUMB) | BIT(BTN_TOP)

							| BIT(BTN_PINKIE);



		a3d_read(a3d, data);



		for (i = 0; i < 4; i++) {

			if (i < 2)

				input_set_abs_params(&a3d->dev, axes[i], 48, a3d->dev.abs[axes[i]] * 2 - 48, 0, 8);

				input_set_abs_params(input_dev, axes[i], 48, input_dev->abs[axes[i]] * 2 - 48, 0, 8);

			else

				input_set_abs_params(&a3d->dev, axes[i], 2, 253, 0, 0);

			input_set_abs_params(&a3d->dev, ABS_HAT0X + i, -1, 1, 0, 0);

				input_set_abs_params(input_dev, axes[i], 2, 253, 0, 0);

			input_set_abs_params(input_dev, ABS_HAT0X + i, -1, 1, 0, 0);

		}



	} else {

		a3d->length = 29;



		init_input_dev(&a3d->dev);



		a3d->dev.evbit[0] |= BIT(EV_KEY) | BIT(EV_REL);

		a3d->dev.relbit[0] |= BIT(REL_X) | BIT(REL_Y);

		a3d->dev.keybit[LONG(BTN_MOUSE)] |= BIT(BTN_RIGHT) | BIT(BTN_LEFT) | BIT(BTN_MIDDLE);

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

		input_dev->relbit[0] |= BIT(REL_X) | BIT(REL_Y);

		input_dev->keybit[LONG(BTN_MOUSE)] |= BIT(BTN_RIGHT) | BIT(BTN_LEFT) | BIT(BTN_MIDDLE);



		a3d_read(a3d, data);
@@ -358,24 +370,17 @@ static int a3d_connect(struct gameport *gameport, struct gameport_driver *drv) 
		}

	}



	a3d->dev.private = a3d;

	a3d->dev.open = a3d_open;

	a3d->dev.close = a3d_close;



	a3d->dev.name = a3d_names[a3d->mode];

	a3d->dev.phys = a3d->phys;

	a3d->dev.id.bustype = BUS_GAMEPORT;

	a3d->dev.id.vendor = GAMEPORT_ID_VENDOR_MADCATZ;

	a3d->dev.id.product = a3d->mode;

	a3d->dev.id.version = 0x0100;



	input_register_device(&a3d->dev);

	printk(KERN_INFO "input: %s on %s\n", a3d_names[a3d->mode], a3d->phys);

	err = input_register_device(a3d->dev);

	if (err)

		goto fail3;



	return 0;



 fail3:	if (a3d->adc)

		gameport_unregister_port(a3d->adc);

 fail2:	gameport_close(gameport);

 fail1:	gameport_set_drvdata(gameport, NULL);

	input_free_device(input_dev);

	kfree(a3d);

	return err;

}
@@ -384,11 +389,9 @@ static void a3d_disconnect(struct gameport *gameport) 
{

	struct a3d *a3d = gameport_get_drvdata(gameport);



	input_unregister_device(&a3d->dev);

	if (a3d->adc) {

	input_unregister_device(a3d->dev);

	if (a3d->adc)

		gameport_unregister_port(a3d->adc);

		a3d->adc = NULL;

	}

	gameport_close(gameport);

	gameport_set_drvdata(gameport, NULL);

	kfree(a3d);
@@ -397,6 +400,7 @@ static void a3d_disconnect(struct gameport *gameport) 
static struct gameport_driver a3d_drv = {

	.driver		= {

		.name	= "adc",

		.owner	= THIS_MODULE,

	},

	.description	= DRIVER_DESC,

	.connect	= a3d_connect,

drivers/input/joystick/db9.c

+46 −39
Original line number Diff line number Diff line
@@ -275,68 +275,70 @@ static unsigned char db9_saturn_read_packet(struct parport *port, unsigned char 
/*

 * db9_saturn_report() analyzes packet and reports.

 */

static int db9_saturn_report(unsigned char id, unsigned char data[60], struct input_dev *dev, int n, int max_pads)

static int db9_saturn_report(unsigned char id, unsigned char data[60], struct input_dev *devs[], int n, int max_pads)

{

	struct input_dev *dev;

	int tmp, i, j;



	tmp = (id == 0x41) ? 60 : 10;

	for (j = 0; (j < tmp) && (n < max_pads); j += 10, n++) {

	for (j = 0; j < tmp && n < max_pads; j += 10, n++) {

		dev = devs[n];

		switch (data[j]) {

		case 0x16: /* multi controller (analog 4 axis) */

			input_report_abs(dev + n, db9_abs[5], data[j + 6]);

			input_report_abs(dev, db9_abs[5], data[j + 6]);

		case 0x15: /* mission stick (analog 3 axis) */

			input_report_abs(dev + n, db9_abs[3], data[j + 4]);

			input_report_abs(dev + n, db9_abs[4], data[j + 5]);

			input_report_abs(dev, db9_abs[3], data[j + 4]);

			input_report_abs(dev, db9_abs[4], data[j + 5]);

		case 0x13: /* racing controller (analog 1 axis) */

			input_report_abs(dev + n, db9_abs[2], data[j + 3]);

			input_report_abs(dev, db9_abs[2], data[j + 3]);

		case 0x34: /* saturn keyboard (udlr ZXC ASD QE Esc) */

		case 0x02: /* digital pad (digital 2 axis + buttons) */

			input_report_abs(dev + n, db9_abs[0], !(data[j + 1] & 128) - !(data[j + 1] & 64));

			input_report_abs(dev + n, db9_abs[1], !(data[j + 1] & 32) - !(data[j + 1] & 16));

			input_report_abs(dev, db9_abs[0], !(data[j + 1] & 128) - !(data[j + 1] & 64));

			input_report_abs(dev, db9_abs[1], !(data[j + 1] & 32) - !(data[j + 1] & 16));

			for (i = 0; i < 9; i++)

				input_report_key(dev + n, db9_cd32_btn[i], ~data[j + db9_saturn_byte[i]] & db9_saturn_mask[i]);

				input_report_key(dev, db9_cd32_btn[i], ~data[j + db9_saturn_byte[i]] & db9_saturn_mask[i]);

			break;

		case 0x19: /* mission stick x2 (analog 6 axis + buttons) */

			input_report_abs(dev + n, db9_abs[0], !(data[j + 1] & 128) - !(data[j + 1] & 64));

			input_report_abs(dev + n, db9_abs[1], !(data[j + 1] & 32) - !(data[j + 1] & 16));

			input_report_abs(dev, db9_abs[0], !(data[j + 1] & 128) - !(data[j + 1] & 64));

			input_report_abs(dev, db9_abs[1], !(data[j + 1] & 32) - !(data[j + 1] & 16));

			for (i = 0; i < 9; i++)

				input_report_key(dev + n, db9_cd32_btn[i], ~data[j + db9_saturn_byte[i]] & db9_saturn_mask[i]);

			input_report_abs(dev + n, db9_abs[2], data[j + 3]);

			input_report_abs(dev + n, db9_abs[3], data[j + 4]);

			input_report_abs(dev + n, db9_abs[4], data[j + 5]);

				input_report_key(dev, db9_cd32_btn[i], ~data[j + db9_saturn_byte[i]] & db9_saturn_mask[i]);

			input_report_abs(dev, db9_abs[2], data[j + 3]);

			input_report_abs(dev, db9_abs[3], data[j + 4]);

			input_report_abs(dev, db9_abs[4], data[j + 5]);

			/*

			input_report_abs(dev + n, db9_abs[8], (data[j + 6] & 128 ? 0 : 1) - (data[j + 6] & 64 ? 0 : 1));

			input_report_abs(dev + n, db9_abs[9], (data[j + 6] & 32 ? 0 : 1) - (data[j + 6] & 16 ? 0 : 1));

			input_report_abs(dev, db9_abs[8], (data[j + 6] & 128 ? 0 : 1) - (data[j + 6] & 64 ? 0 : 1));

			input_report_abs(dev, db9_abs[9], (data[j + 6] & 32 ? 0 : 1) - (data[j + 6] & 16 ? 0 : 1));

			*/

			input_report_abs(dev + n, db9_abs[6], data[j + 7]);

			input_report_abs(dev + n, db9_abs[7], data[j + 8]);

			input_report_abs(dev + n, db9_abs[5], data[j + 9]);

			input_report_abs(dev, db9_abs[6], data[j + 7]);

			input_report_abs(dev, db9_abs[7], data[j + 8]);

			input_report_abs(dev, db9_abs[5], data[j + 9]);

			break;

		case 0xd3: /* sankyo ff (analog 1 axis + stop btn) */

			input_report_key(dev + n, BTN_A, data[j + 3] & 0x80);

			input_report_abs(dev + n, db9_abs[2], data[j + 3] & 0x7f);

			input_report_key(dev, BTN_A, data[j + 3] & 0x80);

			input_report_abs(dev, db9_abs[2], data[j + 3] & 0x7f);

			break;

		case 0xe3: /* shuttle mouse (analog 2 axis + buttons. signed value) */

			input_report_key(dev + n, BTN_START, data[j + 1] & 0x08);

			input_report_key(dev + n, BTN_A, data[j + 1] & 0x04);

			input_report_key(dev + n, BTN_C, data[j + 1] & 0x02);

			input_report_key(dev + n, BTN_B, data[j + 1] & 0x01);

			input_report_abs(dev + n, db9_abs[2], data[j + 2] ^ 0x80);

			input_report_abs(dev + n, db9_abs[3], (0xff-(data[j + 3] ^ 0x80))+1); /* */

			input_report_key(dev, BTN_START, data[j + 1] & 0x08);

			input_report_key(dev, BTN_A, data[j + 1] & 0x04);

			input_report_key(dev, BTN_C, data[j + 1] & 0x02);

			input_report_key(dev, BTN_B, data[j + 1] & 0x01);

			input_report_abs(dev, db9_abs[2], data[j + 2] ^ 0x80);

			input_report_abs(dev, db9_abs[3], (0xff-(data[j + 3] ^ 0x80))+1); /* */

			break;

		case 0xff:

		default: /* no pad */

			input_report_abs(dev + n, db9_abs[0], 0);

			input_report_abs(dev + n, db9_abs[1], 0);

			input_report_abs(dev, db9_abs[0], 0);

			input_report_abs(dev, db9_abs[1], 0);

			for (i = 0; i < 9; i++)

				input_report_key(dev + n, db9_cd32_btn[i], 0);

				input_report_key(dev, db9_cd32_btn[i], 0);

			break;

		}

	}

	return n;

}



static int db9_saturn(int mode, struct parport *port, struct input_dev *dev)

static int db9_saturn(int mode, struct parport *port, struct input_dev *devs[])

{

	unsigned char id, data[60];

	int type, n, max_pads;
@@ -361,7 +363,7 @@ static int db9_saturn(int mode, struct parport *port, struct input_dev *dev) 
	max_pads = min(db9_modes[mode].n_pads, DB9_MAX_DEVICES);

	for (tmp = 0, i = 0; i < n; i++) {

		id = db9_saturn_read_packet(port, data, type + i, 1);

		tmp = db9_saturn_report(id, data, dev, tmp, max_pads);

		tmp = db9_saturn_report(id, data, devs, tmp, max_pads);

	}

	return 0;

}
@@ -489,7 +491,7 @@ static void db9_timer(unsigned long private) 
		case DB9_SATURN_DPP:

		case DB9_SATURN_DPP_2:



			db9_saturn(db9->mode, port, dev);

			db9_saturn(db9->mode, port, db9->dev);

			break;



		case DB9_CD32_PAD:
@@ -614,7 +616,7 @@ static struct db9 __init *db9_probe(int parport, int mode) 
		if (!input_dev) {

			printk(KERN_ERR "db9.c: Not enough memory for input device\n");

			err = -ENOMEM;

			goto err_free_devs;

			goto err_unreg_devs;

		}



		sprintf(db9->phys[i], "%s/input%d", db9->pd->port->name, i);
@@ -640,13 +642,17 @@ static struct db9 __init *db9_probe(int parport, int mode) 
				input_set_abs_params(input_dev, db9_abs[j], 1, 255, 0, 0);

		}



		input_register_device(input_dev);

		err = input_register_device(input_dev);

		if (err)

			goto err_free_dev;

	}



	parport_put_port(pp);

	return db9;



 err_free_devs:

 err_free_dev:

	input_free_device(db9->dev[i]);

 err_unreg_devs:

	while (--i >= 0)

		input_unregister_device(db9->dev[i]);

	kfree(db9);
@@ -658,7 +664,7 @@ static struct db9 __init *db9_probe(int parport, int mode) 
	return ERR_PTR(err);

}



static void __exit db9_remove(struct db9 *db9)

static void db9_remove(struct db9 *db9)

{

	int i;
@@ -696,6 +702,7 @@ static int __init db9_init(void) 


	if (err) {

		while (--i >= 0)

			if (db9_base[i])

				db9_remove(db9_base[i]);

		return err;

	}

drivers/input/joystick/gamecon.c

+206 −155
Original line number Diff line number Diff line
@@ -159,6 +159,48 @@ static void gc_n64_read_packet(struct gc *gc, unsigned char *data) 


}



static void gc_n64_process_packet(struct gc *gc)

{

	unsigned char data[GC_N64_LENGTH];

	signed char axes[2];

	struct input_dev *dev;

	int i, j, s;



	gc_n64_read_packet(gc, data);



	for (i = 0; i < GC_MAX_DEVICES; i++) {



		dev = gc->dev[i];

		if (!dev)

			continue;



		s = gc_status_bit[i];



		if (s & gc->pads[GC_N64] & ~(data[8] | data[9])) {



			axes[0] = axes[1] = 0;



			for (j = 0; j < 8; j++) {

				if (data[23 - j] & s)

					axes[0] |= 1 << j;

				if (data[31 - j] & s)

					axes[1] |= 1 << j;

			}



			input_report_abs(dev, ABS_X,  axes[0]);

			input_report_abs(dev, ABS_Y, -axes[1]);



			input_report_abs(dev, ABS_HAT0X, !(s & data[6]) - !(s & data[7]));

			input_report_abs(dev, ABS_HAT0Y, !(s & data[4]) - !(s & data[5]));



			for (j = 0; j < 10; j++)

				input_report_key(dev, gc_n64_btn[j], s & data[gc_n64_bytes[j]]);



			input_sync(dev);

		}

	}

}



/*

 * NES/SNES support.

 */
@@ -198,6 +240,39 @@ static void gc_nes_read_packet(struct gc *gc, int length, unsigned char *data) 
	}

}



static void gc_nes_process_packet(struct gc *gc)

{

	unsigned char data[GC_SNES_LENGTH];

	struct input_dev *dev;

	int i, j, s;



	gc_nes_read_packet(gc, gc->pads[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH, data);



	for (i = 0; i < GC_MAX_DEVICES; i++) {



		dev = gc->dev[i];

		if (!dev)

			continue;



		s = gc_status_bit[i];



		if (s & (gc->pads[GC_NES] | gc->pads[GC_SNES])) {

			input_report_abs(dev, ABS_X, !(s & data[6]) - !(s & data[7]));

			input_report_abs(dev, ABS_Y, !(s & data[4]) - !(s & data[5]));

		}



		if (s & gc->pads[GC_NES])

			for (j = 0; j < 4; j++)

				input_report_key(dev, gc_snes_btn[j], s & data[gc_nes_bytes[j]]);



		if (s & gc->pads[GC_SNES])

			for (j = 0; j < 8; j++)

				input_report_key(dev, gc_snes_btn[j], s & data[gc_snes_bytes[j]]);



		input_sync(dev);

	}

}



/*

 * Multisystem joystick support

 */
@@ -219,6 +294,35 @@ static void gc_multi_read_packet(struct gc *gc, int length, unsigned char *data) 
	}

}



static void gc_multi_process_packet(struct gc *gc)

{

	unsigned char data[GC_MULTI2_LENGTH];

	struct input_dev *dev;

	int i, s;



	gc_multi_read_packet(gc, gc->pads[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH, data);



	for (i = 0; i < GC_MAX_DEVICES; i++) {



		dev = gc->dev[i];

		if (!dev)

			continue;



		s = gc_status_bit[i];



		if (s & (gc->pads[GC_MULTI] | gc->pads[GC_MULTI2])) {

			input_report_abs(dev, ABS_X,  !(s & data[2]) - !(s & data[3]));

			input_report_abs(dev, ABS_Y,  !(s & data[0]) - !(s & data[1]));

			input_report_key(dev, BTN_TRIGGER, s & data[4]);

		}



		if (s & gc->pads[GC_MULTI2])

			input_report_key(dev, BTN_THUMB, s & data[5]);



		input_sync(dev);

	}

}



/*

 * PSX support

 *
@@ -263,10 +367,11 @@ static short gc_psx_ddr_btn[] = { BTN_0, BTN_1, BTN_2, BTN_3 }; 
 * the psx pad.

 */



static void gc_psx_command(struct gc *gc, int b, unsigned char data[5])

static void gc_psx_command(struct gc *gc, int b, unsigned char data[GC_MAX_DEVICES])

{

	int i, j, cmd, read;

	for (i = 0; i < 5; i++)



	for (i = 0; i < GC_MAX_DEVICES; i++)

		data[i] = 0;



	for (i = 0; i < GC_PSX_LENGTH; i++, b >>= 1) {
@@ -274,7 +379,7 @@ static void gc_psx_command(struct gc *gc, int b, unsigned char data[5]) 
		parport_write_data(gc->pd->port, cmd | GC_PSX_POWER);

		udelay(gc_psx_delay);

		read = parport_read_status(gc->pd->port) ^ 0x80;

		for (j = 0; j < 5; j++)

		for (j = 0; j < GC_MAX_DEVICES; j++)

			data[j] |= (read & gc_status_bit[j] & (gc->pads[GC_PSX] | gc->pads[GC_DDR])) ? (1 << i) : 0;

		parport_write_data(gc->pd->port, cmd | GC_PSX_CLOCK | GC_PSX_POWER);

		udelay(gc_psx_delay);
@@ -286,11 +391,12 @@ static void gc_psx_command(struct gc *gc, int b, unsigned char data[5]) 
 * device identifier code.

 */



static void gc_psx_read_packet(struct gc *gc, unsigned char data[5][GC_PSX_BYTES], unsigned char id[5])

static void gc_psx_read_packet(struct gc *gc, unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES],

			       unsigned char id[GC_MAX_DEVICES])

{

	int i, j, max_len = 0;

	unsigned long flags;

	unsigned char data2[5];

	unsigned char data2[GC_MAX_DEVICES];



	parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);	/* Select pad */

	udelay(gc_psx_delay);
@@ -303,7 +409,7 @@ static void gc_psx_read_packet(struct gc *gc, unsigned char data[5][GC_PSX_BYTES 
	gc_psx_command(gc, 0x42, id);							/* Get device ids */

	gc_psx_command(gc, 0, data2);							/* Dump status */



	for (i =0; i < 5; i++)								/* Find the longest pad */

	for (i =0; i < GC_MAX_DEVICES; i++)								/* Find the longest pad */

		if((gc_status_bit[i] & (gc->pads[GC_PSX] | gc->pads[GC_DDR]))

			&& (GC_PSX_LEN(id[i]) > max_len)

			&& (GC_PSX_LEN(id[i]) <= GC_PSX_BYTES))
@@ -311,7 +417,7 @@ static void gc_psx_read_packet(struct gc *gc, unsigned char data[5][GC_PSX_BYTES 


	for (i = 0; i < max_len; i++) {						/* Read in all the data */

		gc_psx_command(gc, 0, data2);

		for (j = 0; j < 5; j++)

		for (j = 0; j < GC_MAX_DEVICES; j++)

			data[j][i] = data2[j];

	}
@@ -319,164 +425,67 @@ static void gc_psx_read_packet(struct gc *gc, unsigned char data[5][GC_PSX_BYTES 


	parport_write_data(gc->pd->port, GC_PSX_CLOCK | GC_PSX_SELECT | GC_PSX_POWER);



	for(i = 0; i < 5; i++)								/* Set id's to the real value */

	for(i = 0; i < GC_MAX_DEVICES; i++)								/* Set id's to the real value */

		id[i] = GC_PSX_ID(id[i]);

}



/*

 * gc_timer() reads and analyzes console pads data.

 */



#define GC_MAX_LENGTH GC_N64_LENGTH



static void gc_timer(unsigned long private)

static void gc_psx_process_packet(struct gc *gc)

{

	struct gc *gc = (void *) private;

	unsigned char data[GC_MAX_LENGTH];

	unsigned char data_psx[5][GC_PSX_BYTES];

	int i, j, s;



/*

 * N64 pads - must be read first, any read confuses them for 200 us

 */



	if (gc->pads[GC_N64]) {



		gc_n64_read_packet(gc, data);



		for (i = 0; i < 5; i++) {



			s = gc_status_bit[i];



			if (s & gc->pads[GC_N64] & ~(data[8] | data[9])) {



				signed char axes[2];

				axes[0] = axes[1] = 0;



				for (j = 0; j < 8; j++) {

					if (data[23 - j] & s) axes[0] |= 1 << j;

					if (data[31 - j] & s) axes[1] |= 1 << j;

				}



				input_report_abs(gc->dev[i], ABS_X,  axes[0]);

				input_report_abs(gc->dev[i], ABS_Y, -axes[1]);



				input_report_abs(gc->dev[i], ABS_HAT0X, !(s & data[6]) - !(s & data[7]));

				input_report_abs(gc->dev[i], ABS_HAT0Y, !(s & data[4]) - !(s & data[5]));



				for (j = 0; j < 10; j++)

					input_report_key(gc->dev[i], gc_n64_btn[j], s & data[gc_n64_bytes[j]]);



				input_sync(gc->dev[i]);

			}

		}

	}



/*

 * NES and SNES pads

 */



	if (gc->pads[GC_NES] || gc->pads[GC_SNES]) {



		gc_nes_read_packet(gc, gc->pads[GC_SNES] ? GC_SNES_LENGTH : GC_NES_LENGTH, data);



		for (i = 0; i < 5; i++) {



			s = gc_status_bit[i];



			if (s & (gc->pads[GC_NES] | gc->pads[GC_SNES])) {

				input_report_abs(gc->dev[i], ABS_X, !(s & data[6]) - !(s & data[7]));

				input_report_abs(gc->dev[i], ABS_Y, !(s & data[4]) - !(s & data[5]));

			}



			if (s & gc->pads[GC_NES])

				for (j = 0; j < 4; j++)

					input_report_key(gc->dev[i], gc_snes_btn[j], s & data[gc_nes_bytes[j]]);



			if (s & gc->pads[GC_SNES])

				for (j = 0; j < 8; j++)

					input_report_key(gc->dev[i], gc_snes_btn[j], s & data[gc_snes_bytes[j]]);



			input_sync(gc->dev[i]);

		}

	}

	unsigned char data[GC_MAX_DEVICES][GC_PSX_BYTES];

	unsigned char id[GC_MAX_DEVICES];

	struct input_dev *dev;

	int i, j;



/*

 * Multi and Multi2 joysticks

 */

	gc_psx_read_packet(gc, data, id);



	if (gc->pads[GC_MULTI] || gc->pads[GC_MULTI2]) {

	for (i = 0; i < GC_MAX_DEVICES; i++) {



		gc_multi_read_packet(gc, gc->pads[GC_MULTI2] ? GC_MULTI2_LENGTH : GC_MULTI_LENGTH, data);



		for (i = 0; i < 5; i++) {



			s = gc_status_bit[i];



			if (s & (gc->pads[GC_MULTI] | gc->pads[GC_MULTI2])) {

				input_report_abs(gc->dev[i], ABS_X,  !(s & data[2]) - !(s & data[3]));

				input_report_abs(gc->dev[i], ABS_Y,  !(s & data[0]) - !(s & data[1]));

				input_report_key(gc->dev[i], BTN_TRIGGER, s & data[4]);

			}



			if (s & gc->pads[GC_MULTI2])

				input_report_key(gc->dev[i], BTN_THUMB, s & data[5]);



			input_sync(gc->dev[i]);

		}

	}



/*

 * PSX controllers

 */



	if (gc->pads[GC_PSX] || gc->pads[GC_DDR]) {



		gc_psx_read_packet(gc, data_psx, data);

		dev = gc->dev[i];

		if (!dev)

			continue;



		for (i = 0; i < 5; i++) {

			switch (data[i]) {

		switch (id[i]) {



			case GC_PSX_RUMBLE:



					input_report_key(gc->dev[i], BTN_THUMBL, ~data_psx[i][0] & 0x04);

					input_report_key(gc->dev[i], BTN_THUMBR, ~data_psx[i][0] & 0x02);

				input_report_key(dev, BTN_THUMBL, ~data[i][0] & 0x04);

				input_report_key(dev, BTN_THUMBR, ~data[i][0] & 0x02);



			case GC_PSX_NEGCON:

			case GC_PSX_ANALOG:



				if (gc->pads[GC_DDR] & gc_status_bit[i]) {

					for(j = 0; j < 4; j++)

							input_report_key(gc->dev[i], gc_psx_ddr_btn[j], ~data_psx[i][0] & (0x10 << j));

						input_report_key(dev, gc_psx_ddr_btn[j], ~data[i][0] & (0x10 << j));

				} else {

					for (j = 0; j < 4; j++)

							input_report_abs(gc->dev[i], gc_psx_abs[j+2], data_psx[i][j + 2]);

						input_report_abs(dev, gc_psx_abs[j + 2], data[i][j + 2]);



						input_report_abs(gc->dev[i], ABS_X, 128 + !(data_psx[i][0] & 0x20) * 127 - !(data_psx[i][0] & 0x80) * 128);

						input_report_abs(gc->dev[i], ABS_Y, 128 + !(data_psx[i][0] & 0x40) * 127 - !(data_psx[i][0] & 0x10) * 128);

					input_report_abs(dev, ABS_X, 128 + !(data[i][0] & 0x20) * 127 - !(data[i][0] & 0x80) * 128);

					input_report_abs(dev, ABS_Y, 128 + !(data[i][0] & 0x40) * 127 - !(data[i][0] & 0x10) * 128);

				}



				for (j = 0; j < 8; j++)

						input_report_key(gc->dev[i], gc_psx_btn[j], ~data_psx[i][1] & (1 << j));

					input_report_key(dev, gc_psx_btn[j], ~data[i][1] & (1 << j));



					input_report_key(gc->dev[i], BTN_START,  ~data_psx[i][0] & 0x08);

					input_report_key(gc->dev[i], BTN_SELECT, ~data_psx[i][0] & 0x01);

				input_report_key(dev, BTN_START,  ~data[i][0] & 0x08);

				input_report_key(dev, BTN_SELECT, ~data[i][0] & 0x01);



					input_sync(gc->dev[i]);

				input_sync(dev);



				break;



			case GC_PSX_NORMAL:

				if (gc->pads[GC_DDR] & gc_status_bit[i]) {

					for(j = 0; j < 4; j++)

							input_report_key(gc->dev[i], gc_psx_ddr_btn[j], ~data_psx[i][0] & (0x10 << j));

						input_report_key(dev, gc_psx_ddr_btn[j], ~data[i][0] & (0x10 << j));

				} else {

						input_report_abs(gc->dev[i], ABS_X, 128 + !(data_psx[i][0] & 0x20) * 127 - !(data_psx[i][0] & 0x80) * 128);

						input_report_abs(gc->dev[i], ABS_Y, 128 + !(data_psx[i][0] & 0x40) * 127 - !(data_psx[i][0] & 0x10) * 128);

					input_report_abs(dev, ABS_X, 128 + !(data[i][0] & 0x20) * 127 - !(data[i][0] & 0x80) * 128);

					input_report_abs(dev, ABS_Y, 128 + !(data[i][0] & 0x40) * 127 - !(data[i][0] & 0x10) * 128);



					/* for some reason if the extra axes are left unset they drift */

					/* for (j = 0; j < 4; j++)

							input_report_abs(gc->dev[i], gc_psx_abs[j+2], 128);

						input_report_abs(dev, gc_psx_abs[j + 2], 128);

					 * This needs to be debugged properly,

					 * maybe fuzz processing needs to be done in input_sync()

					 *				 --vojtech
@@ -484,12 +493,12 @@ static void gc_timer(unsigned long private) 
				}



				for (j = 0; j < 8; j++)

						input_report_key(gc->dev[i], gc_psx_btn[j], ~data_psx[i][1] & (1 << j));

					input_report_key(dev, gc_psx_btn[j], ~data[i][1] & (1 << j));



					input_report_key(gc->dev[i], BTN_START,  ~data_psx[i][0] & 0x08);

					input_report_key(gc->dev[i], BTN_SELECT, ~data_psx[i][0] & 0x01);

				input_report_key(dev, BTN_START,  ~data[i][0] & 0x08);

				input_report_key(dev, BTN_SELECT, ~data[i][0] & 0x01);



					input_sync(gc->dev[i]);

				input_sync(dev);



				break;
@@ -499,6 +508,42 @@ static void gc_timer(unsigned long private) 
	}

}



/*

 * gc_timer() initiates reads of console pads data.

 */



static void gc_timer(unsigned long private)

{

	struct gc *gc = (void *) private;



/*

 * N64 pads - must be read first, any read confuses them for 200 us

 */



	if (gc->pads[GC_N64])

		gc_n64_process_packet(gc);



/*

 * NES and SNES pads

 */



	if (gc->pads[GC_NES] || gc->pads[GC_SNES])

		gc_nes_process_packet(gc);



/*

 * Multi and Multi2 joysticks

 */



	if (gc->pads[GC_MULTI] || gc->pads[GC_MULTI2])

		gc_multi_process_packet(gc);



/*

 * PSX controllers

 */



	if (gc->pads[GC_PSX] || gc->pads[GC_DDR])

		gc_psx_process_packet(gc);



	mod_timer(&gc->timer, jiffies + GC_REFRESH_TIME);

}
@@ -654,16 +699,18 @@ static struct gc __init *gc_probe(int parport, int *pads, int n_pads) 
	gc->timer.data = (long) gc;

	gc->timer.function = gc_timer;



	for (i = 0; i < n_pads; i++) {

	for (i = 0; i < n_pads && i < GC_MAX_DEVICES; i++) {

		if (!pads[i])

			continue;



		sprintf(gc->phys[i], "%s/input%d", gc->pd->port->name, i);

		err = gc_setup_pad(gc, i, pads[i]);

		if (err)

			goto err_free_devs;

			goto err_unreg_devs;



		input_register_device(gc->dev[i]);

		err = input_register_device(gc->dev[i]);

		if (err)

			goto err_free_dev;

	}



	if (!gc->pads[0]) {
@@ -675,8 +722,11 @@ static struct gc __init *gc_probe(int parport, int *pads, int n_pads) 
	parport_put_port(pp);

	return gc;



 err_free_devs:

 err_free_dev:

	input_free_device(gc->dev[i]);

 err_unreg_devs:

	while (--i >= 0)

		if (gc->dev[i])

			input_unregister_device(gc->dev[i]);

 err_free_gc:

	kfree(gc);
@@ -688,7 +738,7 @@ static struct gc __init *gc_probe(int parport, int *pads, int n_pads) 
	return ERR_PTR(err);

}



static void __exit gc_remove(struct gc *gc)

static void gc_remove(struct gc *gc)

{

	int i;
@@ -726,6 +776,7 @@ static int __init gc_init(void) 


	if (err) {

		while (--i >= 0)

			if (gc_base[i])

				gc_remove(gc_base[i]);

		return err;

	}

drivers/input/joystick/grip.c

+9 −2
Original line number Diff line number Diff line
@@ -192,6 +192,9 @@ static void grip_poll(struct gameport *gameport) 
	for (i = 0; i < 2; i++) {



		dev = grip->dev[i];

		if (!dev)

			continue;



		grip->reads++;



		switch (grip->mode[i]) {
@@ -381,12 +384,15 @@ static int grip_connect(struct gameport *gameport, struct gameport_driver *drv) 
			if (t > 0)

				set_bit(t, input_dev->keybit);



		input_register_device(grip->dev[i]);

		err = input_register_device(grip->dev[i]);

		if (err)

			goto fail4;

	}



	return 0;



 fail3: for (i = 0; i < 2; i++)

 fail4:	input_free_device(grip->dev[i]);

 fail3:	while (--i >= 0)

		if (grip->dev[i])

			input_unregister_device(grip->dev[i]);

 fail2:	gameport_close(gameport);
@@ -411,6 +417,7 @@ static void grip_disconnect(struct gameport *gameport) 
static struct gameport_driver grip_drv = {

	.driver		= {

		.name	= "grip",

		.owner	= THIS_MODULE,

	},

	.description	= DRIVER_DESC,

	.connect	= grip_connect,

drivers/input/joystick/iforce/iforce-main.c

+1 −1
Original line number Diff line number Diff line
@@ -345,7 +345,7 @@ int iforce_init_device(struct iforce *iforce) 
	int i;



	input_dev = input_allocate_device();

	if (input_dev)

	if (!input_dev)

		return -ENOMEM;



	init_waitqueue_head(&iforce->wait);