linux驱动笔记（六）：虚拟总线platform

                   

                             

 

设备（硬件部分）：中断号，寄存器，DMA等	驱动（软件部分）
platform_device 结构体	platform_driver 结构体
struct platform_device {      const char    *name;       名字     int        id;     bool        id_auto;     struct device     dev;   硬件模块必须包含该结构体     u32         num_resources;        资源个数      struct resource    *resource;         资源  人脉     const struct platform_device_id    * id_entry;     /* arch specific additions */     struct pdev_archdata    archdata; };	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;  八字 };
设备实例： static struct platform_device hello_device= {     .name = "bigbang",     .id = -1,     .dev.release = hello_release, };	驱动实例： static struct platform_driver hello_driver= {     .driver.name = "bigbang",     .probe = hello_probe,     .remove = hello_remove, };

 

 

一、总线BUS

Platform总线是2.6 kernel中最近引入的一种虚拟总线，主要用来管理CPU的片上资源，具有更好的移植性，因此在2.6 kernel中，很多驱动都用platform改写了。

platform_bus_type的定义如下:
/drivers/base/platform.c#L609
609struct bus_type platform_bus_type = {
 610        .name           = "platform",
 611        .dev_attrs      = platform_dev_attrs,
 612        .match          = platform_match,
 613        .uevent         = platform_uevent,
 614        .suspend        = platform_suspend,
 615        .suspend_late   = platform_suspend_late,
 616        .resume_early   = platform_resume_early,
 617        .resume         = platform_resume,
 618};
 619EXPORT_SYMBOL_GPL(platform_bus_type);

 

/include/linux/device.h
  55struct bus_type {
  56        const char              *name;
  57        struct bus_attribute    *bus_attrs;
  58        struct device_attribute *dev_attrs;
  59        struct driver_attribute *drv_attrs;
  60
  61        int (*match)(struct device *dev, struct device_driver *drv);
  62        int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
  63        int (*probe)(struct device *dev);
  64        int (*remove)(struct device *dev);
  65        void (*shutdown)(struct device *dev);
  66
  67        int (*suspend)(struct device *dev, pm_message_t state);
  68        int (*suspend_late)(struct device *dev, pm_message_t state);
  69        int (*resume_early)(struct device *dev);
  70        int (*resume)(struct device *dev);
  71
  72        struct bus_type_private *p;
  73};

总线名称是"platform"，其只是bus_type的一种，定义了总线的属性，同时platform_bus_type还有相关操作方法，如挂起、中止、匹配及hotplug事件等。

总线bus是联系driver和device的中间枢纽。Device通过所属的bus找到driver，由match操作方法进行匹配
 

二、设备端platform_device

从device封装而来的platform_device
struct platform_device {
    const char    * name;
    int        id;
    struct device    dev;
    u32        num_resources;
    struct resource    * resource;
 
    struct platform_device_id    *id_entry;
 
    /* arch specific additions */
    struct pdev_archdata    archdata;

｝

platform_device 中的 id 的作用：

    if (pdev->id != -1)      /* 如果不是-1 对name编号 */  
        dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);  
    else                             /* -1时直接是名字 */
        dev_set_name(&pdev->dev, pdev->name); 

name，设备的名称，该名称在设备注册时，会拷贝到dev.init_name中。
    dev，真正的设备，通过 container_of ,就能找到整个platform_device ，访问其它成员，如后面要提到的 resource 
    num_resources、resource，该设备的资源描述，由struct resource（include/linux/ioport.h）结构抽象
 

struct resource {
    resource_size_t start;
    resource_size_t end;
    const char *name;
    unsigned long flags;
    struct resource *parent, *sibling, *child;
};

#define IORESOURCE_MEM        0x00000200
#define IORESOURCE_IRQ        0x00000400   
       flags 指资源类型，我们常用的是 IORESOURCE_MEM、IORESOURCE_IRQ  这两种。start 和 end 的含义会随着 flags而变更，如

a -- flags为IORESOURCE_MEM 时，start 、end 分别表示该platform_device占据的内存的开始地址和结束值；  

b -- flags为 IORESOURCE_IRQ   时，start 、end 分别表示该platform_device使用的中断号的开始地址和结束值

static struct resource led_resource[] = {    //jz2440的参数，驱动未测试 
    [0] = {
        .start = 0x56000010,
        .end   = 0x56000010 + 8 - 1,
        .flags = IORESOURCE_MEM,
    },
    [1] = {
        .start = 5,
        .end   = 5,
        .flags = IORESOURCE_IRQ,
    },
};
static struct platform_device led_dev = {
    .name = "myled",    //设备名字 与 驱动相匹配
    .id      = -1,
    .num_resources = ARRAY_SIZE(led_resource),
    .resource = led_resource,
    
    .dev = {
        .release = led_release,
        //.devt = MKDEV(252, 1),
    },
};

Platform Device提供的API
/* include/linux/platform_device.h */
extern int platform_device_register(struct platform_device *);
extern void platform_device_unregister(struct platform_device *);
 
extern void arch_setup_pdev_archdata(struct platform_device *);
extern struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);
extern int platform_get_irq(struct platform_device *, unsigned int);
extern struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, const char *);
extern int platform_get_irq_byname(struct platform_device *, const char *);
extern int platform_add_devices(struct platform_device **, int);
 
extern struct platform_device *platform_device_register_full(const struct platform_device_info *pdevinfo);
 
static inline struct platform_device *platform_device_register_resndata(
                struct device *parent, const char *name, int id,
                const struct resource *res, unsigned int num,
                const void *data, size_t size)
 
static inline struct platform_device *platform_device_register_simple(
                const char *name, int id,
                const struct resource *res, unsigned int num)
 
static inline struct platform_device *platform_device_register_data(
                struct device *parent, const char *name, int id,
                const void *data, size_t size)
 
extern struct platform_device *platform_device_alloc(const char *name, int id);
extern int platform_device_add_resources(struct platform_device *pdev,
                                         const struct resource *res,
                                         unsigned int num);
extern int platform_device_add_data(struct platform_device *pdev,
                                    const void *data, size_t size);
extern int platform_device_add(struct platform_device *pdev);
extern void platform_device_del(struct platform_device *pdev);
extern void platform_device_put(struct platform_device *pdev);

其中：
    platform_device_register、platform_device_unregister，Platform设备的注册/注销接口，和底层的device_register等接口类似。
    arch_setup_pdev_archdata，设置platform_device变量中的archdata指针。
    platform_get_resource、platform_get_irq、platform_get_resource_byname、platform_get_irq_byname，通过这些接口，可以获取platform_device变量中的resource信息，以及直接获取IRQ的number等等。
    platform_device_register_full、platform_device_register_resndata、platform_device_register_simple、platform_device_register_data，其它形式的设备注册。调用者只需要提供一些必要的信息，如name、ID、resource等，Platform模块就会自动分配一个struct platform_device变量，填充内容后，注册到内核中。
    platform_device_alloc，以name和id为参数，动态分配一个struct platform_device变量。
    platform_device_add_resources，向platform device中增加资源描述。
    platform_device_add_data，向platform device中添加自定义的数据（保存在pdev->dev.platform_data指针中）。
    platform_device_add、platform_device_del、platform_device_put，其它操作接口
 

二、驱动端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;
    struct platform_device_id *id_table;
};
int platform_driver_register(struct platform_driver *drv)
{
    drv->driver.bus = &platform_bus_type;
    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);
}

Platform Driver提供的API
    platform_driver_registe、platform_driver_unregister，platform driver的注册、注销接口。
    platform_driver_probe，主动执行probe动作。
    platform_set_drvdata、platform_get_drvdata，设置或者获取driver保存在device变量中的私有数据。

懒人API
 extern struct platform_device *platform_create_bundle(
       struct platform_driver *driver, int (*probe)(struct platform_device *),
       struct resource *res, unsigned int n_res,
       const void *data, size_t size);
    只要提供一个platform_driver（要把driver的probe接口显式的传入），并告知该设备占用的资源信息，platform模块就会帮忙分配资源，并执行probe操作。对于那些不需要热拔插的设备来说，这种方式是最省事的了。  
 

 

具体例子

设备端：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/sched.h> 
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <linux/input.h>
#include <linux/platform_device.h>
// 设备资源
static struct resource led_resource[] = {    //jz2440的参数，驱动未测试 
    [0] = {
        .start = 0x56000010,
        .end   = 0x56000010 + 8 - 1,
        .flags = IORESOURCE_MEM,
    },
    [1] = {
        .start = 5,
        .end   = 5,
        .flags = IORESOURCE_IRQ,
    },
};
 
static void led_release(struct device *dev){
 
}
 
// 创建一个设备
static struct platform_device led_dev = {
    .name = "myled",    //设备名字 与 驱动相匹配
    .id      = -1,
    .num_resources = ARRAY_SIZE(led_resource),
    .resource = led_resource,
    
    .dev = {
        .release = led_release,
        //.devt = MKDEV(252, 1),
    },
};
 
static int led_dev_init(void){
 
    //向bus注册led_dev match drv链表进行配对
    platform_device_register(&led_dev);
    return 0;
}
 
static void led_dev_exit(void){
    platform_device_unregister(&led_dev);
}
 
module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");

驱动端：

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/interrupt.h>
#include <linux/sched.h> 
#include <linux/irq.h>
#include <asm/uaccess.h>
 
#include <linux/platform_device.h>
#include <linux/io.h>
 
static int major;
 
static struct class *cls;
static struct device *dev;
 
static volatile unsigned long *gpio_con;
static volatile unsigned long *gpio_dat;
static int pin;
 
static int led_open(struct inode *inode, struct file *file){
 
    *gpio_con &= ~(0x03 << (pin*2));
    *gpio_con |=  (0x01 << (pin*2));
    return 0;
}
 
static ssize_t led_write(struct file *file, const char __user *buf,
    size_t count, loff_t *ppos){
 
    int val;
    copy_from_user(&val, buf, count);
 
    if(val == 1){
        
        *gpio_dat &= ~(1<<pin);
    }else{
    
        *gpio_dat &=  (1<<pin);
    }
 
    return 0;
}
 
static struct file_operations led_fops = {
 
    .owner = THIS_MODULE,
    .open  = led_open,
    .write = led_write,
};
 
static int led_probe(struct platform_device *pdev){
 
    struct resource *res;
    // 最后一个参数 0 表示第1个该类型的资源
    res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    gpio_con = ioremap(res->start, res->end - res->start + 1);
    gpio_dat = gpio_con + 1;
 
    res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
    pin = res->start;
 
    printk("led_probe, found led\n");
 
    // 注册设备驱动 创建设备节点
    major = register_chrdev(0, "myled", &led_fops);
    // 创建类
    cls = class_create(THIS_MODULE, "myled");
    // 创建设备节点
    dev = device_create(cls, NULL, MKDEV(major, 0), NULL, "led");
 
    return 0;
}
 
static int led_remove(struct platform_device *pdev){
 
    printk("led_remove, remove led\n");    
    // 删除设备节点
    device_unregister(dev);
    // 销毁类
    class_destroy(cls);
    // 取消注册设备驱动
    unregister_chrdev(major, "myled");
    // 取消内存映射
    iounmap(gpio_con);
 
    return 0;
}
 
struct platform_driver led_drv = {
 
    .probe     = led_probe,    //匹配到dev之后调用probe
    .remove = led_remove,
    .driver = {
        .name = "myled",
    },
};
 
static int led_drv_init(void){
 
    platform_driver_register(&led_drv);
    return 0;
}
 
static void led_drv_exit(void){
    
    platform_driver_unregister(&led_drv);
}
 
module_init(led_drv_init);
module_exit(led_drv_exit);

 

 

总结：如何将现有的驱动驱动融入platform框架中

以 globalfifo驱动挂载在platform总线上为例子，需要完成两个工作：

1. 将globalfifo驱动移植为platform驱动

2. 在板级文件中添加 globalfifo这个 platform设备。

为了完成 目标1，只需要在原始的globalfifo字符设备驱动中，套上一层platform_driver的外壳，注意，这一工作，并没有改变globalfifo是字符设备的本质，只是将其挂接在 platform总线上。

再具体来说，就是讲驱动的入口函数，由原先的globalfifo_init改为 globalfifo_probe ，出口函数由原先的globalfifo_exit改为 globalfifo_remove，在注册和注销中，将平台驱动结构体整个与系统关联起来就可以了。

  

    为了完成目标2，需要在板级初始化上添加平台设备，定义好驱动程序即将使用的资源类型和数量，然后将平台设备结构体嵌入到板级平台设备结构体指针数组中去就可以了。