drivers/input/misc/alps_gpio_scrollwheel.c - kernel/tegra - Git at Google

 /*
  * kernel/drivers/input/misc/alps_gpio_scrollwheel.c
  *
  * Copyright (c) 2010, NVIDIA Corporation.
  *
  * Driver for ScrollWheel on GPIO lines capable of generating interrupts.
  *
  * 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/module.h>
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/sched.h>
 #include <linux/pm.h>
 #include <linux/slab.h>
 #include <linux/sysctl.h>
 #include <linux/proc_fs.h>
 #include <linux/delay.h>
 #include <linux/platform_device.h>
 #include <linux/input.h>
 #include <linux/gpio_scrollwheel.h>
 #include <linux/workqueue.h>
 #include <linux/gpio.h>

 struct scrollwheel_button_data {
 	struct gpio_scrollwheel_button *button;
 	struct input_dev *input;
 	struct timer_list timer;
 	struct work_struct work;
 	int timer_debounce;	/* in msecs */
 	int rotgpio;
 	bool disabled;
 };

 struct gpio_scrollwheel_drvdata {
 	struct input_dev *input;
 	struct mutex disable_lock;
 	unsigned int n_buttons;
 	int (*enable)(struct device *dev);
 	void (*disable)(struct device *dev);
 	struct scrollwheel_button_data data[0];
 };

 static void scrollwheel_report_key(struct scrollwheel_button_data *bdata)
 {
 	struct gpio_scrollwheel_button *button = bdata->button;
 	struct input_dev *input = bdata->input;
 	int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ \
 				button->active_low;
 	int state2 = 0;

 	switch (button->pinaction) {
 	case GPIO_SCROLLWHEEL_PIN_PRESS:
 		input_report_key(input, KEY_ENTER, 1);
 		input_report_key(input, KEY_ENTER, 0);
 		input_sync(input);
 		break;

 	case GPIO_SCROLLWHEEL_PIN_ROT1:
 	case GPIO_SCROLLWHEEL_PIN_ROT2:
 		state2 = (gpio_get_value(bdata->rotgpio) ? 1 : 0) \
 					^ button->active_low;
 		if (state != state2) {
 			input_report_key(input, KEY_DOWN, 1);
 			input_report_key(input, KEY_DOWN, 0);
 		} else {
 			input_report_key(input, KEY_UP, 1);
 			input_report_key(input, KEY_UP, 0);
 		}
 		input_sync(input);
 		break;

 	default:
 		pr_err("%s:Line=%d, Invalid Pinaction\n", __func__, __LINE__);
 	}
 }

 static void scrollwheel_work_func(struct work_struct *work)
 {
 	struct scrollwheel_button_data *bdata =
 		container_of(work, struct scrollwheel_button_data, work);

 	scrollwheel_report_key(bdata);
 }

 static void scrollwheel_timer(unsigned long _data)
 {
 	struct scrollwheel_button_data *data = \
 		(struct scrollwheel_button_data *)_data;

 	schedule_work(&data->work);
 }

 static irqreturn_t scrollwheel_isr(int irq, void *dev_id)
 {
 	struct scrollwheel_button_data *bdata = dev_id;
 	struct gpio_scrollwheel_button *button = bdata->button;

 	BUG_ON(irq != gpio_to_irq(button->gpio));

 	if (bdata->timer_debounce)
 		mod_timer(&bdata->timer,
 			jiffies + msecs_to_jiffies(bdata->timer_debounce));
 	else
 		schedule_work(&bdata->work);

 	return IRQ_HANDLED;
 }

 static int __devinit gpio_scrollwheel_setup_key(struct platform_device *pdev,
 			struct scrollwheel_button_data *bdata,
 			struct gpio_scrollwheel_button *button)
 {
 	char *desc = button->desc ? button->desc : "gpio_scrollwheel";
 	struct device *dev = &pdev->dev;
 	unsigned long irqflags;
 	int irq, error;

 	setup_timer(&bdata->timer, scrollwheel_timer, (unsigned long)bdata);
 	INIT_WORK(&bdata->work, scrollwheel_work_func);

 	error = gpio_request(button->gpio, desc);
 	if (error < 0) {
 		dev_err(dev, "failed to request GPIO %d, error %d\n",
 			button->gpio, error);
 		return error;
 	}

 	error = gpio_direction_input(button->gpio);
 	if (error < 0) {
 		dev_err(dev, "failed to configure"
 			" direction for GPIO %d, error %d\n",
 			button->gpio, error);
 		goto fail;
 	}

 	if (button->debounce_interval) {
 		error = gpio_set_debounce(button->gpio,
 					  button->debounce_interval * 1000);
 		/* use timer if gpiolib doesn't provide debounce */
 		if (error < 0)
 			bdata->timer_debounce = button->debounce_interval;
 	}

 	irq = gpio_to_irq(button->gpio);
 	if (irq < 0) {
 		error = irq;
 		dev_err(dev, "Unable to get irq no for GPIO %d, error %d\n",
 			button->gpio, error);
 		goto fail;
 	}

 	irqflags = IRQF_TRIGGER_FALLING;

 	error = request_irq(irq, scrollwheel_isr, irqflags, desc, bdata);
 	if (error) {
 		dev_err(dev, "Unable to claim irq %d; error %d\n",
 			irq, error);
 		goto fail;
 	}

 	return 0;

 fail:
 	return error;
 }

 static int gpio_scrollwheel_open(struct input_dev *input)
 {
 	struct gpio_scrollwheel_drvdata *ddata = input_get_drvdata(input);

 	return ddata->enable ? ddata->enable(input->dev.parent) : 0;
 }

 static void gpio_scrollwheel_close(struct input_dev *input)
 {
 	struct gpio_scrollwheel_drvdata *ddata = input_get_drvdata(input);

 	if (ddata->disable)
 		ddata->disable(input->dev.parent);
 }

 static int __devinit gpio_scrollwheel_probe(struct platform_device *pdev)
 {
 	struct gpio_scrollwheel_platform_data *pdata = pdev->dev.platform_data;
 	struct gpio_scrollwheel_drvdata *ddata;
 	struct device *dev = &pdev->dev;
 	struct input_dev *input;
 	int i, error;

 	ddata = kzalloc(sizeof(struct gpio_scrollwheel_drvdata) +
 		pdata->nbuttons * sizeof(struct scrollwheel_button_data),
 		GFP_KERNEL);
 	if (ddata == NULL) {
 		dev_err(dev, "failed to allocate memory\n");
 		error = -ENOMEM;
 		return error;
 	}

 	input = input_allocate_device();
 	if (input == NULL) {
 		dev_err(dev, "failed to allocate input device\n");
 		error = -ENOMEM;
 		kfree(ddata);
 		return error;
 	}

 	ddata->input = input;
 	ddata->n_buttons = pdata->nbuttons;
 	ddata->enable = pdata->enable;
 	ddata->disable = pdata->disable;
 	mutex_init(&ddata->disable_lock);

 	platform_set_drvdata(pdev, ddata);
 	input_set_drvdata(input, ddata);

 	input->name = pdev->name;
 	input->phys = "gpio-scrollwheel/input0";
 	input->dev.parent = &pdev->dev;
 	input->open = gpio_scrollwheel_open;
 	input->close = gpio_scrollwheel_close;

 	input->id.bustype = BUS_HOST;
 	input->id.vendor = 0x0001;
 	input->id.product = 0x0001;
 	input->id.version = 0x0100;

 	/* Enable auto repeat feature of Linux input subsystem */
 	if (pdata->rep)
 		__set_bit(EV_REP, input->evbit);

 	for (i = 0; i < pdata->nbuttons; i++) {
 		struct gpio_scrollwheel_button *button = &pdata->buttons[i];
 		struct scrollwheel_button_data *bdata = &ddata->data[i];

 		bdata->input = input;
 		bdata->button = button;

 		if (button->pinaction == GPIO_SCROLLWHEEL_PIN_PRESS ||
 			button->pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
 			error = gpio_scrollwheel_setup_key(pdev, bdata, button);
 			if (error)
 				goto fail;
 		} else {
 			if (button->pinaction == GPIO_SCROLLWHEEL_PIN_ONOFF) {
 				gpio_request(button->gpio, button->desc);
 				gpio_direction_output(button->gpio, 0);
 			}

 			if (button->pinaction == GPIO_SCROLLWHEEL_PIN_ROT2) {
 				gpio_request(button->gpio, button->desc);
 				gpio_direction_input(button->gpio);
 				/* Save rot2 gpio number in rot1 context */
 				ddata->data[2].rotgpio = button->gpio;
 			}
 		}
 	}

 	/* set input capability */
 	__set_bit(EV_KEY, input->evbit);
 	__set_bit(KEY_ENTER, input->keybit);
 	__set_bit(KEY_UP, input->keybit);
 	__set_bit(KEY_DOWN, input->keybit);

 	error = input_register_device(input);
 	if (error) {
 		dev_err(dev, "Unable to register input device, error: %d\n",
 			error);
 		goto fail;
 	}

 	input_sync(input);

 	return 0;

 fail:
 	while (--i >= 0) {
 		if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_PRESS ||
 			pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
 			free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
 			if (ddata->data[i].timer_debounce)
 				del_timer_sync(&ddata->data[i].timer);
 			cancel_work_sync(&ddata->data[i].work);
 		}
 		gpio_free(pdata->buttons[i].gpio);
 	}

 	platform_set_drvdata(pdev, NULL);
 	input_free_device(input);
 	kfree(ddata);
 	return error;
 }

 static int __devexit gpio_scrollwheel_remove(struct platform_device *pdev)
 {
 	struct gpio_scrollwheel_platform_data *pdata = pdev->dev.platform_data;
 	struct gpio_scrollwheel_drvdata *ddata = platform_get_drvdata(pdev);
 	struct input_dev *input = ddata->input;
 	int i;

 	for (i = 0; i < pdata->nbuttons; i++) {
 		if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_PRESS ||
 			pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
 			int irq = gpio_to_irq(pdata->buttons[i].gpio);
 			free_irq(irq, &ddata->data[i]);
 			if (ddata->data[i].timer_debounce)
 				del_timer_sync(&ddata->data[i].timer);
 			cancel_work_sync(&ddata->data[i].work);
 		}
 		gpio_free(pdata->buttons[i].gpio);
 	}

 	input_unregister_device(input);

 	return 0;
 }


 #ifdef CONFIG_PM
 static int gpio_scrollwheel_suspend(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct gpio_scrollwheel_platform_data *pdata = pdev->dev.platform_data;
 	struct gpio_scrollwheel_drvdata *ddata = platform_get_drvdata(pdev);
 	int i, irq;

 	for (i = 0; i < pdata->nbuttons; i++) {
 		if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_PRESS ||
 			pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
 			irq = gpio_to_irq(pdata->buttons[i].gpio);
 			disable_irq(irq);
 			if (ddata->data[i].timer_debounce)
 				del_timer_sync(&ddata->data[i].timer);
 			cancel_work_sync(&ddata->data[i].work);
 		} else {
 			if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ONOFF)
 				gpio_direction_output(pdata->buttons[i].gpio, 1);
 			else {
 				irq = gpio_to_irq(pdata->buttons[i].gpio);
 				disable_irq(irq);
 			}
 		}
 	}
 	return 0;
 }

 static int gpio_scrollwheel_resume(struct device *dev)
 {
 	struct platform_device *pdev = to_platform_device(dev);
 	struct gpio_scrollwheel_platform_data *pdata = pdev->dev.platform_data;
 	struct gpio_scrollwheel_drvdata *ddata = platform_get_drvdata(pdev);
 	int i, irq;

 	for (i = 0; i < pdata->nbuttons; i++) {
 		if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_PRESS ||
 			pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
 			irq = gpio_to_irq(pdata->buttons[i].gpio);
 			enable_irq(irq);
 			if (ddata->data[i].timer_debounce)
 				setup_timer(&ddata->data[i].timer,\
 				scrollwheel_timer, (unsigned long)&ddata->data[i]);

 			INIT_WORK(&ddata->data[i].work, scrollwheel_work_func);
 		} else {
 			if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ONOFF)
 				gpio_direction_output(pdata->buttons[i].gpio, 0);
 			else {
 				irq = gpio_to_irq(pdata->buttons[i].gpio);
 				enable_irq(irq);
 			}
 		}
 	}

 	return 0;
 }

 static const struct dev_pm_ops gpio_scrollwheel_pm_ops = {
 	.suspend	= gpio_scrollwheel_suspend,
 	.resume		= gpio_scrollwheel_resume,
 };
 #endif

 static struct platform_driver gpio_scrollwheel_device_driver = {
 	.probe		= gpio_scrollwheel_probe,
 	.remove		= __devexit_p(gpio_scrollwheel_remove),
 	.driver		= {
 		.name	= "alps-gpio-scrollwheel",
 		.owner	= THIS_MODULE,
 #ifdef CONFIG_PM
 		.pm	= &gpio_scrollwheel_pm_ops,
 #endif
 	}
 };

 static int __init gpio_scrollwheel_init(void)
 {
 	return platform_driver_register(&gpio_scrollwheel_device_driver);
 }

 static void __exit gpio_scrollwheel_exit(void)
 {
 	platform_driver_unregister(&gpio_scrollwheel_device_driver);
 }

 module_init(gpio_scrollwheel_init);
 module_exit(gpio_scrollwheel_exit);

 MODULE_LICENSE("GPL");
 MODULE_AUTHOR("NVIDIA Corporation");
 MODULE_DESCRIPTION("Alps SRBE ScrollWheel driver");

 MODULE_ALIAS("platform:alps-gpio-scrollwheel");
	/*
	* kernel/drivers/input/misc/alps_gpio_scrollwheel.c
	*
	* Copyright (c) 2010, NVIDIA Corporation.
	*
	* Driver for ScrollWheel on GPIO lines capable of generating interrupts.
	*
	* 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/module.h>
	#include <linux/init.h>
	#include <linux/fs.h>
	#include <linux/interrupt.h>
	#include <linux/irq.h>
	#include <linux/sched.h>
	#include <linux/pm.h>
	#include <linux/slab.h>
	#include <linux/sysctl.h>
	#include <linux/proc_fs.h>
	#include <linux/delay.h>
	#include <linux/platform_device.h>
	#include <linux/input.h>
	#include <linux/gpio_scrollwheel.h>
	#include <linux/workqueue.h>
	#include <linux/gpio.h>

	struct scrollwheel_button_data {
	struct gpio_scrollwheel_button *button;
	struct input_dev *input;
	struct timer_list timer;
	struct work_struct work;
	int timer_debounce; /* in msecs */
	int rotgpio;
	bool disabled;
	};

	struct gpio_scrollwheel_drvdata {
	struct input_dev *input;
	struct mutex disable_lock;
	unsigned int n_buttons;
	int (enable)(struct device dev);
	void (disable)(struct device dev);
	struct scrollwheel_button_data data[0];
	};

	static void scrollwheel_report_key(struct scrollwheel_button_data *bdata)
	{
	struct gpio_scrollwheel_button *button = bdata->button;
	struct input_dev *input = bdata->input;
	int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ \
	button->active_low;
	int state2 = 0;

	switch (button->pinaction) {
	case GPIO_SCROLLWHEEL_PIN_PRESS:
	input_report_key(input, KEY_ENTER, 1);
	input_report_key(input, KEY_ENTER, 0);
	input_sync(input);
	break;

	case GPIO_SCROLLWHEEL_PIN_ROT1:
	case GPIO_SCROLLWHEEL_PIN_ROT2:
	state2 = (gpio_get_value(bdata->rotgpio) ? 1 : 0) \
	^ button->active_low;
	if (state != state2) {
	input_report_key(input, KEY_DOWN, 1);
	input_report_key(input, KEY_DOWN, 0);
	} else {
	input_report_key(input, KEY_UP, 1);
	input_report_key(input, KEY_UP, 0);
	}
	input_sync(input);
	break;

	default:
	pr_err("%s:Line=%d, Invalid Pinaction\n", __func__, __LINE__);
	}
	}

	static void scrollwheel_work_func(struct work_struct *work)
	{
	struct scrollwheel_button_data *bdata =
	container_of(work, struct scrollwheel_button_data, work);

	scrollwheel_report_key(bdata);
	}

	static void scrollwheel_timer(unsigned long _data)
	{
	struct scrollwheel_button_data *data = \
	(struct scrollwheel_button_data *)_data;

	schedule_work(&data->work);
	}

	static irqreturn_t scrollwheel_isr(int irq, void *dev_id)
	{
	struct scrollwheel_button_data *bdata = dev_id;
	struct gpio_scrollwheel_button *button = bdata->button;

	BUG_ON(irq != gpio_to_irq(button->gpio));

	if (bdata->timer_debounce)
	mod_timer(&bdata->timer,
	jiffies + msecs_to_jiffies(bdata->timer_debounce));
	else
	schedule_work(&bdata->work);

	return IRQ_HANDLED;
	}

	static int __devinit gpio_scrollwheel_setup_key(struct platform_device *pdev,
	struct scrollwheel_button_data *bdata,
	struct gpio_scrollwheel_button *button)
	{
	char *desc = button->desc ? button->desc : "gpio_scrollwheel";
	struct device *dev = &pdev->dev;
	unsigned long irqflags;
	int irq, error;

	setup_timer(&bdata->timer, scrollwheel_timer, (unsigned long)bdata);
	INIT_WORK(&bdata->work, scrollwheel_work_func);

	error = gpio_request(button->gpio, desc);
	if (error < 0) {
	dev_err(dev, "failed to request GPIO %d, error %d\n",
	button->gpio, error);
	return error;
	}

	error = gpio_direction_input(button->gpio);
	if (error < 0) {
	dev_err(dev, "failed to configure"
	" direction for GPIO %d, error %d\n",
	button->gpio, error);
	goto fail;
	}

	if (button->debounce_interval) {
	error = gpio_set_debounce(button->gpio,
	button->debounce_interval * 1000);
	/* use timer if gpiolib doesn't provide debounce */
	if (error < 0)
	bdata->timer_debounce = button->debounce_interval;
	}

	irq = gpio_to_irq(button->gpio);
	if (irq < 0) {
	error = irq;
	dev_err(dev, "Unable to get irq no for GPIO %d, error %d\n",
	button->gpio, error);
	goto fail;
	}

	irqflags = IRQF_TRIGGER_FALLING;

	error = request_irq(irq, scrollwheel_isr, irqflags, desc, bdata);
	if (error) {
	dev_err(dev, "Unable to claim irq %d; error %d\n",
	irq, error);
	goto fail;
	}

	return 0;

	fail:
	return error;
	}

	static int gpio_scrollwheel_open(struct input_dev *input)
	{
	struct gpio_scrollwheel_drvdata *ddata = input_get_drvdata(input);

	return ddata->enable ? ddata->enable(input->dev.parent) : 0;
	}

	static void gpio_scrollwheel_close(struct input_dev *input)
	{
	struct gpio_scrollwheel_drvdata *ddata = input_get_drvdata(input);

	if (ddata->disable)
	ddata->disable(input->dev.parent);
	}

	static int __devinit gpio_scrollwheel_probe(struct platform_device *pdev)
	{
	struct gpio_scrollwheel_platform_data *pdata = pdev->dev.platform_data;
	struct gpio_scrollwheel_drvdata *ddata;
	struct device *dev = &pdev->dev;
	struct input_dev *input;
	int i, error;

	ddata = kzalloc(sizeof(struct gpio_scrollwheel_drvdata) +
	pdata->nbuttons * sizeof(struct scrollwheel_button_data),
	GFP_KERNEL);
	if (ddata == NULL) {
	dev_err(dev, "failed to allocate memory\n");
	error = -ENOMEM;
	return error;
	}

	input = input_allocate_device();
	if (input == NULL) {
	dev_err(dev, "failed to allocate input device\n");
	error = -ENOMEM;
	kfree(ddata);
	return error;
	}

	ddata->input = input;
	ddata->n_buttons = pdata->nbuttons;
	ddata->enable = pdata->enable;
	ddata->disable = pdata->disable;
	mutex_init(&ddata->disable_lock);

	platform_set_drvdata(pdev, ddata);
	input_set_drvdata(input, ddata);

	input->name = pdev->name;
	input->phys = "gpio-scrollwheel/input0";
	input->dev.parent = &pdev->dev;
	input->open = gpio_scrollwheel_open;
	input->close = gpio_scrollwheel_close;

	input->id.bustype = BUS_HOST;
	input->id.vendor = 0x0001;
	input->id.product = 0x0001;
	input->id.version = 0x0100;

	/* Enable auto repeat feature of Linux input subsystem */
	if (pdata->rep)
	__set_bit(EV_REP, input->evbit);

	for (i = 0; i < pdata->nbuttons; i++) {
	struct gpio_scrollwheel_button *button = &pdata->buttons[i];
	struct scrollwheel_button_data *bdata = &ddata->data[i];

	bdata->input = input;
	bdata->button = button;

	if (button->pinaction == GPIO_SCROLLWHEEL_PIN_PRESS \|\|
	button->pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
	error = gpio_scrollwheel_setup_key(pdev, bdata, button);
	if (error)
	goto fail;
	} else {
	if (button->pinaction == GPIO_SCROLLWHEEL_PIN_ONOFF) {
	gpio_request(button->gpio, button->desc);
	gpio_direction_output(button->gpio, 0);
	}

	if (button->pinaction == GPIO_SCROLLWHEEL_PIN_ROT2) {
	gpio_request(button->gpio, button->desc);
	gpio_direction_input(button->gpio);
	/* Save rot2 gpio number in rot1 context */
	ddata->data[2].rotgpio = button->gpio;
	}
	}
	}

	/* set input capability */
	__set_bit(EV_KEY, input->evbit);
	__set_bit(KEY_ENTER, input->keybit);
	__set_bit(KEY_UP, input->keybit);
	__set_bit(KEY_DOWN, input->keybit);

	error = input_register_device(input);
	if (error) {
	dev_err(dev, "Unable to register input device, error: %d\n",
	error);
	goto fail;
	}

	input_sync(input);

	return 0;

	fail:
	while (--i >= 0) {
	if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_PRESS \|\|
	pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
	free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
	if (ddata->data[i].timer_debounce)
	del_timer_sync(&ddata->data[i].timer);
	cancel_work_sync(&ddata->data[i].work);
	}
	gpio_free(pdata->buttons[i].gpio);
	}

	platform_set_drvdata(pdev, NULL);
	input_free_device(input);
	kfree(ddata);
	return error;
	}

	static int __devexit gpio_scrollwheel_remove(struct platform_device *pdev)
	{
	struct gpio_scrollwheel_platform_data *pdata = pdev->dev.platform_data;
	struct gpio_scrollwheel_drvdata *ddata = platform_get_drvdata(pdev);
	struct input_dev *input = ddata->input;
	int i;

	for (i = 0; i < pdata->nbuttons; i++) {
	if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_PRESS \|\|
	pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
	int irq = gpio_to_irq(pdata->buttons[i].gpio);
	free_irq(irq, &ddata->data[i]);
	if (ddata->data[i].timer_debounce)
	del_timer_sync(&ddata->data[i].timer);
	cancel_work_sync(&ddata->data[i].work);
	}
	gpio_free(pdata->buttons[i].gpio);
	}

	input_unregister_device(input);

	return 0;
	}


	#ifdef CONFIG_PM
	static int gpio_scrollwheel_suspend(struct device *dev)
	{
	struct platform_device *pdev = to_platform_device(dev);
	struct gpio_scrollwheel_platform_data *pdata = pdev->dev.platform_data;
	struct gpio_scrollwheel_drvdata *ddata = platform_get_drvdata(pdev);
	int i, irq;

	for (i = 0; i < pdata->nbuttons; i++) {
	if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_PRESS \|\|
	pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
	irq = gpio_to_irq(pdata->buttons[i].gpio);
	disable_irq(irq);
	if (ddata->data[i].timer_debounce)
	del_timer_sync(&ddata->data[i].timer);
	cancel_work_sync(&ddata->data[i].work);
	} else {
	if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ONOFF)
	gpio_direction_output(pdata->buttons[i].gpio, 1);
	else {
	irq = gpio_to_irq(pdata->buttons[i].gpio);
	disable_irq(irq);
	}
	}
	}
	return 0;
	}

	static int gpio_scrollwheel_resume(struct device *dev)
	{
	struct platform_device *pdev = to_platform_device(dev);
	struct gpio_scrollwheel_platform_data *pdata = pdev->dev.platform_data;
	struct gpio_scrollwheel_drvdata *ddata = platform_get_drvdata(pdev);
	int i, irq;

	for (i = 0; i < pdata->nbuttons; i++) {
	if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_PRESS \|\|
	pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ROT1) {
	irq = gpio_to_irq(pdata->buttons[i].gpio);
	enable_irq(irq);
	if (ddata->data[i].timer_debounce)
	setup_timer(&ddata->data[i].timer,\
	scrollwheel_timer, (unsigned long)&ddata->data[i]);

	INIT_WORK(&ddata->data[i].work, scrollwheel_work_func);
	} else {
	if (pdata->buttons[i].pinaction == GPIO_SCROLLWHEEL_PIN_ONOFF)
	gpio_direction_output(pdata->buttons[i].gpio, 0);
	else {
	irq = gpio_to_irq(pdata->buttons[i].gpio);
	enable_irq(irq);
	}
	}
	}

	return 0;
	}

	static const struct dev_pm_ops gpio_scrollwheel_pm_ops = {
	.suspend = gpio_scrollwheel_suspend,
	.resume = gpio_scrollwheel_resume,
	};
	#endif

	static struct platform_driver gpio_scrollwheel_device_driver = {
	.probe = gpio_scrollwheel_probe,
	.remove = __devexit_p(gpio_scrollwheel_remove),
	.driver = {
	.name = "alps-gpio-scrollwheel",
	.owner = THIS_MODULE,
	#ifdef CONFIG_PM
	.pm = &gpio_scrollwheel_pm_ops,
	#endif
	}
	};

	static int __init gpio_scrollwheel_init(void)
	{
	return platform_driver_register(&gpio_scrollwheel_device_driver);
	}

	static void __exit gpio_scrollwheel_exit(void)
	{
	platform_driver_unregister(&gpio_scrollwheel_device_driver);
	}

	module_init(gpio_scrollwheel_init);
	module_exit(gpio_scrollwheel_exit);

	MODULE_LICENSE("GPL");
	MODULE_AUTHOR("NVIDIA Corporation");
	MODULE_DESCRIPTION("Alps SRBE ScrollWheel driver");

	MODULE_ALIAS("platform:alps-gpio-scrollwheel");