linux核心有中斷函數嗎

#include <linux/types.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/fs.h>
#include <linux/ide.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/errno.h> 
#include <linux/gpio.h>
#include <linux/of_gpio.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_irq.h>
#include <asm/mach/map.h>
#include <linux/timer.h>
#include <linux/jiffies.h>

#define IMX6UIRQ_CNT            1               /* 裝置號個數 */
#define IMX6UIRQ_NAME           "irqDev"        /* 名字 */
#define KEY0VALUE               0X01            /* KEY0 按鍵值 */
#define INVAKEY                 0XFF            /* 無效的按鍵值 */
#define KEY_NUM                 1               /* 按鍵數量 */

/* 可能會有好多按鍵，通過結構體陣列來描述按鍵 */
/* 中斷 IO 描述結構體 */
struct irq_keydesc {
    int gpio;                               /* gpio */
    int irqnum;                             /* 中斷號 */
    unsigned char value;                    /* 按鍵對應的鍵值 */
    char name[10];                          /* 名字 */
    irqreturn_t (*handler)(int, void *);    /* 中斷服務函數 */
};

/* irq裝置結構體 */
struct imx6uirq_dev {
    dev_t               devid;          /* 裝置號 */
    struct cdev         cdev;           /* 字元裝置 */
    struct class        *class;         /* 類 */
    struct device       *device;        /* 裝置 */
    int                 major;          /* 注裝置號 */
    int                 minor;          /* 次裝置號 */
    struct device_node  *nd;            /* 裝置節點 */

    atomic_t            keyvalue;       /* 有效的按鍵鍵值 */
    atomic_t            releasekey;     /* 標記是否完成一次完成的按鍵*/
    struct timer_list   timer;          /* 定義一個定時器*/
    struct irq_keydesc  irqkeydesc[KEY_NUM]; /* 按鍵描述陣列 */
    unsigned char       curkeynum;      /* 當前的按鍵號 */
};

struct imx6uirq_dev  irqDev; /* 定義LED結構體 */

/* @description : 中斷服務函數，開啟定時器，延時 10ms，
* 定時器用於按鍵消抖。
* 兩個引數是中斷處理常式的必須寫法
* @param - irq : 中斷號
* @param - dev_id : 裝置結構。
* @return : 中斷執行結果
*/
static irqreturn_t key0_handler(int irq, void *dev_id)
{
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;

    /* 採用定時器削抖，如果再定時器時間內還是這個值，說明是真的按下了，在定時器中斷中處理 */
    /* 這裡設定為0是簡易處理，因為只有一個按鍵 */
    /* 有其他按鍵要再建一箇中斷處理常式，並把curkeynum改成相應的按鍵值 */
    /* 注意不能所有按鍵用一箇中斷函數，第一是一起按的時候會出錯 */
    /* 第二，無法用curkeynum判斷使用的是第幾個按鍵 */
    dev->curkeynum = 0;
    /* 傳遞給定時器的引數，注意要強轉，在中斷處理常式裡面再轉回來 */
    dev->timer.data = (volatile long)dev_id;
    /* mod_timer會啟動定時器，第二個引數是要修改的超時時間 */
    mod_timer(&dev->timer, jiffies + msecs_to_jiffies(10));
    return IRQ_RETVAL(IRQ_HANDLED);
}

 /* @description : 定時器服務函數，用於按鍵消抖，定時器到了以後
* 再次讀取按鍵值，如果按鍵還是處於按下狀態就表示按鍵有效。
* @param – arg : 裝置結構變數
* @return : 無
*/
void timer_function(unsigned long arg)
{
    unsigned char value;
    unsigned char num;
    struct irq_keydesc *keydesc;
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)arg; 

    /* 因為只有一個按鍵，這裡是0 */
    num = dev->curkeynum;
    keydesc = &dev->irqkeydesc[num]; 
    value = gpio_get_value(keydesc->gpio); /* 讀取 IO 值 */

    if(value == 0){ /* 按下按鍵 */
        atomic_set(&dev->keyvalue, keydesc->value);
    }
    else{ /* 按鍵鬆開 */
        /* 這種情況是按下再鬆開的鬆開，使用keyValue加上releaseKey */
        /* 沒按下的話， releasekey一直為0*/
        atomic_set(&dev->keyvalue, 0x80 | keydesc->value);
        atomic_set(&dev->releasekey, 1); /* 標記鬆開按鍵 */ 
    } 
}

/*
* @description : 按鍵 IO 初始化
* @param : 無
* @return : 無
*/
static int keyio_init(void)
{
    unsigned char i = 0;

    int ret = 0;

    /* 1.獲取key節點 */
    irqDev.nd = of_find_node_by_path("/key");
    if (irqDev.nd== NULL){
        printk("key node not find!\r\n");
        return -EINVAL;
    }
    /* 對每個按鍵都提取 GPIO */
    for (i = 0; i < KEY_NUM; i++) {
        irqDev.irqkeydesc[i].gpio = of_get_named_gpio(irqDev.nd, "key-gpios", i);
        if (irqDev.irqkeydesc[i].gpio < 0) {
            printk("can't get key%d\r\n", i);
        }
    }

    /* 初始化 key 所使用的 IO，並且設定成中斷模式 */
    for (i = 0; i < KEY_NUM; i++) {
        /* 先對每一個IO命名 */
        /* 先對命名清0 */
        memset(irqDev.irqkeydesc[i].name, 0, sizeof(irqDev.irqkeydesc[i].name)); 
        /* 給IO命名 */
        sprintf(irqDev.irqkeydesc[i].name, "KEY%d", i); 
        /* 請求GPIO */
        gpio_request(irqDev.irqkeydesc[i].gpio, irqDev.irqkeydesc[i].name);
        
        /* 設定GPIO為輸入 */
        gpio_direction_input(irqDev.irqkeydesc[i].gpio); 

        /* 獲取中斷號，以下為兩個方法，都可以獲取到 */
        /* 從interrupts屬性裡面獲取 */
        /* 注意i是根據裝置樹裡面設定了多少個就是多少個，都會獲取到 */
        /* 下面的方法是通用的獲取中斷號的函數 */
        irqDev.irqkeydesc[i].irqnum = irq_of_parse_and_map(irqDev.nd, i);
#if 0
        /* 此方法是gpio獲取中斷號的方法 */
        irqDev.irqkeydesc[i].irqnum = gpio_to_irq(irqDev.irqkeydesc[i].gpio);
#endif
        printk("key%d:gpio=%d, irqnum=%d\r\n", i, irqDev.irqkeydesc[i].gpio,
                                                  irqDev.irqkeydesc[i].irqnum);
    }

    /* 2. 按鍵中斷初始化 */
    /* 設定中斷處理常式和按鍵初始值 */
    /* 因為只有一個key0.，所以這裡也沒用迴圈 */
    irqDev.irqkeydesc[0].handler = key0_handler;
    irqDev.irqkeydesc[0].value = KEY0VALUE;
     /* 申請中斷 */
    for (i = 0; i < KEY_NUM; i++) {
        /* request_irq引數
         * 中斷號，中斷函數，中斷觸發型別，中斷名字，傳遞給中斷處理常式的引數（第二個），這裡傳的結構體
         * */
        ret = request_irq(irqDev.irqkeydesc[i].irqnum, irqDev.irqkeydesc[i].handler,
                        IRQF_TRIGGER_FALLING|IRQF_TRIGGER_RISING,
                        irqDev.irqkeydesc[i].name, &irqDev);
        if(ret < 0){
            printk("irq %d request failed!\r\n", irqDev.irqkeydesc[i].irqnum);
            return -EFAULT;
        }
    }

    /* 3. 建立定時器 */
    init_timer(&irqDev.timer);
    irqDev.timer.function = timer_function;
    /* 注意下面不能讓定時器執行，因為要按下按鍵之後再執行 */
    /* 啟動定時器通過mod_timer啟動，通常在初始化階段的定時器用的是add_timer */
    return 0;
}


static int imx6uirq_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &irqDev;
    return 0;
}

static int imx6uirq_release(struct inode *inode, struct file *filp)
{
    //struct imx6uirq_dev  *dev = (struct imx6uirq_dev  *)filp->private_data;
    return 0;
}

 /*
* @description : 從裝置讀取資料
* @param – filp : 要開啟的裝置檔案(檔案描述符)
* @param – buf : 返回給使用者空間的資料緩衝區
* @param - cnt : 要讀取的資料長度
* @param – offt : 相對於檔案首地址的偏移
* @return : 讀取的位元組數，如果為負值，表示讀取失敗
*/
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) { /* 有按鍵按下 */
        if (keyvalue & 0x80) {
            keyvalue &= ~0x80; /* 因為中斷中或了一個0x80,這裡面去掉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;
}

/* 字元裝置操作集 */
static const struct file_operations imx6uirq_fops = {
    .owner = THIS_MODULE,
    .open = imx6uirq_open,
    .release = imx6uirq_release,
    .read = imx6uirq_read
};

/* 模組入口函數 */
static int __init imx6uirq_init(void)
{
    /* 定義一些所需變數 */
    int ret = 0;

    /* 1. 註冊字元裝置驅動 */
    irqDev.major = 0;
    if(irqDev.major) {
        irqDev.devid = MKDEV(irqDev.major, 0);
        ret = register_chrdev_region(irqDev.devid, IMX6UIRQ_CNT, IMX6UIRQ_NAME );  
    } else {
        alloc_chrdev_region(&irqDev.devid, 0, IMX6UIRQ_CNT, IMX6UIRQ_NAME );
        irqDev.major = MAJOR(irqDev.devid);
        irqDev.minor = MINOR(irqDev.devid);
    }
    if(ret < 0){
        goto fail_devid;
    }
    printk("Make devid success! \r\n");
    printk("major = %d, minor = %d \r\n", irqDev.major, irqDev.minor);

    /* 2. 初始化cdev */
    irqDev.cdev.owner = THIS_MODULE;
    cdev_init(&irqDev.cdev, &imx6uirq_fops);
    ret = cdev_add(&irqDev.cdev, irqDev.devid, IMX6UIRQ_CNT);
    if (ret < 0){
        goto fail_cdev;
    } else {
        printk("Cdev add sucess! \r\n");
    }

    /* 3. 自動建立裝置節點 */
    irqDev.class = class_create(THIS_MODULE, IMX6UIRQ_NAME );
    if(IS_ERR(irqDev.class)) {
        ret = PTR_ERR(irqDev.class);
        goto fail_class;
    } else {
        printk("Class create sucess! \r\n");
    }

    irqDev.device = device_create(irqDev.class, NULL, irqDev.devid, NULL, IMX6UIRQ_NAME );
    if(IS_ERR(irqDev.device)) {
        ret = PTR_ERR(irqDev.device);
        goto fail_device;
    } else {
        printk("Device create sucess! \r\n");
    }

    /* 4.初始化按鍵 */
    atomic_set(&irqDev.keyvalue, INVAKEY);
    atomic_set(&irqDev.releasekey, 0);
    keyio_init();

    printk("irqDev init! \r\n");
    return 0;

/* 錯誤處理 */
fail_device:
    class_destroy(irqDev.class);
fail_class:
    cdev_del(&irqDev.cdev);
fail_cdev:
    unregister_chrdev_region(irqDev.devid, IMX6UIRQ_CNT);
fail_devid:
    return ret;
}

/* 模組出口函數 */
static void __exit imx6uirq_exit(void)
{
    unsigned int i = 0;
    /* 刪除定時器 */
    del_timer_sync(&irqDev.timer); 

    /* 釋放中斷 */
    for (i = 0; i < KEY_NUM; i++) {
        free_irq(irqDev.irqkeydesc[i].irqnum, &irqDev);
    }

    /* 1. 釋放裝置號 */
    cdev_del(&irqDev.cdev);
    /* 2. 登出裝置號 */
    unregister_chrdev_region(irqDev.devid, IMX6UIRQ_CNT);
    /* 3. 摧毀裝置 */
    device_destroy(irqDev.class, irqDev.devid);
    /* 4.摧毀類 */
    class_destroy(irqDev.class);


    printk("irqDev exit! \r\n");
}

/* 模組入口和出口註冊 */
module_init(imx6uirq_init);
module_exit(imx6uirq_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Shao Zheming");