Chinaunix首页 | 论坛 | 博客

胡说-操作系统

首页　| 　博文目录　| 　关于我

zhuimengcanyang

  • 博客访问： 831050
  • 博文数量： 281
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 2770
  • 用 户 组： 普通用户
  • 注册时间： 2009-08-02 19:45
个人简介

邮箱：zhuimengcanyang@163.com 痴爱嵌入式技术的蜗牛

文章分类

全部博文（281）

文章存档

2020年（1）

2018年（1）

2017年（56）

2016年（72）

2015年（151）

最近访客
推荐博文
相关博文
第9个驱动程序_总线设备驱动模型

分类： 嵌入式

2015-08-24 13:59:11

目的

        这一节将点灯驱动程序通过总线设备驱动模型来实现，人为地进行拆分，这只是提供了一个参考的机制。


1. 介绍

上一节讲了输入子系统，在这个概念里讲到了分层分离思想。“一切都可以利用分层来实现”。
对于输入子系统，有一个核心层，下面两个层，一个是纯软件部分，内核已经做好了；还有一个是代表设备层，需要用户自己添加驱动代码。这是和硬件相关的部分，需要改变。这样分层的好处就是，对于软件层来说，不需要改变；而硬件层，需要提供不同的操作方法，用户可以根据自己使用硬件的不同而改变驱动程序，仅此而已。
输入子系统中：将核心层与设备相关层分层，每层专注自己的功能。
                      将硬件层和纯软件层分离出来，把稳定的代码保留，用户只需修改与硬件相关的部分。

分离分层思想
（1）分层：核心层和设备相关层分开
这种思想的优点就是能把很多文件共用的代码抽离集中起来成为一个或者多个核心文件供设备相关层调用，每一层专注于自己的功能。
（2）分离：
把硬件相关的代码(对于某个CPU来说是固定的，如板子的网卡、中断地址)和驱动(会根据程序作变动，如点哪一个灯)分离开来，即要编写两个文件：dev.c和drv.c。

2. 代码分析

bus_drv_dev模型： 参考gpio_keys.c文件。

（0）几个重要的数据结构

bus_type：总线的类型

点击(此处)折叠或打开

  1. struct bus_type {
  2.     const char        * name;
  3.     struct module        * owner;

  5.     struct kset        subsys;

  7.       // 含有driver 和 device 链表
  8.   struct kset        drivers;   // drv链表
  9.   struct kset        devices;   // dev链表
  10.     struct klist        klist_devices;
  11.     struct klist        klist_drivers;

  13.     struct blocking_notifier_head bus_notifier;

  15.     struct bus_attribute    * bus_attrs;
  16.     struct device_attribute    * dev_attrs;
  17.     struct driver_attribute    * drv_attrs;
  18.     struct bus_attribute drivers_autoprobe_attr;
  19.     struct bus_attribute drivers_probe_attr;

  21.    int        (*match)(struct device * dev, struct device_driver * drv);   // 用来比较drv和dev的ID是否一致，匹配。
  22.     int        (*uevent)(struct device *dev, char **envp,
  23.                  int num_envp, char *buffer, int buffer_size);
  24.     int        (*probe)(struct device * dev);
  25.     int        (*remove)(struct device * dev);
  26.     void        (*shutdown)(struct device * dev);

  28.     int (*suspend)(struct device * dev, pm_message_t state);
  29.     int (*suspend_late)(struct device * dev, pm_message_t state);
  30.     int (*resume_early)(struct device * dev);
  31.     int (*resume)(struct device * dev);

  33.     unsigned int drivers_autoprobe:1;
  34. };

struct device

点击(此处)折叠或打开

  1. struct device {
  2.     struct klist        klist_children;
  3.     struct klist_node    knode_parent;        /* node in sibling list */
  4.     struct klist_node    knode_driver;
  5.     struct klist_node    knode_bus;
  6.     struct device        *parent;

  8.     struct kobject kobj;
  9.     char    bus_id[BUS_ID_SIZE];    /* position on parent bus */
  10.     struct device_type    *type;
  11.     unsigned        is_registered:1;
  12.     unsigned        uevent_suppress:1;
  13.     struct device_attribute uevent_attr;
  14.     struct device_attribute *devt_attr;

  16.     struct semaphore    sem;    /* semaphore to synchronize calls to
  17.                      * its driver.
  18.                      */

  20.   struct bus_type    * bus;        /* type of bus device is on， 定义在那一根bus上面 */
  21.    struct device_driver *driver;    /* which driver has allocated this device， 和该dev对应的driver */

  23.     void        *driver_data;    /* data private to the driver */
  24.     void        *platform_data;    /* Platform specific data, device
  25.                      core doesn't touch it */
  26.     struct dev_pm_info    power;

  28. #ifdef CONFIG_NUMA
  29.     int        numa_node;    /* NUMA node this device is close to */
  30. #endif
  31.     u64        *dma_mask;    /* dma mask (if dma'able device) */
  32.     u64        coherent_dma_mask;/* Like dma_mask, but for
  33.                      alloc_coherent mappings as
  34.                      not all hardware supports
  35.                      64 bit addresses for consistent
  36.                      allocations such descriptors. */

  38.     struct list_head    dma_pools;    /* dma pools (if dma'ble) */

  40.     struct dma_coherent_mem    *dma_mem; /* internal for coherent mem
  41.                      override */
  42.     /* arch specific additions */
  43.     struct dev_archdata    archdata;

  45.     spinlock_t        devres_lock;
  46.     struct list_head    devres_head;

  48.     /* class_device migration path */
  49.     struct list_head    node;
  50.     struct class        *class;
  51.     dev_t            devt;        /* dev_t, creates the sysfs "dev" */
  52.     struct attribute_group    **groups;    /* optional groups */

  54.     void    (*release)(struct device * dev);  // 需要显示提供
  55. };

struct device_driver

点击(此处)折叠或打开

  1. struct device_driver {
  2.     const char        * name;
  3.    struct bus_type        * bus;   // dev在哪一个bus上面

  5.     struct kobject        kobj;
  6.     struct klist        klist_devices;
  7.     struct klist_node    knode_bus;

  9.     struct module        * owner;
  10.     const char         * mod_name;    /* used for built-in modules */
  11.     struct module_kobject    * mkobj;

  13.    int    (*probe)    (struct device * dev);  // 如果dev和drv匹配，则调用该probe函数。
  14.     int    (*remove)    (struct device * dev);
  15.     void    (*shutdown)    (struct device * dev);
  16.     int    (*suspend)    (struct device * dev, pm_message_t state);
  17.     int    (*resume)    (struct device * dev);
  18. };

（1） 平台驱动注册

platform_driver_register(struct platform_driver *drv)
    driver_register(struct device_driver * drv)
        bus_add_driver(struct device_driver *drv)
           driver_attach(struct device_driver * drv) 
                bus_for_each_dev(struct bus_type * bus, struct device * start, void * data, int (*fn)(struct device *, void *))  // 从dev链表取出每个dev，一一和drv进行比较。
                    __driver_attach(struct device * dev, void * data)
                        driver_probe_device(struct device_driver * drv, struct device * dev)
                            if (drv->bus->match && !drv->bus->match(dev, drv))   // 这里调用bus总线上的match函数来判断drv的ID 和 dev的ID 是否一致，如果一致，则match。
                                                                                                            // 对应platform_bus总线的match函数已经定义好了。

点击(此处)折叠或打开

  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.     .suspend    = platform_suspend,
  7.     .suspend_late    = platform_suspend_late,
  8.     .resume_early    = platform_resume_early,
  9.     .resume        = platform_resume,
  10. };

（2）平台设备注册

platform_device_register(struct platform_device * pdev)
    platform_device_add(struct platform_device *pdev)
        device_add(struct device *dev)
            bus_attach_device(struct device * dev)
                device_attach(struct device * dev)
                    bus_for_each_drv(struct bus_type * bus, struct device_driver * start,  void * data, int (*fn)(struct device_driver *, void *)) // 这里从drv链表，取出drv一一和dev比较
                        __device_attach(struct device_driver * drv, void * data)
                            driver_probe_device(struct device_driver * drv, struct device * dev)
                                if (drv->bus->match && !drv->bus->match(dev, drv))  //调用bus上定义的match函数进行比较，如果drv和dev的ID相同的话，则匹配


（3）总结





3. 驱动代码

dev这边放置的需要经常改变的代码（根据用户使用的外设不同而不同）； drv这边放置的是稳定的代码。

led_dev.c

点击(此处)折叠或打开



  3. #include <linux/module.h>
  4. #include <linux/version.h>

  6. #include <linux/init.h>

  8. #include <linux/kernel.h>
  9. #include <linux/types.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/list.h>
  12. #include <linux/timer.h>
  13. #include <linux/init.h>
  14. #include <linux/serial_core.h>
  15. #include <linux/platform_device.h>


  18. /* 分配/设置/注册一个platform_device */

  20. static struct resource led_resource[] = {
  21.     [0] = {
  22.         .start = 0x56000050,          // 起始 地址GPFCON
  23.         .end = 0x56000050 + 8 - 1,    // 结束地址，定义了两个32位的寄存器。 GPFCON GPFDAT
  24.         .flags = IORESOURCE_MEM,      // 资源类型： 内存类
  25.     },
  26.     [1] = {
  27.         .start = 5,                   // pin 脚值
  28.         .end = 5,                     // pin 脚值
  29.         .flags = IORESOURCE_IRQ,      // 中断资源
  30.     }

  32. };

  34. static void led_release(struct device * dev)  // 显示提供，可以不做任何事
  35. {
  36. }



  40. static struct platform_device led_dev = {
  41.     .name = "myled",
  42.     .id = -1,
  43.     .num_resources = ARRAY_SIZE(led_resource),
  44.     .resource = led_resource,
  45.     .dev = {
  46.         .release = led_release,  // 必须显示提供，不然卸载会报错
  47.     },
  48. };

  50. static int led_dev_init(void)
  51. {
  52.     platform_device_register(&led_dev);  // 注册平台设备
  53.     return 0;
  54. }

  56. static void led_dev_exit(void)
  57. {
  58.     platform_device_unregister(&led_dev);
  59. }

  61. module_init(led_dev_init);
  62. module_exit(led_dev_exit);

  64. MODULE_LICENSE("GPL");

led_drv.c

点击(此处)折叠或打开

  1. /* 分配/设置/注册一个platform_driver */

  3. #include <linux/module.h>
  4. #include <linux/version.h>

  6. #include <linux/init.h>
  7. #include <linux/fs.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/irq.h>
  10. #include <linux/sched.h>
  11. #include <linux/pm.h>
  12. #include <linux/sysctl.h>
  13. #include <linux/proc_fs.h>
  14. #include <linux/delay.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/input.h>
  17. #include <linux/irq.h>
  18. #include <asm/uaccess.h>
  19. #include <asm/io.h>

  21. static int major;


  24. static struct class *cls;
  25. static volatile unsigned long *gpio_con;
  26. static volatile unsigned long *gpio_dat;
  27. static int pin;

  29. static int led_open(struct inode *inode, struct file *file)
  30. {
  31.     //printk("first_drv_open\n");
  32.     /* 配置为输出 */
  33.     *gpio_con &= ~(0x3<<(pin*2));
  34.     *gpio_con |= (0x1<<(pin*2));
  35.     return 0;    
  36. }

  38. static ssize_t led_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
  39. {
  40.     int val;

  42.     //printk("first_drv_write\n");

  44.     copy_from_user(&val, buf, count); //    copy_to_user();

  46.     if (val == 1)
  47.     {
  48.         // 点灯
  49.         *gpio_dat &= ~(1<<pin);
  50.     }
  51.     else
  52.     {
  53.         // 灭灯
  54.         *gpio_dat |= (1<<pin);
  55.     }
  56.     
  57.     return 0;
  58. }


  61. static struct file_operations led_fops = {
  62.     .owner = THIS_MODULE, /* 这是一个宏，推向编译模块时自动创建的__this_module变量 */
  63.     .open = led_open,
  64.     .write    =    led_write,    
  65. };

  67. static int led_probe(struct platform_device *pdev)  // probe函数里面你可以做你想做的事情，这里只是提供了这样一种机制。
  68. {
  69.     struct resource        *res;

  71.     /* 根据platform_device的资源进行ioremap */
  72.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);  // 最后一个参数0：表示从资源的最开始地址获取。
  73.     gpio_con = ioremap(res->start, res->end - res->start + 1);
  74.     gpio_dat = gpio_con + 1;

  76.     res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
  77.     pin = res->start;   //获取pin脚值


  80.     /* 注册字符设备驱动程序 */
  81.     printk("led_probe, found led\n");

  83.     major = register_chrdev(0, "myled", &led_fops);
  84.     cls = class_create(THIS_MODULE, "myled");
  85.     class_device_create(cls, NULL, MKDEV(major, 0), NULL, "led"); /* /dev/led */
  86.     
  87.     return 0;
  88. }

  90. static int led_remove(struct platform_device *pdev)
  91. {
  92.     /* 卸载字符设备驱动程序 */
  93.     /* iounmap */
  94.     printk("led_remove, remove led\n");

  96.     class_device_destroy(cls, MKDEV(major, 0));
  97.     class_destroy(cls);
  98.     unregister_chrdev(major, "myled");
  99.     iounmap(gpio_con);
  100.     
  101.     return 0;
  102. }


  105. struct platform_driver led_drv = {
  106.     .probe        = led_probe,
  107.     .remove        = led_remove,
  108.     .driver        = {
  109.         .name    = "myled",
  110.     }
  111. };


  114. static int led_drv_init(void)
  115. {
  116.     platform_driver_register(&led_drv);
  117.     return 0;
  118. }

  120. static void led_drv_exit(void)
  121. {
  122.     platform_driver_unregister(&led_drv);
  123. }

  125. module_init(led_drv_init);
  126. module_exit(led_drv_exit);

  128. MODULE_LICENSE("GPL");

4. 测试代码

点击(此处)折叠或打开

  1. #include <sys/types.h>
  2. #include <sys/stat.h>
  3. #include <fcntl.h>
  4. #include <stdio.h>

  6. /* led_test on
  7.  * led_test off
  8.  */
  9. int main(int argc, char **argv)
  10. {
  11.     int fd;
  12.     int val = 1;
  13.     fd = open("/dev/led", O_RDWR);
  14.     if (fd < 0)
  15.     {
  16.         printf("can't open!\n");
  17.     }
  18.     if (argc != 2)
  19.     {
  20.         printf("Usage :\n");
  21.         printf("%s \n", argv[0]);
  22.         return 0;
  23.     }

  25.     if (strcmp(argv[1], "on") == 0)
  26.     {
  27.         val = 1;
  28.     }
  29.     else
  30.     {
  31.         val = 0;
  32.     }
  33.     
  34.     write(fd, &val, 4);
  35.     return 0;
  36. }

5. 测试




小结



阅读(560) | 评论(0) | 转发(0) |
0

上一篇：第8个驱动程序_输入子系统

下一篇：git学习网站

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6