Chinaunix首页 | 论坛 | 博客

思而不学

首页　| 　博文目录　| 　关于我

ch122633

  • 博客访问： 478072
  • 博文数量： 223
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 2145
  • 用 户 组： 普通用户
  • 注册时间： 2014-03-01 10:23
个人简介

该坚持的时候坚持，该妥协的时候妥协，该放弃的时候放弃

文章分类

全部博文（223）

文章存档

2017年（56）

2016年（118）

2015年（3）

2014年（46）

我的朋友
最近访客
推荐博文
相关博文
总线设备驱动模型和平台设备模型

分类： 嵌入式

2016-11-11 23:15:29

一、总线模型
随着技术的不断进步，系统的拓扑结构也越来越复杂，对热插拔，跨平台移植性的要求也越来越高，2.4内核已经难以满足这些需求。为适应这种形势的需要，从Linux 2.6内核开始提供了全新的设备模型。

2.1 描述结构
在 Linux 内核中, 总线由 bus_type 结构表示,
定义在
struct bus_type {
const char *name; /*总线名称*/
int (*match) (struct device *dev, struct
device_driver *drv); /*驱动与设备的匹配函数*/
………
}

int (*match)(struct device * dev, struct device_driver * drv);
当一个新设备或者新驱动被添加到这个总线时，该函数被调用。用于判断指定的驱动程序是否能处理指定的设备。若可以，则返回非零。

2.2 总线注册与注销
总线的注册使用如下函数
bus_register(struct bus_type *bus);
若成功，新的总线将被添加进系统，并可在/sys/bus 下看到相应的目录。
总线的注销使用：
void bus_unregister(struct bus_type *bus);

3.1 描述结构
在 Linux内核中, 驱动由 device_driver结构表示。
struct device_driver {
{
const char *name; /*驱动名称*/
struct bus_type *bus; /*驱动程序所在的总线*/
int (*probe) (struct device *dev);
………
}

3.2 驱动注册与注销
 驱动的注册使用如下函数

int driver_register(struct device_driver *drv);
 驱动的注销使用：
void driver_unregister(struct device_driver *drv);

4.1 描述结构
在 Linux内核中, 设备由struct device结构表示。
struct device {
{
const char *init_name; /*设备的名字*/
struct bus_type *bus; /*设备所在的总线*/
………
}

4.2 驱动注册与注销
 设备的注册使用如下函数
int device_register(struct device *dev);
 设备的注销使用：
void device_unregister(struct device *dev);

5.编写代码
bus.c
  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/kernel.h>
  4. #include <linux/device.h>

  6. MODULE_LICENSE("GPL");

  8. int my_match(struct device *dev, struct device_driver *drv)
  9. {
  10.     return !strncmp(dev->kobj.name, drv->name, strlen(drv->name));
  11. }

  13. struct bus_type my_bus_type = {
  14.     .name = "my_bus",
  15.     .match = my_match,
  16. };
  17. EXPORT_SYMBOL(my_bus_type);

  19. int my_bus_init()
  20. {
  21.     int ret;
  22.     ret = bus_register(&my_bus_type);

  24.     return ret;
  25. }

  27. void my_bus_exit()
  28. {
  29.     bus_unregister(&my_bus_type);

  31. }

  33. module_init(my_bus_init);
  34. module_exit(my_bus_exit);
device.c:
  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/kernel.h>
  4. #include <linux/device.h>

  6. MODULE_LICENSE("GPL");

  8. extern struct bus_type my_bus_type;

  10. struct device my_device = {
  11.     .init_name = "my_dev",
  12.     .bus = &my_bus_type,
  13. };

  15. int my_device_init()
  16. {
  17.     int ret;
  18.     ret = device_register(&my_device);
  19.     return ret;
  20. }

  22. void my_device_exit()
  23. {
  24.     device_unregister(&my_device);
  25. }

  27. module_init(my_device_init);
  28. module_exit(my_device_exit);
device.c:
  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/device.h>
  4. #include <linux/kernel.h>

  6. MODULE_LICENSE("GPL");

  8. extern struct bus_type my_bus_type;

  10. int my_probe(struct device *dev)
  11. {
  12.     printk("driver found the device it can handle!\n");
  13.     return 0;
  14. }

  16. struct device_driver my_driver = {
  17.     .name = "my_dev",
  18.     .bus = &my_bus_type,
  19.     .probe = my_probe,
  20. };

  22. int my_driver_init()
  23. {
  24.     int ret;
  25.     ret = driver_register(&my_driver);
  26.     return ret;
  27. }

  29. void my_driver_exit()
  30. {
  31.     driver_unregister(&my_driver);
  32. }

  34. module_init(my_driver_init);
  35. module_exit(my_driver_exit)

1.平台总线概述
平台总线(Platform bus)是linux2.6内核加入的一种虚拟总线，其优势在于采用了总线的模型对设备与驱动进行了管理，这样提高了程序的可移植性。
通过平台总线机制开发设备驱动的流程如图：


2.平台设备
平台设备使用struct platform_device来描述:
struct platform_device {
const char *name; /*设备名*/
int id; /*设备编号，配合设备名使用*/
struct device dev;
u32 num_resources;
struct resource *resource; /*设备资源*/
}

struct resource {
resource_size_t start;
resource_size_t end;
const char *name;
unsigned long flags; /*资源的类型*/
struct resource *parent, *sibling, *child;
};
注册平台设备，使用函数:
int platform_device_register(struct platform_device *pdev);

3.平台驱动
平台驱动使用struct platform_driver 描述：
struct platform_driver {
int (*probe)(struct platform_device *);
int (*remove)(struct platform_device *);
……
}

平台驱动注册使用函数：
int platform_driver_register(struct platform_driver *);

将按键驱动修改为平台驱动模型
key_dev.c:
  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/platform_device.h>
  4. #include <linux/interrupt.h>

  6. MODULE_LICENSE("GPL");

  8. #define GPFCON 0x56000050

  10. struct resource key_resource[] = {                                                             //设置资源，对应2440的芯片地址
  11.     [0] = {
  12.         .start = GPFCON,
  13.     .end = GPFCON + 8,
  14.     .flags = IORESOURCE_MEM,
  15.         },
  16.     [1] = {
  17.         .start = IRQ_EINT0,
  18.     .end = IRQ_EINT2,
  19.     .flags = IORESOURCE_IRQ,
  20.         },
  21. };

  23. struct platform_device key_device = {                                                           //这个是平台设备结构
  24.     .name = "my-key",
  25.     .id = 0,
  26.     .num_resources = 2,
  27.     .resource = key_resource,
  28. };

  30. int keydev_init()
  31. {
  32.     platform_device_register(&key_device);                                                  //注册平台设备
  33. }

  35. void keydev_exit()
  36. {
  37.     platform_device_unregister(&key_device);                                              //注销平台设备
  38. }

  40. module_init(keydev_init);
  41. module_exit(keydev_exit);
key_drv.c:
  1. #include <linux/module.h>
  2. #include <linux/init.h>
  3. #include <linux/miscdevice.h>
  4. #include <linux/fs.h>
  5. #include <asm/uaccess.h>
  6. #include <linux/io.h>
  7. #include <linux/irqreturn.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/uaccess.h>
  10. #include <linux/platform_device.h>

  12. MODULE_LICENSE("GPL");

  14. #define GPFCON (volatile unsigned long*) 0x56000050
  15. #define GPFDAT (volatile unsigned long*) 0x56000054

  17. unsigned int *gpio_data;

  19. struct work_struct *work1;
  20. struct timer_list key_timer;
  21. wait_queue_head_t key_q;

  23. struct resource *res_irq;
  24. struct resource *res_mem;
  25. unsigned int *key_base;

  27. unsigned int key_num = 0;

  29. void key_timer_func(unsigned long data)
  30. {
  31.     unsigned int key_val;
  32.     key_val = readw(key_base+1);
  33.     if((key_val & 0x01) == 0)
  34.     {
  35.         key_num = 4;
  36.     }
  37.     else if((key_val& 0x02) == 0)
  38.     {
  39.         key_num = 1;
  40.     }
  41.     else if((key_val & 0x04) == 0)
  42.     {
  43.         key_num = 3;
  44.     }
  45.     else if((key_val & 0x10) == 0)
  46.     {
  47.         key_num = 2;
  48.     }

  50.     wake_up(&key_q);
  51. }

  53. void work1_func(struct work_struct *work)
  54. {
  55.     mod_timer(&key_timer, jiffies + HZ/10);
  56. }

  58. irqreturn_t key_int(int irq, void *dev_id)
  59. {
  60.     //1.检测是否发生了按键中断
  61.     
  62.     //2.清除已经发生的按键中断
  63.   
  64.     //3.提交下半部
  65.     schedule_work(work1);

  67.     return 0;
  68. }

  70. void key_hw_init()
  71. {
  72.     unsigned short data;
  73.     
  74.     data = readw(key_base);
  75.     data &= ~0x33f;
  76.     data |= 0x22a;
  77.     writew(data, key_base);
  78. }

  80. int key_open(struct inode *inode, struct file *filp)
  81. {
  82.     return 0;
  83. }

  85. ssize_t key_read(struct file *filp, char __user *buf, size_t size, loff_t *pos)
  86. {
  87.     wait_event(key_q, key_num);

  89.     printk("in kernel :key num is %d\n",key_num);
  90.     copy_to_user(buf, &key_num, 4);

  92.     key_num = 0;

  94.     return 4;
  95. }

  97. struct file_operations key_fops = {
  98.     .open = key_open,
  99.     .read = key_read,
  100. };

  102. struct miscdevice key_miscdev = {
  103.     .minor = 200,
  104.     .name = "tq2440key",
  105.     .fops = &key_fops,
  106. };

  108. int key_probe(struct platform_device *pdev)
  109. {
  110.     int ret,size;
  111.     
  112.     
  113.     ret = misc_register(&key_miscdev);
  114.     
  115.     if (ret !=0)
  116.         printk("register fail!\n");
  117.     
  118.     //注册中断处理程序
  119.     
  120.     res_irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);                                            //获取资源
  121.     
  122.     request_irq(res_irq->start,key_int,IRQF_TRIGGER_FALLING,"key",(void *)4);                          //设置中断
  123.     request_irq(res_irq->end,key_int,IRQF_TRIGGER_FALLING,"key",(void *)3);
  124.     
  125.     //按键初始化
  126.     res_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
  127.     size = (res_mem->end - res_mem->start) + 1;
  128.     key_base = ioremap(res_mem->start, size);
  129.     
  130.     key_hw_init();
  131.     
  132.     //. 创建工作
  133.     work1 = kmalloc(sizeof(struct work_struct),GFP_KERNEL);
  134.     INIT_WORK(work1, work1_func);
  135.     
  136.     /* 初始化定时器 */
  137.     init_timer(&key_timer);
  138.     key_timer.function = key_timer_func;
  139.     
  140.     /* 向内核注册一个定时器 */
  141.     add_timer(&key_timer);
  142.     
  143.     /*初始化等待队列*/
  144.     init_waitqueue_head(&key_q);
  145.     
  146.     return 0;
  147. }

  149. int key_remove(struct paltform_device *pdev)
  150. {
  151.     misc_deregister(&key_miscdev);
  152.     //注销中断处理函数
  153.     //free_irq(IRQ_EINT0, 0);
  154.     //free_irq(IRQ_EINT1, 0);
  155.     //free_irq(IRQ_EINT2, 0);
  156.     //free_irq(IRQ_EINT4, 0);
  157.     return 0;
  158. }

  160. struct platform_driver key_driver = {                                                         //这里是平台驱动结构，与平台设备结构通过name进行对接
  161.     .probe = key_probe,
  162.     .remove = key_remove,
  163.     .driver = {
  164.         .owner = THIS_MODULE,
  165.         .name = "my-key",
  166.     },
  167. };

  169. static int button_init()
  170. {
  171.     return platform_driver_register(&key_driver);                                         //注册平台驱动
  172.     
  173. }

  175. static void button_exit()
  176. {
  177.     platform_driver_unregister(&key_driver);                                               //注销平台驱动
  178. }

  180. module_init(button_init);
  181. module_exit(button_exit);



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

上一篇：阻塞型驱动设计

下一篇：tty驱动程序架构

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

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

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

16024965号-6