input/misc/rotary_encoder.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * rotary_encoder.c
0004  *
0005  * (c) 2009 Daniel Mack <daniel@caiaq.de>
0006  * Copyright (C) 2011 Johan Hovold <jhovold@gmail.com>
0007  *
0008  * state machine code inspired by code from Tim Ruetz
0009  *
0010  * A generic driver for rotary encoders connected to GPIO lines.
0011  * See file:Documentation/input/devices/rotary-encoder.rst for more information
0012  */
0013
0014 #include <linux/kernel.h>
0015 #include <linux/module.h>
0016 #include <linux/interrupt.h>
0017 #include <linux/input.h>
0018 #include <linux/device.h>
0019 #include <linux/platform_device.h>
0020 #include <linux/gpio/consumer.h>
0021 #include <linux/slab.h>
0022 #include <linux/of.h>
0023 #include <linux/pm.h>
0024 #include <linux/property.h>
0025
0026 #define DRV_NAME "rotary-encoder"
0027
0028 enum rotary_encoder_encoding {
0029     ROTENC_GRAY,
0030     ROTENC_BINARY,
0031 };
0032
0033 struct rotary_encoder {
0034     struct input_dev *input;
0035
0036     struct mutex access_mutex;
0037
0038     u32 steps;
0039     u32 axis;
0040     bool relative_axis;
0041     bool rollover;
0042     enum rotary_encoder_encoding encoding;
0043
0044     unsigned int pos;
0045
0046     struct gpio_descs *gpios;
0047
0048     unsigned int *irq;
0049
0050     bool armed;
0051     signed char dir;    /* 1 - clockwise, -1 - CCW */
0052
0053     unsigned int last_stable;
0054 };
0055
0056 static unsigned int rotary_encoder_get_state(struct rotary_encoder *encoder)
0057 {
0058     int i;
0059     unsigned int ret = 0;
0060
0061     for (i = 0; i < encoder->gpios->ndescs; ++i) {
0062         int val = gpiod_get_value_cansleep(encoder->gpios->desc[i]);
0063
0064         /* convert from gray encoding to normal */
0065         if (encoder->encoding == ROTENC_GRAY && ret & 1)
0066             val = !val;
0067
0068         ret = ret << 1 | val;
0069     }
0070
0071     return ret & 3;
0072 }
0073
0074 static void rotary_encoder_report_event(struct rotary_encoder *encoder)
0075 {
0076     if (encoder->relative_axis) {
0077         input_report_rel(encoder->input,
0078                  encoder->axis, encoder->dir);
0079     } else {
0080         unsigned int pos = encoder->pos;
0081
0082         if (encoder->dir < 0) {
0083             /* turning counter-clockwise */
0084             if (encoder->rollover)
0085                 pos += encoder->steps;
0086             if (pos)
0087                 pos--;
0088         } else {
0089             /* turning clockwise */
0090             if (encoder->rollover || pos < encoder->steps)
0091                 pos++;
0092         }
0093
0094         if (encoder->rollover)
0095             pos %= encoder->steps;
0096
0097         encoder->pos = pos;
0098         input_report_abs(encoder->input, encoder->axis, encoder->pos);
0099     }
0100
0101     input_sync(encoder->input);
0102 }
0103
0104 static irqreturn_t rotary_encoder_irq(int irq, void *dev_id)
0105 {
0106     struct rotary_encoder *encoder = dev_id;
0107     unsigned int state;
0108
0109     mutex_lock(&encoder->access_mutex);
0110
0111     state = rotary_encoder_get_state(encoder);
0112
0113     switch (state) {
0114     case 0x0:
0115         if (encoder->armed) {
0116             rotary_encoder_report_event(encoder);
0117             encoder->armed = false;
0118         }
0119         break;
0120
0121     case 0x1:
0122     case 0x3:
0123         if (encoder->armed)
0124             encoder->dir = 2 - state;
0125         break;
0126
0127     case 0x2:
0128         encoder->armed = true;
0129         break;
0130     }
0131
0132     mutex_unlock(&encoder->access_mutex);
0133
0134     return IRQ_HANDLED;
0135 }
0136
0137 static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id)
0138 {
0139     struct rotary_encoder *encoder = dev_id;
0140     unsigned int state;
0141
0142     mutex_lock(&encoder->access_mutex);
0143
0144     state = rotary_encoder_get_state(encoder);
0145
0146     if (state & 1) {
0147         encoder->dir = ((encoder->last_stable - state + 1) % 4) - 1;
0148     } else {
0149         if (state != encoder->last_stable) {
0150             rotary_encoder_report_event(encoder);
0151             encoder->last_stable = state;
0152         }
0153     }
0154
0155     mutex_unlock(&encoder->access_mutex);
0156
0157     return IRQ_HANDLED;
0158 }
0159
0160 static irqreturn_t rotary_encoder_quarter_period_irq(int irq, void *dev_id)
0161 {
0162     struct rotary_encoder *encoder = dev_id;
0163     unsigned int state;
0164
0165     mutex_lock(&encoder->access_mutex);
0166
0167     state = rotary_encoder_get_state(encoder);
0168
0169     if ((encoder->last_stable + 1) % 4 == state)
0170         encoder->dir = 1;
0171     else if (encoder->last_stable == (state + 1) % 4)
0172         encoder->dir = -1;
0173     else
0174         goto out;
0175
0176     rotary_encoder_report_event(encoder);
0177
0178 out:
0179     encoder->last_stable = state;
0180     mutex_unlock(&encoder->access_mutex);
0181
0182     return IRQ_HANDLED;
0183 }
0184
0185 static int rotary_encoder_probe(struct platform_device *pdev)
0186 {
0187     struct device *dev = &pdev->dev;
0188     struct rotary_encoder *encoder;
0189     struct input_dev *input;
0190     irq_handler_t handler;
0191     u32 steps_per_period;
0192     unsigned int i;
0193     int err;
0194
0195     encoder = devm_kzalloc(dev, sizeof(struct rotary_encoder), GFP_KERNEL);
0196     if (!encoder)
0197         return -ENOMEM;
0198
0199     mutex_init(&encoder->access_mutex);
0200
0201     device_property_read_u32(dev, "rotary-encoder,steps", &encoder->steps);
0202
0203     err = device_property_read_u32(dev, "rotary-encoder,steps-per-period",
0204                        &steps_per_period);
0205     if (err) {
0206         /*
0207          * The 'half-period' property has been deprecated, you must
0208          * use 'steps-per-period' and set an appropriate value, but
0209          * we still need to parse it to maintain compatibility. If
0210          * neither property is present we fall back to the one step
0211          * per period behavior.
0212          */
0213         steps_per_period = device_property_read_bool(dev,
0214                     "rotary-encoder,half-period") ? 2 : 1;
0215     }
0216
0217     encoder->rollover =
0218         device_property_read_bool(dev, "rotary-encoder,rollover");
0219
0220     if (!device_property_present(dev, "rotary-encoder,encoding") ||
0221         !device_property_match_string(dev, "rotary-encoder,encoding",
0222                       "gray")) {
0223         dev_info(dev, "gray");
0224         encoder->encoding = ROTENC_GRAY;
0225     } else if (!device_property_match_string(dev, "rotary-encoder,encoding",
0226                          "binary")) {
0227         dev_info(dev, "binary");
0228         encoder->encoding = ROTENC_BINARY;
0229     } else {
0230         dev_err(dev, "unknown encoding setting\n");
0231         return -EINVAL;
0232     }
0233
0234     device_property_read_u32(dev, "linux,axis", &encoder->axis);
0235     encoder->relative_axis =
0236         device_property_read_bool(dev, "rotary-encoder,relative-axis");
0237
0238     encoder->gpios = devm_gpiod_get_array(dev, NULL, GPIOD_IN);
0239     if (IS_ERR(encoder->gpios)) {
0240         err = PTR_ERR(encoder->gpios);
0241         if (err != -EPROBE_DEFER)
0242             dev_err(dev, "unable to get gpios: %d\n", err);
0243         return err;
0244     }
0245     if (encoder->gpios->ndescs < 2) {
0246         dev_err(dev, "not enough gpios found\n");
0247         return -EINVAL;
0248     }
0249
0250     input = devm_input_allocate_device(dev);
0251     if (!input)
0252         return -ENOMEM;
0253
0254     encoder->input = input;
0255
0256     input->name = pdev->name;
0257     input->id.bustype = BUS_HOST;
0258     input->dev.parent = dev;
0259
0260     if (encoder->relative_axis)
0261         input_set_capability(input, EV_REL, encoder->axis);
0262     else
0263         input_set_abs_params(input,
0264                      encoder->axis, 0, encoder->steps, 0, 1);
0265
0266     switch (steps_per_period >> (encoder->gpios->ndescs - 2)) {
0267     case 4:
0268         handler = &rotary_encoder_quarter_period_irq;
0269         encoder->last_stable = rotary_encoder_get_state(encoder);
0270         break;
0271     case 2:
0272         handler = &rotary_encoder_half_period_irq;
0273         encoder->last_stable = rotary_encoder_get_state(encoder);
0274         break;
0275     case 1:
0276         handler = &rotary_encoder_irq;
0277         break;
0278     default:
0279         dev_err(dev, "'%d' is not a valid steps-per-period value\n",
0280             steps_per_period);
0281         return -EINVAL;
0282     }
0283
0284     encoder->irq =
0285         devm_kcalloc(dev,
0286                  encoder->gpios->ndescs, sizeof(*encoder->irq),
0287                  GFP_KERNEL);
0288     if (!encoder->irq)
0289         return -ENOMEM;
0290
0291     for (i = 0; i < encoder->gpios->ndescs; ++i) {
0292         encoder->irq[i] = gpiod_to_irq(encoder->gpios->desc[i]);
0293
0294         err = devm_request_threaded_irq(dev, encoder->irq[i],
0295                 NULL, handler,
0296                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
0297                 IRQF_ONESHOT,
0298                 DRV_NAME, encoder);
0299         if (err) {
0300             dev_err(dev, "unable to request IRQ %d (gpio#%d)\n",
0301                 encoder->irq[i], i);
0302             return err;
0303         }
0304     }
0305
0306     err = input_register_device(input);
0307     if (err) {
0308         dev_err(dev, "failed to register input device\n");
0309         return err;
0310     }
0311
0312     device_init_wakeup(dev,
0313                device_property_read_bool(dev, "wakeup-source"));
0314
0315     platform_set_drvdata(pdev, encoder);
0316
0317     return 0;
0318 }
0319
0320 static int __maybe_unused rotary_encoder_suspend(struct device *dev)
0321 {
0322     struct rotary_encoder *encoder = dev_get_drvdata(dev);
0323     unsigned int i;
0324
0325     if (device_may_wakeup(dev)) {
0326         for (i = 0; i < encoder->gpios->ndescs; ++i)
0327             enable_irq_wake(encoder->irq[i]);
0328     }
0329
0330     return 0;
0331 }
0332
0333 static int __maybe_unused rotary_encoder_resume(struct device *dev)
0334 {
0335     struct rotary_encoder *encoder = dev_get_drvdata(dev);
0336     unsigned int i;
0337
0338     if (device_may_wakeup(dev)) {
0339         for (i = 0; i < encoder->gpios->ndescs; ++i)
0340             disable_irq_wake(encoder->irq[i]);
0341     }
0342
0343     return 0;
0344 }
0345
0346 static SIMPLE_DEV_PM_OPS(rotary_encoder_pm_ops,
0347              rotary_encoder_suspend, rotary_encoder_resume);
0348
0349 #ifdef CONFIG_OF
0350 static const struct of_device_id rotary_encoder_of_match[] = {
0351     { .compatible = "rotary-encoder", },
0352     { },
0353 };
0354 MODULE_DEVICE_TABLE(of, rotary_encoder_of_match);
0355 #endif
0356
0357 static struct platform_driver rotary_encoder_driver = {
0358     .probe      = rotary_encoder_probe,
0359     .driver     = {
0360         .name   = DRV_NAME,
0361         .pm = &rotary_encoder_pm_ops,
0362         .of_match_table = of_match_ptr(rotary_encoder_of_match),
0363     }
0364 };
0365 module_platform_driver(rotary_encoder_driver);
0366
0367 MODULE_ALIAS("platform:" DRV_NAME);
0368 MODULE_DESCRIPTION("GPIO rotary encoder driver");
0369 MODULE_AUTHOR("Daniel Mack <daniel@caiaq.de>, Johan Hovold");
0370 MODULE_LICENSE("GPL v2");