嵌入式Linux驱动和固件有何区别？供应商是如何用固件压缩成本的？

ゝ一纸荒年。 2022-06-03 10:23 113阅读 0赞

作为一个驱动开发者, 你可能发现你面对一个设备必须在它能支持工作前下载固件到它里面. 硬件市场的许多地方的竞争是如此得强烈, 以至于甚至一点用作设备控制固件的 EEPROM 的成本制造商都不愿意花费. 因此固件发布在随硬件一起的一张 CD 上, 并且操作系统负责传送固件到设备自身.

硬件越来越复杂，硬件的许多功能使用了程序实现，与直接硬件实现相比，固件拥有处理复杂事物的灵活性和便于升级、维护等优点。固件（firmware）就是这样的一段在设备硬件自身中执行的程序，通过固件标准驱动程序才能实现特定机器的操作，如：光驱、刻录机等都有内部的固件。

固件一般存放在设备上的flash存储器中，但出于成本和灵活性考虑，许多设备都将固件的映像(image)以文件的形式存放在硬盘中，设备驱动程序初始化时再装载到设备内部的存储器中。这样，方便了固件的升级，并省略了设备的flash存储器。

一、驱动和固件的区别

从计算机领域来说，驱动和固件从来没有过明确的定义，就好像今天我们说内存，大部分人用来表示SDRAM，但也有人把Android里的“固化的Flash/Storage"称为“内存”，你不能说这样说就错了，因为这确实是一种“内部存储”。

但在Linux Kernel中，Driver和Firmware是有明确含义的.

1、驱动

Driver是控制被操作系统管理的外部设备（Device）的代码段。很多时候Driver会被实现为LKM，但这不是必要条件。driver通过driver\_register()注册到总线(bus\_type）上，代表系统具备了驱动某种设备（device）的能力。当某个device被注册到同样的总线的时候（通常是总线枚举的时候发现了这个设备），总线驱动会对driver和device会通过一定的策略进行binding（即进行匹配），如果Binding成功，总线驱动会调用driver的probe()函数，把设备的信息（例如端口，中断号等）传递给驱动，驱动就可以对真实的物理部件进行初始化，并把对该设备的控制接口注册到Linux的其他子系统上（例如字符设备，v4l2子系统等）。这样操作系统的其他部分就可以通过这些通用的接口来访问设备了。

2、固件

Firmware，是表示运行在非“控制处理器”（指不直接运行操作系统的处理器，例如外设中的处理器，或者被用于bare metal的主处理器的其中一些核)中的程序。这些程序很多时候使用和操作系统所运行的处理器完全不同的指令集。这些程序以二进制形式存在于Linux内核的源代码树中，生成目标系统的时候，通常拷贝在/lib/firmware目录下。当driver对device进行初始化的时候，通过request\_firmware()等接口，在一个用户态helper程序的帮助下，可以把指定的firmware加载到内存中，由驱动传输到指定的设备上。

所以，总的来说，其实driver和firmware没有什么直接的关系，但firmware通常由驱动去加载。我们讨论的那个OS，一般不需要理解firmware是什么，只是把它当做数据。firmware是什么，只有使用这些数据的那个设备才知道。好比你用一个电话，电话中有一个软件，这个软件你完全不关心如何工作的，你换这个软件的时候，就可以叫这个软件是“固件”，但如果你用了一个智能手机，你要细细关系什么是上面的应用程序，Android平台，插件之类的细节内容，你可能就不叫这个东西叫“固件”了。

如何解决固件问题呢？你可能想解决固件问题使用这样的一个声明:

static char my\_firmware\[\] = \{ 0x34, 0x78, 0xa4, ... \};

但是, 这个方法几乎肯定是一个错误. 将固件编码到一个驱动扩大了驱动的代码, 使固件升级困难, 并且非常可能产生许可问题. 供应商不可能已经发布固件映象在 GPL 之下, 因此和 GPL-许可的代码混合常常是一个错误. 为此, 包含内嵌固件的驱动不可能被接受到主流内核或者被 Linux 发布者包含.

二、内核固件接口

正确的方法是当你需要它时从用户空间获取它. 但是, 请抵制试图从内核空间直接打开包含固件的文件的诱惑; 那是一个易出错的操作, 并且它安放了策略(以一个文件名的形式)到内核. 相反, 正确的方法时使用固件接口, 它就是为此而创建的:

\[cpp\] view plain copy

1. \#include <linux/firmware.h>

3. int request\_firmware(const struct firmware \*\*fw, char \*name, struct device \*device);

函数request\_firmware向用户空间请求提供一个名为name固件映像文件并等待完成。参数device为固件装载的设备。文件内容存入request\_firmware 返回，如果固件请求成功，返回0。该函数从用户空间得到的数据未做任何检查，用户在编写驱动程序时，应对固件映像做数据安全检查，检查方向由设备固件提供商确定，通常有检查标识符、校验和等方法。

调用 request\_firmware 要求用户空间定位并提供一个固件映象给内核; 我们一会儿看它如何工作的细节. name 应当标识需要的固件; 正常的用法是供应者提供的固件文件名. 某些象 my\_firmware.bin 的名子是典型的. 如果固件被成功加载, 返回值是 0(负责常用的错误码被返回), 并且 fw 参数指向一个这些结构:

\[cpp\] view plain copy

1. struct firmware \{

2.  size\_t size;

3.  u8 \*data;

4. \};

那个结构包含实际的固件, 它现在可被下载到设备中. 小心这个固件是来自用户空间的未被检查的数据; 你应当在发送它到硬件之前运用任何并且所有的你能够想到的检查来说服你自己它是正确的固件映象. 设备固件常常包含标识串, 校验和, 等等; 在信任数据前全部检查它们.

在你已经发送固件到设备前, 你应当释放 in-kernel 结构, 使用:

\[cpp\] view plain copy

1. void release\_firmware(struct firmware \*fw);

因为 request\_firmware 请求用户空间来帮忙, 它保证在返回前睡眠. 如果你的驱动当它必须请求固件时不在睡眠的位置, 异步的替代方法可能要使用:

\[cpp\] view plain copy

1. int request\_firmware\_nowait(struct module \*module,

2.        char \*name, struct device \*device, void \*context,

3.              void (\*cont)(const struct firmware \*fw, void \*context));

这里额外的参数是 moudle( 它将一直是 THIS\_MODULE), context (一个固件子系统不使用的私有数据指针), 和 cont. 如果都进行顺利, request\_firmware\_nowait 开始固件加载过程并且返回 0. 在将来某个时间, cont 将用加载的结果被调用. 如果由于某些原因固件加载失败, fw 是 NULL.

三、固件如何工作

固件子系统使用 sysfs 和热插拔机制. 当调用 request\_firmware, 一个新目录在 /sys/class/firmware 下使用你的驱动的名子被创建. 那个目录包含 3 个属性:

这个属性应当被加载固件的用户空间进程设置为 1. 当加载进程完成, 它应当设为 0. 写一个值 -1 到 loading 会中止固件加载进程.

data

data 是一个二进制的接收固件数据自身的属性. 在设置 loading 后, 用户空间进程应当写固件到这个属性.

device

这个属性是一个符号连接到 /sys/devices 下面的被关联入口项.

一旦创建了 sysfs 入口项, 内核为你的设备产生一个热插拔事件. 传递给热插拔处理者的环境包括一个变量 FIRMWARE, 它被设置为提供给 request\_firmware 的名子. 这个处理者应当定位固件文件, 并且拷贝它到内核使用提供的属性. 如果这个文件无法找到, 处理者应当设置 loading 属性为 -1.

如果一个固件请求在 10 秒内没有被服务, 内核就放弃并返回一个失败状态给驱动. 超时周期可通过 sysfs 属性 /sys/class/firmware/timeout 属性改变.

使用 request\_firmware 接口允许你随你的驱动发布设备固件. 当正确地集成到热插拔机制, 固件加载子系统允许设备简化工作"在盒子之外" 显然这是处理问题的最好方法.

但是, 请允许我们提出多一条警告: 设备固件没有制造商的许可不应当发布. 许多制造商会同意在合理的条款下许可它们的固件, 如果客气地请求; 一些其他的可能不何在. 无论如何, 在没有许可时拷贝和发布它们的固件是对版权法的破坏并且招致麻烦.

四、固件接口函数的使用方法

当驱动程序需要使用固件驱动时，在驱动程序的初始化化过程中需要加下如下的代码：

\[cpp\] view plain copy

1. if(request\_firmware(&fw\_entry, $FIRMWARE, device) == 0)  /\*从用户空间请求映像数据\*/

3. /\*将固件映像拷贝到硬件的存储器，拷贝函数由用户编写\*/

4. copy\_fw\_to\_device(fw\_entry->data, fw\_entry->size);

5. release(fw\_entry);

用户还需要在用户空间提供脚本通过文件系统sysfs中的文件data将固件映像文件读入到内核的缓冲区中。脚本样例列出如下：

\[cpp\] view plain copy

1. \#变量$DEVPATH（固件设备的路径）和$FIRMWARE（固件映像名）应已在环境变量中提供

3. HOTPLUG\_FW\_DIR=/usr/lib/hotplug/firmware/    \#固件映像文件所在目录

5. echo 1 > /sys/$DEVPATH/loading

6. cat $HOTPLUG\_FW\_DIR/$FIRMWARE > /sysfs/$DEVPATH/data

7. echo 0 > /sys/$DEVPATH/loading

五、固件请求函数request\_firmware

函数request\_firmware请求从用户空间拷贝固件映像文件到内核缓冲区。该函数的工作流程列出如下：

a -- 在文件系统sysfs中创建文件/sys/class/firmware/xxx/loading和data，"xxx"表示固件的名字，给文件loading和data附加读写函数，设置文件属性，文件loading表示开/关固件映像文件装载功能；文件data的写操作将映像文件的数据写入内核缓冲区，读操作从内核缓冲区读取数据。

b -- 将添加固件的uevent事件（即"add"）通过内核对象模型发送到用户空间。

c -- 用户空间管理uevent事件的后台进程udevd接收到事件后，查找udev规则文件，运行规则所定义的动作，与固件相关的规则列出如下：

\[cpp\] view plain copy

1. $ /etc/udev/rules.d/50-udev-default.rules

2. ……

3. \# firmware class requests

4. SUBSYSTEM=="firmware", ACTION=="add", RUN+="firmware.sh"

5. ……

从上述规则可以看出，固件添加事件将引起运行脚本firmware.sh。

d -- 脚本firmware.sh打开"装载"功能，同命令"cat 映像文件 > /sys/class/firmware/xxx/data"将映像文件数据写入到内核的缓冲区。

e -- 映像数据拷贝完成后，函数request\_firmware从文件系统/sysfs注销固件设备对应的目录"xxx"。如果请求成功，函数返回0。

f -- 用户就将内核缓冲区的固件映像数据拷贝到固件的内存中。然后，调用函数release\_firmware(fw\_entry)释放给固件映像分配的缓冲区。

函数request\_firmware列出如下（在drivers/base/firmware\_class.c中）：

\[cpp\] view plain copy

1. int request\_firmware(const struct firmware \*\*firmware\_p, const char \*name,

2.                  struct device \*device)

3. \{

4.         int uevent = 1;

5.         return \_request\_firmware(firmware\_p, name, device, uevent);

6. \}

8. static int \_request\_firmware(const struct firmware \*\*firmware\_p, const char \*name,

9.          struct device \*device, int uevent)

10. \{

11.     struct device \*f\_dev;

12.     struct firmware\_priv \*fw\_priv;

13.     struct firmware \*firmware;

14.     struct builtin\_fw \*builtin;

15.     int retval;

16.

17.     if (!firmware\_p)

18.         return -EINVAL;

19.

20.     \*firmware\_p = firmware = kzalloc(sizeof(\*firmware), GFP\_KERNEL);

21.     ……  //省略出错保护

22.

23.    /\*如果固件映像在内部\_\_start\_builtin\_fw指向的地址，拷贝数据到缓冲区\*/

24.     for (builtin = \_\_start\_builtin\_fw; builtin != \_\_end\_builtin\_fw;

25.          builtin++) \{

26.         if (strcmp(name, builtin->name))

27.             continue;

28.         dev\_info(device, "firmware: using built-in firmware %s\\n", name);  /\*打印信息\*/

29.         firmware->size = builtin->size;

30.         firmware->data = builtin->data;

31.         return 0;

32.     \}

33.     ……//省略打印信息

34.     /\*在文件系统sysfs建立xxx目录及文件\*/

35.     retval = fw\_setup\_device(firmware, &f\_dev, name, device, uevent);

36.     if (retval)

37.         goto error\_kfree\_fw;

38.

39.     fw\_priv = dev\_get\_drvdata(f\_dev);

40.

41.     if (uevent) \{

42.         if (loading\_timeout > 0) \{   /\*加载定时器\*/

43.             fw\_priv->timeout.expires = jiffies + loading\_timeout \* HZ;

44.             add\_timer(&fw\_priv->timeout);

45.         \}

46.

47.         kobject\_uevent(&f\_dev->kobj, KOBJ\_ADD);     /\*发送事件KOBJ\_ADD\*/

48.         wait\_for\_completion(&fw\_priv->completion);

49.         set\_bit(FW\_STATUS\_DONE, &fw\_priv->status);

50.         del\_timer\_sync(&fw\_priv->timeout);

51.     \} else

52.         wait\_for\_completion(&fw\_priv->completion);   /\*等待完成固件映像数据的装载\*/

53.

54.     mutex\_lock(&fw\_lock);

55.     /\*如果装载出错，释放缓冲区\*/

56.     if (!fw\_priv->fw->size || test\_bit(FW\_STATUS\_ABORT, &fw\_priv->status)) \{

57.         retval = -ENOENT;

58.         release\_firmware(fw\_priv->fw);

59.         \*firmware\_p = NULL;

60.     \}

61.     fw\_priv->fw = NULL;

62.     mutex\_unlock(&fw\_lock);

63.     device\_unregister(f\_dev);   /\*在文件系统sysfs注销xxx目录\*/

64.     goto out;

65.

66. error\_kfree\_fw:

67.     kfree(firmware);

68.     \*firmware\_p = NULL;

69. out:

70.     return retval;

71. \}

函数fw\_setup\_device在文件系统sysfs中创建固件设备的目录和文件，其列出如下：

\[cpp\] view plain copy

1. static int fw\_setup\_device(struct firmware \*fw, struct device \*\*dev\_p,

2.                const char \*fw\_name, struct device \*device,

3.                int uevent)

4. \{

5.     struct device \*f\_dev;

6.     struct firmware\_priv \*fw\_priv;

7.     int retval;

9.     \*dev\_p = NULL;

10.     retval = fw\_register\_device(&f\_dev, fw\_name, device);

11.     if (retval)

12.         goto out;

13.

14.     ……

15.     fw\_priv = dev\_get\_drvdata(f\_dev);  /\*从设备结构中得到私有数据结构\*/

16.

17.     fw\_priv->fw = fw;

18.     retval = sysfs\_create\_bin\_file(&f\_dev->kobj, &fw\_priv->attr\_data);  /\*在sysfs中创建可执行文件\*/

19.     ……  //省略出错保护

20.

21.     retval = device\_create\_file(f\_dev, &dev\_attr\_loading);   /\*在sysfs中创建一般文件\*/

22.     ……  //省略出错保护

23.

24.     if (uevent)

25.         f\_dev->uevent\_suppress = 0;

26.     \*dev\_p = f\_dev;

27.     goto out;

28.

29. error\_unreg:

30.     device\_unregister(f\_dev);

31. out:

32.     return retval;

33. \}

函数fw\_register\_device注册设备，在文件系统sysfs中创建固件设备对应的设备类，存放固件驱动程序私有数据。其列出如下：

\[cpp\] view plain copy

1. static int fw\_register\_device(struct device \*\*dev\_p, const char \*fw\_name,

2.                   struct device \*device)

3. \{

4.     int retval;

5.     struct firmware\_priv \*fw\_priv = kzalloc(sizeof(\*fw\_priv),

6.                         GFP\_KERNEL);

7.     struct device \*f\_dev = kzalloc(sizeof(\*f\_dev), GFP\_KERNEL);

9.     \*dev\_p = NULL;

10.

11.     …… //省略出错保护

12.     init\_completion(&fw\_priv->completion);    /\*初始化completion机制的等待队列\*/

13.     fw\_priv->attr\_data = firmware\_attr\_data\_tmpl;   /\*设置文件的属性结构\*/

14.     strlcpy(fw\_priv->fw\_id, fw\_name, FIRMWARE\_NAME\_MAX);

15.

16.     fw\_priv->timeout.function = firmware\_class\_timeout; /\*超时装载退出函数\*/

17.     fw\_priv->timeout.data = (u\_long) fw\_priv;

18.     init\_timer(&fw\_priv->timeout);    /\*初始化定时器\*/

19.

20.     fw\_setup\_device\_id(f\_dev, device);  /\*拷贝device ->bus\_id到f\_dev中\*/

21.     f\_dev->parent = device;

22.     f\_dev->class = &firmware\_class;    /\*设备类实例\*/

23.     dev\_set\_drvdata(f\_dev, fw\_priv);   /\*存放设备驱动的私有数据：f\_dev ->driver\_data = fw\_priv\*/

24.     f\_dev->uevent\_suppress = 1;

25.     retval = device\_register(f\_dev);

26.     if (retval) \{

27.         dev\_err(device, "%s: device\_register failed\\n", \_\_func\_\_);

28.         goto error\_kfree;

29.     \}

30.     \*dev\_p = f\_dev;

31.     return 0;

32.      ……  //省略了出错保护

33. \}

\[cpp\] view plain copy

1. /\*文件属性结构实例，设置文件系统sysfs中data文件的模式和读/写函数\*/

2. static struct bin\_attribute firmware\_attr\_data\_tmpl = \{

3.     .attr = \{.name = "data", .mode = 0644\},

4.     .size = 0,

5.     .read = firmware\_data\_read,    /\*从内核缓冲区读出数据\*/

6.     .write = firmware\_data\_write,   /\*用于将固件映像文件的数据写入到内核缓冲区\*/

7. \};

9. /\*设备类结构实例，含有发送uevent事件函数和释放设备的函数\*/

10. static struct class firmware\_class = \{

11.     .name       = "firmware",      /\*设备类的名字\*/

12.     .dev\_uevent = firmware\_uevent, /\*设备发送uevent事件的函数\*/

13.     .dev\_release    = fw\_dev\_release, /\*释放设备的函数\*/

14. \};

嵌入式Linux驱动和固件有何区别？供应商是如何用固件压缩成本的？

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关嵌入式linux驱动命令

相关如何更新嵌入式程序中的指令版本和CPU固件版本？

相关嵌入式Linux驱动篇

相关嵌入式Linux--驱动开发常用操作

相关固件分析

相关 [ 物联网篇 ] 34 - 嵌入式固件自动化编译/构建(Jenkins)

相关嵌入式Linux--LCD驱动

相关驱动与固件的区别

相关嵌入式Linux驱动和固件有何区别？供应商是如何用固件压缩成本的？

相关固件：BIOS和UEFI