[i2c] [PATCH] Lifebook apanel driver (rev3)

Stephen Hemminger shemminger at osdl.org
Thu Jan 11 01:07:32 CET 2007


This driver supports the applications buttons on the Fujitsu Lifebook laptops.
It depends on the i2c id patch to identify the i801 adapter.

These buttons are read via the SMBus for more details see:
	http://apanel.sourceforge.net/tech.php
The buttons are routed as normal special keys to the input system.

It is based on the earlier apanel driver done by Jochen Eisenger, but
with many changes.  The original driver used ioctl's and a separate
user space program, this version hooks into the input subsystem so
that the normal Gnome/KDE shortcuts work without any userspace
changes.

Other Fujitsu laptop's have similar keys and can be added later.

Signed-off-by: Stephen Hemminger <shemminger at osdl.org>

---
 drivers/input/misc/Kconfig  |   12 +
 drivers/input/misc/Makefile |    1 
 drivers/input/misc/apanel.c |  448 ++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 461 insertions(+)

--- lifebook.orig/drivers/input/misc/Kconfig	2007-01-10 14:05:40.000000000 -0800
+++ lifebook/drivers/input/misc/Kconfig	2007-01-10 16:05:46.000000000 -0800
@@ -50,6 +50,18 @@
 	  To compile this driver as a module, choose M here: the module will
 	  be called wistron_btns.
 
+config INPUT_APANEL
+	tristate "Fujitsu Lifebook Application Panel buttons"
+	depends on X86 && !X86_64
+	select I2C_I801
+	help
+	 Say Y here for support of the Application Panel buttons, used on
+	 Fujitsu Lifebook. These are attached to the mainboard through
+	 an SMBus interface managed by the I2C Intel ICH (i801) driver.
+
+	 To compile this driver as a module, choose M here: the module will
+	 be called apanel.
+
 config INPUT_IXP4XX_BEEPER
 	tristate "IXP4XX Beeper support"
 	depends on ARCH_IXP4XX
--- lifebook.orig/drivers/input/misc/Makefile	2007-01-10 14:05:40.000000000 -0800
+++ lifebook/drivers/input/misc/Makefile	2007-01-10 15:15:38.000000000 -0800
@@ -9,5 +9,6 @@
 obj-$(CONFIG_INPUT_M68K_BEEP)		+= m68kspkr.o
 obj-$(CONFIG_INPUT_UINPUT)		+= uinput.o
 obj-$(CONFIG_INPUT_WISTRON_BTNS)	+= wistron_btns.o
+obj-$(CONFIG_INPUT_APANEL)		+= apanel.o
 obj-$(CONFIG_HP_SDC_RTC)		+= hp_sdc_rtc.o
 obj-$(CONFIG_INPUT_IXP4XX_BEEPER)	+= ixp4xx-beeper.o
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ lifebook/drivers/input/misc/apanel.c	2007-01-10 15:58:14.000000000 -0800
@@ -0,0 +1,448 @@
+/*
+ *   SMBus client for the Fujitsu Lifebook Application Panel
+ *
+ *  Copyright (C) 2007 Stephen Hemminger <shemminger at osdl.org>
+ *  Copyright (C) 2001-2003 Jochen Eisinger <jochen at penguin-breeder.org>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/ioport.h>
+#include <linux/io.h>
+#include <linux/module.h>
+#include <linux/dmi.h>
+#include <linux/input.h>
+#include <linux/i2c.h>
+#include <linux/workqueue.h>
+
+struct keymap {
+	u32 mask;
+	u8 keycode;
+};
+
+static struct keymap app_media_keys[] = {
+	{ 0x1, 	 KEY_MAIL },
+	{ 0x2,	 KEY_WWW },
+	{ 0x4,	 KEY_PROG2 },
+	{ 0x8,	 KEY_PROG1 },
+	{ 0x100, KEY_FORWARD },
+	{ 0x200, KEY_REWIND },
+	{ 0x400, KEY_STOPCD },
+	{ 0x800, KEY_PLAYPAUSE },
+	{ 0 }
+};
+
+static struct keymap four_keys[] = {
+	{ 0x1, 	KEY_PROG4 },
+	{ 0x2,	KEY_PROG3 },
+	{ 0x4,	KEY_PROG2 },
+	{ 0x8,	KEY_PROG1 },
+	{ 0 }
+};
+
+static const struct keymap *keymap;
+
+static int __init dmi_matched(struct dmi_system_id *dmi)
+{
+	keymap = dmi->driver_data;
+	return 1;
+}
+
+/* List of systems known to work */
+static struct dmi_system_id apanel_dmi_table[] __initdata = {
+	{
+		.callback = dmi_matched,
+		.ident = "Lifebook S",
+		.matches = {
+			DMI_MATCH(DMI_PRODUCT_NAME, "LifeBook S Series"),
+		},
+		.driver_data = app_media_keys,
+	},
+	{
+		.callback = dmi_matched,
+		.ident = "Lifebook B6210",
+		.matches = {
+			DMI_MATCH(DMI_PRODUCT_NAME, "Lifebook B6210"),
+		},
+		.driver_data = four_keys,
+	},
+	{ }
+};
+
+enum apanel_devid {
+	APANEL_DEV_NONE	 = 0,
+	APANEL_DEV_APPBTN= 1,
+	APANEL_DEV_CDBTN = 2,
+	APANEL_DEV_LCD	 = 3,
+	APANEL_DEV_LED	 = 4,
+
+	APANEL_DEV_MAX,
+};
+
+enum apanel_chip {
+	CHIP_NONE   = 0,
+	CHIP_OZ992C = 1,
+	CHIP_OZ163T = 2,
+	CHIP_OZ711M3= 4,
+};
+static enum apanel_chip device_chip[APANEL_DEV_MAX];
+
+static const char *device_names[APANEL_DEV_MAX] = {
+	[APANEL_DEV_APPBTN] = "Application Buttons",
+	[APANEL_DEV_LCD]    = "LCD",
+	[APANEL_DEV_LED]    = "LED",
+	[APANEL_DEV_CDBTN]  = "CD Buttons",
+};
+
+struct apanel {
+	struct input_dev *input;
+	struct i2c_client client;
+	struct delayed_work poll_timer;
+	struct work_struct led_work;
+};
+
+#define POLL_FREQUENCY 10 /* Number of polls per second */
+
+#if POLL_FREQUENCY > HZ
+#error "POLL_FREQUENCY too high"
+#endif
+
+MODULE_AUTHOR("Stephen Hemminger <shemminger at osdl.org>");
+MODULE_DESCRIPTION("Fujitsu Lifebook Application Panel driver");
+MODULE_LICENSE("GPL");
+MODULE_VERSION("0.2");
+
+static int force;
+module_param(force, bool, 0);
+MODULE_PARM_DESC(force, "Load even if computer is not in database");
+
+/* definitions for i2c (smbus) interface */
+static int apanel_probe(struct i2c_adapter *, int, int);
+
+/* for now, we only support one address */
+static unsigned short normal_i2c[] = {0, I2C_CLIENT_END};
+static unsigned short ignore = I2C_CLIENT_END;
+static struct i2c_client_address_data addr_data = {
+	.normal_i2c	= normal_i2c,
+	.probe		= &ignore,
+	.ignore		= &ignore,
+};
+
+/* Poll for key changes every 100ms
+ *
+ * Read Application keys via SMI
+ *  A (0x4), B (0x8), Internet (0x2), Email (0x1).
+ */
+static void report_key(struct input_dev *input,unsigned keycode)
+{
+	input_report_key(input, keycode, 1);
+	input_sync(input);
+	input_report_key(input, keycode, 0);
+	input_sync(input);
+}
+
+static void apanel_poll(struct work_struct *work)
+{
+	struct apanel *ap = container_of(work, struct apanel, poll_timer.work);
+	u8 cmd = device_chip[APANEL_DEV_APPBTN] == CHIP_OZ992C ? 0 : 8;
+	const struct keymap *key;
+	s32 data;
+	static int read_errors;
+
+	data = i2c_smbus_read_word_data(&ap->client, cmd);
+	if (data < 0) {
+		/* too many errors stop polling */
+		if (++read_errors < 2*HZ/POLL_FREQUENCY)
+			goto reschedule;
+		dev_err(&ap->client.dev, "SMBus read error\n");
+		return;
+	}
+	read_errors = 0;
+
+	i2c_smbus_write_word_data(&ap->client, cmd, 0);
+	if (data)
+		dev_dbg(&ap->client.dev, "poll data=%#x\n", data);
+
+	for (key = keymap; key->mask; ++key)
+		if (data & key->mask)
+			report_key(ap->input, key->keycode);
+reschedule:
+	schedule_delayed_work(&ap->poll_timer, POLL_FREQUENCY);
+}
+
+/* Track state changes of LED
+ * There are actually four LED's (A, B, Internet, E-Mail),
+ * unsure about how to access others and what LED_xxx value would be useful.
+ */
+static void apanel_led(struct work_struct *work)
+{
+	struct apanel *ap = container_of(work, struct apanel, led_work);
+
+	i2c_smbus_write_word_data(&ap->client, 0x10,
+				  test_bit(LED_MAIL, ap->input->led)
+				  ? 0x8000 : 0);
+}
+
+/* Callback from input layer when state change happens.
+ * Used to handle LED control.
+ */
+static int apanel_event(struct input_dev *dev, unsigned int type,
+			unsigned int code, int value)
+{
+	struct apanel *ap = dev->private;
+
+	pr_debug("apanel event type %d\n", type);
+	if (device_chip[APANEL_DEV_LED] == CHIP_NONE || type != EV_LED)
+		return -1;
+
+	schedule_work(&ap->led_work);
+	return 0;
+}
+
+static int apanel_input_open(struct input_dev *dev)
+{
+	struct apanel *ap = dev->private;
+
+	schedule_delayed_work(&ap->poll_timer, POLL_FREQUENCY);
+	return 0;
+}
+
+static void apanel_input_close(struct input_dev *dev)
+{
+	struct apanel *ap = dev->private;
+
+	cancel_rearming_delayed_work(&ap->poll_timer);
+}
+
+#ifdef CONFIG_PM
+/* Stop polling */
+static int apanel_suspend(struct device *dev, pm_message_t state)
+{
+	struct apanel *ap = i2c_get_clientdata(to_i2c_client(dev));
+
+	cancel_rearming_delayed_work(&ap->poll_timer);
+	return 0;
+}
+
+/* If input device was opened, then resume polling */
+static int apanel_resume(struct device *dev)
+{
+	struct apanel *ap = i2c_get_clientdata(to_i2c_client(dev));
+	struct input_dev *input = ap->input;
+
+	mutex_lock(&input->mutex);
+	if (input->users)
+		schedule_delayed_work(&ap->poll_timer, POLL_FREQUENCY);
+	mutex_unlock(&input->mutex);
+	return 0;
+}
+#else
+#define apanel_suspend	NULL
+#define apanel_resume	NULL
+#endif
+
+static int apanel_detach_client(struct i2c_client *client)
+{
+	struct apanel *ap = i2c_get_clientdata(client);
+
+	input_unregister_device(ap->input);
+
+	i2c_detach_client(&ap->client);
+	return 0;
+}
+
+/* Function is invoked for every i2c adapter. */
+static int apanel_attach_adapter(struct i2c_adapter *adap)
+{
+	/* Our device is connected only to i801 on laptop */
+	if (adap->id != I2C_HW_SMBUS_I801)
+		return -ENODEV;
+
+	return i2c_probe(adap, &addr_data, apanel_probe);
+}
+
+static struct i2c_driver apanel_driver = {
+	.driver = {
+		.name = "apanel",
+		.suspend = apanel_suspend,
+		.resume = apanel_resume,
+	},
+	.attach_adapter = &apanel_attach_adapter,
+	.detach_client  = &apanel_detach_client,
+};
+
+/*
+  basically this function should probe the i2c client, but we know that it has
+  to be the one we're looking for - and I have no idea how I should probe for
+  it, so we just register...
+ */
+static int apanel_probe(struct i2c_adapter *adap, int addr, int kind)
+{
+	struct apanel *ap;
+	const struct keymap *key;
+	struct input_dev *input;
+	u8 cmd = device_chip[APANEL_DEV_APPBTN] == CHIP_OZ992C ? 0 : 8;
+	int err = -ENOMEM;
+	static struct apanel apanel = {
+		.client = {
+			.name = "apanel",
+			.driver = &apanel_driver,
+		}
+	};
+
+	ap = &apanel;
+	dev_dbg(&ap->client.dev, "probe adapter %p addr %d kind %d\n",
+		 adap, addr, kind);
+
+	input = input_allocate_device();
+	if (!input)
+		goto out1;
+
+	ap->input = input;
+	ap->client.adapter = adap;
+	ap->client.addr = addr;
+	INIT_DELAYED_WORK(&ap->poll_timer, apanel_poll);
+	INIT_WORK(&ap->led_work, apanel_led);
+	i2c_set_clientdata(&ap->client, ap);
+
+	i2c_smbus_write_word_data(&ap->client, cmd, 0);
+
+	input->name = "Lifebook Panel buttons";
+	input->phys = "apanel/input0";
+	input->id.bustype = BUS_HOST;
+	input->cdev.dev = &ap->client.dev;
+	input->private = ap;
+	input->open = apanel_input_open;
+	input->close = apanel_input_close;
+	input->evbit[LONG(EV_KEY)] = BIT(EV_KEY);
+
+	for (key = keymap; key->mask; ++key)
+		set_bit(key->keycode, input->keybit);
+
+	if (device_chip[APANEL_DEV_LED] != CHIP_NONE) {
+		input->event = apanel_event;
+		input->evbit[0] |= BIT(EV_LED);
+		set_bit(LED_MAIL, input->ledbit);
+	}
+
+	err = i2c_attach_client(&ap->client);
+	if (err)
+		goto out2;
+
+	err = input_register_device(input);
+	if (err)
+		goto out3;
+
+	return 0;
+out3:
+	i2c_detach_client(&ap->client);
+out2:
+	input_free_device(input);
+out1:
+	return err;
+}
+
+/* Scan the system ROM for the signature "FJKEYINF" */
+static __init void __iomem *bios_signature(void)
+{
+	void __iomem *bios;
+	ssize_t offset;
+	const unsigned char signature[] = "FJKEYINF";
+
+	bios = ioremap(0xF0000, 0x10000); /* Can't fail */
+
+	for (offset = 0; offset < 0x10000; offset += 0x10) {
+		if (check_signature(bios + offset, signature,
+				    sizeof(signature)-1))
+			return bios + offset;
+	}
+
+	printk(KERN_ERR  "apanel: Fujitsu BIOS signature '%s' not found...\n",
+	       signature);
+	iounmap(bios);
+	return NULL;
+}
+
+static int __init apanel_init(void)
+{
+	void __iomem *bios;
+	u8 devno;
+	int found = 0;
+
+	if (!dmi_check_system(apanel_dmi_table)) {
+		printk(KERN_WARNING "apanel: DMI information does not match\n");
+		if (!force)
+			return -ENODEV;
+	}
+	BUG_ON(!keymap);
+
+	bios = bios_signature();
+	if (!bios)
+		return -ENODEV;
+
+	bios += 8;
+
+	/* just use the first address */
+	normal_i2c[0] = readb(bios+3) >> 1;
+
+	for ( ; (devno = readb(bios)) & 0x7f; bios += 4) {
+		unsigned char method, slave, chip;
+
+		method = readb(bios + 1);
+		chip = readb(bios + 2);
+		slave = readb(bios + 3) >> 1;
+
+		if (slave != normal_i2c[0]) {
+			printk(KERN_ERR "apanel: only one SMBus slave "
+				 "address supported, skiping device...\n");
+			continue;
+		}
+
+		/* translate alternative device numbers */
+		switch (devno) {
+		case 6:
+			devno = APANEL_DEV_APPBTN;
+			break;
+		case 7:
+			devno = APANEL_DEV_LED;
+			break;
+		}
+
+		if (devno >= APANEL_DEV_MAX)
+			printk(KERN_WARNING "apanel: unknown device %d found\n",
+			       devno);
+		else if (device_chip[devno] != CHIP_NONE)
+			printk(KERN_ERR "apanel: duplicate entry for %s\n",
+			       device_names[devno]);
+
+		else if (method != 1 && method != 2 && method != 4) {
+			printk(KERN_ERR "apanel: unknown  method %u for %s\n",
+			       method, device_names[devno]);
+		} else {
+			pr_debug("apanel: %s found, chip=%d\n",
+				 device_names[devno], chip);
+
+			device_chip[devno] = (enum apanel_chip) chip;
+			++found;
+		}
+	}
+	iounmap(bios);
+
+	if (found == 0) {
+		printk(KERN_ERR "apanel: no input devices reported by BIOS\n");
+		return -EIO;
+	}
+
+	return i2c_add_driver(&apanel_driver);
+}
+module_init(apanel_init);
+
+static void __exit apanel_cleanup(void)
+{
+	i2c_del_driver(&apanel_driver);
+}
+module_exit(apanel_cleanup);



More information about the i2c mailing list