4 * (c) 2009 Daniel Mack <daniel@caiaq.de>
5 * Copyright (C) 2011 Johan Hovold <jhovold@gmail.com>
7 * state machine code inspired by code from Tim Ruetz
9 * A generic driver for rotary encoders connected to GPIO lines.
10 * See file:Documentation/input/rotary-encoder.txt for more information
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License version 2 as
14 * published by the Free Software Foundation.
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/interrupt.h>
21 #include <linux/input.h>
22 #include <linux/device.h>
23 #include <linux/platform_device.h>
24 #include <linux/gpio.h>
25 #include <linux/rotary_encoder.h>
26 #include <linux/slab.h>
28 #include <linux/of_platform.h>
29 #include <linux/of_gpio.h>
31 #define DRV_NAME "rotary-encoder"
33 struct rotary_encoder
{
34 struct input_dev
*input
;
35 const struct rotary_encoder_platform_data
*pdata
;
44 unsigned char dir
; /* 0 - clockwise, 1 - CCW */
49 static int rotary_encoder_get_state(const struct rotary_encoder_platform_data
*pdata
)
51 int a
= !!gpio_get_value(pdata
->gpio_a
);
52 int b
= !!gpio_get_value(pdata
->gpio_b
);
54 a
^= pdata
->inverted_a
;
55 b
^= pdata
->inverted_b
;
57 return ((a
<< 1) | b
);
60 static void rotary_encoder_report_event(struct rotary_encoder
*encoder
)
62 const struct rotary_encoder_platform_data
*pdata
= encoder
->pdata
;
64 if (pdata
->relative_axis
) {
65 input_report_rel(encoder
->input
,
66 pdata
->axis
, encoder
->dir
? -1 : 1);
68 unsigned int pos
= encoder
->pos
;
71 /* turning counter-clockwise */
77 /* turning clockwise */
78 if (pdata
->rollover
|| pos
< pdata
->steps
)
86 input_report_abs(encoder
->input
, pdata
->axis
, encoder
->pos
);
89 input_sync(encoder
->input
);
92 static irqreturn_t
rotary_encoder_irq(int irq
, void *dev_id
)
94 struct rotary_encoder
*encoder
= dev_id
;
97 state
= rotary_encoder_get_state(encoder
->pdata
);
101 if (encoder
->armed
) {
102 rotary_encoder_report_event(encoder
);
103 encoder
->armed
= false;
110 encoder
->dir
= state
- 1;
114 encoder
->armed
= true;
121 static irqreturn_t
rotary_encoder_half_period_irq(int irq
, void *dev_id
)
123 struct rotary_encoder
*encoder
= dev_id
;
126 state
= rotary_encoder_get_state(encoder
->pdata
);
131 if (state
!= encoder
->last_stable
) {
132 rotary_encoder_report_event(encoder
);
133 encoder
->last_stable
= state
;
139 encoder
->dir
= (encoder
->last_stable
+ state
) & 0x01;
147 static struct of_device_id rotary_encoder_of_match
[] = {
148 { .compatible
= "rotary-encoder", },
151 MODULE_DEVICE_TABLE(of
, rotary_encoder_of_match
);
153 static struct rotary_encoder_platform_data
*rotary_encoder_parse_dt(struct device
*dev
)
155 const struct of_device_id
*of_id
=
156 of_match_device(rotary_encoder_of_match
, dev
);
157 struct device_node
*np
= dev
->of_node
;
158 struct rotary_encoder_platform_data
*pdata
;
159 enum of_gpio_flags flags
;
164 pdata
= kzalloc(sizeof(struct rotary_encoder_platform_data
),
167 return ERR_PTR(-ENOMEM
);
169 of_property_read_u32(np
, "rotary-encoder,steps", &pdata
->steps
);
170 of_property_read_u32(np
, "linux,axis", &pdata
->axis
);
172 pdata
->gpio_a
= of_get_gpio_flags(np
, 0, &flags
);
173 pdata
->inverted_a
= flags
& OF_GPIO_ACTIVE_LOW
;
175 pdata
->gpio_b
= of_get_gpio_flags(np
, 1, &flags
);
176 pdata
->inverted_b
= flags
& OF_GPIO_ACTIVE_LOW
;
178 pdata
->relative_axis
= !!of_get_property(np
,
179 "rotary-encoder,relative-axis", NULL
);
180 pdata
->rollover
= !!of_get_property(np
,
181 "rotary-encoder,rollover", NULL
);
182 pdata
->half_period
= !!of_get_property(np
,
183 "rotary-encoder,half-period", NULL
);
188 static inline struct rotary_encoder_platform_data
*
189 rotary_encoder_parse_dt(struct device
*dev
)
195 static int rotary_encoder_probe(struct platform_device
*pdev
)
197 struct device
*dev
= &pdev
->dev
;
198 const struct rotary_encoder_platform_data
*pdata
= dev_get_platdata(dev
);
199 struct rotary_encoder
*encoder
;
200 struct input_dev
*input
;
201 irq_handler_t handler
;
205 pdata
= rotary_encoder_parse_dt(dev
);
207 return PTR_ERR(pdata
);
210 dev_err(dev
, "missing platform data\n");
215 encoder
= kzalloc(sizeof(struct rotary_encoder
), GFP_KERNEL
);
216 input
= input_allocate_device();
217 if (!encoder
|| !input
) {
222 encoder
->input
= input
;
223 encoder
->pdata
= pdata
;
225 input
->name
= pdev
->name
;
226 input
->id
.bustype
= BUS_HOST
;
227 input
->dev
.parent
= dev
;
229 if (pdata
->relative_axis
) {
230 input
->evbit
[0] = BIT_MASK(EV_REL
);
231 input
->relbit
[0] = BIT_MASK(pdata
->axis
);
233 input
->evbit
[0] = BIT_MASK(EV_ABS
);
234 input_set_abs_params(encoder
->input
,
235 pdata
->axis
, 0, pdata
->steps
, 0, 1);
238 /* request the GPIOs */
239 err
= gpio_request_one(pdata
->gpio_a
, GPIOF_IN
, dev_name(dev
));
241 dev_err(dev
, "unable to request GPIO %d\n", pdata
->gpio_a
);
245 err
= gpio_request_one(pdata
->gpio_b
, GPIOF_IN
, dev_name(dev
));
247 dev_err(dev
, "unable to request GPIO %d\n", pdata
->gpio_b
);
248 goto exit_free_gpio_a
;
251 encoder
->irq_a
= gpio_to_irq(pdata
->gpio_a
);
252 encoder
->irq_b
= gpio_to_irq(pdata
->gpio_b
);
254 /* request the IRQs */
255 if (pdata
->half_period
) {
256 handler
= &rotary_encoder_half_period_irq
;
257 encoder
->last_stable
= rotary_encoder_get_state(pdata
);
259 handler
= &rotary_encoder_irq
;
262 err
= request_irq(encoder
->irq_a
, handler
,
263 IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
,
266 dev_err(dev
, "unable to request IRQ %d\n", encoder
->irq_a
);
267 goto exit_free_gpio_b
;
270 err
= request_irq(encoder
->irq_b
, handler
,
271 IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
,
274 dev_err(dev
, "unable to request IRQ %d\n", encoder
->irq_b
);
275 goto exit_free_irq_a
;
278 err
= input_register_device(input
);
280 dev_err(dev
, "failed to register input device\n");
281 goto exit_free_irq_b
;
284 platform_set_drvdata(pdev
, encoder
);
289 free_irq(encoder
->irq_b
, encoder
);
291 free_irq(encoder
->irq_a
, encoder
);
293 gpio_free(pdata
->gpio_b
);
295 gpio_free(pdata
->gpio_a
);
297 input_free_device(input
);
299 if (!dev_get_platdata(&pdev
->dev
))
305 static int rotary_encoder_remove(struct platform_device
*pdev
)
307 struct rotary_encoder
*encoder
= platform_get_drvdata(pdev
);
308 const struct rotary_encoder_platform_data
*pdata
= encoder
->pdata
;
310 free_irq(encoder
->irq_a
, encoder
);
311 free_irq(encoder
->irq_b
, encoder
);
312 gpio_free(pdata
->gpio_a
);
313 gpio_free(pdata
->gpio_b
);
315 input_unregister_device(encoder
->input
);
318 if (!dev_get_platdata(&pdev
->dev
))
324 static struct platform_driver rotary_encoder_driver
= {
325 .probe
= rotary_encoder_probe
,
326 .remove
= rotary_encoder_remove
,
329 .owner
= THIS_MODULE
,
330 .of_match_table
= of_match_ptr(rotary_encoder_of_match
),
333 module_platform_driver(rotary_encoder_driver
);
335 MODULE_ALIAS("platform:" DRV_NAME
);
336 MODULE_DESCRIPTION("GPIO rotary encoder driver");
337 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold");
338 MODULE_LICENSE("GPL v2");