| /* |
| * Copyright (c) 2024, STRIM, ALC |
| * |
| * SPDX-License-Identifier: Apache-2.0 |
| */ |
| |
| #define DT_DRV_COMPAT nxp_flexio |
| |
| #include <zephyr/kernel.h> |
| #include <zephyr/device.h> |
| #include <zephyr/logging/log.h> |
| #include <zephyr/drivers/clock_control.h> |
| #include <zephyr/drivers/misc/nxp_flexio/nxp_flexio.h> |
| #include <fsl_flexio.h> |
| |
| LOG_MODULE_REGISTER(mcux_flexio, CONFIG_MCUX_FLEXIO_LOG_LEVEL); |
| |
| |
| struct mcux_flexio_config { |
| FLEXIO_Type *base; |
| const struct device *clock_dev; |
| clock_control_subsys_t clock_subsys; |
| void (*irq_config_func)(const struct device *dev); |
| void (*irq_enable_func)(void); |
| void (*irq_disable_func)(void); |
| }; |
| |
| typedef const struct nxp_flexio_child *nxp_flexio_map_child_t; |
| |
| struct mcux_flexio_data { |
| struct k_mutex lock; |
| uint32_t shifter_indexes_used; |
| uint32_t timer_indexes_used; |
| nxp_flexio_map_child_t *map_shifter_child; |
| nxp_flexio_map_child_t *map_timer_child; |
| uint32_t map_shifter_child_count; |
| uint32_t map_timer_child_count; |
| }; |
| |
| |
| static int mcux_flexio_child_take_shifter_idx(const struct device *dev) |
| { |
| struct mcux_flexio_data *data = dev->data; |
| |
| for (uint32_t i = 0; i < data->map_shifter_child_count; i++) { |
| if ((data->shifter_indexes_used & BIT(i)) == 0) { |
| WRITE_BIT(data->shifter_indexes_used, i, 1); |
| return i; |
| } |
| } |
| |
| return -ENOBUFS; |
| } |
| |
| static int mcux_flexio_child_take_timer_idx(const struct device *dev) |
| { |
| struct mcux_flexio_data *data = dev->data; |
| |
| for (uint32_t i = 0; i < data->map_timer_child_count; i++) { |
| if ((data->timer_indexes_used & BIT(i)) == 0) { |
| WRITE_BIT(data->timer_indexes_used, i, 1); |
| return i; |
| } |
| } |
| |
| return -ENOBUFS; |
| } |
| |
| static void mcux_flexio_isr(const struct device *dev) |
| { |
| const struct mcux_flexio_config *config = dev->config; |
| struct mcux_flexio_data *data = dev->data; |
| FLEXIO_Type *base = config->base; |
| |
| nxp_flexio_map_child_t *map_shifter_child = data->map_shifter_child; |
| uint32_t map_shifter_child_count = data->map_shifter_child_count; |
| uint32_t shifter_status_flag = FLEXIO_GetShifterStatusFlags(base); |
| uint32_t shifter_error_flag = FLEXIO_GetShifterErrorFlags(base); |
| |
| if (shifter_status_flag || shifter_error_flag) { |
| for (uint32_t idx = 0; idx < map_shifter_child_count; idx++) { |
| if (((shifter_status_flag | shifter_error_flag) & BIT(idx)) != 0) { |
| const struct nxp_flexio_child *child = map_shifter_child[idx]; |
| |
| if (child != NULL) { |
| nxp_flexio_child_isr_t isr = child->isr; |
| |
| if (isr != NULL) { |
| isr(child->user_data); |
| } |
| } |
| } |
| } |
| } |
| |
| nxp_flexio_map_child_t *map_timer_child = data->map_timer_child; |
| uint32_t map_timer_child_count = data->map_timer_child_count; |
| uint32_t timer_status_flag = FLEXIO_GetTimerStatusFlags(base); |
| |
| if (timer_status_flag) { |
| for (uint32_t idx = 0; idx < map_timer_child_count; idx++) { |
| if ((timer_status_flag & BIT(idx)) != 0) { |
| const struct nxp_flexio_child *child = map_timer_child[idx]; |
| |
| if (child != NULL) { |
| nxp_flexio_child_isr_t isr = child->isr; |
| |
| if (isr != NULL) { |
| isr(child->user_data); |
| } |
| } |
| } |
| } |
| } |
| |
| SDK_ISR_EXIT_BARRIER; |
| } |
| |
| static int mcux_flexio_init(const struct device *dev) |
| { |
| const struct mcux_flexio_config *config = dev->config; |
| struct mcux_flexio_data *data = dev->data; |
| flexio_config_t flexio_config; |
| |
| k_mutex_init(&data->lock); |
| |
| FLEXIO_GetDefaultConfig(&flexio_config); |
| FLEXIO_Init(config->base, &flexio_config); |
| config->irq_config_func(dev); |
| |
| return 0; |
| } |
| |
| void nxp_flexio_irq_enable(const struct device *dev) |
| { |
| const struct mcux_flexio_config *config = dev->config; |
| |
| config->irq_enable_func(); |
| } |
| |
| void nxp_flexio_irq_disable(const struct device *dev) |
| { |
| const struct mcux_flexio_config *config = dev->config; |
| |
| config->irq_disable_func(); |
| } |
| |
| void nxp_flexio_lock(const struct device *dev) |
| { |
| struct mcux_flexio_data *data = dev->data; |
| |
| k_mutex_lock(&data->lock, K_FOREVER); |
| } |
| |
| void nxp_flexio_unlock(const struct device *dev) |
| { |
| struct mcux_flexio_data *data = dev->data; |
| |
| k_mutex_unlock(&data->lock); |
| } |
| |
| int nxp_flexio_get_rate(const struct device *dev, uint32_t *rate) |
| { |
| const struct mcux_flexio_config *config = dev->config; |
| |
| return clock_control_get_rate(config->clock_dev, config->clock_subsys, rate); |
| } |
| |
| int nxp_flexio_child_attach(const struct device *dev, |
| const struct nxp_flexio_child *child) |
| { |
| struct mcux_flexio_data *data = dev->data; |
| const struct nxp_flexio_child_res *child_res = &child->res; |
| |
| for (uint32_t i = 0; i < child_res->shifter_count; i++) { |
| int shifter_idx = mcux_flexio_child_take_shifter_idx(dev); |
| |
| if (shifter_idx < 0) { |
| LOG_ERR("Failed to take shifter index: %d", shifter_idx); |
| return shifter_idx; |
| } |
| child_res->shifter_index[i] = shifter_idx; |
| data->map_shifter_child[shifter_idx] = child; |
| LOG_DBG("child %p: shifter_idx[%d] is %d", child, i, shifter_idx); |
| } |
| |
| for (uint32_t i = 0; i < child_res->timer_count; i++) { |
| int timer_idx = mcux_flexio_child_take_timer_idx(dev); |
| |
| if (timer_idx < 0) { |
| LOG_ERR("Failed to take timer index: %d", timer_idx); |
| return timer_idx; |
| } |
| child_res->timer_index[i] = timer_idx; |
| data->map_timer_child[timer_idx] = child; |
| LOG_DBG("child %p: timer_idx[%d] is %d", child, i, timer_idx); |
| } |
| |
| return 0; |
| } |
| |
| #define MCUX_FLEXIO_SHIFTER_COUNT_MAX(n) \ |
| ARRAY_SIZE(((FLEXIO_Type *)DT_INST_REG_ADDR(n))->SHIFTCTL) |
| |
| #define MCUX_FLEXIO_TIMER_COUNT_MAX(n) \ |
| ARRAY_SIZE(((FLEXIO_Type *)DT_INST_REG_ADDR(n))->TIMCTL) |
| |
| #define MCUX_FLEXIO_INIT(n) \ |
| static void mcux_flexio_irq_config_func_##n(const struct device *dev); \ |
| static void mcux_flexio_irq_enable_func_##n(void); \ |
| static void mcux_flexio_irq_disable_func_##n(void); \ |
| \ |
| static nxp_flexio_map_child_t \ |
| nxp_flexio_map_shifter_child_##n[MCUX_FLEXIO_SHIFTER_COUNT_MAX(n)] = {0}; \ |
| static nxp_flexio_map_child_t \ |
| nxp_flexio_map_timer_child_##n[MCUX_FLEXIO_TIMER_COUNT_MAX(n)] = {0}; \ |
| \ |
| static struct mcux_flexio_data mcux_flexio_data_##n = { \ |
| .map_shifter_child = nxp_flexio_map_shifter_child_##n, \ |
| .map_shifter_child_count = ARRAY_SIZE(nxp_flexio_map_shifter_child_##n), \ |
| .map_timer_child = nxp_flexio_map_timer_child_##n, \ |
| .map_timer_child_count = ARRAY_SIZE(nxp_flexio_map_timer_child_##n), \ |
| }; \ |
| \ |
| static const struct mcux_flexio_config mcux_flexio_config_##n = { \ |
| .base = (FLEXIO_Type *)DT_INST_REG_ADDR(n), \ |
| .clock_dev = DEVICE_DT_GET(DT_INST_CLOCKS_CTLR(n)), \ |
| .clock_subsys = \ |
| (clock_control_subsys_t)DT_INST_CLOCKS_CELL(n, name), \ |
| .irq_config_func = mcux_flexio_irq_config_func_##n, \ |
| .irq_enable_func = mcux_flexio_irq_enable_func_##n, \ |
| .irq_disable_func = mcux_flexio_irq_disable_func_##n, \ |
| }; \ |
| \ |
| DEVICE_DT_INST_DEFINE(n, &mcux_flexio_init, \ |
| NULL, \ |
| &mcux_flexio_data_##n, \ |
| &mcux_flexio_config_##n, \ |
| POST_KERNEL, \ |
| CONFIG_MCUX_FLEXIO_INIT_PRIORITY, \ |
| NULL); \ |
| \ |
| static void mcux_flexio_irq_config_func_##n(const struct device *dev) \ |
| { \ |
| IRQ_CONNECT(DT_INST_IRQN(n), DT_INST_IRQ(n, priority), \ |
| mcux_flexio_isr, DEVICE_DT_INST_GET(n), 0); \ |
| irq_enable(DT_INST_IRQN(n)); \ |
| } \ |
| \ |
| static void mcux_flexio_irq_enable_func_##n(void) \ |
| { \ |
| irq_enable(DT_INST_IRQN(n)); \ |
| } \ |
| \ |
| static void mcux_flexio_irq_disable_func_##n(void) \ |
| { \ |
| irq_disable(DT_INST_IRQN(n)); \ |
| } |
| |
| DT_INST_FOREACH_STATUS_OKAY(MCUX_FLEXIO_INIT) |