weixin_40725706

这个屌丝很懒，什么也没留下！

热门标签

kernel 加载用户空间fw实现原理_firmware loader kernel inited userspace

作者：weixin_40725706 | 2024-08-10 20:20:39

踩

firmware loader kernel inited userspace

随着手机外围器件的集成度和复杂度越来越高，单纯的设置寄存器可能已经无法使得器件可以正常的工作。在一般情况下，需要将一个特定的fw下载到器件中，从而确保器件可以正常稳定的运行，比如：camera ois，camera actuator， TP等等。一般情况下，有以下三种方案：

直接将fw data转化为特定的数组，编码在驱动代码中。
将fw data烧录到一个分区中，需要的时候从分区中load进来。
将fw打包到某个镜像中，如vendor，system等等，需要的时候从用户空间中load到kernel空间中。
1
2
3

对于方案1，直接将其硬编码在驱动代码中，会造成kernel镜像size变大，有可能造成镜像超限，导致kernel启动失败；并且调试也不方便，每次修改fw都需要重新编译内核。

对于方案2，需要实现预留好空间，某些时候可能无法满足；并且一般重新烧录fw，一般机器需要进入特定的模式，不利于在线调试。

对于方案3，能够有效的避免前两种方案的不足，在驱动中应用比较广泛，也是本文叙述的主题。

下文主要从编程步骤出发，通过调用的接口来具体分析其中实现的机制。
一编程步骤

linux内核为方案3提供了完整的解决方案，驱动开发起来也相当的方便，具体的步骤如下：

在编译的时候，将fw打包到具体镜像中。对于android系统，可以将fw放在/etc/firmware, /vendor/firmware, /firmware/image这几个目录。当上层服务ueventd接收到kernel上报的请求fw的uevent事件，会依次搜索这几个目录，查找对应名称的fw，并通过节点data传递给kernel。
由于内核已经封装好了接口，驱动代码比较简单，具体如下：
1
2

#include<linux/firmware.h>
…
xxx_func() {
const struct firmware *fw=NULL;`
…
request_firmware(&fw, fw_name, dev);
…
release_firmware();
}

有上面的步骤可知，内核代码相当简洁，就可以完成load 用户空间的fw任务。当然kernel还为我们提供了其他接口，主要是提供了一些其他的特性，满足特定条件下load 用户空间的fw。例如，如果在原子上下文load fw，则只能用request_firmware_nowait()接口，该接口不会导致进程睡眠。但是所有的这些接口，其工作原理是一样，因此下文将以request_firmware()为入口分析load用户空间fw的原理。
二实现原理分析
2.1 相关结构体介绍

理解代码最好的入口是熟悉代码使用的数据结构，理解了代码使用的数据结构，就基本上可以对代码的实现原理有一个初步的认识。所以下面熟悉一下相关的数据结构。

firmware 结构体
1

路径:include/linux/firmware.h
struct firmware {
size_t size;
const u8 *data;
struct page **pages;

    /* firmware loader private fields */
    void *priv;
1
2

};

该结构体主要用于向驱动导出load 到内核的fw信息，成员含义如下：
size: firmware 数据的大小.
data: firmware数据.
pages: 指向fw data存储的物理页面。
priv: 私有数据指针.

builtin_fw 结构体
1

路径:include/linux/firmware.h
struct builtin_fw {
char *name;
void *data;
unsigned long size;
};

该结构主要用于描述编译到内核builtin_fw段的fw，成员含义如下：
name: firmware 数据的名称.
data: 指向firmware数据的指针.
size: firmware的大小.

firmware_buf结构体
1

路径:driver/base/firmware_class.c
struct firmware_buf {
struct kref ref;
struct list_head list;
struct completion completion;
struct firmware_cache *fwc;
unsigned long status;
void *data;
size_t size;
size_t allocated_size;
#ifdef CONFIG_FW_LOADER_USER_HELPER
bool is_paged_buf;
bool need_uevent;
struct page **pages;
int nr_pages;
int page_array_size;
struct list_head pending_list;
#endif
const char *fw_id;
};

该结构体主要用于存储fw data,以及一些控制状态等等. 部分重要的成员解释如下:
completion: 完成量,用于在load fw完成时, 唤醒等待的进程.
fwc: 指向全局的fw_cache, 该结构保存了已经load 的fw的相关信息.
status: 保存当前的状态.
data: 指向保存fw data的kernel虚拟地址.
size: fw 的大小.
pages: 指向存储fw data的物理页.
page_array_size: 分配的物理页的数目.
fw_id: fw 的名称.
2.2 实现原理分析

request_firmware()和request_firmware_nowait()等接口都是_request_firmware()的一个前端，仅仅只是传进的参数不一样而已，因此基于分析request_firmware()的实现来探讨其实现原理, request_firmware()如下：

路径:driver/base/firmware_class.c
int
request_firmware(const struct firmware **firmware_p, const char *name,
struct device *device)
{
int ret;

/* Need to pin this module until return */
__module_get(THIS_MODULE);
ret = _request_firmware(firmware_p, name, device, NULL, 0,
			FW_OPT_UEVENT | FW_OPT_FALLBACK);
module_put(THIS_MODULE);
return ret;
1
2
3
4
5
6

}

下面来看看_request_firmware()函数的实现：

路径:driver/base/firmware_class.c
static int
_request_firmware(const struct firmware **firmware_p, const char *name,
struct device *device, void buf, size_t size,
unsigned int opt_flags)
{
…
ret = _request_firmware_prepare(&fw, name, device, buf, size,
opt_flags);
if (ret <= 0) / error or already assigned */
goto out;

…

     ret = fw_get_filesystem_firmware(device, fw->priv);
     if (ret) {
             if (!(opt_flags & FW_OPT_NO_WARN))
                     dev_dbg(device,
                              "Firmware %s was not found in kernel paths. rc:%d\n",
                              name, ret);
             if (opt_flags & FW_OPT_USERHELPER) {
                     dev_err(device, "[%s]Falling back to user helper\n", __func__);
                     ret = fw_load_from_user_helper(fw, name, device,
                                                    opt_flags, timeout);
             }
     }
1
2
3
4
5
6
7
8
9
10
11
12

…
if (!ret)
ret = assign_firmware_buf(fw, device, opt_flags);
…
}

在该函数中，会依次从4个地方尝试load 相应的fw，具体如下：

从内核中相应的段中查找是否有符合要求的firmware.
从cache中查找是否有上次load相应的还没有换出firmware.
直接利用内核中文件接口中读取相应的firmware.
利用uevent接口load相应的firmware.
1
2
3
4

其中, 对于第1种和第2种情况是在_request_firmware_prepare()函数中完成的;第3种情况是在_request_firmware_prepare()函数中完成的; 第4种情况是在fw_load_from_user_helper()函数中完成的.

对于第1种情况, 其具体的实现在fw_get_builtin_firmware()函数中, 原理是通过遍历builtin_fw段的firmware, 并比较firmware的name是否相同, 如果相同, 表示匹配上,则将firmware的size和data赋值给驱动传过来的firmware结构体指针, request_firmware就完成load firmware功能, 具体如下:

路径:drivers/base/firmware_class.c
static int
_request_firmware_prepare(struct firmware **firmware_p, const char *name,
struct device *device, void *dbuf, size_t size,
unsigned int opt_flags)
{
…
*firmware_p = firmware = kzalloc(sizeof(*firmware), GFP_KERNEL);
if (!firmware) {
dev_err(device, “%s: kmalloc(struct firmware) failed\n”,
func);
return -ENOMEM;
}

    if (fw_get_builtin_firmware(firmware, name, dbuf, size)) {
            dev_dbg(device, "using built-in %s\n", name);
            return 0; /* assigned */
    }
1
2
3
4

…
}

路径:drivers/base/firmware_class.c
static bool fw_get_builtin_firmware(struct firmware *fw, const char *name,
void *buf, size_t size)
{
struct builtin_fw *b_fw;

    for (b_fw = __start_builtin_fw; b_fw != __end_builtin_fw; b_fw++) {
            if (strcmp(name, b_fw->name) == 0) {
                    fw->size = b_fw->size;
                    fw->data = b_fw->data;

                    if (buf && fw->size <= size)
                            memcpy(buf, fw->data, fw->size);
                    return true;
            }
    }

    return false;
1
2
3
4
5
6
7
8
9
10
11
12

}

对于第2种情况, 其具体的实现在fw_lookup_and_allocate_buf()函数中, 匹配原理和第1种情况相同,只不过查找实在全局变量fw_cache的链表上查找. fw_cache的 head链表上保存了以前load过的fw的信息,比如name, data, size等等. 其中在函数sync_cached_firmware_buf()中主要检查fw是否已经load到内核空间, 如果没有, 则等待, 否在就调用fw_set_page_data(), 将fw相关的信息赋值到驱动的firmware结构体指针, 具体如下:

路径:drivers/base/firmware_class.c
static int
_request_firmware_prepare(struct firmware **firmware_p, const char *name,
struct device *device, void *dbuf, size_t size,
unsigned int opt_flags)
{
…

    ret = fw_lookup_and_allocate_buf(name, &fw_cache, &buf, dbuf, size,
                                    opt_flags);

    /*
     * bind with 'buf' now to avoid warning in failure path
     * of requesting firmware.
     */
    firmware->priv = buf;

    if (ret > 0) {
            ret = sync_cached_firmware_buf(buf);
            if (!ret) {
                    fw_set_page_data(buf, firmware);
                    return 0; /* assigned */
            }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

…
}

路径:drivers/base/firmware_class.c
static int fw_lookup_and_allocate_buf(const char *fw_name,
struct firmware_cache *fwc,
struct firmware_buf **buf, void *dbuf,
size_t size, unsigned int opt_flags)
{
struct firmware_buf *tmp;

    spin_lock(&fwc->lock);
    if (!(opt_flags & FW_OPT_NOCACHE)) {
            tmp = __fw_lookup_buf(fw_name);
            if (tmp) {
                    kref_get(&tmp->ref);
                    spin_unlock(&fwc->lock);
                    *buf = tmp;
                    return 1;
            }
    }
1
2
3
4
5
6
7
8
9
10

…
}

对于第3种情况, 依据内核预先定义好的路径fw_path调用内核文件读写接口kernel_read_file_from_path load入相应的fw, 在fw_finish_direct_load()函数中做了一些load fw后的清理工作,比如设置完成标志等等.

路径:drivers/base/firmware_class.c
static int
fw_get_filesystem_firmware(struct device *device, struct firmware_buf *buf)
{
…

    for (i = 0; i < ARRAY_SIZE(fw_path); i++) {
            /* skip the unset customized path */
            if (!fw_path[i][0])
                    continue;

            len = snprintf(path, PATH_MAX, "%s/%s",
                           fw_path[i], buf->fw_id);
            if (len >= PATH_MAX) {
                    rc = -ENAMETOOLONG;
                    break;
            }
                                                                              
             buf->size = 0;
             rc = kernel_read_file_from_path(path, &buf->data, &size, msize,
                                             id);
             if (rc) {
                     if (rc == -ENOENT)
                             dev_dbg(device, "loading %s failed with error %d\n",
                                      path, rc);
                     else
                             dev_warn(device, "loading %s failed with error %d\n",
                                      path, rc);
                     continue;
             }
             dev_dbg(device, "direct-loading %s\n", buf->fw_id);
             buf->size = size;
             fw_finish_direct_load(device, buf);
             break;
     }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

…
}

fw_path具体的定义如下, 其中fw_path_para主要用于用户传递定制的路径.

static const char * const fw_path[] = {
fw_path_para,
“/data/vendor/vibrator”,
“/lib/firmware/updates/” UTS_RELEASE,
“/lib/firmware/updates”,
“/lib/firmware/” UTS_RELEASE,
“/lib/firmware”
};

当在前三种情况下无法找到对应的fw时,就会进入第4种情况进行查找, 其工作在函数为fw_load_from_user_helper()种实现, 具体如下:

static int fw_load_from_user_helper(struct firmware *firmware,
const char *name, struct device *device,
unsigned int opt_flags, long timeout)
{
struct firmware_priv *fw_priv;

    fw_priv = fw_create_instance(firmware, name, device, opt_flags);
    if (IS_ERR(fw_priv))
            return PTR_ERR(fw_priv);

    fw_priv->buf = firmware->priv;
    return _request_firmware_load(fw_priv, opt_flags, timeout);
1
2
3
4
5
6

}

在函数 fw_create_instance() 主要进行了一些设备的初始化工作, 如设备所属的class, groups等等. 具体如下:

static struct firmware_priv *
fw_create_instance(struct firmware *firmware, const char *fw_name,
struct device *device, unsigned int opt_flags)
{
struct firmware_priv *fw_priv;
struct device *f_dev;

    fw_priv = kzalloc(sizeof(*fw_priv), GFP_KERNEL);
    if (!fw_priv) {
            fw_priv = ERR_PTR(-ENOMEM);
            goto exit;
    }

    fw_priv->nowait = !!(opt_flags & FW_OPT_NOWAIT);
    fw_priv->fw = firmware;
    f_dev = &fw_priv->dev;

    device_initialize(f_dev);
    dev_set_name(f_dev, "%s", fw_name);
    f_dev->parent = device;
    f_dev->class = &firmware_class;
    f_dev->groups = fw_dev_attr_groups;
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

exit:
return fw_priv;
}

其中重点看一下 fw_dev_attr_groups属性集合, 由linux 设备驱动框架原理,当该设备加入到系统中时,会在该设备下生成两个节点data和loading, 后面讲到这两个节点的用处.

路径:driver/base/firmware_class.c
static const struct attribute_group *fw_dev_attr_groups[] = {
&fw_dev_attr_group,
NULL
};

static const struct attribute_group fw_dev_attr_group = {
.attrs = fw_dev_attrs,
.bin_attrs = fw_dev_bin_attrs,
};

static struct bin_attribute *fw_dev_bin_attrs[] = {
&firmware_attr_data,
NULL
};

static struct attribute *fw_dev_attrs[] = {
&dev_attr_loading.attr,
NULL
};

static struct bin_attribute firmware_attr_data = {
.attr = { .name = “data”, .mode = 0644 },
.size = 0,
.read = firmware_data_read,
.write = firmware_data_write,
};

static DEVICE_ATTR(loading, 0644, firmware_loading_show, firmware_loading_store);

在_request_firmware_load()函数中, 首先调用device_add()函数将设备注册到系统中, 接着调用kobject_uevent()函数向用户空间上报uevent事件, 最后调用wait_for_completion_killable_timeout()函数等待load fw完成.
loading节点写函数如下:

路径:driver/base/firmware_class.c
static ssize_t firmware_loading_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
…

     switch (loading) {
     case 1:
             /* discarding any previous partial load */
             if (!test_bit(FW_STATUS_DONE, &fw_buf->status)) {
                     for (i = 0; i < fw_buf->nr_pages; i++)
                             __free_page(fw_buf->pages[i]);
                     vfree(fw_buf->pages);
                     fw_buf->pages = NULL;
                     fw_buf->page_array_size = 0;
                     fw_buf->nr_pages = 0;
                     set_bit(FW_STATUS_LOADING, &fw_buf->status);
             }
             break;
     case 0:
             if (test_bit(FW_STATUS_LOADING, &fw_buf->status)) {
                     int rc;

                     set_bit(FW_STATUS_DONE, &fw_buf->status);
                     clear_bit(FW_STATUS_LOADING, &fw_buf->status);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

…
rc = fw_map_pages_buf(fw_buf);
…
complete_all(&fw_buf->completion);
break;
}
…
}
…
}

当应用程序将fw写入到data节点时, 如果buf->data已经映射到kernel虚拟地址空间,则调用firmware_rw_buf()直接将fw data copy到buf->data中; 如果buf->data为NULL, 则首先调用fw_realloc_buf()函数, 分配物理页, 然后调用firmware_rw()函数将fw data 拷贝到分配的物理页中.
loading节点写函数如下:

路径:driver/base/firmware_class.c
static ssize_t firmware_loading_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
…

     switch (loading) {
     case 1:
             /* discarding any previous partial load */
             if (!test_bit(FW_STATUS_DONE, &fw_buf->status)) {
                     for (i = 0; i < fw_buf->nr_pages; i++)
                             __free_page(fw_buf->pages[i]);
                     vfree(fw_buf->pages);
                     fw_buf->pages = NULL;
                     fw_buf->page_array_size = 0;
                     fw_buf->nr_pages = 0;
                     set_bit(FW_STATUS_LOADING, &fw_buf->status);
             }
             break;
     case 0:
             if (test_bit(FW_STATUS_LOADING, &fw_buf->status)) {
                     int rc;

                     set_bit(FW_STATUS_DONE, &fw_buf->status);
                     clear_bit(FW_STATUS_LOADING, &fw_buf->status);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

…
rc = fw_map_pages_buf(fw_buf);
…
complete_all(&fw_buf->completion);
break;
}
…
}
…
}

当应用程序向该节点写入1时, 如果status的状态不是FW_STATUS_DONE, 则进行一些初始化工作, 为后续load fw做准备工作, 并将status状态设备为FW_STATUS_LOADING.

当应用程序向该节点写入0时, 设置status的状态为FW_STATUS_DONE, 并调用fw_map_pages_buf函数将保存fw data的pages映射到kernel虚拟地址空间, 变为内核可操作的数据. 然后调用complete_all 唤醒等待的进程. 进程唤醒后,会执行assign_firmware_buf()函数, 将保存在firmware_buf结构中fw信息赋值给request_firmware()的第一个参数, 从而完成fw 的load工作.

路径:driver/base/firmware_class.c
static int assign_firmware_buf(struct firmware *fw, struct device device,
unsigned int opt_flags)
{
…
/ pass the pages buffer to driver at the last minute */
fw_set_page_data(buf, fw);
…
}
static void fw_set_page_data(struct firmware_buf *buf, struct firmware *fw)
{
fw->priv = buf;
#ifdef CONFIG_FW_LOADER_USER_HELPER
fw->pages = buf->pages;
#endif
fw->size = buf->size;
fw->data = buf->data;

    pr_debug("%s: fw-%s buf=%p data=%p size=%u\n",
             __func__, buf->fw_id, buf, buf->data,
             (unsigned int)buf->size);
1
2
3

}

三结束语

本文以request_firmware()为入口详细探讨了内核load fw的实现原理，以期大家对这个模块有一个全面的认识。由于自己相关知识的局限，可能有些许错误，欢迎大家批评指正，谢谢！
————————————————
版权声明：本文为CSDN博主「Fundyqds」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/fundyqds/article/details/84324106

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/weixin_40725706/article/detail/960219