精华内容
下载资源
问答
  • signapk.jar工具及系统platform密钥,platform.pk8 platform.x509.pem
  • platform总线

    千次阅读 2020-02-26 19:24:39
    1、什么是platform总线? 相对于USB、PCI、I2C、SPI等物理总线来说,platform总线是一种虚拟、抽象出来的总线,实际中并不存在这样的总线。那为什么需要platform总线呢?其实是Linux设备驱动模型为了保持设备驱动的...

    1.一个重要思想
    分离思想:将设备和驱动进行分离,各自管理。直到一端加入到总线,进行匹配。
    模型
    2、什么是platform总线?
    相对于USB、PCI、I2C、SPI等物理总线来说,platform总线是一种虚拟、抽象出来的总线,实际中并不存在这样的总线。那为什么需要platform总线呢?其实是Linux设备驱动模型为了保持设备驱动的统一性而虚拟出来的总线。因为对于usb设备、i2c设备、pci设备、spi设备等等,他们与cpu的通信都是直接挂在相应的总线下面与我们的cpu进行数据交互的,但是在我们的嵌入式系统当中,并不是所有的设备都能够归属于这些常见的总线,在嵌入式系统里面,SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设却不依附与此类总线。所以Linux驱动模型为了保持完整性,将这些设备挂在一条虚拟的总线上(platform总线),而不至于使得有些设备挂在总线上,另一些设备没有挂在总线上。
    platform总线相关代码声明:linux/platform_device.h 文件

    3、platform总线的两个重点结构体platform_device和platform_driver
    对于任何一种Linux设备驱动模型下的总线都由两个部分组成:描述设备相关的结构体和描述驱动相关的结构体在platform总线下就是platform_device和platform_driver,下面是对两个结构体的各个元素进行分析:
    (1)platform_device结构体及其中的结构体分析

    struct platform_device {           
          const char * name;      //平台设备的名字
          int id;                 //ID区分设备名字,如果一个驱动对应一个设备,传-1
          struct device dev;      //描述设备信息device结构体
          u32 num_resources;      //资源结构体数量,资源信息结构体数组的大小
          struct resource * resource; //资源结构体,一般定义一个数组
    };
    struct device {
        struct device_driver *driver;  //设备驱动的结构体指针
        struct device_node *of_node;   //设备树节点
        u32 id;	
        void (*release)(struct device *dev);  //设备端卸载的时候,须调用的函数
    };
    struct resource {
    	resource_size_t start;      //起始地址
    	resource_size_t end;        //结束地址
    	const char *name;           //资源名字
    	unsigned long flags;        //标志 IORESOURCE_IO IORESOURCE_MEM 
                                   //IORESOURCE_IRQ
    }; 
    

    设备端调用的代码

    int platform_device_register(struct platform_device *pdev);
    功能:platfrom平台总线设备注册
    参数:
        @pdev    platform平台总线设备端结构体指针
    返回值:成功返回0,失败返回负数错误码
    
    void platform_device_unregister(struct platform_device *); 
    功能:platfrom平台总线设备卸载
    参数:
        @pdev    platform平台总线设备端结构体指针
    返回值:成功返回0,失败返回负数错误码
    

    (2)platform_driver结构体及其中的结构体分析

    struct platform_driver {
    	int (*probe)(struct platform_device *);   //获取设备信息,在匹配成功调用
    	int (*remove)(struct platform_device *);   //在移除的时候调用
    	struct device_driver driver;
    	const struct platform_device_id *id_table; //id_table表
    };
    
    struct device_driver {
    	const char		*name;    //名字  匹配
    	struct bus_type		*bus;     //总线信息结构体
    	struct module		*owner;   //THIS_MODULE
    	const struct of_device_id	*of_match_table;    //设备树的相关信息
    };
    
    struct platform_device_id {
    	char name[PLATFORM_NAME_SIZE];   //名字
    	kernel_ulong_t driver_dat;
    };
    

    驱动端调用的代码

    int platform_driver_register(struct platform_driver *pdrv);
    功能:platform平台总线驱动端注册函数
    参数:
        @pdrv   platform平台总线驱动端结构体指针
    返回值:成功返回0,失败返回负数错误码    
    
    void platform_driver_unregister(struct platform_driver *);
    功能:platform平台总线驱动端卸载函数
    参数:
        @pdrv   platform平台总线驱动端结构体指针
    返回值:成功返回0,失败返回负数错误码  
    

    重点:
    一.platform驱动注册过程:

    platform_driver_register
      --->>>driver_register(&drv->driver);
          --->>>bus_add_driver(drv);
              --->>>driver_attach(drv);   //驱动绑定设备
                      /*遍历设备端的链表,完成匹配*/
                  --->>>bus_for_each_dev(drv->bus, NULL, drv,__driver_attach); 
                      --->>>__driver_attach
                          --->>>driver_match_device(drv, dev)
    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);
        /*和设备树进行匹配*/
    	if (of_driver_match_device(dev, drv))
    		return 1;
    
    	/* 和id_table表进行匹配 */
    	if (pdrv->id_table)
    		return platform_match_id(pdrv->id_table, pdev) != NULL;
    
    	/* 和名字进行匹配*/
    	return (strcmp(pdev->name, drv->name) == 0);
    }
    

    二.platform设备端注册:

    platform_device_register
      --->>>platform_device_add(pdev);
        --->>>device_add(&pdev->dev);
           --->>>bus_probe_device(dev);
             --->>>device_attach(dev);
               --->>>bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
    

    以上调用的最后:

    **driver_probe_device**
    

    总结:platform平台总线,设备和驱动在注册的过程中,都会遍历对方的链表,来查找是否有匹配的,如果有匹配的,就会调用驱动中的probe探测函数,获取设备信息。

    展开全文
  • flutter Platform介绍

    千次阅读 2018-09-06 21:13:58
    Platform 在dart:io中,提供与Platform类的API奇偶校验,但使用实例属性而不是静态属性。这种差异允许在测试中使用这些API,您可以在其中提供模拟实现。 看一下构造方法: class Platform { static int get ...

    Platform

    在dart:io中,提供与Platform类的API奇偶校验,但使用实例属性而不是静态属性。这种差异允许在测试中使用这些API,您可以在其中提供模拟实现。

    看一下构造方法:

    class Platform { 
      static int get numberOfProcessors => _numberOfProcessors;
      static String get pathSeparator => _pathSeparator;
      static String get localeName => _Platform.localeName();
      static String get operatingSystem => _operatingSystem;
      static String get operatingSystemVersion => _operatingSystemVersion;
      static String get localHostname => _localHostname;
      static final bool isLinux = (_operatingSystem == "linux");
      static final bool isMacOS = (_operatingSystem == "macos");
      static final bool isWindows = (_operatingSystem == "windows");
      static final bool isAndroid = (_operatingSystem == "android");
      static final bool isIOS = (_operatingSystem == "ios");
      static final bool isFuchsia = (_operatingSystem == "fuchsia");
      static Map<String, String> get environment => _Platform.environment;
      static String get executable => _Platform.executable;
      static String get resolvedExecutable => _Platform.resolvedExecutable;
      static Uri get script => _Platform.script;
      static List<String> get executableArguments => _Platform.executableArguments;
      static String get packageRoot => _Platform.packageRoot;
      static String get packageConfig => _Platform.packageConfig;
      static String get version => _version;
    }

    可以看到方法还是不少的 , 接下来我们主要介绍一下使用方法以及各个属性代表的含义.

    使用方法

    1.先引入包:

    import ‘dart:io’;

    2.使用:

    Platform.isAndroid
    Platform.operatingSystem
    其他属性使用方法同上.

    3 例如:

      void _btnPress() {
        print(Platform.isAndroid);  // true/false
      }

    如果你的手机是安卓的,会在控制台打印true,否则打印出false.

    API

    以下内容基于 Nexus5X API 28测试

    属性 类型 本机打印结果 描述
    numberOfProcessors int 4 机器的各个执行单元的数量。
    pathSeparator String / 操作系统用于分隔文件路径中的组件的路径分隔符。
    localeName String en_US 获取当前区域设置的名称。
    operatingSystem String android 表示操作系统或平台的字符串。
    operatingSystemVersion String Linux 4.4.124+ #1 SMP PREEMPT Mon Jun 18 17:10:07 UTC 2018 表示操作系统或平台版本的字符串。
    localHostname String localhost 系统的本地主机名
    isLinux bool false 操作系统是否为[Linux]的版本
    isMacOS bool false 操作系统是否为[macOS]的版本
    isWindows bool false 操作系统是否为[Windows]的版本
    isAndroid bool true 操作系统是否为[Android]的版本
    isIOS bool false 操作系统是否为[IOS]的版本
    isFuchsia bool false 操作系统是否为[Fuchsia]的版本
    environment Map< String, String > {PATH:/sbin:/system/sbin:/system/bin:/s } ..等一系列字符串很长.. 此过程的环境为从字符串键到字符串值的映射。映射是不可修改的,其内容在首次使用时从操作系统中检索。Windows上的环境变量不区分大小写,因此在Windows上,映射不区分大小写,并将所有键转换为大写。在其他平台上,可以通过大小写区分键。
    executable String /system/bin/app_process32 用于在此隔离中运行脚本的可执行文件的路径。用于标识脚本的文字路径。此路径可能是相对的,或者只是通过搜索系统路径从中找到可执行文件的名称。使用[resolvedExecutable]获取可执行文件的绝对路径。
    resolvedExecutable String /system/bin/app_process32 操作系统解析后,用于在此隔离中运行脚本的可执行文件的路径。这是解析所有符号链接的绝对路径,用于运行脚本的可执行文件。
    script Uri file:///main.dart 在这个隔离区中运行脚本的绝对URI。如果可执行环境不支持(脚本),uri为空
    executableArguments List< String > [] 在这个隔离区中运行脚本传递给可执行文件的标志。这些是在脚本名称前面的可执行文件的命令行标志。每次读取值时都会提供一个新的列表。
    packageRoot String null --package-root标志传递给可执行文件,用于在该隔离区中运行脚本。如果没有--package-root标志,则为null
    packageConfig String null --package标志传递给可执行文件,用于在该隔离区中运行脚本。如果没有--package标志,则为null
    version String 2.0.0-dev.58.0.flutter-f981f09760 (Sat May 26 03:16:14 2018 +0000) on “android_ia32” 当前DART运行时的版本。
    展开全文
  • platform框架 下图是platform框架,其中左边是设备链表,右边是driver链表。至于该框架之上的kset,kobject等在后续章节进行描述。 Platform主要工作包含三部分,设备链表维护,driver链表维护,设备和driver的...

    platform框架

    下图是platform框架,其中左边是设备链表,右边是driver链表。至于该框架之上的kset,kobject等在后续章节进行描述。
    在这里插入图片描述
    Platform主要工作包含三部分,设备链表维护,driver链表维护,设备和driver的match操作。
    其中设备链表维护即像链表中增加和删除元素,platform_device_register,platform_device_unregister函数即可完成设备链表中元素的增加和删除。
    其中设备链表维护即像链表中增加和删除元素,platform_deriver_register,platform_driver_unregister函数即可完成设备链表中元素的增加和删除。
    设备和driver的match操作是通过比较dev.name和driver.driver.name进行匹配的,相同则匹配成功,否则匹配失败。
    上图中两个链表是通过kobject进行链接的。

    基于platform编写代码

    本章节首先先介绍一些基本知识,以便于理解如何代码是如何实现的;在了解基本知识后,从三部分分别进行阐述(上个章节已对三部分分别进行了简单说明),但通过该部分,仅仅是知道如何使用platform,但platform的具体细节在下一个章节进行描述。

    主要结构体

    主要结构体包含struct platform_driver,struct platform_device,struct resource,各结构体成员的说明见下属结构体成员右侧。
    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; //设备id,一个驱动可用于多个设备,这个设
    

    //备的集合就是这个id表,只要设备id表和驱动
    //的这个id表中的id对应,就可使用这个驱动
    //来操作
    };

    struct platform_device {
    const char *name; //设备名称,match匹配时使用该参数
    int id;
    bool id_auto;
    struct device dev;
    u32 num_resources; //设备的资源数量
    struct resource *resource; //设备的资源信息,比如GPIO信息,中断信息

    const struct platform_device_id	*id_entry;  //设备id表,用于id不同但数据同一系列
    

    //的设备,这种不同设备存在细微差别,但
    //是驱动其读写方式相同,因此用同一驱动,
    //但其细微差别,可以在驱动中使用id来识//别

    /* MFD cell pointer */
    struct mfd_cell *mfd_cell;
    
    /* arch specific additions */
    struct pdev_archdata	archdata;  //似有数据,将设备特有的内容放置在此处,
    

    //用来扩展
    };

    struct resource {
    resource_size_t start; //资源开始的地址,若是IRQ资源,则用中断号的开始值
    resource_size_t end; //资源结束地址,若是IRQ资源,则用中断号的结束值,当IRQ
    //的start和end相同,则表示只有一个中断
    const char *name;
    unsigned long flags; //类型,IORESOURCE_MEM(内存类型), IORESOURCE_DMA
    //IORESOURCE_IRQ(中断类型), IORESOURCE_BUS等
    struct resource *parent, *sibling, *child;
    };

    从上面每个结构体的内容可知,platform_device对应一个具体平台总线下的设备,包含设备的信息,其中struct device是所有设备的共有信息。
    Platform_driver是总线下对应的驱动,该结构体成员指向的那些函数是需要写驱动时实现的,这些函数是对应设备的操作方式,比如读写数据,但要实现这些函数的调用,需要注册结构体Platform_driver。

    代码需要完成的内容

    其实代码要完成的就是上述三个结构体的填充及注册,当均实现,且注册后,platform会进行匹配操作,从而驱动可以访问设备。
    下述为代码需要完成的工作(在platform架构已完成搭建且工作的前提条件下):

    1. 填充platform_device结构体及其使用的资源,即初始化;
    2. 填充platform_driver结构体,即初始化,需要实现probe和remove函数,当不支持PM时,可以不用实现电源相关的函数;
    3. 进行platform_device和platform_driver的注册,目前大多数的platform_device的注册是采用platform_add_device()进行注册的,该函数遍历所有的platform_device然后进行注册。

    设备和驱动的注册和注销

    设备和驱动注册前需要进行platform_device和platform_driver结构的初始化,其实现如下代码所示:

    platform_driver的注册代码

    下属代码摘自i2c的驱动代码,只保留了注册的框架代码,具体的i2c读写方式已删除。
    #include <linux/kernel.h>
    #include <linux/module.h>
    #include <linux/init.h>
    #include <linux/time.h>
    #include <linux/sched.h>
    #include <linux/errno.h>
    #include <linux/clk.h>
    #include <linux/delay.h>
    #include <linux/slab.h>
    #include <linux/module.h>
    #include <linux/completion.h>
    #include <linux/platform_device.h>
    #include <linux/interrupt.h>
    #include <linux/gpio.h>

    static int i2c _probe(struct platform_device *dev)
    {
    int ret = 0;
    void __iomem *iomem;
    struct resource *res; //若有资源,则在此处获取platform_device中设置的资源,此处
    //提供一个获取mem资源的demo
    …………………
    res = platform_get_resource(dev, IORESOURCE_MEM, 0); //具体资源的使用不再此过多描
    iomem = ioremap(res->start, resource_size(res)); //述,若该兴趣,自行查阅相关文档
    …………………
    return 0;

    ERR0:
    return ret;
    }

    static int i2c_remove(struct platform_device *dev)
    {
    struct i2c_pri *i2c = platform_get_drvdata(dev); //获取platform_device中的私有数据部分
    //私有部分可有可无,当需要扩展时使用
    …………………
    return 0;
    }

    static struct platform_driver i2c_ driver = { //platform_driver结构体的初始化
    .probe = i2c _probe,
    .remove = i2c _remove,
    .driver = {
    .name = “i2c_test”,
    },
    };

    static int __init i2c _init(void)
    {
    return platform_driver_register(&i2c _driver); //platform_driver的注册
    }

    subsys_initcall(i2c _init);

    static void __exit i2c _exit(void)
    {
    platform_driver_unregister(&i2c _driver);
    }

    module_exit(i2c _exit);

    MODULE_LICENSE(“GPL”);
    MODULE_DESCRIPTION(“i2c driver for SoCs”);

    platform_device的注册代码

    static struct resource arch_i2c0_resources[] = {		//i2c资源情况
    	[0] = {							        //这些资源一般在probe函数中获取
    		.start          = I2C0_IOBASE,		    //并使用
    		.end           = I2C0_IOBASE + 0x1000 - 1,
    		.flags          = IORESOURCE_MEM,		
    	},							
    	[1] = {							
    		.start          = 中断号,			
    		.end            =中断号,			
    		.flags          = IORESOURCE_IRQ,		
    	},							
    	[2] = {							
    		.start          = JZDMA_REQ_I2C0,		
    		.flags          = IORESOURCE_DMA,		
    	},							
    	[3] = {							
    		.start          = SPEED,	
    		.flags          = IORESOURCE_BUS,		
    	},							
    };								
    struct platform_device arch_i2c0_device = {			//platform_device初始化
    	.name = " i2c_test ",					
    	.id = -1,						
    	.dev = {						
    		.dma_mask               = &arch_i2c_dmamask,
    		.coherent_dma_mask      = 0xffffffff,		
    	},							
    	.num_resources  = ARRAY_SIZE(arch_i2c0_resources),	
    	.resource       = arch_i2c0_resources,		
    };
    

    static struct arch_platform_device platform_devices_array[] __initdata = { //该结构体包含
    #define DEF_DEVICE(DEVICE, DATA, SIZE) \ //所有设备信息,此处
    { .pdevices = DEVICE, \ //只保留例程中的设备
    .pdata = DATA, .size = SIZE,}
    DEF_DEVICE(arch_i2c0_device, 0, 0),
    }

    static int __init board _init(void)
    {
    int pdevices_array_size, i;

    pdevices_array_size = ARRAY_SIZE(platform_devices_array);
    for(i = 0; i < pdevices_array_size; i++)   //此处遍历所有的platform_device设备
    

    {
    if(platform_devices_array[i].size)
    platform_device_add_data(platform_devices_array[i].pdevices,
    platform_devices_array[i].pdata, platform_devices_array[i].size);
    platform_device_register(platform_devices_array[i].pdevices);//platform_device注册
    }
    return 0;
    }

    设备和驱动的匹配

    匹配部分在此不过多描述,当描述完platform的bus总线后,会再次详细描述。
    static int platform_match(struct device *dev, struct device_driver *drv)
    {
    struct platform_device *pdev = to_platform_device(dev); //先获取platform_device结构体
    struct platform_driver *pdrv = to_platform_driver(drv); //先获取platform_driver结构体

    /* Attempt an OF style match first */
    if (of_driver_match_device(dev, drv))
    	return 1;
    
    /* Then try ACPI style match */
    if (acpi_driver_match_device(dev, drv))
    	return 1;
    
    /* Then try to match against the id table */
    if (pdrv->id_table)                      //使用platform_driver中的id表项进行匹配
    	return platform_match_id(pdrv->id_table, pdev) != NULL;
    
    /* fall-back to driver name match */
    return (strcmp(pdev->name, drv->name) == 0);  //使用名字进行匹配
    

    }
    当match之后,会调用platform_driver中的probe函数。

    展开全文
  • Linux platform总线

    2019-08-24 11:19:35
    文章目录Linux platform总线一、总线概念二、platform驱动框架详解2.1 platform驱动框架2.2 platform_device和platform_driver的匹配规则2.3 platform_device中的资源描述三、platform驱动框架源码剖析四、platform...

    Linux platform总线

    一、总线概念

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

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

    设备描述了硬件信息

    驱动是具体的驱动的实现

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

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

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

    二、platform驱动框架详解

    2.1 platform驱动框架

    platform总线相应的设备和驱动分别为platform_deviceplatform_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_deviceplatform_driver

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

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

    在这里插入图片描述

    以上就是platform的驱动框架

    2.2 platform_device和platform_driver的匹配规则

    对于platform_device和platform_driver的匹配规则,要分析platform_match函数,这里先给出结论,后头再分析源码

    第一种情况

    匹配platform_driver中的id_table数组元素的nameplatform_devicename(字符串匹配)

    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中的drivernameplatform_devicename

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

    一般我们值关心startendflags三个变量,它们分别标准资源的起始值,结束值和资源的类型

    其中flags可以为IORESOURCE_IOIORESOURCE_MEMIORESOURCE_IRQIORE-SOURCE_DMA

    startend的解释随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_devicedev成员附加参数

    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_devicedriver_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

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

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

    下面再回到此函数中

    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_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");
    
    展开全文
  • platform 架构

    千次阅读 2016-09-29 13:02:19
    1.1 platform 总线是虚拟总线,当使用这个虚拟总线是带来的好处主要有两点: (1)使得设备被挂接在一个总线上,因此,符合 Linux 2.6 的设备模型。其结果是,配套的sysfs 结点、设备电源管理都成为可能。 (2)...
  • platform_device与platform_driver

    千次阅读 2014-08-29 13:54:34
    做Linux方面也有三个多月了,对代码中的有些结构一直不是很明白,比如platform_device与platform_driver一直分不清关系。在网上搜了下,做个总结。两者的工作顺序是先定义platform_device -> 注册 platform_device->...
  • Spring IO Platform

    千次阅读 2019-09-19 15:51:23
    Spring IO Platform
  • platform详解

    2015-07-15 16:32:13
    从Linux 2.6起引入了一套新的驱动管理和注册机制,platform_device和platform_driver,Linux中大部分的设备驱动都可以使用这套机制。platform是一条虚拟总线。设备用platform_device表示,驱动用platform_driver进行...
  • 很好,没有安装windows hypervisor platform的机会,但是没关系 然后cmd 或powershll 管理员身份运行 Dism /online /Get-Features 可以查看到hypervisor platform是禁用状态 pushd “%~dp0” dir /b %SystemRoot%\...
  • PlatformIO资料

    千次阅读 2019-02-01 14:23:03
    使用PlatformIO构建和刷新固件 使用PlatformIO从Visual Studio代码构建和更新 NodeMCU开发环境搭建之PlatformIO (ESP8266) vscode arduino platformIO 入门 ESP32在VS Code下PlatformIo插件下首次体验...
  • Platform Device and Drivers从我们可以了解Platform bus上面的驱动模型接口:platform_device,platform_driver。和PCI和USB这些大结构的总线不同,虚拟总线Platform bus使用最小结构来
  • vscode安装platformio

    千次阅读 2021-01-26 16:14:23
    vscode安装platformio正确的安装过程如果你已经安装失败了开始正常的安装问题一:为什么帖子里都提示要删掉.platfrmio文件呢?问题二:如何确定电脑里python都有那几个版本 其实之前的阿里云系列已经介绍过vscode里...
  • platform device 与 platform driver

    千次阅读 2011-08-17 14:57:21
    做Linux方面也有三个多月了,对代码中的有些结构一直不是很明白,比如platform_device与platform_driver一直分不清关系。在网上搜了下,做个总结。两者的工作顺序是先定义platform_device -> 注册 platform_device->...
  • platformIO环境安装

    千次阅读 2020-12-08 13:26:44
    文章目录使用用Platform IO作为Arduino的交叉编译环境1.1 PlatformIO简介1.2 VScode下安装PlatformIO1.3软件启动界面1.4 软件配置2. 开发平台和固件安装 1.1 PlatformIO简介 [外链图片转存失败,源站可能有防盗链机制...
  • This application failed to start because it could not find or load the Qt platform plugin "windows"in "", Available platform plugins are: minimal, offscreen, windows. Reinstalling the application may ...
  • python之platform模块

    千次阅读 2019-07-11 19:56:00
    python中,platform模块给我们提供了很多方法去获取操作系统的信息 如: import platform platform.platform() #获取操作系统名称及版本号,'Windows-7-6.1.7601-SP1' platform.version() #获取操作系统版本号,'...
  • platform_device的建立包含两种方式: (1)在内核初始化时通过device_node转换为platform_device,这种是最新的实现方式,基于设备树,在内核初始化时将设备树中的节点转化为platform_device; (2)使用platform...
  • platform驱动详解

    千次阅读 2018-01-04 11:21:55
    platform总线是虚拟的平台总线,是linux设备驱动模型为了保持设备驱动的统一性而虚拟出来的总线。 总线将设备和驱动绑定,系统每注册一个设备的时候,会寻找与之匹配的驱动;相反,系统每注册一个驱动的时候,会...
  • platform驱动模型使用总结

    千次阅读 2018-07-21 18:13:17
    platform平台总线驱动的编写主要分为两个部分: 一个是platform_device部分,主要是提供设备本身对驱动处理所要求的参数。 另一个是platform_driver部分,主要是利用platform_device这边传递过来的参数提供对硬件...
  • Android SDK Platform(Android 6.0系统)

    千次下载 热门讨论 2015-10-04 13:34:44
    这是从Android SDK manager下载的针对于API Level 23(Android 6.0棉花糖)的platform,如果在SDK manager无法下载,可直接下载该资源,使用方法在压缩包中,需下载后方可查看。
  • platform的学习和使用

    万次阅读 2018-02-16 23:18:12
    标签(空格分隔): linux子系统 platform平台框架 http://blog.csdn.net/ufo714/article/details/8595021 platform的灵魂是:device(设备)driver(驱动)platform_bus(platform总线),其特点是设备,驱动...
  • 实现静默安装必须拥有该机器的系统签名,所以安装程序必须得拥有系统签名 实现系统签名必须得拥有两个签名文件和一个jar包 ...2.java -jar signapk.jar platform.x509.pem platform.pk8 apk路径(签名前) apk路径(签名后)
  • Platform Device and Drivers  从我们可以了解Platform bus上面的驱动模型接口:platform_device,platform_driver。和PCI和USB这些大结构的总线不同,虚拟总线 Platform bus使用最小结构来集成SOC processer上的...
  • 在Unity2017 和Unity2018 中已过时,解决方法: return Application.platform != RuntimePlatform.WindowsPlayer && Application.platform != RuntimePlatform.OSXPlayer;

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 547,732
精华内容 219,092
关键字:

platform