Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input (40a64fa8) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/char/keyboard.c

+78 −61

Original line number	Diff line number	Diff line
		@@ -107,7 +107,6 @@ const int NR_TYPES = ARRAY_SIZE(max_vals);

		struct kbd_struct kbd_table[MAX_NR_CONSOLES];
		static struct kbd_struct *kbd = kbd_table;
		static struct kbd_struct kbd0;

		int spawnpid, spawnsig;

		@@ -227,9 +226,9 @@ static void kd_nosound(unsigned long ignored)
		struct input_handle *handle = to_handle_h(node);
		if (test_bit(EV_SND, handle->dev->evbit)) {
		if (test_bit(SND_TONE, handle->dev->sndbit))
		input_event(handle->dev, EV_SND, SND_TONE, 0);
		input_inject_event(handle, EV_SND, SND_TONE, 0);
		if (test_bit(SND_BELL, handle->dev->sndbit))
		input_event(handle->dev, EV_SND, SND_BELL, 0);
		input_inject_event(handle, EV_SND, SND_BELL, 0);
		}
		}
		}
		@@ -247,11 +246,11 @@ void kd_mksound(unsigned int hz, unsigned int ticks)
		struct input_handle *handle = to_handle_h(node);
		if (test_bit(EV_SND, handle->dev->evbit)) {
		if (test_bit(SND_TONE, handle->dev->sndbit)) {
		input_event(handle->dev, EV_SND, SND_TONE, hz);
		input_inject_event(handle, EV_SND, SND_TONE, hz);
		break;
		}
		if (test_bit(SND_BELL, handle->dev->sndbit)) {
		input_event(handle->dev, EV_SND, SND_BELL, 1);
		input_inject_event(handle, EV_SND, SND_BELL, 1);
		break;
		}
		}
		@@ -278,9 +277,9 @@ int kbd_rate(struct kbd_repeat *rep)

		if (test_bit(EV_REP, dev->evbit)) {
		if (rep->delay > 0)
		input_event(dev, EV_REP, REP_DELAY, rep->delay);
		input_inject_event(handle, EV_REP, REP_DELAY, rep->delay);
		if (rep->period > 0)
		input_event(dev, EV_REP, REP_PERIOD, rep->period);
		input_inject_event(handle, EV_REP, REP_PERIOD, rep->period);
		d = dev->rep[REP_DELAY];
		p = dev->rep[REP_PERIOD];
		}
		@@ -988,7 +987,7 @@ static inline unsigned char getleds(void)
		* interrupt routines for this thing allows us to easily mask
		* this when we don't want any of the above to happen.
		* This allows for easy and efficient race-condition prevention
		* for kbd_refresh_leds => input_event(dev, EV_LED, ...) => ...
		* for kbd_start => input_inject_event(dev, EV_LED, ...) => ...
		*/

		static void kbd_bh(unsigned long dummy)
		@@ -999,10 +998,10 @@ static void kbd_bh(unsigned long dummy)
		if (leds != ledstate) {
		list_for_each(node, &kbd_handler.h_list) {
		struct input_handle *handle = to_handle_h(node);
		input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
		input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
		input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
		input_sync(handle->dev);
		input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
		input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
		input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
		input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
		}
		}

		@@ -1011,23 +1010,6 @@ static void kbd_bh(unsigned long dummy)

		DECLARE_TASKLET_DISABLED(keyboard_tasklet, kbd_bh, 0);

		/*
		* This allows a newly plugged keyboard to pick the LED state.
		*/
		static void kbd_refresh_leds(struct input_handle *handle)
		{
		unsigned char leds = ledstate;

		tasklet_disable(&keyboard_tasklet);
		if (leds != 0xff) {
		input_event(handle->dev, EV_LED, LED_SCROLLL, !!(leds & 0x01));
		input_event(handle->dev, EV_LED, LED_NUML, !!(leds & 0x02));
		input_event(handle->dev, EV_LED, LED_CAPSL, !!(leds & 0x04));
		input_sync(handle->dev);
		}
		tasklet_enable(&keyboard_tasklet);
		}

		#if defined(CONFIG_X86) \|\| defined(CONFIG_IA64) \|\| defined(CONFIG_ALPHA) \|\|\
		defined(CONFIG_MIPS) \|\| defined(CONFIG_PPC) \|\| defined(CONFIG_SPARC) \|\|\
		defined(CONFIG_PARISC) \|\| defined(CONFIG_SUPERH) \|\|\
		@@ -1043,7 +1025,7 @@ static const unsigned short x86_keycodes[256] =
		48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
		64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
		80, 81, 82, 83, 84,118, 86, 87, 88,115,120,119,121,112,123, 92,
		284,285,309,298,312, 91,327,328,329,331,333,335,336,337,338,339,
		284,285,309, 0,312, 91,327,328,329,331,333,335,336,337,338,339,
		367,288,302,304,350, 89,334,326,267,126,268,269,125,347,348,349,
		360,261,262,263,268,376,100,101,321,316,373,286,289,102,351,355,
		103,104,105,275,287,279,306,106,274,107,294,364,358,363,362,361,
		@@ -1065,38 +1047,55 @@ extern void sun_do_break(void);
		static int emulate_raw(struct vc_data *vc, unsigned int keycode,
		unsigned char up_flag)
		{
		if (keycode > 255 \|\| !x86_keycodes[keycode])
		return -1;
		int code;

		switch (keycode) {
		case KEY_PAUSE:
		put_queue(vc, 0xe1);
		put_queue(vc, 0x1d \| up_flag);
		put_queue(vc, 0x45 \| up_flag);
		return 0;
		break;

		case KEY_HANGEUL:
		if (!up_flag)
		put_queue(vc, 0xf2);
		return 0;
		break;

		case KEY_HANJA:
		if (!up_flag)
		put_queue(vc, 0xf1);
		return 0;
		}
		break;

		if (keycode == KEY_SYSRQ && sysrq_alt) {
		case KEY_SYSRQ:
		/*
		* Real AT keyboards (that's what we're trying
		* to emulate here emit 0xe0 0x2a 0xe0 0x37 when
		* pressing PrtSc/SysRq alone, but simply 0x54
		* when pressing Alt+PrtSc/SysRq.
		*/
		if (sysrq_alt) {
		put_queue(vc, 0x54 \| up_flag);
		return 0;
		} else {
		put_queue(vc, 0xe0);
		put_queue(vc, 0x2a \| up_flag);
		put_queue(vc, 0xe0);
		put_queue(vc, 0x37 \| up_flag);
		}
		break;

		if (x86_keycodes[keycode] & 0x100)
		put_queue(vc, 0xe0);
		default:
		if (keycode > 255)
		return -1;

		put_queue(vc, (x86_keycodes[keycode] & 0x7f) \| up_flag);
		code = x86_keycodes[keycode];
		if (!code)
		return -1;

		if (keycode == KEY_SYSRQ) {
		if (code & 0x100)
		put_queue(vc, 0xe0);
		put_queue(vc, 0x37 \| up_flag);
		put_queue(vc, (code & 0x7f) \| up_flag);

		break;
		}

		return 0;
		@@ -1298,16 +1297,15 @@ static struct input_handle kbd_connect(struct input_handler handler,
		if (i == BTN_MISC && !test_bit(EV_SND, dev->evbit))
		return NULL;

		if (!(handle = kmalloc(sizeof(struct input_handle), GFP_KERNEL)))
		handle = kzalloc(sizeof(struct input_handle), GFP_KERNEL);
		if (!handle)
		return NULL;
		memset(handle, 0, sizeof(struct input_handle));

		handle->dev = dev;
		handle->handler = handler;
		handle->name = "kbd";

		input_open_device(handle);
		kbd_refresh_leds(handle);

		return handle;
		}
		@@ -1318,6 +1316,24 @@ static void kbd_disconnect(struct input_handle *handle)
		kfree(handle);
		}

		/*
		* Start keyboard handler on the new keyboard by refreshing LED state to
		* match the rest of the system.
		*/
		static void kbd_start(struct input_handle *handle)
		{
		unsigned char leds = ledstate;

		tasklet_disable(&keyboard_tasklet);
		if (leds != 0xff) {
		input_inject_event(handle, EV_LED, LED_SCROLLL, !!(leds & 0x01));
		input_inject_event(handle, EV_LED, LED_NUML, !!(leds & 0x02));
		input_inject_event(handle, EV_LED, LED_CAPSL, !!(leds & 0x04));
		input_inject_event(handle, EV_SYN, SYN_REPORT, 0);
		}
		tasklet_enable(&keyboard_tasklet);
		}

		static struct input_device_id kbd_ids[] = {
		{
		.flags = INPUT_DEVICE_ID_MATCH_EVBIT,
		@@ -1338,6 +1354,7 @@ static struct input_handler kbd_handler = {
		.event = kbd_event,
		.connect = kbd_connect,
		.disconnect = kbd_disconnect,
		.start = kbd_start,
		.name = "kbd",
		.id_table = kbd_ids,
		};
		@@ -1346,15 +1363,15 @@ int __init kbd_init(void)
		{
		int i;

		kbd0.ledflagstate = kbd0.default_ledflagstate = KBD_DEFLEDS;
		kbd0.ledmode = LED_SHOW_FLAGS;
		kbd0.lockstate = KBD_DEFLOCK;
		kbd0.slockstate = 0;
		kbd0.modeflags = KBD_DEFMODE;
		kbd0.kbdmode = VC_XLATE;

		for (i = 0 ; i < MAX_NR_CONSOLES ; i++)
		kbd_table[i] = kbd0;
		for (i = 0; i < MAX_NR_CONSOLES; i++) {
		kbd_table[i].ledflagstate = KBD_DEFLEDS;
		kbd_table[i].default_ledflagstate = KBD_DEFLEDS;
		kbd_table[i].ledmode = LED_SHOW_FLAGS;
		kbd_table[i].lockstate = KBD_DEFLOCK;
		kbd_table[i].slockstate = 0;
		kbd_table[i].modeflags = KBD_DEFMODE;
		kbd_table[i].kbdmode = VC_XLATE;
		}

		input_register_handler(&kbd_handler);

drivers/input/evdev.c

+3 −7

Original line number	Diff line number	Diff line
		@@ -127,14 +127,10 @@ static int evdev_open(struct inode * inode, struct file * file)
		{
		struct evdev_list *list;
		int i = iminor(inode) - EVDEV_MINOR_BASE;
		int accept_err;

		if (i >= EVDEV_MINORS \|\| !evdev_table[i] \|\| !evdev_table[i]->exist)
		return -ENODEV;

		if ((accept_err = input_accept_process(&(evdev_table[i]->handle), file)))
		return accept_err;

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

		@@ -260,7 +256,7 @@ static ssize_t evdev_write(struct file * file, const char __user * buffer, size_

		if (evdev_event_from_user(buffer + retval, &event))
		return -EFAULT;
		input_event(list->evdev->handle.dev, event.type, event.code, event.value);
		input_inject_event(&list->evdev->handle, event.type, event.code, event.value);
		retval += evdev_event_size();
		}

		@@ -428,8 +424,8 @@ static long evdev_ioctl_handler(struct file *file, unsigned int cmd,
		if (get_user(v, ip + 1))
		return -EFAULT;

		input_event(dev, EV_REP, REP_DELAY, u);
		input_event(dev, EV_REP, REP_PERIOD, v);
		input_inject_event(&evdev->handle, EV_REP, REP_DELAY, u);
		input_inject_event(&evdev->handle, EV_REP, REP_PERIOD, v);

		return 0;

drivers/input/gameport/fm801-gp.c

+2 −2

Original line number	Diff line number	Diff line
		@@ -106,10 +106,10 @@ static int __devinit fm801_gp_probe(struct pci_dev *pci, const struct pci_device
		gp->gameport = port;
		gp->res_port = request_region(port->io, 0x10, "FM801 GP");
		if (!gp->res_port) {
		kfree(gp);
		gameport_free_port(port);
		printk(KERN_DEBUG "fm801-gp: unable to grab region 0x%x-0x%x\n",
		port->io, port->io + 0x0f);
		gameport_free_port(port);
		kfree(gp);
		return -EBUSY;
		}

drivers/input/gameport/gameport.c

+49 −17

Original line number	Diff line number	Diff line
		@@ -53,6 +53,7 @@ static LIST_HEAD(gameport_list);

		static struct bus_type gameport_bus;

		static void gameport_add_driver(struct gameport_driver *drv);
		static void gameport_add_port(struct gameport *gameport);
		static void gameport_destroy_port(struct gameport *gameport);
		static void gameport_reconnect_port(struct gameport *gameport);
		@@ -211,8 +212,14 @@ static void gameport_release_driver(struct gameport *gameport)

		static void gameport_find_driver(struct gameport *gameport)
		{
		int error;

		down_write(&gameport_bus.subsys.rwsem);
		device_attach(&gameport->dev);
		error = device_attach(&gameport->dev);
		if (error < 0)
		printk(KERN_WARNING
		"gameport: device_attach() failed for %s (%s), error: %d\n",
		gameport->phys, gameport->name, error);
		up_write(&gameport_bus.subsys.rwsem);
		}

		@@ -316,7 +323,6 @@ static void gameport_remove_duplicate_events(struct gameport_event *event)
		spin_unlock_irqrestore(&gameport_event_lock, flags);
		}


		static struct gameport_event *gameport_get_event(void)
		{
		struct gameport_event *event;
		@@ -342,7 +348,6 @@ static struct gameport_event *gameport_get_event(void)
		static void gameport_handle_event(void)
		{
		struct gameport_event *event;
		struct gameport_driver *gameport_drv;

		mutex_lock(&gameport_mutex);

		@@ -369,8 +374,7 @@ static void gameport_handle_event(void)
		break;

		case GAMEPORT_REGISTER_DRIVER:
		gameport_drv = event->object;
		driver_register(&gameport_drv->driver);
		gameport_add_driver(event->object);
		break;

		default:
		@@ -532,6 +536,7 @@ static void gameport_init_port(struct gameport *gameport)
		if (gameport->parent)
		gameport->dev.parent = &gameport->parent->dev;

		INIT_LIST_HEAD(&gameport->node);
		spin_lock_init(&gameport->timer_lock);
		init_timer(&gameport->poll_timer);
		gameport->poll_timer.function = gameport_run_poll_handler;
		@@ -544,6 +549,8 @@ static void gameport_init_port(struct gameport *gameport)
		*/
		static void gameport_add_port(struct gameport *gameport)
		{
		int error;

		if (gameport->parent)
		gameport->parent->child = gameport;

		@@ -558,7 +565,12 @@ static void gameport_add_port(struct gameport *gameport)
		printk(KERN_INFO "gameport: %s is %s, speed %dkHz\n",
		gameport->name, gameport->phys, gameport->speed);

		device_add(&gameport->dev);
		error = device_add(&gameport->dev);
		if (error)
		printk(KERN_ERR
		"gameport: device_add() failed for %s (%s), error: %d\n",
		gameport->phys, gameport->name, error);
		else
		gameport->registered = 1;
		}

		@@ -583,10 +595,11 @@ static void gameport_destroy_port(struct gameport *gameport)

		if (gameport->registered) {
		device_del(&gameport->dev);
		list_del_init(&gameport->node);
		gameport->registered = 0;
		}

		list_del_init(&gameport->node);

		gameport_remove_pending_events(gameport);
		put_device(&gameport->dev);
		}
		@@ -709,6 +722,17 @@ static struct bus_type gameport_bus = {
		.remove = gameport_driver_remove,
		};

		static void gameport_add_driver(struct gameport_driver *drv)
		{
		int error;

		error = driver_register(&drv->driver);
		if (error)
		printk(KERN_ERR
		"gameport: driver_register() failed for %s, error: %d\n",
		drv->driver.name, error);
		}

		void __gameport_register_driver(struct gameport_driver drv, struct module owner)
		{
		drv->driver.bus = &gameport_bus;
		@@ -778,16 +802,24 @@ void gameport_close(struct gameport *gameport)

		static int __init gameport_init(void)
		{
		gameport_task = kthread_run(gameport_thread, NULL, "kgameportd");
		if (IS_ERR(gameport_task)) {
		printk(KERN_ERR "gameport: Failed to start kgameportd\n");
		return PTR_ERR(gameport_task);
		}
		int error;

		gameport_bus.dev_attrs = gameport_device_attrs;
		gameport_bus.drv_attrs = gameport_driver_attrs;
		gameport_bus.match = gameport_bus_match;
		bus_register(&gameport_bus);
		error = bus_register(&gameport_bus);
		if (error) {
		printk(KERN_ERR "gameport: failed to register gameport bus, error: %d\n", error);
		return error;
		}

		gameport_task = kthread_run(gameport_thread, NULL, "kgameportd");
		if (IS_ERR(gameport_task)) {
		bus_unregister(&gameport_bus);
		error = PTR_ERR(gameport_task);
		printk(KERN_ERR "gameport: Failed to start kgameportd, error: %d\n", error);
		return error;
		}

		return 0;
		}

drivers/input/input.c

+44 −13

Original line number	Diff line number	Diff line
		@@ -35,6 +35,16 @@ static LIST_HEAD(input_handler_list);

		static struct input_handler *input_table[8];

		/**
		* input_event() - report new input event
		* @handle: device that generated the event
		* @type: type of the event
		* @code: event code
		* @value: value of the event
		*
		* This function should be used by drivers implementing various input devices
		* See also input_inject_event()
		*/
		void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
		{
		struct input_handle *handle;
		@@ -183,6 +193,23 @@ void input_event(struct input_dev *dev, unsigned int type, unsigned int code, in
		}
		EXPORT_SYMBOL(input_event);

		/**
		* input_inject_event() - send input event from input handler
		* @handle: input handle to send event through
		* @type: type of the event
		* @code: event code
		* @value: value of the event
		*
		* Similar to input_event() but will ignore event if device is "grabbed" and handle
		* injecting event is not the one that owns the device.
		*/
		void input_inject_event(struct input_handle *handle, unsigned int type, unsigned int code, int value)
		{
		if (!handle->dev->grab \|\| handle->dev->grab == handle)
		input_event(handle->dev, type, code, value);
		}
		EXPORT_SYMBOL(input_inject_event);

		static void input_repeat_key(unsigned long data)
		{
		struct input_dev dev = (void ) data;
		@@ -197,15 +224,6 @@ static void input_repeat_key(unsigned long data)
		mod_timer(&dev->timer, jiffies + msecs_to_jiffies(dev->rep[REP_PERIOD]));
		}

		int input_accept_process(struct input_handle handle, struct file file)
		{
		if (handle->dev->accept)
		return handle->dev->accept(handle->dev, file);

		return 0;
		}
		EXPORT_SYMBOL(input_accept_process);

		int input_grab_device(struct input_handle *handle)
		{
		if (handle->dev->grab)
		@@ -218,8 +236,15 @@ EXPORT_SYMBOL(input_grab_device);

		void input_release_device(struct input_handle *handle)
		{
		if (handle->dev->grab == handle)
		handle->dev->grab = NULL;
		struct input_dev *dev = handle->dev;

		if (dev->grab == handle) {
		dev->grab = NULL;

		list_for_each_entry(handle, &dev->h_list, d_node)
		if (handle->handler->start)
		handle->handler->start(handle);
		}
		}
		EXPORT_SYMBOL(input_release_device);

		@@ -963,8 +988,11 @@ int input_register_device(struct input_dev *dev)
		list_for_each_entry(handler, &input_handler_list, node)
		if (!handler->blacklist \|\| !input_match_device(handler->blacklist, dev))
		if ((id = input_match_device(handler->id_table, dev)))
		if ((handle = handler->connect(handler, dev, id)))
		if ((handle = handler->connect(handler, dev, id))) {
		input_link_handle(handle);
		if (handler->start)
		handler->start(handle);
		}

		input_wakeup_procfs_readers();

		@@ -1028,8 +1056,11 @@ void input_register_handler(struct input_handler *handler)
		list_for_each_entry(dev, &input_dev_list, node)
		if (!handler->blacklist \|\| !input_match_device(handler->blacklist, dev))
		if ((id = input_match_device(handler->id_table, dev)))
		if ((handle = handler->connect(handler, dev, id)))
		if ((handle = handler->connect(handler, dev, id))) {
		input_link_handle(handle);
		if (handler->start)
		handler->start(handle);
		}

		input_wakeup_procfs_readers();
		}