1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * rotary_encoder.c 4 * 5 * (c) 2009 Daniel Mack <daniel@caiaq.de> 6 * Copyright (C) 2011 Johan Hovold <jhovold@gmail.com> 7 * 8 * state machine code inspired by code from Tim Ruetz 9 * 10 * A generic driver for rotary encoders connected to GPIO lines. 11 * See file:Documentation/input/devices/rotary-encoder.rst for more information 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/module.h> 16 #include <linux/interrupt.h> 17 #include <linux/input.h> 18 #include <linux/device.h> 19 #include <linux/platform_device.h> 20 #include <linux/gpio/consumer.h> 21 #include <linux/slab.h> 22 #include <linux/of.h> 23 #include <linux/pm.h> 24 #include <linux/property.h> 25 26 #define DRV_NAME "rotary-encoder" 27 28 enum rotary_encoder_encoding { 29 ROTENC_GRAY, 30 ROTENC_BINARY, 31 }; 32 33 struct rotary_encoder { 34 struct input_dev *input; 35 36 struct mutex access_mutex; 37 38 u32 steps; 39 u32 axis; 40 bool relative_axis; 41 bool rollover; 42 enum rotary_encoder_encoding encoding; 43 44 unsigned int pos; 45 46 struct gpio_descs *gpios; 47 48 unsigned int *irq; 49 50 bool armed; 51 signed char dir; /* 1 - clockwise, -1 - CCW */ 52 53 unsigned int last_stable; 54 }; 55 56 static unsigned int rotary_encoder_get_state(struct rotary_encoder *encoder) 57 { 58 int i; 59 unsigned int ret = 0; 60 61 for (i = 0; i < encoder->gpios->ndescs; ++i) { 62 int val = gpiod_get_value_cansleep(encoder->gpios->desc[i]); 63 64 /* convert from gray encoding to normal */ 65 if (encoder->encoding == ROTENC_GRAY && ret & 1) 66 val = !val; 67 68 ret = ret << 1 | val; 69 } 70 71 return ret & 3; 72 } 73 74 static void rotary_encoder_report_event(struct rotary_encoder *encoder) 75 { 76 if (encoder->relative_axis) { 77 input_report_rel(encoder->input, 78 encoder->axis, encoder->dir); 79 } else { 80 unsigned int pos = encoder->pos; 81 82 if (encoder->dir < 0) { 83 /* turning counter-clockwise */ 84 if (encoder->rollover) 85 pos += encoder->steps; 86 if (pos) 87 pos--; 88 } else { 89 /* turning clockwise */ 90 if (encoder->rollover || pos < encoder->steps) 91 pos++; 92 } 93 94 if (encoder->rollover) 95 pos %= encoder->steps; 96 97 encoder->pos = pos; 98 input_report_abs(encoder->input, encoder->axis, encoder->pos); 99 } 100 101 input_sync(encoder->input); 102 } 103 104 static irqreturn_t rotary_encoder_irq(int irq, void *dev_id) 105 { 106 struct rotary_encoder *encoder = dev_id; 107 unsigned int state; 108 109 guard(mutex)(&encoder->access_mutex); 110 111 state = rotary_encoder_get_state(encoder); 112 113 switch (state) { 114 case 0x0: 115 if (encoder->armed) { 116 rotary_encoder_report_event(encoder); 117 encoder->armed = false; 118 } 119 break; 120 121 case 0x1: 122 case 0x3: 123 if (encoder->armed) 124 encoder->dir = 2 - state; 125 break; 126 127 case 0x2: 128 encoder->armed = true; 129 break; 130 } 131 132 return IRQ_HANDLED; 133 } 134 135 static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id) 136 { 137 struct rotary_encoder *encoder = dev_id; 138 unsigned int state; 139 140 guard(mutex)(&encoder->access_mutex); 141 142 state = rotary_encoder_get_state(encoder); 143 144 if (state & 1) { 145 encoder->dir = ((encoder->last_stable - state + 1) % 4) - 1; 146 } else { 147 if (state != encoder->last_stable) { 148 rotary_encoder_report_event(encoder); 149 encoder->last_stable = state; 150 } 151 } 152 153 return IRQ_HANDLED; 154 } 155 156 static irqreturn_t rotary_encoder_quarter_period_irq(int irq, void *dev_id) 157 { 158 struct rotary_encoder *encoder = dev_id; 159 unsigned int state; 160 161 guard(mutex)(&encoder->access_mutex); 162 163 state = rotary_encoder_get_state(encoder); 164 165 if ((encoder->last_stable + 1) % 4 == state) { 166 encoder->dir = 1; 167 rotary_encoder_report_event(encoder); 168 } else if (encoder->last_stable == (state + 1) % 4) { 169 encoder->dir = -1; 170 rotary_encoder_report_event(encoder); 171 } 172 173 encoder->last_stable = state; 174 175 return IRQ_HANDLED; 176 } 177 178 static int rotary_encoder_probe(struct platform_device *pdev) 179 { 180 struct device *dev = &pdev->dev; 181 struct rotary_encoder *encoder; 182 struct input_dev *input; 183 irq_handler_t handler; 184 u32 steps_per_period; 185 unsigned int i; 186 int err; 187 188 encoder = devm_kzalloc_obj(dev, struct rotary_encoder); 189 if (!encoder) 190 return -ENOMEM; 191 192 mutex_init(&encoder->access_mutex); 193 194 device_property_read_u32(dev, "rotary-encoder,steps", &encoder->steps); 195 196 err = device_property_read_u32(dev, "rotary-encoder,steps-per-period", 197 &steps_per_period); 198 if (err) { 199 /* 200 * The 'half-period' property has been deprecated, you must 201 * use 'steps-per-period' and set an appropriate value, but 202 * we still need to parse it to maintain compatibility. If 203 * neither property is present we fall back to the one step 204 * per period behavior. 205 */ 206 steps_per_period = device_property_read_bool(dev, 207 "rotary-encoder,half-period") ? 2 : 1; 208 } 209 210 encoder->rollover = 211 device_property_read_bool(dev, "rotary-encoder,rollover"); 212 213 if (!device_property_present(dev, "rotary-encoder,encoding") || 214 !device_property_match_string(dev, "rotary-encoder,encoding", 215 "gray")) { 216 dev_info(dev, "gray"); 217 encoder->encoding = ROTENC_GRAY; 218 } else if (!device_property_match_string(dev, "rotary-encoder,encoding", 219 "binary")) { 220 dev_info(dev, "binary"); 221 encoder->encoding = ROTENC_BINARY; 222 } else { 223 dev_err(dev, "unknown encoding setting\n"); 224 return -EINVAL; 225 } 226 227 device_property_read_u32(dev, "linux,axis", &encoder->axis); 228 encoder->relative_axis = 229 device_property_read_bool(dev, "rotary-encoder,relative-axis"); 230 231 encoder->gpios = devm_gpiod_get_array(dev, NULL, GPIOD_IN); 232 if (IS_ERR(encoder->gpios)) 233 return dev_err_probe(dev, PTR_ERR(encoder->gpios), "unable to get gpios\n"); 234 if (encoder->gpios->ndescs < 2) { 235 dev_err(dev, "not enough gpios found\n"); 236 return -EINVAL; 237 } 238 239 input = devm_input_allocate_device(dev); 240 if (!input) 241 return -ENOMEM; 242 243 encoder->input = input; 244 245 input->name = pdev->name; 246 input->id.bustype = BUS_HOST; 247 248 if (encoder->relative_axis) 249 input_set_capability(input, EV_REL, encoder->axis); 250 else 251 input_set_abs_params(input, 252 encoder->axis, 0, encoder->steps, 0, 1); 253 254 switch (steps_per_period >> (encoder->gpios->ndescs - 2)) { 255 case 4: 256 handler = &rotary_encoder_quarter_period_irq; 257 encoder->last_stable = rotary_encoder_get_state(encoder); 258 break; 259 case 2: 260 handler = &rotary_encoder_half_period_irq; 261 encoder->last_stable = rotary_encoder_get_state(encoder); 262 break; 263 case 1: 264 handler = &rotary_encoder_irq; 265 break; 266 default: 267 dev_err(dev, "'%d' is not a valid steps-per-period value\n", 268 steps_per_period); 269 return -EINVAL; 270 } 271 272 encoder->irq = 273 devm_kzalloc_objs(dev, *encoder->irq, encoder->gpios->ndescs); 274 if (!encoder->irq) 275 return -ENOMEM; 276 277 for (i = 0; i < encoder->gpios->ndescs; ++i) { 278 encoder->irq[i] = gpiod_to_irq(encoder->gpios->desc[i]); 279 280 err = devm_request_threaded_irq(dev, encoder->irq[i], 281 NULL, handler, 282 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | 283 IRQF_ONESHOT, 284 DRV_NAME, encoder); 285 if (err) { 286 dev_err(dev, "unable to request IRQ %d (gpio#%d)\n", 287 encoder->irq[i], i); 288 return err; 289 } 290 } 291 292 err = input_register_device(input); 293 if (err) { 294 dev_err(dev, "failed to register input device\n"); 295 return err; 296 } 297 298 device_init_wakeup(dev, 299 device_property_read_bool(dev, "wakeup-source")); 300 301 platform_set_drvdata(pdev, encoder); 302 303 return 0; 304 } 305 306 static int rotary_encoder_suspend(struct device *dev) 307 { 308 struct rotary_encoder *encoder = dev_get_drvdata(dev); 309 unsigned int i; 310 311 if (device_may_wakeup(dev)) { 312 for (i = 0; i < encoder->gpios->ndescs; ++i) 313 enable_irq_wake(encoder->irq[i]); 314 } 315 316 return 0; 317 } 318 319 static int rotary_encoder_resume(struct device *dev) 320 { 321 struct rotary_encoder *encoder = dev_get_drvdata(dev); 322 unsigned int i; 323 324 if (device_may_wakeup(dev)) { 325 for (i = 0; i < encoder->gpios->ndescs; ++i) 326 disable_irq_wake(encoder->irq[i]); 327 } 328 329 return 0; 330 } 331 332 static DEFINE_SIMPLE_DEV_PM_OPS(rotary_encoder_pm_ops, 333 rotary_encoder_suspend, rotary_encoder_resume); 334 335 #ifdef CONFIG_OF 336 static const struct of_device_id rotary_encoder_of_match[] = { 337 { .compatible = "rotary-encoder", }, 338 { }, 339 }; 340 MODULE_DEVICE_TABLE(of, rotary_encoder_of_match); 341 #endif 342 343 static struct platform_driver rotary_encoder_driver = { 344 .probe = rotary_encoder_probe, 345 .driver = { 346 .name = DRV_NAME, 347 .pm = pm_sleep_ptr(&rotary_encoder_pm_ops), 348 .of_match_table = of_match_ptr(rotary_encoder_of_match), 349 } 350 }; 351 module_platform_driver(rotary_encoder_driver); 352 353 MODULE_ALIAS("platform:" DRV_NAME); 354 MODULE_DESCRIPTION("GPIO rotary encoder driver"); 355 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold"); 356 MODULE_LICENSE("GPL v2"); 357