blob: 806ec422c95d86447e643b3e67ad89405c7710b3 [file] [log] [blame]
/* Copyright (c) 2023 Intel Corporation.
*
* SPDX-License-Identifier: Apache-2.0
*/
#define DT_DRV_COMPAT intel_sedi_gpio
#include "sedi_driver_gpio.h"
#include <zephyr/drivers/gpio.h>
#include <zephyr/kernel.h>
#include <zephyr/drivers/gpio/gpio_utils.h>
#include <zephyr/pm/device.h>
struct gpio_sedi_config {
/* gpio_driver_data needs to be first */
struct gpio_driver_config common;
sedi_gpio_t device;
uint32_t pin_nums;
void (*irq_config)(void);
DEVICE_MMIO_ROM;
};
struct gpio_sedi_data {
/* gpio_driver_data needs to be first */
struct gpio_driver_config common;
sys_slist_t callbacks;
DEVICE_MMIO_RAM;
};
static int gpio_sedi_init(const struct device *dev);
#ifdef CONFIG_PM_DEVICE
static int gpio_sedi_suspend_device(const struct device *dev)
{
const struct gpio_sedi_config *config = dev->config;
sedi_gpio_t gpio_dev = config->device;
int ret;
if (pm_device_is_busy(dev)) {
return -EBUSY;
}
ret = sedi_gpio_set_power(gpio_dev, SEDI_POWER_SUSPEND);
if (ret != SEDI_DRIVER_OK) {
return -EIO;
}
return 0;
}
static int gpio_sedi_resume_device_from_suspend(const struct device *dev)
{
const struct gpio_sedi_config *config = dev->config;
sedi_gpio_t gpio_dev = config->device;
int ret;
ret = sedi_gpio_set_power(gpio_dev, SEDI_POWER_FULL);
if (ret != SEDI_DRIVER_OK) {
return -EIO;
}
return 0;
}
static int gpio_sedi_pm_action(const struct device *dev,
enum pm_device_action action)
{
int ret = 0;
switch (action) {
case PM_DEVICE_ACTION_SUSPEND:
ret = gpio_sedi_suspend_device(dev);
break;
case PM_DEVICE_ACTION_RESUME:
ret = gpio_sedi_resume_device_from_suspend(dev);
break;
default:
ret = -ENOTSUP;
}
return ret;
}
#endif /* CONFIG_PM_DEVICE */
static void gpio_sedi_callback(const uint32_t pin_mask,
const sedi_gpio_port_t port,
void *param)
{
ARG_UNUSED(port);
struct device *dev = (struct device *)param;
struct gpio_sedi_data *data =
(struct gpio_sedi_data *)(dev->data);
/* call the callbacks */
gpio_fire_callbacks(&data->callbacks, dev, pin_mask);
}
static void gpio_sedi_write_raw(const struct device *dev,
uint32_t pins,
bool is_clear)
{
uint8_t i;
const struct gpio_sedi_config *config = dev->config;
sedi_gpio_t gpio_dev = config->device;
sedi_gpio_pin_state_t val;
if (is_clear) {
val = SEDI_GPIO_STATE_LOW;
} else {
val = SEDI_GPIO_STATE_HIGH;
}
for (i = 0; i < config->pin_nums; i++) {
if (pins & 0x1) {
sedi_gpio_write_pin(gpio_dev, i, val);
}
pins >>= 1;
if (pins == 0) {
break;
}
}
}
static int gpio_sedi_configure(const struct device *dev, gpio_pin_t pin,
gpio_flags_t flags)
{
const struct gpio_sedi_config *config = dev->config;
sedi_gpio_t gpio_dev = config->device;
sedi_gpio_pin_config_t pin_config = { 0 };
if ((flags & GPIO_OUTPUT) && (flags & GPIO_INPUT)) {
/* Pin cannot be configured as input and output */
return -ENOTSUP;
} else if (!(flags & (GPIO_INPUT | GPIO_OUTPUT))) {
/* Pin has to be configured as input or output */
return -ENOTSUP;
}
pin_config.enable_interrupt = false;
/* Map direction */
if (flags & GPIO_OUTPUT) {
pin_config.direction = SEDI_GPIO_DIR_MODE_OUTPUT;
sedi_gpio_config_pin(gpio_dev, pin, pin_config);
/* Set start state */
if ((flags & GPIO_OUTPUT_INIT_HIGH) != 0) {
sedi_gpio_write_pin(gpio_dev, pin, 1);
} else if ((flags & GPIO_OUTPUT_INIT_LOW) != 0) {
sedi_gpio_write_pin(gpio_dev, pin, 0);
}
} else {
pin_config.direction = SEDI_GPIO_DIR_MODE_INPUT;
sedi_gpio_config_pin(gpio_dev, pin, pin_config);
}
return 0;
}
static int gpio_sedi_get_raw(const struct device *dev, uint32_t *value)
{
const struct gpio_sedi_config *config = dev->config;
sedi_gpio_t gpio_dev = config->device;
*value = sedi_gpio_read_pin_32bits(gpio_dev, 0);
return 0;
}
static int gpio_sedi_set_masked_raw(const struct device *dev,
uint32_t mask,
uint32_t value)
{
gpio_sedi_write_raw(dev, (mask & value), false);
return 0;
}
static int gpio_sedi_set_bits_raw(const struct device *dev, uint32_t pins)
{
gpio_sedi_write_raw(dev, pins, false);
return 0;
}
static int gpio_sedi_clear_bits_raw(const struct device *dev, uint32_t pins)
{
gpio_sedi_write_raw(dev, pins, true);
return 0;
}
static int gpio_sedi_toggle_bits(const struct device *dev, uint32_t pins)
{
const struct gpio_sedi_config *config = dev->config;
sedi_gpio_t gpio_dev = config->device;
uint8_t i;
for (i = 0; i < config->pin_nums; i++) {
if (pins & 0x1) {
sedi_gpio_toggle_pin(gpio_dev, i);
}
pins >>= 1;
if (pins == 0) {
break;
}
}
return 0;
}
static int gpio_sedi_interrupt_configure(const struct device *dev,
gpio_pin_t pin,
enum gpio_int_mode mode,
enum gpio_int_trig trig)
{
const struct gpio_sedi_config *config = dev->config;
sedi_gpio_t gpio_dev = config->device;
sedi_gpio_pin_config_t pin_config = { 0 };
/* Not support level trigger */
if (mode == GPIO_INT_MODE_LEVEL) {
return -EINVAL;
}
/* Only input needs interrupt enabled */
pin_config.direction = SEDI_GPIO_DIR_MODE_INPUT;
pin_config.enable_wakeup = true;
if (mode == GPIO_INT_MODE_DISABLED) {
pin_config.enable_interrupt = false;
} else {
pin_config.enable_interrupt = true;
switch (trig) {
case GPIO_INT_TRIG_LOW:
pin_config.interrupt_mode =
SEDI_GPIO_INT_MODE_FALLING_EDGE;
break;
case GPIO_INT_TRIG_HIGH:
pin_config.interrupt_mode =
SEDI_GPIO_INT_MODE_RISING_EDGE;
break;
case GPIO_INT_TRIG_BOTH:
pin_config.interrupt_mode =
SEDI_GPIO_INT_MODE_BOTH_EDGE;
break;
default:
return -EINVAL;
}
}
/* Configure interrupt mode */
sedi_gpio_config_pin(gpio_dev, pin, pin_config);
return 0;
}
static int gpio_sedi_manage_callback(const struct device *dev,
struct gpio_callback *callback,
bool set)
{
struct gpio_sedi_data *data = dev->data;
gpio_manage_callback(&(data->callbacks), callback, set);
return 0;
}
static uint32_t gpio_sedi_get_pending(const struct device *dev)
{
const struct gpio_sedi_config *config = dev->config;
sedi_gpio_t gpio_dev = config->device;
return sedi_gpio_get_gisr(gpio_dev, 0);
}
static const struct gpio_driver_api gpio_sedi_driver_api = {
.pin_configure = gpio_sedi_configure,
.port_get_raw = gpio_sedi_get_raw,
.port_set_masked_raw = gpio_sedi_set_masked_raw,
.port_set_bits_raw = gpio_sedi_set_bits_raw,
.port_clear_bits_raw = gpio_sedi_clear_bits_raw,
.port_toggle_bits = gpio_sedi_toggle_bits,
.pin_interrupt_configure = gpio_sedi_interrupt_configure,
.manage_callback = gpio_sedi_manage_callback,
.get_pending_int = gpio_sedi_get_pending
};
extern void gpio_isr(IN sedi_gpio_t gpio_device);
static int gpio_sedi_init(const struct device *dev)
{
int ret;
const struct gpio_sedi_config *config = dev->config;
sedi_gpio_t gpio_dev = config->device;
DEVICE_MMIO_MAP(dev, K_MEM_CACHE_NONE);
/* Call sedi gpio init */
ret = sedi_gpio_init(gpio_dev, gpio_sedi_callback, (void *)dev);
if (ret != 0) {
return ret;
}
sedi_gpio_set_power(gpio_dev, SEDI_POWER_FULL);
config->irq_config();
return 0;
}
#define GPIO_SEDI_IRQ_FLAGS_SENSE0(n) 0
#define GPIO_SEDI_IRQ_FLAGS_SENSE1(n) DT_INST_IRQ(n, sense)
#define GPIO_SEDI_IRQ_FLAGS(n) \
_CONCAT(GPIO_SEDI_IRQ_FLAGS_SENSE, DT_INST_IRQ_HAS_CELL(n, sense))(n)
#define GPIO_DEVICE_INIT_SEDI(n) \
static struct gpio_sedi_data gpio##n##_data; \
static void gpio_sedi_irq_config_##n(void) \
{ \
IRQ_CONNECT(DT_INST_IRQN(n), DT_INST_IRQ(n, priority), \
gpio_isr, n, \
GPIO_SEDI_IRQ_FLAGS(n)); \
irq_enable(DT_INST_IRQN(n)); \
}; \
static const struct gpio_sedi_config gpio##n##_config = { \
DEVICE_MMIO_ROM_INIT(DT_DRV_INST(n)), \
.common = { 0xFFFFFFFF }, \
.device = DT_INST_PROP(n, peripheral_id), \
.pin_nums = DT_INST_PROP(n, ngpios), \
.irq_config = gpio_sedi_irq_config_##n, \
}; \
PM_DEVICE_DEFINE(gpio_##n, gpio_sedi_pm_action); \
DEVICE_DT_INST_DEFINE(n, \
&gpio_sedi_init, \
PM_DEVICE_GET(gpio_##n), \
&gpio##n##_data, \
&gpio##n##_config, \
POST_KERNEL, \
CONFIG_GPIO_INIT_PRIORITY, \
&gpio_sedi_driver_api);
DT_INST_FOREACH_STATUS_OKAY(GPIO_DEVICE_INIT_SEDI)