【版权申明】未经博主同意,谢绝转载!(请尊重原创,博主保留追究权)
Linux平台总线设备驱动模型
1. 传统Linux驱动模型 与 平台总线设备驱动模型
传统的Linux驱动模型将对于设备的一切操作都放在了一个文件当中, 这个文件既包含了硬件相关的设备信息(例如引脚信息), 也包含了对设备的操作函数, 这中模型直观, 容易. 但是站在软件设计的角度来看, 确实一种非常糟糕的方式, 它有一个很致命的缺点,就是设备信息和驱动代码冗余在一起,一旦硬件信息发生改变(例如硬件更改引脚, 或者想把代码复用到另一个平台中),就必须要修改驱动源码,非常的麻烦,为了解决这种驱动代码和设备信息耦合的问题,Linux推出了platform bus(平台总线).
platform bus(平台总线), 即使用虚拟总线将设备信息和驱动程序进行分离,将设备信息进行更好的整理。平台总线会维护两条链表,分别管理设备和驱动,当一个设备被注册到总线上时,总线会根据其名字搜索对应的驱动,如果找到就将设备信息导入驱动程序并执行驱动;当一个驱动被注册到平台总线的时候,总线也会搜索设备。总之,平台总线负责将设备信息和驱动代码进行匹配,这样就可以做到驱动和设备信息的分离。
2. 平台总线设备驱动模型 - 设备端
上面提到了平台总线会维护两条链表,分别管理设备和驱动. 他们相互独立, 分别管理着设备信息和驱动代码, 我们统一将他们交由Linux平台总线进行管理, 当
他们两个同时存在时, 这个设备将会被驱动起来(怎么知道他们同时存在? 平台总线已经实现了这个功能, 我们只需要使用平台总线提供的机制/接口, 如它所以期待的方式写出符合它要求的代码即可!)
2.1 设备端 - 相关的数据结构
struct platform_device {
const char *name; // 设备的名字,驱动方法和设备信息匹配的桥梁
int id; // 表示这个platform_device对象表征了几个设备,当多个设备有共用资源时,里面填充相应的设备数量,如果只是一个,填-1
bool id_auto;
struct device dev;// 父类对象,我们通常关心里面的platform_data和release,前者是用来存储私有设备信息的,后者是供当这个设备的最后引用被删除时被内核回调,注意和rmmod没关系。
u32 num_resources; // 资源的数量,即resource数组中元素的个数,我们用ARRAY_SIZE()宏来确定数组的大小
struct resource *resource; // 资源指针,如果是多个资源就是struct resource[]数组
const struct platform_device_id *id_entry;
char *driver_override; /* Driver name to force a match */
/* MFD cell pointer */
struct mfd_cell *mfd_cell;
/* arch specific additions */
struct pdev_archdata archdata;
};
2.1 设备端 - 设备的注册和注销
// 注册:把指定设备添加到内核中平台总线的设备列表,等待匹配,匹配成功则回调驱动中probe;
int platform_device_register(struct platform_device *);
// 注销:把指定设备从设备列表中删除,如果驱动已匹配则回调驱动方法和设备信息中的release;
void platform_device_unregister(struct platform_device *);
// 在动态编译的情况下,我们往往在模块初始化函数中注册一个驱动方法对象,而在模块卸载函数中注销一个驱动方法对象,所以我们可以使用内核中如下的宏来提高代码复用
module_platform_driver(driver_name);
3. 平台总线设备驱动模型 - 驱动端
3.1 驱动端 - 相关的数据结构
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 */
enum probe_type probe_type;
const struct of_device_id *of_match_table;
const struct acpi_device_id *acpi_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;
};
struct platform_driver {
int (*probe)(struct platform_device *); // 探测函数,如果驱动匹配到了目标设备,总线会自动回调probe函数
int (*remove)(struct platform_device *); // 释放函数,如果匹配到的设备从总线移除了,总线会自动回调remove函数
void (*shutdown)(struct platform_device *);
int (*suspend)(struct platform_device *, pm_message_t state);
int (*resume)(struct platform_device *);
struct device_driver driver; // platform_driver的父类
const struct platform_device_id *id_table;
bool prevent_deferred_probe;
};
3.2 驱动端 - 驱动的注册和注销
// 注册
int platform_driver_register(struct platform_driver *drv);
// 注销
int platform_driver_unregister(struct platform_driver *drv);
4. 平台总线设备驱动模型 - 设备与驱动的匹配
设备信息有三种表达方式,而一个驱动是可以匹配多个设备的,平台总线中的驱动要具有三种匹配信息的能力,基于这种需求,platform_driver中使用不同的成员来进行相应的匹配。4.1 struct of_device_id *of_match_table
对于使用设备树编码的设备信息,我们使用其父类device_driver中的of_match_table来匹配
struct platform_driver
struct device_driver driver; // linux/platform_device.h
const struct of_device_id *of_match_table; // linux/device.h
/*
* Struct used for matching a device
* linux/mod_devicetable.h
*/
struct of_device_id {
char name[32]; // 设备名
char type[32]; // 设备类型
char compatible[128]; // 与设备树compatible属性值匹配的字符串
const void *data; // data驱动私有数据
};
对于一个驱动匹配多个设备的情况,我们使用struct of_device_id table[]来表示。
4.2 struct platform_device_id *id_table
struct platform_driver
const struct platform_device_id *id_table; // linux/platform_device.h
struct platform_device_id {
char name[PLATFORM_NAME_SIZE]; // 设备名
kernel_ulong_t driver_data; // 驱动数据
};
static struct platform_device_id table[] = {
{"device0"},
{"device1"},
{}, // 内核判断数组已经结束的标志, 不能省略.
};
4.3 const char *name
struct platform_driver
struct device_driver driver; // linux/platform_device.h
const char *name; // linux/device.h
4.4 platform_driver匹配的优先级
/**
* drivers\base\platform.c
* platform_match - bind platform device to platform driver.
* @dev: device.
* @drv: driver.
*
* Platform device IDs are assumed to be encoded like this:
* "<name><instance>", where <name> is a short description of the type of
* device, like "pci" or "floppy", and <instance> is the enumerated
* instance of the device, like '0' or '42'. Driver IDs are simply
* "<name>". So, extract the <name> from the platform_device structure,
* and compare it against the name of the driver. Return whether they match
* or not.
*/
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);
/* When driver_override is set, only bind to the matching driver */
if (pdev->driver_override)
return !strcmp(pdev->driver_override, drv->name);
/* Attempt an OF style match first */
if (of_driver_match_device(dev, drv))
return 1;
/* Then try ACPI style match */
if (acpi_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);
}
可见, of_match_table > id_table > name.
5. probe() 与 remove()
probe即探测函数,如果驱动匹配到了目标设备(或者设备匹配到了目标驱动),总线会自动回调probe函数, 并把匹配到的设备信息封装成一个platform_device对象传入probe函数,我们可以很容易的得到关于这个设备的所有信息,但是更好的方法就是直接使用内核API中相关的函数.
probe() 函数中的主要工作:
- 申请资源
- 初始化
- 提供接口(cdev/sysfs/proc, 或者说是向内核注册字符设备驱动程序)
显然,remove主要完成与probe相反的操作,这两个接口都是我们必须实现的。
5.1 probe获取设备资源的方式
/**
* drivers\base\platform.c
* platform_get_resource - get a resource for a device
* @dev: platform device, 平台总线设备
* @type: resource type, 资源类型,include/linux/ioport.h中有定义
* @num: resource index, 资源索引,即第几个此类型的资源,从0开始
*/
struct resource *platform_get_resource(struct platform_device *dev,
unsigned int type, unsigned int num)
{
int i;
for (i = 0; i < dev->num_resources; i++) {
struct resource *r = &dev->resource[i];
if (type == resource_type(r) && num-- == 0)
return r;
}
return NULL;
}
注意,通过内核API(eg,上下这两个API)获取的resource如果是中断,那么只能是软中断号,而不是芯片手册/C语言设备信息/设备树设备信息中的硬中断号,但是此时获取的resource的flag是可以正确的反映该中断的触发方式的,只需要flag & IRQF_TRIGGER_MASK即可获取该中断的触发方式。
/**
* platform_get_irq - get an IRQ for a device // 获取一个设备的中断号
* @dev: platform device // 平台总线设备
* @num: IRQ number index // 中断号索引,即想要获取的第几个中断号,从0开始
*/
int platform_get_irq(struct platform_device *dev, unsigned int num)
{
#ifdef CONFIG_SPARC
/* sparc does not have irqs represented as IORESOURCE_IRQ resources */
if (!dev || num >= dev->archdata.num_irqs)
return -ENXIO;
return dev->archdata.irqs[num];
#else
struct resource *r;
if (IS_ENABLED(CONFIG_OF_IRQ) && dev->dev.of_node) {
int ret;
ret = of_irq_get(dev->dev.of_node, num);
if (ret > 0 || ret == -EPROBE_DEFER)
return ret;
}
r = platform_get_resource(dev, IORESOURCE_IRQ, num);
/*
* The resources may pass trigger flags to the irqs that need
* to be set up. It so happens that the trigger flags for
* IORESOURCE_BITS correspond 1-to-1 to the IRQF_TRIGGER*
* settings.
*/
if (r && r->flags & IORESOURCE_BITS) {
struct irq_data *irqd;
irqd = irq_get_irq_data(r->start);
if (!irqd)
return -ENXIO;
irqd_set_trigger_type(irqd, r->flags & IORESOURCE_BITS);
}
return r ? r->start : -ENXIO;
#endif
}
static inline void *dev_get_platdata(const struct device *dev)
{
return dev->platform_data;
}
6. 一个实例
6.1 设备端
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <asm/io.h>
static struct resource led_resource[] = {
[0] = {
.start = 0x120D6100,
.end = 0x120D6100 + 1 - 1,
.flags = IORESOURCE_MEM,
}
};
static void led_release(struct device * dev)
{
}
static struct platform_device led_dev = {
.name = "platform_led",
.id = -1,
.num_resources = ARRAY_SIZE(led_resource),
.resource = led_resource,
.dev = {
.release = led_release,
},
};
static int __init led_dev_init(void)
{
platform_device_register(&led_dev);
return 0;
}
static void __exit led_dev_exit(void)
{
platform_device_unregister(&led_dev);
}
module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_AUTHOR("yangbkGit");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("platform device model.");
MODULE_ALIAS("model");
6.1 驱动端
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <asm/io.h>
#include <asm/uaccess.h>
#include <linux/cdev.h>
#include <linux/device.h>
static dev_t dev_num = 0;
static struct cdev *cdevice = NULL;
static struct class *sys_class = NULL;
static struct device *class_device = NULL;
static volatile unsigned int *gpio_data;
int led_open(struct inode *pinode, struct file *pfile)
{
printk("[%s]\n", __func__);
return 0;
}
ssize_t led_write(struct file *pfile, const char __user *userbuf, size_t size, loff_t *loff)
{
int ret = -1;
int val = -1;
printk("[%s]\n", __func__);
//long copy_from_user(void *to, const void __user * from, unsigned long n)
ret = copy_from_user(&val, userbuf, size);
if(ret == 0 && val == 1){
*gpio_data |= (1<<6);
} else{
*gpio_data &= ~(1<<6);
}
return size;
}
ssize_t led_read(struct file *pfile, char __user *userbuf, size_t size, loff_t *loff)
{
printk("[%s]\n", __func__);
// long copy_to_user(void __user *to, const void *from, unsigned long n)
return 0;
}
static struct file_operations led_fops = {
.owner = THIS_MODULE,
.open = led_open,
.read = led_read,
.write = led_write
};
int led_probe(struct platform_device *pdev)
{
struct resource *res = NULL;
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
gpio_data = (int *)ioremap(res->start, res->end - res->start + 1);
printk("led_probe, found led\n");
cdevice = cdev_alloc();
cdev_init(cdevice, &led_fops);
alloc_chrdev_region(&dev_num, 0, 1, "yangbkLed");
cdev_add(cdevice, dev_num, 1);
sys_class = class_create(THIS_MODULE, "yangbkClass");
class_device = device_create(sys_class, NULL, dev_num, NULL, "yangbkDevice");
return 0;
}
int led_remove(struct platform_device *pdev)
{
printk("led_remove, remove led\n");
device_destroy(sys_class, dev_num);
class_destroy(sys_class);
unregister_chrdev_region(dev_num, 1);
cdev_del(cdevice);
iounmap(gpio_data);
return 0;
}
struct platform_driver led_drv = {
.probe = led_probe,
.remove = led_remove,
.driver = {
.name = "platform_led",
}
};
static int __init led_drv_init(void)
{
platform_driver_register(&led_drv);
return 0;
}
static void __exit led_drv_exit(void)
{
platform_driver_unregister(&led_drv);
}
module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_AUTHOR("yangbkGit");
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("platform driver model.");
MODULE_ALIAS("model");
6.3 应用端
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char **argv)
{
char ch;
int fd = -1;
fd = open("/dev/yangbkDevice", O_WRONLY);
printf("press any keys(not 1/0/enter) to exit this sample.\n");
while(1){
ch = (char)getchar();
if(ch == '\n')
continue;
if(ch == '1'){
int data = 1;
write(fd, &data, sizeof(data));
} else if(ch == '0'){
int data = 0;
write(fd, &data, sizeof(data));
} else{
break;
}
}
close(fd);
return 0;
}