4 * (c) 2009 Daniel Mack <daniel@caiaq.de>
6 * state machine code inspired by code from Tim Ruetz
8 * A generic driver for rotary encoders connected to GPIO lines.
9 * See file:Documentation/input/rotary_encoder.txt for more information
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License version 2 as
13 * published by the Free Software Foundation.
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/init.h>
19 #include <linux/interrupt.h>
20 #include <linux/input.h>
21 #include <linux/device.h>
22 #include <linux/platform_device.h>
23 #include <linux/gpio.h>
24 #include <linux/rotary_encoder.h>
26 #define DRV_NAME "rotary-encoder"
28 struct rotary_encoder
{
29 struct input_dev
*input
;
30 struct rotary_encoder_platform_data
*pdata
;
39 unsigned char dir
; /* 0 - clockwise, 1 - CCW */
42 static irqreturn_t
rotary_encoder_irq(int irq
, void *dev_id
)
44 struct rotary_encoder
*encoder
= dev_id
;
45 struct rotary_encoder_platform_data
*pdata
= encoder
->pdata
;
46 int a
= !!gpio_get_value(pdata
->gpio_a
);
47 int b
= !!gpio_get_value(pdata
->gpio_b
);
50 a
^= pdata
->inverted_a
;
51 b
^= pdata
->inverted_b
;
60 if (pdata
->relative_axis
) {
61 input_report_rel(encoder
->input
, pdata
->axis
,
62 encoder
->dir
? -1 : 1);
64 unsigned int pos
= encoder
->pos
;
67 /* turning counter-clockwise */
73 /* turning clockwise */
74 if (pdata
->rollover
|| pos
< pdata
->steps
)
80 input_report_abs(encoder
->input
, pdata
->axis
,
83 input_sync(encoder
->input
);
85 encoder
->armed
= false;
91 encoder
->dir
= state
- 1;
95 encoder
->armed
= true;
102 static int __devinit
rotary_encoder_probe(struct platform_device
*pdev
)
104 struct rotary_encoder_platform_data
*pdata
= pdev
->dev
.platform_data
;
105 struct rotary_encoder
*encoder
;
106 struct input_dev
*input
;
109 if (!pdata
|| !pdata
->steps
) {
110 dev_err(&pdev
->dev
, "invalid platform data\n");
114 encoder
= kzalloc(sizeof(struct rotary_encoder
), GFP_KERNEL
);
115 input
= input_allocate_device();
116 if (!encoder
|| !input
) {
117 dev_err(&pdev
->dev
, "failed to allocate memory for device\n");
122 encoder
->input
= input
;
123 encoder
->pdata
= pdata
;
124 encoder
->irq_a
= gpio_to_irq(pdata
->gpio_a
);
125 encoder
->irq_b
= gpio_to_irq(pdata
->gpio_b
);
127 /* create and register the input driver */
128 input
->name
= pdev
->name
;
129 input
->id
.bustype
= BUS_HOST
;
130 input
->dev
.parent
= &pdev
->dev
;
132 if (pdata
->relative_axis
) {
133 input
->evbit
[0] = BIT_MASK(EV_REL
);
134 input
->relbit
[0] = BIT_MASK(pdata
->axis
);
136 input
->evbit
[0] = BIT_MASK(EV_ABS
);
137 input_set_abs_params(encoder
->input
,
138 pdata
->axis
, 0, pdata
->steps
, 0, 1);
141 err
= input_register_device(input
);
143 dev_err(&pdev
->dev
, "failed to register input device\n");
147 /* request the GPIOs */
148 err
= gpio_request(pdata
->gpio_a
, DRV_NAME
);
150 dev_err(&pdev
->dev
, "unable to request GPIO %d\n",
152 goto exit_unregister_input
;
155 err
= gpio_request(pdata
->gpio_b
, DRV_NAME
);
157 dev_err(&pdev
->dev
, "unable to request GPIO %d\n",
159 goto exit_free_gpio_a
;
162 /* request the IRQs */
163 err
= request_irq(encoder
->irq_a
, &rotary_encoder_irq
,
164 IORESOURCE_IRQ_HIGHEDGE
| IORESOURCE_IRQ_LOWEDGE
,
167 dev_err(&pdev
->dev
, "unable to request IRQ %d\n",
169 goto exit_free_gpio_b
;
172 err
= request_irq(encoder
->irq_b
, &rotary_encoder_irq
,
173 IORESOURCE_IRQ_HIGHEDGE
| IORESOURCE_IRQ_LOWEDGE
,
176 dev_err(&pdev
->dev
, "unable to request IRQ %d\n",
178 goto exit_free_irq_a
;
181 platform_set_drvdata(pdev
, encoder
);
186 free_irq(encoder
->irq_a
, encoder
);
188 gpio_free(pdata
->gpio_b
);
190 gpio_free(pdata
->gpio_a
);
191 exit_unregister_input
:
192 input_unregister_device(input
);
193 input
= NULL
; /* so we don't try to free it */
195 input_free_device(input
);
200 static int __devexit
rotary_encoder_remove(struct platform_device
*pdev
)
202 struct rotary_encoder
*encoder
= platform_get_drvdata(pdev
);
203 struct rotary_encoder_platform_data
*pdata
= pdev
->dev
.platform_data
;
205 free_irq(encoder
->irq_a
, encoder
);
206 free_irq(encoder
->irq_b
, encoder
);
207 gpio_free(pdata
->gpio_a
);
208 gpio_free(pdata
->gpio_b
);
209 input_unregister_device(encoder
->input
);
210 platform_set_drvdata(pdev
, NULL
);
216 static struct platform_driver rotary_encoder_driver
= {
217 .probe
= rotary_encoder_probe
,
218 .remove
= __devexit_p(rotary_encoder_remove
),
221 .owner
= THIS_MODULE
,
225 static int __init
rotary_encoder_init(void)
227 return platform_driver_register(&rotary_encoder_driver
);
230 static void __exit
rotary_encoder_exit(void)
232 platform_driver_unregister(&rotary_encoder_driver
);
235 module_init(rotary_encoder_init
);
236 module_exit(rotary_encoder_exit
);
238 MODULE_ALIAS("platform:" DRV_NAME
);
239 MODULE_DESCRIPTION("GPIO rotary encoder driver");
240 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>");
241 MODULE_LICENSE("GPL v2");