Linux驱动学习—平台总线模型

1、平台总线模型介绍

①什么是平台总线模型？

平台总线模型也叫platform总线模型。是Linux内核虚拟出来的一条总线，不是真实的导线。

平台总线模型就是把原来的驱动C文件给分成两个C文件，一个是device.c，一个是driver.c

把稳定不变的放在driver.c里面，需要变得放在devic.c里面。

②为什么会有平台总线模型？

（1）可以提高代码的重用性

（2）建设重复性代码

③怎么编写以平台总线模型设计的驱动？

一个是device.c，一个是driver.c，然后分别注册device.c和driver.c。平台总线是以名字来匹配的，实际上就是字符串比较。

2、注册platform设备

①平台总线注册一个device

device.c里面写的是硬件资源，这里的硬件资源就是指寄存器的地址，中断号，时钟等硬件资源。在linux内核里面，我们是用一个结构体来描述硬件资源的。在include/linux/platform_device.h。该结构体如下所示：

struct platform_device {
    const char  *name;//平台总线进行匹配的时候用到的name，/sys/bus/...
    int     id;      //设备id，一般写-1。
    bool        id_auto;
    struct device   dev;//内嵌的device结构体
    u32     num_resources;//资源的个数
    struct resource *resource;//device里面的硬件资源
​
    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;
};

有关resource结构体。在include/linux/ioport.h。定义如下：

struct resource {
    resource_size_t start;//资源的起始
    resource_size_t end;//资源的结束
    const char *name;//资源的名字
    unsigned long flags;//资源的类型
    unsigned long desc;
    struct resource *parent, *sibling, *child;
};

资源的类型一般用下面的几个宏定义：

#define IORESOURCE_IO       0x00000100  //IO的内存
#define IORESOURCE_MEM      0x00000200  //表示一段物理内存
#define IORESOURCE_REG      0x00000300  
#define IORESOURCE_IRQ      0x00000400 //表示中断
#define IORESOURCE_DMA      0x00000800
#define IORESOURCE_BUS      0x00001000

在不支持设备树的 Linux 内核版本中需要在通过 platform_device 结构体来描述设备信息，然后使用 platform_device_register 函数将设备信息注册到 Linux 内核中，此函数原型如下所示：

extern int platform_device_register(struct platform_device *);

②平台总线注销一个device

extern void platform_device_unregister(struct platform_device *);

③实验代码

该实验是在imx6ull中描述GPIO5_DR的寄存器的地址。device.c如下：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
//#include <linux/ioport.h> 

struct resource beep_res[] = {
	[0] = {
		.start = 0x20AC000,
		.end   = 0x20AC003,
		.flags = IORESOURCE_MEM,
		.name  = "GPIO5_DR"
	}
};

void beep_release(struct device *dev)
{
	printk("beep_release\n");
}

struct platform_device beep_device = {
	.name = "beep_test",//ls /sys/bus/platform/devices/可以看到
	.id   = -1,
	.resource = beep_res,
	.num_resources = ARRAY_SIZE(beep_res),
	.dev = {
		.release = beep_release
	}
};

static int device_init(void)
{
	printk("device_init \n");
	return platform_device_register(&beep_device);
}

static void  device_exit(void)
{
	platform_device_unregister(&beep_device);
	printk("device_exit \n");
}

module_init(device_init);
module_exit(device_exit);
MODULE_LICENSE("GPL");

3、注册platform驱动

①编写driver.c的思路

首先定义一个platform_driver结构体变量，然后去实现结构体中的各个成员变量，那么当我们的driver和device匹配成功的时候，就会执行probe函数，所以匹配成功以后的重点在于probe函数的编写。

struct platform_driver {
    int (*probe)(struct platform_device *);//当dricer和device匹配成功的时候，就会执行probe函数
    int (*remove)(struct platform_device *);//当driver和device任意一个remove的时候，就会执行这个函数。
    void (*shutdown)(struct platform_device *);//当设备收到shutdown命令的时候，就会执行这个函数。
    int (*suspend)(struct platform_device *, pm_message_t state);//当设备收到suspend命令的时候，就会执行这个函数。
    int (*resume)(struct platform_device *);
    struct device_driver driver;
    const struct platform_device_id *id_table;
    bool prevent_deferred_probe;
};

可以在probe函数注册杂项设备或者其他设备，有关device_driver结构体：在include/linux/device.h

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;
};

②实验代码

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
​
int beep_probe(struct platform_device *pdev)
{
    pritnk("beep_probe \n");
    return 0;
}
​
int beep_remove(struct platform_device *pdev)
{
    pritnk("beep_remove \n");
    return 0;
}
​
strcut platform_driver beep_driver = {
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "beep_test"
    }
};
​
static int beep_driver_init(void)
{
    printk("beep_driver_init \n");
    return platform_driver_register(&beep_driver);
}
​
static void  beep_driver_exit(void)
{
    platform_driver_unregister(&beep_driver);
    printk("beep_driver_exit \n");
}
​
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");

编译上面的驱动，加载驱动后发现没有进入probe函数。

③由于没进入probe函数第一次修改代码

可以发现这样写不会进入到probe函数。

④由于没进入probe函数第二次修改代码

可以发现这次调用了probe函数。

⑤总结

可以发现设备名称name要一样才能进入probe函数,id_table没有初始化值的时候，device name才会与结构体driver成员name匹配。否则会优先与id_table成员name进行匹配，匹配成功才会加载probe函数。

先加载driver.ko或先加载device.ko没有先后关系

4、平台总线probe函数编写

①编写probe函数的思路

(1)从device.c里面获得硬件资源

方法一：直接获得，不推荐

方法二：只用函数获得，在include/linux/platform_device.h

extern struct resource *platform_get_resource(struct platform_device *,
                          unsigned int, unsigned int);

(2)注册杂项设备/字符设备，完善file_operation结构体，并生成设备节点。

注册之前要先登记：

#define request_mem_region(start,n,name) __request_region(&iomem_resource, (start), (n), (name), 0)

对应的卸载驱动时也要释放掉：

#define release_mem_region(start,n) __release_region(&iomem_resource, (start), (n))

②实验代码

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
​
struct resource *beep_mem;
struct resource *beep_mem_tmp;
​
​
int beep_probe(struct platform_device *pdev)
{
    printk("beep_probe \n");
    //方法1
    //printk("beep_res is %s\n".pdev->resource[0].name);
​
    //方法2
    beep_mem  = platform_get_resource(pdev,IORESOURCE_MEM,0);
    if(beep_mem == NULL) {
        printk("platform_get_resource is error\n");
        return -EBUSY;
    }
​
    printk("platform_get_resource is ok\n");
    printk("beep_res start is 0x%x\n",beep_mem->start);
    printk("beep_res end is 0x%x\n",beep_mem->end);
​
    beep_mem_tmp = request_mem_region(beep_mem->start,beep_mem->end,beep_mem->end-beep_mem->start+1,"beep");
    if(beep_mem_tmp == NULL) {
        printk("request_mem_region is error\n");
        return -EBUSY;
    }
​
    return 0;
err_region:
    release_mem_region(beep_mem->start,beep_mem->end-beep_mem->start+1);
    return -EBUSY;
}
​
int beep_remove(struct platform_device *pdev)
{
    printk("beep_remove \n");
    return 0;
}
​
struct platform_driver beep_driver = {
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "beep_test"
    }
};
​
static int beep_driver_init(void)
{
    printk("beep_driver_init \n");
    return platform_driver_register(&beep_driver);
}
​
static void  beep_driver_exit(void)
{
    platform_driver_unregister(&beep_driver);
    printk("beep_driver_exit \n");
}
​
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");

编译加载驱动发现会报错：

原因是这个开发板的led驱动使用了该硬件资源，所以就会报错。

③在probe注册一个杂项设备代码

在probe函数注册一个杂项设备，会先获取gpio的硬件资源，通过读写杂项设备节点可以操作gpio。

#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h> 
#include <linux/miscdevice.h> 
#include <linux/fs.h> 
#include <linux/uaccess.h> 
#include <linux/io.h> 
​
struct resource *beep_mem;
struct resource *beep_mem_tmp;
unsigned int *vir_gpio5_dr;
​
ssize_t misc_write(struct file *file, const char __user *ubuf, size_t size, loff_t *off_t)
{
    char kbuf[64] = {0};
    
    printk("misc_write \n");
    if(copy_from_user(kbuf,ubuf,size) != 0) {
        printk("copy_from_user error\n");
        return -1;
    }
    printk("kbuf is %s \n",kbuf);
    if(kbuf[0] == 1)
        *vir_gpio5_dr |= (1<<1);
    else if(kbuf[1] == 0)
        *vir_gpio5_dr &= ~(1<<1);
    
    return 0;
}
ssize_t misc_read(struct file *file, char __user *user, size_t size, loff_t *loff_t)
{
    printk("misc_read \n");
    return 0;
}
​
int misc_open(struct inode *inode, struct file *file)
{
    printk("misc_release \n");
    return 0;
}
​
int misc_release (struct inode *inode, struct file *file)
{
    printk("misc_release \n");
    return 0;
}
​
struct file_operations misc_fops = {
    .owner = THIS_MODULE,
    .open = misc_open,
    .read = misc_read,
    .write = misc_write,
    .release = misc_release
};
​
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,//动态分配设备号
    .name  = "hello_misc",
    .fops  = &misc_fops
};
​
​
int beep_probe(struct platform_device *pdev)
{
    int ret = 0;
    printk("beep_probe \n");
    //方法1
    //printk("beep_res is %s\n".pdev->resource[0].name);
​
    //方法2
    beep_mem  = platform_get_resource(pdev,IORESOURCE_MEM,0);
    if(beep_mem == NULL) {
        printk("platform_get_resource is error\n");
        return -EBUSY;
    }
​
    vir_gpio5_dr = ioremap(beep_mem->start,4);
    if(vir_gpio5_dr == NULL) {
        printk("GPIO5_DR ioremap is error\n");
        return -EBUSY;
    }
    printk("GPIO5_DR ioremap is ok\n");
​
    ret = misc_register(&misc_dev);
    if(ret < 0) {
        printk("misc_register is error\n");
        return -1;
    }
    printk("misc_register is ok\n");
    return 0;
}
​
int beep_remove(struct platform_device *pdev)
{
    printk("beep_remove \n");
    return 0;
}
​
struct platform_driver beep_driver = {
    .probe = beep_probe,
    .remove = beep_remove,
    .driver = {
        .owner = THIS_MODULE,
        .name  = "beep_test"
    }
};
​
static int beep_driver_init(void)
{
    printk("beep_driver_init \n");
    return platform_driver_register(&beep_driver);
}
​
static void  beep_driver_exit(void)
{
    platform_driver_unregister(&beep_driver);
    misc_deregister(&misc_dev);
    iounmap(vir_gpio5_dr);
    printk("beep_driver_exit \n");
}
​
module_init(beep_driver_init);
module_exit(beep_driver_exit);
MODULE_LICENSE("GPL");

5、平台总线模型总结与回顾

6、设备树

请看下面这篇：

Linux驱动学习—设备树及设备树下的platform总线-CSDN博客

7、设备树下的platform总线

 请看下面这篇：

Linux驱动学习—设备树及设备树下的platform总线-CSDN博客

8.注册一个 platform 驱动的两种方法

具体方法请参考这篇：

module_platform_driver()-CSDN博客

8.1 方法一：就是本文所介绍的传统方法

就是本文所介绍的传统方法，如下：

static int __init xxx_init(void)
{
    return platform_driver_register(&xxx_driver);
}
module_init(xxx_init);
// 驱动模块卸载 
static void __exit xxx_exit(void)
{
    platform_driver_unregister(&xxx_driver);
}
module_exit(xxx_exit);

8.2 方法二：使用采用 module_platform_driver 来完成向 Linux 内核注册 platform 驱动的操作

module_platform_driver 定义在 include/linux/platform_device.h 文件中，如下：

/* module_platform_driver() - Helper macro for drivers that don't do
 * anything special in module init/exit.  This eliminates a lot of
 * boilerplate.  Each module may only use this macro once, and
 * calling it replaces module_init() and module_exit()
 */
#define module_platform_driver(__platform_driver) \
	module_driver(__platform_driver, platform_driver_register, \
			platform_driver_unregister)

可以看出，module_platform_driver 依赖 module_driver，module_driver 也是一个宏，定义在include/linux/device.h 文件中，内容如下：

#define module_driver(__driver, __register, __unregister, ...) \
static int __init __driver##_init(void) \
{ \
	return __register(&(__driver) , ##__VA_ARGS__); \
} \
module_init(__driver##_init); \
static void __exit __driver##_exit(void) \
{ \
	__unregister(&(__driver) , ##__VA_ARGS__); \
} \
module_exit(__driver##_exit);

具体驱动代码中使用如下所示:：

module_platform_driver(xxx_driver);

可见方法一就是方法二的展开形式。