搜索
bottom↓
回复: 0

《领航者ZYNQ之嵌入式Linux开发指南_V2.0》第三十三章 Linux中断

[复制链接]

出0入234汤圆

发表于 2022-1-22 15:22:25 | 显示全部楼层 |阅读模式
1)实验平台:正点原子领航者V2 ZYNQ开发板
2)  章节摘自【正点原子】《领航者ZYNQ之嵌入式Linux开发指南_V2.0》
3)购买链接:https://detail.tmall.com/item.htm?id=609032204975
4)全套实验源码+手册+视频下载地址:http://www.openedv.com/thread-329957-1-1.html
5)正点原子官方B站:https://space.bilibili.com/394620890
6)正点原子FPGA技术交流QQ群:90562473
1.png


2.jpg


3.png

第三十三章 Linux中断实验

       不管是裸机实验还是Linux下的驱动实验,中断都是频繁使用的功能,关于ZYNQ的中断原理已经在《领航者ZYNQ嵌入式开发指南》第四章中做了详细的讲解,在裸机中使用中断我们需要做一大堆的工作,比如配置寄存器,使能IRQ等等(SDK提供的库函数中已经封装好了)。Linux内核提供了完善的中断框架,我们只需要申请中断,然后注册中断处理函数即可,使用非常方便,不需要一系列复杂的寄存器配置。本章我们就来学习一下如何在Linux下使用中断。

       1.1Linux中断简介
1.1.1Linux中断API函数
       先来回顾一下裸机实验里面按键中断的处理方法:
       ①、使能中断异常。
       ②、注册中断服务函数。
       ③、设置中断的触发方式。
       ④、最后使能按键中断。
       当按键中断发生以后进入到前面绑定的IRQ中断服务函数当中,然后执行相应的中断处理代码。在Linux内核中也提供了大量的中断相关的API函数,我们来看一下这些跟中断有关的API函数:
       1、中断号
       每个中断都有一个中断号,通过中断号即可区分不同的中断,有的资料也把中断号叫做中断线。在Linux内核中使用一个int变量表示中断号。
       2、request_irq函数
       在Linux内核中要想使用某个中断是需要申请的,request_irq函数用于申请中断,request_irq函数可能会导致睡眠,因此不能在中断上下文或者其他禁止睡眠的代码段中使用request_irq函数。request_irq函数会激活(使能)中断,所以不需要我们手动去使能中断,request_irq函数原型如下:
  1. int request_irq(unsigned int                 irq,
  2.                         irq_handler_t                 handler,
  3.                         unsigned long                flags,
  4.                         const char                 *name,
  5.                         void                         *dev)
复制代码
       函数参数和返回值含义如下:
       irq:要申请中断的中断号。
       handler:中断处理函数,当中断发生以后就会执行此中断处理函数。
       flags:中断标志,可以在内核源码目录include/linux/interrupt.h文件中查看所有的中断标志,这里我们介绍几个常用的中断标志,如表 33.1.1所示:
1.png

表 33.1.1 常用的中断标志

       比如开发板上的PS_KEY0使用GPIO0_IO12(也就是MIO 12),按下PS_KEY0以后为低电平,因此可以设置为下降沿触发,也就是将flags设置为IRQF_TRIGGER_FALLING。表 33.1.1中的这些标志可以通过“|”来实现多种组合。
       name:中断名字,设置以后可以在/proc/interrupts文件中看到对应的中断名字。
       dev:如果将flags设置为IRQF_SHARED的话,dev用来区分不同的中断,一般情况下将dev设置为设备结构体,dev会传递给中断处理函数irq_handler_t的第二个参数。
       返回值:0 中断申请成功,其他负值 中断申请失败,如果返回-EBUSY的话表示中断已经被申请了。
       3、free_irq函数
       使用中断的时候需要通过request_irq函数申请,使用完成以后就要通过free_irq函数释放掉相应的中断。如果中断不是共享的,那么free_irq会删除中断处理函数并且禁止中断。free_irq函数原型如下所示:
  1. void free_irq(unsigned int irq, void *dev)
复制代码
       函数参数和返回值含义如下:
       irq:要释放的中断。
       dev:如果中断设置为共享(IRQF_SHARED)的话,此参数用来区分具体的中断。共享中断只有在释放最后中断处理函数的时候才会被禁止掉。
       返回值:无。
       4、中断处理函数
       使用request_irq函数申请中断的时候需要设置中断处理函数,中断处理函数格式如下所示:
  1. irqreturn_t (*irq_handler_t) (int, void *)
复制代码
        第一个参数是要中断处理函数要相应的中断号。第二个参数是一个指向void的指针,也就是个通用指针,需要与request_irq函数的dev参数保持一致。用于区分共享中断的不同设备,dev也可以指向设备数据结构。中断处理函数的返回值为irqreturn_t类型,irqreturn_t类型定义如下所示:
  1. 示例代码 33.1.1 irqreturn_t结构体
  2. 10 enum irqreturn {
  3. 11     IRQ_NONE                        = (0 << 0),
  4. 12     IRQ_HANDLED                = (1 << 0),
  5. 13     IRQ_WAKE_THREAD        = (1 << 1),
  6. 14 };
  7. 15
  8. 16 typedef enum irqreturn irqreturn_t;
复制代码
       可以看出irqreturn_t是个枚举类型,一共有三种返回值。一般中断服务函数返回值使用如下形式:
  1. return IRQ_RETVAL(IRQ_HANDLED)
复制代码
       5、中断使能与禁止函数
       常用的中断使用和禁止函数如下所示:
  1. void enable_irq(unsigned int irq)
  2. void disable_irq(unsigned int irq)
复制代码
       enable_irq和disable_irq用于使能和禁止指定的中断,irq就是要禁止的中断号。disable_irq函数要等到当前正在执行的中断处理函数执行完才返回,因此使用者需要保证不会产生新的中断,并且确保所有已经开始执行的中断处理程序已经全部退出。在这种情况下,可以使用另外一个中断禁止函数:
  1. void disable_irq_nosync(unsigned int irq)
复制代码
       disable_irq_nosync函数调用以后立即返回,不会等待当前中断处理程序执行完毕。上面三个函数都是使能或者禁止某一个中断,有时候我们需要关闭当前处理器的整个中断系统,也就是在学习STM32的时候常说的关闭全局中断,这个时候可以使用如下两个函数:
  1. local_irq_enable()
  2. local_irq_disable()
复制代码
       local_irq_enable用于使能当前处理器中断系统,local_irq_disable用于禁止当前处理器中断系统。假如A任务调用local_irq_disable关闭全局中断10S,当关闭了2S的时候B任务开始运行,B任务也调用local_irq_disable关闭全局中断3S,3秒以后B任务调用local_irq_enable函数将全局中断打开了。此时才过去2+3=5秒的时间,然后全局中断就被打开了,此时A任务要关闭10S全局中断的愿望就破灭了,然后A任务就“生气了”,结果很严重,可能系统都要被A任务整崩溃。为了解决这个问题,B任务不能直接简单粗暴的通过local_irq_enable函数来打开全局中断,而是将中断状态恢复到以前的状态,要考虑到别的任务的感受,此时就要用到下面两个函数:
  1. local_irq_save(flags)
  2. local_irq_restore(flags)
复制代码
       这两个函数是一对,local_irq_save函数用于禁止中断,并且将中断状态保存在flags中。local_irq_restore用于恢复中断,将中断到flags状态。
1.1.2上半部与下半部
       在有些资料中也将上半部和下半部称为顶半部和底半部,都是一个意思。我们在使用request_irq申请中断的时候注册的中断服务函数属于中断处理的上半部,只要中断触发,那么中断处理函数就会执行。我们都知道中断处理函数一定要快点执行完毕,越短越好,但是现实往往是残酷的,有些中断处理过程就是比较费时间,我们必须要对其进行处理,缩小中断处理函数的执行时间。比如电容触摸屏通过中断通知SOC有触摸事件发生,SOC响应中断,然后通过IIC接口读取触摸坐标值并将其上报给系统。但是我们都知道IIC的速度最高也只有400Kbit/S,所以在中断中通过IIC读取数据就会浪费时间。我们可以将通过IIC读取触摸数据的操作暂后执行,中断处理函数仅仅相应中断,然后清除中断标志位即可。这个时候中断处理过程就分为了两部分:
       上半部:上半部就是中断处理函数,那些处理过程比较快,不会占用很长时间的处理就可以放在上半部完成。
       下半部:如果中断处理过程比较耗时,那么就将这些比较耗时的代码提出来,交给下半部去执行,这样中断处理函数就会快进快出。
       因此,Linux内核将中断分为上半部和下半部的主要目的就是实现中断处理函数的快进快出,那些对时间敏感、执行速度快的操作可以放到中断处理函数中,也就是上半部。剩下的所有工作都可以放到下半部去执行,比如在上半部将数据拷贝到内存中,关于数据的具体处理就可以放到下半部去执行。至于哪些代码属于上半部,哪些代码属于下半部并没有明确的规定,一切根据实际使用情况去判断,这个就很考验驱动编写人员的功底了。这里有一些可以借鉴的参考点:
       ①、如果要处理的内容不希望被其他中断打断,那么可以放到上半部。
       ②、如果要处理的任务对时间敏感,可以放到上半部。
       ③、如果要处理的任务与硬件有关,可以放到上半部
       ④、除了上述三点以外的其他任务,优先考虑放到下半部。
       上半部处理很简单,直接编写中断处理函数就行了,关键是下半部该怎么做呢?Linux内核提供了多种下半部机制,接下来我们来学习一下这些下半部机制。
       1、软中断
       一开始Linux内核提供了“bottom half”机制来实现下半部,简称“BH”。后面引入了软中断和tasklet来替代“BH”机制,完全可以使用软中断和tasklet来替代BH,从2.5版本的Linux内核开始BH已经被抛弃了。Linux内核使用结构体softirq_action表示软中断,softirq_action结构体定义在文件include/linux/interrupt.h中,内容如下:
  1. 示例代码 33.1.2 softirq_action结构体
  2. 433 struct softirq_action
  3. 434 {
  4. 435     void (*action)(struct softirq_action *);
  5. 436 };
复制代码
       在kernel/softirq.c文件中一共定义了10个软中断,如下所示:
  1. 示例代码 33.1.3 softirq_vec数组-1
  2. 056 static struct softirq_action softirq_vec[NR_SOFTIRQS];
复制代码
       NR_SOFTIRQS是枚举类型,定义在文件include/linux/interrupt.h中,定义如下:
  1. 示例代码 33.1.4 softirq_vec数组-2
  2. 458 enum
  3. 459 {
  4. 460     HI_SOFTIRQ=0,
  5. 461     TIMER_SOFTIRQ,
  6. 462     NET_TX_SOFTIRQ,
  7. 463     NET_RX_SOFTIRQ,
  8. 464     BLOCK_SOFTIRQ,
  9. 465     IRQ_POLL_SOFTIRQ,
  10. 466     TASKLET_SOFTIRQ,
  11. 467     SCHED_SOFTIRQ,
  12. 468     HRTIMER_SOFTIRQ, /* Unused, but kept as tools rely on the
  13. 469                         numbering. Sigh! */
  14. 470     RCU_SOFTIRQ, /* Preferable RCU should always be the last softirq */
  15. 471
  16. 472     NR_SOFTIRQS
  17. 473 };
复制代码
       可以看出,一共有10个软中断,因此NR_SOFTIRQS为10,因此数组softirq_vec有10个元素。softirq_action结构体中的action成员变量就是软中断的服务函数,数组softirq_vec是个全局数组,因此所有的CPU(对于SMP系统而言)都可以访问到,每个CPU都有自己的触发和控制机制,并且只执行自己所触发的软中断。但是各个CPU所执行的软中断服务函数确是相同的,都是数组softirq_vec中定义的action函数。要使用软中断,必须先使用open_softirq函数注册对应的软中断处理函数,open_softirq函数原型如下:
  1. void open_softirq(int nr, void (*action)(struct softirq_action *))
复制代码
       函数参数和返回值含义如下:
       nr:要开启的软中断,在示例代码 33.1.4中选择一个。
       action:软中断对应的处理函数。
       返回值:没有返回值。
       注册好软中断以后需要通过raise_softirq函数触发,raise_softirq函数原型如下:
  1. void raise_softirq(unsigned int nr)
复制代码
       函数参数和返回值含义如下:
       nr:要触发的软中断,在示例代码 33.1.4中选择一个。
       返回值:没有返回值。
       软中断必须在编译的时候静态注册!Linux内核使用softirq_init函数初始化软中断,softirq_init函数定义在kernel/softirq.c文件里面,函数内容如下:
  1. 示例代码 33.1.5 softirq_init函数内容
  2. 634 void __init softirq_init(void)
  3. 635 {
  4. 636     int cpu;
  5. 637
  6. 638     for_each_possible_cpu(cpu) {
  7. 639         per_cpu(tasklet_vec, cpu).tail =
  8. 640             &per_cpu(tasklet_vec, cpu).head;
  9. 641         per_cpu(tasklet_hi_vec, cpu).tail =
  10. 642             &per_cpu(tasklet_hi_vec, cpu).head;
  11. 643     }
  12. 644
  13. 645     open_softirq(TASKLET_SOFTIRQ, tasklet_action);
  14. 646     open_softirq(HI_SOFTIRQ, tasklet_hi_action);
  15. 647 }
复制代码
       从示例代码 33.1.5可以看出,softirq_init函数默认会打开TASKLET_SOFTIRQ和HI_SOFTIRQ。
       2、tasklet
       tasklet是利用软中断来实现的另外一种下半部机制,在软中断和tasklet之间,建议大家使用tasklet。Linux内核使用结构体
  1. 示例代码 33.1.6 tasklet_struct结构体
  2. 484 struct tasklet_struct
  3. 485 {
  4. 486     struct tasklet_struct *next;                /* 下一个tasklet */
  5. 487     unsigned long state;                        /* tasklet状态 */
  6. 488     atomic_t count;                                /* 计数器,记录对tasklet的引用数 */
  7. 489     void (*func)(unsigned long);                /* tasklet执行的函数 */
  8. 490     unsigned long data;                                /* 函数func的参数 */
  9. 491 };
复制代码
       第489行的func函数就是tasklet要执行的处理函数,用户定义函数内容,相当于中断处理函数。如果要使用tasklet,必须先定义一个tasklet,然后使用tasklet_init函数初始化tasklet,taskled_init函数原型如下:
void tasklet_init(struct tasklet_struct *t, void (*func)(unsigned long), unsigned long data);
       函数参数和返回值含义如下:
       t:要初始化的tasklet
       func:tasklet的处理函数。
       data:要传递给func函数的参数
       返回值:没有返回值。
       也可以使用宏DECLARE_TASKLET来一次性完成tasklet的定义和初始化, DECLARE_TASKLET定义在include/linux/interrupt.h文件中,定义如下:
  1. DECLARE_TASKLET(name, func, data)
复制代码
       其中name为要定义的tasklet名字,这个名字就是一个tasklet_struct类型的时候变量,func就是tasklet的处理函数,data是传递给func函数的参数。
       在上半部,也就是中断处理函数中调用tasklet_schedule函数就能使tasklet在合适的时间运行,tasklet_schedule函数原型如下:
  1. void tasklet_schedule(struct tasklet_struct *t)
复制代码
       函数参数和返回值含义如下:
       t:要调度的tasklet,也就是DECLARE_TASKLET宏里面的name。
       返回值:没有返回值。
       关于tasklet的参考使用示例如下所示:
  1. 示例代码 33.1.7 tasklet使用示例
  2. /* 定义taselet */
  3. struct tasklet_struct testtasklet;

  4. /* tasklet处理函数 */
  5. void testtasklet_func(unsigned long data)
  6. {
  7.     /* tasklet具体处理内容 */
  8. }

  9. /* 中断处理函数 */
  10. irqreturn_t test_handler(int irq, void *dev_id)
  11. {
  12.     ......
  13.     /* 调度tasklet */
  14.     tasklet_schedule(&testtasklet);
  15.     ......
  16. }

  17. /* 驱动入口函数 */
  18. static int __init xxxx_init(void)
  19. {
  20.     ......
  21.     /* 初始化tasklet */
  22.     tasklet_init(&testtasklet, testtasklet_func, data);
  23.     /* 注册中断处理函数 */
  24.     request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
  25.     ......
  26. }
复制代码
       2、工作队列
       工作队列是另外一种下半部执行方式,工作队列在进程上下文执行,工作队列将要推后的工作交给一个内核线程去执行,因为工作队列工作在进程上下文,因此工作队列允许睡眠或重新调度。因此如果你要推后的工作可以睡眠那么就可以选择工作队列,否则的话就只能选择软中断或tasklet。
       Linux内核使用work_struct结构体表示一个工作,该结构体定义在内核源码目录include/linux/workqueue.h头文件中,内容如下:
  1. 示例代码 33.1.8 work_struct结构体
  2. 101  struct work_struct {
  3. 102     atomic_long_t data;
  4. 103     struct list_head entry;
  5. 104     work_func_t func;                /* 工作处理函数 */
  6. 105 #ifdef CONFIG_LOCKDEP
  7. 106     struct lockdep_map lockdep_map;
  8. 107 #endif
  9. 108 };
复制代码
       这些工作组织成工作队列,工作队列使用workqueue_struct结构体表示,该结构体定义在内核源码目录kernel/workqueue.c文件中,内容如下:
  1. 示例代码 33.1.9 workqueue_struct结构体
  2. 239 struct workqueue_struct {
  3. 240     struct list_head pwqs;        /* WR: all pwqs of this wq */
  4. 241     struct list_head list;                /* PR: list of all workqueues */
  5. 242
  6. 243     struct mutex mutex;                /* protects this wq */
  7. 244     int work_color;                        /* WQ: current work color */
  8. 245     int flush_color;                        /* WQ: current flush color */
  9. 246     atomic_t nr_pwqs_to_flush;                        /* flush in progress */
  10. 247     struct wq_flusher *first_flusher;                /* WQ: first flusher */
  11. 248     struct list_head flusher_queue;                /* WQ: flush waiters */
  12. 249     struct list_head flusher_overflow;                /* WQ: flush overflow list */
  13. 250
  14. 251     struct list_head maydays;                        /* MD: pwqs requesting rescue */
  15. 252     struct worker *rescuer;                                /* I: rescue worker */
  16. 253
  17. 254     int nr_drainers;                /* WQ: drain in progress */
  18. 255     int saved_max_active;        /* WQ: saved pwq max_active */
  19. 256
  20. 257     struct workqueue_attrs *unbound_attrs;                /* PW: only for unbound wqs */
  21. 258     struct pool_workqueue *dfl_pwq;                        /* PW: only for unbound wqs */
  22. 259
  23. 260 #ifdef CONFIG_SYSFS
  24. 261     struct wq_device *wq_dev;                        /* I: for sysfs interface */
  25. 262 #endif
  26. 263 #ifdef CONFIG_LOCKDEP
  27. 264     struct lockdep_map lockdep_map;
  28. 265 #endif
  29. 266     char name[WQ_NAME_LEN];                /* I: workqueue name */
  30. 267
  31. 268     /*
  32. 269      * Destruction of workqueue_struct is sched-RCU protected to allow
  33. 270      * walking the workqueues list without grabbing wq_pool_mutex.
  34. 271      * This is used to dump all workqueues from sysrq.
  35. 272      */
  36. 273     struct rcu_head rcu;
  37. 274
  38. 275     /* hot fields used during command issue, aligned to cacheline */
  39. 276     unsigned int flags ____cacheline_aligned;                /* WQ: WQ_* flags */
  40. 277     struct pool_workqueue __percpu *cpu_pwqs;        /* I: per-cpu pwqs */
  41. 278     struct pool_workqueue __rcu *numa_pwq_tbl[];        /* PWR: unbound pwqs indexed by node */
  42. 279 };
复制代码
       Linux内核使用工作者线程(worker thred)来处理工作队列中的各个工作,Linux内核使用worker结构体表示工作者线程,该结构体定义在内核源码目录kernel/workqueue_internal.h头文件中,worker结构体内容如下:
  1. 示例代码 33.1.10 worker结构体
  2. 239 struct workqueue_struct {
  3. 240     struct list_head  pwqs;                /* WR: all pwqs of this wq */
  4. 241     struct list_head  list;                /* PR: list of all workqueues */
  5. 242
  6. 243     struct mutex  mutex;                /* protects this wq */
  7. 244     int work_color;                        /* WQ: current work color */
  8. 245     int flush_color;                        /* WQ: current flush color */
  9. 246     atomic_t nr_pwqs_to_flush;        /* flush in progress */
  10. 247     struct wq_flusher  *first_flusher;                /* WQ: first flusher */
  11. 248     struct list_head  flusher_queue;                /* WQ: flush waiters */
  12. 249     struct list_head  flusher_overflow;        /* WQ: flush overflow list */


  13. 024 struct worker {
  14. 025     /* on idle list while idle, on busy hash table while busy */
  15. 026     union {
  16. 027         struct list_head  entry;                /* L: while idle */
  17. 028         struct hlist_node  hentry;        /* L: while busy */
  18. 029     };
  19. 030
  20. 031     struct work_struct  *current_work;        /* L: work being processed */
  21. 032     work_func_t  current_func;                        /* L: current_work's fn */
  22. 033     struct pool_workqueue  *current_pwq;        /* L: current_work's pwq */
  23. 034     bool desc_valid;                        /* ->desc is valid */
  24. 035     struct list_head  scheduled;        /* L: scheduled works */
  25. 036
  26. 037     /* 64 bytes boundary on 64bit, 32 on 32bit */
  27. 038
  28. 039     struct task_struct  *task;                /* I: worker task */
  29. 040     struct worker_pool  *pool;                /* I: the associated pool */
  30. 041                                         /* L: for rescuers */
  31. 042     struct list_head  node;                        /* A: anchored at pool->workers */
  32. 043                                                /* A: runs through worker->node */
  33. 044
  34. 045     unsigned long  last_active;                /* L: last active timestamp */
  35. 046     unsigned int  flags;                        /* X: flags */
  36. 047     int  id;                                                /* I: worker id */
  37. 048
  38. 049     /*
  39. 050      * Opaque string set with work_set_desc().  Printed out with task
  40. 051      * dump for debugging - WARN, BUG, panic or sysrq.
  41. 052      */
  42. 053     char  desc[WORKER_DESC_LEN];
  43. 054
  44. 055     /* used only by rescuers to point to the target workqueue */
  45. 056     struct workqueue_struct  *rescue_wq;        /* I: the workqueue to rescue */
  46. 057 };
复制代码
       从示例代码 33.1.10可以看出,每个worker都有一个工作队列,工作者线程处理自己工作队列中的所有工作。在实际的驱动开发中,我们只需要定义工作(work_struct)即可,关于工作队列和工作者线程我们基本不用去管。简单创建工作很简单,直接定义一个work_struct结构体变量即可,然后使用INIT_WORK宏来初始化工作,INIT_WORK宏定义如下:
  1. #define INIT_WORK(_work, _func)
复制代码
       _work表示要初始化的工作,_func是工作对应的处理函数。
       也可以使用DECLARE_WORK宏一次性完成工作的创建和初始化,宏定义如下:
  1. #define DECLARE_WORK(n, f)
复制代码
       n表示定义的工作(work_struct),f表示工作对应的处理函数。
       和tasklet一样,工作也是需要调度才能运行的,工作的调度函数为schedule_work,函数原型如下所示:
  1. bool schedule_work(struct work_struct *work)
复制代码
       函数参数和返回值含义如下:
       work:要调度的工作。
       返回值:0 成功,其他值 失败。
       关于工作队列的参考使用示例如下所示:
  1. 示例代码 33.1.11 工作队列使用示例
  2. /* 定义工作(work) */
  3. struct  work_struct testwork;

  4. /* work处理函数 */
  5. void testwork_func_t(struct work_struct *work);
  6. {
  7.     /* work具体处理内容 */
  8. }

  9. /* 中断处理函数 */
  10. irqreturn_t test_handler(int irq, void *dev_id)
  11. {
  12.     ......
  13.     /* 调度work */
  14.     schedule_work(&testwork);
  15.     ......
  16. }

  17. /* 驱动入口函数 */
  18. static int __init xxxx_init(void)
  19. {
  20.     ......
  21.     /* 初始化work */
  22.     INIT_WORK(&testwork, testwork_func_t);
  23.     /* 注册中断处理函数 */
  24.     request_irq(xxx_irq, test_handler, 0, "xxx", &xxx_dev);
  25.     ......
  26. }
复制代码
1.1.3设备树中断信息节点
       如果使用设备树的话就需要在设备树中设置好中断属性信息,Linux内核通过读取设备树中的中断属性信息来配置中断。对于中断控制器而言,设备树绑定信息参考文档Documentation/devicetree/bindings/arm/gic.txt。打开arch/arm/boot/dts/zynq-7000.dtsi文件,其中的intc节点就是ZYNQ 7010/7020的中断控制器节点,节点内容如下所示:
  1. 示例代码 33.1.12 中断控制器intc节点
  2. 144 intc: interrupt-controller@f8f01000 {
  3. 145     compatible = "arm,cortex-a9-gic";
  4. 146     #interrupt-cells = <3>;
  5. 147     interrupt-controller;
  6. 148     reg = <0xF8F01000 0x1000>,
  7. 149          <0xF8F00100 0x100>;
  8. 150 };
复制代码
       第145行,compatible属性值为“arm,cortex-a9-gic”在Linux内核源码中搜索“arm,cortex-a9-gic”即可找到GIC中断控制器驱动文件。
       第146行,#interrupt-cells和#address-cells、#size-cells一样。表示此中断控制器下设备的cells大小,对于设备而言,会使用interrupts属性描述中断信息,#interrupt-cells描述了interrupts属性的cells大小,也就是一条信息有几个cells。每个cells都是32位整形值,对于ARM处理的GIC来说,一共有3个cells,这三个cells的含义如下:
       第一个cells:中断类型,0表示SPI中断(共享外设中断),1表示PPI中断(私有外设中断)。
       第二个cells:中断号,在《领航者ZYNQ之嵌入式开发指南》第四章中介绍过,SPI中断大约有60个,它们对应的中断号范围为32~92(61个),对于PPI中断来说中断号的范围为27~31。但是该cell描述的中断号是从0开始。
       第三个cells:标志,bit[3:0]表示中断触发类型,为1的时候表示上升沿触发,为2的时候表示下降沿触发,为4的时候表示高电平触发,为8的时候表示低电平触发。bit[15:8]为PPI中断的CPU掩码。
       第147行,使用interrupt-controller属性来表示当前节点是中断控制器节点。
对于gpio来说,gpio节点也可以作为中断控制器,比如zynq-7000.dtsi文件中的gpio0节点内容如下所示:
  1. 示例代码 33.1.13 gpio0设备节点
  2. 110 gpio0: gpio@e000a000 {
  3. 111     compatible = "xlnx,zynq-gpio-1.0";
  4. 112     #gpio-cells = <2>;
  5. 113     clocks = <&clkc 42>;
  6. 114     gpio-controller;
  7. 115     interrupt-controller;
  8. 116     #interrupt-cells = <2>;
  9. 117     interrupt-parent = <&intc>;
  10. 118     interrupts = <0 20 4>;
  11. 119     reg = <0xe000a000 0x1000>;
  12. 120 };
复制代码
       第118行,使用interrupts属性来描述gpio中断源的信息,“interrupts = <0 20 4>”中,0表示中断类型,也就是前面说到的SPI中断;20对应的就是ZYNQ 7010/7020 GPIO外设所对应的中断号;而4表示中断触发类型是高电平触发。打开ZYNQ 7010/7020的参考手册,路径为:领航者ZYNQ开发板资料盘(A盘)\8_ZYNQ&FPGA参考资料\Xilinx\User Guide\ug585-Zynq-7000-TRM.pdf,找到“Ch. 7: Interrupts”章节,找到Table 7-4,如下图所示:
第三十三章 Linux中断实验16166.png

图 33.1.1 中断号

       从图 33.1.1中可以看出,GPIO外设所对应的中断号为52,那么前面的20是怎么计算出来的呢?其实就是将中断号编号从0开始,将52减去SPI类型中断的起始编号32即可得出20。
       第115行,interrupt-controller属性表明了gpio0节点也是个中断控制器,用于控制ZYNQ 7010/7020的所有IO的中断。第114行,gpio-controller属性表明该节点是gpio中断控制器。
       第116行,将#interrupt-cells修改为2,所以在设备树中使用gpio中断需要提供2个参数,第一个表示GPIO编号,第二个表示该GPIO的中断触发类型。
       在设备树中如何表示一个GPIO中断呢?我们来看看下面这个示例:
  1. 示例代码 33.1.14 gpio中断使用示例
  2. 1 test-node {
  3. 2    compatible = "test-node";
  4. 3    reg = <0x1e>;
  5. 4    interrupt-parent = <&gpio0>;
  6. 5    interrupts = <12 2>;
  7. 6 };
复制代码
       第4行,interrupt-parent属性设置中断控制器,这里使用gpio0作为中断控制器。
       第6行,interrupts设置中断信息,12表示一个具体的GPIO引脚编号,也就是对应GPIO0_12;而2表示该GPIO的中断触发类型为下降沿触发。
       简单总结一下与中断有关的设备树属性信息:
       ①、#interrupt-cells,指定中断源的信息cells(参数)个数。
       ②、interrupt-controller,表示当前节点为中断控制器。
       ③、interrupts,指定中断号,触发方式等。
       ④、interrupt-parent,指定父中断,也就是中断控制器。
1.1.4获取中断号
        编写驱动的时候需要用到中断号,我们用到中断号,中断信息已经写到了设备树里面,因此可以通过irq_of_parse_and_map函数从interupts属性中提取到对应的设备号,函数原型如下:
  1. unsigned int irq_of_parse_and_map(struct device_node *dev, int index)
复制代码
       函数参数和返回值含义如下:
       dev:设备节点。
       index:索引号,interrupts属性可能包含多条中断信息,通过index指定要获取的信息。
       返回值:中断号。
       如果使用GPIO的话,可以使用gpio_to_irq函数来获取gpio对应的中断号,函数原型如下:
  1. int gpio_to_irq(unsigned int gpio)
复制代码
       函数参数和返回值含义如下:
       gpio:要获取的GPIO编号。
       返回值:GPIO对应的中断号。
       1.2硬件原理图分析
       本章实验硬件原理图参考31.2小节即可。
       1.3实验程序编写
       本实验对应的例程路径为:领航者ZYNQ开发板光盘资料(A盘)\4_SourceCode\3_Embedded_Linux\Linux驱动例程\13_irq。
       本章实验我们驱动开发板上的PS_KEY0按键,不过我们采用中断的方式,并且采用定时器来实现按键消抖,应用程序读取按键值并且通过终端打印出来。通过本章我们可以学习到Linux内核中断的使用方法,以及对Linux内核定时器的回顾。
1.3.1修改设备树文件
       本章实验使用到了按键PS_KEY0,按键PS_KEY0使用中断模式,因此需要在system-top.dts文件中的“key”节点下添加中断相关属性,添加完成以后的“key”节点内容如下所示:
  1. 示例代码 33.3.1 key节点信息
  2. ......

  3.   7 #define GPIO_ACTIVE_HIGH   0
  4.   8 #define GPIO_ACTIVE_LOW    1
  5.   9
  6. 10 /dts-v1/;
  7. 11 #include "zynq-7000.dtsi"
  8. 12 #include "pl.dtsi"
  9. 13 #include "pcw.dtsi"
  10. 14 #include <dt-bindings/interrupt-controller/irq.h>

  11. ......

  12. 51     key {
  13. 52         compatible = "alientek,key";
  14. 53         status = "okay";
  15. 54         key-gpio = <&gpio0 12 GPIO_ACTIVE_LOW>;
  16. 55
  17. 56         interrupt-parent = <&gpio0>;
  18. 57         interrupts = <12 IRQ_TYPE_EDGE_BOTH>;
  19. 58     };
复制代码
       第14行,使用include包含了一个头文件,在内核源码目录include/dt-bindings/interrupt-controller/irq.h。
       第56行,设置interrupt-parent属性值为“gpio0”,因为PS_KEY0所使用的GPIO为GPIO0_IO12,也就是设置PS_KEY0的GPIO中断控制器为gpio0。
       第57行,设置interrupts属性,也就是设置中断源,第一个cells的12表示GPIO0组的12号IO。IRQ_TYPE_EDGE_BOTH定义在头文件include/dt-bindings/interrupt-controller/irq.h中,定义如下:
  1. 示例代码 33.3.2 irq.h头文件内容
  2. 13 #define IRQ_TYPE_NONE                        0
  3. 14 #define IRQ_TYPE_EDGE_RISING        1
  4. 15 #define IRQ_TYPE_EDGE_FALLING        2
  5. 16 #define IRQ_TYPE_EDGE_BOTH                (IRQ_TYPE_EDGE_FALLING | IRQ_TYPE_EDGE_RISING)
  6. 17 #define IRQ_TYPE_LEVEL_HIGH                4
  7. 18 #define IRQ_TYPE_LEVEL_LOW                8
复制代码
       从示例代码 33.3.2中可以看出,IRQ_TYPE_EDGE_BOTH表示上升沿和下降沿同时有效,相当于PS_KEY0按下和释放都会触发中断。
       设备树编写完成以后使用下面这条命令重新编译设备树,如下所示:
  1. make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- system-top.dtb
复制代码
第三十三章 Linux中断实验19166.png

图 33.3.1 重新编译设备树

       将编译的到的system-top.dtb文件重命名为system.dtb,用这个文件替换SD启动卡FAT分区中的dtb文件,然后重新启动开发板。
1.3.2按键中断驱动程序编写
       在drivers目录下新建名为“13_irq”的文件夹,然后在13_irq目录中新建keyirq.c源文件,在keyirq.c里面输入如下内容:
  1. 示例代码 33.3.3 keyirq.c文件代码
  2.   1 /***************************************************************
  3.   2  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
  4.   3  文件名    : keyirq.c
  5.   4  作者      : 邓涛
  6.   5  版本      : V1.0
  7.   6  描述      : GPIO按键中断驱动实验
  8.   7  其他      : 无
  9.   8  论坛      : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
  10.   9  日志      : 初版V1.0 2019/1/30 邓涛创建
  11. 10  ***************************************************************/
  12. 11
  13. 12 #include <linux/types.h>
  14. 13 #include <linux/kernel.h>
  15. 14 #include <linux/delay.h>
  16. 15 #include <linux/ide.h>
  17. 16 #include <linux/init.h>
  18. 17 #include <linux/module.h>
  19. 18 #include <linux/errno.h>
  20. 19 #include <linux/gpio.h>
  21. 20 #include <asm/mach/map.h>
  22. 21 #include <asm/uaccess.h>
  23. 22 #include <asm/io.h>
  24. 23 #include <linux/cdev.h>
  25. 24 #include <linux/of.h>
  26. 25 #include <linux/of_address.h>
  27. 26 #include <linux/of_gpio.h>
  28. 27 #include <linux/of_irq.h>
  29. 28 #include <linux/irq.h>
  30. 29
  31. 30 #define KEY_CNT                1                /* 设备号个数 */
  32. 31 #define KEY_NAME        "key"        /* 名字 */
  33. 32
  34. 33 /* 定义按键状态 */
  35. 34 enum key_status {
  36. 35     KEY_PRESS = 0,                // 按键按下
  37. 36     KEY_RELEASE,                // 按键松开
  38. 37     KEY_KEEP,                        // 按键状态保持
  39. 38 };
  40. 39
  41. 40 /* 按键设备结构体 */
  42. 41 struct key_dev {
  43. 42     dev_t devid;                        /* 设备号 */
  44. 43     struct cdev cdev;                /* cdev结构体 */
  45. 44     struct class *class;                /* 类 */
  46. 45     struct device *device;        /* 设备 */
  47. 46     int key_gpio;                        /* GPIO编号 */
  48. 47     int irq_num;                        /* 中断号 */
  49. 48     struct timer_list timer;        /* 定时器 */
  50. 49     spinlock_t spinlock;        /* 自旋锁 */
  51. 50 };
  52. 51
  53. 52 static struct key_dev key;                        /* 按键设备 */
  54. 53 static int status = KEY_KEEP;        /* 按键状态 */
  55. 54
  56. 55 /*
  57. 56  * @description                        : 打开设备
  58. 57  * @param – inode                        : 传递给驱动的inode
  59. 58  * @param – filp                        : 设备文件,file结构体有个叫做private_data的成员变量
  60. 59  *                                                   一般在open的时候将private_data指向设备结构体。
  61. 60  * @return                                : 0 成功;其他 失败
  62. 61  */
  63. 62 static int key_open(struct inode *inode, struct file *filp)
  64. 63 {
  65. 64     return 0;
  66. 65 }
  67. 66
  68. 67 /*
  69. 68  * @description                : 从设备读取数据
  70. 69  * @param – filp                : 要打开的设备文件(文件描述符)
  71. 70  * @param – buf                : 返回给用户空间的数据缓冲区
  72. 71  * @param – cnt                : 要读取的数据长度
  73. 72  * @param – offt                : 相对于文件首地址的偏移
  74. 73  * @return                        : 读取的字节数,如果为负值,表示读取失败
  75. 74  */
  76. 75 static ssize_t key_read(struct file *filp, char __user *buf,
  77. 76             size_t cnt, loff_t *offt)
  78. 77 {
  79. 78     unsigned long flags;
  80. 79     int ret;
  81. 80
  82. 81     /* 自旋锁上锁 */
  83. 82     spin_lock_irqsave(&key.spinlock, flags);
  84. 83
  85. 84     /* 将按键状态信息发送给应用程序 */
  86. 85     ret = copy_to_user(buf, &status, sizeof(int));
  87. 86
  88. 87     /* 状态重置 */
  89. 88     status = KEY_KEEP;
  90. 89
  91. 90     /* 自旋锁解锁 */
  92. 91     spin_unlock_irqrestore(&key.spinlock, flags);
  93. 92
  94. 93     return ret;
  95. 94 }
  96. 95
  97. 96 /*
  98. 97  * @description                : 向设备写数据
  99. 98  * @param – filp                : 设备文件,表示打开的文件描述符
  100. 99  * @param – buf                : 要写给设备写入的数据
  101. 100  * @param – cnt                : 要写入的数据长度
  102. 101  * @param – offt                : 相对于文件首地址的偏移
  103. 102  * @return                        : 写入的字节数,如果为负值,表示写入失败
  104. 103  */
  105. 104 static ssize_t key_write(struct file *filp, const char __user *buf,
  106. 105             size_t cnt, loff_t *offt)
  107. 106 {
  108. 107         return 0;
  109. 108 }
  110. 109
  111. 110 /*
  112. 111  * @description                : 关闭/释放设备
  113. 112  * @param – filp                : 要关闭的设备文件(文件描述符)
  114. 113  * @return                        : 0 成功;其他 失败
  115. 114  */
  116. 115 static int key_release(struct inode *inode, struct file *filp)
  117. 116 {
  118. 117     return 0;
  119. 118 }
  120. 119
  121. 120 static void key_timer_function(unsigned long arg)
  122. 121 {
  123. 122     static int last_val = 1;
  124. 123     unsigned long flags;
  125. 124     int current_val;
  126. 125
  127. 126     /* 自旋锁上锁 */
  128. 127     spin_lock_irqsave(&key.spinlock, flags);
  129. 128
  130. 129     /* 读取按键值并判断按键当前状态 */
  131. 130     current_val = gpio_get_value(key.key_gpio);
  132. 131     if (0 == current_val && last_val)       // 按下
  133. 132         status = KEY_PRESS;
  134. 133     else if (1 == current_val && !last_val)
  135. 134         status = KEY_RELEASE;   // 松开
  136. 135     else
  137. 136         status = KEY_KEEP;              // 状态保持
  138. 137
  139. 138     last_val = current_val;
  140. 139
  141. 140     /* 自旋锁解锁 */
  142. 141     spin_unlock_irqrestore(&key.spinlock, flags);
  143. 142 }
  144. 143
  145. 144 static irqreturn_t key_interrupt(int irq, void *dev_id)
  146. 145 {
  147. 146     /* 按键防抖处理,开启定时器延时15ms */
  148. 147     mod_timer(&key.timer, jiffies + msecs_to_jiffies(15));
  149. 148     return IRQ_HANDLED;
  150. 149 }
  151. 150
  152. 151 static int key_parse_dt(void)
  153. 152 {
  154. 153     struct device_node *nd;
  155. 154     const char *str;
  156. 155     int ret;
  157. 156
  158. 157     /* 获取key节点 */
  159. 158     nd = of_find_node_by_path("/key");
  160. 159     if(NULL == nd) {
  161. 160         printk(KERN_ERR "key: Failed to get key node\n");
  162. 161         return -EINVAL;
  163. 162     }
  164. 163
  165. 164     /* 读取status属性 */
  166. 165     ret = of_property_read_string(nd, "status", &str);
  167. 166     if(!ret) {
  168. 167         if (strcmp(str, "okay"))
  169. 168             return -EINVAL;
  170. 169     }
  171. 170
  172. 171     /* 获取compatible属性值并进行匹配 */
  173. 172     ret = of_property_read_string(nd, "compatible", &str);
  174. 173     if(ret)
  175. 174         return ret;
  176. 175
  177. 176     if (strcmp(str, "alientek,key")) {
  178. 177         printk(KERN_ERR "key: Compatible match failed\n");
  179. 178         return -EINVAL;
  180. 179     }
  181. 180
  182. 181     /* 获取设备树中的key-gpio属性,得到按键的GPIO编号 */
  183. 182     key.key_gpio = of_get_named_gpio(nd, "key-gpio", 0);
  184. 183     if(!gpio_is_valid(key.key_gpio)) {
  185. 184         printk(KERN_ERR "key: Failed to get key-gpio\n");
  186. 185         return -EINVAL;
  187. 186     }
  188. 187
  189. 188     /* 获取GPIO对应的中断号 */
  190. 189     key.irq_num = irq_of_parse_and_map(nd, 0);
  191. 190     if (!key.irq_num)
  192. 191         return -EINVAL;
  193. 192
  194. 193     return 0;
  195. 194 }
  196. 195
  197. 196 static int key_gpio_init(void)
  198. 197 {
  199. 198     unsigned long irq_flags;
  200. 199     int ret;
  201. 200
  202. 201     /* 申请使用GPIO */
  203. 202     ret = gpio_request(key.key_gpio, "Key Gpio");
  204. 203     if (ret)
  205. 204         return ret;
  206. 205
  207. 206     /* 将GPIO设置为输入模式 */
  208. 207     gpio_direction_input(key.key_gpio);
  209. 208
  210. 209     /* 获取设备树中指定的中断触发类型 */
  211. 210     irq_flags = irq_get_trigger_type(key.irq_num);
  212. 211     if (IRQF_TRIGGER_NONE == irq_flags)
  213. 212         irq_flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;
  214. 213
  215. 214     /* 申请中断 */
  216. 215     ret = request_irq(key.irq_num, key_interrupt, irq_flags, "PS Key0 IRQ", NULL);
  217. 216     if (ret) {
  218. 217         gpio_free(key.key_gpio);
  219. 218         return ret;
  220. 219     }
  221. 220
  222. 221     return 0;
  223. 222 }
  224. 223
  225. 224 /* 设备操作函数 */
  226. 225 static struct file_operations key_fops = {
  227. 226     .owner                = THIS_MODULE,
  228. 227     .open                = key_open,
  229. 228     .read                        = key_read,
  230. 229     .write                = key_write,
  231. 230     .release                = key_release,
  232. 231 };
  233. 232
  234. 233 static int __init mykey_init(void)
  235. 234 {
  236. 235     int ret;
  237. 236
  238. 237     /* 初始化自旋锁 */
  239. 238     spin_lock_init(&key.spinlock);
  240. 239
  241. 240     /* 设备树解析 */
  242. 241     ret = key_parse_dt();
  243. 242     if (ret)
  244. 243         return ret;
  245. 244
  246. 245     /* GPIO、中断初始化 */
  247. 246     ret = key_gpio_init();
  248. 247     if (ret)
  249. 248         return ret;
  250. 249
  251. 250     /* 初始化cdev */
  252. 251     key.cdev.owner = THIS_MODULE;
  253. 252     cdev_init(&key.cdev, &key_fops);
  254. 253
  255. 254     /* 添加cdev */
  256. 255     ret = alloc_chrdev_region(&key.devid, 0, KEY_CNT, KEY_NAME);
  257. 256     if (ret)
  258. 257         goto out1;
  259. 258
  260. 259     ret = cdev_add(&key.cdev, key.devid, KEY_CNT);
  261. 260     if (ret)
  262. 261         goto out2;
  263. 262
  264. 263     /* 创建类 */
  265. 264     key.class = class_create(THIS_MODULE, KEY_NAME);
  266. 265     if (IS_ERR(key.class)) {
  267. 266         ret = PTR_ERR(key.class);
  268. 267         goto out3;
  269. 268     }
  270. 269
  271. 270     /* 创建设备 */
  272. 271     key.device = device_create(key.class, NULL,
  273. 272                 key.devid, NULL, KEY_NAME);
  274. 273     if (IS_ERR(key.device)) {
  275. 274         ret = PTR_ERR(key.device);
  276. 275         goto out4;
  277. 276     }
  278. 277
  279. 278     /* 初始化定时器 */
  280. 279     init_timer(&key.timer);
  281. 280     key.timer.function = key_timer_function;
  282. 281
  283. 282     return 0;
  284. 283
  285. 284 out4:
  286. 285     class_destroy(key.class);
  287. 286
  288. 287 out3:
  289. 288     cdev_del(&key.cdev);
  290. 289
  291. 290 out2:
  292. 291     unregister_chrdev_region(key.devid, KEY_CNT);
  293. 292
  294. 293 out1:
  295. 294     free_irq(key.irq_num, NULL);
  296. 295     gpio_free(key.key_gpio);
  297. 296
  298. 297     return ret;
  299. 298 }
  300. 299
  301. 300 static void __exit mykey_exit(void)
  302. 301 {
  303. 302     /* 删除定时器 */
  304. 303     del_timer_sync(&key.timer);
  305. 304
  306. 305     /* 注销设备 */
  307. 306     device_destroy(key.class, key.devid);
  308. 307
  309. 308     /* 注销类 */
  310. 309     class_destroy(key.class);
  311. 310
  312. 311     /* 删除cdev */
  313. 312     cdev_del(&key.cdev);
  314. 313
  315. 314     /* 注销设备号 */
  316. 315     unregister_chrdev_region(key.devid, KEY_CNT);
  317. 316
  318. 317     /* 释放中断 */
  319. 318     free_irq(key.irq_num, NULL);
  320. 319
  321. 320     /* 释放GPIO */
  322. 321     gpio_free(key.key_gpio);
  323. 322 }
  324. 323
  325. 324 /* 驱动模块入口和出口函数注册 */
  326. 325 module_init(mykey_init);
  327. 326 module_exit(mykey_exit);
  328. 327
  329. 328 MODULE_AUTHOR("DengTao <<a href="mailto:773904075@qq.com">773904075@qq.com</a>>");
  330. 329 MODULE_DESCRIPTION("Gpio Key Interrupt Driver");
  331. 330 MODULE_LICENSE("GPL");
复制代码
       第34~38行,定义了一个枚举类型,包含3个常量KEY_PRESS、KEY_RELEASE、KEY_KEEP,分别用来表示按键的3种不同的状态,即按键按下、按键松开以及按键状态保持。
       第41~50行,结构体key_dev为按键设备所对应的结构体,key_gpio为按键GPIO编号,irq_num为按键IO对应的中断号;除此之外,结构体当中还定义了一个定时器用于实现按键的去抖操作,还定义了一个自旋锁用于实现对关键代码的保护操作。
       第52行,定义一个按键设备key。
       第53行,定义一个int类型的静态全局变量status用来表示按键的状态。
       第75~94行,key_read函数,对应应用程序的read函数。此函数向应用程序返回按键状态信息数据;这个函数其实很简单,使用copy_to_user函数直接将statue数据发送给应用程序,status变量保存了按键当前的状态,发送完成之后再将按键状态重置即可!需要注意的是,该函数中使用了自旋锁进行保护。
       第120~142行,key_timer_function函数为定时器定时处理函数,它的参数arg在本驱动程序中我们并没有使用到;该函数中定义了一个静态局部变量last_val用来保存按键上一次读取到的值,变量current_val用来存放当前按键读取到的值;第130~136行,通过读取到的按键值以及上一次读取到的值来判断按键当前所属的状态,如果本次读取的值为0,而上一次读取的值1,则表示按键按下;如果本次读取的值为1,而上一次读取的值0,则表示按键松开;如果本次读取的值为0,而上一次读取的值也是0,则表示按键一直被按着;如果本次读取的值为1,而上一次读取的值也是1,则表示没有触碰按键。第138行,当状态判断完成之后,会将current_val的值赋值给last_val。本函数中也使用自旋锁对全局变量status进行加锁保护!
       第144~149行,key_interrupt函数是按键PS_KEY0中断处理函数,参数dev_id是一个void类型的指针,本驱动程序并没使用到这个参数;这个中断处理函数很简单直接开启定时器,延时15毫秒,用于实现按键的软件防抖。
       第151~194行,key_parse_dt函数中主要是对设备树中的属性进行了解析,获取设备树中的key节点,通过of_get_named_gpio函数得到按键的GPIO编号,通过irq_of_parse_and_map函数获取按键的中断号,irq_of_parse_and_map函数会解析key节点中的interrupt-parent和interrupts属性然后得到一个中断号,后面就可以使用这个中断号去申请以及释放中断了。
       第196~222行,key_gpio_init函数中主要对GPIO以及中断进行了相关的初始化。使用gpio_request函数申请GPIO使用权,通过gpio_direction_input将GPIO设置为输出模式;irq_get_trigger_type函数可以获取到key节点中定义的中断触发类型,最后使用request_irq申请中断,并设置key_interrupt函数作为我们的按键中断处理函数,当按键中断发生之后便会跳转到该函数执行;request_irq函数会默认使能中断,所以不需要enable_irq来使能中断,当然我们也可以在申请成功之后先使用disable_irq函数禁用中断,等所有工作完成之后再来使能中断,这样会比较安全,建议大家这样使用。
       第225~231行,按键设备的file_operations结构体。
       第233~298行,mykey_init是驱动入口函数,第238行调用spin_lock_init初始化自旋锁变量,279~280行对定时器进行初始化并将key_timer_function函数绑定为定时器定时处理函数,当定时时间到了之后便会跳转到该函数执行。
       第300~322行,mykey_exit驱动出口函数,第303行调用del_timer_sync函数删除定时器,代码中已经注释得非常详细了,这里便不再多说!
1.3.3编写测试APP
       测试APP要实现的内容很简单,通过不断的读取/dev/key设备文件来获取按键值来判断当前按键的状态,从按键驱动上传到应用程序的数据可以有3个值,分别为0、1、2;0表示按键按下时的这个状态,1表示按键松开时对应的状态,而2表示按键一直被按住或者松开;搞懂数据代表的意思之后,我们开始编写测试程序,在13_irq目录下新建名为keyApp.c的文件,然后输入如下所示内容:
  1. 示例代码 33.3.4 keyApp.c文件代码
  2.   1 /***************************************************************
  3.   2  Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
  4.   3  文件名              : keyApp.c
  5.   4  作者                : 邓涛
  6.   5  版本                : V1.0
  7.   6  描述                : 按键测试应用程序
  8.   7  其他                : 无
  9.   8  使用方法            : ./keyApp /dev/key
  10.   9  论坛                : <a href="www.openedv.com" target="_blank">www.openedv.com</a>
  11. 10  日志                : 初版V1.0 2019/1/30 邓涛创建
  12. 11  ***************************************************************/
  13. 12
  14. 13 #include <stdio.h>
  15. 14 #include <unistd.h>
  16. 15 #include <sys/types.h>
  17. 16 #include <sys/stat.h>
  18. 17 #include <fcntl.h>
  19. 18 #include <stdlib.h>
  20. 19 #include <string.h>
  21. 20
  22. 21 /*
  23. 22  * @description                : main主程序
  24. 23  * @param – argc                : argv数组元素个数
  25. 24  * @param – argv                : 具体参数
  26. 25  * @return                        : 0 成功;其他 失败
  27. 26  */
  28. 27 int main(int argc, char *argv[])
  29. 28 {
  30. 29     int fd, ret;
  31. 30     int key_val;
  32. 31
  33. 32     /* 判断传参个数是否正确 */
  34. 33     if(2 != argc) {
  35. 34         printf("Usage:\n"
  36. 35              "\t./keyApp /dev/key\n"
  37. 36             );
  38. 37         return -1;
  39. 38     }
  40. 39
  41. 40     /* 打开设备 */
  42. 41     fd = open(argv[1], O_RDONLY);
  43. 42     if(0 > fd) {
  44. 43         printf("ERROR: %s file open failed!\n", argv[1]);
  45. 44         return -1;
  46. 45     }
  47. 46
  48. 47     /* 循环读取按键数据 */
  49. 48     for ( ; ; ) {
  50. 49
  51. 50         read(fd, &key_val, sizeof(int));
  52. 51         if (0 == key_val)
  53. 52             printf("Key Press\n");
  54. 53         else if (1 == key_val)
  55. 54             printf("Key Release\n");
  56. 55     }
  57. 56
  58. 57     /* 关闭设备 */
  59. 58     close(fd);
  60. 59     return 0;
  61. 60 }
  62.         第48~55行使用for循环不断的读取按键值,如果读取到的值是0则打印“Key Press”字符串,而过读取到的值是1则打印“Key Release”字符串。
  63. 1.4运行测试
  64. 1.4.1编译驱动程序和测试APP
  65. 1、编译驱动程序
  66. 编写Makefile文件,直接将上一章实验目录12_timer下的Makefile文件拷贝到本实验目录下,打开该Makefile文件,将obj-m变量的值改为keyirq.o,Makefile内容如下所示:
  67. 示例代码 33.4.1 Makefile文件
  68.   1 KERN_DIR := /home/zynq/linux/kernel/linux-xlnx-xilinx-v2018.3
  69.   2
  70.   3 obj-m := keyirq.o
  71.   4
  72.   5 all:
  73.   6         make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- -C $(KERN_DIR) M=`pwd` modules
  74.   7
  75.   8 clean:
  76.   9         make -C $(KERN_DIR) M=`pwd` clean
复制代码
       第3行,设置obj-m变量的值为keyirq.o。
       修改完成之后保存退出,输入如下命令编译出驱动模块文件:
  1. make
复制代码
       编译成功以后就会生成一个名为“keyirq.ko”的驱动模块文件,如下所示:
第三十三章 Linux中断实验32054.png

图 33.4.1 编译驱动模块

       2、编译测试APP
       输入如下命令编译测试imx6uirqApp.c这个测试程序:
  1. arm-linux-gnueabihf-gcc keyApp.c -o keyApp
复制代码
       编译成功以后就会生成keyApp这个应用程序。
1.4.2运行测试
       将上一小节编译出来keyirq.ko和keyApp这两个文件拷贝到开发板根文件系统/lib/modules/4.14.0-xilinx目录中,然后重启开发板,进入到目录/lib/modules/4.14.0-xilinx中,输入如下命令加载keyirq.ko驱动模块:
  1. depmod                                //第一次加载驱动的时候需要运行此命令
  2. modprobe keyirq.ko        //加载驱动
复制代码
       驱动加载成功以后可以通过查看/proc/interrupts文件来检查一下对应的中断有没有被注册上,输入如下命令:
  1. cat /proc/interrupts
复制代码
       结果如图 33.4.2所示:
第三十三章 Linux中断实验32537.png

图 33.4.2 查看当前系统已经使用的中断号

       图 33.4.2中红框标识的中断信息就是keyirq按键中断驱动程序中使用的中断,中断号为60,触发方式为跳边沿(Edge),中断命名为“PS Key0 IRQ”。
       接下来使用如下命令来测试按键中断工作是否正常了:
  1. ./keyApp /dev/key
复制代码
        按下开发板上的PS_KEY0键,终端就会打印出字符串,如图 33.4.3所示:
第三十三章 Linux中断实验32820.png

图 33.4.3 按键中断测试结果

       从图 33.4.3可以看出,当我们按下PS_KEY0按键时,终端会打印出“Key Press”字符串,当松开按键时,中断会打印出“Key Release”字符串;由于我们在驱动程序中加入了软件防抖处理,所以效果会比第三十一章测试时好很多。
       如果要卸载驱动的话输入如下命令即可:
  1. rmmod keyirq.ko
复制代码


回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子论坛 ( 公安交互式论坛备案:44190002001997 粤ICP备09047143号 )

GMT+8, 2022-7-6 03:07

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表