[deliverable/linux.git] / drivers / input / misc / sgi_btns.c

/*
 *  SGI Volume Button interface driver
 *
 *  Copyright (C) 2008  Thomas Bogendoerfer <tsbogend@alpha.franken.de>
 *
 *  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.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */
#include <linux/input-polldev.h>
#include <linux/ioport.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/slab.h>

#ifdef CONFIG_SGI_IP22
#include <asm/sgi/ioc.h>

static inline u8 button_status(void)
{
	u8 status;

	status = readb(&sgioc->panel) ^ 0xa0;
	return ((status & 0x80) >> 6) | ((status & 0x20) >> 5);
}
#endif

#ifdef CONFIG_SGI_IP32
#include <asm/ip32/mace.h>

static inline u8 button_status(void)
{
	u64 status;

	status = readq(&mace->perif.audio.control);
	writeq(status & ~(3U << 23), &mace->perif.audio.control);

	return (status >> 23) & 3;
}
#endif

#define BUTTONS_POLL_INTERVAL	30	/* msec */
#define BUTTONS_COUNT_THRESHOLD	3

static const unsigned short sgi_map[] = {
	KEY_VOLUMEDOWN,
	KEY_VOLUMEUP
};

struct buttons_dev {
	struct input_polled_dev *poll_dev;
	unsigned short keymap[ARRAY_SIZE(sgi_map)];
	int count[ARRAY_SIZE(sgi_map)];
};

static void handle_buttons(struct input_polled_dev *dev)
{
	struct buttons_dev *bdev = dev->private;
	struct input_dev *input = dev->input;
	u8 status;
	int i;

	status = button_status();

	for (i = 0; i < ARRAY_SIZE(bdev->keymap); i++) {
		if (status & (1U << i)) {
			if (++bdev->count[i] == BUTTONS_COUNT_THRESHOLD) {
				input_event(input, EV_MSC, MSC_SCAN, i);
				input_report_key(input, bdev->keymap[i], 1);
				input_sync(input);
			}
		} else {
			if (bdev->count[i] >= BUTTONS_COUNT_THRESHOLD) {
				input_event(input, EV_MSC, MSC_SCAN, i);
				input_report_key(input, bdev->keymap[i], 0);
				input_sync(input);
			}
			bdev->count[i] = 0;
		}
	}
}

static int sgi_buttons_probe(struct platform_device *pdev)
{
	struct buttons_dev *bdev;
	struct input_polled_dev *poll_dev;
	struct input_dev *input;
	int error, i;

	bdev = kzalloc(sizeof(struct buttons_dev), GFP_KERNEL);
	poll_dev = input_allocate_polled_device();
	if (!bdev || !poll_dev) {
		error = -ENOMEM;
		goto err_free_mem;
	}

	memcpy(bdev->keymap, sgi_map, sizeof(bdev->keymap));

	poll_dev->private = bdev;
	poll_dev->poll = handle_buttons;
	poll_dev->poll_interval = BUTTONS_POLL_INTERVAL;

	input = poll_dev->input;
	input->name = "SGI buttons";
	input->phys = "sgi/input0";
	input->id.bustype = BUS_HOST;
	input->dev.parent = &pdev->dev;

	input->keycode = bdev->keymap;
	input->keycodemax = ARRAY_SIZE(bdev->keymap);
	input->keycodesize = sizeof(unsigned short);

	input_set_capability(input, EV_MSC, MSC_SCAN);
	__set_bit(EV_KEY, input->evbit);
	for (i = 0; i < ARRAY_SIZE(sgi_map); i++)
		__set_bit(bdev->keymap[i], input->keybit);
	__clear_bit(KEY_RESERVED, input->keybit);

	bdev->poll_dev = poll_dev;
	platform_set_drvdata(pdev, bdev);

	error = input_register_polled_device(poll_dev);
	if (error)
		goto err_free_mem;

	return 0;

 err_free_mem:
	input_free_polled_device(poll_dev);
	kfree(bdev);
	return error;
}

static int sgi_buttons_remove(struct platform_device *pdev)
{
	struct buttons_dev *bdev = platform_get_drvdata(pdev);

	input_unregister_polled_device(bdev->poll_dev);
	input_free_polled_device(bdev->poll_dev);
	kfree(bdev);

	return 0;
}

static struct platform_driver sgi_buttons_driver = {
	.probe	= sgi_buttons_probe,
	.remove	= sgi_buttons_remove,
	.driver	= {
		.name	= "sgibtns",
	},
};
module_platform_driver(sgi_buttons_driver);

MODULE_LICENSE("GPL");
Commit	Line	Data
3bee2a04	1	/*
48ad88b1	2	* SGI Volume Button interface driver
3bee2a04 TB	3	*
	4	* Copyright (C) 2008 Thomas Bogendoerfer <tsbogend@alpha.franken.de>
	5	*
	6	* This program is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation; either version 2 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program; if not, write to the Free Software
	18	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	*/
3bee2a04 TB	20	#include <linux/input-polldev.h>
	21	#include <linux/ioport.h>
	22	#include <linux/module.h>
	23	#include <linux/platform_device.h>
5a0e3ad6	24	#include <linux/slab.h>
3bee2a04	25
48ad88b1 TB	26	#ifdef CONFIG_SGI_IP22
	27	#include <asm/sgi/ioc.h>
	28
	29	static inline u8 button_status(void)
	30	{
	31	u8 status;
	32
	33	status = readb(&sgioc->panel) ^ 0xa0;
	34	return ((status & 0x80) >> 6) \| ((status & 0x20) >> 5);
	35	}
	36	#endif
	37
	38	#ifdef CONFIG_SGI_IP32
3bee2a04 TB	39	#include <asm/ip32/mace.h>
3bee2a04 TB	40
48ad88b1 TB	41	static inline u8 button_status(void)
	42	{
	43	u64 status;
	44
	45	status = readq(&mace->perif.audio.control);
	46	writeq(status & ~(3U << 23), &mace->perif.audio.control);
	47
	48	return (status >> 23) & 3;
	49	}
	50	#endif
	51
3bee2a04 TB	52	#define BUTTONS_POLL_INTERVAL 30 /* msec */
	53	#define BUTTONS_COUNT_THRESHOLD 3
	54
48ad88b1 TB	55	static const unsigned short sgi_map[] = {
	56	KEY_VOLUMEDOWN,
	57	KEY_VOLUMEUP
3bee2a04 TB	58	};
	59
	60	struct buttons_dev {
	61	struct input_polled_dev *poll_dev;
48ad88b1 TB	62	unsigned short keymap[ARRAY_SIZE(sgi_map)];
48ad88b1 TB	63	int count[ARRAY_SIZE(sgi_map)];
3bee2a04 TB	64	};
	65
	66	static void handle_buttons(struct input_polled_dev *dev)
	67	{
	68	struct buttons_dev *bdev = dev->private;
	69	struct input_dev *input = dev->input;
48ad88b1	70	u8 status;
3bee2a04 TB	71	int i;
3bee2a04 TB	72
48ad88b1	73	status = button_status();
3bee2a04 TB	74
	75	for (i = 0; i < ARRAY_SIZE(bdev->keymap); i++) {
	76	if (status & (1U << i)) {
3bee2a04 TB	77	if (++bdev->count[i] == BUTTONS_COUNT_THRESHOLD) {
	78	input_event(input, EV_MSC, MSC_SCAN, i);
	79	input_report_key(input, bdev->keymap[i], 1);
	80	input_sync(input);
	81	}
	82	} else {
	83	if (bdev->count[i] >= BUTTONS_COUNT_THRESHOLD) {
	84	input_event(input, EV_MSC, MSC_SCAN, i);
	85	input_report_key(input, bdev->keymap[i], 0);
	86	input_sync(input);
	87	}
	88	bdev->count[i] = 0;
	89	}
	90	}
	91	}
	92
5298cc4c	93	static int sgi_buttons_probe(struct platform_device *pdev)
3bee2a04 TB	94	{
	95	struct buttons_dev *bdev;
	96	struct input_polled_dev *poll_dev;
	97	struct input_dev *input;
	98	int error, i;
	99
	100	bdev = kzalloc(sizeof(struct buttons_dev), GFP_KERNEL);
	101	poll_dev = input_allocate_polled_device();
	102	if (!bdev \|\| !poll_dev) {
	103	error = -ENOMEM;
	104	goto err_free_mem;
	105	}
	106
48ad88b1	107	memcpy(bdev->keymap, sgi_map, sizeof(bdev->keymap));
3bee2a04 TB	108
	109	poll_dev->private = bdev;
	110	poll_dev->poll = handle_buttons;
	111	poll_dev->poll_interval = BUTTONS_POLL_INTERVAL;
	112
	113	input = poll_dev->input;
48ad88b1 TB	114	input->name = "SGI buttons";
48ad88b1 TB	115	input->phys = "sgi/input0";
3bee2a04 TB	116	input->id.bustype = BUS_HOST;
	117	input->dev.parent = &pdev->dev;
	118
	119	input->keycode = bdev->keymap;
	120	input->keycodemax = ARRAY_SIZE(bdev->keymap);
	121	input->keycodesize = sizeof(unsigned short);
	122
	123	input_set_capability(input, EV_MSC, MSC_SCAN);
	124	__set_bit(EV_KEY, input->evbit);
48ad88b1	125	for (i = 0; i < ARRAY_SIZE(sgi_map); i++)
3bee2a04 TB	126	__set_bit(bdev->keymap[i], input->keybit);
	127	__clear_bit(KEY_RESERVED, input->keybit);
	128
	129	bdev->poll_dev = poll_dev;
35c4b122	130	platform_set_drvdata(pdev, bdev);
3bee2a04 TB	131
	132	error = input_register_polled_device(poll_dev);
	133	if (error)
	134	goto err_free_mem;
	135
	136	return 0;
	137
	138	err_free_mem:
	139	input_free_polled_device(poll_dev);
	140	kfree(bdev);
3bee2a04 TB	141	return error;
	142	}
	143
e2619cf7	144	static int sgi_buttons_remove(struct platform_device *pdev)
3bee2a04	145	{
35c4b122	146	struct buttons_dev *bdev = platform_get_drvdata(pdev);
3bee2a04 TB	147
	148	input_unregister_polled_device(bdev->poll_dev);
	149	input_free_polled_device(bdev->poll_dev);
	150	kfree(bdev);
3bee2a04 TB	151
	152	return 0;
	153	}
	154
48ad88b1 TB	155	static struct platform_driver sgi_buttons_driver = {
48ad88b1 TB	156	.probe = sgi_buttons_probe,
1cb0aa88	157	.remove = sgi_buttons_remove,
3bee2a04	158	.driver = {
48ad88b1	159	.name = "sgibtns",
3bee2a04 TB	160	},
3bee2a04 TB	161	};
840a746b	162	module_platform_driver(sgi_buttons_driver);
3bee2a04	163
4c2bdcdc	164	MODULE_LICENSE("GPL");