大主宰天蚕土豆小说,辰东全部小说,神武八荒一颗小说

上篇，學習GPIO輸入功能的使用，本篇，來學習使用中斷的方式來檢測按鍵的按下。

1 Linux中斷介紹

1.1 中斷的上半部與下半部

中斷處理函數的執行，越快越好，但實際使用中，某些情況確實需要比較耗時是中斷過程，為此，Linux內核將中斷分為上半部和下半部兩個處理部分：

上半部：中斷處理函數，那些處理過程比較快，不會占用很長時間的處理就可以放在上半部完成

下半部：如果中斷處理過程比較耗時，那么就將這些比較耗時的代碼提出來，交給下半部去執行，這樣中斷處理函數就會快進快出

對于一個中斷，如何劃分出上下兩部分呢?

對時間敏感，將其放在上半部

和硬件相關，將其放在上半部

要求不被其他中斷打斷，將其放在上半部

其他所有任務，考慮放在下半部

1.2 下半部的3種實現方式

1.2.1 軟中斷

Linux內核使用softirq_action結構體表示軟中斷：

struct softirq_action 
{ 
	void (*action)(struct softirq_action *); 
};

一共有 10 個軟中斷

enum 
{ 
    HI_SOFTIRQ = 0,          /* 高優先級軟中斷    */ 
    TIMER_SOFTIRQ,           /* 定時器軟中斷      */ 
    NET_TX_SOFTIRQ,          /* 網絡數據發送軟中斷 */ 
    NET_RX_SOFTIRQ,          /* 網絡數據接收軟中斷 */ 
    BLOCK_SOFTIRQ,           
    BLOCK_IOPOLL_SOFTIRQ,    
    TASKLET_SOFTIRQ,         /* tasklet 軟中斷   */ 
    SCHED_SOFTIRQ,           /* 調度軟中斷        */ 
    HRTIMER_SOFTIRQ,         /* 高精度定時器軟中斷 */ 
    RCU_SOFTIRQ,             /* RCU 軟中斷       */ 
        
    NR_SOFTIRQS 
};

要使用軟中斷，必須先使用open_softirq函數注冊對應的軟中斷處理函數:

/**
 * nr: 要開啟的軟中斷
 * action: 軟中斷對應的處理函數
 * return: 無
 */
void open_softirq(int nr,  void (*action)(struct softirq_action *))

注冊好軟中斷以后需要通過raise_softirq函數觸發：

/**
 * nr: 要觸發的軟中斷
 * return: 無
 */
void raise_softirq(unsigned int nr)

1.2.2 tasklet

Linux內核使用tasklet_struct結構體來表示tasklet：

struct tasklet_struct 
{ 
	struct tasklet_struct *next;     /* 下一個tasklet      */ 
	unsigned long state;             /* tasklet狀態        */ 
	atomic_t count;                  /* 計數器, 記錄對tasklet的引用數 */ 
	void (*func)(unsigned long);     /* tasklet執行的函數  */ 
	unsigned long data;              /* 函數func的參數     */ 
};

要使用 tasklet，必須先定義一個tasklet，然后初始化：

/**
 * t: 要初始化的tasklet
 * func: tasklet的處理函數
 * data: 要傳遞給func函數的參數
 * return: 無
 */
void tasklet_init(struct tasklet_struct *t,
                void (*func)(unsigned long),  
                        unsigned long data);

在上半部（中斷處理函數）中調用tasklet_schedule函數就能使tasklet在合適的時間運行：

/**
 * t: 要調度的tasklet
 * return: 無
 */
void tasklet_schedule(struct tasklet_struct *t)

1.2.3 工作隊列

工作隊列（work queue）是另外一種將中斷的部分工作推后的一種方式，它可以實現一些tasklet不能實現的工作，比如工作隊列機制可以睡眠。

Linux 內核使用work_struct結構體表示一個工作：

struct work_struct { 
    atomic_long_t data;     
    struct list_head entry;  
    work_func_t func;        /* 工作隊列處理函數  */ 
};

這些工作組織成工作隊列，工作隊列使用workqueue_struct結構體表示。

在工作隊列機制中，將推后的工作交給一個稱之為工作者線程（worker thread）的內核線程去完成。

1.3 中斷API函數

1.3.1 request_irq中斷請求函數

/**
 * irq: 要申請中斷的中斷號
 * handler: 中斷處理函數，當中斷發生以后就會執行此中斷處理函數
 * flags: 中斷標志
 * name: 中斷名字
 * dev: 設備結構體
 * return: 0-中斷申請成功, 其他負值-中斷申請失敗
 */
int request_irq(unsigned int irq,  
               irq_handler_t handler,  
               unsigned long flags, 
                  const char *name,  
                        void *dev)

flags中斷標志，有下面幾種類型

中斷標志	描述
IRQF_SHARED	多個設備共享一個中斷線，共享的所有中斷都必須指定此標志
IRQF_ONESHOT	單次中斷，中斷執行一次就結束
IRQF_TRIGGER_NONE	無觸發
IRQF_TRIGGER_RISING	上升沿觸發
IRQF_TRIGGER_FALLING	下降沿觸發
IRQF_TRIGGER_HIGH	高電平觸發
IRQF_TRIGGER_LOW	低電平觸發

1.3.2 free_irq中斷釋放函數

/**
 * irq: 要釋放中斷的中斷號
 * dev: 設備結構體
 * return: 無
 */
void free_irq(unsigned int irq,  
                      void *dev)

1.3.3 irq_handler_t中斷處理函數

/**
 * int: 要處理的中斷號
 * void *: 通用指針, 需要與request_irq函數的dev參數保持一致
 * return: irqreturn_t枚舉類型
 */
irqreturn_t (*irq_handler_t) (int, void *)

irqreturn_t枚舉類型定義：

enum irqreturn { 
	IRQ_NONE          = (0 << 0), 
    IRQ_HANDLED       = (1 << 0), 
	IRQ_WAKE_THREAD   = (1 << 1), 
}; 

typedef enum irqreturn irqreturn_t;

1.3.4 中斷使能/禁用函數

/**
 * int: 要使能的中斷號
 */
void enable_irq(unsigned int irq) 
    
/**
 * int: 要禁用的中斷號
 */
void disable_irq(unsigned int irq)

1.3.5 獲取中斷號

使用中斷時，中斷信息先寫到了設備樹里面，然后通過irq_of_parse_and_map函數從interupts屬性中提取到對應的中斷號

/**
 * dev: 設備節點
 * index: 索引號
 * return: 中斷號
 */
unsigned int irq_of_parse_and_map(struct device_node *dev, 
                                                 int index)

2 軟件編寫

仍使用上篇按鍵實驗中用到的兩個按鍵：

為了理解簡單，本次程序暫不實現中斷的下半部邏輯，直接將整個中斷處理過程都放到中斷的上半部中處理。

2.1 修改設備樹文件

在上篇key實驗代碼的基礎上，修改imx6ull-myboard.dts，主要是修改key子節點，添加中斷，修改后內容如下：

key { 
    #address-cells = <1>; 
    #size-cells = <1>; 
    compatible = "myboard-irq-key"; 
    pinctrl-names = "default"; 
    pinctrl-0 = <&pinctrl_key>; 
    key1-gpio = <&gpio5 1 GPIO_ACTIVE_HIGH>;   /* SW2 */
    key2-gpio = <&gpio5 11 GPIO_ACTIVE_LOW>;   /* SW4 */
    interrupt-parent = <&gpio5>; 
    interrupts = <  1 IRQ_TYPE_EDGE_BOTH
                   11 IRQ_TYPE_EDGE_BOTH >;
    status = "okay"; 
};

2.2 按鍵中斷驅動程序

2.2.1 硬件初始化與中斷配置

static int keyio_init(void)
{
    unsigned char i = 0;
    int ret = 0;
    
    /* 設備樹中獲取key節點 */
    imx6uirq.nd = of_find_node_by_path("/key");
    if (imx6uirq.nd== NULL)
    {
        printk("key node not find!\r\n");
        return -EINVAL;
    } 

    /* 提取GPIO */
    imx6uirq.irqkeydesc[0].gpio = of_get_named_gpio(imx6uirq.nd ,"key1-gpio", 0);
    imx6uirq.irqkeydesc[1].gpio = of_get_named_gpio(imx6uirq.nd ,"key2-gpio", 0);
    if ((imx6uirq.irqkeydesc[0].gpio < 0)||(imx6uirq.irqkeydesc[1].gpio < 0))
    {
        printk("can't get key\r\n");
        return -EINVAL;
    }
    printk("key1_gpio=%d, key2_gpio=%d\r\n", imx6uirq.irqkeydesc[0].gpio, imx6uirq.irqkeydesc[1].gpio);
    
    /* 初始化key所使用的IO，并且設置成中斷模式 */
    for (i = 0; i < KEY_NUM; i++)
    {
        memset(imx6uirq.irqkeydesc[i].name, 0, sizeof(imx6uirq.irqkeydesc[i].name)); /* 緩沖區清零 */
        sprintf(imx6uirq.irqkeydesc[i].name, "key%d", i+1); /* 組合名字 */
        gpio_request(imx6uirq.irqkeydesc[i].gpio, imx6uirq.irqkeydesc[i].name);
        gpio_direction_input(imx6uirq.irqkeydesc[i].gpio);    
        imx6uirq.irqkeydesc[i].irqnum = irq_of_parse_and_map(imx6uirq.nd, i); /* 取到對應的中斷號 */

        printk("key%d:gpio=%d, irqnum=%d\r\n",i+1,
                                              imx6uirq.irqkeydesc[i].gpio, 
                                              imx6uirq.irqkeydesc[i].irqnum);
    }
    /* 申請中斷 */
    imx6uirq.irqkeydesc[0].handler = key1_handler;
    imx6uirq.irqkeydesc[1].handler = key2_handler;
    imx6uirq.irqkeydesc[0].value = KEY1VALUE;
    imx6uirq.irqkeydesc[1].value = KEY2VALUE;
    
    for (i = 0; i < KEY_NUM; i++)
    {
        /* 中斷請求函數 */
        ret = request_irq(imx6uirq.irqkeydesc[i].irqnum,
                          imx6uirq.irqkeydesc[i].handler,
                          IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,
                          imx6uirq.irqkeydesc[i].name,
                          &imx6uirq);
        if(ret < 0)
        {
            printk("irq %d request failed!\r\n", imx6uirq.irqkeydesc[i].irqnum);
            return -EFAULT;
        }
    }

    /* 創建定時器 */
    init_timer(&imx6uirq.timer1);
    imx6uirq.timer1.function = timer1_function;
    init_timer(&imx6uirq.timer2);
    imx6uirq.timer2.function = timer2_function;
    return 0;
}

中斷檢測到按鍵按下后，為了消除按鍵抖動，這里使用定時器來進行按鍵消抖，因為本次實驗用到兩個按鍵，所以就先也使用兩個定時器。

2.2.2 中斷服務函數

static irqreturn_t key1_handler(int irq, void *dev_id)
{
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;

    dev->timer1.data = (volatile long)dev_id;
    mod_timer(&dev->timer1, jiffies + msecs_to_jiffies(10)); /* 10ms定時 */
    
    return IRQ_RETVAL(IRQ_HANDLED);
}

中斷函數檢測到按鍵按下后，會開啟一個10ms的定時器，用來按鍵消抖。

2.2.3 定時器服務函數

定時器的10ms到達之后，會觸發定時器服務函數，此時再次讀取按鍵的值，若仍為按下，則是按鍵真的按下了，若10ms后又檢測不到按鍵了，則說明是按鍵抖動導致的按鍵誤觸發。

void timer1_function(unsigned long arg)
{
    unsigned char value;
    struct irq_keydesc *keydesc;
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg;

    keydesc = &dev->irqkeydesc[0];

    value = gpio_get_value(keydesc->gpio); /* 讀取IO值 */
    if(value == 1) /* 按下按鍵 */
    {
        printk("get key1: high\r\n");
        atomic_set(&dev->keyvalue, keydesc->value);
    }
    else /* 按鍵松開 */
    {
        printk("key1 release\r\n");
        atomic_set(&dev->keyvalue, 0x80 | keydesc->value);
        atomic_set(&dev->releasekey, 1); /* 標記松開按鍵，即完成一次完整的按鍵過程 */            
    }    
}

2.2.4 按鍵讀取函數

static ssize_t imx6uirq_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    int ret = 0;
    unsigned char keyvalue = 0;
    unsigned char releasekey = 0;
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;

    keyvalue = atomic_read(&dev->keyvalue);
    releasekey = atomic_read(&dev->releasekey);

    if (releasekey) /* 有按鍵按下 */
    {
        //printk("releasekey!\r\n");
        if (keyvalue & 0x80)
        {
            keyvalue &= ~0x80;
            ret = copy_to_user(buf, &keyvalue, sizeof(keyvalue));
        }
        else
        {
            goto data_error;
        }
        atomic_set(&dev->releasekey, 0); /* 按下標志清零 */
    }
    else
    {
        goto data_error;
    }
    return 0;
    
data_error:
    return -EINVAL;
}