Linux设备模型－－总线

淡淡的烟草味﹌ 2022-03-26 17:26 362阅读 0赞

Linux设备模型是由总线（bus\_type），设备（device），驱动（device\_driver）这三个数据结构来描述的。在设备模型中，所有的设备都通过总线来连接。即使有些设备没有连接到一根物理上的总线，Linux为其设置了一个内部的，虚拟的platform总线，来维持总线，驱动，设备的关系。总线是处理器与一个或者多个设备之间的通道。比如一个USB控制器通常是一个PCI设备，设备模型展示了总线和他们所控制的设备之间的连接。linux设备模型中，总线由bus\_type结构表示，定义在<linux/device.h>

struct bus\_type \{

const char      \*name;       //总线类型的名称

struct bus\_attribute    \*bus\_attrs;  //总线属性

struct device\_attribute \*dev\_attrs;  //设备属性

struct driver\_attribute \*drv\_attrs;  //驱动属性

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

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

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

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

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

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

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

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

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

struct dev\_pm\_ops \*pm;

struct bus\_type\_private \*p;

\};

struct bus\_type\_private \{

struct kset subsys;                  //该总线的subsystem

struct kset \*drivers\_kset;           //所有与该总线相关的驱动集合

struct kset \*devices\_kset;           //所有挂接在该总线上的设备集合

struct klist klist\_devices;

struct klist klist\_drivers;

struct blocking\_notifier\_head bus\_notifier;

unsigned int drivers\_autoprobe:1;

struct bus\_type \*bus;

\};

总线的注册使用bus\_register(struct bus\_type \*bus)若成功，新的总线将被添加进系统，并可在sysfs的/sys/bus下看到  
总线的删除使用void bus\_unregister(struct bus\_type \*bus)

我们在深入看bus\_register 这个函数

1.  int bus\_register(struct bus\_type \*bus)  
2.  \{  
3.  int retval;  
4.  struct bus\_type\_private \*priv;  
5.  priv = kzalloc(sizeof(struct bus\_type\_private), GFP\_KERNEL);  
6.  if (!priv)  
7.  return -ENOMEM;  
8.  priv->busbus = bus;  
9.  bus->p = priv;

**\[html\]**  [view plain][] [copy][view plain]

1.  BLOCKING\_INIT\_NOTIFIER\_HEAD(&priv->bus\_notifier);  
2.  retval = kobject\_set\_name(&priv->subsys.kobj, "%s", bus->name);  
3.  if (retval)  
4.  goto out;  
5.    
6.  priv->subsys.kobj.kset = bus\_kset;  
7.  priv->subsys.kobj.ktype = &bus\_ktype;  
8.  priv->drivers\_autoprobe = 1;  
9.    
10. retval = kset\_register(&priv->subsys);  
11. if (retval)  
12. goto out;  
13.   
14. retval = bus\_create\_file(bus, &bus\_attr\_uevent);  
15. if (retval)  
16. goto bus\_uevent\_fail;  
17.   
18.   
19. priv->devices\_kset = kset\_create\_and\_add("devices", NULL,  
20. &priv->subsys.kobj);  
21. if (!priv->devices\_kset) \{  
22. retval = -ENOMEM;  
23. goto bus\_devices\_fail;  
24. \}  
25.   
26.   
27. priv->drivers\_kset = kset\_create\_and\_add("drivers", NULL,  
28. &priv->subsys.kobj);  
29. if (!priv->drivers\_kset) \{  
30. retval = -ENOMEM;  
31. goto bus\_drivers\_fail;  
32. \}  
33.   
34.   
35. klist\_init(&priv->klist\_devices, klist\_devices\_get, klist\_devices\_put);  
36. klist\_init(&priv->klist\_drivers, NULL, NULL);  
37.   
38. retval = add\_probe\_files(bus);  
39. if (retval)  
40. goto bus\_probe\_files\_fail;  
41.   
42. retval = bus\_add\_attrs(bus);  
43. if (retval)  
44. goto bus\_attrs\_fail;  
45.   
46. pr\_debug("bus: '%s': registered\\n", bus->name);  
47. return 0;  
48.   
49. bus\_attrs\_fail:  
50. remove\_probe\_files(bus);  
51. bus\_probe\_files\_fail:  
52. kset\_unregister(bus->p->drivers\_kset);  
53. bus\_drivers\_fail:  
54. kset\_unregister(bus->p->devices\_kset);  
55. bus\_devices\_fail:  
56. bus\_remove\_file(bus, &bus\_attr\_uevent);  
57. bus\_uevent\_fail:  
58. kset\_unregister(&bus->p->subsys);  
59. kfree(bus->p);  
60. out:  
61. return retval;  
62. \}

从这里

priv->subsys.kobj.kset = bus\_kset;  
priv->subsys.kobj.ktype = &bus\_ktype;

可以看得出总线初始化了自己的kset对象。kset在后续文件中有讲到。

int (\*match)(struct device \*dev, struct device\_driver \*drv);匹配设备和驱动程序。

当一个新设备或者驱动被添加到这个总线时，该方法被调用，用于判断指定的驱动和谐是否能处理指定的设备。若可以，则返回非零值。后 面的测试程序采用匹配设备的dev->bus\_id字符串和驱动的drv->name字符串是否相同来判断驱动是否能处理该设备。

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

在为用户空间产生热插拔事件之前，这个方法允许总线添加环境变量

总线属性由bus\_attribute结构描述

struct bus\_attribute \{

struct attribute    attr;

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

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

\};

创建属性

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

删除属性

int bus\_remove\_file(struct bus\_type \*bus,struct bus\_attribute \*attr)  
  
注意下面这个内核定义的宏后面的例子会用到

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

struct bus\_attribute bus\_attr\_\#\#\_name = \_\_ATTR(\_name, \_mode, \_show, \_store)

在编译时创建和初始化bus\_attribute结构，它将bus\_attr\_作为给定前缀来创建总线的真正名称。

如：static BUS\_ATTR(version, S\_IRUGO, show\_bus\_version, NULL);

将创建一个bus\_attr\_version结构体对象。

添加总线例子：

\#include <linux/device.h>

\#include <linux/module.h>

\#include <linux/kernel.h>

\#include <linux/init.h>

\#include <linux/string.h>

MODULE\_AUTHOR("David Xie");

MODULE\_LICENSE("Dual BSD/GPL");

static char \*Version = "$Revision: 1.9 $";

static int my\_match(struct device \*dev, struct device\_driver \*driver)

return !strncmp(dev->bus\_id, driver->name, strlen(driver->name));

static void my\_bus\_release(struct device \*dev)

printk(KERN\_DEBUG "my bus release\\n");

struct device my\_bus = \{

.bus\_id   = "my\_bus0",

.release  = my\_bus\_release

\};

struct bus\_type my\_bus\_type = \{

.name = "my\_bus",

.match = my\_match,

\};

EXPORT\_SYMBOL(my\_bus);

EXPORT\_SYMBOL(my\_bus\_type);

/\*

\* Export a simple attribute.

\*/

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

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

static BUS\_ATTR(version, S\_IRUGO, show\_bus\_version, NULL);

static int \_\_init my\_bus\_init(void)

int ret;

/\*注册总线\*/

ret = bus\_register(&my\_bus\_type);

if (ret)

return ret;

/\*创建属性文件\*/

if (bus\_create\_file(&my\_bus\_type, &bus\_attr\_version))

printk(KERN\_NOTICE "Fail to create version attribute!\\n");

/\*注册总线设备\*/

ret = device\_register(&my\_bus);

if (ret)

printk(KERN\_NOTICE "Fail to register device:my\_bus!\\n");

return ret;

static void my\_bus\_exit(void)

device\_unregister(&my\_bus);

bus\_unregister(&my\_bus\_type);

module\_init(my\_bus\_init);

module\_exit(my\_bus\_exit);

创建一条名为my\_bus\_type的总线和一个名为my\_bus的总线设备，注意总线也是一个设备，也需要注册。

测试结果：  
![Image 1][]

运行后，查看/sys/bus/目录

ls /sys/bus/

acpi  i2c  mdio\_bus my\_bus pci\_express  platform  scsi   usb

hid   isa  pci       pcmcia

[view plain]: http://blog.csdn.net/ayangke/article/details/6802109#
[Image 1]:

Linux设备模型－－总线

发表评论取消回复

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

相关阅读

相关 LINUX设备驱动模型之platform(平台)总线简介

相关 ldd3学习之十一(3)：Linux设备模型---platform总线分析

相关 Linux设备驱动模型之platform(平台)总线详解

相关 Linux 设备总线驱动模型

相关 Linux设备模型－－platform

相关 Linux设备模型－－驱动

相关 Linux设备模型－－设备

相关 Linux设备模型－－总线

相关 Linux字符设备驱动模型

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