1 files changed, 329 insertions, 0 deletions
diff --git a/drivers/input/misc/dm355evm_keys.c b/drivers/input/misc/dm355evm_keys.c
new file mode 100644
index 000000000000..a63315ce4a6c
--- /dev/null
+++ b/drivers/input/misc/dm355evm_keys.c
@@ -0,0 +1,329 @@
+/*
+ * dm355evm_keys.c - support buttons and IR remote on DM355 EVM board
+ *
+ * Copyright (c) 2008 by David Brownell
+ *
+ * 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.
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/i2c/dm355evm_msp.h>
+/*
+ * The MSP430 firmware on the DM355 EVM monitors on-board pushbuttons
+ * and an IR receptor used for the remote control.  When any key is
+ * pressed, or its autorepeat kicks in, an event is sent.  This driver
+ * read those events from the small (32 event) queue and reports them.
+ *
+ * Because we communicate with the MSP430 using I2C, and all I2C calls
+ * in Linux sleep, we need to cons up a kind of threaded IRQ handler
+ * using a work_struct.  The IRQ is active low, but we use it through
+ * the GPIO controller so we can trigger on falling edges.
+ *
+ * Note that physically there can only be one of these devices.
+ *
+ * This driver was tested with firmware revision A4.
+ */
+struct dm355evm_keys {
+        struct work_struct      work;
+        struct input_dev        *input;
+        struct device           *dev;
+        int                     irq;
+};
+static irqreturn_t dm355evm_keys_irq(int irq, void *_keys)
+{
+        struct dm355evm_keys    *keys = _keys;
+        schedule_work(&keys->work);
+        return IRQ_HANDLED;
+}
+/* These initial keycodes can be remapped by dm355evm_setkeycode(). */
+static struct {
+        u16     event;
+        u16     keycode;
+} dm355evm_keys[] = {
+        /*
+         * Pushbuttons on the EVM board ... note that the labels for these
+         * are SW10/SW11/etc on the PC board.  The left/right orientation
+         * comes only from the firmware's documentation, and presumes the
+         * power connector is immediately in front of you and the IR sensor
+         * is to the right.  (That is, rotate the board counter-clockwise
+         * by 90 degrees from the SW10/etc and "DM355 EVM" labels.)
+         */
+        { 0x00d8, KEY_OK, },            /* SW12 */
+        { 0x00b8, KEY_UP, },            /* SW13 */
+        { 0x00e8, KEY_DOWN, },          /* SW11 */
+        { 0x0078, KEY_LEFT, },          /* SW14 */
+        { 0x00f0, KEY_RIGHT, },         /* SW10 */
+        /*
+         * IR buttons ... codes assigned to match the universal remote
+         * provided with the EVM (Philips PM4S) using DVD code 0020.
+         *
+         * These event codes match firmware documentation, but other
+         * remote controls could easily send more RC5-encoded events.
+         * The PM4S manual was used in several cases to help select
+         * a keycode reflecting the intended usage.
+         *
+         * RC5 codes are 14 bits, with two start bits (0x3 prefix)
+         * and a toggle bit (masked out below).
+         */
+        { 0x300c, KEY_POWER, },         /* NOTE: docs omit this */
+        { 0x3000, KEY_NUMERIC_0, },
+        { 0x3001, KEY_NUMERIC_1, },
+        { 0x3002, KEY_NUMERIC_2, },
+        { 0x3003, KEY_NUMERIC_3, },
+        { 0x3004, KEY_NUMERIC_4, },
+        { 0x3005, KEY_NUMERIC_5, },
+        { 0x3006, KEY_NUMERIC_6, },
+        { 0x3007, KEY_NUMERIC_7, },
+        { 0x3008, KEY_NUMERIC_8, },
+        { 0x3009, KEY_NUMERIC_9, },
+        { 0x3022, KEY_ENTER, },
+        { 0x30ec, KEY_MODE, },          /* "tv/vcr/..." */
+        { 0x300f, KEY_SELECT, },        /* "info" */
+        { 0x3020, KEY_CHANNELUP, },     /* "up" */
+        { 0x302e, KEY_MENU, },          /* "in/out" */
+        { 0x3011, KEY_VOLUMEDOWN, },    /* "left" */
+        { 0x300d, KEY_MUTE, },          /* "ok" */
+        { 0x3010, KEY_VOLUMEUP, },      /* "right" */
+        { 0x301e, KEY_SUBTITLE, },      /* "cc" */
+        { 0x3021, KEY_CHANNELDOWN, },   /* "down" */
+        { 0x3022, KEY_PREVIOUS, },
+        { 0x3026, KEY_SLEEP, },
+        { 0x3172, KEY_REWIND, },        /* NOTE: docs wrongly say 0x30ca */
+        { 0x3175, KEY_PLAY, },
+        { 0x3174, KEY_FASTFORWARD, },
+        { 0x3177, KEY_RECORD, },
+        { 0x3176, KEY_STOP, },
+        { 0x3169, KEY_PAUSE, },
+};
+static void dm355evm_keys_work(struct work_struct *work)
+{
+        struct dm355evm_keys    *keys;
+        int                     status;
+        keys = container_of(work, struct dm355evm_keys, work);
+        /* For simplicity we ignore INPUT_COUNT and just read
+         * events until we get the "queue empty" indicator.
+         * Reading INPUT_LOW decrements the count.
+         */
+        for (;;) {
+                static u16      last_event;
+                u16             event;
+                int             keycode;
+                int             i;
+                status = dm355evm_msp_read(DM355EVM_MSP_INPUT_HIGH);
+                if (status < 0) {
+                        dev_dbg(keys->dev, "input high err %d\n",
+                                        status);
+                        break;
+                }
+                event = status << 8;
+                status = dm355evm_msp_read(DM355EVM_MSP_INPUT_LOW);
+                if (status < 0) {
+                        dev_dbg(keys->dev, "input low err %d\n",
+                                        status);
+                        break;
+                }
+                event |= status;
+                if (event == 0xdead)
+                        break;
+                /* Press and release a button:  two events, same code.
+                 * Press and hold (autorepeat), then release: N events
+                 * (N > 2), same code.  For RC5 buttons the toggle bits
+                 * distinguish (for example) "1-autorepeat" from "1 1";
+                 * but PCB buttons don't support that bit.
+                 *
+                 * So we must synthesize release events.  We do that by
+                 * mapping events to a press/release event pair; then
+                 * to avoid adding extra events, skip the second event
+                 * of each pair.
+                 */
+                if (event == last_event) {
+                        last_event = 0;
+                        continue;
+                }
+                last_event = event;
+                /* ignore the RC5 toggle bit */
+                event &= ~0x0800;
+                /* find the key, or leave it as unknown */
+                keycode = KEY_UNKNOWN;
+                for (i = 0; i < ARRAY_SIZE(dm355evm_keys); i++) {
+                        if (dm355evm_keys[i].event != event)
+                                continue;
+                        keycode = dm355evm_keys[i].keycode;
+                        break;
+                }
+                dev_dbg(keys->dev,
+                        "input event 0x%04x--> keycode %d\n",
+                        event, keycode);
+                /* report press + release */
+                input_report_key(keys->input, keycode, 1);
+                input_sync(keys->input);
+                input_report_key(keys->input, keycode, 0);
+                input_sync(keys->input);
+        }
+}
+static int dm355evm_setkeycode(struct input_dev *dev, int index, int keycode)
+{
+        u16             old_keycode;
+        unsigned        i;
+        if (((unsigned)index) >= ARRAY_SIZE(dm355evm_keys))
+                return -EINVAL;
+        old_keycode = dm355evm_keys[index].keycode;
+        dm355evm_keys[index].keycode = keycode;
+        set_bit(keycode, dev->keybit);
+        for (i = 0; i < ARRAY_SIZE(dm355evm_keys); i++) {
+                if (dm355evm_keys[index].keycode == old_keycode)
+                        goto done;
+        }
+        clear_bit(old_keycode, dev->keybit);
+done:
+        return 0;
+}
+static int dm355evm_getkeycode(struct input_dev *dev, int index, int *keycode)
+{
+        if (((unsigned)index) >= ARRAY_SIZE(dm355evm_keys))
+                return -EINVAL;
+        return dm355evm_keys[index].keycode;
+}
+/*----------------------------------------------------------------------*/
+static int __devinit dm355evm_keys_probe(struct platform_device *pdev)
+{
+        struct dm355evm_keys    *keys;
+        struct input_dev        *input;
+        int                     status;
+        int                     i;
+        /* allocate instance struct and input dev */
+        keys = kzalloc(sizeof *keys, GFP_KERNEL);
+        input = input_allocate_device();
+        if (!keys || !input) {
+                status = -ENOMEM;
+                goto fail1;
+        }
+        keys->dev = &pdev->dev;
+        keys->input = input;
+        INIT_WORK(&keys->work, dm355evm_keys_work);
+        /* set up "threaded IRQ handler" */
+        status = platform_get_irq(pdev, 0);
+        if (status < 0)
+                goto fail1;
+        keys->irq = status;
+        input_set_drvdata(input, keys);
+        input->name = "DM355 EVM Controls";
+        input->phys = "dm355evm/input0";
+        input->dev.parent = &pdev->dev;
+        input->id.bustype = BUS_I2C;
+        input->id.product = 0x0355;
+        input->id.version = dm355evm_msp_read(DM355EVM_MSP_FIRMREV);
+        input->evbit[0] = BIT(EV_KEY);
+        for (i = 0; i < ARRAY_SIZE(dm355evm_keys); i++)
+                __set_bit(dm355evm_keys[i].keycode, input->keybit);
+        input->setkeycode = dm355evm_setkeycode;
+        input->getkeycode = dm355evm_getkeycode;
+        /* REVISIT:  flush the event queue? */
+        status = request_irq(keys->irq, dm355evm_keys_irq,
+                             IRQF_TRIGGER_FALLING,
+                             dev_name(&pdev->dev), keys);
+        if (status < 0)
+                goto fail1;
+        /* register */
+        status = input_register_device(input);
+        if (status < 0)
+                goto fail2;
+        platform_set_drvdata(pdev, keys);
+        return 0;
+fail2:
+        free_irq(keys->irq, keys);
+fail1:
+        input_free_device(input);
+        kfree(keys);
+        dev_err(&pdev->dev, "can't register, err %d\n", status);
+        return status;
+}
+static int __devexit dm355evm_keys_remove(struct platform_device *pdev)
+{
+        struct dm355evm_keys    *keys = platform_get_drvdata(pdev);
+        free_irq(keys->irq, keys);
+        input_unregister_device(keys->input);
+        kfree(keys);
+        return 0;
+}
+/* REVISIT:  add suspend/resume when DaVinci supports it.  The IRQ should
+ * be able to wake up the system.  When device_may_wakeup(&pdev->dev), call
+ * enable_irq_wake() on suspend, and disable_irq_wake() on resume.
+ */
+/*
+ * I2C is used to talk to the MSP430, but this platform device is
+ * exposed by an MFD driver that manages I2C communications.
+ */
+static struct platform_driver dm355evm_keys_driver = {
+        .probe          = dm355evm_keys_probe,
+        .remove         = __devexit_p(dm355evm_keys_remove),
+        .driver         = {
+                .owner  = THIS_MODULE,
+                .name   = "dm355evm_keys",
+        },
+};
+static int __init dm355evm_keys_init(void)
+{
+        return platform_driver_register(&dm355evm_keys_driver);
+}
+module_init(dm355evm_keys_init);
+static void __exit dm355evm_keys_exit(void)
+{
+        platform_driver_unregister(&dm355evm_keys_driver);
+}
+module_exit(dm355evm_keys_exit);
+MODULE_LICENSE("GPL");

diff --git a/drivers/input/misc/dm355evm_keys.c b/drivers/input/misc/dm355evm_keys.c new file mode 100644 index 000000000000..a63315ce4a6c --- /dev/null +++ b/drivers/input/misc/dm355evm_keys.c
@@ -0,0 +1,329 @@
	1	/*
	2	* dm355evm_keys.c - support buttons and IR remote on DM355 EVM board
	3	*
	4	* Copyright (c) 2008 by David Brownell
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the License, or (at your option) any later version.
	10	*/
	11	#include <linux/kernel.h>
	12	#include <linux/init.h>
	13	#include <linux/input.h>
	14	#include <linux/platform_device.h>
	15	#include <linux/interrupt.h>
	16
	17	#include <linux/i2c/dm355evm_msp.h>
	18
	19
	20	/*
	21	* The MSP430 firmware on the DM355 EVM monitors on-board pushbuttons
	22	* and an IR receptor used for the remote control. When any key is
	23	* pressed, or its autorepeat kicks in, an event is sent. This driver
	24	* read those events from the small (32 event) queue and reports them.
	25	*
	26	* Because we communicate with the MSP430 using I2C, and all I2C calls
	27	* in Linux sleep, we need to cons up a kind of threaded IRQ handler
	28	* using a work_struct. The IRQ is active low, but we use it through
	29	* the GPIO controller so we can trigger on falling edges.
	30	*
	31	* Note that physically there can only be one of these devices.
	32	*
	33	* This driver was tested with firmware revision A4.
	34	*/
	35	struct dm355evm_keys {
	36	struct work_struct work;
	37	struct input_dev *input;
	38	struct device *dev;
	39	int irq;
	40	};
	41
	42	static irqreturn_t dm355evm_keys_irq(int irq, void *_keys)
	43	{
	44	struct dm355evm_keys *keys = _keys;
	45
	46	schedule_work(&keys->work);
	47	return IRQ_HANDLED;
	48	}
	49
	50	/* These initial keycodes can be remapped by dm355evm_setkeycode(). */
	51	static struct {
	52	u16 event;
	53	u16 keycode;
	54	} dm355evm_keys[] = {
	55
	56	/*
	57	* Pushbuttons on the EVM board ... note that the labels for these
	58	* are SW10/SW11/etc on the PC board. The left/right orientation
	59	* comes only from the firmware's documentation, and presumes the
	60	* power connector is immediately in front of you and the IR sensor
	61	* is to the right. (That is, rotate the board counter-clockwise
	62	* by 90 degrees from the SW10/etc and "DM355 EVM" labels.)
	63	*/
	64	{ 0x00d8, KEY_OK, }, /* SW12 */
	65	{ 0x00b8, KEY_UP, }, /* SW13 */
	66	{ 0x00e8, KEY_DOWN, }, /* SW11 */
	67	{ 0x0078, KEY_LEFT, }, /* SW14 */
	68	{ 0x00f0, KEY_RIGHT, }, /* SW10 */
	69
	70	/*
	71	* IR buttons ... codes assigned to match the universal remote
	72	* provided with the EVM (Philips PM4S) using DVD code 0020.
	73	*
	74	* These event codes match firmware documentation, but other
	75	* remote controls could easily send more RC5-encoded events.
	76	* The PM4S manual was used in several cases to help select
	77	* a keycode reflecting the intended usage.
	78	*
	79	* RC5 codes are 14 bits, with two start bits (0x3 prefix)
	80	* and a toggle bit (masked out below).
	81	*/
	82	{ 0x300c, KEY_POWER, }, /* NOTE: docs omit this */
	83	{ 0x3000, KEY_NUMERIC_0, },
	84	{ 0x3001, KEY_NUMERIC_1, },
	85	{ 0x3002, KEY_NUMERIC_2, },
	86	{ 0x3003, KEY_NUMERIC_3, },
	87	{ 0x3004, KEY_NUMERIC_4, },
	88	{ 0x3005, KEY_NUMERIC_5, },
	89	{ 0x3006, KEY_NUMERIC_6, },
	90	{ 0x3007, KEY_NUMERIC_7, },
	91	{ 0x3008, KEY_NUMERIC_8, },
	92	{ 0x3009, KEY_NUMERIC_9, },
	93	{ 0x3022, KEY_ENTER, },
	94	{ 0x30ec, KEY_MODE, }, /* "tv/vcr/..." */
	95	{ 0x300f, KEY_SELECT, }, /* "info" */
	96	{ 0x3020, KEY_CHANNELUP, }, /* "up" */
	97	{ 0x302e, KEY_MENU, }, /* "in/out" */
	98	{ 0x3011, KEY_VOLUMEDOWN, }, /* "left" */
	99	{ 0x300d, KEY_MUTE, }, /* "ok" */
	100	{ 0x3010, KEY_VOLUMEUP, }, /* "right" */
	101	{ 0x301e, KEY_SUBTITLE, }, /* "cc" */
	102	{ 0x3021, KEY_CHANNELDOWN, }, /* "down" */
	103	{ 0x3022, KEY_PREVIOUS, },
	104	{ 0x3026, KEY_SLEEP, },
	105	{ 0x3172, KEY_REWIND, }, /* NOTE: docs wrongly say 0x30ca */
	106	{ 0x3175, KEY_PLAY, },
	107	{ 0x3174, KEY_FASTFORWARD, },
	108	{ 0x3177, KEY_RECORD, },
	109	{ 0x3176, KEY_STOP, },
	110	{ 0x3169, KEY_PAUSE, },
	111	};
	112
	113	static void dm355evm_keys_work(struct work_struct *work)
	114	{
	115	struct dm355evm_keys *keys;
	116	int status;
	117
	118	keys = container_of(work, struct dm355evm_keys, work);
	119
	120	/* For simplicity we ignore INPUT_COUNT and just read
	121	* events until we get the "queue empty" indicator.
	122	* Reading INPUT_LOW decrements the count.
	123	*/
	124	for (;;) {
	125	static u16 last_event;
	126	u16 event;
	127	int keycode;
	128	int i;
	129
	130	status = dm355evm_msp_read(DM355EVM_MSP_INPUT_HIGH);
	131	if (status < 0) {
	132	dev_dbg(keys->dev, "input high err %d\n",
	133	status);
	134	break;
	135	}
	136	event = status << 8;
	137
	138	status = dm355evm_msp_read(DM355EVM_MSP_INPUT_LOW);
	139	if (status < 0) {
	140	dev_dbg(keys->dev, "input low err %d\n",
	141	status);
	142	break;
	143	}
	144	event \|= status;
	145	if (event == 0xdead)
	146	break;
	147
	148	/* Press and release a button: two events, same code.
	149	* Press and hold (autorepeat), then release: N events
	150	* (N > 2), same code. For RC5 buttons the toggle bits
	151	* distinguish (for example) "1-autorepeat" from "1 1";
	152	* but PCB buttons don't support that bit.
	153	*
	154	* So we must synthesize release events. We do that by
	155	* mapping events to a press/release event pair; then
	156	* to avoid adding extra events, skip the second event
	157	* of each pair.
	158	*/
	159	if (event == last_event) {
	160	last_event = 0;
	161	continue;
	162	}
	163	last_event = event;
	164
	165	/* ignore the RC5 toggle bit */
	166	event &= ~0x0800;
	167
	168	/* find the key, or leave it as unknown */
	169	keycode = KEY_UNKNOWN;
	170	for (i = 0; i < ARRAY_SIZE(dm355evm_keys); i++) {
	171	if (dm355evm_keys[i].event != event)
	172	continue;
	173	keycode = dm355evm_keys[i].keycode;
	174	break;
	175	}
	176	dev_dbg(keys->dev,
	177	"input event 0x%04x--> keycode %d\n",
	178	event, keycode);
	179
	180	/* report press + release */
	181	input_report_key(keys->input, keycode, 1);
	182	input_sync(keys->input);
	183	input_report_key(keys->input, keycode, 0);
	184	input_sync(keys->input);
	185	}
	186	}
	187
	188	static int dm355evm_setkeycode(struct input_dev *dev, int index, int keycode)
	189	{
	190	u16 old_keycode;
	191	unsigned i;
	192
	193	if (((unsigned)index) >= ARRAY_SIZE(dm355evm_keys))
	194	return -EINVAL;
	195
	196	old_keycode = dm355evm_keys[index].keycode;
	197	dm355evm_keys[index].keycode = keycode;
	198	set_bit(keycode, dev->keybit);
	199
	200	for (i = 0; i < ARRAY_SIZE(dm355evm_keys); i++) {
	201	if (dm355evm_keys[index].keycode == old_keycode)
	202	goto done;
	203	}
	204	clear_bit(old_keycode, dev->keybit);
	205	done:
	206	return 0;
	207	}
	208
	209	static int dm355evm_getkeycode(struct input_dev dev, int index, int keycode)
	210	{
	211	if (((unsigned)index) >= ARRAY_SIZE(dm355evm_keys))
	212	return -EINVAL;
	213
	214	return dm355evm_keys[index].keycode;
	215	}
	216
	217	/----------------------------------------------------------------------/
	218
	219	static int __devinit dm355evm_keys_probe(struct platform_device *pdev)
	220	{
	221	struct dm355evm_keys *keys;
	222	struct input_dev *input;
	223	int status;
	224	int i;
	225
	226	/* allocate instance struct and input dev */
	227	keys = kzalloc(sizeof *keys, GFP_KERNEL);
	228	input = input_allocate_device();
	229	if (!keys \|\| !input) {
	230	status = -ENOMEM;
	231	goto fail1;
	232	}
	233
	234	keys->dev = &pdev->dev;
	235	keys->input = input;
	236	INIT_WORK(&keys->work, dm355evm_keys_work);
	237
	238	/* set up "threaded IRQ handler" */
	239	status = platform_get_irq(pdev, 0);
	240	if (status < 0)
	241	goto fail1;
	242	keys->irq = status;
	243
	244	input_set_drvdata(input, keys);
	245
	246	input->name = "DM355 EVM Controls";
	247	input->phys = "dm355evm/input0";
	248	input->dev.parent = &pdev->dev;
	249
	250	input->id.bustype = BUS_I2C;
	251	input->id.product = 0x0355;
	252	input->id.version = dm355evm_msp_read(DM355EVM_MSP_FIRMREV);
	253
	254	input->evbit[0] = BIT(EV_KEY);
	255	for (i = 0; i < ARRAY_SIZE(dm355evm_keys); i++)
	256	__set_bit(dm355evm_keys[i].keycode, input->keybit);
	257
	258	input->setkeycode = dm355evm_setkeycode;
	259	input->getkeycode = dm355evm_getkeycode;
	260
	261	/* REVISIT: flush the event queue? */
	262
	263	status = request_irq(keys->irq, dm355evm_keys_irq,
	264	IRQF_TRIGGER_FALLING,
	265	dev_name(&pdev->dev), keys);
	266	if (status < 0)
	267	goto fail1;
	268
	269	/* register */
	270	status = input_register_device(input);
	271	if (status < 0)
	272	goto fail2;
	273
	274	platform_set_drvdata(pdev, keys);
	275
	276	return 0;
	277
	278	fail2:
	279	free_irq(keys->irq, keys);
	280	fail1:
	281	input_free_device(input);
	282	kfree(keys);
	283	dev_err(&pdev->dev, "can't register, err %d\n", status);
	284
	285	return status;
	286	}
	287
	288	static int __devexit dm355evm_keys_remove(struct platform_device *pdev)
	289	{
	290	struct dm355evm_keys *keys = platform_get_drvdata(pdev);
	291
	292	free_irq(keys->irq, keys);
	293	input_unregister_device(keys->input);
	294	kfree(keys);
	295
	296	return 0;
	297	}
	298
	299	/* REVISIT: add suspend/resume when DaVinci supports it. The IRQ should
	300	* be able to wake up the system. When device_may_wakeup(&pdev->dev), call
	301	* enable_irq_wake() on suspend, and disable_irq_wake() on resume.
	302	*/
	303
	304	/*
	305	* I2C is used to talk to the MSP430, but this platform device is
	306	* exposed by an MFD driver that manages I2C communications.
	307	*/
	308	static struct platform_driver dm355evm_keys_driver = {
	309	.probe = dm355evm_keys_probe,
	310	.remove = __devexit_p(dm355evm_keys_remove),
	311	.driver = {
	312	.owner = THIS_MODULE,
	313	.name = "dm355evm_keys",
	314	},
	315	};
	316
	317	static int __init dm355evm_keys_init(void)
	318	{
	319	return platform_driver_register(&dm355evm_keys_driver);
	320	}
	321	module_init(dm355evm_keys_init);
	322
	323	static void __exit dm355evm_keys_exit(void)
	324	{
	325	platform_driver_unregister(&dm355evm_keys_driver);
	326	}
	327	module_exit(dm355evm_keys_exit);
	328
	329	MODULE_LICENSE("GPL");