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
#include
#include
//#include
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
#include
#include
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
#include
#include
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
#include
#include
#include
#include
#include
#include
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博客