430 lines
9.0 KiB
C
430 lines
9.0 KiB
C
/*
|
|
* Copyright (c) 2006-2024 RT-Thread Development Team
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2022-11-26 GuEe-GUI first version
|
|
*/
|
|
|
|
#include <rtthread.h>
|
|
#include <rtservice.h>
|
|
|
|
#define DBG_TAG "rtdm.reset"
|
|
#define DBG_LVL DBG_INFO
|
|
#include <rtdbg.h>
|
|
|
|
#include <drivers/ofw.h>
|
|
#include "reset.h"
|
|
|
|
struct reset_control_array
|
|
{
|
|
struct rt_reset_control captain;
|
|
|
|
rt_size_t count;
|
|
struct rt_reset_control *rstcs[];
|
|
};
|
|
|
|
#define reset_control_to_array(rstc) rt_container_of(rstc, struct reset_control_array, captain)
|
|
|
|
static struct rt_spinlock _rstcer_lock = { 0 };
|
|
static rt_list_t _rstcer_nodes = RT_LIST_OBJECT_INIT(_rstcer_nodes);
|
|
|
|
rt_err_t rt_reset_controller_register(struct rt_reset_controller *rstcer)
|
|
{
|
|
rt_ubase_t level;
|
|
|
|
if (!rstcer)
|
|
{
|
|
return -RT_EINVAL;
|
|
}
|
|
|
|
rt_list_init(&rstcer->list);
|
|
rt_list_init(&rstcer->rstc_nodes);
|
|
rt_spin_lock_init(&rstcer->spinlock);
|
|
|
|
level = rt_spin_lock_irqsave(&_rstcer_lock);
|
|
|
|
rt_list_insert_after(&_rstcer_nodes, &rstcer->list);
|
|
|
|
rt_spin_unlock_irqrestore(&_rstcer_lock, level);
|
|
|
|
if (rstcer->ofw_node)
|
|
{
|
|
if (!rt_ofw_data(rstcer->ofw_node))
|
|
{
|
|
rt_ofw_data(rstcer->ofw_node) = rstcer;
|
|
}
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
rt_err_t rt_reset_controller_unregister(struct rt_reset_controller *rstcer)
|
|
{
|
|
if (rstcer)
|
|
{
|
|
rt_spin_lock(&_rstcer_lock);
|
|
|
|
rt_list_remove(&rstcer->list);
|
|
|
|
rt_spin_unlock(&_rstcer_lock);
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
return -RT_EINVAL;
|
|
}
|
|
|
|
rt_err_t rt_reset_control_reset(struct rt_reset_control *rstc)
|
|
{
|
|
rt_err_t err;
|
|
|
|
if (!rstc)
|
|
{
|
|
return -RT_EINVAL;
|
|
}
|
|
|
|
if (rstc->rstcer->ops->reset)
|
|
{
|
|
if ((err = rstc->rstcer->ops->reset(rstc)))
|
|
{
|
|
return err;
|
|
}
|
|
}
|
|
|
|
if (rstc->is_array)
|
|
{
|
|
struct reset_control_array *rstc_arr = reset_control_to_array(rstc);
|
|
|
|
for (int i = 0; i < rstc_arr->count; ++i)
|
|
{
|
|
if ((err = rt_reset_control_reset(rstc_arr->rstcs[i])))
|
|
{
|
|
return err;
|
|
}
|
|
}
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
rt_err_t rt_reset_control_assert(struct rt_reset_control *rstc)
|
|
{
|
|
rt_err_t err;
|
|
|
|
if (!rstc)
|
|
{
|
|
return -RT_EINVAL;
|
|
}
|
|
|
|
if (rstc->deassert && rstc->rstcer->ops->assert)
|
|
{
|
|
if ((err = rstc->rstcer->ops->assert(rstc)))
|
|
{
|
|
return err;
|
|
}
|
|
|
|
rstc->deassert = RT_FALSE;
|
|
}
|
|
|
|
if (rstc->is_array)
|
|
{
|
|
struct reset_control_array *rstc_arr = reset_control_to_array(rstc);
|
|
|
|
for (int i = 0; i < rstc_arr->count; ++i)
|
|
{
|
|
if ((err = rt_reset_control_assert(rstc_arr->rstcs[i])))
|
|
{
|
|
if (rstc->rstcer->ops->deassert)
|
|
{
|
|
rstc->rstcer->ops->deassert(rstc);
|
|
|
|
rstc->deassert = RT_TRUE;
|
|
}
|
|
|
|
while (i --> 0)
|
|
{
|
|
rt_reset_control_deassert(rstc_arr->rstcs[i]);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
}
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
rt_err_t rt_reset_control_deassert(struct rt_reset_control *rstc)
|
|
{
|
|
rt_err_t err;
|
|
|
|
if (!rstc)
|
|
{
|
|
return -RT_EINVAL;
|
|
}
|
|
|
|
if (!rstc->deassert && rstc->rstcer->ops->deassert)
|
|
{
|
|
if ((err = rstc->rstcer->ops->deassert(rstc)))
|
|
{
|
|
return err;
|
|
}
|
|
|
|
rstc->deassert = RT_TRUE;
|
|
}
|
|
|
|
if (rstc->is_array)
|
|
{
|
|
struct reset_control_array *rstc_arr = reset_control_to_array(rstc);
|
|
|
|
for (int i = 0; i < rstc_arr->count; ++i)
|
|
{
|
|
if ((err = rt_reset_control_deassert(rstc_arr->rstcs[i])))
|
|
{
|
|
if (rstc->rstcer->ops->assert)
|
|
{
|
|
rstc->rstcer->ops->assert(rstc);
|
|
|
|
rstc->deassert = RT_FALSE;
|
|
}
|
|
|
|
while (i --> 0)
|
|
{
|
|
rt_reset_control_assert(rstc_arr->rstcs[i]);
|
|
}
|
|
|
|
return err;
|
|
}
|
|
}
|
|
}
|
|
|
|
return RT_EOK;
|
|
}
|
|
|
|
int rt_reset_control_status(struct rt_reset_control *rstc)
|
|
{
|
|
if (!rstc)
|
|
{
|
|
return -RT_EINVAL;
|
|
}
|
|
|
|
if (rstc->rstcer->ops->status)
|
|
{
|
|
return rstc->rstcer->ops->status(rstc);
|
|
}
|
|
|
|
return -RT_ENOSYS;
|
|
}
|
|
|
|
static void reset_free(struct rt_reset_control *rstc)
|
|
{
|
|
if (rstc->is_array)
|
|
{
|
|
struct reset_control_array *rstc_arr = reset_control_to_array(rstc);
|
|
|
|
for (int i = 0; i < rstc_arr->count; ++i)
|
|
{
|
|
rt_reset_control_put(rstc_arr->rstcs[i]);
|
|
}
|
|
}
|
|
|
|
rt_free(rstc);
|
|
}
|
|
|
|
struct rt_reset_control *rt_reset_control_get_array(struct rt_device *dev)
|
|
{
|
|
return rt_ofw_get_reset_control_array(dev->ofw_node);
|
|
}
|
|
|
|
struct rt_reset_control *rt_reset_control_get_by_index(struct rt_device *dev, int index)
|
|
{
|
|
return rt_ofw_get_reset_control_by_index(dev->ofw_node, index);
|
|
}
|
|
|
|
struct rt_reset_control *rt_reset_control_get_by_name(struct rt_device *dev, const char *name)
|
|
{
|
|
return rt_ofw_get_reset_control_by_name(dev->ofw_node, name);
|
|
}
|
|
|
|
void rt_reset_control_put(struct rt_reset_control *rstc)
|
|
{
|
|
struct rt_reset_controller *rstcer;
|
|
|
|
if (!rstc)
|
|
{
|
|
return;
|
|
}
|
|
|
|
rstcer = rstc->rstcer;
|
|
|
|
rt_spin_lock(&rstcer->spinlock);
|
|
|
|
rt_list_remove(&rstc->list);
|
|
|
|
rt_spin_unlock(&rstcer->spinlock);
|
|
|
|
reset_free(rstc);
|
|
}
|
|
|
|
static struct rt_reset_control *ofw_get_reset_control(struct rt_ofw_node *np, int index,
|
|
const char *name, rt_bool_t is_array)
|
|
{
|
|
struct rt_reset_control *rstc;
|
|
struct rt_ofw_cell_args reset_args = {};
|
|
struct rt_reset_controller *rstcer = RT_NULL;
|
|
|
|
if (is_array)
|
|
{
|
|
rt_size_t rstc_nr;
|
|
struct reset_control_array *rstc_arr;
|
|
|
|
rstc_nr = rt_ofw_count_phandle_cells(np, "resets", "#reset-cells");
|
|
|
|
if (!rstc_nr)
|
|
{
|
|
return RT_NULL;
|
|
}
|
|
|
|
rstc_arr = rt_calloc(1, sizeof(*rstc_arr) + sizeof(struct rt_reset_control *) * rstc_nr);
|
|
|
|
if (!rstc_arr)
|
|
{
|
|
LOG_E("No memory to create %s[%d] reset control",
|
|
rt_ofw_node_full_name(np), index);
|
|
|
|
return RT_NULL;
|
|
}
|
|
|
|
rstc_arr->count = rstc_nr - 1;
|
|
|
|
for (int i = 0; i < rstc_arr->count; ++i)
|
|
{
|
|
rstc_arr->rstcs[i] = ofw_get_reset_control(np, i + 1, RT_NULL, RT_FALSE);
|
|
|
|
if (!rstc_arr->rstcs[i])
|
|
{
|
|
while (i --> 0)
|
|
{
|
|
rt_reset_control_put(rstc_arr->rstcs[i]);
|
|
}
|
|
|
|
rt_free(rstc_arr);
|
|
rstc_arr = RT_NULL;
|
|
|
|
return RT_NULL;
|
|
}
|
|
}
|
|
|
|
rstc = &rstc_arr->captain;
|
|
rstc->is_array = RT_TRUE;
|
|
}
|
|
else
|
|
{
|
|
rstc = rt_calloc(1, sizeof(*rstc));
|
|
|
|
if (!rstc)
|
|
{
|
|
LOG_E("No memory to create %s[%d] reset control",
|
|
rt_ofw_node_full_name(np), index);
|
|
|
|
return RT_NULL;
|
|
}
|
|
}
|
|
|
|
if (!rt_ofw_parse_phandle_cells(np, "resets", "#reset-cells", index, &reset_args))
|
|
{
|
|
void *rt_data = rt_ofw_data(reset_args.data);
|
|
|
|
if (rt_data)
|
|
{
|
|
/* check is clk */
|
|
if (rt_ofw_prop_read_bool(reset_args.data, "#clock-cells"))
|
|
{
|
|
struct rt_reset_controller_clk_node *rstcer_clk = rt_data;
|
|
|
|
rstcer = &rstcer_clk->rstcer;
|
|
}
|
|
else
|
|
{
|
|
rstcer = rt_data;
|
|
}
|
|
}
|
|
|
|
rt_ofw_node_put(reset_args.data);
|
|
}
|
|
|
|
if (!rstcer)
|
|
{
|
|
goto _fail;
|
|
}
|
|
|
|
if (!name && rt_ofw_prop_read_bool(np, "reset-names"))
|
|
{
|
|
rt_ofw_prop_read_string_index(np, "reset-names", index, &name);
|
|
}
|
|
|
|
rstc->con_id = name;
|
|
rstc->rstcer = rstcer;
|
|
|
|
if (rstcer->ops->ofw_parse)
|
|
{
|
|
rt_err_t err = rstcer->ops->ofw_parse(rstc, &reset_args);
|
|
|
|
if (err)
|
|
{
|
|
LOG_E("Parse %s reset control error = %s",
|
|
rt_ofw_node_full_name(np), rt_strerror(err));
|
|
|
|
goto _fail;
|
|
}
|
|
}
|
|
|
|
rstc->id = reset_args.args[0];
|
|
|
|
rt_list_init(&rstc->list);
|
|
|
|
rt_spin_lock(&rstcer->spinlock);
|
|
|
|
rt_list_insert_after(&rstcer->rstc_nodes, &rstc->list);
|
|
|
|
rt_spin_unlock(&rstcer->spinlock);
|
|
|
|
return rstc;
|
|
|
|
_fail:
|
|
if (rstc && !rstc->is_array)
|
|
{
|
|
rt_free(rstc);
|
|
}
|
|
|
|
return RT_NULL;
|
|
}
|
|
|
|
struct rt_reset_control *rt_ofw_get_reset_control_array(struct rt_ofw_node *np)
|
|
{
|
|
return ofw_get_reset_control(np, 0, RT_NULL, RT_TRUE);
|
|
}
|
|
|
|
struct rt_reset_control *rt_ofw_get_reset_control_by_index(struct rt_ofw_node *np, int index)
|
|
{
|
|
return ofw_get_reset_control(np, index, RT_NULL, RT_FALSE);
|
|
}
|
|
|
|
struct rt_reset_control *rt_ofw_get_reset_control_by_name(struct rt_ofw_node *np, const char *name)
|
|
{
|
|
if (np)
|
|
{
|
|
int index = rt_ofw_prop_index_of_string(np, "reset-names", name);
|
|
|
|
if (index >= 0)
|
|
{
|
|
return ofw_get_reset_control(np, index, name, RT_FALSE);
|
|
}
|
|
}
|
|
|
|
return RT_NULL;
|
|
}
|