zara
/
zephyr
mirror of https://github.com/zephyrproject-rtos/zephyr
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Primary Git Repository for the Zephyr Project. Zephyr is a new generation, scalable, optimized, secure RTOS for multiple hardware architectures.
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.
118168 Commits
82 Branches
204 Tags
1.7 GiB
 
 
 
 
 
 
Tree: a93a80be82
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a93a80be82'
${ noResults }
zephyr/drivers/gpio/gpio_aw9523b.c

505 lines
15 KiB
Raw Blame History

/*
* Copyright (c) 2024 TOKITA Hiroshi
*
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT awinic_aw9523b_gpio
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio.h>
#include <zephyr/drivers/gpio/gpio_utils.h>
#include <zephyr/drivers/i2c.h>
#include <zephyr/drivers/mfd/aw9523b.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/ring_buffer.h>
#include <zephyr/logging/log.h>
LOG_MODULE_REGISTER(gpio_aw9523b, CONFIG_GPIO_LOG_LEVEL);
#define AW9523B_GPOMD BIT(4)
#define AW9523B_RESET_PULSE_WIDTH 20
#define AW9523B_REG_CONFIG(n) (AW9523B_REG_CONFIG0 + n)
#define AW9523B_REG_INT(n) (AW9523B_REG_INT0 + n)
#define AW9523B_REG_OUTPUT(n) (AW9523B_REG_OUTPUT0 + n)
enum read_write_toggle_t {
READ,
WRITE,
TOGGLE,
};
struct gpio_aw9523b_config {
struct gpio_driver_config common;
const struct device *mfd_dev;
struct i2c_dt_spec i2c;
bool port0_push_pull;
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(reset_gpios)
struct gpio_dt_spec reset_gpio;
#endif
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(int_gpios)
struct gpio_dt_spec int_gpio;
gpio_callback_handler_t int_cb;
#endif
};
struct gpio_aw9523b_data {
struct gpio_driver_data common;
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(int_gpios)
const struct device *dev;
sys_slist_t callbacks;
struct gpio_callback gpio_callback;
struct k_work intr_worker;
gpio_port_value_t prev_value;
gpio_port_pins_t rising_event_pins;
gpio_port_pins_t falling_event_pins;
#endif
};
static int gpio_aw9523b_pin_configure(const struct device *dev, gpio_pin_t pin, gpio_flags_t flags)
{
const struct gpio_aw9523b_config *const config = dev->config;
const uint8_t port = (pin < 8) ? 0 : 1;
const uint8_t mask = BIT(pin % 8);
const uint8_t input_en = (flags & GPIO_INPUT) ? mask : 0x00;
const uint8_t out_high = (flags & GPIO_OUTPUT_INIT_HIGH) ? mask : 0x00;
int err;
/* Can't do I2C operations from an ISR */
if (k_is_in_isr()) {
return -EWOULDBLOCK;
}
/* Either INPUT or OUTPUT must be set */
if ((!(flags & GPIO_INPUT) && !(flags & GPIO_OUTPUT)) ||
((flags & GPIO_INPUT) && (flags & GPIO_OUTPUT))) {
return -ENOTSUP;
}
/* Open-drain support is per port, not per pin.
* So can't really support the API as-is.
*/
if (port == 0 && !config->port0_push_pull) {
if (!((flags & GPIO_SINGLE_ENDED) && (flags & GPIO_LINE_OPEN_DRAIN))) {
return -ENOTSUP;
}
} else {
if (flags & GPIO_SINGLE_ENDED) {
return -ENOTSUP;
}
}
if ((flags & GPIO_INPUT) && ((flags & GPIO_PULL_UP) || (flags & GPIO_PULL_DOWN))) {
return -ENOTSUP;
}
k_sem_take(aw9523b_get_lock(config->mfd_dev), K_FOREVER);
err = i2c_reg_update_byte_dt(&config->i2c, AW9523B_REG_CONFIG(port), mask, input_en);
if (err) {
LOG_ERR("%s: Failed to set pin%d direction (%d)", dev->name, pin, err);
goto on_error;
}
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(int_gpios)
if (config->int_gpio.port) {
if (input_en) {
struct gpio_aw9523b_data *const data = dev->data;
uint8_t buf[2];
/* Read initial pin state */
err = i2c_burst_read_dt(&config->i2c, AW9523B_REG_INPUT0, buf, sizeof(buf));
if (err) {
LOG_ERR("%s: Read initial pin state failed (%d)", dev->name, err);
goto on_error;
}
WRITE_BIT(data->prev_value, pin, sys_get_le16(buf) & BIT(pin));
} else {
struct gpio_aw9523b_data *const data = dev->data;
WRITE_BIT(data->falling_event_pins, pin, 0);
WRITE_BIT(data->rising_event_pins, pin, 0);
}
}
#endif
err = i2c_reg_update_byte_dt(&config->i2c, AW9523B_REG_OUTPUT(port), mask, out_high);
if (err) {
LOG_ERR("%s: Failed to set initial pin state (%d)", dev->name, err);
return err;
}
on_error:
k_sem_give(aw9523b_get_lock(config->mfd_dev));
return err;
}
/**
* Common implementation of Read, Write, and Toggle
*
* @param[in] dev Specify device instance.
* @param[in] mask Register mask to select pins to operate.
* @param[in,out] value When mode is READ, this param is pointer to result value storing region.
* When mode is WRITE, this param is used as input value.
* When mode is TOGGLE, this param will ignored.
* @param[in] mode Choose mode from READ, WRITE or TOGGLE.
*/
static int gpio_aw9523b_port_read_write_toggle(const struct device *dev, gpio_port_pins_t mask,
gpio_port_value_t *value,
enum read_write_toggle_t mode)
{
const struct gpio_aw9523b_config *const config = dev->config;
uint8_t buf[2];
gpio_port_value_t old_value;
gpio_port_value_t new_value;
int err;
/* Can't do I2C bus operations from an ISR */
if (k_is_in_isr()) {
return -EWOULDBLOCK;
}
k_sem_take(aw9523b_get_lock(config->mfd_dev), K_FOREVER);
/*
* As with interrupts, the INPUT values are read for each address
* to keep the internal state correct.
*/
err = i2c_burst_read_dt(&config->i2c, AW9523B_REG_INPUT0, &buf[0], 1);
if (err) {
LOG_ERR("%s: Failed to read port0 status (%d)", dev->name, err);
goto end;
}
err = i2c_burst_read_dt(&config->i2c, AW9523B_REG_INPUT1, &buf[1], 1);
if (err) {
LOG_ERR("%s: Failed to read port1 status (%d)", dev->name, err);
goto end;
}
if (mode == READ) {
goto end;
}
old_value = sys_get_le16(buf);
if (mode == WRITE) {
new_value = (old_value & ~mask) | (*value & mask);
} else {
new_value = (old_value & ~mask) | (~old_value & mask);
}
if (new_value == old_value) {
goto end;
}
*(uint16_t *)buf = sys_get_le16((uint8_t *)&new_value);
err = i2c_burst_write_dt(&config->i2c, AW9523B_REG_OUTPUT0, buf, sizeof(buf));
if (err) {
LOG_ERR("%s: Failed to set port (%d)", dev->name, err);
}
end:
k_sem_give(aw9523b_get_lock(config->mfd_dev));
if (err == 0 && mode == READ) {
*value = sys_get_le16(buf);
}
return err;
}
static int gpio_aw9523b_port_get_raw(const struct device *dev, gpio_port_value_t *value)
{
return gpio_aw9523b_port_read_write_toggle(dev, UINT16_MAX, value, READ);
}
static int gpio_aw9523b_port_set_masked_raw(const struct device *dev, gpio_port_pins_t mask,
gpio_port_value_t value)
{
return gpio_aw9523b_port_read_write_toggle(dev, mask, &value, WRITE);
}
static int gpio_aw9523b_port_set_bits_raw(const struct device *dev, gpio_port_pins_t pins)
{
return gpio_aw9523b_port_read_write_toggle(dev, pins, &pins, WRITE);
}
static int gpio_aw9523b_port_clear_bits_raw(const struct device *dev, gpio_port_pins_t pins)
{
const gpio_port_value_t zero = 0;
/* If WRITE is specified, this pointer is used for reading only. It can cast. */
return gpio_aw9523b_port_read_write_toggle(dev, pins, (gpio_port_value_t *)&zero, WRITE);
}
static int gpio_aw9523b_port_toggle_bits(const struct device *dev, gpio_port_pins_t pins)
{
return gpio_aw9523b_port_read_write_toggle(dev, pins, NULL, TOGGLE);
}
static __maybe_unused void gpio_aw9523b_interrupt_worker(struct k_work *work)
{
struct gpio_aw9523b_data *const data =
CONTAINER_OF(work, struct gpio_aw9523b_data, intr_worker);
const struct gpio_aw9523b_config *const config = data->dev->config;
gpio_port_value_t value, rising, falling;
uint8_t buf[2];
int err;
/*
* We need to read INPUT0 to deassert INTN when that is asserted by
* pin0-7 interruption, and same also INPUT1 for pin8-15.
* It cannot deassert by burst-read.
*/
err = i2c_burst_read_dt(&config->i2c, AW9523B_REG_INPUT0, &buf[0], 1);
if (err) {
LOG_ERR("%s: Failed to read INPUT0 %d", data->dev->name, err);
}
err = i2c_burst_read_dt(&config->i2c, AW9523B_REG_INPUT1, &buf[1], 1);
if (err) {
LOG_ERR("%s: Failed to read INPUT1 %d", data->dev->name, err);
}
value = sys_get_le16(buf);
rising = (value ^ data->prev_value) & (value & data->rising_event_pins);
falling = (value ^ data->prev_value) & (~value & data->falling_event_pins);
data->prev_value = value;
gpio_fire_callbacks(&data->callbacks, data->dev, rising | falling);
}
static __maybe_unused int gpio_aw9523b_pin_interrupt_configure(const struct device *dev,
gpio_pin_t pin,
enum gpio_int_mode mode,
enum gpio_int_trig trig)
{
const struct gpio_aw9523b_config *const config = dev->config;
struct gpio_aw9523b_data *const data = dev->data;
const uint8_t port = (pin < 8) ? 0 : 1;
const uint8_t mask = BIT(port ? pin - 8 : pin);
const uint8_t n_int_en = (mode & GPIO_INT_MODE_EDGE) ? 0x00 : 0xFF;
uint8_t buf[2];
int err;
/* Can't do I2C bus operations from an ISR */
if (k_is_in_isr()) {
return -EWOULDBLOCK;
}
if (mode == GPIO_INT_MODE_LEVEL) {
return -ENOTSUP;
}
if (data->common.invert & BIT(pin)) {
WRITE_BIT(data->falling_event_pins, pin, trig & GPIO_INT_HIGH_1);
WRITE_BIT(data->rising_event_pins, pin, trig & GPIO_INT_LOW_0);
} else {
WRITE_BIT(data->falling_event_pins, pin, trig & GPIO_INT_LOW_0);
WRITE_BIT(data->rising_event_pins, pin, trig & GPIO_INT_HIGH_1);
}
k_sem_take(aw9523b_get_lock(config->mfd_dev), K_FOREVER);
err = i2c_reg_update_byte_dt(&config->i2c, AW9523B_REG_INT(port), mask, n_int_en);
if (err) {
LOG_ERR("%s: Failed to configure pin interruption (%d)", dev->name, err);
goto end;
}
if (!n_int_en) {
/* Read initial pin state */
err = i2c_burst_read_dt(&config->i2c, AW9523B_REG_INPUT0, buf, sizeof(buf));
if (err) {
LOG_ERR("%s: Failed to read initial pin state (%d)", dev->name, err);
goto end;
}
WRITE_BIT(data->prev_value, pin, sys_get_le16(buf) & BIT(pin));
} else {
WRITE_BIT(data->falling_event_pins, pin, 0);
WRITE_BIT(data->rising_event_pins, pin, 0);
}
end:
k_sem_give(aw9523b_get_lock(config->mfd_dev));
return err;
}
static __maybe_unused int gpio_aw9523b_manage_callback(const struct device *dev,
struct gpio_callback *callback, bool set)
{
const struct gpio_aw9523b_config *const config = dev->config;
struct gpio_aw9523b_data *const data = dev->data;
int err;
k_sem_take(aw9523b_get_lock(config->mfd_dev), K_FOREVER);
err = gpio_manage_callback(&data->callbacks, callback, set);
if (err) {
LOG_ERR("%s: gpio_manage_callback failed (%d)", dev->name, err);
}
k_sem_give(aw9523b_get_lock(config->mfd_dev));
return err;
}
static __maybe_unused void gpio_aw9523b_int_handler(const struct device *gpio_dev,
struct gpio_callback *cb, uint32_t pins)
{
struct gpio_aw9523b_data *data = CONTAINER_OF(cb, struct gpio_aw9523b_data, gpio_callback);
k_work_submit(&data->intr_worker);
}
static DEVICE_API(gpio, gpio_aw9523b_api) = {
.pin_configure = gpio_aw9523b_pin_configure,
.port_get_raw = gpio_aw9523b_port_get_raw,
.port_set_masked_raw = gpio_aw9523b_port_set_masked_raw,
.port_set_bits_raw = gpio_aw9523b_port_set_bits_raw,
.port_clear_bits_raw = gpio_aw9523b_port_clear_bits_raw,
.port_toggle_bits = gpio_aw9523b_port_toggle_bits,
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(int_gpios)
.pin_interrupt_configure = gpio_aw9523b_pin_interrupt_configure,
.manage_callback = gpio_aw9523b_manage_callback,
#endif
};
static int gpio_aw9523b_init(const struct device *dev)
{
const struct gpio_aw9523b_config *const config = dev->config;
const uint8_t int_init_data[] = {0xFF, 0xFF};
uint8_t buf[2];
int err;
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(int_gpios)
struct gpio_aw9523b_data *const data = dev->data;
if (!config->int_gpio.port) {
goto end_init_int_gpio;
}
/* Store self-reference for interrupt handling */
data->dev = dev;
/* Prepare interrupt worker */
k_work_init(&data->intr_worker, gpio_aw9523b_interrupt_worker);
if (!gpio_is_ready_dt(&config->int_gpio)) {
LOG_ERR("%s: Interrupt GPIO not ready", dev->name);
return -ENODEV;
}
err = gpio_pin_configure_dt(&config->int_gpio, GPIO_INPUT);
if (err) {
LOG_ERR("%s: Failed to configure interrupt pin %d (%d)", dev->name,
config->int_gpio.pin, err);
return err;
}
err = gpio_pin_interrupt_configure_dt(&config->int_gpio, GPIO_INT_EDGE_TO_ACTIVE);
if (err) {
LOG_ERR("%s: Failed to configure interrupt %d (%d)", dev->name,
config->int_gpio.pin, err);
return err;
}
gpio_init_callback(&data->gpio_callback, config->int_cb, BIT(config->int_gpio.pin));
err = gpio_add_callback(config->int_gpio.port, &data->gpio_callback);
if (err) {
LOG_ERR("%s: Failed to add interrupt callback for pin %d (%d)", dev->name,
config->int_gpio.pin, err);
return err;
}
end_init_int_gpio:
#endif
#if DT_ANY_INST_HAS_PROP_STATUS_OKAY(reset_gpios)
if (!config->reset_gpio.port) {
goto end_hw_reset;
}
if (!gpio_is_ready_dt(&config->reset_gpio)) {
LOG_ERR("%s: Reset GPIO not ready", dev->name);
return -ENODEV;
}
err = gpio_pin_configure_dt(&config->reset_gpio, GPIO_OUTPUT_ACTIVE);
if (err) {
LOG_ERR("%s: Failed to configure reset pin %d (%d)", dev->name,
config->reset_gpio.pin, err);
return err;
}
k_busy_wait(AW9523B_RESET_PULSE_WIDTH);
err = gpio_pin_set_dt(&config->reset_gpio, 0);
if (err) {
LOG_ERR("%s: Failed to set 0 reset pin %d (%d)", dev->name, config->reset_gpio.pin,
err);
return err;
}
end_hw_reset:
#endif
if (!device_is_ready(config->i2c.bus)) {
return -ENODEV;
}
k_sem_init(aw9523b_get_lock(config->mfd_dev), 1, 1);
/* Software reset */
err = i2c_reg_read_byte_dt(&config->i2c, AW9523B_REG_SW_RSTN, buf);
if (err) {
LOG_ERR("%s: Failed to software reset (%d)", dev->name, err);
return err;
}
/* Disabling all interrupts */
err = i2c_burst_write_dt(&config->i2c, AW9523B_REG_INT0, int_init_data, sizeof(buf));
if (err) {
LOG_ERR("%s: Failed to disable all interrupts (%d)", dev->name, err);
return err;
}
if (!config->port0_push_pull) {
/* Configure port0 to push-pull mode */
err = i2c_reg_update_byte_dt(&config->i2c, AW9523B_REG_CTL, AW9523B_GPOMD, 0xFF);
if (err) {
LOG_ERR("%s: Failed to configure port0 to push-pull (%d)", dev->name, err);
return err;
}
}
return 0;
}
#define GPIO_AW9523B_DEFINE(inst) \
static struct gpio_aw9523b_data gpio_aw9523b_data##inst; \
\
static const struct gpio_aw9523b_config gpio_aw9523b_config##inst = { \
.common = { \
.port_pin_mask = GPIO_PORT_PIN_MASK_FROM_DT_INST(inst), \
}, \
.mfd_dev = DEVICE_DT_GET(DT_INST_PARENT(inst)), \
.i2c = I2C_DT_SPEC_GET(DT_INST_PARENT(inst)), \
.port0_push_pull = DT_INST_PROP_OR(inst, port0_push_pull, false), \
IF_ENABLED(DT_INST_PROP_HAS_IDX(inst, int_gpios, 0), ( \
.int_gpio = GPIO_DT_SPEC_INST_GET(inst, int_gpios), \
.int_cb = gpio_aw9523b_int_handler, \
)) \
IF_ENABLED(DT_INST_PROP_HAS_IDX(inst, reset_gpios, 0), ( \
.reset_gpio = GPIO_DT_SPEC_INST_GET(inst, reset_gpios), \
)) \
}; \
\
DEVICE_DT_INST_DEFINE(inst, gpio_aw9523b_init, NULL, &gpio_aw9523b_data##inst, \
&gpio_aw9523b_config##inst, POST_KERNEL, \
CONFIG_MFD_INIT_PRIORITY, &gpio_aw9523b_api);
DT_INST_FOREACH_STATUS_OKAY(GPIO_AW9523B_DEFINE)