Linux platform总线

以你之姓@ 2024-04-17 05:50 64阅读 0赞

# Linux platform总线 #

### 文章目录 ###

*  Linux platform总线
 *   *  一、总线概念
     *  二、platform驱动框架详解
     *   *  2.1 platform驱动框架
         *  2.2 platform\_device和platform\_driver的匹配规则
         *  2.3 platform\_device中的资源描述
     *  三、platform驱动框架源码剖析
     *  四、platform驱动程序模板

## 一、总线概念 ##

在Linux驱动模型中总要关心三个对象：`总线`、`设备`、`驱动`

**总线**指i2c总线、spi总线、usb总线等总线，它们管理着设备和驱动

**设备**描述了硬件信息

**驱动**是具体的驱动的实现

当向总线注册设备时，会寻找与之匹配的驱动。反之，当注册驱动时，会寻找与之匹配的设备

使用这种机制可以使得一个驱动程序给多个硬件设备使用，实现了硬件与软件的分离

对于一个设备总要附于某一条总线上，如i2c总线、spi总线、usb总线等，当有的设备如led，并不是接在某一具体的总线上，而内核为了实现`总线`、`设备`、`驱动`这种模型，所以就产生了虚拟总线（platform总线）

## 二、platform驱动框架详解 ##

### 2.1 platform驱动框架 ###

platform总线相应的设备和驱动分别为`platform_device`和`platform_driver`

所谓`platform_device`并不是和字符设备、块设备、网络设备并列的概念，而是内核提供的一种机制

**platform\_device结构体定义如下**

struct platform_device {
        
    	const char		*name;
    	struct device	dev;
    	u32			    num_resources;
    	struct resource	*resource;
    	...
    };

`name`是platform\_device的名称，此名称将会被用于和platform\_driver的匹配规则中

`dev`表明这是一个设备

`resource`描述硬件资源

`num_resources`表明`resource`所指的数组有几项

注册设备的接口为

int platform_device_register(struct platform_device *);
    void platform_device_unregister(struct platform_device *);

**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;
    	const struct platform_device_id *id_table;
    };

`platform_driver`中定义了probe、remove等一系列函数，其中的probe函数将在驱动和设备匹配时被调用

`driver`表明这是一个驱动，`id_table`将用于与`platform_device`的匹配规则中

注册驱动的接口为

int platform_driver_register(struct platform_driver *);
    void platform_driver_unregister(struct platform_driver *);

**platform总线结构体如下**

struct bus_type platform_bus_type = {
        
    	.name		= "platform",
    	.dev_attrs	= platform_dev_attrs,
    	.match		= platform_match,
    	.uevent		= platform_uevent,
    	.pm			= &platform_dev_pm_ops,
    };

platform总线并不是直接暴露给驱动开发者，它是一个幕后工作者，管理者`platform_device`和`platform_driver`

其中`platform_match`定义了设备和驱动的匹配规则

总线维护一个设备链表和一个驱动链表，当注册设备时，会遍历驱动链表，调用总线的匹配规则，如果匹配就调用驱动的probe函数，注册驱动时同理

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70]

以上就是platform的驱动框架

### 2.2 platform\_device和platform\_driver的匹配规则 ###

对于platform\_device和platform\_driver的匹配规则，要分析`platform_match`函数，这里先给出结论，后头再分析源码

**第一种情况**

匹配`platform_driver`中的`id_table数组`元素的`name`和`platform_device`的`name`（字符串匹配）

struct platform_device_id {
        
    	char name[PLATFORM_NAME_SIZE];
    	kernel_ulong_t driver_data
    			__attribute__((aligned(sizeof(kernel_ulong_t))));
    };
    
    struct platform_driver {
        
        ...
    	const struct platform_device_id *id_table;
    };

struct platform_device {
        
    	const char	* name;
        ...
    }

**第二种情况**

匹配`platform_driver`中的`driver`的`name`和`platform_device`的`name`

struct device_driver {
        
    	const char		*name;
        ...
    };
    
    struct platform_driver {
        
        ...
    	struct device_driver driver;
    	...
    };

struct platform_device {
        
    	const char	* name;
        ...
    }

### 2.3 platform\_device中的资源描述 ###

前面介绍说`platform_device`时描述硬件资源，那么`platform_driver`就要获取资源

至于怎么描述和获取资源，下面来介绍

资源的描述在`platform_device`中，其中`resource`指向一个`resource`数组

struct platform_device {
        
    	u32			    num_resources;
    	struct resource	*resource;
    	...
    };

`resource`的定义如下

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

一般我们值关心`start`、`end`、`flags`三个变量，它们分别标准资源的起始值，结束值和资源的类型

其中`flags`可以为`IORESOURCE_IO`、`IORESOURCE_MEM`、`IORESOURCE_IRQ`、`IORE-SOURCE_DMA`等

`start`和`end`的解释随`flags`而改变

在驱动程序中获取资源可以使用

/*
     * dev：表示平台设备
     * flags：要获取的资源类型
     * index：该类资源在平台设备中的编号
     */
    struct resource *platform_get_resource(struct platform_device *dev,
                                           unsigned int flag, unsigned int index);

举个例子

static struct resource s5p_dm9000_resources[] = {
        
    	[0] = {
        
    		.start = S5P_PA_DM9000,
    		.end   = S5P_PA_DM9000 + 3,
    		.flags = IORESOURCE_MEM,
    	},
    	[1] = {
        
    		.start = S5P_PA_DM9000 + 1,
    		.end   = S5P_PA_DM9000 + 1,
    		.flags = IORESOURCE_MEM,
    	},
    	[2] = {
        
    		.start = IRQ_EINT10,
    		.end   = IRQ_EINT10,
    		.flags = IORESOURCE_IRQ | IORESOURCE_IRQ_HIGHLEVEL,
    	}
    };
    
    struct platform_device s5p_device_dm9000 = {
        
    	.name		= "dm9000",
    	.id		=  0,
    	.num_resources	= ARRAY_SIZE(s5p_dm9000_resources),
    	.resource	= s5p_dm9000_resources,
    };

这是网卡dm9000的硬件描述，在驱动程序中想要获取资源可以这样做

struct resource *resource;
    
    resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    resource = platform_get_resource(pdev, IORESOURCE_MEM, 1);
    resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0);

对于获取中断资源还可以调用

int platform_get_irq(struct platform_device *dev, unsigned int num);

实际上调用的是

platform_get_resource(dev，IORESOURCE_IRQ，num);

此外还可以在`platform_device`的`dev`成员附加参数

static struct dm9000_plat_data s5p_dm9000_platdata = {
        
    	.dev_addr = {
        0x00,0x09,0xc0,0xff,0xec,0x48},
    };
    
    struct platform_device s5p_device_dm9000 = {
        
    	.name		= "dm9000",
    	.id		=  0,
    	.num_resources	= ARRAY_SIZE(s5p_dm9000_resources),
    	.resource	= s5p_dm9000_resources,
    	.dev		= {
        
    		.platform_data = &s5p_dm9000_platdata,
    	}
    };

在驱动程序中这样获取

struct dm9000_plat_data *pdata = dev_get_platdata(&pdev->dev);

## 三、platform驱动框架源码剖析 ##

下面从platform的注册接口来分析platform的驱动框架

int platform_device_register(struct platform_device *pdev)
    {
        
        return platform_device_add(pdev);
    }

int platform_device_add(struct platform_device *pdev)
    {
        
        /* 设置设备对应的总线为platform总线 */
        pdev->dev.bus = &platform_bus_type;
        
        device_add(&pdev->dev);
    }

int device_add(struct device *dev)
    {
        
     	/* 将设备添加进总线的设备链表 */
        bus_add_device(dev);
        
        bus_probe_device(dev);
    }

void bus_probe_device(struct device *dev)
    {
        
        device_attach(dev);
    }

int device_attach(struct device *dev)
    {
        
        /* 遍历总线的所有驱动，执行__device_attach函数 */
        bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
    }

`__device_attach`函数会判断驱动和设备是否匹配，如果不匹配的话，函数就退出，如果匹配就调用`driver_probe_device`，`driver_probe_device`函数将调用驱动的probe函数

static int __device_attach(struct device_driver *drv, void *data)
    {
        
        struct device *dev = data;
        
    	if (!driver_match_device(drv, dev))
    		return 0;
    
    	return driver_probe_device(drv, dev);
    }

下面那看一下`driver_match_device`是如何匹配的

static inline int driver_match_device(struct device_driver *drv,
    				      struct device *dev)
    {
        
    	return drv->bus->match ? drv->bus->match(dev, drv) : 1;
    }

可以看到，调用了`drv->bus->match`函数，其中的bus在注册设备的时候被设备为`platform_bus_type`

所以此时的匹配函数为`platform_match`，下面分析此函数，这也正是platform的匹配的规则

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);
        
        /* 优先匹配platform_driver的id_table和platform_device的name */
        if (pdrv->id_table)
    		return platform_match_id(pdrv->id_table, pdev) != NULL;
        
        /* 如果pdrv->id_table没有定义，那么就匹配platform_device的name和platform_driver中drv的name */
        return (strcmp(pdev->name, drv->name) == 0);
    }

其中的匹配都是通过字符串进行匹配的

下面再回到此函数中

如果匹配成功，就会调用`driver_probe_device`，此函数会调用对用驱动的probe函数

int driver_probe_device(struct device_driver *drv, struct device *dev)
    {
        
        really_probe(dev, drv);
    }

static int really_probe(struct device *dev, struct device_driver *drv)
    {
        
        drv->probe(dev);
    }

对于注册platform\_driver的过程和上述同理，这里不再重述

## 四、platform驱动程序模板 ##

这里给出一个编写platform驱动的模板

**platform\_device**

#include <linux/module.h>
    #include <linux/init.h>
    #include <linux/kernel.h>
    #include <linux/platform_device.h>
    
    
    static void mydev_release(struct device *dev)
    {
        
        printk("mydev_release\n");
    }
    
    static struct platform_device mydev_device = {
        
    	.name      = "mydev",
    	.id        = -1,
    	//.num_resources =
    	//.resource =
    	.dev       = {
        
    	    //.platform_data =
            .release = mydev_release,
        },
    };
    
    static int __devinit mydev_init(void)
    {
        
    	int ret;
    
    	ret = platform_device_register(&mydev_device);
    	if(ret)
    		printk("failed to register device\n");
    
    
    	return ret;
    }
    
    static void mydev_exit(void)
    {
        
        platform_device_unregister(&mydev_device);
    }
    
    module_init(mydev_init);
    module_exit(mydev_exit);
    
    MODULE_LICENSE("GPL");

**platform\_driver**

#include <linux/module.h>
    #include <linux/init.h>
    #include <linux/kernel.h>
    #include <linux/platform_device.h>
    
    
    static int mydriver_probe(struct platform_device *device)
    {
        
        printk("mydriver_probe\n");
    
        //struct resource *resource;
        //resource = platform_get_resource(pdev, IORESOURCE_MEM, 0);
    
        //viod *pdata = dev_get_platdata(&pdev->dev);
        
        return 0;
    }
    
    static int mydriver_remove(struct platform_device *device)
    {
        
        printk("mydriver_remove\n");
        return 0;
    }
    
    
    static struct platform_driver mydriver = {
        
    	.probe		= mydriver_probe,
        .remove     = mydriver_remove,
    	.driver		= {
        
    		.name	= "mydev",
    	},
    };
    
    static int __devinit mydriver_init(void)
    {
        
    	int ret;
    
    	ret = platform_driver_register(&mydriver);
    	if(ret)
    		printk("failed to register driver\n");
    
    	return ret;
    }
    
    static void mydriver_exit(void)
    {
        
    	platform_driver_unregister(&mydriver);
    }
    
    module_init(mydriver_init);
    module_exit(mydriver_exit);
    
    MODULE_LICENSE("GPL");

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20190824102335838.PNG?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MjQ2MjIwMg==,size_16,color_FFFFFF,t_70