copy from : https://blog.csdn.net/weixin_42462202/article/details/100050640
文章目录
Linux platform总线
一、总线概念
二、platform驱动框架详解
2.1 platform驱动框架
2.2 platform_device和platform_driver的匹配规则
2.3 platform_device中的资源描述
三、platform驱动框架源码剖析
四、platform驱动程序模板
一、总线概念
在Linux驱动模型中总要关心三个对象：总线、设备、驱动
总线指i2c总线、spi总线、usb总线等总线，它们管理着设备和驱动
设备描述了硬件信息
驱动是具体的驱动的实现
当向总线注册设备时，会寻找与之匹配的驱动。反之，当注册驱动时，会寻找与之匹配的设备
使用这种机制可以使得一个驱动程序给多个硬件设备使用，实现了硬件与软件的分离
对于一个设备总要附于某一条总线上，如i2c总线、spi总线、usb总线等，当有的设备如led，并不是接在某一具体的总线上，而内核为了实现总线、设备、驱动这种模型，所以就产生了虚拟总线（platform总线）
二、platform驱动框架详解
2.1 platform驱动框架
platform总线相应的设备和驱动分别为platform_device和platform_driver
所谓platform_device并不是和字符设备、块设备、网络设备并列的概念，而是内核提供的一种机制
platform_device结构体定义如下
struct platform_device {
const char *name;
struct device dev;
u32 num_resources;
struct resource *resource;
...
};
name是platform_device的名称，此名称将会被用于和platform_driver的匹配规则中
dev表明这是一个设备
resource描述硬件资源
num_resources表明resource所指的数组有几项
注册设备的接口为
int platform_device_register(struct platform_device *);
void platform_device_unregister(struct platform_device *);
platform_driver结构体定义如下
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_driver中定义了probe、remove等一系列函数，其中的probe函数将在驱动和设备匹配时被调用
driver表明这是一个驱动，id_table将用于与platform_device的匹配规则中
注册驱动的接口为
int platform_driver_register(struct platform_driver *);
void platform_driver_unregister(struct platform_driver *);
platform总线结构体如下
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总线并不是直接暴露给驱动开发者，它是一个幕后工作者，管理者platform_device和platform_driver
其中platform_match定义了设备和驱动的匹配规则
总线维护一个设备链表和一个驱动链表，当注册设备时，会遍历驱动链表，调用总线的匹配规则，如果匹配就调用驱动的probe函数，注册驱动时同理
以上就是platform的驱动框架
2.2 platform_device和platform_driver的匹配规则
对于platform_device和platform_driver的匹配规则，要分析platform_match函数，这里先给出结论，后头再分析源码
第一种情况
匹配platform_driver中的id_table数组元素的name和platform_device的name（字符串匹配）
struct platform_device_id {
char name[PLATFORM_NAME_SIZE];
kernel_ulong_t driver_data
__attribute__((aligned(sizeof(kernel_ulong_t))));
};
struct platform_driver {
...
const struct platform_device_id *id_table;
};
struct platform_device {
const char * name;
...
}
第二种情况
匹配platform_driver中的driver的name和platform_device的name
struct device_driver {
const char *name;
...
};
struct platform_driver {
...
struct device_driver driver;
...
};
struct platform_device {
const char * name;
...
}
2.3 platform_device中的资源描述
前面介绍说platform_device时描述硬件资源，那么platform_driver就要获取资源
至于怎么描述和获取资源，下面来介绍
资源的描述在platform_device中，其中resource指向一个resource数组
struct platform_device {
u32 num_resources;
struct resource *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、flags三个变量，它们分别标准资源的起始值，结束值和资源的类型
其中flags可以为IORESOURCE_IO、IORESOURCE_MEM、IORESOURCE_IRQ、IORE-SOURCE_DMA等
start和end的解释随flags而改变
在驱动程序中获取资源可以使用
/*
* dev：表示平台设备
* flags：要获取的资源类型
* index：该类资源在平台设备中的编号
*/
struct resource *platform_get_resource(struct platform_device *dev,
unsigned int flag, unsigned int index);
举个例子
static struct resource s5p_dm9000_resources[] = {
[0] = {
.start = S5P_PA_DM9000,
.end = S5P_PA_DM9000 + 3,
.flags = IORESOURCE_MEM,
},
[1] = {
.start = S5P_PA_DM9000 + 1,
.end = S5P_PA_DM9000 + 1,
.flags = IORESOURCE_MEM,
},
[2] = {
.start = IRQ_EINT10,
.end = IRQ_EINT10,
.flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
}
};
struct platform_device s5p_device_dm9000 = {
.name = "dm9000",
.id = 0,
.num_resources = ARRAY_SIZE(s5p_dm9000_resources),
.resource = s5p_dm9000_resources,
};
这是网卡dm9000的硬件描述，在驱动程序中想要获取资源可以这样做
struct resource *resource;
resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
对于获取中断资源还可以调用
int platform_get_irq(struct platform_device *dev, unsigned int num);
实际上调用的是
platform_get_resource(dev，IORESOURCE_IRQ，num);
此外还可以在platform_device的dev成员附加参数
static struct dm9000_plat_data s5p_dm9000_platdata = {
.dev_addr = {0x00,0x09,0xc0,0xff,0xec,0x48},
};
struct platform_device s5p_device_dm9000 = {
.name = "dm9000",
.id = 0,
.num_resources = ARRAY_SIZE(s5p_dm9000_resources),
.resource = s5p_dm9000_resources,
.dev = {
.platform_data = &s5p_dm9000_platdata,
}
};
在驱动程序中这样获取
struct dm9000_plat_data *pdata = dev_get_platdata(&pdev->dev);
三、platform驱动框架源码剖析
下面从platform的注册接口来分析platform的驱动框架
int platform_device_register(struct platform_device *pdev)
{
return platform_device_add(pdev);
}
int platform_device_add(struct platform_device *pdev)
{
/* 设置设备对应的总线为platform总线 */
pdev->dev.bus = &platform_bus_type;
device_add(&pdev->dev);
}
int device_add(struct device *dev)
{
/* 将设备添加进总线的设备链表 */
bus_add_device(dev);
bus_probe_device(dev);
}
void bus_probe_device(struct device *dev)
{
device_attach(dev);
}
int device_attach(struct device *dev)
{
/* 遍历总线的所有驱动，执行__device_attach函数 */
bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
}
__device_attach函数会判断驱动和设备是否匹配，如果不匹配的话，函数就退出，如果匹配就调用driver_probe_device，driver_probe_device函数将调用驱动的probe函数
static int __device_attach(struct device_driver *drv, void *data)
{
struct device *dev = data;
if (!driver_match_device(drv, dev))
return 0;
return driver_probe_device(drv, dev);
}
下面那看一下driver_match_device是如何匹配的
static inline int driver_match_device(struct device_driver *drv,
struct device *dev)
{
return drv->bus->match ? drv->bus->match(dev, drv) : 1;
}
可以看到，调用了drv->bus->match函数，其中的bus在注册设备的时候被设备为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_match，下面分析此函数，这也正是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);
/* 优先匹配platform_driver的id_table和platform_device的name */
if (pdrv->id_table)
return platform_match_id(pdrv->id_table, pdev) != NULL;
/* 如果pdrv->id_table没有定义，那么就匹配platform_device的name和platform_driver中drv的name */
return (strcmp(pdev->name, drv->name) == 0);
}
其中的匹配都是通过字符串进行匹配的
下面再回到此函数中
static int __device_attach(struct device_driver *drv, void *data)
{
struct device *dev = data;
if (!driver_match_device(drv, dev))
return 0;
return driver_probe_device(drv, dev);
}
如果匹配成功，就会调用driver_probe_device，此函数会调用对用驱动的probe函数
int driver_probe_device(struct device_driver *drv, struct device *dev)
{
really_probe(dev, drv);
}
static int really_probe(struct device *dev, struct device_driver *drv)
{
drv->probe(dev);
}
对于注册platform_driver的过程和上述同理，这里不再重述
四、platform驱动程序模板
这里给出一个编写platform驱动的模板
platform_device
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
static void mydev_release(struct device *dev)
{
printk("mydev_release
");
}
static struct platform_device mydev_device = {
.name = "mydev",
.id = -1,
//.num_resources =
//.resource =
.dev = {
//.platform_data =
.release = mydev_release,
},
};
static int __devinit mydev_init(void)
{
int ret;
ret = platform_device_register(&mydev_device);
if(ret)
printk("failed to register device
");
return ret;
}
static void mydev_exit(void)
{
platform_device_unregister(&mydev_device);
}
module_init(mydev_init);
module_exit(mydev_exit);
MODULE_LICENSE("GPL");
platform_driver
#include <linux/module.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/platform_device.h>
static int mydriver_probe(struct platform_device *device)
{
printk("mydriver_probe
");
//struct resource *resource;
//resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
//viod *pdata = dev_get_platdata(&pdev->dev);
return 0;
}
static int mydriver_remove(struct platform_device *device)
{
printk("mydriver_remove
");
return 0;
}
static struct platform_driver mydriver = {
.probe = mydriver_probe,
.remove = mydriver_remove,
.driver = {
.name = "mydev",
},
};
static int __devinit mydriver_init(void)
{
int ret;
ret = platform_driver_register(&mydriver);
if(ret)
printk("failed to register driver
");
return ret;
}
static void mydriver_exit(void)
{
platform_driver_unregister(&mydriver);
}
module_init(mydriver_init);
module_exit(mydriver_exit);
MODULE_LICENSE("GPL");
————————————————
版权声明：本文为CSDN博主「JT同学」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/weixin_42462202/article/details/100050640