SCPfirmware 源码分析 on 夜云泊

SCP-firmware 源码分析-module 间 api 调用分析

Thu, 15 Aug 2024 15:42:13 +0800

想了解如何提供 API，我们先看看 CMN 模块是如何使用 API 的，在文件module/cmn700/src/mod_cmn700.c我们可以看到如下代码：

// module/cmn700/src/mod_cmn700.c
static struct mod_system_info_get_info_api *system_info_api;

int cmn700_start(fwk_id_t id)
{
    ...
    status = system_info_api->get_system_info(&system_info);
    if (status == FWK_SUCCESS) {
        chip_id = system_info->chip_id;
        multi_chip_mode = system_info->multi_chip_mode;
    }
    ...
}

他调用了system_info_api->get_system_info这个函数，实际这就是 mod_system_info 暴露给 mod_cmn700 的一个 API。用于获取系统信息。

为何这个静态变量system_info_api就能调用到mod_system_info的函数呢？我们继续搜索代码，可以看到如下代码：

// module/cmn700/src/mod_cmn700.c
static int cmn700_bind(fwk_id_t id, unsigned int round)
{
    ...
    if (fwk_id_is_type(id, FWK_ID_TYPE_MODULE)) {
        /* Bind to system info module to obtain multi-chip info */
        status = fwk_module_bind(
            FWK_ID_MODULE(FWK_MODULE_IDX_SYSTEM_INFO),
            FWK_ID_API(FWK_MODULE_IDX_SYSTEM_INFO, MOD_SYSTEM_INFO_GET_API_IDX),
            &system_info_api);
        return status;
    }
    ...
}

在cmn700_bind函数中，调用了fwk_module_bind函数，这个函数的作用是绑定一个模块的 API，这样就可以通过这个 API 调用模块的函数。fwk_module_bind函数的第一个参数是提供 API 的模块的 ID，比如当前是模块system_info的 ID，如果是要用 USB 的 API，那么就是 USB 模块的 ID。第二个参数是 API 的 ID，这个 ID 是在模块的头文件中定义的，比如mod_system_info.h中定义了MOD_SYSTEM_INFO_GET_API_IDX，这个宏定义的值就是 API 的 ID。第三个参数是 API 的指针，这个指针就是开头提到的静态变量的地址，它是定义在使用 API 的模块中的。这样就可以通过 API 的指针调用模块的函数。对于 USB 模块，我们就需要在使用到 USB 的模块中定义一个静态变量。

fwk_module_bind做了什么呢？进入该函数，可以看到它回调了mod_system_info的process_bind_request函数，也就是system_info_process_bind_request函数。

// framework/src/fwk_module.c
int fwk_module_bind(fwk_id_t target_id, fwk_id_t api_id, const void *api)
{
    ...
    status = fwk_mod_ctx->desc->process_bind_request(
        fwk_module_ctx.bind_id, target_id, api_id, (const void **)api);
    ...
}

system_info_process_bind_request函数的作用是根据 API 的 ID 返回 API 的指针。它把get_system_info_api的地址赋值给了api。这就实现了 API 的暴露。经过这个函数，system_info_api就指向了get_system_info_api。实际就是我们在cmn700_bind函数中使用system_info_api就是在调用get_system_info_api。

// module/system_info/src/mod_system_info.c
static int system_info_process_bind_request(fwk_id_t requester_id,
        fwk_id_t targer_id, fwk_id_t api_id, const void **api)
{
    switch (fwk_id_get_api_idx(api_id)) {
    case MOD_SYSTEM_INFO_GET_API_IDX:
        *api = &get_system_info_api;
        break;
    default:
        return FWK_E_PARAM;
    }
    return FWK_SUCCESS;
}

解释完这个 bind 函数，它是在哪被调用的？它在框架初始化时就会被调用，分析fwk_arch_init函数，可以看到在fwk_module_start函数中会对每一个模块调用bind函数。函数调用流程参考图片文件。在此就不再赘述了。

经过以上分析，提供 API 的模块需要做的事情就是：

在模块的头文件中定义 API 的 ID，它有一定的格式，具体可以参考 MSCP 文档doc/framework.md的APIs章节。
```
enum mod_modulename_api {
    MOD_MODULENAME_API_A,
    MOD_MODULENAME_API_B,
};
```

在模块的源文件中定义 API 结构体，用于在其他模块中使用。

struct mod_system_info_get_info_api {
    int (*get_system_info)(const struct mod_system_info **sys_info);
};

在模块原文件中提供process_bind_request函数，用于根据 API 的 ID 返回 API 的指针。

static int system_info_process_bind_request(fwk_id_t requester_id,
    fwk_id_t targer_id, fwk_id_t api_id, const void **api)
{
    switch (fwk_id_get_api_idx(api_id)) {
    case MOD_SYSTEM_INFO_GET_API_IDX:
        *api = &get_system_info_api;
        break;
    default:
        return FWK_E_PARAM;
    }
    return FWK_SUCCESS;
}

在模块的源文件中定义 API 的指针，用于提供 API 的地址。

static struct mod_system_info_get_info_api get_system_info_api = {
    .get_system_info = system_info_get_system_info,
};

实现需要提供的 API 函数。

static int system_info_get_system_info(const struct mod_system_info **sys_info)
{
    *sys_info = &system_info;
    return FWK_SUCCESS;
}

以上就是大致的移植流程了。

Responsive Image

SCP-firmware 源码分析 - 源码编译以及模块初始化流程

Sat, 10 Aug 2024 15:42:13 +0800

编译源码

下载配置工具链

访问ARM 官网下载工具链下载自己系统的版本的工具链。如果你也是 x86_64 的 Linux 系统，直接点击该链接下载 arm-gnu-toolchain-13.3

解压工具链：

xz -d arm-gnu-toolchain-13.3.rel1-x86_64-aarch64-none-linux-gnu.tar.xz
tar -xvf arm-gnu-toolchain-13.3.rel1-x86_64-aarch64-none-linux-gnu.tar

将工具链路径添加到环境变量中。

编译源码

源码使用 CMake 进行编译，CMake 版本需要 3.18.4 以上。如果你是 Ubuntu 20.04，直接安装即可。

sudo apt install cmake

如果你是 Ubuntu 18.04，需要升级 CMAKE。可以通过下面的方式下载源码编译安装 CMAKE。

wget https://github.com/Kitware/CMake/releases/download/v3.22.0/cmake-3.22.0-linux-x86_64.tar.gz
tar -zxvf cmake-3.22.0-linux-x86_64.tar.gz
mv cmake-3.22.0-linux-x86_64 /usr/local/cmake
export PATH=/usr/local/cmake/bin:$PATH

源码编译：

make -f Makefile.cmake PRODUCT=totalcompute/tc2 MODE=debug firmware-scp_ramfw

源码编译成功后，会在build/tc2/GNU/debug/firmware-scp_ramfw/bin目录下生成二进制文件。具体编译参数，可以参考源码根目录下的user_guide文档。

初始化流程分析

Responsive Image

fwk_module_init 初始时，module_config_table 是在什么时候被初始化的？

module_config_table 无法在源码中直接搜索到，因为它是在编译过程中生成的，当你编译一次后，就会在 output/build/mpw/GNU/debug/firmware-scp_romfw/framework/src/fwk_module_list.c 找到这个变量。具体它是如何生成的，注意通过 framework/CMakeLists.txt 文件中的这段代码完成，我们逐行分析这段代码。

list(LENGTH SCP_MODULES SCP_MODULE_IDX_MAX)

获取模块列表的长度，保存在 SCP_MODULE_IDX_MAX 变量中。在每个 Firmware.cmake 文件中，都会有一个 SCP_MODULES 变量，这个变量保存了该产品所包含的模块。

# product/juno/scp_romfw/Firmware.cmake
list(APPEND SCP_MODULES "test")
list(APPEND SCP_MODULES "uart")

当前我们加入了两个模块，所以 SCP_MODULE_IDX_MAX 的值为 2。

foreach(idx RANGE ${SCP_MODULE_IDX_MAX})
    if(idx EQUAL SCP_MODULE_IDX_MAX)
        string(APPEND SCP_MODULE_IDX_GEN "    FWK_MODULE_IDX_COUNT = ${idx},\n")

        break()
    endif()

遍历模块列表，生成模块索引的定义，如下：

enum fwk_module_idx {
    FWK_MODULE_IDX_COUNT = 0,
};

    list(GET SCP_MODULES ${idx} SCP_MODULE)

将 SCP_MODULES 列表中索引为 idx 的元素赋值给变量 SCP_MODULE，以便在后续的代码中使用。当前 idx 为 0，所以 SCP_MODULE 为 test。

    string(MAKE_C_IDENTIFIER ${SCP_MODULE} SCP_MODULE)
    string(TOUPPER ${SCP_MODULE} SCP_MODULE_UPPER)

将 SCP_MODULE 转换为 C 标识符。将 SCP_MODULE 转为大写并保存在 SCP_MODULE_UPPER 中，即 SCP_MODULE_UPPER="TEST"

    string(APPEND SCP_MODULE_IDX_GEN "    FWK_MODULE_IDX_${SCP_MODULE_UPPER} = ${idx},\n")
    string(APPEND SCP_MODULE_ID_INIT_GEN "#define FWK_MODULE_ID_${SCP_MODULE_UPPER}_INIT FWK_ID_MODULE_INIT(FWK_MODULE_IDX_${SCP_MODULE_UPPER})\n")
    string(APPEND SCP_MODULE_ID_GEN "#define FWK_MODULE_ID_${SCP_MODULE_UPPER} FWK_ID_MODULE(FWK_MODULE_IDX_${SCP_MODULE_UPPER})\n")
    string(APPEND SCP_MODULE_ID_CONST_GEN "static const fwk_id_t fwk_module_id_${SCP_MODULE} = FWK_MODULE_ID_${SCP_MODULE_UPPER}_INIT;\n")
    string(APPEND SCP_MODULE_EXTERN_GEN "extern const struct fwk_module module_${SCP_MODULE};\n")
    string(APPEND SCP_MODULE_EXTERN_CONFIG_GEN "extern const struct fwk_module_config config_${SCP_MODULE};\n")
    string(APPEND SCP_MODULE_GEN "    &module_${SCP_MODULE},\n")
    string(APPEND SCP_MODULE_CONFIG_GEN "    &config_${SCP_MODULE},\n")

进行一些宏替换，替换后的结果如下：

SCP_MODULE_IDX_GEN: "   FWK_MODULE_IDX_TEST = 0,"
SCP_MODULE_ID_INIT_GEN: "#define FWK_MODULE_ID_TEST_INIT FWK_ID_MODULE_INIT(FWK_MODULE_IDX_TEST)"
SCP_MODULE_ID_GEN: "#define FWK_MODULE_ID_TEST FWK_ID_MODULE(FWK_MODULE_IDX_TEST)"
SCP_MODULE_ID_CONST_GEN: "static const fwk_id_t fwk_module_id_test = FWK_MODULE_ID_TEST_INIT;"
SCP_MODULE_EXTERN_GEN: "extern const struct fwk_module module_test;"
SCP_MODULE_EXTERN_CONFIG_GEN: "extern const struct fwk_module_config config_test;"
SCP_MODULE_GEN: "&module_test,"
SCP_MODULE_CONFIG_GEN: "&config_test,"

    target_compile_definitions(framework
                               PUBLIC "BUILD_HAS_MOD_${SCP_MODULE_UPPER}=1")

将 BUILD_HAS_MOD_TEST 定义为 1，以便在后续的代码中使用。

在源码文件中有两个模板文件，分别为 fwk_module_list.c.in 和 fwk_module_idx.h.in，这两个文件中包含了一些宏定义，这些宏定义在编译过程中会被替换为上面生成的宏定义。

#include <stddef.h>

@SCP_MODULE_EXTERN_GEN@

const struct fwk_module *module_table[FWK_MODULE_IDX_COUNT] = {
@SCP_MODULE_GEN@
};

@SCP_MODULE_EXTERN_CONFIG_GEN@

const struct fwk_module_config *module_config_table[FWK_MODULE_IDX_COUNT] = {
@SCP_MODULE_CONFIG_GEN@
};

#include <fwk_id.h>

@SCP_MODULE_ID_INIT_GEN@
@SCP_MODULE_ID_GEN@

enum fwk_module_idx {
@SCP_MODULE_IDX_GEN@
};

@SCP_MODULE_ID_CONST_GEN@

在编译过程中就会生成下面两个文件，当使用module_config_table时，就会引用这两个文件，找到对应的配置。

// build/mpw/GNU/debug/firmware-scp_romfw/framework/include/fwk_module_idx.h
#define FWK_MODULE_ID_TEST_INIT FWK_ID_MODULE_INIT(FWK_MODULE_IDX_TEST)
#define FWK_MODULE_ID_UART_INIT FWK_ID_MODULE_INIT(FWK_MODULE_IDX_UART)


#define FWK_MODULE_ID_TEST FWK_ID_MODULE(FWK_MODULE_IDX_TEST)
#define FWK_MODULE_ID_UART FWK_ID_MODULE(FWK_MODULE_IDX_UART)


enum fwk_module_idx {
    FWK_MODULE_IDX_TEST = 0,
    FWK_MODULE_IDX_UART = 1,
    FWK_MODULE_IDX_COUNT = 2,

};

static const fwk_id_t fwk_module_id_test = FWK_MODULE_ID_TEST_INIT;
static const fwk_id_t fwk_module_id_uart = FWK_MODULE_ID_UART_INIT;

// build/mpw/GNU/debug/firmware-scp_romfw/framework/src/fwk_module_list.c
extern const struct fwk_module module_test;
extern const struct fwk_module module_uart;


const struct fwk_module *module_table[FWK_MODULE_IDX_COUNT] = {
    &module_test,
    &module_uart,

};

extern const struct fwk_module_config config_test;
extern const struct fwk_module_config config_uart;


const struct fwk_module_config *module_config_table[FWK_MODULE_IDX_COUNT] = {
    &config_test,
    &config_uart,
};

如何确定各个模块在初始化过程中的执行顺序？

在每个产品目录 mscp/product/juno/scp_romfw/Firmware.cmake 中，都会有一个 Firmware.cmake 文件，这个文件中会包含该产品所包含的模块：

list(APPEND SCP_MODULES "juno-ppu")
list(APPEND SCP_MODULES "juno-rom")
list(APPEND SCP_MODULES "gtimer")
list(APPEND SCP_MODULES "sds")
list(APPEND SCP_MODULES "bootloader")
list(APPEND SCP_MODULES "juno-soc-clock")

编译后会在 output 文件夹中生成fwk_module_idx.h文件，这个文件中会包含所有模块的索引，如下：

Responsive Image