[arm驱动]Platform设备驱动

Tip:红色字体为简要部分
《[arm驱动]Platform设备驱动》涉及内核驱动函数五个，内核结构体三个，分析了内核驱动函数四个；可参考的相关应用程序模板或内核驱动模板零个，可参考的相关应用程序或内核驱动二个
想了解platform总线管理方式的原理 参考[arm驱动]Platform总线原理

前言扩展
1、sysfs文件系统
设备模型sysfs是2.6内核新引入的特征。设备模型提供了一个独立的机制专门来表示设备，并描述其在系统中的拓扑结构。
在2.4内核中，设备的信息放在/proc中。
而在2.6内核，内核把设备相关的信息归类在新增加sysfs文件系统，并将它挂载到/sys目录中，把设备信息归类的同时，让用户可以通过用户空间访问。
2、sys中的目录：
block：用于管理块设备，系统中的每一个块设备会在该目录下对应一个子目录。
bus：用于管理总线，每注册一条总线，在该目录下有一个对应的子目录。(重要)
其中，每个总线子目录下会有两个子目录：devices和drivers。
devices包含里系统中所有属于该总线的的设备。(重要)
drivers包含里系统中所有属于该总线的的驱动。(这个好像在linux2.6以上版本剔除了)
class：将系统中的设备按功能分类。(重要)
devices：该目录提供了系统中设备拓扑结构图。
dev：该目录已注册的设备节点的视图。
kernel：内核中的相关参数。
module：内核中的模块信息。
fireware：内核中的固件信息。
Fs：描述内核中的文件系统。
3、总线，设备，驱动对应的定义struct bus_type,devices,drivers;
4、总线:总线不是字符设备、块设备和网络设备并列的概念，它是一种"设备"和"驱动"的管理者,总线通过分别遍历"设备(device)"和”驱动(driver)"链表如果发现name是一样的就将调device_bind_driver将name对应的设备(device)和驱动(driver)绑定好。
5、总的来说:对于总线型设备驱动，我们只要关心如何将设备(device)和驱动(driver)挂载到总线上就行了;剩下的工作就交给了内核了:设备(device)如果配备驱动(driver)由内核的总线来管理
6、总线的工作方式案例:以USB为例(u盘、键盘、鼠标设备都算usb)
a)古老的方式：
先有device,每一个要用的device在计算机启动之前就已经插好了,插放在它应该在的位置上,然后计算机启动,然后操作系统开始初始化,总线开始扫描设备,每找到一个设备,就为其申请一个struct device结构,并且挂入总线中的devices链表中来；然后每一个驱动程序开始初始化,开始注册其struct device_driver结构,然后它去总线的devices链表中去寻找(遍历),去寻找每一个还没有绑定driver的设备,即struct device中的struct device_driver指针仍为空的设备,然后它会去观察这种设备的特征,看是否是他所支持的设备,如果是,那么调用一个叫做device_bind_driver的函数,然后他们就结为了秦晋之好.
b)现在的方式：
device可以在任何时刻出现,而driver也可以在任何时刻被加载,所以,出现的情况就是,每当一个struct device诞生,它就会去bus的drivers链表中寻找自己的另一半,反之,每当一个一个struct device_driver诞生,它就去bus的devices链表中寻找它的那些设备.如果找到了合适的,那么ok,和之前那种情况一下,调用device_bind_driver绑定好.如果找不到,没有关系,等待
7）platform总线是bus总线的一条子总线，可以理解为platform继承了bus，platform是bus的子类

一、platform设备驱动
platform继承bus,文件位于/sys/bus/platform下;/sys//bus/platform/device文件夹和/sys/bus/platform/driver目录下的文件分别是对应platform总线的"设备(device)“驱动(driver)"。与传统的bus/device/driver机制相比，platform由内核进行统一管理，在驱动中使用资源，提高了代码的安全性和可移植性。

1.一个现实的Linux设备和驱动通常都需要挂接在一种总线上，对于本身依附于PCI、USB、I2C、SPI等的设备而言，这自然不是问题，
但是在嵌入式系统里面，SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设等确不依附于此类总线。
基于这一背景，Linux发明了一种虚拟的总线，称为platform总线，相应的设备称为platform_device，而驱动成为 platform_driver。

2.注意，所谓的platform_device并不是与字符设备、块设备和网络设备并列的概念，而是Linux系统提供的一种附加手段，
例如，在 S3C6410处理器中，把内部集成的I2C、RTC、SPI、LCD、看门狗等控制器都归纳为platform_device，而它们本身就是字符设备。

二、设备(device)驱动(driver)相关结构体
结构体一)platform设备(device)结构体platform_device

struct platform_device {     //设备结构体信息
const char      * name;     //该平台设备的名称
u32             id;      //设备id，用于给插入给该总线并且具有相同name的设备编号，如果只有一个设备的话填-1。
struct device   dev;    ///结构体中内嵌的device结构体
u32             num_resources;    //设备使用的资源的数目
struct resource * resource;         //定义平台设备的资源
};

结构体二)device结构体中的resources

struct resource {
resource_size_t start;      //定义资源的起始地址
resource_size_t end;       //定义资源的结束地址
const char *name;                   //定义资源的名称
unsigned long flags;           //定义资源的类型，例如MEM, IO ,IRQ, DMA类型
struct resource *parent, *sibling, *child;     //资源链表指针
};

结构体三)platform 驱动(driver)结构体

struct platform_driver {
int (*probe)(struct platform_device *);
//driver和device注册之后，会触发平台设备和驱动的匹配函数platform_match，匹配成功，则会调用平台设备驱动的probe()函数
int (*remove)(struct platform_device *);        //删除该设备
void (*shutdown)(struct platform_device *);    //关闭该设备
int (*suspend)(struct platform_device *, pm_message_t state);//电源管理挂起
int (*suspend_late)(struct platform_device *, pm_message_t state);//电源管理挂起
int (*resume_early)(struct platform_device *);//电源管理唤醒
int (*resume)(struct platform_device *);//电源管理唤醒
struct device_driver driver;                         //老设备驱动，定义在include/linux/device.h中
};

三、设备(device)驱动(driver)相关定义、注册函数
1设备结构体定义和注册
1)、设备platform_device变量的定义
方式a)使用platform_device结构体数组定义
单个设备结构platform_device体定义

static struct platform_device platformthird_dev_device = {  //单个设备结构体定义
.name = "platformthird_dev",
.id = -1,
};

多个设备结构体定义

static struct platform_device platformthird_dev_device[] = {  //多个设备结构体定义
[0] = {.name = "platformthird_dev",
.id = 0,
},
[1] = {.name = "platformthird_dev",
.id = 1,
},
[2] = {.name = "platformthird_dev",
.id = 2,
},
//................
};

函数一)b)动态定义方式一个platform_device

struct platform_device * platform_device_alloc(const char * name, unsigned int id)

如:

struct platform_device *platformthird_dev_device = platform_device_alloc("platform_led", -1);
//-1表示只有一个设备

2)、设备(device)注册函数
函数二)单个设备(device)的注册:platform_device_register(struct platform_device * pdev);
内核源码一)

int platform_device_register(struct platform_device *pdev)
{
device_initialize(&pdev->dev);//dev初始化
arch_setup_pdev_archdata(pdev);
return platform_device_add(pdev);//加入到dev链表
}
//int platform_device_add(struct platform_device *pdev)内核源码
int platform_device_add(struct platform_device *pdev)
{
int i, ret = 0;
if (!pdev)
return -EINVAL;
if (!pdev->dev.parent)
pdev->dev.parent = &platform_bus;
pdev->dev.bus = &platform_bus_type;
//id = -1时的操作
if (pdev->id != -1)
snprintf(pdev->dev.bus_id, BUS_ID_SIZE, "%s.%u", pdev->name, pdev->id);
else
strlcpy(pdev->dev.bus_id, pdev->name, BUS_ID_SIZE);
for (i = 0; i < pdev->num_resources; i++) {
struct resource *p, *r = &pdev->resource[i];
if (r->name == NULL)
r->name = pdev->dev.bus_id;
p = r->parent;
if (!p) {
if (r->flags & IORESOURCE_MEM)
p = &iomem_resource;
else if (r->flags & IORESOURCE_IO)
p = &ioport_resource;
}
if (p && insert_resource(p, r)) {
printk(KERN_ERR
"%s: failed to claim resource %d\n",
pdev->dev.bus_id, i);
ret = -EBUSY;
goto failed;
}
}
pr_debug("Registering platform device '%s'. Parent at %s\n",
pdev->dev.bus_id, pdev->dev.parent->bus_id);
ret = device_add(&pdev->dev);
if (ret == 0)
return ret;
failed:
while (--i >= 0)
if (pdev->resource[i].flags & (IORESOURCE_MEM|IORESOURCE_IO))
release_resource(&pdev->resource[i]);
return ret;
}

函数三)多个设备(device)的注册:

platform_add_devices(struct platform_device **devs, int num)

内核源码三)

//platform_add_devices调用了platform_device_register
int platform_add_devices(struct platform_device **devs, int num)
{
int i, ret = 0;
for (i = 0; i < num; i++) {
ret = platform_device_register(devs[i]);
if (ret) {
while (--i >= 0)
platform_device_unregister(devs[i]);
break;
}
}
return ret;
}

如：

platform_add_devices(platformthird_dev_device,  ARRAY_SIZE(platformthird_dev_device));

2、驱动(driver)结构体定义和注册
a)platform_driver结构体的定义如：

static struct platform_driver platformthird_dev_driver = {
.probe = platformthird_dev_probe,
.remove = platformthird_dev_remove,
.driver = {
.name = "platformthird_dev",//名字要和设备(device)的名字一样
.owner = THIS_MODULE,
}

函数四)platform_driver结构体的注册

platform_driver_register(struct platform_driver *drv)

如:

platform_driver_register(&platformthird_dev_driver)

内核源码四)

int platform_driver_register(struct platform_driver *drv)
{
drv->driver.bus =&platform_bus_type;
//总线platform_bus_type就是指platform总线，详细见(五、platform总线管理方式的原理)
/*设置成platform_bus_type这个很重要，因为driver和device是通过bus联系在一起的，
具体在本例中是通过 platform_bus_type中注册的回调例程和属性来是实现的,
driver与device的匹配就是通过 platform_bus_type注册的回调例程platform_match ()来完成的。
*/
if(drv->probe)
drv-> driver.probe = platform_drv_probe;
if(drv->remove)
drv->driver.remove = platform_drv_remove;
if(drv->shutdown)
drv->driver.shutdown = platform_drv_shutdown;//电源设备
return driver_register(&drv->driver);
//注册驱动,将drv的driver添加到总线的driver链表中
}

函数五)int (*probe)(struct platform_device *);//driver被insmod后，会触发平台设备和驱动的匹配函数platform_match匹配成功，则会调用平台设备驱动的probe()函数;详细看五、platform总线管理方式的原理。
driver结构体几个函数的运行顺序
插入driver==>触发平台设备和驱动的匹配函数platform_match匹配，成功则调用probe()==>当device被卸载时就会调用remove

四、实例
实例一）实验一、只添加一个名为name的驱动(driver)到总线上，此时只创建名称为name驱动文件夹/sys/bus/platform/driver/name

/*
*本程序只涉及platform的driver(驱动);未涉及device。
*/
#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/platform_device.h>
MODULE_LICENSE("GPL");

static int test_probe(struct platform_device *dev)//
{
printk("driver say the driver found the device\n");
return 0;
}
static int test_remove(struct platform_device *dev)
{
printk("driver say the device is polled out\n");
return 0;
}
//platform 总线相关文件挂载/sys/bus/platform/路径下
static struct platform_driver test_driver = {//driver是驱动的意思，相关文件在/sys/bus/platform/drivers
.probe = test_probe,//注册时要执行的函数
.remove = test_remove,//注销时会执行的函数
.driver = {
.owner = THIS_MODULE,
.name = "platform_dev",//会在"/sys/bus/platform/drivers"下创建platform_dev文件夹
},
};
static int __init test_driver_init(void)
{
/*注册平台驱动*/
return platform_driver_register(&test_driver);
}
static void test_driver_exit(void)
{
platform_driver_unregister(&test_driver);
}
module_init(test_driver_init);
module_exit(test_driver_exit);

实例二)实验二、只添加一个名为names(driver)到总线上，此时只创建名称为name驱动文件夹/sys/bus/platform/drivers/name

#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/platform_device.h>
#include <linux/fs.h>//文件系统相关的函数和头文件
#include <linux/device.h>
#include <linux/cdev.h> //cdev结构的头文件包含<linux/kdev_t.h>
static void platformthird_dev_release(struct device * dev){
printk("device say the device is release\n");
return;
}
static struct platform_device platformthird_dev_device = {  //添加设备结构体
.name = "platform_dev",
.id = -1,
.dev = {
.release = platformthird_dev_release,//解决"Device 'platform_dev' does not have a release() function“问题
}
};
static int  __init platformthird_dev_init(void){
platform_device_register(&platformthird_dev_device);  //注册设备到内核
return 0;
}
static void platformthird_dev_exit(void){
platform_device_unregister(&platformthird_dev_device);  //卸载设备
printk(KERN_ALERT "good bye\n");
}
module_init(platformthird_dev_init);
module_exit(platformthird_dev_exit);
MODULE_LICENSE("GPL");

实例一和实例二的Makefile如下

KERN_DIR = /workspacearm/linux-2.6.2.6
#platform_device_test.ko
all:
make -C $(KERN_DIR) M=`pwd` modules
cp platform_device_test.ko /opt/fsmini/
cp platform_driver_test.ko /opt/fsmini/
clean:
make -C $(KERN_DIR) M=`pwd` modules clean
rm -rf modules.order
rm -rf Module.symvers
obj-m   += platform_device_test.o
obj-m   += platform_driver_test.o

Make一下，在开发板上加载驱动，结果如下输出

# insmod platform_driver_test.ko
# insmod platform_device_test.ko
driver say the driver found the device
# rmmod platform_device_test.ko
driver say the device is polled out
device say the device is release
good bye

# rmmod platform_driver_test.ko
#

实验结论:从前面三句可以看的出来，当driver没有device时，会一直等候device的接入,类似热插拔，当有对应name的device时执行probe;从第四句可以知道当设备被拔出时候,driver执行remove。验证了:插入driver==>触发平台设备和驱动的匹配函数platform_match匹配，成功则调用probe()
实例三)实验三、创建名称为name的/sys/bus/platform/drivers/name和/sys/bus/platform/devices/name文件夹

/*
*本程序实现将字符设备挂载在总线上，只是在原来的的基础上加上一层platform_driver的外壳。
*将驱动设备device挂载在总线上，这样的好处是:总线将设备(device)和驱动(driver)绑定，当有事件发生时就会调用相应驱动函数来完成，如智能电源管理(挂起,休眠，关机唤醒等等)，热插拔，即插即用的支持
*
*/
#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/platform_device.h>
#include <linux/fs.h>//文件系统相关的函数和头文件
#include <linux/device.h>
#include <linux/cdev.h> //cdev结构的头文件包含<linux/kdev_t.h>
#define VIRTUALDISK_MAJOR 250
int VirtualDisk_major = VIRTUALDISK_MAJOR;
static int  platformthird_dev_probe(struct platform_device *pdev){
return 0;
}
static int platformthird_dev_remove(struct platform_device *pdev){
return 0;
}
static struct platform_device platformthird_dev_device = {  //添加设备结构体
.name = "platformthird_dev",
.id = -1,
};
static struct platform_driver platformthird_dev_driver = {
.probe = platformthird_dev_probe,
.remove = platformthird_dev_remove,
.driver = {
.name = "platformthird_dev",
.owner = THIS_MODULE,
}
};
static int  __init platformthird_dev_init(void){
int ret = 0;
platform_device_register(&platformthird_dev_device);  //注册设备到内核总线
ret = platform_driver_register(&platformthird_dev_driver);  //注册驱动到内核总线
if (ret){
printk(KERN_ERR "failed to register\n");
}
return ret;
}
static void platformthird_dev_exit(void){
platform_device_unregister(&platformthird_dev_device);  //卸载设备
platform_driver_unregister(&platformthird_dev_driver);  //卸载驱动
printk(KERN_ALERT "good bye\n");
}
module_init(platformthird_dev_init);
module_exit(platformthird_dev_exit);
MODULE_LICENSE("GPL");

实例四)实验四，给以前写的一般驱动代码加platform壳,原来只是创建/dev/***,注册class,class_device(对应/sys/class文件夹下****文件夹)

/*
*本程序实现将字符设备挂载在总线上，只是在原来的的基础上加上一层platform_driver的外壳。
*将驱动设备device挂载在总线上，这样的好处是:总线将设备(device)和驱动(driver)绑定，当有事件发生时就会调用相应驱动函数来完成，如智能电源管理(挂起,休眠，关机唤醒等等)，热插拔，即插即用的支持
*
*/
#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include <linux/platform_device.h>
#include <linux/fs.h>//文件系统相关的函数和头文件
#include <linux/device.h>
#include <linux/cdev.h> //cdev结构的头文件包含<linux/kdev_t.h>
#define VIRTUALDISK_MAJOR 250
int VirtualDisk_major = VIRTUALDISK_MAJOR;
struct cdev cdev;
static struct class *platform_class;
static struct class_device  *platform_class_dev;
static int platform_drv_open(struct inode *inode, struct file *file)
{
printk("platform_dev read\n");
return 0;
}
static int platform_drv_release(struct inode *inode, struct file *file)
{
printk("platform_dev release\n");
return 0;
}
static struct file_operations platform_drv_fops = {
.owner  =   THIS_MODULE,    /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
.release = platform_drv_release,
.open = platform_drv_open,
};
static int  platform_dev_probe(struct platform_device *pdev){
int result;
int err;
dev_t devno = MKDEV(VirtualDisk_major, 0);
if(VirtualDisk_major){
result = register_chrdev_region(devno, 1, "platform_dev");
}else{
result = alloc_chrdev_region(&devno, 0, 1, "platform_dev");
VirtualDisk_major = MAJOR(devno);
}
if(result < 0 ){
return result;
}
cdev_init(&cdev, &platform_drv_fops);
cdev.owner = THIS_MODULE;
err = cdev_add(&cdev, devno, 1);
if(err){
printk("error %d cdev file added\n", err);
}
platform_class = class_create(THIS_MODULE, "platform_dev");
if (IS_ERR(platform_class))
return PTR_ERR(platform_class);
platform_class_dev = class_device_create(platform_class, NULL, MKDEV(VirtualDisk_major, 0), NULL, "platform_dev"); /* /dev/xyz */
if (IS_ERR(platform_class_dev))
return PTR_ERR(platform_class_dev);

return 0;
}
static int platform_dev_remove(struct platform_device *pdev){
cdev_del(&cdev);
unregister_chrdev_region(MKDEV(VirtualDisk_major, 0), 1);
class_device_unregister(platform_class_dev);
class_destroy(platform_class);
return 0;
}
static void platform_device_release(struct device * dev){
return;
}
static struct platform_device platform_dev_device = {  //添加设备结构体
.name = "platform_dev",
.id = -1,
.dev = {
.release = platform_device_release,//解决"Device 'platform_dev' does not have a release() function“问题
}
};
static struct platform_driver platform_dev_driver = {
.probe = platform_dev_probe,
.remove = platform_dev_remove,
.driver = {
.name = "platform_dev",
.owner = THIS_MODULE,
}
};
static int  __init platform_dev_init(void){
int ret = 0;
platform_device_register(&platform_dev_device);  //注册设备到内核
ret = platform_driver_register(&platform_dev_driver);  //注册驱动到内核
if (ret){
printk(KERN_ERR "failed to register\n");
}

return ret;
}
static void platform_dev_exit(void){
platform_device_unregister(&platform_dev_device);  //卸载设备
platform_driver_unregister(&platform_dev_driver);  //卸载驱动

printk(KERN_ALERT "good bye\n");
}
module_init(platform_dev_init);
module_exit(platform_dev_exit);
MODULE_LICENSE("GPL");

五、platform总线管理方式的原理
参考[arm驱动]Platform总线原理