程序博客网 > 相片添加日期软件

Linux设备模型（下）之Platform

来源：互联网 发布：相片添加日期软件 编辑：程序博客网 时间：2024/06/03 14:53

从Linux2.6内核起，引入一套新的驱动管理和注册机制：platform_device和 platform_driver 。Linux 中大部分的设备驱动，都可以使用这套机制，设备用 platform_device 表示；驱动用platform_driver 进行注册。 platform是一个虚拟的地址总线，相比pci，usb，它主要用于描述SOC上的片上资源，比如s3c2440上集成的控制器（lcd，watchdog，rtc等）， platform所描述的资源有一个共同点，就是在cpu的总线上直接取址。平台设备会分到一个名称(用在驱动绑定中)以及一系列诸如地址和中断请求号(IRQ)之类的资源.

  1. struct platform_device {  
  2.     const char * name;  
  3.     intid;  
  4.     struct device dev;  
  5.     u32num_resources;  
  6.     struct resource * resource;  
  7.  };  

平台驱动遵循标准驱动模型的规范, 平台驱动按标准规范对电源管理和关机通告提供支 持

  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 device_driver driver;  
  10. };  


probe()总应该核实指定的设备硬件确实存在;平台设置代码有时不能确定这一点

 

系统为platform总线定义一个bus_type的实例platform_bus_type，通过其成员函数match()，确定device和driver如何匹配。

匹配platform_device和platform_driver主要看二者的name字段是否相同。（name必须要相同才能匹配）

 用platform_device_register(platform_device*)函数注册单个的平台设备。

一般是在平台的BSP文件中定义platform_device，通过platform_add_devices(platform_device*)函数将平台设备注册到系统中platform_driver 的注册与注销：

platform_driver_register(platform_driver*)

platform_driver_unregister(platform_driver*)

 

设备资源（struct resource)

关于资源的操作（平台设备会分到一系列诸如地址和中断请求号(IRQ)之类的资源)

struct resource {

   resource_size_t start;

   resource_size_t end;

   const char *name;

   unsigned long flags;

 // IORESOURCE_IO

 //IORESOURCE_MEM

 //IORESOURCE_IRQ

 //IORESOURCE_DMA

   struct resource *parent, *sibling, *child;

};

基于资源的分类（flags）有I/O端口、IRQ、DMA等等，而I/O端口又分为2种类型，IORESOURCE_IO（I/O映射） IORESOURCE_MEM（内存映射）CPU对外设IO端口物理地址的编址方式有2种：一种是IO映射方式（IO-mapped）， 另一种是内存映射方式（Memory-mapped）。具体采用哪一种方式则取决于CPU的体系结构。 像X86体系对外设就专门实现了一个单独地址空间，并且有专门的I/O指令来访问I/O端口，像ARM体系结构通常只是实现一个物理地址空间，I/O端口就被映射到CPU的单一物理地址空间中，而成为内存的一部分，所以一般资源都采用（IORESOURCE_MEM）。linux中对设备的资源按照资源树的结构来组织(其实就是一个链表结构的插入、删除、查找等操作），上面再添加设备（platform_device_add）的同时对相应的资源在资源树上进行插入操作

int insert_resource(struct resource *parent, struct resource *new)

 

关于platform resource有相关的函数进行对资源的操作。

struct resource *platform_get_resource(struct platform_device *, unsigned int, unsigned int);

int platform_get_irq(struct platform_device *, unsigned int);

struct resource *platform_get_resource_byname(struct platform_device *, unsigned int, char *);

int platform_get_irq_byname(struct platform_device *, char *);

例如s3c2440的watchdog资源分配实例：

watchdog寄存器的基地址为0x5300000

#define S3C2410_PA_WATCHDOG (0x53000000)

#define S3C24XX_SZ_WATCHDOG SZ_1M

static struct resource s3c_wdt_resource[] = {

   [0] = {

      .start = S3C24XX_PA_WATCHDOG,

      .end = S3C24XX_PA_WATCHDOG + S3C24XX_SZ_WATCHDOG - 1,

      .flags = IORESOURCE_MEM, //内存映射

   },

   [1] = {

      .start = IRQ_WDT,

      .end = IRQ_WDT,

      .flags = IORESOURCE_IRQ, //IRQ

   }

};

plat_button_device.c：

  1. #include <linux/module.h>  
  2. #include <linux/types.h>  
  3. #include <linux/fs.h>  
  4. #include <linux/init.h>  
  5. #include <linux/platform_device.h>  
  6. #include <mach/regs-gpio.h>  
  7. #include <linux/interrupt.h>  
  8. #include <linux/device.h>  
  9. #include <linux/io.h>  
  10.   
  11. /*平台资源的定义*/  
  12. static struct resource s3c_buttons_resource[] = {  
  13.     [0]={  
  14.         .start = S3C24XX_PA_GPIO,//                       (0x56000000)  
  15.         .end   = S3C24XX_PA_GPIO + S3C24XX_SZ_GPIO - 1,//(0x56000000) + 0x00100000 -1   
  16.         .flags = IORESOURCE_MEM,  
  17.     },  
  18.       
  19.     [1]={  
  20.         .start = IRQ_EINT7,  
  21.         .end   = IRQ_EINT7,  
  22.         .flags = IORESOURCE_IRQ,  
  23.     },  
  24.     [2]={  
  25.         .start = IRQ_EINT1,  
  26.         .end   = IRQ_EINT1,  
  27.         .flags = IORESOURCE_IRQ,  
  28.     },  
  29.     [3]={  
  30.         .start = IRQ_EINT2,  
  31.         .end   = IRQ_EINT2,  
  32.         .flags = IORESOURCE_IRQ,  
  33.     },  
  34.     [4]={  
  35.         .start = IRQ_EINT3,  
  36.         .end   = IRQ_EINT3,  
  37.         .flags = IORESOURCE_IRQ,  
  38.     },  
  39.     [5]={  
  40.         .start = IRQ_EINT4,  
  41.         .end   = IRQ_EINT4,  
  42.         .flags = IORESOURCE_IRQ,  
  43.     },  
  44.     [6]={  
  45.         .start = IRQ_EINT5,  
  46.         .end   = IRQ_EINT5,  
  47.         .flags = IORESOURCE_IRQ,  
  48.     }  
  49. };  
  50.   
  51. static struct platform_device *s3c_buttons;  
  52.   
  53.   
  54. static int __init platform_init(void)  
  55. {  
  56.   
  57.     s3c_buttons = platform_device_alloc("gec2440-buttons",-1);  
  58.   
  59.     platform_device_add_resources(s3c_buttons,&s3c_buttons_resource,7);  
  60.   
  61.     /*平台设备的注册*/  
  62.     platform_device_add(s3c_buttons);  
  63. }  
  64.   
  65. static void __exit platform_exit(void)  
  66. {  
  67.     platform_device_unregister(s3c_buttons);  
  68. }  
  69.   
  70. module_init(platform_init);  
  71. module_exit(platform_exit);  
  72.   
  73. MODULE_AUTHOR("Steven Bai");  
  74. MODULE_LICENSE("GPL");  
  75. MODULE_ALIAS("platform:gec2440buttons");  

plat_button_driver.c：

  1. #include <linux/module.h>  
  2. #include <linux/types.h>  
  3. #include <linux/miscdevice.h>  
  4. #include <linux/fs.h>  
  5. #include <linux/init.h>  
  6. #include <linux/platform_device.h>  
  7. #include <linux/interrupt.h>  
  8. #include <linux/clk.h>  
  9. #include <linux/uaccess.h>  
  10. #include <linux/io.h>  
  11. #include <mach/map.h>  
  12. #include <mach/regs-gpio.h>  
  13. #include <linux/poll.h>  
  14. #include <linux/irq.h>  
  15. #include <asm/unistd.h>  
  16. #include <linux/device.h>  
  17.   
  18. #define DEVICE_NAME "buttons"  
  19.   
  20.   
  21. static DECLARE_WAIT_QUEUE_HEAD(button_waitq);  
  22.   
  23. static volatile int ev_press = 0;  
  24.   
  25.   
  26. static int key_value;  
  27. static struct device     *buttons_dev;  /* platform device attached to */  
  28. static struct resource  *buttons_mem;  
  29. static struct resource   *buttons_irq;  
  30. static void __iomem     *buttons_base;  
  31.   
  32.   
  33. static int button_irqs[6];  
  34.   
  35. static irqreturn_t buttons_interrupt(int irq, void *dev_id)  
  36. {  
  37.     int i;  
  38.     for(i=0; i<6; i++){  
  39.         if(irq == button_irqs[i]){  
  40.             printk("==>interrput number:%d\n",irq);    
  41.             key_value = i;  
  42.             ev_press =1;  
  43.             wake_up_interruptible(&button_waitq);         
  44.         }  
  45.     }  
  46.       
  47.     return IRQ_RETVAL(IRQ_HANDLED);  
  48.       
  49. }  
  50.   
  51. static int s3c24xx_buttons_open(struct inode *inode, struct file *file)  
  52. {  
  53.     int i;  
  54.     int err = 0;  
  55.     /*注册中断*/  
  56.     for(i=0; i<6; i++){  
  57.         if (button_irqs[i] < 0)   
  58.             continue;  
  59.                               
  60.                 /*中断触发方式：上升沿触发*/  
  61.         err = request_irq(button_irqs[i],buttons_interrupt,IRQ_TYPE_EDGE_RISING,NULL,NULL);  
  62.         if(err)  
  63.           break;  
  64.     }  
  65.   
  66.     if (err) {  
  67.         i--;  
  68.         for (; i >= 0; i--) {  
  69.             if (button_irqs[i] < 0) {  
  70.                 continue;  
  71.             }  
  72.             disable_irq(button_irqs[i]);  
  73.             free_irq(button_irqs[i], NULL);  
  74.         }  
  75.         return -EBUSY;  
  76.     }  
  77.   
  78.     ev_press = 0;     
  79.     return 0;  
  80. }  
  81.   
  82. static int s3c24xx_buttons_close(struct inode *inode, struct file *file)  
  83. {  
  84.     int i;      
  85.     for (i=0; i<6; i++) {  
  86.             if (button_irqs[i] < 0) {  
  87.                 continue;  
  88.             }  
  89.             free_irq(button_irqs[i],NULL);  
  90.     }  
  91.     return 0;  
  92. }  
  93.   
  94. static int s3c24xx_buttons_read(struct file *filp, char __user *buff, size_t count, loff_t *offp)  
  95. {  
  96.     unsigned long err;  
  97.     if (!ev_press) {  
  98.         if (filp->f_flags & O_NONBLOCK)  
  99.             return -EAGAIN;  
  100.         else  
  101.             wait_event_interruptible(button_waitq, ev_press);  
  102.     }      
  103.     ev_press = 0;  
  104.     err = copy_to_user(buff, &key_value, sizeof(key_value));  
  105.     return sizeof(key_value);  
  106. }  
  107.   
  108. static unsigned int s3c24xx_buttons_poll( struct file *file, struct poll_table_struct *wait)  
  109. {  
  110.     unsigned int mask = 0;  
  111.     poll_wait(file, &button_waitq, wait);  
  112.     if (ev_press){  
  113.         mask |= POLLIN | POLLRDNORM;  
  114.     }  
  115.     return mask;  
  116. }  
  117.   
  118.   
  119.   
  120. static struct file_operations gec2440buttons_fops = {  
  121.     .owner   =   THIS_MODULE,  
  122.     .open    =   s3c24xx_buttons_open,  
  123.     .release =   s3c24xx_buttons_close,  
  124.     .read    =   s3c24xx_buttons_read,  
  125.     .poll    =   s3c24xx_buttons_poll,  
  126. };  
  127.   
  128. static struct miscdevice gec2440_miscdev = {  
  129.       
  130.     .minor = MISC_DYNAMIC_MINOR,  
  131.     .name = DEVICE_NAME,  
  132.     .fops = &gec2440buttons_fops,  
  133. };  
  134.   
  135. /* device interface */  
  136. static int gec2440_buttons_probe(struct platform_device *pdev)  
  137. {  
  138.     struct resource *res;  
  139.     struct device *dev;  
  140.     int ret;  
  141.     int size;  
  142.     int i;  
  143.       
  144.     printk("probe:%s\n", __func__);  
  145.     dev = &pdev->dev;  
  146.     buttons_dev = &pdev->dev;  
  147.       
  148.     /*平台资源获取*/  
  149.     res = platform_get_resource(pdev, IORESOURCE_MEM, 0);  
  150.     if (res == NULL) {  
  151.         dev_err(dev, "no memory resource specified\n");  
  152.         return -ENOENT;  
  153.     }  
  154.       
  155.     size = (res->end - res->start) + 1;  
  156.     buttons_mem = request_mem_region(res->start, size, pdev->name);  
  157.     if (buttons_mem == NULL) {  
  158.         dev_err(dev, "failed to get memory region\n");  
  159.         ret = -ENOENT;  
  160.         goto err_req;  
  161.     }  
  162.       
  163.     buttons_base = ioremap(res->start, size);  
  164.     if (buttons_base == NULL) {  
  165.         dev_err(dev, "failed to ioremap() region\n");  
  166.         ret = -EINVAL;  
  167.         goto err_req;  
  168.     }  
  169.     printk(KERN_DEBUG"probe: mapped buttons_base=%p\n", buttons_base);  
  170.   
  171.  /*get irq number*/  
  172.     for(i=0; i<6; i++)  
  173.     {  
  174.          buttons_irq = platform_get_resource(pdev,IORESOURCE_IRQ,i);  
  175.          if(buttons_irq == NULL)  
  176.          {  
  177.             dev_err(dev,"no irq resource specified\n");  
  178.               ret = -ENOENT;  
  179.               goto err_map;  
  180.           }  
  181.         button_irqs[i] = buttons_irq->start;  
  182.         printk("button_irqs[%d]=%d\n",i,button_irqs[i]);    
  183.     }  
  184.     ret = misc_register(&gec2440_miscdev);  
  185.           
  186.     return 0;  
  187.   
  188.  err_map:  
  189.     iounmap(buttons_base);  
  190.   
  191.  err_req:  
  192.     release_resource(buttons_mem);  
  193.     kfree(buttons_mem);  
  194.   
  195.     return ret;  
  196. }  
  197.   
  198. static int gec2440_buttons_remove(struct platform_device *dev)  
  199. {  
  200.     release_resource(buttons_mem);  
  201.     kfree(buttons_mem);  
  202.     buttons_mem = NULL;  
  203.   
  204.     iounmap(buttons_base);  
  205.     misc_deregister(&gec2440_miscdev);  
  206.     return 0;  
  207. }  
  208.   
  209. /*平台驱动定义*/  
  210. static struct platform_driver gec2440buttons_driver = {  
  211.     .probe      = gec2440_buttons_probe,  
  212.     .remove     = gec2440_buttons_remove,  
  213.     .driver     = {  
  214.         .owner  = THIS_MODULE,  
  215.         .name   = "gec2440-buttons",  
  216.     },  
  217. };  
  218.   
  219. static char banner[] __initdata =  
  220.      "gec2440 Buttons Driver\n";  
  221.   
  222. static int __init buttons_init(void)  
  223. {  
  224.     printk(banner);  
  225.     /*平台驱动注册*/  
  226.     platform_driver_register(&gec2440buttons_driver);  
  227.     return 0;  
  228. }  
  229.   
  230. static void __exit buttons_exit(void)  
  231. {  
  232.     platform_driver_unregister(&gec2440buttons_driver);  
  233. }  
  234.   
  235. module_init(buttons_init);  
  236. module_exit(buttons_exit);  
  237.   
  238. MODULE_AUTHOR("Steven Bai");  
  239. MODULE_DESCRIPTION("gec2440 Buttons Driver");  
  240. MODULE_LICENSE("GPL");  

 

开发板一上电后，可以/sys/bus/platform/下会挂上这个设备和对应的驱动
0 0
相片添加日期软件 相片添加日期软件
原创粉丝点击
热门IT博客
php demophp demo
java封装类例子java封装类例子
淘宝开店做什么赚钱
伦敦地铁爆炸 知乎
电子印章制作软件
eureka java
炎黄网络 服务器怎么样
隐藏淘宝导航代码大全
慕课网络教育
如何查询数据库中的表
装修设计软件免费版
尼采知乎
java分布式应用开发
淘宝优惠券转化淘宝客
打印机安装软件
阿里巴巴商机助理mac
mcs51单片机编程环境
虚拟现实仿真软件
李守力 知乎
软件规范介绍
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 长吁短叹 噫吁嚱 长吁短叹读音 吁嗟 香月气喘吁吁老中医干 李昶吁初安琪结婚照 李昶吁 吁组词 吁嗟篇 短叹长吁 噫吁嚱危乎高哉 嗟吁 吁蚨加 噫吁 吁的多音字组词 吁多音字组词 吁的成语 什么吁什么叹 都俞吁 噫吁戏危乎高哉 州吁的读音 吁字开头的成语 吁怎么读音 吁的读音 吁三个多音字组词 初安琪与李昶吁现状 干点活就气喘吁吁 东吴证券 东吴 东吴大学 苏州东吴 东吴一点红 东吴大都督 东吴镇 三国东吴 东吴都督 东吴人才网 东吴面馆 东吴传 东吴人寿 东吴四英杰

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里