0
  • 聊天消息
  • 系统消息
  • 评论与回复
登录后你可以
  • 下载海量资料
  • 学习在线课程
  • 观看威廉希尔官方网站 视频
  • 写文章/发帖/加入社区
会员中心
创作中心

完善资料让更多小伙伴认识你,还能领取20积分哦,立即完善>

3天内不再提示

电源管理入门-5 arm-scmi和mailbox核间通信

yzcdx 来源:OS与AUTOSAR研究 2023-10-16 17:09 次阅读

上篇介绍了电源管理入门-4子系统reset,提到子系统reset的执行为了安全可以到SCP里面去执行,但是怎么把这个消息传递过去呢,答案就是mailbox。

Mailbox是核间通信硬件的统称。

  • 在软件上可以使用SCMI协议+共享内存报文头,
  • 在硬件上可以使用PL320或者MHU。

1. 整体架构介绍

fedb1840-6bf8-11ee-939d-92fbcf53809c.png

Reset系统架构框图

上图以NPU子模块的服务为例子,Mailbox的硬件使用PL320,整体流程如下:

  1. Reset consumer模块执行devm_reset_control_get()获取npu_reset复位句柄,然后通过reset_control_reset()触发复位
  2. Linux系统reset framework找到复位驱动并执行ops->reset()回调函数
  3. scmi-reset驱动里面提供.reset函数的实现scmi_reset_deassert(),并执行
  4. arm-scmi里面提供scmi reset协议的实现模块reset,里面提供reset函数scmi_reset_domain_reset()
  5. arm-scmi里面提供scmi协议收发的框架driver,提供do_xfer()
  6. arm-scmi里面提供mailbox的接口函数mailbox_send_message()
  7. arm-scmi里面提供共享内存的操作函数shmem_tx_prepare()
  8. mailbox驱动里面提供硬件PL320的寄存器操作实现pl320_mbox_send_data()
  9. SCP中PL320驱动模块接收mailbox中断
  10. SCP中SMT模块从共享内存中读取SCMI报文数据
  11. SCP中SCMI模块对SCMI协议报文进行解析,并进行分发处理
  12. SCP中SCMI RESET DOMAIN协议模块对报文进行功能处理
  13. SCP中RESET DOMAIN模块屏蔽硬件差异实现统一API
  14. SCP中JUNO RESET DOMAIN模块提供具体硬件CRU寄存器操作实现

2 Linux中reset模块

2.1 Reset consumer

之前的文章电源管理入门-4子系统reset介绍了怎么使用Linux的reset子系统,这里我们就直接使用,需要在DTS中修改即可。

reset使用Linux自带的reset框架,假定consumer-firmware-npu这个驱动要使用NPU的reset,定义在DTS中有reset consumer的说明:consumer-firmware-npu。

/ {
        consumer_firmware@0x0 {
                compatible = "consumer-firmware-npu";
                reg = < 0x0 0x0 0x0 0x00 >;
                resets = <&scmi_reset 0>;
                reset-names = "npu_reset";
        };
};

drivers/firmware/consumer/consumer.c中驱动需要使用reset功能。

static struct platform_driver consumer_firmware_driver = {
        .driver = {
                .name = "consumer_firmware",
                .of_match_table = consumer_firmware_of_match,
        },
        .probe = consumer_firmware_probe,
        .remove = consumer_firmware_remove,
};
consumer_firmware_probe
--》devm_reset_control_get //获取"npu_reset"复位句柄
--》consumer_fw_firmware_cb 
  --》consumer_fw_memcpy //拷贝镜像
  --》consumer_control_reset //通知reset驱动进行reset

这样DTS探测到consumer_firmware的时候就会触发reset操作。

reset_control_reset
    rstc->rcdev->ops->reset(rstc->rcdev, rstc->id);

reset的provider驱动使用compatible = "scmi-reset";驱动,详细见后面2.2reset provider中分析。当reset时在drivers/reset/reset-scmi.c中实现

static int
scmi_reset_reset(struct reset_controller_dev *rcdev, unsigned long id)
{
        const struct scmi_protocol_handle *ph = to_scmi_handle(rcdev);

        return reset_ops->reset(ph, id);
}

static const struct reset_control_ops scmi_reset_ops = {
        .assert                = scmi_reset_assert,
        .deassert        = scmi_reset_deassert,
        .reset                = scmi_reset_reset,
};

reset_ops在scmi_reset_probe的时候会赋值

        reset_ops = handle->devm_protocol_get(sdev, SCMI_PROTOCOL_RESET, &ph);

handle->devm_protocol_get为drivers/firmware/arm_scmi/driver.c中scmi_devm_protocol_get,

    pi = scmi_get_protocol_instance(handle, protocol_id);
    return pi->proto->ops;

在scmi协议初始化的时候,scmi_reset_register会注册0x16的回调函数,详细分析见2.2.1SCMI reset协议初始化内容。在drivers/firmware/arm_scmi/reset.c中

static const struct scmi_reset_proto_ops reset_proto_ops = {
        .num_domains_get = scmi_reset_num_domains_get,
        .name_get = scmi_reset_name_get,
        .latency_get = scmi_reset_latency_get,
        .reset = scmi_reset_domain_reset,
        .assert = scmi_reset_domain_assert,
        .deassert = scmi_reset_domain_deassert,
};

scmi_reset_domain_reset--》scmi_domain_reset ret = ph->xops->do_xfer(ph, t); do_xfer在drivers/firmware/arm_scmi/driver.c中实现

do_xfer(ph, xfer);
ret = info->desc->ops->send_message(cinfo, xfer);

send_message在drivers/firmware/arm_scmi/mailbox.c中定义

static const struct scmi_transport_ops scmi_mailbox_ops = {
        .chan_available = mailbox_chan_available,
        .chan_setup = mailbox_chan_setup,
        .chan_free = mailbox_chan_free,
        .send_message = mailbox_send_message,
        .mark_txdone = mailbox_mark_txdone,
        .fetch_response = mailbox_fetch_response,
        .fetch_notification = mailbox_fetch_notification,
        .clear_channel = mailbox_clear_channel,
        .poll_done = mailbox_poll_done,
};

mailbox_send_message见3.2中分析

2.2 Reset provider

reset的provider是scmi-reset驱动,DTS中设置如下:

    scmi_reset: protocol@16 {
            reg = <0x16>;
            #reset-cells = <1>;
    };

代码位置在:drivers/reset/reset-scmi.c

static struct scmi_driver scmi_reset_driver = {
        .name = "scmi-reset",
        .probe = scmi_reset_probe,
        .id_table = scmi_id_table,
};
module_scmi_driver(scmi_reset_driver);

scmi_reset_probe的定义如下:

static int scmi_reset_probe(struct scmi_device *sdev)
{
        reset_ops = handle->devm_protocol_get(sdev, SCMI_PROTOCOL_RESET, &ph);

        data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
        data->rcdev.ops = &scmi_reset_ops;
        data->rcdev.owner = THIS_MODULE;
        data->rcdev.of_node = np;
        data->rcdev.nr_resets = reset_ops->num_domains_get(ph);
        data->ph = ph;

        return devm_reset_controller_register(dev, &data->rcdev);//进行驱动注册
}

handle->devm_protocol_get为scmi_devm_protocol_get,这里面发送了三条0x16的scmi消息 scmi_devm_protocol_get->scmi_get_protocol_instance

scmi_get_protocol_instance里面发送了三条0x16的scmi消息,来获取reset的版本号,支持那些devices等信息

3. Linux SCMI reset通信

ff0cc872-6bf8-11ee-939d-92fbcf53809c.png

如上图中,Linux通过非安全通道跟SCP交互。

3.1 SCMI reset协议初始化

系统初始化的时候会执行subsys_initcall(scmi_driver_init);在drivers/firmware/arm_scmi/driver.c中:

static int __init scmi_driver_init(void)
{
        int ret;

        /* Bail out if no SCMI transport was configured */
        if (WARN_ON(!IS_ENABLED(CONFIG_ARM_SCMI_HAVE_TRANSPORT)))
                return -EINVAL;

        scmi_bus_init();

        /* Initialize any compiled-in transport which provided an init/exit */
        ret = scmi_transports_init();
        if (ret)
                return ret;

        scmi_base_register();

        scmi_clock_register();
        scmi_perf_register();
        scmi_power_register();
        scmi_reset_register();
        scmi_sensors_register();
        scmi_voltage_register();
        scmi_system_register();

        return platform_driver_register(&scmi_driver);
}

scmi_driver的定义为:

static struct platform_driver scmi_driver = {
        .driver = {
                   .name = "arm-scmi",
                   .suppress_bind_attrs = true,
                   .of_match_table = scmi_of_match,
                   .dev_groups = versions_groups,
                   },
        .probe = scmi_probe,
        .remove = scmi_remove,
};

drivers/firmware/arm_scmi/driver.c中scmi_probe函数

static int scmi_probe(struct platform_device *pdev)
{
    ret = scmi_txrx_setup(info, dev, SCMI_PROTOCOL_BASE);
    
    ret = scmi_xfer_info_init(info);、
    
    ret = scmi_protocol_acquire(handle, SCMI_PROTOCOL_BASE);

scmi_txrx_setup中会调用mailbox_chan_setup函数

    size = resource_size(&res);
    smbox->shmem = devm_ioremap(dev, res.start, size);
    smbox->chan = mbox_request_channel(cl, tx ? 0 : 1);

scmi_protocol_acquire()函数

int scmi_protocol_acquire(const struct scmi_handle *handle, u8 protocol_id)
{
        return PTR_ERR_OR_ZERO(scmi_get_protocol_instance(handle, protocol_id));
}
scmi_get_protocol_instance
    scmi_alloc_init_protocol_instance(info, proto);
        ret = pi->proto->instance_init(&pi->ph);

drivers/firmware/arm_scmi/base.c中定义了instance_init

static int scmi_base_protocol_init(const struct scmi_protocol_handle *ph)
    ret = ph->xops->version_get(ph, &version);

static const struct scmi_xfer_ops xfer_ops = {
        .version_get = version_get,
        .xfer_get_init = xfer_get_init,
        .reset_rx_to_maxsz = reset_rx_to_maxsz,
        .do_xfer = do_xfer,
        .do_xfer_with_response = do_xfer_with_response,
        .xfer_put = xfer_put,
};

version_get中进行scmi的发送

static int version_get(const struct scmi_protocol_handle *ph, u32 *version)
{
        ret = xfer_get_init(ph, PROTOCOL_VERSION, 0, sizeof(*version), &t);
        ret = do_xfer(ph, t);
        xfer_put(ph, t);

xfer_get_init中进行了赋值xfer->hdr.id = msg_id; do_xfer进行了发送操作,之后等待回复

    ret = info->desc->ops->send_message(cinfo, xfer);

    /* And we wait for the response. */
    timeout = msecs_to_jiffies(info->desc->max_rx_timeout_ms);
    if (!wait_for_completion_timeout(&xfer->done, timeout)) {
            dev_err(dev, "timed out in resp(caller: %pS)
",
                    (void *)_RET_IP_);
            ret = -ETIMEDOUT;
    }

send_message在drivers/firmware/arm_scmi/mailbox.c中定义

static const struct scmi_transport_ops scmi_mailbox_ops = {
        .chan_available = mailbox_chan_available,
        .chan_setup = mailbox_chan_setup,
        .chan_free = mailbox_chan_free,
        .send_message = mailbox_send_message,
        .mark_txdone = mailbox_mark_txdone,
        .fetch_response = mailbox_fetch_response,
        .fetch_notification = mailbox_fetch_notification,
        .clear_channel = mailbox_clear_channel,
        .poll_done = mailbox_poll_done,
};

mbox_send_message就是mailbox提供的发消息接口函数,详细介绍见3.2

初始化的时候不仅初始化了scmi协议还调用了scmi_reset_register();注册了0x16的scmi reset协议 在drivers/firmware/arm_scmi/reset.c中

static const struct scmi_protocol scmi_reset = {
        .id = SCMI_PROTOCOL_RESET,
        .owner = THIS_MODULE,
        .instance_init = &scmi_reset_protocol_init,
        .ops = &reset_proto_ops,
        .events = &reset_protocol_events,
};

DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(reset, scmi_reset)

#define DEFINE_SCMI_PROTOCOL_REGISTER_UNREGISTER(name, proto)        
static const struct scmi_protocol *__this_proto = &(proto);        
                                                                
int __init scmi_##name##_register(void)                                
{                                                                
        return scmi_protocol_register(__this_proto);                
}

3.2 SCMI reset消息收发

ff2aa0c2-6bf8-11ee-939d-92fbcf53809c.png

  1. A核先往某个指定共享内存空间buffer写数据,然后写入共享内存空间的地址信息到相应通道数据寄存器,mailbox触发中断给R核;
  2. M核(SCP)通过得到mailbox中断,获取共享内存相应offset,读取buffer数据;
  3. M核(SCP)通过mailbox触发中断通知A核接收消息完毕。

PL320和MHU硬件的区别?

PL320带传输数据和中断功能,但是数据量比较小7*32bit。对于新的SoC来说数据传输基本都使用共享内存,PL320自带的数据传输基本用不上了,所以其算过时了。新的MHU只保留了中断功能,并且是1对1的集成,核间通信时成对出现,用几个加几个更加的灵活,PL320是一次32个通道集成进SoC的,也可能浪费。

我们以PL320为例,只使用其中断,数据还是通过共享内存传输,驱动跟MHU原理差不多。关于PL320,可以参考ARM官网的文档,后面会专门写一个核间通信的专题介绍下。

在drivers/mailbox/mailbox.c中,mailbox_send_message发消息的时候会调用mbox_send_message

mailbox_send_message
--》mbox_send_message
  --》msg_submit
  
static void msg_submit(struct mbox_chan *chan)
{
        data = chan->msg_data[idx];
        if (chan->cl->tx_prepare)
                chan->cl->tx_prepare(chan->cl, data);
        err = chan->mbox->ops->send_data(chan, data);
}

tx_prepare-》shmem_tx_prepare会往共享内存里面存入数据,在drivers/firmware/arm_scmi/shmem.c中

void shmem_tx_prepare(struct scmi_shared_mem __iomem *shmem,
                      struct scmi_xfer *xfer)
{
        spin_until_cond(ioread32(&shmem->channel_status) &
                        SCMI_SHMEM_CHAN_STAT_CHANNEL_FREE);
        iowrite32(0x0, &shmem->channel_status);
        iowrite32(xfer->hdr.poll_completion ? 0 : SCMI_SHMEM_FLAG_INTR_ENABLED,
                  &shmem->flags);
        iowrite32(sizeof(shmem->msg_header) + xfer->tx.len, &shmem->length);
        iowrite32(pack_scmi_header(&xfer->hdr), &shmem->msg_header);
        pr_info("#### shmem_tx_prepare shmem->msg_header=0x%x
", shmem->msg_header);
        if (xfer->tx.buf){
                memcpy_toio(shmem->msg_payload, xfer->tx.buf, xfer->tx.len);
        pr_info("#### shmem_tx_prepare shmem->msg_payload[0]=0x%x
", (int)shmem->msg_payload[0]);
        }
}

发消息drivers/mailbox/pl320-ipc.c中pl320_mbox_send_data函数

static const struct mbox_chan_ops pl320_mbox_ops = {
        .send_data        = pl320_mbox_send_data,
};

ops->send_data-》pl320_mbox_send_data-》__ipc_send(pl320_id, ch, buf);会触发中断

static void __ipc_send(int pl320_id, int mbox, u32 *data)
{
        ipc_base = get_ipc_base(pl320_id);

        for (i = 0; i < MBOX_MSG_LEN; i++)
                writel_relaxed(data[i], ipc_base + IPCMxDR(mbox, i));

        if (mbox % 2 == 0)
                writel_relaxed(0x1, ipc_base + IPCMxSEND(mbox));
        else
                writel_relaxed(0x2, ipc_base + IPCMxSEND(mbox));
}

收消息,drivers/mailbox/pl320-ipc.c中ipc_handler

        for (idx = 0; idx < MBOX_CHAN_MAX; idx++)
                if (irq_stat & (1 << idx))
                        receive_flag |= channel_handler(mbox, idx);

channel_handler中会清中断

4. SCP中reset

ff41f092-6bf8-11ee-939d-92fbcf53809c.png

4.1 固件新增module

  • 根据我们的需求需要处理0x16 scmi reset domain协议,所以在scmi module之后需要新加协议层scmi-reset-domain
  • 根据SCP固件的分层结构,协议层之后需要添加HAL层和驱动层

综上,需要在product/juno/scp_ramfw/CMakeLists.txt中新加如下module模块:

if(SCP_ENABLE_SCMI_RESET)
    target_sources(
        juno-bl2
        PRIVATE
            "${CMAKE_CURRENT_SOURCE_DIR}/config_reset_domain.c"
            "${CMAKE_CURRENT_SOURCE_DIR}/config_scmi_reset_domain.c"
            "${CMAKE_CURRENT_SOURCE_DIR}/config_juno_reset_domain.c")
endif()

if(SCP_ENABLE_SCMI_RESET)
    list(APPEND SCP_MODULES "reset-domain")
    list(APPEND SCP_MODULES "scmi-reset-domain")
    list(APPEND SCP_MODULES "juno-reset-domain")
endif()

打开SCP_ENABLE_SCMI_RESET宏,在product/juno/scp_ramfw/Firmware.cmake中 set(SCP_ENABLE_SCMI_RESET TRUE) set(SCP_ENABLE_SCMI_RESET_INIT TRUE)

4.2 scmi_reset_domain初始化

新增scmi_reset_domain协议module后,首先初始化的时候需要向scmi注册,这样当收到scmi消息的时候,会根据scmi协议号0x16进行协议分发处理。

ff55bcf8-6bf8-11ee-939d-92fbcf53809c.png

module/scmi_reset_domain/src/mod_scmi_reset_domain.c中初始化会执行.bind = scmi_reset_bind,函数

    status = fwk_module_bind(FWK_ID_MODULE(FWK_MODULE_IDX_SCMI),
                             FWK_ID_API(FWK_MODULE_IDX_SCMI,
                                        MOD_SCMI_API_IDX_PROTOCOL),
                             &scmi_rd_ctx.scmi_api);

去绑定scmi模块,在scmi中执行.process_bind_request = scmi_process_bind_request,

        scmi_ctx.protocol_table[PROTOCOL_TABLE_RESERVED_ENTRIES_COUNT +
                                scmi_ctx.protocol_count++].id = source_id;
        *api = &scmi_from_protocol_api;

会填充scmi_ctx.protocol_table,之后.bind = scmi_bind,执行

    for (protocol_idx = 0;
         protocol_idx < scmi_ctx.protocol_count; protocol_idx++) {
        protocol = &scmi_ctx.protocol_table[
            PROTOCOL_TABLE_RESERVED_ENTRIES_COUNT + protocol_idx];
        //根据module信息进行绑定,拿到api
        status = fwk_module_bind(protocol->id,
            FWK_ID_API(fwk_id_get_module_idx(protocol->id), 0), &protocol_api);
        //使用拿到的api获取scmi协议id号
        status = protocol_api->get_scmi_protocol_id(protocol->id,
                                                    &scmi_protocol_id);
        FWK_LOG_INFO("[SCMI] Support scmi_protocol_id:0x%x", scmi_protocol_id));

        scmi_ctx.scmi_protocol_id_to_idx[scmi_protocol_id] =
            (uint8_t)(protocol_idx + PROTOCOL_TABLE_RESERVED_ENTRIES_COUNT);
        protocol->message_handler = protocol_api->message_handler;
    }

protocol 是scmi协议的module,首先绑定这个module拿到两个api

static struct mod_scmi_to_protocol_api scmi_reset_mod_scmi_to_protocol_api = {
    .get_scmi_protocol_id = scmi_reset_get_scmi_protocol_id,
    .message_handler = scmi_reset_message_handler
};
scmi_reset_get_scmi_protocol_id为获取协议id
/*!
 * rief SCMI Reset Domain Protocol
 */
#define MOD_SCMI_PROTOCOL_ID_RESET_DOMAIN UINT32_C(0x16)

static int scmi_reset_get_scmi_protocol_id(fwk_id_t protocol_id,
                                           uint8_t *scmi_protocol_id)
{
    *scmi_protocol_id = MOD_SCMI_PROTOCOL_ID_RESET_DOMAIN;

    return FWK_SUCCESS;
}

4.3 scmi_reset_domain消息处理

协议模块负责处理reset相关的所有协议子命令,对于scmi_reset_domain一共支持6个子命令,如下:

enum scmi_command_id {
    MOD_SCMI_PROTOCOL_VERSION = 0x000,
    MOD_SCMI_PROTOCOL_ATTRIBUTES = 0x001,
    MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES = 0x002
};
enum scmi_reset_domain_command_id {
    MOD_SCMI_RESET_DOMAIN_ATTRIBUTES = 0x03,
    MOD_SCMI_RESET_REQUEST = 0x04,
    MOD_SCMI_RESET_NOTIFY = 0x05,
    MOD_SCMI_RESET_COMMAND_COUNT,
};

我们需要在协议模块scmi_reset_domain中,给这些命令设计处理函数如下:

static int (*msg_handler_table[])(fwk_id_t, const uint32_t *) = {
    [MOD_SCMI_PROTOCOL_VERSION] = protocol_version_handler,
    [MOD_SCMI_PROTOCOL_ATTRIBUTES] = protocol_attributes_handler,
    [MOD_SCMI_PROTOCOL_MESSAGE_ATTRIBUTES] =
         protocol_message_attributes_handler,
    [MOD_SCMI_RESET_DOMAIN_ATTRIBUTES] = reset_attributes_handler,
    [MOD_SCMI_RESET_REQUEST] = reset_request_handler,
#ifdef BUILD_HAS_SCMI_NOTIFICATIONS
    [MOD_SCMI_RESET_NOTIFY] = reset_notify_handler,
#endif
};

我们以为reset_request_handler例,进行说明

ff696b7c-6bf8-11ee-939d-92fbcf53809c.png

4.3.1 scmi_reset_domain中处理
static struct mod_scmi_to_protocol_api scmi_reset_mod_scmi_to_protocol_api = {
    .get_scmi_protocol_id = scmi_reset_get_scmi_protocol_id,
    .message_handler = scmi_reset_message_handler
};

scmi_reset_message_handler()函数中会根据命令id找到处理函数执行 msg_handler_table[message_id](service_id, payload); message_id就是cmd id,payload就是协议携带的数据部分。

[MOD_SCMI_RESET_REQUEST] = reset_request_handler,

reset_request_handler中会解析payload,并对payload的数据大小进行校验,然后进行解析

struct scmi_reset_domain_request_a2p {
    uint32_t domain_id;
    uint32_t flags;
    uint32_t reset_state;
};

   params = *(const struct scmi_reset_domain_request_a2p *)payload;
   status = get_reset_device(service_id, params.domain_id, &reset_device);
    status = scmi_reset_domain_reset_request_policy(&policy_status,
        &mode, &reset_state, agent_id, params.domain_id);

    status = reset_api->set_reset_state(reset_device->element_id,
                                        mode,
                                        reset_state,
                                        (uintptr_t)agent_id);

reset_api->set_reset_state是从HAL层拿到的api

4.3.2 reset-domain HAL层

/* HAL API */
static const struct mod_reset_domain_drv_api reset_api = {
    .set_reset_state = set_reset_state,
};

static int set_reset_state(fwk_id_t reset_dev_id,
                           enum mod_reset_domain_mode mode,
                           uint32_t reset_state,
                           uintptr_t cookie)
{
    struct rd_dev_ctx *reset_ctx;
    unsigned int reset_domain_idx = fwk_id_get_element_idx(reset_dev_id);
    FWK_LOG_INFO("[RESET DOMAIN] set_reset_state");

    reset_ctx = &module_reset_ctx.dev_ctx_table[reset_domain_idx];

    return reset_ctx->driver_api->set_reset_state(reset_ctx->config->driver_id,
                                                  mode, reset_state, cookie);
}

从driver层拿到api进行处理

4.3.3 juno-reset-domain驱动层

static struct mod_reset_domain_drv_api juno_reset_domain_drv_api = {
    .set_reset_state = juno_set_reset_state,
};

static int juno_set_reset_state(
    fwk_id_t dev_id,
    enum mod_reset_domain_mode mode,
    uint32_t reset_state,
    uintptr_t cookie)
{
    unsigned int domain_idx = fwk_id_get_element_idx(dev_id);
    dev_ctx = &module_juno_reset_ctx.dev_ctx_table[domain_idx];
    
    if (domain_idx == juno_RESET_DOMAIN_IDX_NPU) {
        status = handle_dev_reset_set_state(dev_ctx);
        if (status != FWK_SUCCESS) {
            return status;
        }
    } 

    return FWK_SUCCESS;
}

handle_dev_reset_set_state里面处理具体的硬件寄存器操作:

/* Helper functions */
static int handle_dev_reset_set_state(struct juno_reset_dev_ctx *dev_ctx)
{
    /* Reset device */
    dev_ctx->reset_state = DEVICE_STATE_RESET;
    *dev_config->reset_reg = 0;
    for (int j = 0; j < 10000; j++)
        ;
    *dev_config->reset_reg = 1;

    *dev_config->clkctl_reg = 1;

    dev_ctx->reset_state = DEVICE_STATE_NORMAL;

根据2.4章节中CRU硬件,这里需要对reset寄存器和clk寄存器进行写操作来实现其他硬件模块的reset功能。

5. 硬件CRU设计

CRU(Clock & Reset Unit)位于SCP子系统中,受SCP软件控制,然后硬件信号会连接到其他子系统上,我们的SCP固件一般运行在ARM的M核心上,还有一堆外围的器件,例如NXPimx8qm里面:

ff7c0aa2-6bf8-11ee-939d-92fbcf53809c.png

将clock gate信号和reset信号送给多个子系统(有时钟控制、reset控制等需求的子系统)。通过SCP软件来操作CRU的相关寄存器,从而实现对子系统时钟和复位信号的控制,

ff8b404e-6bf8-11ee-939d-92fbcf53809c.png

芯片手册会给出控制CRU的reset及clk的寄存器配置,操作响应的寄存器即可。

后记:

本小节介绍比较详细,其实很多知识点都是相通的,例如SCMI、SCP、Mailbox、DTS这些东西,早晚都需要掌握,但是通过一个业务流程或者场景就可以学习到,本文就是一个了解这些知识的机会。

声明:本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人,不代表电子发烧友网立场。文章及其配图仅供工程师学习之用,如有内容侵权或者其他违规问题,请联系本站处理。 举报投诉
  • ARM
    ARM
    +关注

    关注

    134

    文章

    9091

    浏览量

    367453
  • 寄存器
    +关注

    关注

    31

    文章

    5342

    浏览量

    120285
  • 电源管理
    +关注

    关注

    115

    文章

    6180

    浏览量

    144471
  • 通信
    +关注

    关注

    18

    文章

    6029

    浏览量

    135970

原文标题:电源管理入门-5 arm-scmi和mailbox核间通信

文章出处:【微信号:OS与AUTOSAR研究,微信公众号:OS与AUTOSAR研究】欢迎添加关注!文章转载请注明出处。

收藏 人收藏

    评论

    相关推荐

    SoC的通信机制—mailbox介绍

    目前很多芯片都会有几个core,有的是Cortex M0+、M4、M7、A53、A73等等,有的有着2、3、4甚至68
    发表于 08-11 10:51 5710次阅读
    SoC的<b class='flag-5'>核</b><b class='flag-5'>间</b><b class='flag-5'>通信</b>机制—<b class='flag-5'>mailbox</b>介绍

    电源管理入门:Hypervisor中的电源管理

    很多时候听说Hypervisor,但是对底层软件威廉希尔官方网站 不了解的人感觉挺神秘。本篇文章简单介绍下Hypervisor的基本概念,另外介绍下电源管理在Hypervisor之上多OS怎么应用。
    的头像 发表于 12-06 09:27 1454次阅读
    <b class='flag-5'>电源</b><b class='flag-5'>管理入门</b>:Hypervisor中的<b class='flag-5'>电源</b><b class='flag-5'>管理</b>

    关于AM5728通信方式(共享内存)问题

    您好,我使用的开发板为AM5728,目前要在两个ARM-Cotex-A15和两个DSP上都应用OS,初步定为都运行SYS/BIOS,在这种情况下我们想实现实时、快速、可靠的通信
    发表于 05-15 07:34

    搞定单CPU内双通信和双CPU通信

    [table][tr][td] 终于搞定了单CPU内双通信和双CPU通信 +-----+ +
    发表于 08-19 01:37

    ARM电源管理系列资料汇总(一)

    管理 SoC 中其它设备的电源。对于 PPU 在 SoC 中的集成,可以在前面 PCSA 的文章中看到,今天重点是看一下 PPU 里面到底包含哪些内容。2、ARM系列之SCMI软件接
    发表于 03-30 14:17

    通信(IPC)解决方案

    以运行在不同的模式,比如A72可以运行的SMP模式,双R5F可以运行在Lockstep或Split Mode上,因此,通信方案要充分利
    发表于 11-03 07:26

    使用ARM SCMI规范的电源和性能管理

    本白皮书概述了ARM系统控制和管理接口(SCMI)规范。 它描述了启用SCMI的系统如何通过操作系统和系统控制器之间的抽象和职责划分的组合来优化电源
    发表于 08-23 07:36

    防火墙原理入门

    防火墙原理入门 防火墙能增强机构内部网络的安全性。防火墙系统决定了哪些内部服务可以被外界访问;外界的哪些人可以访问内部的服务以及哪
    发表于 08-01 10:21 1022次阅读
    防火墙原<b class='flag-5'>理入门</b>

    一种基于Mailbox机制的多核处理系统

    基于FPGA的嵌入式应用在近几年来作为一个比较新颖的课题,本文在研究各种通信机制的基础上,提出了一种基于Mailbox
    发表于 11-22 17:31 1.3w次阅读

    Jacinto™︎ 7通信解决方案

    Jacinto™︎ 7通信解决方案
    发表于 10-28 11:59 3次下载
    Jacinto™︎ 7<b class='flag-5'>核</b><b class='flag-5'>间</b><b class='flag-5'>通信</b>解决方案

    Jacinto 7通信解决方案

    近年来,处理器性能越来越强,无论是通用处理器还是嵌入式处理器,都进入了多核处理器时代,多核处理器中,每个核心不能独立工作,需要协同工作才能充分发挥处理器的性能,也就是需要高效的通信
    的头像 发表于 03-16 09:19 1193次阅读
    Jacinto 7<b class='flag-5'>核</b><b class='flag-5'>间</b><b class='flag-5'>通信</b>解决方案

    SoC通信的实现机制之mailbox中断

    目前很多芯片都会有几个core,有的是Cortex M0+、M4、M7、A53、A73等等,有的有着2、3、4甚至68
    的头像 发表于 09-05 17:29 1725次阅读
    SoC<b class='flag-5'>核</b><b class='flag-5'>间</b><b class='flag-5'>通信</b>的实现机制之<b class='flag-5'>mailbox</b>中断

    通信(IPC)的目标和实现机制

    的应用程序提供简洁高效的编程接口。 根据所使用的硬件特性,通信的实现机制有: • ·Mailbox中断 • ·基于共享内
    的头像 发表于 09-13 17:32 3320次阅读
    <b class='flag-5'>核</b><b class='flag-5'>间</b><b class='flag-5'>通信</b>(IPC)的目标和实现机制

    通信可能的实现机制

    理解为软件可自由定义的中断模块。 用于在片上处理器之间通信的一种mailbox队列中断机制,mailbox队列中断机制允许软件通过一组寄存器和关联的中断设置和得到信息在二个处理之间建立通信
    的头像 发表于 09-13 17:39 1249次阅读
    <b class='flag-5'>核</b><b class='flag-5'>间</b><b class='flag-5'>通信</b>可能的实现机制

    使用mailbox和MUTEX的处理器通信解决方案

    现在业界的许多解决方案都包含多个处理器,或者是硬核处理器,如Arm A9、A53或R5,软如MicroBlaze、Arm Cortex-M1/M3,或者是两者的组合。
    的头像 发表于 09-21 15:23 1098次阅读
    使用<b class='flag-5'>mailbox</b>和MUTEX的处理器<b class='flag-5'>间</b><b class='flag-5'>通信</b>解决方案