rt-thread/components/drivers/regulator/regulator.c

/*
 * Copyright (c) 2006-2023, RT-Thread Development Team
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Change Logs:
 * Date           Author       Notes
 * 2023-09-23     GuEe-GUI     first version
 * 2026-03-27     Evlers       add current support and break away from reliance on DM,
 *                             and solve the problem of enabling counting.
 */

#include <rtthread.h>
#include <rtservice.h>
#include <rtdevice.h>

#define DBG_TAG "rtdm.regulator"
#define DBG_LVL DBG_INFO
#include <rtdbg.h>

struct rt_regulator
{
    struct rt_regulator_node *reg_np;
};

struct rt_regulator_record
{
    rt_list_t list;
    struct rt_regulator_node *reg_np;
};

static RT_DEFINE_SPINLOCK(_regulator_lock);
static rt_list_t _regulator_records = RT_LIST_OBJECT_INIT(_regulator_records);

static rt_err_t regulator_enable(struct rt_regulator_node *reg_np);
static rt_err_t regulator_disable(struct rt_regulator_node *reg_np);

static struct rt_regulator_record *regulator_find_record_by_name(const char *name)
{
    struct rt_regulator_record *record = RT_NULL;

    rt_list_for_each_entry(record, &_regulator_records, list)
    {
        if (!rt_strcmp(record->reg_np->supply_name, name))
        {
            return record;
        }
    }

    return RT_NULL;
}

static struct rt_regulator_record *regulator_find_record_by_node(struct rt_regulator_node *reg_np)
{
    struct rt_regulator_record *record = RT_NULL;

    rt_list_for_each_entry(record, &_regulator_records, list)
    {
        if (record->reg_np == reg_np)
        {
            return record;
        }
    }

    return RT_NULL;
}

rt_err_t rt_regulator_register(struct rt_regulator_node *reg_np)
{
    rt_err_t err;
    struct rt_regulator_record *record;
    const struct rt_regulator_param *param;

    if (!reg_np || !reg_np->dev || !reg_np->param || !reg_np->ops)
    {
        return -RT_EINVAL;
    }

    rt_list_init(&reg_np->list);
    rt_list_init(&reg_np->children_nodes);
    rt_list_init(&reg_np->notifier_nodes);
    rt_ref_init(&reg_np->ref);
    rt_atomic_store(&reg_np->enabled_count, 0);

    param = reg_np->param;

    reg_np->parent = RT_NULL;

    if ((param->ramp_delay || param->ramp_disable) &&
        reg_np->ops->set_ramp_delay)
    {
        if ((err = reg_np->ops->set_ramp_delay(reg_np, param->ramp_delay)))
        {
            LOG_E("Set ramp error = %s\n", rt_strerror(err));
            return err;
        }
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    if (regulator_find_record_by_name(reg_np->supply_name))
    {
        rt_hw_spin_unlock(&_regulator_lock.lock);
        return -RT_EBUSY;
    }

    record = rt_calloc(1, sizeof(*record));

    if (!record)
    {
        rt_hw_spin_unlock(&_regulator_lock.lock);
        return -RT_ENOMEM;
    }

    record->reg_np = reg_np;
    rt_list_init(&record->list);
    rt_list_insert_before(&_regulator_records, &record->list);

    rt_hw_spin_unlock(&_regulator_lock.lock);

#ifdef RT_USING_OFW
    if (reg_np->dev->ofw_node)
    {
        rt_ofw_data(reg_np->dev->ofw_node) = reg_np;
    }
#endif /* RT_USING_OFW */

    if (param->boot_on || param->always_on)
    {
        regulator_enable(reg_np);
    }

    return RT_EOK;
}

rt_err_t rt_regulator_unregister(struct rt_regulator_node *reg_np)
{
    rt_err_t err = RT_EOK;
    struct rt_regulator_record *record;

    if (!reg_np)
    {
        return -RT_EINVAL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    if (rt_atomic_load(&reg_np->enabled_count) != 0)
    {
        err = -RT_EBUSY;

        LOG_E("%s was enabled by consumer", reg_np->supply_name);

        goto _unlock;
    }

    if (!(reg_np->param->boot_on || reg_np->param->always_on))
    {
        regulator_disable(reg_np);
    }

    if (!rt_list_isempty(&reg_np->children_nodes) || rt_ref_read(&reg_np->ref) > 1)
    {
        err = -RT_EBUSY;

        goto _unlock;
    }

    reg_np->parent = RT_NULL;
    rt_list_remove(&reg_np->list);

    record = regulator_find_record_by_node(reg_np);

    if (record)
    {
        rt_list_remove(&record->list);
    }

_unlock:
    rt_hw_spin_unlock(&_regulator_lock.lock);

    if (!err && record)
    {
        rt_free(record);
    }

    return err;
}

rt_err_t rt_regulator_notifier_register(struct rt_regulator *reg,
        struct rt_regulator_notifier *notifier)
{
    struct rt_regulator_node *reg_np;

    if (!reg || !notifier)
    {
        return -RT_EINVAL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    reg_np = reg->reg_np;
    notifier->regulator = reg;

    rt_list_init(&notifier->list);
    rt_list_insert_after(&reg_np->notifier_nodes, &notifier->list);

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return RT_EOK;
}

rt_err_t rt_regulator_notifier_unregister(struct rt_regulator *reg,
        struct rt_regulator_notifier *notifier)
{
    if (!reg || !notifier)
    {
        return -RT_EINVAL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    rt_list_remove(&notifier->list);

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return RT_EOK;
}

static rt_err_t regulator_notifier_call_chain(struct rt_regulator_node *reg_np,
        rt_ubase_t msg, void *data)
{
    rt_err_t err = RT_EOK;
    struct rt_regulator_notifier *notifier;
    rt_list_t *head = &reg_np->notifier_nodes;

    if (rt_list_isempty(head))
    {
        return err;
    }

    rt_list_for_each_entry(notifier, head, list)
    {
        err = notifier->callback(notifier, msg, data);

        if (err == -RT_EIO)
        {
            break;
        }
    }

    return err;
}

static rt_uint32_t regulator_get_enable_time(struct rt_regulator_node *reg_np)
{
    if (reg_np->param->enable_delay)
    {
        return reg_np->param->enable_delay;
    }

    if (reg_np->ops->enable_time)
    {
        return reg_np->ops->enable_time(reg_np);
    }

    return 0;
}

static rt_uint32_t regulator_set_voltage_time(struct rt_regulator_node *reg_np,
        int old_uvolt, int new_uvolt)
{
    unsigned int ramp_delay = 0;

    if (reg_np->param->ramp_delay)
    {
        ramp_delay = reg_np->param->ramp_delay;
    }
    else if (reg_np->param->ramp_delay)
    {
        ramp_delay = reg_np->param->ramp_delay;
    }
    else if (reg_np->param->settling_time)
    {
        return reg_np->param->settling_time;
    }
    else if (reg_np->param->settling_time_up && new_uvolt > old_uvolt)
    {
        return reg_np->param->settling_time_up;
    }
    else if (reg_np->param->settling_time_down && new_uvolt < old_uvolt)
    {
        return reg_np->param->settling_time_down;
    }

    if (ramp_delay == 0)
    {
        return 0;
    }

    return RT_DIV_ROUND_UP(rt_abs(new_uvolt - old_uvolt), ramp_delay);
}

static void regulator_delay(rt_uint32_t delay)
{
    rt_uint32_t ms = delay / 1000;
    rt_uint32_t us = delay % 1000;

    if (ms > 0)
    {
        /*
         * For small enough values, handle super-millisecond
         * delays in the usleep_range() call below.
         */
        if (ms < 20)
        {
            us += ms * 1000;
        }
        else if (rt_thread_self())
        {
            rt_thread_mdelay(ms);
        }
        else
        {
            rt_hw_us_delay(ms * 1000);
        }
    }

    /*
     * Give the scheduler some room to coalesce with any other
     * wakeup sources. For delays shorter than 10 us, don't even
     * bother setting up high-resolution timers and just busy-loop.
     */
    if (us >= 10)
    {
        rt_hw_us_delay((us + 100) >> 1);
    }
    else
    {
        rt_hw_us_delay(us);
    }
}

static rt_err_t regulator_enable(struct rt_regulator_node *reg_np)
{
    rt_err_t err = RT_EOK;

    if (reg_np->ops->enable)
    {
        err = reg_np->ops->enable(reg_np);

        if (!err)
        {
            rt_uint32_t enable_delay = regulator_get_enable_time(reg_np);

            if (enable_delay)
            {
                regulator_delay(enable_delay);
            }

            err = regulator_notifier_call_chain(reg_np, RT_REGULATOR_MSG_ENABLE, RT_NULL);
        }
    }

    if (!err && reg_np->parent)
    {
        err = regulator_enable(reg_np->parent);
    }

    return err;
}

rt_err_t rt_regulator_enable(struct rt_regulator *reg)
{
    rt_err_t err;
    int enabled_cnt;

    if (!reg)
    {
        return -RT_EINVAL;
    }

    if (rt_regulator_is_enabled(reg))
    {
        rt_atomic_add(&reg->reg_np->enabled_count, 1);
        return RT_EOK;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    enabled_cnt = rt_atomic_load(&reg->reg_np->enabled_count);
    if (enabled_cnt > 0)
    {
        rt_atomic_add(&reg->reg_np->enabled_count, 1);
        rt_hw_spin_unlock(&_regulator_lock.lock);
        return RT_EOK;
    }

    err = regulator_enable(reg->reg_np);

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return err;
}

static rt_err_t regulator_disable(struct rt_regulator_node *reg_np)
{
    rt_err_t err = RT_EOK;

    if (reg_np->ops->disable)
    {
        err = reg_np->ops->disable(reg_np);

        if (!err)
        {
            if (reg_np->param->off_on_delay)
            {
                regulator_delay(reg_np->param->off_on_delay);
            }

            err = regulator_notifier_call_chain(reg_np, RT_REGULATOR_MSG_DISABLE, RT_NULL);
        }
    }

    if (!err && reg_np->parent)
    {
        err = regulator_disable(reg_np->parent);
    }

    return err;
}

rt_err_t rt_regulator_disable(struct rt_regulator *reg)
{
    rt_err_t err = RT_EOK;
    int enabled_cnt;

    if (!reg)
    {
        return -RT_EINVAL;
    }

    if (!rt_regulator_is_enabled(reg))
    {
        return RT_EOK;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    enabled_cnt = rt_atomic_load(&reg->reg_np->enabled_count);
    rt_atomic_sub(&reg->reg_np->enabled_count, 1);

    if (enabled_cnt == 1)
    {
        err = regulator_disable(reg->reg_np);
    }

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return err;
}

rt_bool_t rt_regulator_is_enabled(struct rt_regulator *reg)
{
    if (!reg)
    {
        return RT_FALSE;
    }

    if (reg->reg_np->ops->is_enabled)
    {
        return reg->reg_np->ops->is_enabled(reg->reg_np);
    }

    return rt_atomic_load(&reg->reg_np->enabled_count) > 0;
}

static rt_err_t regulator_set_voltage(struct rt_regulator_node *reg_np, int min_uvolt, int max_uvolt)
{
    rt_err_t err = RT_EOK;

    if (reg_np->ops->set_voltage)
    {
        union rt_regulator_notifier_args args;

        RT_ASSERT(reg_np->ops->get_voltage != RT_NULL);

        args.old_uvolt = reg_np->ops->get_voltage(reg_np);
        args.min_uvolt = min_uvolt;
        args.max_uvolt = max_uvolt;

        err = regulator_notifier_call_chain(reg_np, RT_REGULATOR_MSG_VOLTAGE_CHANGE, &args);

        if (!err)
        {
            err = reg_np->ops->set_voltage(reg_np, min_uvolt, max_uvolt);
        }

        if (!err)
        {
            rt_uint32_t delay = regulator_set_voltage_time(reg_np,
                    args.old_uvolt, reg_np->ops->get_voltage(reg_np));

            if (delay)
            {
                regulator_delay(delay);
            }
        }
        else
        {
            regulator_notifier_call_chain(reg_np, RT_REGULATOR_MSG_VOLTAGE_CHANGE_ERR,
                    (void *)(rt_base_t)args.old_uvolt);
        }
    }

    if (!err && reg_np->parent)
    {
        err = regulator_set_voltage(reg_np->parent, min_uvolt, max_uvolt);
    }

    return err;
}

static rt_err_t regulator_set_current(struct rt_regulator_node *reg_np, int min_uamp, int max_uamp)
{
    rt_err_t err = RT_EOK;

    if (reg_np->ops->set_current)
    {
        union rt_regulator_notifier_args args;

        RT_ASSERT(reg_np->ops->get_current != RT_NULL);

        args.old_uamp = reg_np->ops->get_current(reg_np);
        args.min_uamp = min_uamp;
        args.max_uamp = max_uamp;

        err = regulator_notifier_call_chain(reg_np, RT_REGULATOR_MSG_CURRENT_CHANGE, &args);

        if (!err)
        {
            err = reg_np->ops->set_current(reg_np, min_uamp, max_uamp);
        }

        if (err)
        {
            regulator_notifier_call_chain(reg_np, RT_REGULATOR_MSG_CURRENT_CHANGE_ERR,
                                          (void *)(rt_base_t)args.old_uamp);
        }
    }
    else
    {
        err = -RT_ENOSYS;
    }

    return err;
}

rt_bool_t rt_regulator_is_supported_voltage(struct rt_regulator *reg, int min_uvolt, int max_uvolt)
{
    const struct rt_regulator_param *param;

    RT_ASSERT(reg != RT_NULL);

    param = reg->reg_np->param;

    if (!param)
    {
        return RT_FALSE;
    }

    return param->min_uvolt <= min_uvolt && param->max_uvolt >= max_uvolt;
}

rt_err_t rt_regulator_set_voltage(struct rt_regulator *reg, int min_uvolt, int max_uvolt)
{
    rt_err_t err;

    if (!reg)
    {
        return -RT_EINVAL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    err = regulator_set_voltage(reg->reg_np, min_uvolt, max_uvolt);

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return err;
}

int rt_regulator_get_voltage(struct rt_regulator *reg)
{
    int uvolt = RT_REGULATOR_UVOLT_INVALID;
    struct rt_regulator_node *reg_np;

    if (!reg)
    {
        return -RT_EINVAL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    reg_np = reg->reg_np;

    if (reg_np->ops->get_voltage)
    {
        uvolt = reg_np->ops->get_voltage(reg->reg_np);
    }
    else
    {
        uvolt = -RT_ENOSYS;
    }

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return uvolt;
}

rt_bool_t rt_regulator_is_supported_current(struct rt_regulator *reg, int min_uamp, int max_uamp)
{
    const struct rt_regulator_param *param;

    if (!reg)
    {
        return RT_FALSE;
    }

    param = reg->reg_np->param;

    if (!param || param->max_uamp <= 0)
    {
        return RT_FALSE;
    }

    return param->min_uamp <= min_uamp && param->max_uamp >= max_uamp;
}

rt_err_t rt_regulator_set_current(struct rt_regulator *reg, int min_uamp, int max_uamp)
{
    rt_err_t err;

    if (!reg)
    {
        return -RT_EINVAL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    err = regulator_set_current(reg->reg_np, min_uamp, max_uamp);

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return err;
}

int rt_regulator_get_current(struct rt_regulator *reg)
{
    int uamp = RT_REGULATOR_UAMP_INVALID;
    struct rt_regulator_node *reg_np;

    if (!reg)
    {
        return -RT_EINVAL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    reg_np = reg->reg_np;

    if (reg_np->ops->get_current)
    {
        uamp = reg_np->ops->get_current(reg_np);
    }
    else
    {
        uamp = -RT_ENOSYS;
    }

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return uamp;
}

rt_err_t rt_regulator_set_mode(struct rt_regulator *reg, rt_uint32_t mode)
{
    rt_err_t err;
    struct rt_regulator_node *reg_np;

    if (!reg)
    {
        return -RT_EINVAL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    reg_np = reg->reg_np;

    if (reg_np->ops->set_mode)
    {
        err = reg_np->ops->set_mode(reg_np, mode);
    }
    else
    {
        err = -RT_ENOSYS;
    }

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return err;
}

rt_int32_t rt_regulator_get_mode(struct rt_regulator *reg)
{
    rt_int32_t mode;
    struct rt_regulator_node *reg_np;

    if (!reg)
    {
        return -RT_EINVAL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    reg_np = reg->reg_np;

    if (reg_np->ops->get_mode)
    {
        mode = reg_np->ops->get_mode(reg_np);
    }
    else
    {
        mode = -RT_ENOSYS;
    }

    rt_hw_spin_unlock(&_regulator_lock.lock);

    return mode;
}

static void regulator_check_parent(struct rt_regulator_node *reg_np)
{
    if (reg_np->parent)
    {
        return;
    }
    else
    {
    #ifdef RT_USING_OFW
        rt_phandle parent_phandle = 0;
        struct rt_ofw_node *np = reg_np->dev->ofw_node;

        while (np)
        {
            if (rt_ofw_prop_read_u32(np, "vin-supply", &parent_phandle))
            {
                break;
            }

            if (!(np = rt_ofw_find_node_by_phandle(parent_phandle)))
            {
                break;
            }

            if (!(reg_np->parent = rt_ofw_data(np)))
            {
                LOG_W("%s parent ofw node = %s not init",
                        reg_np->supply_name, rt_ofw_node_full_name(np));

                rt_ofw_node_put(np);
                break;
            }

            rt_list_insert_after(&reg_np->parent->children_nodes, &reg_np->list);
            rt_ofw_node_put(np);
        }
    #endif /* RT_USING_OFW */
    }
}

struct rt_regulator *rt_regulator_get(struct rt_device *dev, const char *id)
{
    struct rt_regulator *reg = RT_NULL;
    struct rt_regulator_node *reg_np = RT_NULL;

    if (!id)
    {
        reg = rt_err_ptr(-RT_EINVAL);
        goto _end;
    }

#ifdef RT_USING_OFW
    if (dev && dev->ofw_node)
    {
        rt_phandle supply_phandle;
        struct rt_ofw_node *np = dev->ofw_node;
        char supply_name[64];

        rt_snprintf(supply_name, sizeof(supply_name), "%s-supply", id);

        if (rt_ofw_prop_read_u32(np, supply_name, &supply_phandle))
        {
            goto _end;
        }

        if (!(np = rt_ofw_find_node_by_phandle(supply_phandle)))
        {
            reg = rt_err_ptr(-RT_EIO);
            goto _end;
        }

        if (!rt_ofw_data(np))
        {
            rt_platform_ofw_request(np);
        }

        reg_np = rt_ofw_data(np);
        rt_ofw_node_put(np);
    }
#endif /* RT_USING_OFW */

    if (!reg_np)
    {
        struct rt_regulator_record *record;

        rt_hw_spin_lock(&_regulator_lock.lock);
        record = regulator_find_record_by_name(id);
        if (record)
        {
            reg_np = record->reg_np;
        }
        rt_hw_spin_unlock(&_regulator_lock.lock);
    }

    if (!reg_np)
    {
        goto _end;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);

    regulator_check_parent(reg_np);

    rt_hw_spin_unlock(&_regulator_lock.lock);

    reg = rt_calloc(1, sizeof(*reg));

    if (!reg)
    {
        reg = rt_err_ptr(-RT_ENOMEM);
        goto _end;
    }

    reg->reg_np = reg_np;
    rt_ref_get(&reg_np->ref);

_end:
    return reg;
}

static void regulator_release(struct rt_ref *r)
{
    struct rt_regulator_node *reg_np = rt_container_of(r, struct rt_regulator_node, ref);

    rt_regulator_unregister(reg_np);
}

void rt_regulator_put(struct rt_regulator *reg)
{
    if (!reg)
    {
        return;
    }

    rt_ref_put(&reg->reg_np->ref, &regulator_release);
    rt_free(reg);
}

struct rt_regulator_node **rt_regulator_nodes_snapshot(rt_size_t *count)
{
    struct rt_regulator_record *record;
    struct rt_regulator_node **nodes;
    rt_size_t total = 0;
    rt_size_t idx = 0;

    if (!count)
    {
        return RT_NULL;
    }

    *count = 0;

    rt_hw_spin_lock(&_regulator_lock.lock);
    rt_list_for_each_entry(record, &_regulator_records, list)
    {
        total++;
    }
    rt_hw_spin_unlock(&_regulator_lock.lock);

    if (!total)
    {
        return RT_NULL;
    }

    nodes = rt_calloc(total, sizeof(*nodes));
    if (!nodes)
    {
        return RT_NULL;
    }

    rt_hw_spin_lock(&_regulator_lock.lock);
    rt_list_for_each_entry(record, &_regulator_records, list)
    {
        nodes[idx] = record->reg_np;
        rt_ref_get(&record->reg_np->ref);
        idx++;
    }
    rt_hw_spin_unlock(&_regulator_lock.lock);

    *count = total;
    return nodes;
}

void rt_regulator_nodes_snapshot_free(struct rt_regulator_node **nodes, rt_size_t count)
{
    if (!nodes)
    {
        return;
    }

    while (count--)
    {
        rt_ref_put(&nodes[count]->ref, &regulator_release);
    }

    rt_free(nodes);
}