forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
370 lines
8.4 KiB
370 lines
8.4 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* rotary_encoder.c |
|
* |
|
* (c) 2009 Daniel Mack <[email protected]> |
|
* Copyright (C) 2011 Johan Hovold <[email protected]> |
|
* |
|
* state machine code inspired by code from Tim Ruetz |
|
* |
|
* A generic driver for rotary encoders connected to GPIO lines. |
|
* See file:Documentation/input/devices/rotary-encoder.rst for more information |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/module.h> |
|
#include <linux/interrupt.h> |
|
#include <linux/input.h> |
|
#include <linux/device.h> |
|
#include <linux/platform_device.h> |
|
#include <linux/gpio/consumer.h> |
|
#include <linux/slab.h> |
|
#include <linux/of.h> |
|
#include <linux/pm.h> |
|
#include <linux/property.h> |
|
|
|
#define DRV_NAME "rotary-encoder" |
|
|
|
enum rotary_encoder_encoding { |
|
ROTENC_GRAY, |
|
ROTENC_BINARY, |
|
}; |
|
|
|
struct rotary_encoder { |
|
struct input_dev *input; |
|
|
|
struct mutex access_mutex; |
|
|
|
u32 steps; |
|
u32 axis; |
|
bool relative_axis; |
|
bool rollover; |
|
enum rotary_encoder_encoding encoding; |
|
|
|
unsigned int pos; |
|
|
|
struct gpio_descs *gpios; |
|
|
|
unsigned int *irq; |
|
|
|
bool armed; |
|
signed char dir; /* 1 - clockwise, -1 - CCW */ |
|
|
|
unsigned int last_stable; |
|
}; |
|
|
|
static unsigned int rotary_encoder_get_state(struct rotary_encoder *encoder) |
|
{ |
|
int i; |
|
unsigned int ret = 0; |
|
|
|
for (i = 0; i < encoder->gpios->ndescs; ++i) { |
|
int val = gpiod_get_value_cansleep(encoder->gpios->desc[i]); |
|
|
|
/* convert from gray encoding to normal */ |
|
if (encoder->encoding == ROTENC_GRAY && ret & 1) |
|
val = !val; |
|
|
|
ret = ret << 1 | val; |
|
} |
|
|
|
return ret & 3; |
|
} |
|
|
|
static void rotary_encoder_report_event(struct rotary_encoder *encoder) |
|
{ |
|
if (encoder->relative_axis) { |
|
input_report_rel(encoder->input, |
|
encoder->axis, encoder->dir); |
|
} else { |
|
unsigned int pos = encoder->pos; |
|
|
|
if (encoder->dir < 0) { |
|
/* turning counter-clockwise */ |
|
if (encoder->rollover) |
|
pos += encoder->steps; |
|
if (pos) |
|
pos--; |
|
} else { |
|
/* turning clockwise */ |
|
if (encoder->rollover || pos < encoder->steps) |
|
pos++; |
|
} |
|
|
|
if (encoder->rollover) |
|
pos %= encoder->steps; |
|
|
|
encoder->pos = pos; |
|
input_report_abs(encoder->input, encoder->axis, encoder->pos); |
|
} |
|
|
|
input_sync(encoder->input); |
|
} |
|
|
|
static irqreturn_t rotary_encoder_irq(int irq, void *dev_id) |
|
{ |
|
struct rotary_encoder *encoder = dev_id; |
|
unsigned int state; |
|
|
|
mutex_lock(&encoder->access_mutex); |
|
|
|
state = rotary_encoder_get_state(encoder); |
|
|
|
switch (state) { |
|
case 0x0: |
|
if (encoder->armed) { |
|
rotary_encoder_report_event(encoder); |
|
encoder->armed = false; |
|
} |
|
break; |
|
|
|
case 0x1: |
|
case 0x3: |
|
if (encoder->armed) |
|
encoder->dir = 2 - state; |
|
break; |
|
|
|
case 0x2: |
|
encoder->armed = true; |
|
break; |
|
} |
|
|
|
mutex_unlock(&encoder->access_mutex); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
static irqreturn_t rotary_encoder_half_period_irq(int irq, void *dev_id) |
|
{ |
|
struct rotary_encoder *encoder = dev_id; |
|
unsigned int state; |
|
|
|
mutex_lock(&encoder->access_mutex); |
|
|
|
state = rotary_encoder_get_state(encoder); |
|
|
|
if (state & 1) { |
|
encoder->dir = ((encoder->last_stable - state + 1) % 4) - 1; |
|
} else { |
|
if (state != encoder->last_stable) { |
|
rotary_encoder_report_event(encoder); |
|
encoder->last_stable = state; |
|
} |
|
} |
|
|
|
mutex_unlock(&encoder->access_mutex); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
static irqreturn_t rotary_encoder_quarter_period_irq(int irq, void *dev_id) |
|
{ |
|
struct rotary_encoder *encoder = dev_id; |
|
unsigned int state; |
|
|
|
mutex_lock(&encoder->access_mutex); |
|
|
|
state = rotary_encoder_get_state(encoder); |
|
|
|
if ((encoder->last_stable + 1) % 4 == state) |
|
encoder->dir = 1; |
|
else if (encoder->last_stable == (state + 1) % 4) |
|
encoder->dir = -1; |
|
else |
|
goto out; |
|
|
|
rotary_encoder_report_event(encoder); |
|
|
|
out: |
|
encoder->last_stable = state; |
|
mutex_unlock(&encoder->access_mutex); |
|
|
|
return IRQ_HANDLED; |
|
} |
|
|
|
static int rotary_encoder_probe(struct platform_device *pdev) |
|
{ |
|
struct device *dev = &pdev->dev; |
|
struct rotary_encoder *encoder; |
|
struct input_dev *input; |
|
irq_handler_t handler; |
|
u32 steps_per_period; |
|
unsigned int i; |
|
int err; |
|
|
|
encoder = devm_kzalloc(dev, sizeof(struct rotary_encoder), GFP_KERNEL); |
|
if (!encoder) |
|
return -ENOMEM; |
|
|
|
mutex_init(&encoder->access_mutex); |
|
|
|
device_property_read_u32(dev, "rotary-encoder,steps", &encoder->steps); |
|
|
|
err = device_property_read_u32(dev, "rotary-encoder,steps-per-period", |
|
&steps_per_period); |
|
if (err) { |
|
/* |
|
* The 'half-period' property has been deprecated, you must |
|
* use 'steps-per-period' and set an appropriate value, but |
|
* we still need to parse it to maintain compatibility. If |
|
* neither property is present we fall back to the one step |
|
* per period behavior. |
|
*/ |
|
steps_per_period = device_property_read_bool(dev, |
|
"rotary-encoder,half-period") ? 2 : 1; |
|
} |
|
|
|
encoder->rollover = |
|
device_property_read_bool(dev, "rotary-encoder,rollover"); |
|
|
|
if (!device_property_present(dev, "rotary-encoder,encoding") || |
|
!device_property_match_string(dev, "rotary-encoder,encoding", |
|
"gray")) { |
|
dev_info(dev, "gray"); |
|
encoder->encoding = ROTENC_GRAY; |
|
} else if (!device_property_match_string(dev, "rotary-encoder,encoding", |
|
"binary")) { |
|
dev_info(dev, "binary"); |
|
encoder->encoding = ROTENC_BINARY; |
|
} else { |
|
dev_err(dev, "unknown encoding setting\n"); |
|
return -EINVAL; |
|
} |
|
|
|
device_property_read_u32(dev, "linux,axis", &encoder->axis); |
|
encoder->relative_axis = |
|
device_property_read_bool(dev, "rotary-encoder,relative-axis"); |
|
|
|
encoder->gpios = devm_gpiod_get_array(dev, NULL, GPIOD_IN); |
|
if (IS_ERR(encoder->gpios)) { |
|
err = PTR_ERR(encoder->gpios); |
|
if (err != -EPROBE_DEFER) |
|
dev_err(dev, "unable to get gpios: %d\n", err); |
|
return err; |
|
} |
|
if (encoder->gpios->ndescs < 2) { |
|
dev_err(dev, "not enough gpios found\n"); |
|
return -EINVAL; |
|
} |
|
|
|
input = devm_input_allocate_device(dev); |
|
if (!input) |
|
return -ENOMEM; |
|
|
|
encoder->input = input; |
|
|
|
input->name = pdev->name; |
|
input->id.bustype = BUS_HOST; |
|
input->dev.parent = dev; |
|
|
|
if (encoder->relative_axis) |
|
input_set_capability(input, EV_REL, encoder->axis); |
|
else |
|
input_set_abs_params(input, |
|
encoder->axis, 0, encoder->steps, 0, 1); |
|
|
|
switch (steps_per_period >> (encoder->gpios->ndescs - 2)) { |
|
case 4: |
|
handler = &rotary_encoder_quarter_period_irq; |
|
encoder->last_stable = rotary_encoder_get_state(encoder); |
|
break; |
|
case 2: |
|
handler = &rotary_encoder_half_period_irq; |
|
encoder->last_stable = rotary_encoder_get_state(encoder); |
|
break; |
|
case 1: |
|
handler = &rotary_encoder_irq; |
|
break; |
|
default: |
|
dev_err(dev, "'%d' is not a valid steps-per-period value\n", |
|
steps_per_period); |
|
return -EINVAL; |
|
} |
|
|
|
encoder->irq = |
|
devm_kcalloc(dev, |
|
encoder->gpios->ndescs, sizeof(*encoder->irq), |
|
GFP_KERNEL); |
|
if (!encoder->irq) |
|
return -ENOMEM; |
|
|
|
for (i = 0; i < encoder->gpios->ndescs; ++i) { |
|
encoder->irq[i] = gpiod_to_irq(encoder->gpios->desc[i]); |
|
|
|
err = devm_request_threaded_irq(dev, encoder->irq[i], |
|
NULL, handler, |
|
IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING | |
|
IRQF_ONESHOT, |
|
DRV_NAME, encoder); |
|
if (err) { |
|
dev_err(dev, "unable to request IRQ %d (gpio#%d)\n", |
|
encoder->irq[i], i); |
|
return err; |
|
} |
|
} |
|
|
|
err = input_register_device(input); |
|
if (err) { |
|
dev_err(dev, "failed to register input device\n"); |
|
return err; |
|
} |
|
|
|
device_init_wakeup(dev, |
|
device_property_read_bool(dev, "wakeup-source")); |
|
|
|
platform_set_drvdata(pdev, encoder); |
|
|
|
return 0; |
|
} |
|
|
|
static int __maybe_unused rotary_encoder_suspend(struct device *dev) |
|
{ |
|
struct rotary_encoder *encoder = dev_get_drvdata(dev); |
|
unsigned int i; |
|
|
|
if (device_may_wakeup(dev)) { |
|
for (i = 0; i < encoder->gpios->ndescs; ++i) |
|
enable_irq_wake(encoder->irq[i]); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static int __maybe_unused rotary_encoder_resume(struct device *dev) |
|
{ |
|
struct rotary_encoder *encoder = dev_get_drvdata(dev); |
|
unsigned int i; |
|
|
|
if (device_may_wakeup(dev)) { |
|
for (i = 0; i < encoder->gpios->ndescs; ++i) |
|
disable_irq_wake(encoder->irq[i]); |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static SIMPLE_DEV_PM_OPS(rotary_encoder_pm_ops, |
|
rotary_encoder_suspend, rotary_encoder_resume); |
|
|
|
#ifdef CONFIG_OF |
|
static const struct of_device_id rotary_encoder_of_match[] = { |
|
{ .compatible = "rotary-encoder", }, |
|
{ }, |
|
}; |
|
MODULE_DEVICE_TABLE(of, rotary_encoder_of_match); |
|
#endif |
|
|
|
static struct platform_driver rotary_encoder_driver = { |
|
.probe = rotary_encoder_probe, |
|
.driver = { |
|
.name = DRV_NAME, |
|
.pm = &rotary_encoder_pm_ops, |
|
.of_match_table = of_match_ptr(rotary_encoder_of_match), |
|
} |
|
}; |
|
module_platform_driver(rotary_encoder_driver); |
|
|
|
MODULE_ALIAS("platform:" DRV_NAME); |
|
MODULE_DESCRIPTION("GPIO rotary encoder driver"); |
|
MODULE_AUTHOR("Daniel Mack <[email protected]>, Johan Hovold"); |
|
MODULE_LICENSE("GPL v2");
|
|
|