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