碼上歡樂
相關內容    簡體    繁體

linux中斷申請之request_threaded_irq

本文轉載自   查看原文   2016-07-01 10:03   4031    driver

轉自:http://blog.chinaunix.net/xmlrpc.php?r=blog/article&uid=21977330&id=3755609

 

在linux里，中斷處理分為頂半（top half），底半(bottom half)，在頂半里處理優先級比較高的事情，要求占用中斷時間盡量的短，在處理完成后，就激活底半，有底半處理其余任務。底半的處理方式主要有soft_irq, tasklet, workqueue三種，他們在使用方式和適用情況上各有不同。soft_irq用在對底半執行時間要求比較緊急或者非常重要的場合，主要為一些subsystem用，一般driver基本上用不上。 tasklet和work queue在普通的driver里用的相對較多，主要區別是tasklet是在中斷上下文執行,而work queue是在process上下文，因此可以執行可能sleep的操作。

request_threaded_irq()是Linux kernel 2.6.30 之后新加的irq handler API 

如何確定可以用到 request_threaded_irq() ? 
Linux kernel config 需要定義CONFIG_GENERIC_HARDIQS 
kernel config 才有支援threaded irq 

    Moving interrupts to threads 介紹request_threaded_irq() 的由來 
    http://lwn.net/Articles/302043/ 
    從realtime tree 移植而來，為了減少kernel 因為要等待每一個硬件中斷處理的時間 
    ，就另外交給kernel thread 處理中斷后續工作。 
    優點： 
        1 減少 kernel 延遲時間 
        2 避免處理中斷時要分辨是在硬體中斷或軟體中斷？ 
        3 更容易為kernel 中斷處理除錯，可能可完全取代tasklet 
    原本的中斷處理分上半部(硬體中斷處理，必須關閉中斷無法處理新的中斷)跟下半部( 
    軟體中斷處理)，因此上半部的硬體中斷處理必須盡可能簡短，讓系統反應速度更快。 

    request_threaded_irq 是在將上半部的硬件中斷處理縮短為只確定硬體中斷來 
    自我們要處理的裝置，喚醒kernel thread 執行后續中斷任務。

    缺點： 
    對於非irq 中斷的kernel threads ，需要在原本task_struct 新增struct 
    irqaction 多占 4/8 bytes 記憶體空間 
    linux kernel 2.6.29 之后(2.6.30)加入request_threaded_irq 


    跟傳統top/bottom havles 的差異是threaded_irq 受Linux kernel system 
    的 process scheduling 控制，不會因為寫錯的bottom half 代碼造成整個系統 
    延遲的問題。 

    也可以透過RT/non RT 跟nice 等工具調整各個thread 優先權，丟給使用率較低的 
    cpu 以及受惠於kernel 原本可以對threads 做的各種控制，包括但不限於sleep, 
    lock, allocate 新的記憶體區塊。 

    受惠最大的是shared irq line 的多個中斷處理。除了可以加速共享中斷造成的延遲 
    ，threaded_irq 也可以降低在同一段程式碼處理多個裝置中斷的復雜度。 

    threaded irq 在使用性上也比tasklet(接着top half 直接執行，無法sleep) 
    /workqueue(kernel context?) 等需要在top half 增加跟bottom half 連結與溝通 
    的麻煩。 

int request_threaded_irq(unsigned int irq, irq_handler_t handler, irq_handler_t thread_fn, unsigned long irqflags, const char *devname, void *dev_id) 

IRQF_SHARED 共享中斷時，dev_id不能為空，因為釋放irq時要區分哪個共享中斷
irq：中斷號
handler：發生中斷時首先要執行的硬中斷處理函數，這個函數可以通過返回 IRQ_WAKE_THREADED喚醒中斷線程，也可
返回IRQ_HANDLE不執行中斷線程
thread_fn : 中斷線程，類似於中斷下半部
后三個參數與request_irq中的一致

關於IRQF_ONESHOT, 直到線程函數執行完畢才會開啟該中斷

IRQF_ONESHOT:Interrupt is not reenabled after the hardirq handler finished.     Used by threaded interrupts which need to keep the irq line disabled until the threaded handler has been run. 這里linus在郵件列表里指明IRQF_ONESHOT 的原因
Making the IRQF_ONESHOT explicit does two things:
 - it makes people who read the code *aware* of things
 - if/when you have irq conflicts and two drivers want to attach to
the same interrupt, at least you can see directly from the source what
flags they used (and again, not have to even *think* about it).

IRQF_ONESHOT 與 IRQF_SHARED 不能同時使用
當多個設備共享中斷時，由於IRQF_ONESHOT會關閉中斷線程的中斷，而線程一般執行時間會比較長，所以是不允許的
當hardirq函數為NULL時，必須聲明IRQF_ONESHOT, 表示threadirq線程中關閉該中斷,在某些情況下，這個標志會非常有用
例如：設備是低電平產生中斷，而硬中斷函數為NULL，如果不使用IRQF_ONESHOT,就會一直產生中斷執行NULL函數，中斷線程
得不到執行，聲明IRQF_ONESHOT后，會執行完線程才使能該中斷  

 

點擊(此處)折疊或打開

  1. /* 
  2.  * gpio_irqTest.c 
  3.  * PB27 receive this signal as IRQ and make the LED linking on PB17 turn on or turn off 
  4.  * 
  5.  */ 
  6.   
  7. #include <linux/types.h> 
  8. #include <linux/kernel.h> 
  9. #include <linux/module.h> 
  10. #include <linux/init.h> 
  11. #include <linux/platform_device.h> 
  12. #include <linux/cdev.h> 
  13. #include <linux/ioctl.h> 
  14. #include <linux/fs.h> 
  15. #include <linux/gpio.h>
  16. #include <linux/delay.h>
  17. #include <linux/cdev.h> 
  18. #include <linux/interrupt.h>
  20. #include <asm/io.h> 
  21. #include <asm/io.h>
  23. #include <mach/gpio.h> 
  24. #include <mach/hardware.h> 
  25. #include <mach/board.h> 
  26. #include <mach/gpio.h> 
  27. #include <mach/at91_pio.h> 
  28. #include <mach/at91_aic.h> 
  29. #include <mach/at91_pmc.h> 
  31. void led_on() 
  32. { 
  33. // at91_set_gpio_output(AT91_PIN_PB17,1);
  34.     printk("led on\n");
  35. } 
  36.   
  37. void led_off() 
  38. { 
  39. // at91_set_gpio_output(AT91_PIN_PB17 ,0);
  40.     printk("led off.\n");
  41. } 
  42.   
  43. struct light_dev *light_devp; 
  44. int light_major = 200; 
  45.   
  46. struct light_dev 
  47. { 
  48.     struct cdev cdev; 
  49.     unsigned char value; 
  50. }; 
  51.   
  53.   
  54. static void io_init(void) 
  55. {
  56.     at91_set_GPIO_periph(AT91_PIN_PB27, 0);
  57.     at91_set_gpio_input(AT91_PIN_PB27, 1); 
  58.     at91_set_deglitch(AT91_PIN_PB27, 1); 
  60. } 
  61.   
  62.   
  63. struct gpio_irq_desc 
  64. {
  65.     int pin;
  66.     int irq; 
  67.     unsigned long flags; 
  68.     char *name; 
  69. }; 
  70.   
  71. static struct gpio_irq_desc gpio_irq={AT91_PIN_PB27, AT91_PIN_PB27,IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING|IRQF_ONESHOT,"PB27"};
  72. static irqreturn_t gpio_irqhandler(int irq, void *dev_id)
  73. {
  74.     printk(KERN_INFO "In hard irq handler.\n");
  75.     return IRQ_WAKE_THREAD;
  76. }
  78. static irqreturn_t gpio_threadhandler(int irq, void *dev_id) 
  79. {
  80.     int rst;
  81.     rst = at91_get_gpio_value(gpio_irq.pin);
  82.     printk(KERN_INFO "gpio stat: %d\n", rst);
  83.     if(rst == 0){
  84.         led_on();
  85.     }else{
  86.         led_off();
  87.     }
  88.     printk(KERN_INFO "sleep 3000ms\n");
  89.     msleep(3000);
  90.     printk(KERN_INFO "awake after sleep\n");
  91.     return IRQ_HANDLED;
  92. }
  93.   
  94. int light_open(struct inode *inode,struct file *filp) 
  95. { 
  96.     int err; 
  97.     struct light_dev *dev;
  98.     dev = container_of(inode->i_cdev,struct light_dev,cdev); 
  99.     filp->private_data = dev;
  100.     printk(KERN_DEBUG "%s", __FUNCTION__);
  101.     io_init(); 
  102. // err = request_threaded_irq(gpio_irq.irq,gpio_irqhandler,gpio_threadhandler,gpio_irq.flags,gpio_irq.name,(void*)0);
  103.     err = request_threaded_irq(gpio_irq.irq,NULL,gpio_threadhandler,gpio_irq.flags,gpio_irq.name,(void*)0);
  104.     if(err) 
  105.     { 
  106. // free_irq(gpio_irq.irq,(void*)0);
  107.         printk(KERN_DEBUG "request irq failed.\n");
  108.         return -EBUSY; 
  109.     } 
  110.       
  111.     return 0; 
  112. } 
  113.   
  114. int light_release(struct inode *inode,struct file *filp) 
  115. { 
  116.     free_irq(gpio_irq.irq,(void*)0); 
  117.     return 0; 
  118. } 
  119.   
  120. int light_ioctl(struct inode *inode,struct file *filp,unsigned int cmd, unsigned long arg)
  121. { 
  122.     struct light_dev *dev = filp->private_data; 
  123.   
  124.     switch(cmd) 
  125.     { 
  126.         case 0: 
  127.             at91_set_gpio_output(AT91_PIN_PB19,0); 
  128.         break; 
  129.   
  130.         case 1: 
  131.           at91_set_gpio_output(AT91_PIN_PB19,1); 
  132.        led_off(); 
  133.         break; 
  134.   
  135.     default: 
  136.   
  137.             return -ENOTTY;
  138.         // break;
  139.     }
  140.     return 0;
  141. } 
  142.   
  143. struct file_operations light_fops = 
  144. { 
  145.     .owner = THIS_MODULE,
  146.     .open = light_open,
  147.     .release = light_release,
  148.     .unlocked_ioctl = light_ioctl,
  149. }; 
  150.   
  151.   
  152. static void light_setup_cdev(struct light_dev *dev,int index) 
  153. { 
  154.     int err,devno = MKDEV(light_major,index); 
  155.   
  156.     cdev_init(&dev->cdev,&light_fops); 
  157.     dev->cdev.owner = THIS_MODULE; 
  158.     dev->cdev.ops = &light_fops; 
  159.   
  160.     err = cdev_add(&dev->cdev,devno,1); 
  161.   
  162.     if(err) 
  163.     { 
  164.         printk(KERN_NOTICE "Error %d adding LED%d",err,index); 
  165.     }
  166. } 
  167.   
  168.   
  169. int __init light_init(void) 
  170. { 
  171.     int result; 
  172.   
  173.     dev_t dev = MKDEV(light_major,0); 
  174.     if(light_major) 
  175.     { 
  176.           
  177.         result = register_chrdev_region(dev,1,"gpio"); 
  178.     } 
  179.   
  180.     if(result < 0) 
  181.     {
  182.         printk(KERN_DEBUG "%s: register char dev failed.\n", __FUNCTION__);
  183.         return result; 
  184.     } 
  185.   
  186.     light_devp = kmalloc(sizeof(struct light_dev),GFP_KERNEL); 
  187.     if(!light_devp) 
  188.     { 
  189.         result = - ENOMEM; 
  190.         goto fail_malloc; 
  191.     } 
  192.   
  193.     memset(light_devp,0,sizeof(struct light_dev)); 
  194.     light_setup_cdev(light_devp,0); 
  195.       
  196.     printk(KERN_DEBUG "%s done\n", __FUNCTION__);
  197.     return 0; 
  198.   
  199.     fail_malloc:unregister_chrdev_region(dev,light_devp); 
  200.     return result; 
  201.       
  202. } 
  203.   
  204. void __exit light_cleanup(void) 
  205. { 
  206.     cdev_del(&light_devp->cdev); 
  207.     kfree(light_devp); 
  208.     unregister_chrdev_region(MKDEV(light_major,0),1); 
  209. } 
  210.   
  211. module_init(light_init); 
  212. module_exit(light_cleanup);
  214. MODULE_AUTHOR("Enzo Fang"); 
  215. MODULE_LICENSE("Dual BSD/GPL");


結論：
使用
request_threaded_irq(gpio_irq.irq,gpio_irqhandler,gpio_threadhandler,gpio_irq.flags,gpio_irq.name,(void*)0);
hardirq和thread_fn同時出現時，處理thread_fn時該中斷是打開的

  err = request_threaded_irq(gpio_irq.irq,NULL,gpio_threadhandler,gpio_irq.flags,gpio_irq.name,(void*)0);
但hardirq和thread_fn只有一個存在時，處理thread_fn時，中斷是關閉的


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 request_irq() | 注冊中斷服務 6.分析request_irq和free_irq函數如何注冊注銷中斷(詳解) Linux kernel的中斷子系統之（二）：IRQ Domain介紹 linux arm irq (1): irq init Linux kernel中斷子系統之（五）：驅動申請中斷API【轉】 ARM 之FIQ(快速中斷) IRQ（中斷） linux arm irq (2): interrupt handling linux arm irq (3): gpio interrupt Linux中斷-簡單中斷，以GPIO中斷為例 linux 中斷管理(一)
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM