Version:  2.6.34 2.6.35 2.6.36 2.6.37 2.6.38 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14

Linux/drivers/input/misc/rotary_encoder.c

  1 /*
  2  * rotary_encoder.c
  3  *
  4  * (c) 2009 Daniel Mack <daniel@caiaq.de>
  5  * Copyright (C) 2011 Johan Hovold <jhovold@gmail.com>
  6  *
  7  * state machine code inspired by code from Tim Ruetz
  8  *
  9  * A generic driver for rotary encoders connected to GPIO lines.
 10  * See file:Documentation/input/rotary-encoder.txt for more information
 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/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>
 25 #include <linux/slab.h>
 26 #include <linux/of.h>
 27 #include <linux/of_platform.h>
 28 #include <linux/of_gpio.h>
 29 
 30 #define DRV_NAME "rotary-encoder"
 31 
 32 struct rotary_encoder {
 33         struct input_dev *input;
 34         const struct rotary_encoder_platform_data *pdata;
 35 
 36         unsigned int axis;
 37         unsigned int pos;
 38 
 39         unsigned int irq_a;
 40         unsigned int irq_b;
 41 
 42         bool armed;
 43         unsigned char dir;      /* 0 - clockwise, 1 - CCW */
 44 
 45         char last_stable;
 46 };
 47 
 48 static int rotary_encoder_get_state(const struct rotary_encoder_platform_data *pdata)
 49 {
 50         int a = !!gpio_get_value(pdata->gpio_a);
 51         int b = !!gpio_get_value(pdata->gpio_b);
 52 
 53         a ^= pdata->inverted_a;
 54         b ^= pdata->inverted_b;
 55 
 56         return ((a << 1) | b);
 57 }
 58 
 59 static void rotary_encoder_report_event(struct rotary_encoder *encoder)
 60 {
 61         const struct rotary_encoder_platform_data *pdata = encoder->pdata;
 62 
 63         if (pdata->relative_axis) {
 64                 input_report_rel(encoder->input,
 65                                  pdata->axis, encoder->dir ? -1 : 1);
 66         } else {
 67                 unsigned int pos = encoder->pos;
 68 
 69                 if (encoder->dir) {
 70                         /* turning counter-clockwise */
 71                         if (pdata->rollover)
 72                                 pos += pdata->steps;
 73                         if (pos)
 74                                 pos--;
 75                 } else {
 76                         /* turning clockwise */
 77                         if (pdata->rollover || pos < pdata->steps)
 78                                 pos++;
 79                 }
 80 
 81                 if (pdata->rollover)
 82                         pos %= pdata->steps;
 83 
 84                 encoder->pos = pos;
 85                 input_report_abs(encoder->input, pdata->axis, encoder->pos);
 86         }
 87 
 88         input_sync(encoder->input);
 89 }
 90 
 91 static irqreturn_t rotary_encoder_irq(int irq, void *dev_id)
 92 {
 93         struct rotary_encoder *encoder = dev_id;
 94         int state;
 95 
 96         state = rotary_encoder_get_state(encoder->pdata);
 97 
 98         switch (state) {
 99         case 0x0:
100                 if (encoder->armed) {
101                         rotary_encoder_report_event(encoder);
102                         encoder->armed = false;
103                 }
104                 break;
105 
106         case 0x1:
107         case 0x2:
108                 if (encoder->armed)
109                         encoder->dir = state - 1;
110                 break;
111 
112         case 0x3:
113                 encoder->armed = true;
114                 break;
115         }
116 
117         return IRQ_HANDLED;
118 }
119 
120 static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id)
121 {
122         struct rotary_encoder *encoder = dev_id;
123         int state;
124 
125         state = rotary_encoder_get_state(encoder->pdata);
126 
127         switch (state) {
128         case 0x00:
129         case 0x03:
130                 if (state != encoder->last_stable) {
131                         rotary_encoder_report_event(encoder);
132                         encoder->last_stable = state;
133                 }
134                 break;
135 
136         case 0x01:
137         case 0x02:
138                 encoder->dir = (encoder->last_stable + state) & 0x01;
139                 break;
140         }
141 
142         return IRQ_HANDLED;
143 }
144 
145 #ifdef CONFIG_OF
146 static struct of_device_id rotary_encoder_of_match[] = {
147         { .compatible = "rotary-encoder", },
148         { },
149 };
150 MODULE_DEVICE_TABLE(of, rotary_encoder_of_match);
151 
152 static struct rotary_encoder_platform_data *rotary_encoder_parse_dt(struct device *dev)
153 {
154         const struct of_device_id *of_id =
155                                 of_match_device(rotary_encoder_of_match, dev);
156         struct device_node *np = dev->of_node;
157         struct rotary_encoder_platform_data *pdata;
158         enum of_gpio_flags flags;
159 
160         if (!of_id || !np)
161                 return NULL;
162 
163         pdata = kzalloc(sizeof(struct rotary_encoder_platform_data),
164                         GFP_KERNEL);
165         if (!pdata)
166                 return ERR_PTR(-ENOMEM);
167 
168         of_property_read_u32(np, "rotary-encoder,steps", &pdata->steps);
169         of_property_read_u32(np, "linux,axis", &pdata->axis);
170 
171         pdata->gpio_a = of_get_gpio_flags(np, 0, &flags);
172         pdata->inverted_a = flags & OF_GPIO_ACTIVE_LOW;
173 
174         pdata->gpio_b = of_get_gpio_flags(np, 1, &flags);
175         pdata->inverted_b = flags & OF_GPIO_ACTIVE_LOW;
176 
177         pdata->relative_axis = !!of_get_property(np,
178                                         "rotary-encoder,relative-axis", NULL);
179         pdata->rollover = !!of_get_property(np,
180                                         "rotary-encoder,rollover", NULL);
181         pdata->half_period = !!of_get_property(np,
182                                         "rotary-encoder,half-period", NULL);
183 
184         return pdata;
185 }
186 #else
187 static inline struct rotary_encoder_platform_data *
188 rotary_encoder_parse_dt(struct device *dev)
189 {
190         return NULL;
191 }
192 #endif
193 
194 static int rotary_encoder_probe(struct platform_device *pdev)
195 {
196         struct device *dev = &pdev->dev;
197         const struct rotary_encoder_platform_data *pdata = dev_get_platdata(dev);
198         struct rotary_encoder *encoder;
199         struct input_dev *input;
200         irq_handler_t handler;
201         int err;
202 
203         if (!pdata) {
204                 pdata = rotary_encoder_parse_dt(dev);
205                 if (IS_ERR(pdata))
206                         return PTR_ERR(pdata);
207 
208                 if (!pdata) {
209                         dev_err(dev, "missing platform data\n");
210                         return -EINVAL;
211                 }
212         }
213 
214         encoder = kzalloc(sizeof(struct rotary_encoder), GFP_KERNEL);
215         input = input_allocate_device();
216         if (!encoder || !input) {
217                 err = -ENOMEM;
218                 goto exit_free_mem;
219         }
220 
221         encoder->input = input;
222         encoder->pdata = pdata;
223 
224         input->name = pdev->name;
225         input->id.bustype = BUS_HOST;
226         input->dev.parent = dev;
227 
228         if (pdata->relative_axis) {
229                 input->evbit[0] = BIT_MASK(EV_REL);
230                 input->relbit[0] = BIT_MASK(pdata->axis);
231         } else {
232                 input->evbit[0] = BIT_MASK(EV_ABS);
233                 input_set_abs_params(encoder->input,
234                                      pdata->axis, 0, pdata->steps, 0, 1);
235         }
236 
237         /* request the GPIOs */
238         err = gpio_request_one(pdata->gpio_a, GPIOF_IN, dev_name(dev));
239         if (err) {
240                 dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_a);
241                 goto exit_free_mem;
242         }
243 
244         err = gpio_request_one(pdata->gpio_b, GPIOF_IN, dev_name(dev));
245         if (err) {
246                 dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_b);
247                 goto exit_free_gpio_a;
248         }
249 
250         encoder->irq_a = gpio_to_irq(pdata->gpio_a);
251         encoder->irq_b = gpio_to_irq(pdata->gpio_b);
252 
253         /* request the IRQs */
254         if (pdata->half_period) {
255                 handler = &rotary_encoder_half_period_irq;
256                 encoder->last_stable = rotary_encoder_get_state(pdata);
257         } else {
258                 handler = &rotary_encoder_irq;
259         }
260 
261         err = request_irq(encoder->irq_a, handler,
262                           IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
263                           DRV_NAME, encoder);
264         if (err) {
265                 dev_err(dev, "unable to request IRQ %d\n", encoder->irq_a);
266                 goto exit_free_gpio_b;
267         }
268 
269         err = request_irq(encoder->irq_b, handler,
270                           IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
271                           DRV_NAME, encoder);
272         if (err) {
273                 dev_err(dev, "unable to request IRQ %d\n", encoder->irq_b);
274                 goto exit_free_irq_a;
275         }
276 
277         err = input_register_device(input);
278         if (err) {
279                 dev_err(dev, "failed to register input device\n");
280                 goto exit_free_irq_b;
281         }
282 
283         platform_set_drvdata(pdev, encoder);
284 
285         return 0;
286 
287 exit_free_irq_b:
288         free_irq(encoder->irq_b, encoder);
289 exit_free_irq_a:
290         free_irq(encoder->irq_a, encoder);
291 exit_free_gpio_b:
292         gpio_free(pdata->gpio_b);
293 exit_free_gpio_a:
294         gpio_free(pdata->gpio_a);
295 exit_free_mem:
296         input_free_device(input);
297         kfree(encoder);
298         if (!dev_get_platdata(&pdev->dev))
299                 kfree(pdata);
300 
301         return err;
302 }
303 
304 static int rotary_encoder_remove(struct platform_device *pdev)
305 {
306         struct rotary_encoder *encoder = platform_get_drvdata(pdev);
307         const struct rotary_encoder_platform_data *pdata = encoder->pdata;
308 
309         free_irq(encoder->irq_a, encoder);
310         free_irq(encoder->irq_b, encoder);
311         gpio_free(pdata->gpio_a);
312         gpio_free(pdata->gpio_b);
313 
314         input_unregister_device(encoder->input);
315         kfree(encoder);
316 
317         if (!dev_get_platdata(&pdev->dev))
318                 kfree(pdata);
319 
320         return 0;
321 }
322 
323 static struct platform_driver rotary_encoder_driver = {
324         .probe          = rotary_encoder_probe,
325         .remove         = rotary_encoder_remove,
326         .driver         = {
327                 .name   = DRV_NAME,
328                 .owner  = THIS_MODULE,
329                 .of_match_table = of_match_ptr(rotary_encoder_of_match),
330         }
331 };
332 module_platform_driver(rotary_encoder_driver);
333 
334 MODULE_ALIAS("platform:" DRV_NAME);
335 MODULE_DESCRIPTION("GPIO rotary encoder driver");
336 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold");
337 MODULE_LICENSE("GPL v2");
338 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us