Input: add driver for slidebar on Lenovo IdeaPad laptops (1ea4c161) · Commits · e / devices / android_kernel_xiaomi_markw

MAINTAINERS

+7 −0

Original line number	Diff line number	Diff line
		@@ -4038,6 +4038,13 @@ W: http://launchpad.net/ideapad-laptop
		S: Maintained
		F: drivers/platform/x86/ideapad-laptop.c

		IDEAPAD LAPTOP SLIDEBAR DRIVER
		M: Andrey Moiseev <o2g.org.ru@gmail.com>
		L: linux-input@vger.kernel.org
		W: https://github.com/o2genum/ideapad-slidebar
		S: Maintained
		F: drivers/input/misc/ideapad_slidebar.c

		IDE/ATAPI DRIVERS
		M: Borislav Petkov <bp@alien8.de>
		L: linux-ide@vger.kernel.org

drivers/input/misc/Kconfig

+10 −0

Original line number	Diff line number	Diff line
		@@ -647,4 +647,14 @@ config INPUT_SIRFSOC_ONKEY

		If unsure, say N.

		config INPUT_IDEAPAD_SLIDEBAR
		tristate "IdeaPad Laptop Slidebar"
		depends on INPUT
		depends on SERIO_I8042
		help
		Say Y here if you have an IdeaPad laptop with a slidebar.

		To compile this driver as a module, choose M here: the
		module will be called ideapad_slidebar.

		endif

drivers/input/misc/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -61,3 +61,4 @@ obj-$(CONFIG_INPUT_WISTRON_BTNS) += wistron_btns.o
		obj-$(CONFIG_INPUT_WM831X_ON) += wm831x-on.o
		obj-$(CONFIG_INPUT_XEN_KBDDEV_FRONTEND) += xen-kbdfront.o
		obj-$(CONFIG_INPUT_YEALINK) += yealink.o
		obj-$(CONFIG_INPUT_IDEAPAD_SLIDEBAR) += ideapad_slidebar.o

drivers/input/misc/ideapad_slidebar.c

0 → 100644

+358 −0

Original line number	Diff line number	Diff line
		/*
		* Input driver for slidebars on some Lenovo IdeaPad laptops
		*
		* Copyright (C) 2013 Andrey Moiseev <o2g.org.ru@gmail.com>
		*
		* Reverse-engineered from Lenovo SlideNav software (SBarHook.dll).
		*
		* 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.
		*
		* Trademarks are the property of their respective owners.
		*/

		/*
		* Currently tested and works on:
		* Lenovo IdeaPad Y550
		* Lenovo IdeaPad Y550P
		*
		* Other models can be added easily. To test,
		* load with 'force' parameter set 'true'.
		*
		* LEDs blinking and input mode are managed via sysfs,
		* (hex, unsigned byte value):
		* /sys/devices/platform/ideapad_slidebar/slidebar_mode
		*
		* The value is in byte range, however, I only figured out
		* how bits 0b10011001 work. Some other bits, probably,
		* are meaningfull too.
		*
		* Possible states:
		*
		* STD_INT, ONMOV_INT, OFF_INT, LAST_POLL, OFF_POLL
		*
		* Meaning:
		* released touched
		* STD 'heartbeat' lights follow the finger
		* ONMOV no lights lights follow the finger
		* LAST at last pos lights follow the finger
		* OFF no lights no lights
		*
		* INT all input events are generated, interrupts are used
		* POLL no input events by default, to get them,
		* send 0b10000000 (read below)
		*
		* Commands: write
		*
		* All \| 0b01001 -> STD_INT
		* possible \| 0b10001 -> ONMOV_INT
		* states \| 0b01000 -> OFF_INT
		*
		* \| 0b0 -> LAST_POLL
		* STD_INT or ONMOV_INT \|
		* \| 0b1 -> STD_INT
		*
		* \| 0b0 -> OFF_POLL
		* OFF_INT or OFF_POLL \|
		* \| 0b1 -> OFF_INT
		*
		* Any state \| 0b10000000 -> if the slidebar has updated data,
		* produce one input event (last position),
		* switch to respective POLL mode
		* (like 0x0), if not in POLL mode yet.
		*
		* Get current state: read
		*
		* masked by 0x11 read value means:
		*
		* 0x00 LAST
		* 0x01 STD
		* 0x10 OFF
		* 0x11 ONMOV
		*/

		#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

		#include <linux/module.h>
		#include <linux/kernel.h>
		#include <linux/dmi.h>
		#include <linux/spinlock.h>
		#include <linux/platform_device.h>
		#include <linux/input.h>
		#include <linux/io.h>
		#include <linux/ioport.h>
		#include <linux/i8042.h>
		#include <linux/serio.h>

		#define IDEAPAD_BASE 0xff29

		static bool force;
		module_param(force, bool, 0);
		MODULE_PARM_DESC(force, "Force driver load, ignore DMI data");

		static DEFINE_SPINLOCK(io_lock);

		static struct input_dev *slidebar_input_dev;
		static struct platform_device *slidebar_platform_dev;

		static u8 slidebar_pos_get(void)
		{
		u8 res;
		unsigned long flags;

		spin_lock_irqsave(&io_lock, flags);
		outb(0xf4, 0xff29);
		outb(0xbf, 0xff2a);
		res = inb(0xff2b);
		spin_unlock_irqrestore(&io_lock, flags);

		return res;
		}

		static u8 slidebar_mode_get(void)
		{
		u8 res;
		unsigned long flags;

		spin_lock_irqsave(&io_lock, flags);
		outb(0xf7, 0xff29);
		outb(0x8b, 0xff2a);
		res = inb(0xff2b);
		spin_unlock_irqrestore(&io_lock, flags);

		return res;
		}

		static void slidebar_mode_set(u8 mode)
		{
		unsigned long flags;

		spin_lock_irqsave(&io_lock, flags);
		outb(0xf7, 0xff29);
		outb(0x8b, 0xff2a);
		outb(mode, 0xff2b);
		spin_unlock_irqrestore(&io_lock, flags);
		}

		static bool slidebar_i8042_filter(unsigned char data, unsigned char str,
		struct serio *port)
		{
		static bool extended = false;

		/* We are only interested in data coming form KBC port */
		if (str & I8042_STR_AUXDATA)
		return false;

		/* Scancodes: e03b on move, e0bb on release. */
		if (data == 0xe0) {
		extended = true;
		return true;
		}

		if (!extended)
		return false;

		extended = false;

		if (likely((data & 0x7f) != 0x3b)) {
		serio_interrupt(port, 0xe0, 0);
		return false;
		}

		if (data & 0x80) {
		input_report_key(slidebar_input_dev, BTN_TOUCH, 0);
		} else {
		input_report_key(slidebar_input_dev, BTN_TOUCH, 1);
		input_report_abs(slidebar_input_dev, ABS_X, slidebar_pos_get());
		}
		input_sync(slidebar_input_dev);

		return true;
		}

		static ssize_t show_slidebar_mode(struct device *dev,
		struct device_attribute *attr,
		char *buf)
		{
		return sprintf(buf, "%x\n", slidebar_mode_get());
		}

		static ssize_t store_slidebar_mode(struct device *dev,
		struct device_attribute *attr,
		const char *buf, size_t count)
		{
		u8 mode;
		int error;

		error = kstrtou8(buf, 0, &mode);
		if (error)
		return error;

		slidebar_mode_set(mode);

		return count;
		}

		static DEVICE_ATTR(slidebar_mode, S_IWUSR \| S_IRUGO,
		show_slidebar_mode, store_slidebar_mode);

		static struct attribute *ideapad_attrs[] = {
		&dev_attr_slidebar_mode.attr,
		NULL
		};

		static struct attribute_group ideapad_attr_group = {
		.attrs = ideapad_attrs
		};

		static const struct attribute_group *ideapad_attr_groups[] = {
		&ideapad_attr_group,
		NULL
		};

		static int __init ideapad_probe(struct platform_device* pdev)
		{
		int err;

		if (!request_region(IDEAPAD_BASE, 3, "ideapad_slidebar")) {
		dev_err(&pdev->dev, "IO ports are busy\n");
		return -EBUSY;
		}

		slidebar_input_dev = input_allocate_device();
		if (!slidebar_input_dev) {
		dev_err(&pdev->dev, "Failed to allocate input device\n");
		err = -ENOMEM;
		goto err_release_ports;
		}

		slidebar_input_dev->name = "IdeaPad Slidebar";
		slidebar_input_dev->id.bustype = BUS_HOST;
		slidebar_input_dev->dev.parent = &pdev->dev;
		input_set_capability(slidebar_input_dev, EV_KEY, BTN_TOUCH);
		input_set_capability(slidebar_input_dev, EV_ABS, ABS_X);
		input_set_abs_params(slidebar_input_dev, ABS_X, 0, 0xff, 0, 0);

		err = i8042_install_filter(slidebar_i8042_filter);
		if (err) {
		dev_err(&pdev->dev,
		"Failed to install i8042 filter: %d\n", err);
		goto err_free_dev;
		}

		err = input_register_device(slidebar_input_dev);
		if (err) {
		dev_err(&pdev->dev,
		"Failed to register input device: %d\n", err);
		goto err_remove_filter;
		}

		return 0;

		err_remove_filter:
		i8042_remove_filter(slidebar_i8042_filter);
		err_free_dev:
		input_free_device(slidebar_input_dev);
		err_release_ports:
		release_region(IDEAPAD_BASE, 3);
		return err;
		}

		static int ideapad_remove(struct platform_device *pdev)
		{
		i8042_remove_filter(slidebar_i8042_filter);
		input_unregister_device(slidebar_input_dev);
		release_region(IDEAPAD_BASE, 3);

		return 0;
		}

		static struct platform_driver slidebar_drv = {
		.driver = {
		.name = "ideapad_slidebar",
		.owner = THIS_MODULE,
		},
		.remove = ideapad_remove,
		};

		static int __init ideapad_dmi_check(const struct dmi_system_id *id)
		{
		pr_info("Laptop model '%s'\n", id->ident);
		return 1;
		}

		static const struct dmi_system_id ideapad_dmi[] __initconst = {
		{
		.ident = "Lenovo IdeaPad Y550",
		.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
		DMI_MATCH(DMI_PRODUCT_NAME, "20017"),
		DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo IdeaPad Y550")
		},
		.callback = ideapad_dmi_check
		},
		{
		.ident = "Lenovo IdeaPad Y550P",
		.matches = {
		DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
		DMI_MATCH(DMI_PRODUCT_NAME, "20035"),
		DMI_MATCH(DMI_PRODUCT_VERSION, "Lenovo IdeaPad Y550P")
		},
		.callback = ideapad_dmi_check
		},
		{ NULL, }
		};
		MODULE_DEVICE_TABLE(dmi, ideapad_dmi);

		static int __init slidebar_init(void)
		{
		int err;

		if (!force && !dmi_check_system(ideapad_dmi)) {
		pr_err("DMI does not match\n");
		return -ENODEV;
		}

		slidebar_platform_dev = platform_device_alloc("ideapad_slidebar", -1);
		if (!slidebar_platform_dev) {
		pr_err("Not enough memory\n");
		return -ENOMEM;
		}

		slidebar_platform_dev->dev.groups = ideapad_attr_groups;

		err = platform_device_add(slidebar_platform_dev);
		if (err) {
		pr_err("Failed to register platform device\n");
		goto err_free_dev;
		}

		err = platform_driver_probe(&slidebar_drv, ideapad_probe);
		if (err) {
		pr_err("Failed to register platform driver\n");
		goto err_delete_dev;
		}

		return 0;

		err_delete_dev:
		platform_device_del(slidebar_platform_dev);
		err_free_dev:
		platform_device_put(slidebar_platform_dev);
		return err;
		}

		static void __exit slidebar_exit(void)
		{
		platform_device_unregister(slidebar_platform_dev);
		platform_driver_unregister(&slidebar_drv);
		}

		module_init(slidebar_init);
		module_exit(slidebar_exit);

		MODULE_AUTHOR("Andrey Moiseev <o2g.org.ru@gmail.com>");
		MODULE_DESCRIPTION("Slidebar input support for some Lenovo IdeaPad laptops");
		MODULE_LICENSE("GPL");

drivers/input/serio/i8042.h

+0 −24

Original line number	Diff line number	Diff line
		@@ -40,30 +40,6 @@

		#define I8042_CTL_TIMEOUT 10000

		/*
		* Status register bits.
		*/

		#define I8042_STR_PARITY 0x80
		#define I8042_STR_TIMEOUT 0x40
		#define I8042_STR_AUXDATA 0x20
		#define I8042_STR_KEYLOCK 0x10
		#define I8042_STR_CMDDAT 0x08
		#define I8042_STR_MUXERR 0x04
		#define I8042_STR_IBF 0x02
		#define I8042_STR_OBF 0x01

		/*
		* Control register bits.
		*/

		#define I8042_CTR_KBDINT 0x01
		#define I8042_CTR_AUXINT 0x02
		#define I8042_CTR_IGNKEYLOCK 0x08
		#define I8042_CTR_KBDDIS 0x10
		#define I8042_CTR_AUXDIS 0x20
		#define I8042_CTR_XLATE 0x40

		/*
		* Return codes.
		*/