438 lines
10 KiB
C
438 lines
10 KiB
C
/*
|
|
* Copyright 2023 Google LLC
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#define DT_DRV_COMPAT gpio_qdec
|
|
|
|
#include <stdint.h>
|
|
#include <stdlib.h>
|
|
|
|
#include <zephyr/device.h>
|
|
#include <zephyr/drivers/gpio.h>
|
|
#include <zephyr/input/input.h>
|
|
#include <zephyr/kernel.h>
|
|
#include <zephyr/pm/device.h>
|
|
#include <zephyr/pm/device_runtime.h>
|
|
#include <zephyr/sys/atomic.h>
|
|
#include <zephyr/sys/util.h>
|
|
|
|
#include <zephyr/logging/log.h>
|
|
LOG_MODULE_REGISTER(input_gpio_qdec, CONFIG_INPUT_LOG_LEVEL);
|
|
|
|
#define GPIO_QDEC_GPIO_NUM 2
|
|
|
|
struct gpio_qdec_config {
|
|
struct gpio_dt_spec ab_gpio[GPIO_QDEC_GPIO_NUM];
|
|
const struct gpio_dt_spec *led_gpio;
|
|
uint8_t led_gpio_count;
|
|
uint32_t led_pre_us;
|
|
uint32_t sample_time_us;
|
|
uint32_t idle_poll_time_us;
|
|
uint32_t idle_timeout_ms;
|
|
uint16_t axis;
|
|
uint8_t steps_per_period;
|
|
};
|
|
|
|
struct gpio_qdec_data {
|
|
const struct device *dev;
|
|
struct k_timer sample_timer;
|
|
uint8_t prev_step;
|
|
int32_t acc;
|
|
struct k_work event_work;
|
|
struct k_work_delayable idle_work;
|
|
struct gpio_callback gpio_cb;
|
|
atomic_t polling;
|
|
#ifdef CONFIG_PM_DEVICE
|
|
atomic_t suspended;
|
|
#endif
|
|
};
|
|
|
|
/* Positive transitions */
|
|
#define QDEC_LL_LH 0x01
|
|
#define QDEC_LH_HH 0x13
|
|
#define QDEC_HH_HL 0x32
|
|
#define QDEC_HL_LL 0x20
|
|
|
|
/* Negative transitions */
|
|
#define QDEC_LL_HL 0x02
|
|
#define QDEC_LH_LL 0x10
|
|
#define QDEC_HH_LH 0x31
|
|
#define QDEC_HL_HH 0x23
|
|
|
|
static void gpio_qdec_irq_setup(const struct device *dev, bool enable)
|
|
{
|
|
const struct gpio_qdec_config *cfg = dev->config;
|
|
gpio_flags_t flags = enable ? GPIO_INT_EDGE_BOTH : GPIO_INT_DISABLE;
|
|
int ret;
|
|
|
|
for (int i = 0; i < GPIO_QDEC_GPIO_NUM; i++) {
|
|
const struct gpio_dt_spec *gpio = &cfg->ab_gpio[i];
|
|
|
|
ret = gpio_pin_interrupt_configure_dt(gpio, flags);
|
|
if (ret != 0) {
|
|
LOG_ERR("Pin %d interrupt configuration failed: %d", i, ret);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool gpio_qdec_idle_polling_mode(const struct device *dev)
|
|
{
|
|
const struct gpio_qdec_config *cfg = dev->config;
|
|
|
|
if (cfg->idle_poll_time_us > 0) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static void gpio_qdec_poll_mode(const struct device *dev)
|
|
{
|
|
const struct gpio_qdec_config *cfg = dev->config;
|
|
struct gpio_qdec_data *data = dev->data;
|
|
|
|
if (!gpio_qdec_idle_polling_mode(dev)) {
|
|
gpio_qdec_irq_setup(dev, false);
|
|
}
|
|
|
|
k_timer_start(&data->sample_timer, K_NO_WAIT,
|
|
K_USEC(cfg->sample_time_us));
|
|
|
|
atomic_set(&data->polling, 1);
|
|
|
|
LOG_DBG("polling start");
|
|
}
|
|
|
|
static void gpio_qdec_idle_mode(const struct device *dev)
|
|
{
|
|
const struct gpio_qdec_config *cfg = dev->config;
|
|
struct gpio_qdec_data *data = dev->data;
|
|
|
|
if (gpio_qdec_idle_polling_mode(dev)) {
|
|
k_timer_start(&data->sample_timer, K_NO_WAIT,
|
|
K_USEC(cfg->idle_poll_time_us));
|
|
} else {
|
|
k_timer_stop(&data->sample_timer);
|
|
gpio_qdec_irq_setup(dev, true);
|
|
}
|
|
|
|
atomic_set(&data->polling, 0);
|
|
|
|
LOG_DBG("polling stop");
|
|
}
|
|
|
|
static uint8_t gpio_qdec_get_step(const struct device *dev)
|
|
{
|
|
const struct gpio_qdec_config *cfg = dev->config;
|
|
uint8_t step = 0x00;
|
|
|
|
if (gpio_qdec_idle_polling_mode(dev)) {
|
|
for (int i = 0; i < cfg->led_gpio_count; i++) {
|
|
gpio_pin_set_dt(&cfg->led_gpio[i], 1);
|
|
}
|
|
|
|
k_busy_wait(cfg->led_pre_us);
|
|
}
|
|
|
|
if (gpio_pin_get_dt(&cfg->ab_gpio[0])) {
|
|
step |= 0x01;
|
|
}
|
|
if (gpio_pin_get_dt(&cfg->ab_gpio[1])) {
|
|
step |= 0x02;
|
|
}
|
|
|
|
if (gpio_qdec_idle_polling_mode(dev)) {
|
|
for (int i = 0; i < cfg->led_gpio_count; i++) {
|
|
gpio_pin_set_dt(&cfg->led_gpio[i], 0);
|
|
}
|
|
}
|
|
|
|
return step;
|
|
}
|
|
|
|
static void gpio_qdec_sample_timer_timeout(struct k_timer *timer)
|
|
{
|
|
const struct device *dev = k_timer_user_data_get(timer);
|
|
const struct gpio_qdec_config *cfg = dev->config;
|
|
struct gpio_qdec_data *data = dev->data;
|
|
int8_t delta = 0;
|
|
unsigned int key;
|
|
uint8_t step;
|
|
|
|
#ifdef CONFIG_PM_DEVICE
|
|
if (atomic_get(&data->suspended) == 1) {
|
|
return;
|
|
}
|
|
#endif
|
|
|
|
step = gpio_qdec_get_step(dev);
|
|
|
|
if (data->prev_step == step) {
|
|
return;
|
|
}
|
|
|
|
if (gpio_qdec_idle_polling_mode(dev) &&
|
|
atomic_get(&data->polling) == 0) {
|
|
gpio_qdec_poll_mode(dev);
|
|
}
|
|
|
|
switch ((data->prev_step << 4U) | step) {
|
|
case QDEC_LL_LH:
|
|
case QDEC_LH_HH:
|
|
case QDEC_HH_HL:
|
|
case QDEC_HL_LL:
|
|
delta = 1;
|
|
break;
|
|
case QDEC_LL_HL:
|
|
case QDEC_LH_LL:
|
|
case QDEC_HH_LH:
|
|
case QDEC_HL_HH:
|
|
delta = -1;
|
|
break;
|
|
default:
|
|
LOG_WRN("%s: lost steps", dev->name);
|
|
}
|
|
|
|
data->prev_step = step;
|
|
|
|
key = irq_lock();
|
|
data->acc += delta;
|
|
irq_unlock(key);
|
|
|
|
if (abs(data->acc) >= cfg->steps_per_period) {
|
|
k_work_submit(&data->event_work);
|
|
}
|
|
|
|
k_work_reschedule(&data->idle_work, K_MSEC(cfg->idle_timeout_ms));
|
|
}
|
|
|
|
static void gpio_qdec_event_worker(struct k_work *work)
|
|
{
|
|
struct gpio_qdec_data *data = CONTAINER_OF(
|
|
work, struct gpio_qdec_data, event_work);
|
|
const struct device *dev = data->dev;
|
|
const struct gpio_qdec_config *cfg = dev->config;
|
|
unsigned int key;
|
|
int32_t acc;
|
|
|
|
key = irq_lock();
|
|
acc = data->acc / cfg->steps_per_period;
|
|
data->acc -= acc * cfg->steps_per_period;
|
|
irq_unlock(key);
|
|
|
|
if (acc != 0) {
|
|
input_report_rel(data->dev, cfg->axis, acc, true, K_FOREVER);
|
|
}
|
|
}
|
|
|
|
static void gpio_qdec_idle_worker(struct k_work *work)
|
|
{
|
|
struct k_work_delayable *dwork = k_work_delayable_from_work(work);
|
|
struct gpio_qdec_data *data = CONTAINER_OF(
|
|
dwork, struct gpio_qdec_data, idle_work);
|
|
const struct device *dev = data->dev;
|
|
|
|
gpio_qdec_idle_mode(dev);
|
|
}
|
|
|
|
static void gpio_qdec_cb(const struct device *gpio_dev, struct gpio_callback *cb,
|
|
uint32_t pins)
|
|
{
|
|
struct gpio_qdec_data *data = CONTAINER_OF(
|
|
cb, struct gpio_qdec_data, gpio_cb);
|
|
const struct device *dev = data->dev;
|
|
|
|
gpio_qdec_poll_mode(dev);
|
|
}
|
|
|
|
static int gpio_qdec_init(const struct device *dev)
|
|
{
|
|
const struct gpio_qdec_config *cfg = dev->config;
|
|
struct gpio_qdec_data *data = dev->data;
|
|
int ret;
|
|
|
|
data->dev = dev;
|
|
|
|
k_work_init(&data->event_work, gpio_qdec_event_worker);
|
|
k_work_init_delayable(&data->idle_work, gpio_qdec_idle_worker);
|
|
|
|
k_timer_init(&data->sample_timer, gpio_qdec_sample_timer_timeout, NULL);
|
|
k_timer_user_data_set(&data->sample_timer, (void *)dev);
|
|
|
|
gpio_init_callback(&data->gpio_cb, gpio_qdec_cb,
|
|
BIT(cfg->ab_gpio[0].pin) | BIT(cfg->ab_gpio[1].pin));
|
|
for (int i = 0; i < GPIO_QDEC_GPIO_NUM; i++) {
|
|
const struct gpio_dt_spec *gpio = &cfg->ab_gpio[i];
|
|
|
|
if (!gpio_is_ready_dt(gpio)) {
|
|
LOG_ERR("%s is not ready", gpio->port->name);
|
|
return -ENODEV;
|
|
}
|
|
|
|
ret = gpio_pin_configure_dt(gpio, GPIO_INPUT);
|
|
if (ret != 0) {
|
|
LOG_ERR("Pin %d configuration failed: %d", i, ret);
|
|
return ret;
|
|
}
|
|
|
|
if (gpio_qdec_idle_polling_mode(dev)) {
|
|
continue;
|
|
}
|
|
|
|
ret = gpio_add_callback_dt(gpio, &data->gpio_cb);
|
|
if (ret < 0) {
|
|
LOG_ERR("Could not set gpio callback");
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < cfg->led_gpio_count; i++) {
|
|
const struct gpio_dt_spec *gpio = &cfg->led_gpio[i];
|
|
gpio_flags_t mode;
|
|
|
|
if (!gpio_is_ready_dt(gpio)) {
|
|
LOG_ERR("%s is not ready", gpio->port->name);
|
|
return -ENODEV;
|
|
}
|
|
|
|
mode = gpio_qdec_idle_polling_mode(dev) ?
|
|
GPIO_OUTPUT_INACTIVE : GPIO_OUTPUT_ACTIVE;
|
|
|
|
ret = gpio_pin_configure_dt(gpio, mode);
|
|
if (ret != 0) {
|
|
LOG_ERR("Pin %d configuration failed: %d", i, ret);
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
data->prev_step = gpio_qdec_get_step(dev);
|
|
|
|
gpio_qdec_idle_mode(dev);
|
|
|
|
ret = pm_device_runtime_enable(dev);
|
|
if (ret < 0) {
|
|
LOG_ERR("Failed to enable runtime power management");
|
|
return ret;
|
|
}
|
|
|
|
LOG_DBG("Device %s initialized", dev->name);
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_PM_DEVICE
|
|
static void gpio_qdec_pin_suspend(const struct device *dev, bool suspend)
|
|
{
|
|
const struct gpio_qdec_config *cfg = dev->config;
|
|
gpio_flags_t mode = suspend ? GPIO_DISCONNECTED : GPIO_INPUT;
|
|
int ret;
|
|
|
|
for (int i = 0; i < GPIO_QDEC_GPIO_NUM; i++) {
|
|
const struct gpio_dt_spec *gpio = &cfg->ab_gpio[i];
|
|
|
|
ret = gpio_pin_configure_dt(gpio, mode);
|
|
if (ret != 0) {
|
|
LOG_ERR("Pin %d configuration failed: %d", i, ret);
|
|
return;
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < cfg->led_gpio_count; i++) {
|
|
if (suspend) {
|
|
gpio_pin_set_dt(&cfg->led_gpio[i], 0);
|
|
} else if (!gpio_qdec_idle_polling_mode(dev)) {
|
|
gpio_pin_set_dt(&cfg->led_gpio[i], 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
static int gpio_qdec_pm_action(const struct device *dev,
|
|
enum pm_device_action action)
|
|
{
|
|
struct gpio_qdec_data *data = dev->data;
|
|
|
|
switch (action) {
|
|
case PM_DEVICE_ACTION_SUSPEND:
|
|
struct k_work_sync sync;
|
|
|
|
atomic_set(&data->suspended, 1);
|
|
|
|
k_work_cancel_delayable_sync(&data->idle_work, &sync);
|
|
|
|
if (!gpio_qdec_idle_polling_mode(dev)) {
|
|
gpio_qdec_irq_setup(dev, false);
|
|
}
|
|
|
|
k_timer_stop(&data->sample_timer);
|
|
|
|
gpio_qdec_pin_suspend(dev, true);
|
|
|
|
break;
|
|
case PM_DEVICE_ACTION_RESUME:
|
|
atomic_set(&data->suspended, 0);
|
|
|
|
gpio_qdec_pin_suspend(dev, false);
|
|
|
|
data->prev_step = gpio_qdec_get_step(dev);
|
|
data->acc = 0;
|
|
|
|
gpio_qdec_idle_mode(dev);
|
|
|
|
break;
|
|
default:
|
|
return -ENOTSUP;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|
|
#define QDEC_GPIO_INIT(n) \
|
|
BUILD_ASSERT(DT_INST_PROP_LEN(n, gpios) == GPIO_QDEC_GPIO_NUM, \
|
|
"input_gpio_qdec: gpios must have exactly two entries"); \
|
|
\
|
|
BUILD_ASSERT(!(DT_INST_NODE_HAS_PROP(n, led_gpios) && \
|
|
DT_INST_NODE_HAS_PROP(n, idle_poll_time_us)) || \
|
|
DT_INST_NODE_HAS_PROP(n, led_pre_us), \
|
|
"led-pre-us must be specified when setting led-gpios and " \
|
|
"idle-poll-time-us"); \
|
|
\
|
|
IF_ENABLED(DT_INST_NODE_HAS_PROP(n, led_gpios), ( \
|
|
static const struct gpio_dt_spec gpio_qdec_led_gpio_##n[] = { \
|
|
DT_INST_FOREACH_PROP_ELEM_SEP(n, led_gpios, \
|
|
GPIO_DT_SPEC_GET_BY_IDX, (,)) \
|
|
}; \
|
|
)) \
|
|
\
|
|
static const struct gpio_qdec_config gpio_qdec_cfg_##n = { \
|
|
.ab_gpio = { \
|
|
GPIO_DT_SPEC_INST_GET_BY_IDX(n, gpios, 0), \
|
|
GPIO_DT_SPEC_INST_GET_BY_IDX(n, gpios, 1), \
|
|
}, \
|
|
IF_ENABLED(DT_INST_NODE_HAS_PROP(n, led_gpios), ( \
|
|
.led_gpio = gpio_qdec_led_gpio_##n, \
|
|
.led_gpio_count = ARRAY_SIZE(gpio_qdec_led_gpio_##n), \
|
|
.led_pre_us = DT_INST_PROP_OR(n, led_pre_us, 0), \
|
|
)) \
|
|
.sample_time_us = DT_INST_PROP(n, sample_time_us), \
|
|
.idle_poll_time_us = DT_INST_PROP_OR(n, idle_poll_time_us, 0), \
|
|
.idle_timeout_ms = DT_INST_PROP(n, idle_timeout_ms), \
|
|
.steps_per_period = DT_INST_PROP(n, steps_per_period), \
|
|
.axis = DT_INST_PROP(n, zephyr_axis), \
|
|
}; \
|
|
\
|
|
static struct gpio_qdec_data gpio_qdec_data_##n; \
|
|
\
|
|
PM_DEVICE_DT_INST_DEFINE(n, gpio_qdec_pm_action); \
|
|
\
|
|
DEVICE_DT_INST_DEFINE(n, gpio_qdec_init, PM_DEVICE_DT_INST_GET(n), \
|
|
&gpio_qdec_data_##n, \
|
|
&gpio_qdec_cfg_##n, \
|
|
POST_KERNEL, CONFIG_INPUT_INIT_PRIORITY, \
|
|
NULL);
|
|
|
|
DT_INST_FOREACH_STATUS_OKAY(QDEC_GPIO_INIT)
|