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 static irqreturn_t rotary_encoder_quarter_period_irq(int irq, void *dev_id) 147 { 148 struct rotary_encoder *encoder = dev_id; 149 unsigned char sum; 150 int state; 151 152 state = rotary_encoder_get_state(encoder->pdata); 153 154 /* 155 * We encode the previous and the current state using a byte. 156 * The previous state in the MSB nibble, the current state in the LSB 157 * nibble. Then use a table to decide the direction of the turn. 158 */ 159 sum = (encoder->last_stable << 4) + state; 160 switch (sum) { 161 case 0x31: 162 case 0x10: 163 case 0x02: 164 case 0x23: 165 encoder->dir = 0; /* clockwise */ 166 break; 167 168 case 0x13: 169 case 0x01: 170 case 0x20: 171 case 0x32: 172 encoder->dir = 1; /* counter-clockwise */ 173 break; 174 175 default: 176 /* 177 * Ignore all other values. This covers the case when the 178 * state didn't change (a spurious interrupt) and the 179 * cases where the state changed by two steps, making it 180 * impossible to tell the direction. 181 * 182 * In either case, don't report any event and save the 183 * state for later. 184 */ 185 goto out; 186 } 187 188 rotary_encoder_report_event(encoder); 189 190 out: 191 encoder->last_stable = state; 192 return IRQ_HANDLED; 193 } 194 195 #ifdef CONFIG_OF 196 static const struct of_device_id rotary_encoder_of_match[] = { 197 { .compatible = "rotary-encoder", }, 198 { }, 199 }; 200 MODULE_DEVICE_TABLE(of, rotary_encoder_of_match); 201 202 static struct rotary_encoder_platform_data *rotary_encoder_parse_dt(struct device *dev) 203 { 204 const struct of_device_id *of_id = 205 of_match_device(rotary_encoder_of_match, dev); 206 struct device_node *np = dev->of_node; 207 struct rotary_encoder_platform_data *pdata; 208 enum of_gpio_flags flags; 209 int error; 210 211 if (!of_id || !np) 212 return NULL; 213 214 pdata = kzalloc(sizeof(struct rotary_encoder_platform_data), 215 GFP_KERNEL); 216 if (!pdata) 217 return ERR_PTR(-ENOMEM); 218 219 of_property_read_u32(np, "rotary-encoder,steps", &pdata->steps); 220 of_property_read_u32(np, "linux,axis", &pdata->axis); 221 222 pdata->gpio_a = of_get_gpio_flags(np, 0, &flags); 223 pdata->inverted_a = flags & OF_GPIO_ACTIVE_LOW; 224 225 pdata->gpio_b = of_get_gpio_flags(np, 1, &flags); 226 pdata->inverted_b = flags & OF_GPIO_ACTIVE_LOW; 227 228 pdata->relative_axis = 229 of_property_read_bool(np, "rotary-encoder,relative-axis"); 230 pdata->rollover = of_property_read_bool(np, "rotary-encoder,rollover"); 231 232 error = of_property_read_u32(np, "rotary-encoder,steps-per-period", 233 &pdata->steps_per_period); 234 if (error) { 235 /* 236 * The 'half-period' property has been deprecated, you must use 237 * 'steps-per-period' and set an appropriate value, but we still 238 * need to parse it to maintain compatibility. 239 */ 240 if (of_property_read_bool(np, "rotary-encoder,half-period")) { 241 pdata->steps_per_period = 2; 242 } else { 243 /* Fallback to one step per period behavior */ 244 pdata->steps_per_period = 1; 245 } 246 } 247 248 pdata->wakeup_source = of_property_read_bool(np, "wakeup-source"); 249 250 return pdata; 251 } 252 #else 253 static inline struct rotary_encoder_platform_data * 254 rotary_encoder_parse_dt(struct device *dev) 255 { 256 return NULL; 257 } 258 #endif 259 260 static int rotary_encoder_probe(struct platform_device *pdev) 261 { 262 struct device *dev = &pdev->dev; 263 const struct rotary_encoder_platform_data *pdata = dev_get_platdata(dev); 264 struct rotary_encoder *encoder; 265 struct input_dev *input; 266 irq_handler_t handler; 267 int err; 268 269 if (!pdata) { 270 pdata = rotary_encoder_parse_dt(dev); 271 if (IS_ERR(pdata)) 272 return PTR_ERR(pdata); 273 274 if (!pdata) { 275 dev_err(dev, "missing platform data\n"); 276 return -EINVAL; 277 } 278 } 279 280 encoder = kzalloc(sizeof(struct rotary_encoder), GFP_KERNEL); 281 input = input_allocate_device(); 282 if (!encoder || !input) { 283 err = -ENOMEM; 284 goto exit_free_mem; 285 } 286 287 encoder->input = input; 288 encoder->pdata = pdata; 289 290 input->name = pdev->name; 291 input->id.bustype = BUS_HOST; 292 input->dev.parent = dev; 293 294 if (pdata->relative_axis) { 295 input->evbit[0] = BIT_MASK(EV_REL); 296 input->relbit[0] = BIT_MASK(pdata->axis); 297 } else { 298 input->evbit[0] = BIT_MASK(EV_ABS); 299 input_set_abs_params(encoder->input, 300 pdata->axis, 0, pdata->steps, 0, 1); 301 } 302 303 /* request the GPIOs */ 304 err = gpio_request_one(pdata->gpio_a, GPIOF_IN, dev_name(dev)); 305 if (err) { 306 dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_a); 307 goto exit_free_mem; 308 } 309 310 err = gpio_request_one(pdata->gpio_b, GPIOF_IN, dev_name(dev)); 311 if (err) { 312 dev_err(dev, "unable to request GPIO %d\n", pdata->gpio_b); 313 goto exit_free_gpio_a; 314 } 315 316 encoder->irq_a = gpio_to_irq(pdata->gpio_a); 317 encoder->irq_b = gpio_to_irq(pdata->gpio_b); 318 319 switch (pdata->steps_per_period) { 320 case 4: 321 handler = &rotary_encoder_quarter_period_irq; 322 encoder->last_stable = rotary_encoder_get_state(pdata); 323 break; 324 case 2: 325 handler = &rotary_encoder_half_period_irq; 326 encoder->last_stable = rotary_encoder_get_state(pdata); 327 break; 328 case 1: 329 handler = &rotary_encoder_irq; 330 break; 331 default: 332 dev_err(dev, "'%d' is not a valid steps-per-period value\n", 333 pdata->steps_per_period); 334 err = -EINVAL; 335 goto exit_free_gpio_b; 336 } 337 338 err = request_irq(encoder->irq_a, handler, 339 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 340 DRV_NAME, encoder); 341 if (err) { 342 dev_err(dev, "unable to request IRQ %d\n", encoder->irq_a); 343 goto exit_free_gpio_b; 344 } 345 346 err = request_irq(encoder->irq_b, handler, 347 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING, 348 DRV_NAME, encoder); 349 if (err) { 350 dev_err(dev, "unable to request IRQ %d\n", encoder->irq_b); 351 goto exit_free_irq_a; 352 } 353 354 err = input_register_device(input); 355 if (err) { 356 dev_err(dev, "failed to register input device\n"); 357 goto exit_free_irq_b; 358 } 359 360 device_init_wakeup(&pdev->dev, pdata->wakeup_source); 361 362 platform_set_drvdata(pdev, encoder); 363 364 return 0; 365 366 exit_free_irq_b: 367 free_irq(encoder->irq_b, encoder); 368 exit_free_irq_a: 369 free_irq(encoder->irq_a, encoder); 370 exit_free_gpio_b: 371 gpio_free(pdata->gpio_b); 372 exit_free_gpio_a: 373 gpio_free(pdata->gpio_a); 374 exit_free_mem: 375 input_free_device(input); 376 kfree(encoder); 377 if (!dev_get_platdata(&pdev->dev)) 378 kfree(pdata); 379 380 return err; 381 } 382 383 static int rotary_encoder_remove(struct platform_device *pdev) 384 { 385 struct rotary_encoder *encoder = platform_get_drvdata(pdev); 386 const struct rotary_encoder_platform_data *pdata = encoder->pdata; 387 388 device_init_wakeup(&pdev->dev, false); 389 390 free_irq(encoder->irq_a, encoder); 391 free_irq(encoder->irq_b, encoder); 392 gpio_free(pdata->gpio_a); 393 gpio_free(pdata->gpio_b); 394 395 input_unregister_device(encoder->input); 396 kfree(encoder); 397 398 if (!dev_get_platdata(&pdev->dev)) 399 kfree(pdata); 400 401 return 0; 402 } 403 404 #ifdef CONFIG_PM_SLEEP 405 static int rotary_encoder_suspend(struct device *dev) 406 { 407 struct rotary_encoder *encoder = dev_get_drvdata(dev); 408 409 if (device_may_wakeup(dev)) { 410 enable_irq_wake(encoder->irq_a); 411 enable_irq_wake(encoder->irq_b); 412 } 413 414 return 0; 415 } 416 417 static int rotary_encoder_resume(struct device *dev) 418 { 419 struct rotary_encoder *encoder = dev_get_drvdata(dev); 420 421 if (device_may_wakeup(dev)) { 422 disable_irq_wake(encoder->irq_a); 423 disable_irq_wake(encoder->irq_b); 424 } 425 426 return 0; 427 } 428 #endif 429 430 static SIMPLE_DEV_PM_OPS(rotary_encoder_pm_ops, 431 rotary_encoder_suspend, rotary_encoder_resume); 432 433 static struct platform_driver rotary_encoder_driver = { 434 .probe = rotary_encoder_probe, 435 .remove = rotary_encoder_remove, 436 .driver = { 437 .name = DRV_NAME, 438 .pm = &rotary_encoder_pm_ops, 439 .of_match_table = of_match_ptr(rotary_encoder_of_match), 440 } 441 }; 442 module_platform_driver(rotary_encoder_driver); 443 444 MODULE_ALIAS("platform:" DRV_NAME); 445 MODULE_DESCRIPTION("GPIO rotary encoder driver"); 446 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold"); 447 MODULE_LICENSE("GPL v2"); 448