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/interrupt.h>
20 #include <linux/input.h>
21 #include <linux/device.h>
22 #include <linux/platform_device.h>
23 #include <linux/gpio/consumer.h>
24 #include <linux/slab.h>
27 #include <linux/property.h>
29 #define DRV_NAME "rotary-encoder"
31 struct rotary_encoder
{
32 struct input_dev
*input
;
34 struct mutex access_mutex
;
43 struct gpio_descs
*gpios
;
48 signed char dir
; /* 1 - clockwise, -1 - CCW */
53 static unsigned rotary_encoder_get_state(struct rotary_encoder
*encoder
)
58 for (i
= 0; i
< encoder
->gpios
->ndescs
; ++i
) {
59 int val
= gpiod_get_value_cansleep(encoder
->gpios
->desc
[i
]);
60 /* convert from gray encoding to normal */
70 static void rotary_encoder_report_event(struct rotary_encoder
*encoder
)
72 if (encoder
->relative_axis
) {
73 input_report_rel(encoder
->input
,
74 encoder
->axis
, encoder
->dir
);
76 unsigned int pos
= encoder
->pos
;
78 if (encoder
->dir
< 0) {
79 /* turning counter-clockwise */
80 if (encoder
->rollover
)
81 pos
+= encoder
->steps
;
85 /* turning clockwise */
86 if (encoder
->rollover
|| pos
< encoder
->steps
)
90 if (encoder
->rollover
)
91 pos
%= encoder
->steps
;
94 input_report_abs(encoder
->input
, encoder
->axis
, encoder
->pos
);
97 input_sync(encoder
->input
);
100 static irqreturn_t
rotary_encoder_irq(int irq
, void *dev_id
)
102 struct rotary_encoder
*encoder
= dev_id
;
105 mutex_lock(&encoder
->access_mutex
);
107 state
= rotary_encoder_get_state(encoder
);
111 if (encoder
->armed
) {
112 rotary_encoder_report_event(encoder
);
113 encoder
->armed
= false;
120 encoder
->dir
= 2 - state
;
124 encoder
->armed
= true;
128 mutex_unlock(&encoder
->access_mutex
);
133 static irqreturn_t
rotary_encoder_half_period_irq(int irq
, void *dev_id
)
135 struct rotary_encoder
*encoder
= dev_id
;
138 mutex_lock(&encoder
->access_mutex
);
140 state
= rotary_encoder_get_state(encoder
);
143 encoder
->dir
= ((encoder
->last_stable
- state
+ 1) % 4) - 1;
145 if (state
!= encoder
->last_stable
) {
146 rotary_encoder_report_event(encoder
);
147 encoder
->last_stable
= state
;
151 mutex_unlock(&encoder
->access_mutex
);
156 static irqreturn_t
rotary_encoder_quarter_period_irq(int irq
, void *dev_id
)
158 struct rotary_encoder
*encoder
= dev_id
;
161 mutex_lock(&encoder
->access_mutex
);
163 state
= rotary_encoder_get_state(encoder
);
165 if ((encoder
->last_stable
+ 1) % 4 == state
)
167 else if (encoder
->last_stable
== (state
+ 1) % 4)
172 rotary_encoder_report_event(encoder
);
175 encoder
->last_stable
= state
;
176 mutex_unlock(&encoder
->access_mutex
);
181 static int rotary_encoder_probe(struct platform_device
*pdev
)
183 struct device
*dev
= &pdev
->dev
;
184 struct rotary_encoder
*encoder
;
185 struct input_dev
*input
;
186 irq_handler_t handler
;
187 u32 steps_per_period
;
191 encoder
= devm_kzalloc(dev
, sizeof(struct rotary_encoder
), GFP_KERNEL
);
195 mutex_init(&encoder
->access_mutex
);
197 device_property_read_u32(dev
, "rotary-encoder,steps", &encoder
->steps
);
199 err
= device_property_read_u32(dev
, "rotary-encoder,steps-per-period",
203 * The 'half-period' property has been deprecated, you must
204 * use 'steps-per-period' and set an appropriate value, but
205 * we still need to parse it to maintain compatibility. If
206 * neither property is present we fall back to the one step
207 * per period behavior.
209 steps_per_period
= device_property_read_bool(dev
,
210 "rotary-encoder,half-period") ? 2 : 1;
214 device_property_read_bool(dev
, "rotary-encoder,rollover");
216 device_property_read_u32(dev
, "linux,axis", &encoder
->axis
);
217 encoder
->relative_axis
=
218 device_property_read_bool(dev
, "rotary-encoder,relative-axis");
220 encoder
->gpios
= devm_gpiod_get_array(dev
, NULL
, GPIOD_IN
);
221 if (IS_ERR(encoder
->gpios
)) {
222 dev_err(dev
, "unable to get gpios\n");
223 return PTR_ERR(encoder
->gpios
);
225 if (encoder
->gpios
->ndescs
< 2) {
226 dev_err(dev
, "not enough gpios found\n");
230 input
= devm_input_allocate_device(dev
);
234 encoder
->input
= input
;
236 input
->name
= pdev
->name
;
237 input
->id
.bustype
= BUS_HOST
;
238 input
->dev
.parent
= dev
;
240 if (encoder
->relative_axis
)
241 input_set_capability(input
, EV_REL
, encoder
->axis
);
243 input_set_abs_params(input
,
244 encoder
->axis
, 0, encoder
->steps
, 0, 1);
246 switch (steps_per_period
>> (encoder
->gpios
->ndescs
- 2)) {
248 handler
= &rotary_encoder_quarter_period_irq
;
249 encoder
->last_stable
= rotary_encoder_get_state(encoder
);
252 handler
= &rotary_encoder_half_period_irq
;
253 encoder
->last_stable
= rotary_encoder_get_state(encoder
);
256 handler
= &rotary_encoder_irq
;
259 dev_err(dev
, "'%d' is not a valid steps-per-period value\n",
266 sizeof(*encoder
->irq
) * encoder
->gpios
->ndescs
,
271 for (i
= 0; i
< encoder
->gpios
->ndescs
; ++i
) {
272 encoder
->irq
[i
] = gpiod_to_irq(encoder
->gpios
->desc
[i
]);
274 err
= devm_request_threaded_irq(dev
, encoder
->irq
[i
],
276 IRQF_TRIGGER_RISING
| IRQF_TRIGGER_FALLING
|
280 dev_err(dev
, "unable to request IRQ %d (gpio#%d)\n",
286 err
= input_register_device(input
);
288 dev_err(dev
, "failed to register input device\n");
292 device_init_wakeup(dev
,
293 device_property_read_bool(dev
, "wakeup-source"));
295 platform_set_drvdata(pdev
, encoder
);
300 static int __maybe_unused
rotary_encoder_suspend(struct device
*dev
)
302 struct rotary_encoder
*encoder
= dev_get_drvdata(dev
);
305 if (device_may_wakeup(dev
)) {
306 for (i
= 0; i
< encoder
->gpios
->ndescs
; ++i
)
307 enable_irq_wake(encoder
->irq
[i
]);
313 static int __maybe_unused
rotary_encoder_resume(struct device
*dev
)
315 struct rotary_encoder
*encoder
= dev_get_drvdata(dev
);
318 if (device_may_wakeup(dev
)) {
319 for (i
= 0; i
< encoder
->gpios
->ndescs
; ++i
)
320 disable_irq_wake(encoder
->irq
[i
]);
326 static SIMPLE_DEV_PM_OPS(rotary_encoder_pm_ops
,
327 rotary_encoder_suspend
, rotary_encoder_resume
);
330 static const struct of_device_id rotary_encoder_of_match
[] = {
331 { .compatible
= "rotary-encoder", },
334 MODULE_DEVICE_TABLE(of
, rotary_encoder_of_match
);
337 static struct platform_driver rotary_encoder_driver
= {
338 .probe
= rotary_encoder_probe
,
341 .pm
= &rotary_encoder_pm_ops
,
342 .of_match_table
= of_match_ptr(rotary_encoder_of_match
),
345 module_platform_driver(rotary_encoder_driver
);
347 MODULE_ALIAS("platform:" DRV_NAME
);
348 MODULE_DESCRIPTION("GPIO rotary encoder driver");
349 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold");
350 MODULE_LICENSE("GPL v2");