1. #include <linux/init.h>
    2. #include <linux/module.h>
    3. #include <linux/fs.h>
    4. #include <linux/kernel.h>
    5. #include <asm/io.h>
    6. #include <asm/uaccess.h>
    7. #include <linux/device.h>
    8. #include <linux/gpio.h>
    9. #include <linux/irq.h>
    10. #include <linux/interrupt.h>
    11. #include <linux/poll.h>
    12. #include <asm-generic/errno-base.h>
    13. #include <linux/input.h>
    14. #include <linux/of_irq.h>
    16. //描述按键信息的数据结构
    17. struct key_resource {
    18.     char *name;
    19.     int irq;
    20.     int gpio;
    21.     int code;
    22. };
    24. //保存按键的硬件信息，全局化
    25. static struct key_resource *pKeyData = NULL;
    27. //定义一个按键去抖动的定时器
    28. static struct timer_list key_timer;
    30. //新建一个输入子系统的设备结构
    31. static struct input_dev *keys_input;
    33. //定义初始化按键硬件信息的对象
    34. static struct key_resource key_info[] = {
    35.     {
    36.         .name = "KEY_ENTER",
    37.         //.irq = IRQ_EXT0,
    38.         .gpio = NUC970_PG14,
    39.         .code = KEY_ENTER
    40.     },
    42.     {
    43.         .name = "KEY_CANCEL",
    44.         //.irq = IRQ_EXT0,
    45.         .gpio = NUC970_PG13,
    46.         .code = KEY_CANCEL
    47.     },
    49.     {
    50.         .name = "KEY_UP",
    51.         //.irq = IRQ_EXT0,
    52.         .gpio = NUC970_PG12,
    53.         .code = KEY_UP
    54.     },
    56.     {
    57.         .name = "KEY_DOWN",
    58.         //.irq = IRQ_EXT0,
    59.         .gpio = NUC970_PG11,
    60.         .code = KEY_DOWN
    61.     },
    62. };
    64. //中断处理函数
    65. static irqreturn_t key_isr(int irq, void *dev)
    66. {
    67.     //获取按键信息
    68.     pKeyData = (struct key_resource *)dev;
    70.     //启动定时器
    71.     mod_timer(&key_timer, msecs_to_jiffies(10));
    73.     return IRQ_HANDLED;
    74. }
    76. //定时器的超时处理函数
    77. static void key_timer_function(unsigned long data)
    78. {
    79.     unsigned int pin_val;
    81.     if (NULL == pKeyData) {
    82.         return;
    83.     } else {
    84.         printk("key:%s\n", pKeyData->name);
    86.         pin_val = gpio_get_value(pKeyData->gpio);
    87.         if (!pin_val) {
    88.             input_event(keys_input, EV_KEY, pKeyData->code, 0);
    89.             input_sync(keys_input);
    90.         }
    91.     }
    92. }
    94. static int key_init(void)
    95. {
    96.     int i,ret,irqno, cnt;
    98.     //分配一个keys_input结构体
    99.     keys_input = input_allocate_device();
    100.     if (!keys_input)
    101.     {
    102.         printk("%s %s LINE: %d alloc input failed!!!\n",__FILE__, __FUNCTION__, __LINE__);
    103.         return -ENOMEM;
    104.     }
    106.     //设置输入事件类型
    107.     set_bit(EV_KEY, keys_input->evbit);
    108.     set_bit(EV_REP, keys_input->evbit);
    110.     //输入事件类型的哪一种
    111.     set_bit(KEY_ENTER, keys_input->keybit);
    112.     set_bit(KEY_CANCEL, keys_input->keybit);
    113.     set_bit(KEY_UP, keys_input->keybit);
    114.     set_bit(KEY_DOWN, keys_input->keybit);
    116.     //注册
    117.     ret = input_register_device(keys_input);
    118.     if (ret) {
    119.         printk("%s %s LINE:%d failed to register input device\n",__FILE__, __FUNCTION__, __LINE__);
    120.         return -1;
    121.     }
    123.     cnt = 0;
    124.     for (i=0; i < ARRAY_SIZE(key_info); i++) {
    125.         ret = gpio_request(key_info[i].gpio, key_info[i].name);
    126.         if (ret) {
    127.                printk("Request GPIO = %d failed, ret = %d\n", key_info[i].gpio, ret);
    128.             goto fail;
    129.         }
    131.         irqno = gpio_to_irq(key_info[i].gpio);
    132.         key_info[i].irq = irqno;
    134.         ret = request_irq(key_info[i].irq, key_isr, IRQF_TRIGGER_FALLING,
    135.                           key_info[i].name, &key_info[i]);
    136.         if (ret) {
    137.             printk("GPIO = %d, request irq failed, ret = %d\n", key_info[i].gpio, ret);
    138.             goto fail;
    139.         }
    140.         cnt++;
    141.     }
    143.     init_timer(&key_timer);
    144.     key_timer.function = key_timer_function;
    145.     printk("Add ZKS Key SUCCESSS!!!");
    146.     return 0;
    147. fail:
    148.     input_free_device(keys_input);
    149.     for (i =0; i < cnt; i++) {
    150.         gpio_free(key_info[i].gpio);
    151.         free_irq(key_info[i].irq, &key_info[i]);
    152.     }
    153.     return ret;
    154. }
    156. static void key_exit(void)
    157. {
    158.     int i;
    160.     input_free_device(keys_input);
    161.     for (i = 0; i < ARRAY_SIZE(key_info); i++) {
    162.         gpio_free(key_info[i].gpio);
    163.         free_irq(key_info[i].irq, &key_info[i]);
    164.     }
    165. }
    167. module_init(key_init);
    168. module_exit(key_exit);
    169. MODULE_LICENSE("GPL");