Re: Add INPUT support to toshiba_acpi

Dmitry Torokhov
2007-06-01T16:45:44Z

[-- Attachment #1: Type: text/plain, Size: 1538 bytes --]

Hi Richard,

On 5/31/07, Richard Hughes <hughsient@gmail.com> wrote:
> On Thu, 2007-05-31 at 14:44 +0100, Richard Hughes wrote:
> > Nope, impossible AFAICS. The hardware is just broken. Windows XP has an
> > toshiba supplied daemon that polls, so I think we have to just bite the
> > bullet.
>
> ... adding in reply in different thread...
>
> On Thu, 2007-05-31 at 10:37 -0400, Dmitry Torokhov wrote:
> > Please use input-polldev to set up polled devices. It
> > will create work queue for you and will make sure that polling is
> > stopped when device is closed.
>
> Okay, I had never heard of this. I've done the suggested changes in the
> attached patch. Please can you have a look and make sure I'm being sane.
>

The patch was pretty good, I did not quite like the driver
registration code so I tried to clean it up. What do you think about
the attached patch (not tested due to the lack of hardware). If you
are OK with it please add your signed-off-by because version of the
patch I grabbed did not have it.

> > Also I don't think you want to use
> > KEY_BREAK. What is the expected function of that key?
>
> It's a "lock" key, I really want KEY_LOCK added to input.h, but that
> might prove difficult. For now I've used KEY_CLEAR, yell if you think
> there's a better one to substitute or if you guys want me to add get a
> constant added to input.h.

Iam still struggling with the purpose of the key. What would you
extect to happen when youser presses this key? Screen gets locked?
KEY_SCREENLOCK? KEY_SCREENSAVER?

--
Dmitry

[-- Attachment #2: toshiba_acpi_add_buttons.patch --]
[-- Type: text/plain, Size: 14181 bytes --]

From: Richard Hughes <hughsient@gmail.com>
Subject: toshiba_acpi: integrate with INPUT layer

Toshiba hardware is a little oddball, and does not provide ACPI events
on some key presses, typically Fn hotkey buttons. The key interface is
now polled, and events now matched to a list of toshiba specific
scancodes, and are squirted to userspace using the INPUT subsystem.

This means that toshiba laptops buttons "just work" without any
userspace daemon (using uinput) such as fnfx or bodges such as using a
userspace hal addon. Doing the polling in kernel is more efficient, and
makes stuff just work out of the box. You can assign the keys using
standard X keymaps, or using tools such as gnome-keybinding-properties.

Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
---
Documentation/kernel-parameters.txt | 11 +
drivers/acpi/Kconfig | 1
drivers/acpi/toshiba_acpi.c | 333 ++++++++++++++++++++++++++++--------
3 files changed, 278 insertions(+), 67 deletions(-)

Index: linux/drivers/acpi/Kconfig
===================================================================
--- linux.orig/drivers/acpi/Kconfig
+++ linux/drivers/acpi/Kconfig
@@ -222,6 +222,7 @@ config ACPI_TOSHIBA
tristate "Toshiba Laptop Extras"
depends on X86
select BACKLIGHT_CLASS_DEVICE
+ select INPUT_POLLDEV
---help---
This driver adds support for access to certain system settings
on "legacy free" Toshiba laptops. These laptops can be recognized by
Index: linux/drivers/acpi/toshiba_acpi.c
===================================================================
--- linux.orig/drivers/acpi/toshiba_acpi.c
+++ linux/drivers/acpi/toshiba_acpi.c
@@ -27,13 +27,13 @@
* engineering the Windows drivers
* Yasushi Nagato - changes for linux kernel 2.4 -> 2.5
* Rob Miller - TV out and hotkeys help
- *
+ * Richard Hughes - emit INPUT events for hotkeys
*
* TODO
*
*/

-#define TOSHIBA_ACPI_VERSION "0.18"
+#define TOSHIBA_ACPI_VERSION "0.19"
#define PROC_INTERFACE_VERSION 1

#include <linux/kernel.h>
@@ -42,6 +42,7 @@
#include <linux/types.h>
#include <linux/proc_fs.h>
#include <linux/backlight.h>
+#include <linux/input-polldev.h>

#include <asm/uaccess.h>

@@ -55,6 +56,7 @@ MODULE_LICENSE("GPL");
#define MY_ERR KERN_ERR MY_LOGPREFIX
#define MY_NOTICE KERN_NOTICE MY_LOGPREFIX
#define MY_INFO KERN_INFO MY_LOGPREFIX
+#define MY_DEBUG KERN_DEBUG MY_LOGPREFIX

/* Toshiba ACPI method paths */
#define METHOD_LCD_BRIGHTNESS "\\_SB_.PCI0.VGA_.LCD_._BCM"
@@ -99,6 +101,17 @@ MODULE_LICENSE("GPL");
#define HCI_VIDEO_OUT_CRT 0x2
#define HCI_VIDEO_OUT_TV 0x4

+/* key definitions */
+#define HCI_HKEY_FN 0x0100
+#define HCI_HKEY_MUTE 0x0101
+#define HCI_HKEY_BREAK 0x013b
+#define HCI_HKEY_SEARCH 0x013c
+#define HCI_HKEY_SUSPEND 0x013d
+#define HCI_HKEY_HIBERNATE 0x013e
+#define HCI_HKEY_BRIGHTNESSDOWN 0x0140
+#define HCI_HKEY_BRIGHTNESSUP 0x0141
+#define HCI_HKEY_WLAN 0x0142
+
/* utility
*/

@@ -213,10 +226,21 @@ static acpi_status hci_read1(u32 reg, u3

static struct proc_dir_entry *toshiba_proc_dir /*= 0*/ ;
static struct backlight_device *toshiba_backlight_device;
+static struct input_polled_dev *toshiba_poll_dev;
static int force_fan;
static int last_key_event;
static int key_event_valid;

+static int hotkeys_over_input = 1;
+module_param(hotkeys_over_input, bool, 0444);
+MODULE_PARM_DESC(hotkeys_over_input,
+ "Enable delivery of hotkey events via input layer.");
+
+static int hotkeys_poll_interval = 500; /* msecs */
+module_param(hotkeys_poll_interval, uint, 0444);
+MODULE_PARM_DESC(hotkeys_poll_interval,
+ "How often to poll hotkey state (default is 500 msec)");
+
typedef struct _ProcItem {
const char *name;
char *(*read_func) (char *);
@@ -438,32 +462,47 @@ static unsigned long write_fan(const cha
return count;
}

+static u32 hci_poll_keys_once(u32 *value)
+{
+ u32 hci_result;
+
+ hci_read1(HCI_SYSTEM_EVENT, value, &hci_result);
+ if (hci_result == HCI_NOT_SUPPORTED) {
+ /* This is a workaround for an unresolved issue on
+ * some machines where system events sporadically
+ * become disabled. */
+ hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
+ printk(MY_DEBUG "Re-enabled hotkeys\n");
+ hci_result = HCI_EMPTY;
+ }
+
+ return hci_result;
+}
+
static char *read_keys(char *p)
{
u32 hci_result;
u32 value;

- if (!key_event_valid) {
- hci_read1(HCI_SYSTEM_EVENT, &value, &hci_result);
- if (hci_result == HCI_SUCCESS) {
- key_event_valid = 1;
- last_key_event = value;
- } else if (hci_result == HCI_EMPTY) {
- /* better luck next time */
- } else if (hci_result == HCI_NOT_SUPPORTED) {
- /* This is a workaround for an unresolved issue on
- * some machines where system events sporadically
- * become disabled. */
- hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);
- printk(MY_NOTICE "Re-enabled hotkeys\n");
- } else {
- printk(MY_ERR "Error reading hotkey status\n");
- goto end;
+ if (!hotkeys_over_input) {
+ if (!key_event_valid) {
+ hci_result = hci_poll_keys_once(&value);
+ if (hci_result == HCI_SUCCESS) {
+ key_event_valid = 1;
+ last_key_event = value;
+ } else if (hci_result != HCI_EMPTY) {
+ printk(MY_ERR "Error reading hotkey status\n");
+ goto end;
+ }
}
+ } else {
+ key_event_valid = 0;
+ last_key_event = 0;
}

p += sprintf(p, "hotkey_ready: %d\n", key_event_valid);
p += sprintf(p, "hotkey: 0x%04x\n", last_key_event);
+ p += sprintf(p, "hotkeys_via_input: %d\n", hotkeys_over_input);

end:
return p;
@@ -501,60 +540,204 @@ static ProcItem proc_items[] = {
{"fan", read_fan, write_fan},
{"keys", read_keys, write_keys},
{"version", read_version, NULL},
- {NULL}
};

-static acpi_status __init add_device(void)
+static int __init add_proc_entries(void)
{
struct proc_dir_entry *proc;
ProcItem *item;
+ int mode;
+ int i;

- for (item = proc_items; item->name; ++item) {
- proc = create_proc_read_entry(item->name,
- S_IFREG | S_IRUGO | S_IWUSR,
- toshiba_proc_dir,
- (read_proc_t *) dispatch_read,
- item);
- if (proc)
- proc->owner = THIS_MODULE;
- if (proc && item->write_func)
+ toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
+ if (!toshiba_proc_dir) {
+ printk(MY_ERR "failed to create toshiba proc directory\n");
+ goto err_out;
+ }
+
+ toshiba_proc_dir->owner = THIS_MODULE;
+
+ for (i = 0; i < ARRAY_SIZE(proc_items); i++) {
+ item = &proc_items[i];
+
+ mode = S_IFREG | S_IRUGO;
+ if (item->write_func)
+ mode = S_IWUSR;
+
+ proc = create_proc_entry(item->name, mode, toshiba_proc_dir);
+ if (!proc) {
+ printk(MY_ERR "failed to create %s proc entry\n",
+ item->name);
+ goto err_remove_proc;
+ }
+
+ proc->owner = THIS_MODULE;
+ proc->data = item;
+ proc->read_proc = (read_proc_t *) dispatch_read;
+ if (item->write_func)
proc->write_proc = (write_proc_t *) dispatch_write;
}

- return AE_OK;
+ return 0;
+
+ err_remove_proc:
+ while (-- i >= 0)
+ remove_proc_entry(proc_items[i].name, toshiba_proc_dir);
+ remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
+ err_out:
+ return -EBUSY; /* arbitrary */
}

-static acpi_status __exit remove_device(void)
+static void __exit remove_proc_entries(void)
{
- ProcItem *item;
+ int i;

- for (item = proc_items; item->name; ++item)
- remove_proc_entry(item->name, toshiba_proc_dir);
- return AE_OK;
+ for (i = 0; i < ARRAY_SIZE(proc_items); i++)
+ remove_proc_entry(proc_items[i].name, toshiba_proc_dir);
+
+ remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
}

static struct backlight_ops toshiba_backlight_data = {
- .get_brightness = get_lcd,
- .update_status = set_lcd_status,
+ .get_brightness = get_lcd,
+ .update_status = set_lcd_status,
};

-static void __exit toshiba_acpi_exit(void)
+static void toshiba_deliver_button_event(struct input_dev *input, u32 value)
{
- if (toshiba_backlight_device)
- backlight_device_unregister(toshiba_backlight_device);
+ int keycode;
+ int key_down;

- remove_device();
+ /* translate MSB to key up */
+ key_down = !(value & 0x80);
+ value &= ~0x80;
+
+ /* translate keys to keycodes */
+ switch (value) {
+ case HCI_HKEY_FN:
+ keycode = KEY_RESERVED; /* ignore FN on its own */
+ return;
+ case HCI_HKEY_MUTE:
+ keycode = KEY_MUTE;
+ break;
+ case HCI_HKEY_BREAK:
+ keycode = KEY_BREAK;
+ break;
+ case HCI_HKEY_SEARCH:
+ keycode = KEY_SEARCH;
+ break;
+ case HCI_HKEY_SUSPEND:
+ keycode = KEY_SLEEP;
+ break;
+ case HCI_HKEY_HIBERNATE:
+ keycode = KEY_SUSPEND;
+ break;
+ case HCI_HKEY_BRIGHTNESSDOWN:
+ keycode = KEY_BRIGHTNESSDOWN;
+ break;
+ case HCI_HKEY_BRIGHTNESSUP:
+ keycode = KEY_BRIGHTNESSUP;
+ break;
+ case HCI_HKEY_WLAN:
+ keycode = KEY_WLAN;
+ break;
+ default:
+ keycode = KEY_UNKNOWN;
+ break;
+ }
+
+ if (keycode != KEY_RESERVED) {
+ input_report_key(input, keycode, key_down);
+ input_event(input, EV_MSC, MSC_SCAN, value);
+ input_sync(input);
+ }
+}

- if (toshiba_proc_dir)
- remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
+static void toshiba_keys_flush(struct input_polled_dev *dev)
+{
+ int dropped = 0;
+ int clear_queue = 0;
+ u32 value;
+
+ /*
+ * We don't want to get stuck here; older toshibas such as the
+ * A60 may load and then return junk during the hci_read
+ * so limit reads to 16 attempts.
+ */
+ do {
+ if (hci_poll_keys_once(&value) != HCI_SUCCESS)
+ break;
+
+ dropped++;
+ } while (clear_queue++ < 16);
+
+ printk(MY_DEBUG "Dropped %d keys from the queue on startup\n",
+ dropped);
+}
+
+static void toshiba_keys_poll(struct input_polled_dev *dev)
+{
+ struct input_dev *input = dev->input;
+ u32 value;
+
+ while (hci_poll_keys_once(&value) == HCI_SUCCESS)
+ toshiba_deliver_button_event(input, value);
+}
+
+static int __init toshiba_input_polldev_init(void)
+{
+ int error;
+ struct input_dev *input;
+
+ /* use INPUT for key events */
+ toshiba_poll_dev = input_allocate_polled_device();;
+ if (!toshiba_poll_dev) {
+ printk(MY_ERR "could not allocate input device\n");
+ error = -ENOMEM;
+ goto err_no_mem;
+ }
+
+ toshiba_poll_dev->flush = toshiba_keys_flush;
+ toshiba_poll_dev->poll = toshiba_keys_poll;
+
+ /* sanitise polling to something sane */
+ if (hotkeys_poll_interval < 100)
+ hotkeys_poll_interval = 100;
+ toshiba_poll_dev->poll_interval = hotkeys_poll_interval;
+
+ /* create one 'keyboard' virtual input device for all the acpi events */
+ input = toshiba_poll_dev->input;
+ input->name = "Toshiba Extra Buttons";
+ input->phys = "toshiba/input0";
+ input->id.bustype = BUS_HOST;
+ input->evbit[0] = BIT(EV_KEY);
+ set_bit(KEY_MUTE, input->keybit);
+ set_bit(KEY_BREAK, input->keybit); /* probably should be KEY_LOCK */
+ set_bit(KEY_SEARCH, input->keybit);
+ set_bit(KEY_SUSPEND, input->keybit);
+ set_bit(KEY_SLEEP, input->keybit);
+ set_bit(KEY_BRIGHTNESSDOWN, input->keybit);
+ set_bit(KEY_BRIGHTNESSUP, input->keybit);
+ set_bit(KEY_WLAN, input->keybit);
+
+ error = input_register_polled_device(toshiba_poll_dev);
+ if (error) {
+ printk(MY_ERR "could not register input device\n");
+ goto err_free_input;
+ }

- return;
+ return 0;
+
+ err_free_input:
+ input_free_polled_device(toshiba_poll_dev);
+ err_no_mem:
+ return error;
}

static int __init toshiba_acpi_init(void)
{
- acpi_status status = AE_OK;
u32 hci_result;
+ int error;

if (acpi_disabled)
return -ENODEV;
@@ -571,33 +754,49 @@ static int __init toshiba_acpi_init(void
TOSHIBA_ACPI_VERSION);
printk(MY_INFO " HCI method: %s\n", method_hci);

- force_fan = 0;
- key_event_valid = 0;
-
/* enable event fifo */
hci_write1(HCI_SYSTEM_EVENT, 1, &hci_result);

- toshiba_proc_dir = proc_mkdir(PROC_TOSHIBA, acpi_root_dir);
- if (!toshiba_proc_dir) {
- status = AE_ERROR;
- } else {
- toshiba_proc_dir->owner = THIS_MODULE;
- status = add_device();
- if (ACPI_FAILURE(status))
- remove_proc_entry(PROC_TOSHIBA, acpi_root_dir);
- }
-
- toshiba_backlight_device = backlight_device_register("toshiba",NULL,
- NULL,
- &toshiba_backlight_data);
- if (IS_ERR(toshiba_backlight_device)) {
- printk(KERN_ERR "Could not register toshiba backlight device\n");
- toshiba_backlight_device = NULL;
- toshiba_acpi_exit();
+ error = add_proc_entries();
+ if (error)
+ goto err_out;
+
+ toshiba_backlight_device = backlight_device_register("toshiba", NULL,
+ NULL, &toshiba_backlight_data);
+ if (IS_ERR(toshiba_backlight_device)) {
+ printk(MY_ERR "Could not register toshiba backlight device\n");
+ goto err_remove_proc;
+ }
+ toshiba_backlight_device->props.max_brightness =
+ HCI_LCD_BRIGHTNESS_LEVELS - 1;
+
+ /* we have to poll the device as we do not get events */
+ if (hotkeys_over_input && hotkeys_poll_interval) {
+ error = toshiba_input_polldev_init();
+ if (error)
+ goto err_remove_backlight;
+ }
+
+ return 0;
+
+ err_remove_backlight:
+ backlight_device_unregister(toshiba_backlight_device);
+ err_remove_proc:
+ remove_proc_entries();
+ err_out:
+ return error;
+}
+
+static void __exit toshiba_acpi_exit(void)
+{
+ backlight_device_unregister(toshiba_backlight_device);
+
+ if (toshiba_poll_dev) {
+ input_unregister_polled_device(toshiba_poll_dev);
+ input_free_polled_device(toshiba_poll_dev);
}
- toshiba_backlight_device->props.max_brightness = HCI_LCD_BRIGHTNESS_LEVELS - 1;

- return (ACPI_SUCCESS(status)) ? 0 : -ENODEV;
+ remove_proc_entries();
}

module_init(toshiba_acpi_init);
Index: linux/Documentation/kernel-parameters.txt
===================================================================
--- linux.orig/Documentation/kernel-parameters.txt
+++ linux/Documentation/kernel-parameters.txt
@@ -1841,6 +1841,17 @@ and is between 256 and 4096 characters.
See comment before function dc390_setup() in
drivers/scsi/tmscsim.c.

+ toshiba_acpi.hotkeys_over_input
+ [HW,ACPI]
+ Instructs the driver to deliver hotkey events
+ via input layer as opposed to /proc. Enabled
+ by default.
+ toshiba_acpi.hotkeys_poll_interval =
+ [HW,ACPI]
+ Determines how often the driver polls hotkey
+ state when hotkeys are delivered via input
+ layer. Default is 500 msecs.
+
tp720= [HW,PS2]

trix= [HW,OSS] MediaTrix AudioTrix Pro