程序博客网 > js给select标签负值

基于platform总线的中断(按键)字符设备驱动设计

来源：互联网 发布：js给select标签负值 编辑：程序博客网 时间：2024/04/30 22:06

基于platform总线的中断(按键)字符设备驱动设计

于platform总线的中断(按键)字符设备驱动设计2011-12-23 13:02:02

分类： LINUX

我的环境：
主机:Fedora 14，内核版本2.6.38.1
开发板:ARM9 tq2440
移植内核版本:linux-2.6.30.4

1、platform简介
为了理解platform总线设备驱动模型的实际运用，我首先分析了基于S3C2410的看门狗驱动实现过程，我本着将自己学过的知识在温习一遍的态度，完成了基于platform平台总线的外部中断（按键）的基本实现过程，分别采用了混杂字符设备和一般字符设备进行了操作，其中混杂字符设备驱动、应用程序参照了 Y-Kee http://blog.csdn.net/ayangke,QQ:843308498的基本框架。
platform总线是总线设备驱动模型中的一种，内核帮助实现了总线部分，我们在设计驱动的过程中只需要完成驱动和设备的添加即可。其中设备的添加包括添加设备名和相关的硬件资源（中断号和寄存器分布）。而驱动的添加除了添加必要的驱动模型以外，还需要得到硬件的具体资源，并对资源进行相应的操作和处理。
2、中断处理简介
中断是处理外设与处理器速度不匹配过程中常用的方法，基本的思想是，当产生中断以后，CPU必须停止当前处理的任务，转去执行中断处理程序，待中断处理程序处理完成以后再回到当前处理任务的过程。嵌入式处理器中的中断主要包括两部分CPU的内部中断（主要是异常）以及外设的中断（外部中断）。同时有的中断可以被屏蔽，而有的中断又不能被屏蔽，又可以将中断分为屏蔽和不可屏蔽中断。根据入口的跳转方法又可以将中断分为向量中断和非向量中断。向量中断通常是不同的中断号有不同的处理程序入口地址（硬件提供），而非向量中断通常是指共享型的中断，入口地址通常是由用户软件提供。

在linux内核中对中断的操作主要包括两部分：1、中断的申请和释放；2、中断处理程序设计
其中的中断的申请和释放，具体的采用函数：
  1. /*申请中断*/
  2. request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,const char *name, void *dev)
  3. /*释放中断*/
  4. void free_irq(unsigned int irq, void *dev_id)
在request_irq中的参数：
1、unsigned int irq表示具体的中断号，一般而言，针对不同的CPU，中断号存在一定的差别。
2、irq_handler_t handler表示一个回调函数，具体的就是中断操作的具体函数，称为中断处理函数。根据
typedef irqreturn_t (*irq_handler_t)(int, void *);
irq_handler_t 是一个函数指针，也就是中断处理函数应该是一个参数分别为int和void*,返回值为irqreturn_t,是枚举型参数。
  1. enum irqreturn {
  2.     IRQ_NONE,
  3.     IRQ_HANDLED,
  4.     IRQ_WAKE_THREAD,
  5. };

  7. typedef enum irqreturn irqreturn_t;
  8. #define IRQ_RETVAL(x)    ((x) != IRQ_NONE)
其中中断处理函数的形式就是一个函数，采用一般的C语言就可以实现。并没有什么特别需要注意的事项，但是需要保证的是中断要尽可能的短小精悍，不要出现长时间等待以及睡眠等形式，不能出现互信息量、信号量等并发机制，只能采用自旋锁实现。
3、unsigned long flags参数表示的中断的触发方式（高低电平触发等）或者处理方式(快速、一般中断)，其中的IRQF_DISABLE表示快速中断模式，IRQF_SHARED表示共享中断模式。
  
 /*可以选择的基本触发方式和处理方式*/
  1. #include <linux/interrupt.h>
 /*中断处理方式*/
  1. #ifndef IRQF_DISABLED
  2. #define IRQF_DISABLED SA_INTERRUPT
  3. #define IRQF_SAMPLE_RANDOM SA_SAMPLE_RANDOM
  4. #define IRQF_SHARED SA_SHIRQ
  5. #define IRQF_PROBE_SHARED SA_PROBEIRQ
  6. #define IRQF_PERCPU SA_PERCPU
  7. #ifdef SA_TRIGGER_MASK
  8. #define IRQF_TRIGGER_NONE 0
  9. #define IRQF_TRIGGER_LOW SA_TRIGGER_LOW
  10. #define IRQF_TRIGGER_HIGH SA_TRIGGER_HIGH
  11. #define IRQF_TRIGGER_FALLING SA_TRIGGER_FALLING
  12. #define IRQF_TRIGGER_RISING SA_TRIGGER_RISING
  13. #define IRQF_TRIGGER_MASK SA_TRIGGER_MASK
  14. #else /*中断触发方式*/
  15. #define IRQF_TRIGGER_NONE 0
  16. #define IRQF_TRIGGER_LOW 0
  17. #define IRQF_TRIGGER_HIGH 0
  18. #define IRQF_TRIGGER_FALLING 0
  19. #define IRQF_TRIGGER_RISING 0
  20. #define IRQF_TRIGGER_MASK 0
  21. #endif
  22. #endif

4、const char *name表示具体的设备名。
5、void *dev，这个参数比较灵活，可以选择不同的值，当中断选择为共享中断模式时，dev必须是唯一的；而当中断选择为其他处理模式时，该参数可以为NULL,也可以用来传递需要处理的变量或者资源。具体后面分析。

释放函数则相对来说简单很多，主要是释放的中断号和相关的处理数据。free_irq()针对共享设备非常有用，因为不能关闭中断disable_irq()，影响其他共享该中断号的设备。

3、功能简介
我这次完成的设计主要是采用platform设备驱动模型实现外部中断的设计。具体的操作主要是包括如下两步：
1、设备的添加(主要包括资源的添加和设备的注册)
2、驱动的设计(难点),首先要注册总线驱动，第二要完成具体驱动（外部中断或者按键）的设计(字符型驱动或者混杂设备驱动)，最后实现对应的操作函数。

难点分析：
1、具体设备的结构体设计，设备包含的数据，这一步是驱动设计的重点。
2、中断函数的设计，需要处理那些数据，保证短小精悍。
3、具体操作的设计，主要包括初始化和具体函数的操作。

字符设备的驱动源码代码分析，关于混杂设备的参看引用文章。
首先是设备添加代码：
  1. #include<linux/module.h>
  2. #include<linux/init.h>
  3. #include<linux/kernel.h>
  4. #include<linux/string.h>
  5. #include<linux/platform_device.h>
  6. /*硬件相关的头文件*/
  7. #include<mach/regs-gpio.h>
  8. #include<mach/hardware.h>
  9. #include<linux/gpio.h>

  11. /*这个是硬件（CPU）密切相关的中断号*/
  12. #include<mach/irqs.h>

  14. /*硬件资源量，这是根据tq2440开发板确定的*/
  15. static struct resource tq2440_button_resource[]=
  16. {
  17.     /*EINT0*/
  18.     [0]=
  19.     {
  20.         .flags = IORESOURCE_IRQ,
  21.         .start = IRQ_EINT0,
  22.         .end = IRQ_EINT0,
  23.         .name = "S3C24XX_EINT0",
  24.     },
  25.     /*EINT1*/
  26.     [1]=
  27.     {
  28.         .flags = IORESOURCE_IRQ,
  29.         .start = IRQ_EINT1,
  30.         .end = IRQ_EINT1,
  31.         .name = "S3C24xx_EINT1",
  32.     },
  33.     /*EINT2*/
  34.     [2]=
  35.     {
  36.         .flags = IORESOURCE_IRQ,
  37.         .start = IRQ_EINT2,
  38.         .end = IRQ_EINT2,
  39.         .name = "S3C24xx_EINT2",
  40.     },
  41.     /*EINT4*/
  42.     [3]=
  43.     {
  44.         .flags = IORESOURCE_IRQ,
  45.         .start = IRQ_EINT4,
  46.         .end = IRQ_EINT4,
  47.         .name = "S3C24xx_EINT4",
  48.     },
  49. };

  51. static struct platform_device tq2440_button_device=
  52. {
  53.     /*设备名*/
  54.     .name = "tq2440_button",
  55.     .id = -1,
  56.     /*资源数*/
  57.     .num_resources = ARRAY_SIZE(tq2440_button_resource),
  58.     /*资源指针*/
  59.     .resource = tq2440_button_resource,
  60. };

  62. static int __init tq2440_button_init(void)
  63. {
  64.     int ret ;
  65.     /*设备注册*/
  66.     ret = platform_device_register(&tq2440_button_device);
  67. }

  69. static void __exit tq2440_button_exit(void)
  70. {
  71.     /*设备的注销*/
  72.     platform_device_unregister(&tq2440_button_device);
  73. }

  75. /*加载与卸载*/
  76. module_init(tq2440_button_init);
  77. module_exit(tq2440_button_exit);

  79. /*LICENSE和作者信息*/
  80. MODULE_LICENSE("GPL");
  81. MODULE_AUTHOR("GP-<gp19861112@yahoo.com.cn>");
然后是驱动实现代码：
  1. #include<linux/types.h>
  2. #include<linux/kernel.h>
  3. #include<linux/init.h>
  4. #include<linux/module.h>
  5. #include<linux/platform_device.h>
  6. #include<mach/irqs.h>
  7. #include<linux/irq.h>
  8. #include<mach/regs-gpio.h>
  9. #include<linux/device.h>
  10. #include<linux/string.h>
  11. #include<linux/cdev.h>
  12. #include<linux/fs.h>
  13. #include<linux/spinlock.h>
  14. #include<linux/wait.h>
  15. #include<linux/interrupt.h>
  16. #include<linux/uaccess.h>
  17. #include<linux/poll.h>


  20. #define NUM_RESOURCE    4

  22. /*主设备号*/
  23. int dev_major = -1;

  25. /*中断结构体定义*/
  26. struct irqs
  27. {
  28.     int pirqs[NUM_RESOURCE];
  29.     char *names[NUM_RESOURCE];
  30. }irqs;
  31. /*完成具体设备的结构体设计*/
  32. struct tq2440_button
  33. {
  34.     /*添加具体的字符设备结构*/
  35.     struct cdev cdev;
  36.     /*用于自动创建设备*/
  37.     struct class *myclass;
  38.     /*引用次数统计表*/
  39.     unsigned int count;
  40.     /*添加并行机制*/
  41.     spinlock_t lock;
  42.     /*添加等待队列*/
  43.     wait_queue_head_t read_wait_queue;
  44.     /*数据*/
  45.     int bepressed;
  46.     /*案件值*/
  47.     int key_values;
  48. };

  50. static struct tq2440_button tq2440_button;

  52. static irqreturn_t tq2440_button_interrupt_handler(int irq,void*dev_id)
  53. {
  54.     /*得到传递过来的参数*/
  55.     struct tq2440_button * dev = dev_id;
  56.     int i;
  57.     /*根据得到的irq值确定具体的按键值*/
  58.     for (i= 0; i < NUM_RESOURCE; ++ i)
  59.     {
  60.         /*判断条件*/
  61.         if(irq== irqs.pirqs[i])
  62.         {
  63.             /*对关键数据添加并行机制*/
  64.             spin_lock(&(dev->lock));
  65.             /*确定被按下的值*/
  66.             dev->key_values= i ;
  67.             /*表示有数据可以读*/
  68.             dev->bepressed= 1;
  69.             spin_unlock(&(dev->lock));
  70.             /*唤醒等待的队列*/
  71.             wake_up_interruptible(&(dev->read_wait_queue));    
  72.         }
  73.     }
  74.     /*返回值*/
  75.     return IRQ_RETVAL(IRQ_HANDLED);
  76. }

  78. static int tq2440_button_open(struct inode*inode,struct file*filp)
  79. {
  80.     int i = 0,ret= 0;
  81.     
  82.     /*中断申请*/
  83.     /*这句话主要是实现间接控制，但是还是可以直接控制*/
  84.     filp->private_data= &tq2440_button;
  85.     
  86.     /*修改被打开的次数值*/
  87.     spin_lock(&(tq2440_button.lock));    
  88.     tq2440_button.count ++ ;
  89.     spin_unlock(&(tq2440_button.lock));

  91.     /*如果是第一次打开则需要申请中断，这是比较推荐的方法，也可以在probe函数中申请中断*/
  92.     if(1==tq2440_button.count)
  93.     {
  94.         for(i= 0;i < NUM_RESOURCE; ++ i)
  95.         {
  96.             /*request_irq操作*/
  97.             ret = request_irq(irqs.pirqs[i],
  98.                 tq2440_button_interrupt_handler,
  99.                 IRQ_TYPE_EDGE_BOTH,irqs.names[i],(void*)&tq2440_button);
  100.         
  101.             if(ret)
  102.             {
  103.                 break;
  104.             }
  105.         }
  106.         if(ret)/*错误处理机制*/
  107.         {
  108.             i --;
  109.             for(; i>=0;--i)
  110.             {
  111.                 /*禁止中断*/
  112.                 
  113.                 disable_irq(irqs.pirqs[i]);
  114.             
  115.                 free_irq(irqs.pirqs[i],(void*)&tq2440_button);
  116.             }
  117.             return -EBUSY;
  118.         }
  119.     }    
  120.     return 0;
  121. }

  123. /*closed函数*/
  124. static int tq2440_button_close(struct inode*inode,struct file*filp)
  125. {
  126.     /*确保是最后一次使用设备*/
  127.     int i = 0;
  128.     if(tq2440_button.count== 1)
  129.     {
  130.         for(i= 0; i < NUM_RESOURCE; ++ i)
  131.         {
  132.             free_irq(irqs.pirqs[i],(void*)&tq2440_button);
  133.         }
  134.     }
  135.     /*更新设备文件引用次数*/
  136.     spin_lock(&(tq2440_button.lock));
  137.     tq2440_button.count = 0;
  138.     spin_unlock(&(tq2440_button.lock));

  140.     return 0;
  141. }

  143. static unsigned long tq2440_button_read(struct file*filp,char __user*buff,
  144.                     size_t count,loff_t offp)
  145. {
  146.     /*设备操作*/
  147.     struct tq2440_button *dev = filp->private_data;
  148.     
  149.     unsigned long err;
  150.         if(!dev->bepressed)/*确保没有采用非堵塞方式读标志*/
  151.         {
  152.         if(filp->f_flags& O_NONBLOCK)
  153.             return -EAGAIN;
  154.         else
  155.             /*添加等待队列，条件是bepressed*/
  156.             wait_event_interruptible(dev->read_wait_queue,dev->bepressed);
  157.     }    

  159.     /*复制数据到用户空间*/
  160.     err = copy_to_user(buff,&(dev->key_values),min(sizeof(dev->key_values),count));
  161.     
  162.     /*修改标志表示没有数据可读了*/
  163.     spin_lock(&(dev->lock));
  164.     dev->bepressed= 0;
  165.     spin_unlock(&(dev->lock));
  166.     
  167.     /*返回数据量*/
  168.     
  169.     return err ? -EFAULT:min(sizeof(dev->key_values),count);
  170. }


  173. static unsigned int tq2440_button_poll(struct file*filp,
  174.                 struct poll_table_struct *wait)
  175. {
  176.     struct tq2440_button *dev = filp->private_data;

  178.     unsigned int mask = 0;
  179.     
  180.     /*将结构体中的等待队列添加到wait_table*/    
  181.     poll_wait(filp,&(dev->read_wait_queue),wait);

  183.     /*
  184.     返回掩码
  185.     POLLIN|POLLRDNORM表示有数据可读
  186.     */
  187.     if(dev->bepressed)
  188.     {
  189.         mask |= POLLIN| POLLRDNORM;
  190.     }

  192.     return mask;
  193. }

  195. /*设备的具体操作函数*/
  196. static const struct file_operations tq2440_fops=
  197. {
  198.     .owner = THIS_MODULE,
  199.     .open = tq2440_button_open,
  200.     .release = tq2440_button_close,
  201.     .read = tq2440_button_read,
  202.     .poll = tq2440_button_poll,
  203. };


  206. /*remove函数实现字符设备的注销操作*/

  208. static int tq2440_button_probe(struct platform_device*dev)
  209. {
  210.     printk("The driver found a device can be handler on platform bus\n");
  211.     
  212.     /*用来存储定义好的资源，即中断号*/
  213.     
  214.     struct resource * irq_resource;
  215.     struct platform_device *pdev = dev;
  216.     int i = 0,ret= 0;

  218.     /*接下来完成具体字符驱动结构体的初始化*/
  219.     /*1、设备号申请*/
  220.     
  221.     dev_t devno;

  223.     if(dev_major> 0)/*静态申请设备号*/
  224.     {
  225.         devno = MKDEV(dev_major,0);
  226.         ret = register_chrdev_region(devno,1,"tq2440_button");
  227.     }
  228.     else/*动态申请设备号*/
  229.     {
  230.         ret = alloc_chrdev_region(&devno,0,1,"tq2440_button");
  231.         dev_major = MAJOR(devno);
  232.     }
  233.     if(ret< 0)
  234.     {
  235.         return ret;
  236.     }

  238.     /*完成设备类的创建，主要实现设备文件的自动创建*/
  239.     tq2440_button.myclass = class_create(THIS_MODULE,"tq2440_button_class");
  240.  
  241.     /*2、完成字符设备的加载*/
  242.     cdev_init(&(tq2440_button.cdev),&tq2440_fops);
  243.     tq2440_button.cdev.owner= THIS_MODULE;
  244.     ret = cdev_add(&(tq2440_button.cdev),devno,1);    
  245.     if(ret)
  246.     {
  247.         printk("Add device error\n");
  248.         return ret;
  249.     }
  250.     
  251.         /*初始化自旋锁*/
  252.     spin_lock_init(&(tq2440_button.lock));
  253.     
  254.     /*修改引用次数值*/
  255.     
  256.     spin_lock(&(tq2440_button.lock));
  257.     /*被打开次数统计*/
  258.     tq2440_button.count = 0;    
  259.     /*键值*/
  260.     tq2440_button.key_values = -1;
  261.     spin_unlock(&(tq2440_button.lock));
  262.     
  263.     /*初始化等待队列*/
  264.     
  265.     init_waitqueue_head(&(tq2440_button.read_wait_queue));
  266.     
  267.     
  268.     /*设备的创建，实现设备文件自动创建*/
  269.     
  270.     device_create(tq2440_button.myclass,NULL,devno,NULL,"tq2440_button");

  272.     /*3.获得资源*/
  273.     for(; i< NUM_RESOURCE;++ i)
  274.     {
  275.         /*获得设备的资源*/
  276.         irq_resource = platform_get_resource(pdev,IORESOURCE_IRQ,i);
  277.         
  278.         if(NULL== irq_resource)
  279.         {
  280.             return -ENOENT;
  281.         }
  282.         irqs.pirqs[i]= irq_resource->start;

  284.         /*实现名字的复制操作*/
  285.         //strcpy(tq2440_irqs.name[i],irq_resource->name);

  287.         /*这一句是将指针的地址指向一个具体的地址*/
  288.         irqs.names[i]= irq_resource->name;
  289.     }
  290.     /*将设备的指针指向中断号*/
  291.     
  292.     return 0;
  293. }

  295. /*probe函数实现字符设备的初始化操作*/
  296. static int tq2440_button_remove(struct platform_device*dev)
  297. {
  298.     printk("The driver found a device be removed from the platform bus\n");
  299.     
  300.     /*注销设备*/
  301.     device_destroy(tq2440_button.myclass,MKDEV(dev_major,0));
  302.     /*字符设备注销*/
  303.     cdev_del(&(tq2440_button.cdev));
  304.     /*注销创建的设备类*/
  305.     class_destroy(&(tq2440_button.myclass));
  306.     /*释放设备号*/
  307.     unregister_chrdev_region(MKDEV(dev_major,0),1);
  308.     return 0;
  309. }

  311. /*完成平台总线结构体的设计*/
  312. static const struct platform_driver tq2440_button_driver=
  313. {
  314.     /*完成具体设备的初始化操作*/
  315.     .probe = tq2440_button_probe,
  316.     /*完成具体设备的退出操作*/
  317.     .remove = tq2440_button_remove,
  318.     .driver =
  319.     {
  320.         .owner = THIS_MODULE,
  321.         .name = "tq2440_button",
  322.     },
  323. };

  325. /*总线设备初始化过程*/
  326. static int __init platform_driver_init(void)
  327. {
  328.     int ret;
  329.     
  330.     /*总线驱动注册*/
  331.     ret = platform_driver_register(&tq2440_button_driver);
  332.     
  333.     /*错误处理*/
  334.     if(ret)
  335.     {
  336.         platform_driver_unregister(&tq2440_button_driver);
  337.         return ret;
  338.     }

  340.     return 0;
  341. }

  343. static void __exit platform_driver_exit(void)
  344. {
  345.     /*总线驱动释放*/
  346.     platform_driver_unregister(&tq2440_button_driver);
  347. }

  349. /*加载和卸载*/
  350. module_init(platform_driver_init);
  351. module_exit(platform_driver_exit);

  353. /*LICENSE和作者信息*/
  354. MODULE_LICENSE("GPL");
  355. MODULE_AUTHOR("GP-<gp19861112@yahoo.com.cn>");
应用程序
  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. #include<unistd.h>
  4. #include<sys/types.h>
  5. #include<sys/ioctl.h>
  6. #include<sys/stat.h>
  7. #include<sys/select.h>
  8. #include<sys/time.h>
  9. #include<errno.h>

  11. int main()
  12. {
  13.     int buttons_fd;
  14.     int key_value = 0;
  15.     
  16.     /*open函数测试*/
  17.     buttons_fd = open("/dev/tq2440_button",0);

  19.     if(buttons_fd< 0)
  20.     {
  21.         perror("open device buttons\n");
  22.         exit(1);
  23.     }

  25.     while(1)
  26.     {
  27.         fd_set rds;
  28.         int ret;

  30.         FD_ZERO(&rds);
  31.         FD_SET(buttons_fd,&rds);
  32.         /*poll函数测试*/
  33.         ret = select(buttons_fd + 1,&rds,NULL,NULL,NULL);
  34.         if(ret< 0)
  35.         {
  36.             perror("select");
  37.             exit(1);
  38.         }
  39.         if(ret== 0)
  40.         {
  41.             printf("Timeout.\n");
  42.         }
  43.         else if(FD_ISSET(buttons_fd,&rds))
  44.         {
  45.     /*read函数测试*/
  46.             int ret = read(buttons_fd,&key_value,sizeof key_value);
  47.             if(ret!= sizeof key_value)
  48.             {
  49.                 if(errno!= EAGAIN)
  50.                     perror("read buttons\n");
  51.                 continue;
  52.             }
  53.             else
  54.             {
  55.                 printf("buttons_value:%d\n",key_value+1);
  56.             }
  57.         }
  58.     }
  59.     /*release函数测试*/
  60.     close(buttons_fd); 
  61.     return 0;
  62. }
采用plotform总线实现中断的操作，基本中断的操作。
中断操作设备驱动集合：



之前接触到的字符设备驱动是非常单纯的Linux字符设备驱动，他不具备工程中Linux驱动中的设备与驱动分离思想和设备驱动的分层思想，不具备“总线-设备-驱动”模型的概念。接下来通过分析platform设备驱动模型的搭建过程来看看Linux的设备驱动模型究竟是怎样的？

platform驱动模型搭建：

(1)platform核心层：为设备层和驱动层提供注册接口、为设备层和驱动层的匹配提供标准

①搭建总线框架：


struct bus_type {
    constchar      *name;
    struct bus_attribute    *bus_attrs;
    struct device_attribute *dev_attrs;
    struct driver_attribute *drv_attrs;
    int(*match)(struct device *dev, struct device_driver *drv);//#####
    int(*uevent)(struct device *dev, struct kobj_uevent_env *env);
    int(*probe)(struct device *dev);
    int(*remove)(struct device *dev);
    void(*shutdown)(struct device *dev);
    int(*suspend)(struct device *dev, pm_message_t state);
    int(*suspend_late)(struct device *dev, pm_message_t state);
    int(*resume_early)(struct device *dev);
    int(*resume)(struct device *dev);
    struct dev_pm_ops *pm;
    struct bus_type_private *p;//看到这个private就有点C++类中的限定域关键字了，这个类的私有成员
};

总线类实例化：platform总线

?
1
2
3
4
5
6
7
struct bus_type platform_bus_type = {
    .name       ="platform",
    .dev_attrs  = platform_dev_attrs,
    .match      = platform_match,//关键成员
    .uevent     = platform_uevent,
    .pm     = PLATFORM_PM_OPS_PTR,
};
注册platform总线过程：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
platform_bus_init()
{
    .....
    error =  bus_register(&platform_bus_type);//注册platform总线的核心工作
    .....
}
bus_register(struct bus_type *bus)
{
    //创建bus的属性文件  
    retval = bus_create_file(bus, &bus_attr_uevent);
    ......
    //在/sys/bus/bus->name目录下创建devices目录
    priv->devices_kset = kset_create_and_add("devices", NULL,&priv->subsys.kobj);
    ....
    //在/sys/bus/bus->name目录下创建drivers目录
    priv->drivers_kset = kset_create_and_add("drivers", NULL,&priv->subsys.kobj);
    //初始化总线设备\总线驱动链表
    klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
    klist_init(&priv->klist_drivers, NULL, NULL);
}
核心层的功绩：初始化了klist_devices和klist_drivers两个链表，没有谈到如何判断设备和驱动匹配？“.match=platform_match”有初始化，但是什么时候被调用？

当一个驱动挂接到该总线的时候，该总线的match方法被调用。同样的，当一个设备挂接到该总线时，platform_match也会被调用。也就是说核心层只提供匹配的方法！不会帮他们去匹配，这人生大事要他们自己去完成！
这就好办了，都是挂接到总线上的时候，往后分析时肯定会遇到，先暂时放着，先看看他的实现：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
 
 
    /* match against the id table first */
    if(pdrv->id_table) //看看drv的id_table中是否有现成匹配的设备记录
        returnplatform_match_id(pdrv->id_table, pdev) != NULL;
 
 
    /* fall-back to driver name match */
    return(strcmp(pdev->name, drv->name) == 0);/* match成功，strcmp返回0，语句逻辑返回1 */

}


②为设备层提供注册API、提供自动匹配接口函数
设备基类：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct device {
    struct device           *parent;
    struct device_private   *p;
    struct kobject          kobj;
    constchar              *init_name;    /* initial name of the device 这个就是传统的bus_id，具体到每一个设备之后当做默认值 */
    struct device_type      *type;
    ......
    struct bus_type         *bus;          /* type of bus device is on */
    struct device_driver    *driver;       /* which driver has allocated this device */
    void                   *driver_data;   /* data private to the driver */
    void                   *platform_data; /* Platform specific data, device core doesn't touch it */
    ......
    void                   (*release)(struct device *dev);
};



派生类：platform设备
?
1
2
3
4
5
6
7
8
struct platform_device {
    constchar      *name;
    int            id;  // 硬件设备的象征/代表
    struct device   dev;// 由此继承基类
    u32             num_resources;
    struct resource * resource;//这个驱动使用的资源
    struct platform_device_id   *id_entry;
};
注册platform设备函数调用关系：
platform_device_register(struct platform_device *pdev)
platform_device_add(struct platform_device *pdev)
pdev->dev.bus = &platform_bus_type;
device_add(&pdev->dev);
bus_attach_device(struct device *dev)
device_attach(dev);
bus_for_each_drv(dev->bus, NULL, dev, __device_attach);
bus_for_each_drv()函数的实现：
?
1
2
3
4
5
6
7
8
bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
             void*data, int (*fn)(struct device_driver *, void *))
{
    ......
    while((drv = next_driver(&i)) && !error)
        error = fn(drv, data);
    ......
}
分析：
首先关心他的最后一个形参(*fn)，他在注册platform_device时最终被重定向到__device_attach()函数，回调函数的使用在内核源码里边屡见不鲜！因为它可以减少很多重复的代码。
现在分析的焦点转移到__device_attach函数：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
__device_attach(struct device_driver *drv,void *data)
{
    struct device *dev = data;
    if(!driver_match_device(drv, dev))
        return0;
    returndriver_probe_device(drv, dev); //match成功就执行这个函数，他最终调用really_probe()函数
}
driver_match_device(struct device_driver *drv,struct device *dev)
{
    returndrv->bus->match ? drv->bus->match(dev, drv) : 1;//看到这一句，上面留下的疑问就解决了：原来核心层留下的匹配判断标准match接口就是在这里被调用的！！！好爽！^_^
}
really_probe(struct device *dev, struct device_driver *drv)
{
......
    if(dev->bus->probe) //如果bus_type结构里边的probe成员有定义就优先调用他的
    {
        ret = dev->bus->probe(dev);
        if(ret)
            gotoprobe_failed;
    }
    elseif (drv->probe) //没有就调用匹配到的drv结构里边的probe成员函数
    {
        ret = drv->probe(dev);
        if(ret)
            gotoprobe_failed;
    }
    driver_bound(dev);//bound是绑定的意思，即将match成功的设备加入驱动的设备链表
    ......
}
③为驱动层提供API、提供自动匹配接口函数
驱动基类：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct device_driver {
    constchar      *name;
    struct bus_type     *bus;
    struct module       *owner;
    constchar      *mod_name;  /* used for built-in modules */
    int (*probe) (struct device *dev);
    int (*remove) (struct device *dev);
    void(*shutdown) (struct device *dev);
    int (*suspend) (struct device *dev, pm_message_t state);
    int (*resume) (struct device *dev);
    struct attribute_group **groups;
    struct dev_pm_ops *pm;
    struct driver_private *p;
};
驱动派生类：
?
1
2
3
4
5
6
7
8
9
10
11
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(*suspend_late)(struct platform_device *, pm_message_t state);
    int(*resume_early)(struct platform_device *);
    int(*resume)(struct platform_device *);
    struct device_driver driver; //继承基类
    struct platform_device_id *id_table;
};
注册platform_driver驱动结构体函数执行流程：
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
platform_driver_register(struct platform_driver *drv)
{
    /*下面进行一系列的判断，如果派生的platform_driver中没有对特有成员进行初始化，设置成默认的 */
    drv->driver.bus = &platform_bus_type;  //指向这个驱动所属的bus类型：platform
    if(drv->probe)  //有重定向
        drv->driver.probe = platform_drv_probe;
    if(drv->remove) //有重定向
        drv->driver.remove = platform_drv_remove;
    ......
    returndriver_register(&drv->driver); 【进入分析】
    //注册的关键材料是platform_driver->driver->bus：关键是为了注册总线的类型platform_bus_type
}
driver_register(struct device_driver *drv)
{
    ......
    struct device_driver *other;
    ......
    other = driver_find(drv->name, drv->bus);//在该总线上查找是否有该设备驱动名对应的驱动
    if(other) { //如果设备已经存在对应的驱动就：出错，驱动已经存在
        put_driver(other);
        printk(KERN_ERR"Error: Driver '%s' is already registered, "
            "aborting...\n", drv->name);
        return-EEXIST;
    }
    bus_add_driver(drv); /* 在总线上添加这个驱动，成功的话最终结果：在bus/platform/drivers目录下面生成“name”对应的目录 ,并且会生成 bind  module  uevent  unbind 四个文件*/
    ......
}
继续深入分析：
bus_add_driver(struct device_driver *drv)
driver_attach(drv); /* 试图将驱动和设备绑定起来 */
bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);//到这里可以非常明显的发现和设备层做的事情非常相似，几乎是对称出现
/* 对总线上的每一个设备都会拿来执行__driver_attach，他在这里被用作回调函数，看看是否匹配，这个函数和__device_attach函数做的事情基本一样这里就不再累述了*/

(2)设备层：主要工作就是把核心层提供的API用起来
1.设置好platform_device结构体成员：主要是name、resource、num_resources、id、dev->release、

2.通过platform_device_register()把这个结构体链入核心层的klist_devices链表

(3)驱动层：同样是把核心层提供的接口函数用起来
1.设置好platform_driver结构体成员：probe、remove、driver->name
2.通过platform_driver_register()函数把这个结构体链入核心层的klist_drivers链表
3.实现probe成员函数
4.通常最后才去完成probe函数用到的材料，一般是file_operation结构体成员，这样应用层就可以通过这个接口来操作设备
0 0
js给select标签负值 js给select标签负值
原创粉丝点击
热门IT博客
卡西欧自拍神器软件卡西欧自拍神器软件
淘宝商城女装毛衣外套淘宝商城女装毛衣外套
天文馆软件
数据录入员有升职吗
域名在哪里备案
赛尔网络集大
机电一体化网络教育
男人很脆弱知乎
网络剧人造暖男
ant linux下载
t.tt域名多少钱
centos7 yum安装wine
443端口和80端口
海康威视网络球机接线
淘宝虚拟充值平台网址
河南网络诈骗案例
我要开淘宝店怎么开
流畅的python 知乎
深圳市华梦汽车网络
数据分析师有关证书
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 血恋高清粤语 血恋2高清粤语 血恋1995 血恋在线 血恋粤语 血恋3完整国语 血恋在线播放 血恋三部 血恋3高清 血恋1国语版在线播放 血恋高清 血恋3国版手机在线播放 血恋2中文字 一级二级香港血恋2 血雨母孑情 血雨母子情 神级狂医 血方情 情与血txt下载 血情 血千夜冷千情大结局 越南浴血战 血战铜锣湾 血战台儿庄 血战上海滩 血战大西南 血战丛林 血战1944 血战太平洋 血战长津湖 血战长空 血战铜锣湾3 血战唐人街 血战 烈血战场 血战王朝 秦先生血战高校双胞胎 黑夜传说5血战 英雄血战下载 四川麻将血战 血战上海滩手机版 血战钢锯岭真实事件

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