Commit | Line | Data |
---|---|---|
73969ff0 DM |
1 | /* |
2 | * rotary_encoder.c | |
3 | * | |
4 | * (c) 2009 Daniel Mack <daniel@caiaq.de> | |
e70bdd41 | 5 | * Copyright (C) 2011 Johan Hovold <jhovold@gmail.com> |
73969ff0 DM |
6 | * |
7 | * state machine code inspired by code from Tim Ruetz | |
8 | * | |
9 | * A generic driver for rotary encoders connected to GPIO lines. | |
395cf969 | 10 | * See file:Documentation/input/rotary-encoder.txt for more information |
73969ff0 DM |
11 | * |
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. | |
15 | */ | |
16 | ||
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> | |
5a0e3ad6 | 26 | #include <linux/slab.h> |
73969ff0 DM |
27 | |
28 | #define DRV_NAME "rotary-encoder" | |
29 | ||
30 | struct rotary_encoder { | |
73969ff0 DM |
31 | struct input_dev *input; |
32 | struct rotary_encoder_platform_data *pdata; | |
bd3ce655 HS |
33 | |
34 | unsigned int axis; | |
35 | unsigned int pos; | |
36 | ||
37 | unsigned int irq_a; | |
38 | unsigned int irq_b; | |
39 | ||
40 | bool armed; | |
41 | unsigned char dir; /* 0 - clockwise, 1 - CCW */ | |
e70bdd41 JH |
42 | |
43 | char last_stable; | |
73969ff0 DM |
44 | }; |
45 | ||
521a8f5c | 46 | static int rotary_encoder_get_state(struct rotary_encoder_platform_data *pdata) |
73969ff0 | 47 | { |
73969ff0 DM |
48 | int a = !!gpio_get_value(pdata->gpio_a); |
49 | int b = !!gpio_get_value(pdata->gpio_b); | |
73969ff0 DM |
50 | |
51 | a ^= pdata->inverted_a; | |
52 | b ^= pdata->inverted_b; | |
73969ff0 | 53 | |
521a8f5c JH |
54 | return ((a << 1) | b); |
55 | } | |
73969ff0 | 56 | |
521a8f5c JH |
57 | static void rotary_encoder_report_event(struct rotary_encoder *encoder) |
58 | { | |
59 | struct rotary_encoder_platform_data *pdata = encoder->pdata; | |
73969ff0 | 60 | |
521a8f5c JH |
61 | if (pdata->relative_axis) { |
62 | input_report_rel(encoder->input, | |
63 | pdata->axis, encoder->dir ? -1 : 1); | |
64 | } else { | |
65 | unsigned int pos = encoder->pos; | |
66 | ||
67 | if (encoder->dir) { | |
68 | /* turning counter-clockwise */ | |
bd3ce655 | 69 | if (pdata->rollover) |
521a8f5c JH |
70 | pos += pdata->steps; |
71 | if (pos) | |
72 | pos--; | |
73 | } else { | |
74 | /* turning clockwise */ | |
75 | if (pdata->rollover || pos < pdata->steps) | |
76 | pos++; | |
73969ff0 | 77 | } |
73969ff0 | 78 | |
521a8f5c JH |
79 | if (pdata->rollover) |
80 | pos %= pdata->steps; | |
81 | ||
82 | encoder->pos = pos; | |
83 | input_report_abs(encoder->input, pdata->axis, encoder->pos); | |
84 | } | |
85 | ||
86 | input_sync(encoder->input); | |
87 | } | |
88 | ||
89 | static irqreturn_t rotary_encoder_irq(int irq, void *dev_id) | |
90 | { | |
91 | struct rotary_encoder *encoder = dev_id; | |
92 | int state; | |
93 | ||
94 | state = rotary_encoder_get_state(encoder->pdata); | |
95 | ||
96 | switch (state) { | |
97 | case 0x0: | |
98 | if (encoder->armed) { | |
99 | rotary_encoder_report_event(encoder); | |
100 | encoder->armed = false; | |
101 | } | |
73969ff0 DM |
102 | break; |
103 | ||
104 | case 0x1: | |
105 | case 0x2: | |
106 | if (encoder->armed) | |
107 | encoder->dir = state - 1; | |
108 | break; | |
109 | ||
110 | case 0x3: | |
bd3ce655 | 111 | encoder->armed = true; |
73969ff0 DM |
112 | break; |
113 | } | |
114 | ||
115 | return IRQ_HANDLED; | |
116 | } | |
117 | ||
e70bdd41 JH |
118 | static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id) |
119 | { | |
120 | struct rotary_encoder *encoder = dev_id; | |
121 | int state; | |
122 | ||
123 | state = rotary_encoder_get_state(encoder->pdata); | |
124 | ||
125 | switch (state) { | |
126 | case 0x00: | |
127 | case 0x03: | |
128 | if (state != encoder->last_stable) { | |
129 | rotary_encoder_report_event(encoder); | |
130 | encoder->last_stable = state; | |
131 | } | |
132 | break; | |
133 | ||
134 | case 0x01: | |
135 | case 0x02: | |
136 | encoder->dir = (encoder->last_stable + state) & 0x01; | |
137 | break; | |
138 | } | |
139 | ||
140 | return IRQ_HANDLED; | |
141 | } | |
142 | ||
73969ff0 DM |
143 | static int __devinit rotary_encoder_probe(struct platform_device *pdev) |
144 | { | |
145 | struct rotary_encoder_platform_data *pdata = pdev->dev.platform_data; | |
146 | struct rotary_encoder *encoder; | |
147 | struct input_dev *input; | |
e70bdd41 | 148 | irq_handler_t handler; |
73969ff0 DM |
149 | int err; |
150 | ||
06ee3d3c HS |
151 | if (!pdata) { |
152 | dev_err(&pdev->dev, "missing platform data\n"); | |
73969ff0 DM |
153 | return -ENOENT; |
154 | } | |
155 | ||
156 | encoder = kzalloc(sizeof(struct rotary_encoder), GFP_KERNEL); | |
157 | input = input_allocate_device(); | |
158 | if (!encoder || !input) { | |
159 | dev_err(&pdev->dev, "failed to allocate memory for device\n"); | |
160 | err = -ENOMEM; | |
161 | goto exit_free_mem; | |
162 | } | |
163 | ||
164 | encoder->input = input; | |
165 | encoder->pdata = pdata; | |
166 | encoder->irq_a = gpio_to_irq(pdata->gpio_a); | |
167 | encoder->irq_b = gpio_to_irq(pdata->gpio_b); | |
168 | ||
169 | /* create and register the input driver */ | |
170 | input->name = pdev->name; | |
171 | input->id.bustype = BUS_HOST; | |
172 | input->dev.parent = &pdev->dev; | |
bd3ce655 HS |
173 | |
174 | if (pdata->relative_axis) { | |
175 | input->evbit[0] = BIT_MASK(EV_REL); | |
176 | input->relbit[0] = BIT_MASK(pdata->axis); | |
177 | } else { | |
178 | input->evbit[0] = BIT_MASK(EV_ABS); | |
179 | input_set_abs_params(encoder->input, | |
180 | pdata->axis, 0, pdata->steps, 0, 1); | |
181 | } | |
73969ff0 DM |
182 | |
183 | err = input_register_device(input); | |
184 | if (err) { | |
185 | dev_err(&pdev->dev, "failed to register input device\n"); | |
186 | goto exit_free_mem; | |
187 | } | |
188 | ||
189 | /* request the GPIOs */ | |
190 | err = gpio_request(pdata->gpio_a, DRV_NAME); | |
191 | if (err) { | |
192 | dev_err(&pdev->dev, "unable to request GPIO %d\n", | |
193 | pdata->gpio_a); | |
194 | goto exit_unregister_input; | |
195 | } | |
196 | ||
5deeac99 AC |
197 | err = gpio_direction_input(pdata->gpio_a); |
198 | if (err) { | |
199 | dev_err(&pdev->dev, "unable to set GPIO %d for input\n", | |
200 | pdata->gpio_a); | |
201 | goto exit_unregister_input; | |
202 | } | |
203 | ||
73969ff0 DM |
204 | err = gpio_request(pdata->gpio_b, DRV_NAME); |
205 | if (err) { | |
206 | dev_err(&pdev->dev, "unable to request GPIO %d\n", | |
207 | pdata->gpio_b); | |
208 | goto exit_free_gpio_a; | |
209 | } | |
210 | ||
5deeac99 AC |
211 | err = gpio_direction_input(pdata->gpio_b); |
212 | if (err) { | |
213 | dev_err(&pdev->dev, "unable to set GPIO %d for input\n", | |
214 | pdata->gpio_b); | |
215 | goto exit_free_gpio_a; | |
216 | } | |
217 | ||
73969ff0 | 218 | /* request the IRQs */ |
e70bdd41 JH |
219 | if (pdata->half_period) { |
220 | handler = &rotary_encoder_half_period_irq; | |
221 | encoder->last_stable = rotary_encoder_get_state(pdata); | |
222 | } else { | |
223 | handler = &rotary_encoder_irq; | |
224 | } | |
225 | ||
226 | err = request_irq(encoder->irq_a, handler, | |
e0d5f4c3 | 227 | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
73969ff0 DM |
228 | DRV_NAME, encoder); |
229 | if (err) { | |
230 | dev_err(&pdev->dev, "unable to request IRQ %d\n", | |
231 | encoder->irq_a); | |
232 | goto exit_free_gpio_b; | |
233 | } | |
234 | ||
e70bdd41 | 235 | err = request_irq(encoder->irq_b, handler, |
e0d5f4c3 | 236 | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, |
73969ff0 DM |
237 | DRV_NAME, encoder); |
238 | if (err) { | |
239 | dev_err(&pdev->dev, "unable to request IRQ %d\n", | |
240 | encoder->irq_b); | |
241 | goto exit_free_irq_a; | |
242 | } | |
243 | ||
244 | platform_set_drvdata(pdev, encoder); | |
245 | ||
246 | return 0; | |
247 | ||
248 | exit_free_irq_a: | |
249 | free_irq(encoder->irq_a, encoder); | |
250 | exit_free_gpio_b: | |
251 | gpio_free(pdata->gpio_b); | |
252 | exit_free_gpio_a: | |
253 | gpio_free(pdata->gpio_a); | |
254 | exit_unregister_input: | |
255 | input_unregister_device(input); | |
256 | input = NULL; /* so we don't try to free it */ | |
257 | exit_free_mem: | |
258 | input_free_device(input); | |
259 | kfree(encoder); | |
260 | return err; | |
261 | } | |
262 | ||
263 | static int __devexit rotary_encoder_remove(struct platform_device *pdev) | |
264 | { | |
265 | struct rotary_encoder *encoder = platform_get_drvdata(pdev); | |
266 | struct rotary_encoder_platform_data *pdata = pdev->dev.platform_data; | |
267 | ||
268 | free_irq(encoder->irq_a, encoder); | |
269 | free_irq(encoder->irq_b, encoder); | |
270 | gpio_free(pdata->gpio_a); | |
271 | gpio_free(pdata->gpio_b); | |
272 | input_unregister_device(encoder->input); | |
273 | platform_set_drvdata(pdev, NULL); | |
274 | kfree(encoder); | |
275 | ||
276 | return 0; | |
277 | } | |
278 | ||
279 | static struct platform_driver rotary_encoder_driver = { | |
280 | .probe = rotary_encoder_probe, | |
281 | .remove = __devexit_p(rotary_encoder_remove), | |
282 | .driver = { | |
283 | .name = DRV_NAME, | |
284 | .owner = THIS_MODULE, | |
285 | } | |
286 | }; | |
287 | ||
288 | static int __init rotary_encoder_init(void) | |
289 | { | |
290 | return platform_driver_register(&rotary_encoder_driver); | |
291 | } | |
292 | ||
293 | static void __exit rotary_encoder_exit(void) | |
294 | { | |
295 | platform_driver_unregister(&rotary_encoder_driver); | |
296 | } | |
297 | ||
298 | module_init(rotary_encoder_init); | |
299 | module_exit(rotary_encoder_exit); | |
300 | ||
301 | MODULE_ALIAS("platform:" DRV_NAME); | |
302 | MODULE_DESCRIPTION("GPIO rotary encoder driver"); | |
e70bdd41 | 303 | MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold"); |
73969ff0 | 304 | MODULE_LICENSE("GPL v2"); |