Linux 设备驱动开发 —— platform 设备驱动

一、platform总线、设备与驱动

        在Linux 2.6 的设备驱动模型中，关心总线、设备和驱动3个实体，总线将设备和驱动绑定。在系统每注册一个设备的时候，会寻找与之匹配的驱动；相反的，在系统每注册一个驱动的时候，会寻找与之匹配的设备，而匹配由总线完成。

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

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

       基于Platform总线的驱动开发流程如下：

a -- 定义初始化platform bus

b -- 定义各种platform devices

c -- 注册各种platform devices

d -- 定义相关platform driver

e -- 注册相关platform driver

f  -- 操作相关设备


相关结构体定义：

1、平台相关结构 --- platform_device结构体

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. struct platform_device {  
  2.     const char * name;/* 设备名 */  
  3.     u32 id;//设备id，用于给插入给该总线并且具有相同name的设备编号，如果只有一个设备的话填-1。  
  4.     struct device dev;//结构体中内嵌的device结构体。  
  5.     u32 num_resources;/* 设备所使用各类资源数量 */  
  6.   struct resource * resource;/* //定义平台设备的资源*/  
  7. };  

2、设备的驱动 --- platform_driver 结构体

       这个结构体中包含probe()、remove()、shutdown()、suspend()、 resume()函数，通常也需要由驱动实现

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. struct platform_driver {  
  2.     int (*probe)(struct platform_device *);  
  3.     int (*remove)(struct platform_device *);  
  4.     void (*shutdown)(struct platform_device *);  
  5.     int (*suspend)(struct platform_device *, pm_message_t state);  
  6.     int (*suspend_late)(struct platform_device *, pm_message_t state);  
  7.     int (*resume_early)(struct platform_device *);  
  8.     int (*resume)(struct platform_device *);  
  9.     struct pm_ext_ops *pm;  
  10.     struct device_driver driver;  
  11. };  

3、系统中为platform总线定义了一个bus_type的实例 --- platform_bus_type

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. struct bus_type platform_bus_type = {  
  2.     .name = “platform”,  
  3.     .dev_attrs = platform_dev_attrs,  
  4.     .match = platform_match,  
  5.     .uevent = platform_uevent,  
  6.     .pm = PLATFORM_PM_OPS_PTR,  
  7. };  
  8. EXPORT_SYMBOL_GPL(platform_bus_type);  

      这里要重点关注其match()成员函数，正是此成员表明了platform_device和platform_driver之间如何匹配。

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static int platform_match(struct device *dev, struct device_driver *drv)  
  2. {  
  3.     struct platform_device *pdev;  
  4.   
  5.     pdev = container_of(dev, struct platform_device, dev);  
  6.     return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);  
  7. }  
       匹配platform_device和platform_driver主要看二者的name字段是否相同。对platform_device的定义通常在BSP的板文件中实现，在板文件中，将platform_device归纳为一个数组，最终通过platform_add_devices()函数统一注册。

      platform_add_devices()函数可以将平台设备添加到系统中，这个函数的 原型为：

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. int platform_add_devices(struct platform_device **devs, int num);  

该函数的第一个参数为平台设备数组的指针，第二个参数为平台设备的数量，它内部调用了platform_device_register()函 数用于注册单个的平台设备。

a -- platform bus总线先被kenrel注册。

b -- 系统初始化过程中调用platform_add_devices或者platform_device_register，将平台设备(platform devices)注册到平台总线中(platform bus)

c -- 平台驱动(platform driver)与平台设备(platform device)的关联是在platform_driver_register或者driver_register中实现，一般这个函数在驱动的初始化过程调用。
通过这三步，就将平台总线，设备，驱动关联起来。



二．Platform初始化

       系统启动时初始化时创建了platform_bus总线设备和platform_bus_type总线,platform总线是在内核初始化的时候就注册进了内核。

       内核初始化函数kernel_init()中调用了do_basic_setup() ，该函数中调用driver_init()，该函数中调用platform_bus_init()，我们看看platform_bus_init()函数： 

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. int __init platform_bus_init(void)  
  2. {  
  3.        int error;  
  4.        early_platform_cleanup(); //清除platform设备链表  
  5.        //该函数把设备名为platform 的设备platform_bus注册到系统中，其他的platform的设备都会以它为parent。它在sysfs中目录下.即 /sys/devices/platform。  
  6.        //platform_bus总线也是设备，所以也要进行设备的注册  
  7.        //struct device platform_bus = {  
  8.        //.init_name = "platform",  
  9.         //};  
  10.        error = device_register(&platform_bus);//将平台bus作为一个设备注册，出现在sys文件系统的device目录   
  11.        if (error)  
  12.               return error;  
  13.        //接着bus_register(&platform_bus_type)注册了platform_bus_type总线.  
  14.        /* 
  15.        struct bus_type platform_bus_type = { 
  16.                     .name = “platform”, 
  17.                     .dev_attrs = platform_dev_attrs, 
  18.                     .match = platform_match, 
  19.                     .uevent = platform_uevent, 
  20.                     .pm = PLATFORM_PM_OPS_PTR, 
  21.                 }; 
  22.        */  
  23.        //默认platform_bus_type中没有定义probe函数。  
  24.        error = bus_register(&platform_bus_type);//注册平台类型的bus，将出现sys文件系统在bus目录下，创建一个platform的目录，以及相关属性文件  
  25.        if (error)  
  26.               device_unregister(&platform_bus);  
  27.        return error;  
  28. }  

       总线类型match函数是在设备匹配驱动时调用，uevent函数在产生事件时调用。

       platform_match函数在当属于platform的设备或者驱动注册到内核时就会调用，完成设备与驱动的匹配工作

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static int platform_match(struct device *dev, struct device_driver *drv)  
  2. {  
  3.        struct platform_device *pdev = to_platform_device(dev);  
  4.        struct platform_driver *pdrv = to_platform_driver(drv);  
  5.        /* match against the id table first */  
  6.        if (pdrv->id_table)  
  7.               return platform_match_id(pdrv->id_table, pdev) != NULL;  
  8.        /* fall-back to driver name match */  
  9.        return (strcmp(pdev->name, drv->name) == 0);//比较设备和驱动的名称是否一样  
  10.   
  11. }  
  12.   
  13. static const struct platform_device_id *platform_match_id(struct platform_device_id *id,struct platform_device *pdev)  
  14. {  
  15.        while (id->name[0]) {  
  16.               if (strcmp(pdev->name, id->name) == 0) {  
  17.                      pdev->id_entry = id;  
  18.                      return id;  
  19.               }  
  20.               id++;  
  21.        }  
  22.        return NULL;  
  23.   
  24. }  
        不难看出，如果pdrv的id_table数组中包含了pdev->name，或者drv->name和pdev->name名字相同，都会认为是匹配成功。id_table数组是为了应对那些对应设备和驱动的drv->name和pdev->name名字不同的情况。

        再看看platform_uevent（）函数：platform_uevent 热插拔操作函数

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static int platform_uevent(struct device *dev, struct kobj_uevent_env *env)  
  2. {  
  3.        struct platform_device *pdev = to_platform_device(dev);  
  4.        add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX, (pdev->id_entry) ? pdev->id_entry->name : pdev->name);  
  5.        return 0;  
  6. }  

      添加了MODALIAS环境变量，我们回顾一下：platform_bus. parent->kobj->kset->uevent_ops为device_uevent_ops，bus_uevent_ops的定义如下

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static struct kset_uevent_ops device_uevent_ops = {  
  2.        .filter = dev_uevent_filter,  
  3.        .name = dev_uevent_name,  
  4.        .uevent = dev_uevent,  
  5. };  
     当调用device_add()时会调用kobject_uevent(&dev->kobj, KOBJ_ADD)产生一个事件，这个函数中会调用相应的kset_uevent_ops的uevent函数


三．Platform设备的注册

        我们在设备模型的分析中知道了把设备添加到系统要调用device_initialize()和platform_device_add(pdev)函数。

Platform设备的注册分两种方式：

a -- 对于platform设备的初注册，内核源码提供了platform_device_add()函数，输入参数platform_device可以是静态的全局设备，它是进行一系列的操作后调用device_add()将设备注册到相应的总线（platform总线）上，内核代码中platform设备的其他注册函数都是基于这个函数，如platform_device_register()、platform_device_register_simple()、platform_device_register_data()等。

b -- 另外一种机制就是动态申请platform_device_alloc()一个platform_device设备，然后通过platform_device_add_resources及platform_device_add_data等添加相关资源和属性。

     无论哪一种platform_device，最终都将通过platform_device_add这册到platform总线上。区别在于第二步：其实platform_device_add()包括device_add()，不过要先注册resources，然后将设备挂接到特定的platform总线。

   

1、 第一种平台设备注册方式

       platform_device是静态的全局设备，即platform_device结构的成员已经初始化完成。直接将平台设备注册到platform总线上。platform_device_register和device_register的区别:

a  -- 主要是有没有resource的区别，前者的结构体包含后面，并且增加了struct resource结构体成员，后者没有。platform_device_register在device_register的基础上增加了struct resource部分的注册。

         由此。可以看出，platform_device---paltform_driver_register机制与device-driver的主要区别就在于resource。前者适合于具有独立资源设备的描述，后者则不是。

b -- 其实linux的各种其他驱动机制的基础都是device_driver。只不过是增加了部分功能，适合于不同的应用场合.

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. int platform_device_register(struct platform_device *pdev)  
  2. {  
  3.     device_initialize(&pdev->dev);//初始化platform_device内嵌的device  
  4.     return platform_device_add(pdev);//把它注册到platform_bus_type上  
  5. }  
  6.   
  7. int platform_device_add(struct platform_device *pdev)  
  8. {  
  9.         int i, ret = 0;  
  10.         if (!pdev)  
  11.          return -EINVAL;  
  12.         if (!pdev->dev.parent)  
  13.             pdev->dev.parent = &platform_bus;//设置父节点，即platform_bus作为总线设备的父节点，其余的platform设备都是它的子设备  
  14.               
  15.         //platform_bus是一个设备，platform_bus_type才是真正的总线      
  16.         pdev->dev.bus = &platform_bus_type;//设置platform总线,指定bus类型为platform_bus_type   
  17.           
  18.         //设置pdev->dev内嵌的kobj的name字段,将platform下的名字传到内部device，最终会传到kobj   
  19.         if (pdev->id != -1)  
  20.          dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);  
  21.         else  
  22.          dev_set_name(&pdev->dev, "%s", pdev->name);  
  23.           
  24.           
  25.         //初始化资源并将资源分配给它，每个资源的它的parent不存在则根据flags域设置parent，flags为IORESOURCE_MEM，  
  26.         //则所表示的资源为I/O映射内存，flags为IORESOURCE_IO，则所表示的资源为I/O端口。  
  27.         for (i = 0; i < pdev->num_resources; i++) {  
  28.          struct resource *p, *r = &pdev->resource[i];  
  29.          if (r->name == NULL)//资源名称为NULL则把设备名称设置给它  
  30.                  r->name = dev_name(&pdev->dev);  
  31.            
  32.          p = r->parent;//取得资源的父节点，资源在内核中也是层次安排的  
  33.          if (!p) {  
  34.          if (resource_type(r) == IORESOURCE_MEM) //如果父节点为NULL，并且资源类型为IORESOURCE_MEM，则把父节点设置为iomem_resource   
  35.                  p = &iomem_resource;  
  36.          else if (resource_type(r) == IORESOURCE_IO)//否则如果类型为IORESOURCE_IO，则把父节点设置为ioport_resource  
  37.               p = &ioport_resource;  
  38.          }  
  39.            
  40.          //从父节点申请资源，也就是出现在父节点目录层次下   
  41.          if (p && insert_resource(p, r)) {  
  42.          printk(KERN_ERR "%s: failed to claim resource %d\n",dev_name(&pdev->dev), i);ret = -EBUSY;  
  43.          goto failed;  
  44.          }  
  45.         }  
  46.           
  47.         pr_debug("Registering platform device '%s'. Parent at %s\n",dev_name(&pdev->dev), dev_name(pdev->dev.parent));  
  48.         //device_creat() 创建一个设备并注册到内核驱动架构...  
  49.         //device_add() 注册一个设备到内核，少了一个创建设备..  
  50.         ret = device_add(&pdev->dev);//就在这里把设备注册到总线设备上,标准设备注册，即在sys文件系统中添加目录和各种属性文件  
  51.         if (ret == 0)  
  52.          return ret;  
  53.           
  54.         failed:  
  55.         while (--i >= 0) {  
  56.          struct resource *r = &pdev->resource[i];  
  57.          unsigned long type = resource_type(r);  
  58.          if (type == IORESOURCE_MEM || type == IORESOURCE_IO)  
  59.          release_resource(r);  
  60.         }  
  61.         return ret;  
  62.   
  63. }  

2、第二种平台设备注册方式

      先分配一个platform_device结构，对其进行资源等的初始化；之后再对其进行注册，再调用platform_device_register()函数

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. struct platform_device * platform_device_alloc(const char *name, int id)  
  2. {  
  3.     struct platform_object *pa;  
  4.     /* 
  5.     struct platform_object { 
  6.        struct platform_device pdev; 
  7.        char name[1]; 
  8.     }; 
  9.     */  
  10.     pa = kzalloc(sizeof(struct platform_object) + strlen(name), GFP_KERNEL);//该函数首先为platform设备分配内存空间  
  11.     if (pa) {  
  12.         strcpy(pa->name, name);  
  13.         pa->pdev.name = pa->name;//初始化platform_device设备的名称  
  14.         pa->pdev.id = id;//初始化platform_device设备的id  
  15.         device_initialize(&pa->pdev.dev);//初始化platform_device内嵌的device  
  16.         pa->pdev.dev.release = platform_device_release;  
  17.     }  
  18.     return pa ? &pa->pdev : NULL;  
  19. }  

一个更好的方法是，通过下面的函数platform_device_register_simple()动态创建一个设备，并把这个设备注册到系统中：
[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. struct platform_device *platform_device_register_simple(const char *name,int id,struct resource *res,unsigned int num)  
  2. {  
  3.        struct platform_device *pdev;  
  4.        int retval;  
  5.        pdev = platform_device_alloc(name, id);  
  6.        if (!pdev) {  
  7.               retval = -ENOMEM;  
  8.               goto error;  
  9.        }  
  10.   
  11.        if (num) {  
  12.               retval = platform_device_add_resources(pdev, res, num);  
  13.               if (retval)  
  14.                      goto error;  
  15.        }  
  16.   
  17.        retval = platform_device_add(pdev);  
  18.        if (retval)  
  19.               goto error;  
  20.                 
  21.        return pdev;  
  22. error:  
  23.        platform_device_put(pdev);  
  24.        return ERR_PTR(retval);  
  25. }  
       该函数就是调用了platform_device_alloc()和platform_device_add()函数来创建的注册platform device，函数也根据res参数分配资源，看看platform_device_add_resources()函数：
[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. int platform_device_add_resources(struct platform_device *pdev,struct resource *res, unsigned int num)  
  2. {  
  3.        struct resource *r;  
  4.        r = kmalloc(sizeof(struct resource) * num, GFP_KERNEL);//为资源分配内存空间  
  5.        if (r) {  
  6.               memcpy(r, res, sizeof(struct resource) * num);  
  7.               pdev->resource = r; //并拷贝参数res中的内容，链接到device并设置其num_resources  
  8.               pdev-> num_resources = num;  
  9.        }  
  10.        return r ? 0 : -ENOMEM;  
  11. }  


四．Platform设备驱动的注册

        我们在设备驱动模型的分析中已经知道驱动在注册要调用driver_register()，platform driver的注册函数platform_driver_register()同样也是进行其它的一些初始化后调用driver_register()将驱动注册到platform_bus_type总线上.

[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. int platform_driver_register(struct platform_driver *drv)  
  2. {  
  3.        drv->driver.bus = &platform_bus_type;//它将要注册到的总线  
  4.             /*设置成platform_bus_type这个很重要，因为driver和device是通过bus联系在一起的， 
  5.             具体在本例中是通过 platform_bus_type中注册的回调例程和属性来是实现的, 
  6.             driver与device的匹配就是通过 platform_bus_type注册的回调例程platform_match ()来完成的。 
  7.             */  
  8.        if (drv->probe)  
  9.               drv-> driver.probe = platform_drv_probe;  
  10.        if (drv->remove)  
  11.               drv->driver.remove = platform_drv_remove;  
  12.        if (drv->shutdown)  
  13.               drv->driver.shutdown = platform_drv_shutdown;  
  14.        return driver_register(&drv->driver);//注册驱动  
  15. }  
然后设定了platform_driver内嵌的driver的probe、remove、shutdown函数。
[cpp] view plaincopy
在CODE上查看代码片派生到我的代码片
  1. static int platform_drv_probe(struct device *_dev)  
  2. {  
  3.        struct platform_driver *drv = to_platform_driver(_dev->driver);  
  4.        struct platform_device *dev = to_platform_device(_dev);  
  5.        return drv->probe(dev);//调用platform_driver的probe()函数，这个函数一般由用户自己实现  
  6.                                                        //例如下边结构，回调的是serial8250_probe()函数  
  7.            /* 
  8.                 static struct platform_driver serial8250_isa_driver = { 
  9.                     .probe        = serial8250_probe, 
  10.                     .remove        = __devexit_p(serial8250_remove), 
  11.                     .suspend    = serial8250_suspend, 
  12.                     .resume        = serial8250_resume, 
  13.                     .driver        = { 
  14.                         .name    = "serial8250", 
  15.                         .owner    = THIS_MODULE, 
  16.                     }, 
  17.                 }; 
  18.                 */  
  19. }  
  20.   
  21. static int platform_drv_remove(struct device *_dev)  
  22. {  
  23.        struct platform_driver *drv = to_platform_driver(_dev->driver);  
  24.        struct platform_device *dev = to_platform_device(_dev);  
  25.        return drv->remove(dev);  
  26.   
  27. }  
  28.   
  29. static void platform_drv_shutdown(struct device *_dev)  
  30. {  
  31.        struct platform_driver *drv = to_platform_driver(_dev->driver);  
  32.        struct platform_device *dev = to_platform_device(_dev);  
  33.        drv->shutdown(dev);  
  34.   
  35. }  

总结：

1、从这三个函数的代码可以看到，又找到了相应的platform_driver和platform_device，然后调用platform_driver的probe、remove、shutdown函数。这是一种高明的做法：

在不针对某个驱动具体的probe、remove、shutdown指向的函数，而通过上三个过度函数来找到platform_driver，然后调用probe、remove、shutdown接口。

如果设备和驱动都注册了，就可以通过bus ->match、bus->probe或driver->probe进行设备驱动匹配了。


2、驱动注册的时候platform_driver_register()->driver_register()->bus_add_driver()->driver_attach()->bus_for_each_dev()，

    对每个挂在虚拟的platform bus的设备作__driver_attach()->driver_probe_device()->drv->bus->match()==platform_match()->比较strncmp(pdev->name, drv->name, BUS_ID_SIZE)，如果相符就调用platform_drv_probe()->driver->probe()，如果probe成功则绑定该设备到该驱动。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/402148.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

HTML5本地存储——IndexedDB（二：索引）

HTML5本地存储——IndexedDB（二：索引）

在HTML5本地存储——IndexedDB&#xff08;一&#xff1a;基本使用&#xff09;中介绍了关于IndexedDB的基本使用方法&#xff0c;很不过瘾&#xff0c;这篇我们来看看indexedDB的杀器——索引。 熟悉数据库的同学都知道索引的一个好处就是可以迅速定位数据&#xff0c;提高搜索…
阅读更多...
Linux 字符设备驱动开发基础（五）—— ioremap() 函数解析

Linux 字符设备驱动开发基础（五）—— ioremap() 函数解析

一、 ioremap() 函数基础概念 几乎每一种外设都是通过读写设备上的寄存器来进行的&#xff0c;通常包括控制寄存器、状态寄存器和数据寄存器三大类&#xff0c;外设的寄存器通常被连续地编址。根据CPU体系结构的不同&#xff0c;CPU对IO端口的编址方式有两种&#xff1a; a -- …
阅读更多...
Linux 字符设备驱动开发基础（三）—— read()、write() 相关函数解析

Linux 字符设备驱动开发基础（三）—— read()、write() 相关函数解析

我们在前面讲到了file_operations&#xff0c;其是一个函数指针的集合&#xff0c;用于存放我们定义的用于操作设备的函数的指针&#xff0c;如果我们不定义&#xff0c;它默认保留为NULL。其中有最重要的几个函数&#xff0c;分别是open()、read()、write()、ioctl()&#xff…
阅读更多...
机电传动控制第一周学习笔记

机电传动控制第一周学习笔记

机电传动控制第一周学习笔记&#xff1a; 1 这一周主要讲述了概论和机电传动控制系统动力学基础两个章节内容。 2 绪论中说明了《机电传动控制》课程主要内容为下图所示&#xff1a; 3机电传动控制系统动力学基础章节主要内容分为&#xff1a; &#xff08;1&#xff09;a&…
阅读更多...
opengl 配置

opengl 配置

OpenGL(Open Graphics Library)是一个跨编程语言、跨平台的专业图形程序接口。 OpenGL是SGI公司开发的一套计算机图形处理系统&#xff0c;是图形硬件的软件接口&#xff0c;任何一个OpenGL应用程序无须考虑其运行环境所在平台与操作系统&#xff0c;在任何一个遵循OpenG…
阅读更多...
Linux 字符设备驱动开发基础（二）—— 编写简单 PWM 设备驱动

Linux 字符设备驱动开发基础（二）—— 编写简单 PWM 设备驱动

编写驱动的第一步仍是看原理图&#xff1a; 可以看到&#xff0c;该蜂鸣器由 GPD0_0 来控制 &#xff0c;查手册可知该I/O口由Time0 来控制&#xff0c;找到相应的寄存器&#xff1a; a -- I/O口寄存器及地址 GPD0CON 0x114000a0 b -- Time0 寄存器及地址 基地址为&#xff1a…
阅读更多...
专访：混合云的发展趋势

专访：混合云的发展趋势

近日&#xff0c;业界享有盛誉的vForum2013大会在京召开&#xff0c;此次大会云集了近百家国内外知名的云计算、数据存储、大数据及信息安全厂商&#xff0c;共同讨论了虚拟化、云计算及未来IT模式的发展趋势。笔者也有幸在大会期间采访到了VMware 大中华区技术总监张振伦先生&…
阅读更多...
Tomcat7性能优化

Tomcat7性能优化

用了很久的Tomcat&#xff0c;没怎么看过它的优化&#xff0c;今天抽出时间研究了下&#xff0c;将内容记录下。 首先&#xff0c;是客户端访问tomcat的一个过程&#xff0c;如图所示&#xff1a; 图中间虚线框部分是 Apache基金下的服务器来做静态资源处理的&#xff0c;而这部…
阅读更多...
Fast Image Cache – iOS 应用程序高性能图片缓存

Fast Image Cache – iOS 应用程序高性能图片缓存

Fast Image Cache 是一种在 iOS 应用程序中高效、持续、超快速的存储和检索图像的解决方案。任何良好的 iOS 应用程序的用户体验都应该是快速&#xff0c;平滑滚动的&#xff0c;Fast Image Cache 提供图像高速缓存有助于使这更容易实现。 对于图片丰富的应用程序&#xff0c;图…
阅读更多...
Linux 字符设备驱动开发基础（四）—— ioctl() 函数解析

Linux 字符设备驱动开发基础（四）—— ioctl() 函数解析

解析完 open、close、read、write 四个函数后&#xff0c;终于到我们的 ioctl() 函数了 一、 什么是ioctl ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理&#xff0c;就是对设备的一些特性进行控制&#xff0c;例如串口的传输波特率、马达的转速…
阅读更多...
android自动化框架简要剖析（一）：运行原理+基本框架

android自动化框架简要剖析（一）：运行原理+基本框架

android自动化测试原理&#xff1a; 1、将测试apk和被测试apk&#xff0c;运行在一个进程中&#xff1b;通过instrumentation进行线程间的通信 2、通过android.test.AndroidTestCase及其子类&#xff0c;控制android系统对象 3、通过android.test.InstrumentationTestCase 及其…
阅读更多...
Linux 字符设备驱动开发基础（一）—— 编写简单 LED 设备驱动

Linux 字符设备驱动开发基础（一）—— 编写简单 LED 设备驱动

现在&#xff0c;我们来编写自己第一个字符设备驱动 —— 点亮LED。&#xff08;不完善&#xff0c;后面再完善&#xff09; 硬件平台&#xff1a;Exynos4412&#xff08;FS4412&#xff09; 编写驱动分下面几步&#xff1a; a -- 查看原理图、数据手册&#xff0c;了解设备的操…
阅读更多...
Linux 字符设备驱动结构（四）—— file_operations 结构体知识解析

Linux 字符设备驱动结构（四）—— file_operations 结构体知识解析

前面在 Linux 字符设备驱动开发基础 &#xff08;三&#xff09;—— 字符设备驱动结构&#xff08;中&#xff09; &#xff0c;我们已经介绍了两种重要的数据结构 struct inode{...}与 struct file{...} &#xff0c;下面来介绍另一个比较重要数据结构 struct _file_operatio…
阅读更多...
Android开发群

Android开发群

为什么80%的码农都做不了架构师&#xff1f;>>> 我的自建Android应用开发群&#xff0c;欢迎大家来聊聊呀&#xff01;201427584 转载于:https://my.oschina.net/catia/blog/176384
阅读更多...
Linux 字符设备驱动结构（三）—— file、inode结构体及chardevs数组等相关知识解析

Linux 字符设备驱动结构（三）—— file、inode结构体及chardevs数组等相关知识解析

前面我们学习了字符设备结构体cdev Linux 字符设备驱动开发 &#xff08;一&#xff09;—— 字符设备驱动结构&#xff08;上&#xff09; 下面继续学习字符设备另外几个重要的数据结构。 先看下面这张图&#xff0c;这是Linux 中虚拟文件系统、一般的设备文件与设备驱动程序…
阅读更多...
技术人生：三亚之行

技术人生：三亚之行

人生收获 此次是公司组团去的三亚&#xff0c;地接的导游非常热情&#xff0c;如同大多数人一样&#xff0c;导游也会在这短短的几天内&#xff0c;尽可能的表现自己&#xff0c;此文聊聊导游说的三句话。 旅游三不“较”&#xff1a; 不比较不计较不睡觉人生何尝不是如此&…
阅读更多...
Linux 字符设备驱动结构（二）—— 自动创建设备节点

Linux 字符设备驱动结构（二）—— 自动创建设备节点

上一篇我们介绍到创建设备文件的方法&#xff0c;利用cat /proc/devices查看申请到的设备名&#xff0c;设备号。 第一种是使用mknod手工创建&#xff1a;mknod filename type major minor 第二种是自动创建设备节点&#xff1a;利用udev&#xff08;mdev&#xff09;来实现设备…
阅读更多...
Linux 字符设备驱动结构（一）—— cdev 结构体、设备号相关知识解析

Linux 字符设备驱动结构（一）—— cdev 结构体、设备号相关知识解析

一、字符设备基础知识 1、设备驱动分类 linux系统将设备分为3类&#xff1a;字符设备、块设备、网络设备。使用驱动程序&#xff1a; 字符设备&#xff1a;是指只能一个字节一个字节读写的设备&#xff0c;不能随机读取设备内存中的某一数据&#xff0c;读取数据需要按照先后数…
阅读更多...
Linux 驱动开发之内核模块开发（四）—— 符号表的导出

Linux 驱动开发之内核模块开发（四）—— 符号表的导出

Linux内核头文件提供了一个方便的方法用来管理符号的对模块外部的可见性,因此减少了命名空间的污染(命名空间的名称可能会与内核其他地方定义的名称冲突),并且适当信息隐藏。 如果你的模块需要输出符号给其他模块使用,应当使用下面的宏定义: EXPORT_SYMBOL(name); EXPORT_SYMBO…
阅读更多...
Linux 驱动开发之内核模块开发 （三）—— 模块传参

Linux 驱动开发之内核模块开发 （三）—— 模块传参

一、module_param() 定义 通常在用户态下编程&#xff0c;即应用程序&#xff0c;可以通过main()的来传递命令行参数&#xff0c;而编写一个内核模块&#xff0c;则通过module_param() 来传参。 module_param()宏是Linux 2.6内核中新增的&#xff0c;该宏被定义在include/linux…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023