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

Commit 3c42f0c3 authored by Dmitry Torokhov's avatar Dmitry Torokhov Committed by Greg Kroah-Hartman
Browse files

[PATCH] drivers/input/keyboard: convert to dynamic input_dev allocation 



Input: convert drivers/input/keyboard to dynamic input_dev allocation

This is required for input_dev sysfs integration

Signed-off-by: default avatarDmitry Torokhov <dtor@mail.ru>
Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@suse.de>
parent 2e5b636b

drivers/input/keyboard/amikbd.c

+29 −30
Original line number Diff line number Diff line
@@ -155,10 +155,7 @@ static const char *amikbd_messages[8] = { 
	[7] = KERN_WARNING "amikbd: keyboard interrupt\n"

};



static struct input_dev amikbd_dev;



static char *amikbd_name = "Amiga keyboard";

static char *amikbd_phys = "amikbd/input0";

static struct input_dev *amikbd_dev;



static irqreturn_t amikbd_interrupt(int irq, void *dummy, struct pt_regs *fp)

{
@@ -176,16 +173,16 @@ static irqreturn_t amikbd_interrupt(int irq, void *dummy, struct pt_regs *fp) 


		scancode = amikbd_keycode[scancode];



		input_regs(&amikbd_dev, fp);

		input_regs(amikbd_dev, fp);



		if (scancode == KEY_CAPSLOCK) {	/* CapsLock is a toggle switch key on Amiga */

			input_report_key(&amikbd_dev, scancode, 1);

			input_report_key(&amikbd_dev, scancode, 0);

			input_sync(&amikbd_dev);

			input_report_key(amikbd_dev, scancode, 1);

			input_report_key(amikbd_dev, scancode, 0);

		} else {

			input_report_key(&amikbd_dev, scancode, down);

			input_sync(&amikbd_dev);

			input_report_key(amikbd_dev, scancode, down);

		}



		input_sync(amikbd_dev);

	} else				/* scancodes >= 0x78 are error codes */

		printk(amikbd_messages[scancode - 0x78]);
@@ -202,38 +199,40 @@ static int __init amikbd_init(void) 
	if (!request_mem_region(CIAA_PHYSADDR-1+0xb00, 0x100, "amikeyb"))

		return -EBUSY;



	init_input_dev(&amikbd_dev);

	amikbd_dev = input_dev_allocate();

	if (!amikbd_dev) {

		printk(KERN_ERR "amikbd: not enough memory for input device\n");

		release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100);

		return -ENOMEM;

	}



	amikbd_dev->name = "Amiga Keyboard";

	amikbd_dev->phys = "amikbd/input0";

	amikbd_dev->id.bustype = BUS_AMIGA;

	amikbd_dev->id.vendor = 0x0001;

	amikbd_dev->id.product = 0x0001;

	amikbd_dev->id.version = 0x0100;



	amikbd_dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP);

	amikbd_dev.keycode = amikbd_keycode;

	amikbd_dev.keycodesize = sizeof(unsigned char);

	amikbd_dev.keycodemax = ARRAY_SIZE(amikbd_keycode);

	amikbd_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP);

	amikbd_dev->keycode = amikbd_keycode;

	amikbd_dev->keycodesize = sizeof(unsigned char);

	amikbd_dev->keycodemax = ARRAY_SIZE(amikbd_keycode);



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

		if (amikbd_keycode[i])

			set_bit(amikbd_keycode[i], amikbd_dev.keybit);

			set_bit(amikbd_keycode[i], amikbd_dev->keybit);



	ciaa.cra &= ~0x41;	 /* serial data in, turn off TA */

	request_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt, 0, "amikbd", amikbd_interrupt);



	amikbd_dev.name = amikbd_name;

	amikbd_dev.phys = amikbd_phys;

	amikbd_dev.id.bustype = BUS_AMIGA;

	amikbd_dev.id.vendor = 0x0001;

	amikbd_dev.id.product = 0x0001;

	amikbd_dev.id.version = 0x0100;



	input_register_device(&amikbd_dev);



	printk(KERN_INFO "input: %s\n", amikbd_name);



	input_register_device(amikbd_dev);

	return 0;

}



static void __exit amikbd_exit(void)

{

	input_unregister_device(&amikbd_dev);

	free_irq(IRQ_AMIGA_CIAA_SP, amikbd_interrupt);

	input_unregister_device(amikbd_dev);

	release_mem_region(CIAA_PHYSADDR - 1 + 0xb00, 0x100);

}

drivers/input/keyboard/atkbd.c

+102 −86
Original line number Diff line number Diff line
@@ -186,11 +186,11 @@ static struct { 
struct atkbd {



	struct ps2dev ps2dev;

	struct input_dev *dev;



	/* Written only during init */

	char name[64];

	char phys[32];

	struct input_dev dev;



	unsigned short id;

	unsigned char keycode[512];
@@ -290,7 +290,7 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 
	if (!atkbd->enabled)

		goto out;



	input_event(&atkbd->dev, EV_MSC, MSC_RAW, code);

	input_event(atkbd->dev, EV_MSC, MSC_RAW, code);



	if (atkbd->translated) {
@@ -326,10 +326,10 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 
			atkbd->release = 1;

			goto out;

		case ATKBD_RET_HANGUEL:

			atkbd_report_key(&atkbd->dev, regs, KEY_HANGUEL, 3);

			atkbd_report_key(atkbd->dev, regs, KEY_HANGUEL, 3);

			goto out;

		case ATKBD_RET_HANJA:

			atkbd_report_key(&atkbd->dev, regs, KEY_HANJA, 3);

			atkbd_report_key(atkbd->dev, regs, KEY_HANJA, 3);

			goto out;

		case ATKBD_RET_ERR:

			printk(KERN_DEBUG "atkbd.c: Keyboard on %s reports too many keys pressed.\n", serio->phys);
@@ -345,7 +345,7 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 
	}



	if (atkbd->keycode[code] != ATKBD_KEY_NULL)

		input_event(&atkbd->dev, EV_MSC, MSC_SCAN, code);

		input_event(atkbd->dev, EV_MSC, MSC_SCAN, code);



	switch (atkbd->keycode[code]) {

		case ATKBD_KEY_NULL:
@@ -365,7 +365,7 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 
				       "to make it known.\n",

				       code & 0x80 ? "e0" : "", code & 0x7f);

			}

			input_sync(&atkbd->dev);

			input_sync(atkbd->dev);

			break;

		case ATKBD_SCR_1:

			scroll = 1 - atkbd->release * 2;
@@ -390,7 +390,7 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 
			break;

		default:

			value = atkbd->release ? 0 :

				(1 + (!atkbd->softrepeat && test_bit(atkbd->keycode[code], atkbd->dev.key)));

				(1 + (!atkbd->softrepeat && test_bit(atkbd->keycode[code], atkbd->dev->key)));



			switch (value) {	/* Workaround Toshiba laptop multiple keypress */

				case 0:
@@ -398,7 +398,7 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 
					break;

				case 1:

					atkbd->last = code;

					atkbd->time = jiffies + msecs_to_jiffies(atkbd->dev.rep[REP_DELAY]) / 2;

					atkbd->time = jiffies + msecs_to_jiffies(atkbd->dev->rep[REP_DELAY]) / 2;

					break;

				case 2:

					if (!time_after(jiffies, atkbd->time) && atkbd->last == code)
@@ -406,16 +406,16 @@ static irqreturn_t atkbd_interrupt(struct serio *serio, unsigned char data, 
					break;

			}



			atkbd_report_key(&atkbd->dev, regs, atkbd->keycode[code], value);

			atkbd_report_key(atkbd->dev, regs, atkbd->keycode[code], value);

	}



	if (atkbd->scroll) {

		input_regs(&atkbd->dev, regs);

		input_regs(atkbd->dev, regs);

		if (click != -1)

			input_report_key(&atkbd->dev, BTN_MIDDLE, click);

		input_report_rel(&atkbd->dev, REL_WHEEL, scroll);

		input_report_rel(&atkbd->dev, REL_HWHEEL, hscroll);

		input_sync(&atkbd->dev);

			input_report_key(atkbd->dev, BTN_MIDDLE, click);

		input_report_rel(atkbd->dev, REL_WHEEL, scroll);

		input_report_rel(atkbd->dev, REL_HWHEEL, hscroll);

		input_sync(atkbd->dev);

	}



	atkbd->release = 0;
@@ -463,7 +463,6 @@ static int atkbd_event(struct input_dev *dev, unsigned int type, unsigned int co 


			return 0;





		case EV_REP:



			if (atkbd->softrepeat) return 0;
@@ -693,7 +692,7 @@ static void atkbd_disconnect(struct serio *serio) 
	device_remove_file(&serio->dev, &atkbd_attr_softrepeat);

	device_remove_file(&serio->dev, &atkbd_attr_softraw);



	input_unregister_device(&atkbd->dev);

	input_unregister_device(atkbd->dev);

	serio_close(serio);

	serio_set_drvdata(serio, NULL);

	kfree(atkbd);
@@ -701,7 +700,7 @@ static void atkbd_disconnect(struct serio *serio) 




/*

 * atkbd_set_device_attrs() initializes keyboard's keycode table

 * atkbd_set_keycode_table() initializes keyboard's keycode table

 * according to the selected scancode set

 */
@@ -737,53 +736,58 @@ static void atkbd_set_keycode_table(struct atkbd *atkbd) 


static void atkbd_set_device_attrs(struct atkbd *atkbd)

{

	struct input_dev *input_dev = atkbd->dev;

	int i;



	memset(&atkbd->dev, 0, sizeof(struct input_dev));

	if (atkbd->extra)

		sprintf(atkbd->name, "AT Set 2 Extra keyboard");

	else

		sprintf(atkbd->name, "AT %s Set %d keyboard",

			atkbd->translated ? "Translated" : "Raw", atkbd->set);



	init_input_dev(&atkbd->dev);

	sprintf(atkbd->phys, "%s/input0", atkbd->ps2dev.serio->phys);



	atkbd->dev.name = atkbd->name;

	atkbd->dev.phys = atkbd->phys;

	atkbd->dev.id.bustype = BUS_I8042;

	atkbd->dev.id.vendor = 0x0001;

	atkbd->dev.id.product = atkbd->translated ? 1 : atkbd->set;

	atkbd->dev.id.version = atkbd->id;

	atkbd->dev.event = atkbd_event;

	atkbd->dev.private = atkbd;

	atkbd->dev.dev = &atkbd->ps2dev.serio->dev;

	input_dev->name = atkbd->name;

	input_dev->phys = atkbd->phys;

	input_dev->id.bustype = BUS_I8042;

	input_dev->id.vendor = 0x0001;

	input_dev->id.product = atkbd->translated ? 1 : atkbd->set;

	input_dev->id.version = atkbd->id;

	input_dev->event = atkbd_event;

	input_dev->private = atkbd;

	input_dev->cdev.dev = &atkbd->ps2dev.serio->dev;



	atkbd->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_MSC);

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



	if (atkbd->write) {

		atkbd->dev.evbit[0] |= BIT(EV_LED);

		atkbd->dev.ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);

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

		input_dev->ledbit[0] = BIT(LED_NUML) | BIT(LED_CAPSL) | BIT(LED_SCROLLL);

	}



	if (atkbd->extra)

		atkbd->dev.ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) |

		input_dev->ledbit[0] |= BIT(LED_COMPOSE) | BIT(LED_SUSPEND) |

					BIT(LED_SLEEP) | BIT(LED_MUTE) | BIT(LED_MISC);



	if (!atkbd->softrepeat) {

		atkbd->dev.rep[REP_DELAY] = 250;

		atkbd->dev.rep[REP_PERIOD] = 33;

		input_dev->rep[REP_DELAY] = 250;

		input_dev->rep[REP_PERIOD] = 33;

	}



	atkbd->dev.mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN);

	input_dev->mscbit[0] = atkbd->softraw ? BIT(MSC_SCAN) : BIT(MSC_RAW) | BIT(MSC_SCAN);



	if (atkbd->scroll) {

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

		atkbd->dev.relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL);

		set_bit(BTN_MIDDLE, atkbd->dev.keybit);

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

		input_dev->relbit[0] = BIT(REL_WHEEL) | BIT(REL_HWHEEL);

		set_bit(BTN_MIDDLE, input_dev->keybit);

	}



	atkbd->dev.keycode = atkbd->keycode;

	atkbd->dev.keycodesize = sizeof(unsigned char);

	atkbd->dev.keycodemax = ARRAY_SIZE(atkbd_set2_keycode);

	input_dev->keycode = atkbd->keycode;

	input_dev->keycodesize = sizeof(unsigned char);

	input_dev->keycodemax = ARRAY_SIZE(atkbd_set2_keycode);



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

		if (atkbd->keycode[i] && atkbd->keycode[i] < ATKBD_SPECIAL)

			set_bit(atkbd->keycode[i], atkbd->dev.keybit);

			set_bit(atkbd->keycode[i], input_dev->keybit);

}



/*
@@ -796,13 +800,15 @@ static void atkbd_set_device_attrs(struct atkbd *atkbd) 
static int atkbd_connect(struct serio *serio, struct serio_driver *drv)

{

	struct atkbd *atkbd;

	int err;



	if (!(atkbd = kmalloc(sizeof(struct atkbd), GFP_KERNEL)))

		return - ENOMEM;

	struct input_dev *dev;

	int err = -ENOMEM;



	memset(atkbd, 0, sizeof(struct atkbd));

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

	dev = input_allocate_device();

	if (!atkbd || !dev)

		goto fail;



	atkbd->dev = dev;

	ps2_init(&atkbd->ps2dev, serio);



	switch (serio->id.type) {
@@ -828,19 +834,15 @@ static int atkbd_connect(struct serio *serio, struct serio_driver *drv) 
	serio_set_drvdata(serio, atkbd);



	err = serio_open(serio, drv);

	if (err) {

		serio_set_drvdata(serio, NULL);

		kfree(atkbd);

		return err;

	}

	if (err)

		goto fail;



	if (atkbd->write) {



		if (atkbd_probe(atkbd)) {

			serio_close(serio);

			serio_set_drvdata(serio, NULL);

			kfree(atkbd);

			return -ENODEV;

			err = -ENODEV;

			goto fail;

		}



		atkbd->set = atkbd_select_set(atkbd, atkbd_set, atkbd_extra);
@@ -851,19 +853,9 @@ static int atkbd_connect(struct serio *serio, struct serio_driver *drv) 
		atkbd->id = 0xab00;

	}



	if (atkbd->extra)

		sprintf(atkbd->name, "AT Set 2 Extra keyboard");

	else

		sprintf(atkbd->name, "AT %s Set %d keyboard",

			atkbd->translated ? "Translated" : "Raw", atkbd->set);



	sprintf(atkbd->phys, "%s/input0", serio->phys);



	atkbd_set_keycode_table(atkbd);

	atkbd_set_device_attrs(atkbd);



	input_register_device(&atkbd->dev);



	device_create_file(&serio->dev, &atkbd_attr_extra);

	device_create_file(&serio->dev, &atkbd_attr_scroll);

	device_create_file(&serio->dev, &atkbd_attr_set);
@@ -872,9 +864,14 @@ static int atkbd_connect(struct serio *serio, struct serio_driver *drv) 


	atkbd_enable(atkbd);



	printk(KERN_INFO "input: %s on %s\n", atkbd->name, serio->phys);

	input_register_device(atkbd->dev);



	return 0;



 fail:	serio_set_drvdata(serio, NULL);

	input_free_device(dev);

	kfree(atkbd);

	return err;

}



/*
@@ -896,9 +893,9 @@ static int atkbd_reconnect(struct serio *serio) 
	atkbd_disable(atkbd);



	if (atkbd->write) {

		param[0] = (test_bit(LED_SCROLLL, atkbd->dev.led) ? 1 : 0)

		         | (test_bit(LED_NUML,    atkbd->dev.led) ? 2 : 0)

		         | (test_bit(LED_CAPSL,   atkbd->dev.led) ? 4 : 0);

		param[0] = (test_bit(LED_SCROLLL, atkbd->dev->led) ? 1 : 0)

		         | (test_bit(LED_NUML,    atkbd->dev->led) ? 2 : 0)

		         | (test_bit(LED_CAPSL,   atkbd->dev->led) ? 4 : 0);



		if (atkbd_probe(atkbd))

			return -1;
@@ -1008,6 +1005,7 @@ static ssize_t atkbd_show_extra(struct atkbd *atkbd, char *buf) 


static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t count)

{

	struct input_dev *new_dev;

	unsigned long value;

	char *rest;
@@ -1019,12 +1017,19 @@ static ssize_t atkbd_set_extra(struct atkbd *atkbd, const char *buf, size_t coun 
		return -EINVAL;



	if (atkbd->extra != value) {

		/* unregister device as it's properties will change */

		input_unregister_device(&atkbd->dev);

		/*

		 * Since device's properties will change we need to

		 * unregister old device. But allocate new one first

		 * to make sure we have it.

		 */

		if (!(new_dev = input_allocate_device()))

			return -ENOMEM;

		input_unregister_device(atkbd->dev);

		atkbd->dev = new_dev;

		atkbd->set = atkbd_select_set(atkbd, atkbd->set, value);

		atkbd_activate(atkbd);

		atkbd_set_device_attrs(atkbd);

		input_register_device(&atkbd->dev);

		input_register_device(atkbd->dev);

	}

	return count;

}
@@ -1036,6 +1041,7 @@ static ssize_t atkbd_show_scroll(struct atkbd *atkbd, char *buf) 


static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t count)

{

	struct input_dev *new_dev;

	unsigned long value;

	char *rest;
@@ -1044,12 +1050,14 @@ static ssize_t atkbd_set_scroll(struct atkbd *atkbd, const char *buf, size_t cou 
		return -EINVAL;



	if (atkbd->scroll != value) {

		/* unregister device as it's properties will change */

		input_unregister_device(&atkbd->dev);

		if (!(new_dev = input_allocate_device()))

			return -ENOMEM;

		input_unregister_device(atkbd->dev);

		atkbd->dev = new_dev;

		atkbd->scroll = value;

		atkbd_set_keycode_table(atkbd);

		atkbd_set_device_attrs(atkbd);

		input_register_device(&atkbd->dev);

		input_register_device(atkbd->dev);

	}

	return count;

}
@@ -1061,6 +1069,7 @@ static ssize_t atkbd_show_set(struct atkbd *atkbd, char *buf) 


static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count)

{

	struct input_dev *new_dev;

	unsigned long value;

	char *rest;
@@ -1072,13 +1081,15 @@ static ssize_t atkbd_set_set(struct atkbd *atkbd, const char *buf, size_t count) 
		return -EINVAL;



	if (atkbd->set != value) {

		/* unregister device as it's properties will change */

		input_unregister_device(&atkbd->dev);

		if (!(new_dev = input_allocate_device()))

			return -ENOMEM;

		input_unregister_device(atkbd->dev);

		atkbd->dev = new_dev;

		atkbd->set = atkbd_select_set(atkbd, value, atkbd->extra);

		atkbd_activate(atkbd);

		atkbd_set_keycode_table(atkbd);

		atkbd_set_device_attrs(atkbd);

		input_register_device(&atkbd->dev);

		input_register_device(atkbd->dev);

	}

	return count;

}
@@ -1090,6 +1101,7 @@ static ssize_t atkbd_show_softrepeat(struct atkbd *atkbd, char *buf) 


static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t count)

{

	struct input_dev *new_dev;

	unsigned long value;

	char *rest;
@@ -1101,15 +1113,16 @@ static ssize_t atkbd_set_softrepeat(struct atkbd *atkbd, const char *buf, size_t 
		return -EINVAL;



	if (atkbd->softrepeat != value) {

		/* unregister device as it's properties will change */

		input_unregister_device(&atkbd->dev);

		if (!(new_dev = input_allocate_device()))

			return -ENOMEM;

		input_unregister_device(atkbd->dev);

		atkbd->dev = new_dev;

		atkbd->softrepeat = value;

		if (atkbd->softrepeat)

			atkbd->softraw = 1;

		atkbd_set_device_attrs(atkbd);

		input_register_device(&atkbd->dev);

		input_register_device(atkbd->dev);

	}



	return count;

}
@@ -1121,6 +1134,7 @@ static ssize_t atkbd_show_softraw(struct atkbd *atkbd, char *buf) 


static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t count)

{

	struct input_dev *new_dev;

	unsigned long value;

	char *rest;
@@ -1129,11 +1143,13 @@ static ssize_t atkbd_set_softraw(struct atkbd *atkbd, const char *buf, size_t co 
		return -EINVAL;



	if (atkbd->softraw != value) {

		/* unregister device as it's properties will change */

		input_unregister_device(&atkbd->dev);

		if (!(new_dev = input_allocate_device()))

			return -ENOMEM;

		input_unregister_device(atkbd->dev);

		atkbd->dev = new_dev;

		atkbd->softraw = value;

		atkbd_set_device_attrs(atkbd);

		input_register_device(&atkbd->dev);

		input_register_device(atkbd->dev);

	}

	return count;

}

drivers/input/keyboard/corgikbd.c

+39 −35
Original line number Diff line number Diff line
@@ -70,8 +70,7 @@ static unsigned char corgikbd_keycode[NR_SCANCODES] = { 


struct corgikbd {

	unsigned char keycode[ARRAY_SIZE(corgikbd_keycode)];

	struct input_dev input;

	char phys[32];

	struct input_dev *input;



	spinlock_t lock;

	struct timer_list timer;
@@ -147,7 +146,7 @@ static void corgikbd_scankeyboard(struct corgikbd *corgikbd_data, struct pt_regs 
	spin_lock_irqsave(&corgikbd_data->lock, flags);



	if (regs)

		input_regs(&corgikbd_data->input, regs);

		input_regs(corgikbd_data->input, regs);



	num_pressed = 0;

	for (col = 0; col < KB_COLS; col++) {
@@ -169,14 +168,14 @@ static void corgikbd_scankeyboard(struct corgikbd *corgikbd_data, struct pt_regs 
			scancode = SCANCODE(row, col);

			pressed = rowd & KB_ROWMASK(row);



			input_report_key(&corgikbd_data->input, corgikbd_data->keycode[scancode], pressed);

			input_report_key(corgikbd_data->input, corgikbd_data->keycode[scancode], pressed);



			if (pressed)

				num_pressed++;



			if (pressed && (corgikbd_data->keycode[scancode] == CORGI_KEY_OFF)

					&& time_after(jiffies, corgikbd_data->suspend_jiffies + HZ)) {

				input_event(&corgikbd_data->input, EV_PWR, CORGI_KEY_OFF, 1);

				input_event(corgikbd_data->input, EV_PWR, CORGI_KEY_OFF, 1);

				corgikbd_data->suspend_jiffies=jiffies;

			}

		}
@@ -185,7 +184,7 @@ static void corgikbd_scankeyboard(struct corgikbd *corgikbd_data, struct pt_regs 


	corgikbd_activate_all();



	input_sync(&corgikbd_data->input);

	input_sync(corgikbd_data->input);



	/* if any keys are pressed, enable the timer */

	if (num_pressed)
@@ -249,9 +248,9 @@ static void corgikbd_hinge_timer(unsigned long data) 
		if (hinge_count >= HINGE_STABLE_COUNT) {

			spin_lock_irqsave(&corgikbd_data->lock, flags);



			input_report_switch(&corgikbd_data->input, SW_0, ((sharpsl_hinge_state & CORGI_SCP_SWA) != 0));

			input_report_switch(&corgikbd_data->input, SW_1, ((sharpsl_hinge_state & CORGI_SCP_SWB) != 0));

			input_sync(&corgikbd_data->input);

			input_report_switch(corgikbd_data->input, SW_0, ((sharpsl_hinge_state & CORGI_SCP_SWA) != 0));

			input_report_switch(corgikbd_data->input, SW_1, ((sharpsl_hinge_state & CORGI_SCP_SWB) != 0));

			input_sync(corgikbd_data->input);



			spin_unlock_irqrestore(&corgikbd_data->lock, flags);

		}
@@ -287,16 +286,21 @@ static int corgikbd_resume(struct device *dev, uint32_t level) 


static int __init corgikbd_probe(struct device *dev)

{

	int i;

	struct corgikbd *corgikbd;

	struct input_dev *input_dev;

	int i;



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

	if (!corgikbd)

	input_dev = input_allocate_device();

	if (!corgikbd || !input_dev) {

		kfree(corgikbd);

		input_free_device(input_dev);

		return -ENOMEM;

	}



	dev_set_drvdata(dev, corgikbd);

	strcpy(corgikbd->phys, "corgikbd/input0");



	corgikbd->input = input_dev;

	spin_lock_init(&corgikbd->lock);



	/* Init Keyboard rescan timer */
@@ -311,28 +315,30 @@ static int __init corgikbd_probe(struct device *dev) 


	corgikbd->suspend_jiffies=jiffies;



	init_input_dev(&corgikbd->input);

	corgikbd->input.private = corgikbd;

	corgikbd->input.name = "Corgi Keyboard";

	corgikbd->input.dev = dev;

	corgikbd->input.phys = corgikbd->phys;

	corgikbd->input.id.bustype = BUS_HOST;

	corgikbd->input.id.vendor = 0x0001;

	corgikbd->input.id.product = 0x0001;

	corgikbd->input.id.version = 0x0100;

	corgikbd->input.evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_PWR) | BIT(EV_SW);

	corgikbd->input.keycode = corgikbd->keycode;

	corgikbd->input.keycodesize = sizeof(unsigned char);

	corgikbd->input.keycodemax = ARRAY_SIZE(corgikbd_keycode);



	memcpy(corgikbd->keycode, corgikbd_keycode, sizeof(corgikbd->keycode));



	input_dev->name = "Corgi Keyboard";

	input_dev->phys = "corgikbd/input0";

	input_dev->id.bustype = BUS_HOST;

	input_dev->id.vendor = 0x0001;

	input_dev->id.product = 0x0001;

	input_dev->id.version = 0x0100;

	input_dev->cdev.dev = dev;

	input_dev->private = corgikbd;



	input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_REP) | BIT(EV_PWR) | BIT(EV_SW);

	input_dev->keycode = corgikbd->keycode;

	input_dev->keycodesize = sizeof(unsigned char);

	input_dev->keycodemax = ARRAY_SIZE(corgikbd_keycode);



	for (i = 0; i < ARRAY_SIZE(corgikbd_keycode); i++)

		set_bit(corgikbd->keycode[i], corgikbd->input.keybit);

	clear_bit(0, corgikbd->input.keybit);

	set_bit(SW_0, corgikbd->input.swbit);

	set_bit(SW_1, corgikbd->input.swbit);

		set_bit(corgikbd->keycode[i], input_dev->keybit);

	clear_bit(0, input_dev->keybit);

	set_bit(SW_0, input_dev->swbit);

	set_bit(SW_1, input_dev->swbit);



	input_register_device(corgikbd->input);



	input_register_device(&corgikbd->input);

	mod_timer(&corgikbd->htimer, jiffies + HINGE_SCAN_INTERVAL);



	/* Setup sense interrupts - RisingEdge Detect, sense lines as inputs */
@@ -349,8 +355,6 @@ static int __init corgikbd_probe(struct device *dev) 
	for (i = 0; i < CORGI_KEY_STROBE_NUM; i++)

		pxa_gpio_mode(CORGI_GPIO_KEY_STROBE(i) | GPIO_OUT | GPIO_DFLT_HIGH);



	printk(KERN_INFO "input: Corgi Keyboard Registered\n");



	return 0;

}
@@ -365,7 +369,7 @@ static int corgikbd_remove(struct device *dev) 
	del_timer_sync(&corgikbd->htimer);

	del_timer_sync(&corgikbd->timer);



	input_unregister_device(&corgikbd->input);

	input_unregister_device(corgikbd->input);



	kfree(corgikbd);

drivers/input/keyboard/lkkbd.c

+64 −64
Original line number Diff line number Diff line
@@ -102,7 +102,7 @@ static int ctrlclick_volume = 100; /* % */ 
module_param (ctrlclick_volume, int, 0);

MODULE_PARM_DESC (ctrlclick_volume, "Ctrlclick volume (in %), default is 100%");



static int lk201_compose_is_alt = 0;

static int lk201_compose_is_alt;

module_param (lk201_compose_is_alt, int, 0);

MODULE_PARM_DESC (lk201_compose_is_alt, "If set non-zero, LK201' Compose key "

		"will act as an Alt key");
@@ -274,7 +274,7 @@ static lk_keycode_t lkkbd_keycode[LK_NUM_KEYCODES] = { 
};



#define CHECK_LED(LED, BITS) do {		\

	if (test_bit (LED, lk->dev.led))	\

	if (test_bit (LED, lk->dev->led))	\

		leds_on |= BITS;		\

	else					\

		leds_off |= BITS;		\
@@ -287,7 +287,7 @@ struct lkkbd { 
	lk_keycode_t keycode[LK_NUM_KEYCODES];

	int ignore_bytes;

	unsigned char id[LK_NUM_IGNORE_BYTES];

	struct input_dev dev;

	struct input_dev *dev;

	struct serio *serio;

	struct work_struct tq;

	char name[64];
@@ -423,8 +423,7 @@ lkkbd_interrupt (struct serio *serio, unsigned char data, unsigned int flags, 
	DBG (KERN_INFO "Got byte 0x%02x\n", data);



	if (lk->ignore_bytes > 0) {

		DBG (KERN_INFO "Ignoring a byte on %s\n",

				lk->name);

		DBG (KERN_INFO "Ignoring a byte on %s\n", lk->name);

		lk->id[LK_NUM_IGNORE_BYTES - lk->ignore_bytes--] = data;



		if (lk->ignore_bytes == 0)
@@ -435,14 +434,14 @@ lkkbd_interrupt (struct serio *serio, unsigned char data, unsigned int flags, 


	switch (data) {

		case LK_ALL_KEYS_UP:

			input_regs (&lk->dev, regs);

			input_regs (lk->dev, regs);

			for (i = 0; i < ARRAY_SIZE (lkkbd_keycode); i++)

				if (lk->keycode[i] != KEY_RESERVED)

					input_report_key (&lk->dev, lk->keycode[i], 0);

			input_sync (&lk->dev);

					input_report_key (lk->dev, lk->keycode[i], 0);

			input_sync (lk->dev);

			break;

		case LK_METRONOME:

			DBG (KERN_INFO "Got LK_METRONOME and don't "

			DBG (KERN_INFO "Got %#d and don't "

					"know how to handle...\n");

			break;

		case LK_OUTPUT_ERROR:
@@ -482,12 +481,12 @@ lkkbd_interrupt (struct serio *serio, unsigned char data, unsigned int flags, 


		default:

			if (lk->keycode[data] != KEY_RESERVED) {

				input_regs (&lk->dev, regs);

				if (!test_bit (lk->keycode[data], lk->dev.key))

					input_report_key (&lk->dev, lk->keycode[data], 1);

				input_regs (lk->dev, regs);

				if (!test_bit (lk->keycode[data], lk->dev->key))

					input_report_key (lk->dev, lk->keycode[data], 1);

				else

					input_report_key (&lk->dev, lk->keycode[data], 0);

				input_sync (&lk->dev);

					input_report_key (lk->dev, lk->keycode[data], 0);

				input_sync (lk->dev);

                        } else

                                printk (KERN_WARNING "%s: Unknown key with "

						"scancode 0x%02x on %s.\n",
@@ -605,7 +604,7 @@ lkkbd_reinit (void *data) 
	lk->serio->write (lk->serio, volume_to_hw (lk->bell_volume));



	/* Enable/disable keyclick (and possibly set volume) */

	if (test_bit (SND_CLICK, lk->dev.snd)) {

	if (test_bit (SND_CLICK, lk->dev->snd)) {

		lk->serio->write (lk->serio, LK_CMD_ENABLE_KEYCLICK);

		lk->serio->write (lk->serio, volume_to_hw (lk->keyclick_volume));

		lk->serio->write (lk->serio, LK_CMD_ENABLE_CTRCLICK);
@@ -616,7 +615,7 @@ lkkbd_reinit (void *data) 
	}



	/* Sound the bell if needed */

	if (test_bit (SND_BELL, lk->dev.snd))

	if (test_bit (SND_BELL, lk->dev->snd))

		lk->serio->write (lk->serio, LK_CMD_SOUND_BELL);

}
@@ -627,71 +626,70 @@ static int 
lkkbd_connect (struct serio *serio, struct serio_driver *drv)

{

	struct lkkbd *lk;

	struct input_dev *input_dev;

	int i;

	int err;



	if (!(lk = kmalloc (sizeof (struct lkkbd), GFP_KERNEL)))

		return -ENOMEM;



	memset (lk, 0, sizeof (struct lkkbd));



	init_input_dev (&lk->dev);

	set_bit (EV_KEY, lk->dev.evbit);

	set_bit (EV_LED, lk->dev.evbit);

	set_bit (EV_SND, lk->dev.evbit);

	set_bit (EV_REP, lk->dev.evbit);

	set_bit (LED_CAPSL, lk->dev.ledbit);

	set_bit (LED_SLEEP, lk->dev.ledbit);

	set_bit (LED_COMPOSE, lk->dev.ledbit);

	set_bit (LED_SCROLLL, lk->dev.ledbit);

	set_bit (SND_BELL, lk->dev.sndbit);

	set_bit (SND_CLICK, lk->dev.sndbit);

	lk = kzalloc (sizeof (struct lkkbd), GFP_KERNEL);

	input_dev = input_allocate_device ();

	if (!lk || !input_dev) {

		err = -ENOMEM;

		goto fail;

	}



	lk->serio = serio;



	lk->dev = input_dev;

	INIT_WORK (&lk->tq, lkkbd_reinit, lk);



	lk->bell_volume = bell_volume;

	lk->keyclick_volume = keyclick_volume;

	lk->ctrlclick_volume = ctrlclick_volume;

	memcpy (lk->keycode, lkkbd_keycode, sizeof (lk_keycode_t) * LK_NUM_KEYCODES);



	lk->dev.keycode = lk->keycode;

	lk->dev.keycodesize = sizeof (lk_keycode_t);

	lk->dev.keycodemax = LK_NUM_KEYCODES;



	lk->dev.event = lkkbd_event;

	lk->dev.private = lk;

	strlcpy (lk->name, "DEC LK keyboard", sizeof(lk->name));

	snprintf (lk->phys, sizeof(lk->phys), "%s/input0", serio->phys);



	input_dev->name = lk->name;

	input_dev->phys = lk->phys;

	input_dev->id.bustype = BUS_RS232;

	input_dev->id.vendor = SERIO_LKKBD;

	input_dev->id.product = 0;

	input_dev->id.version = 0x0100;

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

	input_dev->event = lkkbd_event;

	input_dev->private = lk;



	set_bit (EV_KEY, input_dev->evbit);

	set_bit (EV_LED, input_dev->evbit);

	set_bit (EV_SND, input_dev->evbit);

	set_bit (EV_REP, input_dev->evbit);

	set_bit (LED_CAPSL, input_dev->ledbit);

	set_bit (LED_SLEEP, input_dev->ledbit);

	set_bit (LED_COMPOSE, input_dev->ledbit);

	set_bit (LED_SCROLLL, input_dev->ledbit);

	set_bit (SND_BELL, input_dev->sndbit);

	set_bit (SND_CLICK, input_dev->sndbit);



	input_dev->keycode = lk->keycode;

	input_dev->keycodesize = sizeof (lk_keycode_t);

	input_dev->keycodemax = LK_NUM_KEYCODES;

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

		set_bit (lk->keycode[i], input_dev->keybit);



	serio_set_drvdata (serio, lk);



	err = serio_open (serio, drv);

	if (err) {

		serio_set_drvdata (serio, NULL);

		kfree (lk);

		return err;

	}



	sprintf (lk->name, "DEC LK keyboard");

	sprintf (lk->phys, "%s/input0", serio->phys);



	memcpy (lk->keycode, lkkbd_keycode, sizeof (lk_keycode_t) * LK_NUM_KEYCODES);

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

		set_bit (lk->keycode[i], lk->dev.keybit);

	if (err)

		goto fail;



	lk->dev.name = lk->name;

	lk->dev.phys = lk->phys;

	lk->dev.id.bustype = BUS_RS232;

	lk->dev.id.vendor = SERIO_LKKBD;

	lk->dev.id.product = 0;

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

	lk->dev.dev = &serio->dev;



	input_register_device (&lk->dev);



	printk (KERN_INFO "input: %s on %s, initiating reset\n", lk->name, serio->phys);

	input_register_device (lk->dev);

	lk->serio->write (lk->serio, LK_CMD_POWERCYCLE_RESET);



	return 0;



 fail:	serio_set_drvdata (serio, NULL);

	input_free_device (input_dev);

	kfree (lk);

	return err;

}



/*
@@ -702,9 +700,11 @@ lkkbd_disconnect (struct serio *serio) 
{

	struct lkkbd *lk = serio_get_drvdata (serio);



	input_unregister_device (&lk->dev);

	input_get_device (lk->dev);

	input_unregister_device (lk->dev);

	serio_close (serio);

	serio_set_drvdata (serio, NULL);

	input_put_device (lk->dev);

	kfree (lk);

}

drivers/input/keyboard/maple_keyb.c

+31 −41

File changed.

Preview size limit exceeded, changes collapsed.