嵌入式之Linux驱动（七）

姓名：郑煜烁学号：19029100010 学院：电子工程学院

转自：https://blog.csdn.net/u012142460/article/details/79125461

【嵌牛导读】Linux中的设备及其所起到的作用

【嵌牛鼻子】设备模型介绍以及platform设备驱动

【嵌牛提问】驱动需要哪些设备，作用是什么

【嵌牛正文】

前面讲过了字符驱动，我们把过程再来回顾一下，我们是如何来完成一个驱动的。

1、设备号相关问题，手动或自动创建设备号。

2、设备对象相关问题，完成驱动操作方法集合，并向内核注册该设备对象。

3、生成设备节点

这其中有一个最大的问题：设备和驱动高度耦合，设备修改后，驱动也需要修改，牵一发而动全身。这为后续的驱动开发造成了很不好的影响。我们应该做到的是，高内聚低耦合。设备修改后只修改相应的设备文件，驱动需要修改就只修改驱动部分。那驱动和设备如何联系起来的呢？这就又需要要给文件来配合，总线。这就是Linux2.6以后的设备驱动模型：总线、设备、驱动。

那三者是如何分工的呢？

设备：描述一个设备的详细信息。例如一个串口，那应该体现该串口设备的相关信息，例如串口的名称，设备的地址，设备的中断号等等。

驱动：描述如何使用设备的方法，这个好说，其实还是一堆方法嘛。为用户提供操作设备的方法。

总线：总得有一个东西把设备和驱动联系起来把，那就是总线。总线中有一个匹配函数，系统每注册一个设备，就去找一下系统中与之匹配的驱动。同样，注册驱动的时候，也要去系统中寻找一个与之匹配的设备。这样，设备和驱动就联系到一起了。

系统中有很多总线，I2C总线，SPI总线，USB总线。但有很多设备没有总线实体，例如LED灯，这算什么总线？Linux添加了一种虚拟总线，叫做平台总线---platform。

我们再来了解下一个问题，linux设备模型的对象化。c语言是面向过程的语言，很多高级语言c++，java等都是面向对象的过程。c语言同样可以实现对象化的过程。Linux的设备模型就向我们很好的展示了这个过程。我们就以platform设备模型为例来看一看。

在c语言如何实现一个类呢？用的就是结构体。与类相比，结构体不能定义方法，但我们可以用函数指针来作为方法。文件操作集合struct file_operations就是一个典型的例子。继承如何实现呢？很简单，讲父类（父结构体）包含就ok了，父类（父结构体）中的变量或者方法就能用了。

linux设备驱动模型中的根类是kobject，这是linux中所有驱动模型的基类，我们刚才讲的总线、设备、驱动都是继承

struct device { //设备的基类

struct device *parent;

struct device_private *p;

struct kobject kobj; //++++++++++++++++++++++继承自kobject

const char *init_name; /* initial name of the device */

const struct device_type *type;

struct mutex mutex; /* mutex to synchronize calls to

* its driver.

struct bus_type *bus; /* type of bus device is on */

struct device_driver *driver; /* which driver has allocated this

device */

void *platform_data; /* Platform specific data, device

core doesn't touch it */

struct dev_pm_info power;

struct dev_power_domain *pwr_domain;

...........}

struct device_driver {//设备驱动基类结构体

const char *name;

struct bus_type *bus;

struct module *owner;

const char *mod_name; /* used for built-in modules */

bool suppress_bind_attrs; /* disables bind/unbind via sysfs */

const struct of_device_id *of_match_table;

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 (*resume) (struct device *dev);

const struct attribute_group **groups;

const struct dev_pm_ops *pm;

struct driver_private *p;//这个里面包含object

};

struct driver_private {

struct kobject kobj; //父类

struct klist klist_devices;

struct klist_node knode_bus;

struct module_kobject *mkobj;

struct device_driver *driver;

};

总线基类结构体

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 (*resume)(struct device *dev);

const struct dev_pm_ops *pm;

struct subsys_private *p;//这个里面继续++++++++++++++=

};

struct subsys_private {

struct kset subsys; //kset是object基类的集合

struct kset *devices_kset;

struct kset *drivers_kset;

struct klist klist_devices;

struct klist klist_drivers;

struct blocking_notifier_head bus_notifier;

unsigned int drivers_autoprobe:1;

struct bus_type *bus;

struct list_head class_interfaces;

struct kset glue_dirs;

struct mutex class_mutex;

struct class *class;

};

int (*match)(struct device *dev, struct device_driver *drv)；总线中的match方法就是用来匹配驱动和设备的。

struct bus_type、struct device 、struct device_driver 分别是总线、设备、驱动的基类结构体。具体的总线、设备、驱动都继承自这里。

继续，来看看我们的平台设备platform相关的类。

1、platform总线

platform总线是bus_type的一个对象实例。

struct bus_type platform_bus_type = {

.name = "platform",

.dev_attrs = platform_dev_attrs,

.match = platform_match,

.uevent = platform_uevent,

.pm = &platform_dev_pm_ops,

};

借此我们来看一下，platform是如何匹配的驱动和设备的呢？

static int platform_match(struct device *dev, struct device_driver *drv)

{

struct platform_device *pdev = to_platform_device(dev);

struct platform_driver *pdrv = to_platform_driver(drv);

/* Attempt an OF style match first */

if (of_driver_match_device(dev, drv))

return 1;

/* Then try to match against the id table */

if (pdrv->id_table)

return platform_match_id(pdrv->id_table, pdev) != NULL;

/* fall-back to driver name match */

return (strcmp(pdev->name, drv->name) == 0);

}

匹配方法有三种：1、基于设备树风格的匹配。2、基于id_table表的匹配 3、基于设备name和驱动name的匹配。设备树的方式我们先不讲，我们介绍一下后后两种方式。请继续向下看。

2、platform设备

struct platform_device {

const char * name;

int id;

struct device dev;

u32 num_resources;

struct resource * resource;

const struct platform_device_id *id_entry;

/* MFD cell pointer */

struct mfd_cell *mfd_cell;

/* arch specific additions */

struct pdev_archdata archdata;

};

name：设备名称，可以用来与驱动名称进行匹配，match函数中的name匹配方法就是比对这里的name

id：设备id，现在我们一般直接设置成-1，不用它了。

dev：设备父类

num_resources：资源数量

resource：资源结构体。这是设备最重要的东西。

id_entry：也是用来匹配，match函数中id_table匹配的方法。

resource是设备中最重要的东西。驱动要操作设备，首先需要知道什么呢？当然是设备地址了，如果有中断还需要知道中断号，这就是resource的作用。

struct resource {

resource_size_t start;

resource_size_t end;

const char *name;

unsigned long flags;

struct resource *parent, *sibling, *child;

};

start：资源起始（起始地址或中断号起始值）

end：资源结束（结束地址或中断号结束值）

name：名称

flags：资源标志定义，表征是什么类型的资源，最常用的有以下几个：

IORESOURCE_MEM：内存资源，也包括IO内存，

IORESOURCE_IRQ：中断资源

IORESOURCE_DMA ：DMA通道资源

3、platform驱动

struct platform_driver {

int (*probe)(struct platform_device *);

int (*remove)(struct platform_device *);

void (*shutdown)(struct platform_device *);

int (*suspend)(struct platform_device *, pm_message_t state);

int (*resume)(struct platform_device *);

struct device_driver driver;

const struct platform_device_id *id_table;

};

platform驱动中包含多个方法、一个设备基类、一个id_table表

probe：这是匹配上之后要执行的函数。

remove:所驱动的平台设备被移除时或平台驱动注销时所用

driver：基类，driver中的name成员可用来匹配设备，match匹配函数的第三种方法

id_table：可以驱动的平台设备ID列表。match匹配函数的第二种方法。主要设置name即可。

struct platform_device_id {

char name[PLATFORM_NAME_SIZE];

kernel_ulong_t driver_data

__attribute__((aligned(sizeof(kernel_ulong_t))));

};

好，相关的类介绍完毕，现在来看看相关的API函数。总线相关的工作一般情况下内核已经给我们做好了，我们只需要做设备和驱动相关的工作。

1、设备注册与注销

int platform_add_devices(struct platform_device **devs, int num)

int platform_device_register(struct platform_device *pdev)

第一个函数可以注册多个平台设备，第二个函数只注册一个设备，而实际上platform_add_devices内部时多次调用platform_device_register函数的。

devs是platform_device结构体二级指针

num是要注册的个数

pdev是platform_device结构体指针

void platform_device_unregister(struct platform_device *pdev)

设备注销函数。

2、驱动的注册与注销

int platform_driver_register(struct platform_driver *drv)

驱动的注册

void platform_driver_unregister(struct platform_driver *drv)

驱动的注销

3、设备资源获取

我们刚才说到，设备中类中有一个成员变量是resource，是代表设备的硬件信息。驱动要操作设备就必须获取硬件信息，linux为我们提供了这样的API函数。

struct resource *platform_get_resource(struct platform_device *dev,

unsigned int type, unsigned int num)

功能：获取设备资源

参数：dev：设备对象

type：要获取的资源类型，和resource中的flags对应。

IORESOURCE_MEM：内存资源，也包括IO内存，

IORESOURCE_IRQ：中断资源

IORESOURCE_DMA ：DMA通道资源

num：第几个资源

返回值：成功返回获取的资源结构体地址。

有人会不会有这样的疑问，驱动不是分为字符设备、块设备、网络设备吗？platform设备又是什么？这里不要把两种搞混淆了，驱动仍是只有字符设备、块设备和网络设备三类。平台设备只是为了符合linux的驱动模型而产生的，除了平台设备模型，还有I2C设备模型、SPI设备模型。都是为了符合驱动模型而创建的。但i2c设备和spi设备仍然是字符设备。

看个例程把，先来简单熟悉以下过程

设备，资源中我们假定一个寄存器地址

#include

MODULE_LICENSE("GPL");

void demo_release(struct device *dev)

{

printk("%s,%d\n", __func__, __LINE__);

}

struct resource res = {

.start = 0x10004000,

.end = 0x10004007,

.flags = IORESOURCE_MEM,

};

struct platform_device virtual_dev = {

.name = "vir_dev", //名称和驱动中匹配。

.id = -1,

.dev = {

.release = demo_release,

.num_resources = 1,

.resource = &res,

};

static int __init demo_device_init(void)

{

platform_device_register(&virtual_dev);

printk(KERN_INFO"%s,%d\n",__func__,__LINE__);

return 0;

}

static void __exit demo_device_exit(void)

{

platform_device_unregister(&virtual_dev);

printk(KERN_INFO"%s,%d\n",__func__,__LINE__);

}

module_init(demo_device_init);

module_exit(demo_device_exit);

驱动中，获得资源，并打印开始和结束地址

#include

MODULE_LICENSE("GPL");

struct resource *res0;

static int virtual_probe(struct platform_device *pdev)

{

printk(KERN_INFO"%s,%d\n",__func__,__LINE__);

res0 = platform_get_resource(pdev, IORESOURCE_MEM, 0);

printk(KERN_INFO"startaddr:%x,endaddr:%x\n",(unsigned int)res0->start,(unsigned int)res0->end);

return 0;

}

static int virtual_remove(struct platform_device *pdev)

{

printk(KERN_INFO"%s,%d\n",__func__,__LINE__);

return 0;

}

struct platform_driver virtual_driver = {

.probe = virtual_probe,

.remove = virtual_remove,

.driver = {

.name = "vir_dev", //名称和设备中保持一致

.owner = THIS_MODULE,

}

};

module_platform_driver(virtual_driver);

最后一行是模块入口函数和出口函数的简写方式，这一行就可以代替之前的一堆，这是因为，之前初始化的工作我们将都会放到probe函数中，所以xxx_init()函数除了作为入口函数以及注册驱动外也就没什么作用了，所以才有此简写方式。

加载两个模块执行结果

注册设备号，注册字符设备等工作我们放到probe函数中去操作。其余部分和我们之前介绍的字符设备驱动都一样了。基本的框架就是这样，下一节我们来看看如何在实际的开发板中利用platform设备点亮LED灯

————————————————

原文链接：https://blog.csdn.net/u012142460/article/details/79125461

嵌入式之Linux驱动（七）

你可能感兴趣的:(嵌入式之Linux驱动（七）)