linux设备驱动归纳总结（八）：1.总线、设备和驱动

悠悠 2022-03-19 03:54 426阅读 0赞

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

这几天一直在看设备模型，内核的代码看得我越来越沮丧，特别是kboject、kset和ktype之间的关系。但是，设备模型的归纳我打算先跳过这几个重要结构体，先介绍总线、设备和驱动——设备管理的相关内容。先介绍如何使用，有机会介绍大概的原理。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

一、sysfs文件系统

设备模型是2.6内核新引入的特征。设备模型提供了一个独立的机制专门来表示设备，并描述其在系统中的拓扑结构。

在2.4内核中，设备的信息放在/proc中。

而在2.6内核，内核把设备相关的信息归类在新增加sysfs文件系统，并将它挂载到/sys目录中，把设备信息归类的同时，让用户可以通过用户空间访问。

接下来简单介绍一些sys中的目录：

block：用于管理块设备，系统中的每一个块设备会在该目录下对应一个子目录。

bus：用于管理总线，没注册一条总线，在该目录下有一个对应的子目录。

其中，每个总线子目录下会有两个子目录：devices和drivers。

devices包含里系统中所有属于该总线的的设备。

drivers包含里系统中所有属于该总线的的驱动。

class：将系统中的设备按功能分类。

devices：该目录提供了系统中设备拓扑结构图。

dev：该目录已注册的设备节点的视图。

kernel：内核中的相关参数。

module：内核中的模块信息。

fireware：内核中的固件信息。

Fs：描述内核中的文件系统。

上面的目录，接下来的章节会常常提起bus和device。

再说说这些目录,来个简单的命令：

root@xiaobai-laptop:/sys\# ll class/net/eth0

lrwxrwxrwx 1 root root 0 2011-01-31 10:11 class/net/eth0 -> ../../devices/pci0000:00/0000:00:1c.5/0000:86:00.0/net/eth0/

上面的命令也可以看到class/net/eth0的路径其实就是devices目录中一个网卡设备的软连接。

贴个书上的图：

[![25014876_1296562467cFAa.png][]][25014876_1296562467cFAa.png]

由上面两个例子看到，sys中的其他目录都是将devvice目录下的数据加以转换加工而得。上面的图中，将use设备归类到bus总线上，又把它归类到class。正是在sys中有很多这样的结构，内核就有一个完整而且复杂的拓扑结构图。

而维护这些关系的结构体就包括kobject、kset、ktype和subsystem等数据结构，不过这里就先不介绍。

通过设备模型，内核就能实现多种不同的任务，如：

1、电源管理和系统关机。

2、与用户空间通信。这个就比较容易理解，sys目录向用户展示了设备模型的结构图。

3、热插拔设备。大概意思就是，当设备插入后，内核会根据插入的设备安装驱动，设备拔出后，内核又会自动卸载驱动。

4、设备类型。将设备归类。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

在接下来的内容会简单介绍总线、设备和驱动程序的概念和函数调用，以下的函数我将模拟创建一条ubs总线，一个usb设备和一个usb驱动。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

二、总线

总线是处理器和设备之间的通道，在设备模型中，所有的设备都通过总线相连，以总线来管理设备和驱动函数。总线有bus\_type结构表示。

/\*linux/device.h\*/

51 struct bus\_type \{

52 const char \*name;

53 struct bus\_attribute \*bus\_attrs;

54 struct device\_attribute \*dev\_attrs;

55 struct driver\_attribute \*drv\_attrs;

56

57 int (\*match)(struct device \*dev, struct device\_driver \*drv);

58 int (\*uevent)(struct device \*dev, struct kobj\_uevent\_env \*env);

59 int (\*probe)(struct device \*dev);

60 int (\*remove)(struct device \*dev);

61 void (\*shutdown)(struct device \*dev);

62

63 int (\*suspend)(struct device \*dev, pm\_message\_t state);

64 int (\*suspend\_late)(struct device \*dev, pm\_message\_t state);

65 int (\*resume\_early)(struct device \*dev);

66 int (\*resume)(struct device \*dev);

67

68 struct dev\_pm\_ops \*pm;

69

70 struct bus\_type\_private \*p;

71 \};

红色部分是以后将会介绍的成员，其中name是总线的名字， bus\_attrs是总线的属性，那些函数指针的操作总线的方法，在这一章节先不讲总线的方法。

总线的注册和删除：

总线的注册有两个步骤：

1、定义一个bus\_type结构体，并设置好需要设置的结构体成员。

2、调用函数bus\_register注册总线。函数原型如下：

/\*drivers/base/bus.c\*/

865 int bus\_register(struct bus\_type \*bus)

该调用有可能失败，所以必须检查它的返回值，如果注册成功，会在/sys/bus下看到指定名字的总线。

总线删除时调用：

/\*drivers/base/bus.c\*/

946 void bus\_unregister(struct bus\_type \*bus)

接下来贴个函数：

/\*8th\_devModule\_1/1st/bus.c\*/

1 \#include <linux/module.h>

2 \#include <linux/init.h>

3

4 \#include <linux/device.h>

5

6 struct bus\_type usb\_bus = \{

7 .name = "usb", //定义总线的名字为usb，注册成功后将在/sys/bus目录下看到

8 \}; //目录usb，如果你的系统已经有usb总线，那你就要换个名字。

9

10 static int \_\_init usb\_bus\_init(void)

11 \{

12 int ret;

13 /\*总线注册，必须检测返回值\*/

14 ret = bus\_register(&usb\_bus);

15 if(ret)\{

16 printk("bus register failed!\\n");

17 return ret;

18 \}

19

20 printk("usb bus init\\n");

21 return 0;

22 \}

23

24 static void \_\_exit usb\_bus\_exit(void)

25 \{

26 bus\_unregister(&usb\_bus);

27 printk("usb bus bye!\\n");

28 \}

29

30 module\_init(usb\_bus\_init);

31 module\_exit(usb\_bus\_exit);

32

33 MODULE\_LICENSE("GPL");

上面的函数可以看到，我仅仅定义了总线的名字为usb，其他的都没有做。看看效果：

\[root: 1st\]\# insmod bus.ko

usb bus init

\[root: 1st\]\# ls /sys/bus/usb/ //sys/bus目录下多了一个usb的目录，但是里面的东西都是空的，

devices drivers\_autoprobe uevent //因为我仅仅设置了总线的名字

drivers drivers\_probe

总线属性添加和删除：

个人理解，设置总线的属性后，会在对应的总线目录下增加了一个新的文件，通过对该文件的读写访问，触发相应的函数操作，从而实现/sys/的文件接口与内核设备模型的数据交互。

/\*linux/sysfs.h\*/

28 struct attribute \{

29 const char \*name; //设定该文件的名字

30 struct module \*owner; //设定该文件的属主

31 mode\_t mode; //设定该文件的文件操作权限

32 \};

/\*linux/device.h\*/

38 struct bus\_attribute \{

39 struct attribute attr;

40 ssize\_t (\*show)(struct bus\_type \*bus, char \*buf);

41 ssize\_t (\*store)(struct bus\_type \*bus, const char \*buf, size\_t count);

42 \};

bus\_attribute中有两个函数指针，show和store。

当访问总线目录中的name文件时，就会触发show函数，一般会将指定的信息存放到数组buf，并传到用户空间显示。

当修改总线目录中的name文件是，就会触发stroe函数，一般会将从用户空间传来的buf指针存放的count个字节内容存放到内核中。

由此可以看到，通过这样的文件，就能实现sys目录下的文件与内核设备模型之间的数据交互。

设置总线属性有两个步骤：

1、创建并初始化bus\_attribute结构，使用宏BUS\_ATTR

BUS\_ATTR(\_name, \_mode, \_show, \_store)

该宏会定义一个名叫bus\_attr\_\_name（红色部分是固定的）的bus\_attibute的结构，并且成员name设置为\_name，文件权限mode设置为\_mode，两个函数调用分别人show和store。

2、将bus\_attibute添加到指定的总线上，使用以下调用：

/\*/drivers/base/bus.c\*/

123 int bus\_create\_file(struct bus\_type \*bus, struct bus\_attribute \*attr)

该函数失败时返回错误号。

一旦调用该函数，会就在指定bus总线的目录下新建一个名叫\_name的文件，权限为\_mode，当访问和修改该文件是会分别调用show和store函数调用。

如果不需要该属性时，使用以下函数删除：

/\*/drivers/base/bus.c\*/

135 void bus\_remove\_file(struct bus\_type \*bus, struct bus\_attribute \*attr)

说了这么多，马上来个程序：

/\*8th\_devModule\_1/2nd/bus.c\*/

1 \#include <linux/module.h>

2 \#include <linux/init.h>

3

4 \#include <linux/device.h>

5

6 \#define VER\_SIZE 100

7

8 struct bus\_type usb\_bus = \{

9 .name = "usb",

10 \};

11

12 char Version\[VER\_SIZE\] = "xiaobai V1.0";

13

14 static ssize\_t show\_bus\_version(struct bus\_type \*bus, char \*buf)

15 \{

16 return snprintf(buf, VER\_SIZE, "%s\\n", Version);

17 \}

18 static ssize\_t store\_bus\_version(struct bus\_type \*bus, const char \*buf, size\_t count)

19 \{

20 return snprintf(Version, VER\_SIZE, "%s", buf);

21 \}

22 /\*该宏会定义一个名叫bus\_attr\_version的bus\_attribute的结构，并且成员name设置为

23 \* version，文件权限mode设置为S\_IRUGO|S\_IWUGO，并设置show函数为

24 \* show\_bus\_version，stror 函数为stroe\_bus\_version\*/

25 static BUS\_ATTR(version, S\_IRUGO|S\_IWUGO, show\_bus\_version, store\_bus\_version);

26

27 static int \_\_init usb\_bus\_init(void)

28 \{

29 int ret;

30

31 /\*总线注册\*/

32 ret = bus\_register(&usb\_bus);

33 if(ret)\{

34 printk("bus register failed!\\n");

35 goto err1;

36 \}

37 /\*为总线添加属性，调用成功后在/sys/bus/usb目录下有一个version的文件，权限为

38 \* S\_IRUGO|S\_IWUGO，查看该文件时会调用函数show\_bus\_version,修改时调用store。\*/

39 ret = bus\_create\_file(&usb\_bus, &bus\_attr\_version);

40 if(ret)\{

41 printk("bus creat file failed!\\n");

42 goto err2;

43 \}

44 printk("usb bus init\\n");

45 return 0;

46

47 err2:

48 bus\_unregister(&usb\_bus);

49 err1:

50 return ret;

51 \}

52

53 static void \_\_exit usb\_bus\_exit(void)

54 \{

55 bus\_remove\_file(&usb\_bus, &bus\_attr\_version); //不调用这个也可以的，删除总线时会删除

56 bus\_unregister(&usb\_bus);

57 printk("usb bus bye!\\n");

58 \}

验证一下：

\[root: 2nd\]\# insmod bus.ko

usb bus init

\[root: 2nd\]\# ls /sys/bus/usb/

devices drivers\_autoprobe uevent

drivers drivers\_probe version //多了一个version文件

\[root: 2nd\]\# ls -l /sys/bus/usb/version //文件的权限的可读可写（S\_IRUGO|S\_IWUGO）

\-rw-rw-rw- 1 root root 4096 Oct 27 23:46 /sys/bus/usb/version

\[root: 2nd\]\# cat /sys/bus/usb/version //读文件时触发show函数

xiaobai V1.0

\[root: 2nd\]\# echo "haha"> /sys/bus/usb/version //写文件是触发store函数

\[root: 2nd\]\# cat /sys/bus/usb/version

haha

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

三、设备

在最底层，linux系统中每个设备都用一个device结构的表示，如下，我省略掉部分成员：

/\*linux/device.h\*/

369 struct device \{

370 struct klist klist\_children;

371 struct klist\_node knode\_parent; /\* node in sibling list \*/

372 struct klist\_node knode\_driver;

373 struct klist\_node knode\_bus;

374 struct device \*parent; //指定该设备的父设备，如果不指定(NULL)，注册后的设备目录

375 ///在sys/device下

376 struct kobject kobj;

377 char bus\_id\[BUS\_ID\_SIZE\]; /\* position on parent bus \*/ //在总线生识别设备的字符串，

385 //同时也是设备注册后的目录名字。

386 struct bus\_type \*bus; /\* type of bus device is on \*/ //指定该设备连接的总线

387 struct device\_driver \*driver; /\* which driver has allocated this

388 device \*/ //管理该设备的驱动函数

389 void \*driver\_data; /\* data private to the driver \*/ //驱动程序的私有数据

392 struct dev\_pm\_info power;

422 void (\*release)(struct device \*dev); //当给设备的最后一个引用被删除时，调用该函数

423 \};

在注册一个完整的device结构前，至少定义parrent、bus\_id、bus和release成员。但我接下来的程序仅仅定义了bus\_id（指定目录的名字）、bus（对应的总线，不加也行）和release（这是必须的，不然卸载模块时会出错，不信自己试试）。

设备注册和注销：

与总线的注册一样：

1、定义结构体device。

2、调用注册函数：

int device\_register(struct device \*dev)

函数失败返回非零，需要判断返回值来检查注册是否成功。

设备注销函数：

void device\_unregister(struct device \*dev)

设备属性：

这个也是和总线属性差不多，不细讲：

设备相关的结构体和总线的类似，处理指定文件属性为，还定义了show和store两个函数。

/\*linux/device.h\*/

300 struct device\_attribute \{

301 struct attribute attr;

302 ssize\_t (\*show)(struct device \*dev, struct device\_attribute \*attr,

303 char \*buf);

304 ssize\_t (\*store)(struct device \*dev, struct device\_attribute \*attr,

305 const char \*buf, size\_t count);

306 \};

设置设备属性有两个步骤：

1、创建并初始化device\_attribute结构，使用宏DEVICE\_ATTR

DEVICE\_ATTR(\_name, \_mode, \_show, \_store)

该宏会定义一个名叫dev\_attr\_\_name（红色部分是固定的）的device\_attibute的结构，并且成员name设置为\_name，文件权限mode设置为\_mode，两个函数调用分别人show和store。

2、将device\_attibute添加到指定的设备上，使用以下调用：

/\*drivers/base/core.c\*/

430 int device\_create\_file(struct device \*dev, struct device\_attribute \*attr)

该函数失败时返回错误号。

一旦调用该函数，会就在指定dev设备的目录下新建一个名叫\_name的文件，权限为\_mode，当访问和修改该文件是会分别调用show和store函数调用。

如果不需要该属性时，使用以下函数删除：

/\*drivers/base/core.c\*/

443 void device\_remove\_file(struct device \*dev, struct device\_attribute \*attr)

讲了这么多，来个函数，和总线那个函数差不多，具体功能就是新建了一个执行名字(usb\_device)的的设备目录，并且里面有一个属性文件version。

/\*8th\_devModule\_1/3rd/device.c\*/

1 \#include <linux/module.h>

2 \#include <linux/init.h>

3

4 \#include <linux/device.h>

5

6 \#define VER\_SIZE 100

7

8 extern struct bus\_type usb\_bus;

9

10 void usb\_dev\_release(struct device \*dev)

11 \{

12 printk("<kernel> release\\n");

13 \}

14

15 struct device usb\_device = \{

16 .bus\_id = "usb\_device",

17 .bus = &usb\_bus, //指定该设备的总线，这样会在sys/bus/usb/device目录下有一个软连接

18 .release = usb\_dev\_release, //必须要都有release函数，不然卸载时会出错

19 \};

11

12 char Version\[VER\_SIZE\] = "xiaobai V1.0";

13

14 static ssize\_t show\_device\_version(struct device \*dev,

15 struct device\_attribute \*attr, char \*buf)

16 \{

17 return snprintf(buf, VER\_SIZE, "%s\\n", Version);

18 \}

19 static ssize\_t store\_device\_version(struct device \*dev,

20 struct device\_attribute \*attr, const char \*buf, size\_t count)

21 \{

22 return snprintf(Version, VER\_SIZE, "%s", buf);

23 \}

24 /\*该宏会定义一个名叫dev\_attr\_version的device\_attribute的结构，并且成员name设置

25 \* 为version，文件权限mode设置为S\_IRUGO|S\_IWUGO，并设置show函数为

26 \*show\_device\_version, ，stror函数为stroe\_device\_version\*/

27 static DEVICE\_ATTR(version, S\_IRUGO|S\_IWUGO,

28 show\_device\_version, store\_device\_version);

29

30 static int \_\_init usb\_device\_init(void)

31 \{

32 int ret;

33

34 /\*设备注册，注册成功后在/sys/device目录下创建目录usb\_device\*/

35 ret = device\_register(&usb\_device);

36 if(ret)\{

37 printk("device register failed!\\n");

38 goto err1;

39 \}

40 /\*为设备添加属性，调用成功后在/sys/device/usb\_device/目录下有一个version的

41 \* 文件，权限为S\_IRUGO|S\_IWUGO，查看该文件时会调用函数show\_device\_version,

42 \* 修改时调用store\_device\_version。\*/

43 ret = device\_create\_file(&usb\_device, &dev\_attr\_version);

44 if(ret)\{

45 printk("device creat file failed!\\n");

46 goto err2;

47 \}

48 printk("usb device init\\n");

49 return 0;

50

51 err2:

52 device\_unregister(&usb\_device);

53 err1:

54 return ret;

55 \}

56

57 static void \_\_exit usb\_device\_exit(void)

58 \{

59 device\_remove\_file(&usb\_device, &dev\_attr\_version);

60 device\_unregister(&usb\_device);

61 printk("usb device bye!\\n");

62 \}

63

64 module\_init(usb\_device\_init);

65 module\_exit(usb\_device\_exit);

再看看效果，这是没有设置总线(bus = &usb\_bus)时的效果，代码在8th\_devModule\_1/3rd/device\_bak.c，我没有编译，如果需要的话自己编译运行看看：

\[root: 3rd\]\# insmod device.ko

usb device init

\[root: /\]\# find -name "usb\_device" //注册后查找一下在哪里有以设备bus\_id为名字的目录

./sys/devices/usb\_device ///sys/device下有一个

\[root: /\]\#

\[root: /\]\# ls /sys/devices/usb\_device/ //里面有一个空文件，一个属性文件version

uevent version

\[root: /\]\# cat /sys/devices/usb\_device/version //查看一下version,调用shoe函数

xiaobai V1.0

\[root: /\]\# echo "haha" > /sys/devices/usb\_device/version //修改version，调用store函数

\[root: /\]\# cat /sys/devices/usb\_device/version

haha

下面的是程序8th\_devModule\_1/3rd/device.c的效果：

\[root: /\]\# cd review\_driver/8th\_devModule/8th\_devModule\_1/3rd/

\[root: 3rd\]\# insmod bus.ko //先加载总线的模块

usb bus init

\[root: 3rd\]\# insmod device.ko //再加载设备的模块

usb device init

\[root: 3rd\]\# cd /

\[root: /\]\# find -name "usb\_device" //查找一下usb\_device，发现比没有指定总线时多了一个路径

./sys/devices/usb\_device //这个目录的出现是因为语句（.bus = &usb\_bus,）

./sys/bus/usb/devices/usb\_device //这个目录的出现是因为语句（device\_register(&usb\_device);）

\[root: /\]\# cat /sys/devices/usb\_device/version

xiaobai V1.0

\[root: /\]\# ls -l sys/bus/usb/devices //原来该路径只是一个软连接，是该设备归类到usb\_bus总线下

lrwxrwxrwx 1 root root 0 Oct 27 13:49 usb\_device -> ../../../devices/usb\_device

\[root: /\]\# rmmod device

<kernel> release //下载时调用release函数调用，如果没有设置release，卸载时会出错。

usb device bye!

\[root: /\]\# rmmod bus

usb bus bye!

\[root: /\]\#

上面的验证需要先加载bus.ko，bus.c源程序和1st/bus.c的函数没什么区别，只是将usb\_bus导出到符号表。不然的话，加载模块时不能找到对应的总线。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

四、驱动程序

设备模型跟踪所有系统所知道的设备。进行跟踪的主要原因是让驱动程序协调与设备之间的关系。

先看驱动程序的结构体，我仅仅贴出一些重要的成员：

/\*linux/device.h\*/

122 struct device\_driver \{

123 const char \*name; //驱动函数的名字，在对应总线的driver目录下显示

124 struct bus\_type \*bus; //指定该驱动程序所操作的总线类型，必须设置，不然会注册失败

125

126 struct module \*owner;

127 const char \*mod\_name; /\* used for built-in modules \*/

128

129 int (\*probe) (struct device \*dev); //探测函数，以后会讲

130 int (\*remove) (struct device \*dev); //卸载函数，当设备从系统中删除时调用，以后讲

131 void (\*shutdown) (struct device \*dev); //当系统关机是调用

132 int (\*suspend) (struct device \*dev, pm\_message\_t state);

133 int (\*resume) (struct device \*dev);

134 struct attribute\_group \*\*groups;

135

136 struct dev\_pm\_ops \*pm;

137

138 struct driver\_private \*p;

139 \};

和设备不一样的是，在注册驱动函数是必须指定该驱动函数对应的总线，因为驱动函数注册成功后，会存放在对应总线的driver目录下，如果没有总线，注册当然会失败。

与总线的注册一样：

1、定义结构体device\_driver。

2、调用注册函数：

214 int driver\_register(struct device\_driver \*drv)

函数失败返回非零，需要判断返回值来检查注册是否成功。

设备注销函数：

249 void driver\_unregister(struct device\_driver \*drv)

驱动函数属性：

这个也是和总线属性差不多，不细讲：

驱动函数相关的结构体和总线的类似，处理指定文件属性为，还定义了show和store两个函数。

155 struct driver\_attribute \{

156 struct attribute attr;

157 ssize\_t (\*show)(struct device\_driver \*driver, char \*buf);

158 ssize\_t (\*store)(struct device\_driver \*driver, const char \*buf,

159 size\_t count);

160 \};

设置设备属性有两个步骤：

1、创建并初始化device\_attribute结构，使用宏DEVICE\_ATTR

DRIVER\_ATTR(\_name, \_mode, \_show, \_store)

该宏会定义一个名叫driver\_attr\_\_name（红色部分是固定的）的driver\_attibute的结构，并且成员name设置为\_name，文件权限mode设置为\_mode，两个函数调用分别人show和store。

2、将device\_attibute添加到指定的驱动函数上，使用以下调用：

/\*drivers/base/driver.c\*/

93 int driver\_create\_file(struct device\_driver \*drv, struct driver\_attribute \*attr)

该函数失败时返回错误号。

一旦调用该函数，会就在指定dev设备的目录下新建一个名叫\_name的文件，权限为\_mode，当访问和修改该文件是会分别调用show和store函数调用。

如果不需要该属性时，使用以下函数删除：

/\*drivers/base/driver.c\*/

110 void driver\_remove\_file(struct device\_driver \*drv, struct driver\_attribute \*attr)

贴上函数：

/\*8th\_devModule\_1/4th/driver.c\*/

1 \#include <linux/module.h>

2 \#include <linux/init.h>

3

4 \#include <linux/device.h>

5

6 \#define VER\_SIZE 100

7

8 extern struct bus\_type usb\_bus;

9

10 struct device\_driver usb\_driver = \{

11 .name = "usb\_driver",

12 .bus = &usb\_bus,

13 \};

14

15 char Version\[VER\_SIZE\] = "xiaobai V1.0";

16

17 static ssize\_t show\_driver\_version(struct device\_driver \*drv, char \*buf)

18 \{

19 return snprintf(buf, VER\_SIZE, "%s\\n", Version);

20 \}

21 static ssize\_t store\_driver\_version(struct device\_driver \*drv,

22 const char \*buf, size\_t count)

23 \{

24 return snprintf(Version, VER\_SIZE, "%s", buf);

25 \}

26 /\*该宏会定义一个名叫driver\_attr\_version的driver\_attribute的结构，并且成员

27 \* name设置为version，文件权限mode设置为S\_IRUGO|S\_IWUGO，并设置show函数为

28 \* show\_driver\_version,stror函数为stroe\_driver\_version\*/

29 static DRIVER\_ATTR(version, S\_IRUGO|S\_IWUGO,

30 show\_driver\_version, store\_driver\_version);

31

32 static int \_\_init usb\_driver\_init(void)

33 \{

34 int ret;

35

36 /\*驱动注册，注册成功后在/sys/bus/usb/driver目录下创建目录usb\_driver\*/

37 ret = driver\_register(&usb\_driver);

38 if(ret)\{

39 printk("driver register failed!\\n");

40 goto err1;

41 \}

42 /\*为驱动添加属性，调用成功后在/sys/bus/usb/dirver目录下有一个version的

43 \* 文件，权限为S\_IRUGO|S\_IWUGO，查看该文件时会调用函数show\_driver\_version,修改时

44 \* 调用store\_driver\_version。\*/

45 ret = driver\_create\_file(&usb\_driver, &driver\_attr\_version);

46 if(ret)\{

47 printk("driver creat file failed!\\n");

48 goto err2;

49 \}

50 printk("usb driver init\\n");

51 return 0;

52

53 err2:

54 driver\_unregister(&usb\_driver);

55 err1:

56 return ret;

57 \}

58

59 static void \_\_exit usb\_driver\_exit(void)

60 \{

61 driver\_remove\_file(&usb\_driver, &driver\_attr\_version);

62 driver\_unregister(&usb\_driver);

63 printk("usb driver bye!\\n");

64 \}

看看效果，同样必须先加载bus.ko：

\[root: /\]\# cd review\_driver/8th\_devModule/8th\_devModule\_1/4th/

\[root: 4th\]\# insmod bus.ko //必须先加载总线

usb bus init

\[root: 4th\]\# insmod driver.ko

usb driver init

\[root: 4th\]\# cd /

\[root: /\]\# find -name "usb\_driver" //只有一处创建了usb\_driver目录

./sys/bus/usb/drivers/usb\_driver

\[root: /\]\# ls /sys/bus/usb/drivers/usb\_driver/

bind uevent unbind version

\[root: /\]\# cat /sys/bus/usb/drivers/usb\_driver/version //访问version文件是触发show函数

xiaobai V1.0

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

五、总结

这节讲得内容其实不多，归纳起来就是四个函数一个属性结构体。

属性结构体：xx\_attribute。

注册函数：xx\_register。

注销函数：xx+unregister。

创建属性文件函数：xx\_create\_file。

删除属性文件函数：xx\_remove\_file。

其中xx可以是总线(bus)、设备(device)或者驱动函数(deriver)。

一但注册成功，就会在/sys目录下相应的地方创建一个自己命名的目录。其中，设备和驱动函数还可以添加到指定的bus目录下。

总线的成功注册后会在/sys/bus目录下创建相应的目录。

设备的成功注册后会在/sys/device目录下创建相应的目录，如果指定总线，会在指定总线目录/sys/bus/xx/device下创建一个指向/sys/device目录的软连接。

驱动函数的公共注册会在/sys/bus/xx/driver目录下创建相应的目录。

属性文件提供了shoe和store两个函数调用，当读写文件时会触发相应的函数调用，实现内核sysfs与用户空间的数据交互。

三者具体的关系就在后面章节介绍。

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

[25014876_1296562467cFAa.png]: http://blog168.chinaunix.net/attachment/201102/1/25014876_1296562467cFAa.png

发表评论取消回复

表情：

评论列表（有 0 条评论，426人围观）

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

相关阅读

相关 Linux 设备总线驱动模型

尽管LDD3中说对多数程序员掌握设备驱动模型不是必要的，但对于嵌入式Linux的底层程序员而言，对设备驱动模型的学习非常重要。 Linux设备模型的目的：为内核建立

古城微笑少年丶/ 2022年06月02日 02:26/ 0 赞/ 242 阅读

相关 linux设备驱动归纳总结（六）：1.中断的实现

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

分手后的思念是犯贱/ 2022年04月23日 10:56/ 0 赞/ 205 阅读

相关 linux设备驱动归纳总结（三）：3.设备驱动面向对象思想和lseek的实现

一、结构体struct file和struct inode 在之前写的函数，全部是定义了一些零散的全局变量。有没有办法整合成到一个结构体当中？这样的话，看起来和用起

古城微笑少年丶/ 2022年03月20日 19:24/ 0 赞/ 205 阅读

相关 linux设备驱动归纳总结（三）：1.字符型设备之设备申请

操作系统：Ubunru 10.04 实验平台：S3C2440 + linux2.6.29内核注：在今后驱动程序的学习中经常需要查看内核源代码，建议大家新加一个内核目录，去

清疚/ 2022年03月20日 19:19/ 0 赞/ 264 阅读

相关 linux设备驱动归纳总结（十）：1.udev&misc

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

骑猪看日落/ 2022年03月19日 03:56/ 0 赞/ 291 阅读

相关 linux设备驱动归纳总结（九）：1.platform总线的设备和驱动

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

雨点打透心脏的1/2处/ 2022年03月19日 03:56/ 0 赞/ 298 阅读

相关 linux设备驱动归纳总结（八）：4.总线热插拔

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

忘是亡心i/ 2022年03月19日 03:56/ 0 赞/ 220 阅读

相关 linux设备驱动归纳总结（八）：2.总线、设备和驱动的关系

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

雨点打透心脏的1/2处/ 2022年03月19日 03:54/ 0 赞/ 215 阅读

相关 linux设备驱动归纳总结（八）：1.总线、设备和驱动

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

悠悠/ 2022年03月19日 03:54/ 0 赞/ 427 阅读

相关 Linux设备驱动——虚拟总线platform

在Linux设备中有的是没有对应的物理总线的，但为了适配Linux的总线模型，内核针对这种没有物理总线的设备开发了一种虚拟总线——platform总线。一、平台设备（de

- 日理万妓/ 2021年12月09日 05:49/ 0 赞/ 297 阅读