2. GPIO按键中断

任务目标

在RK3588平台上编写Linux内核驱动，将GPIO按键配置为中断触发模式，在中断处理函数中记录按键事件并通过miscdevice向用户空间提供读取接口。用户程序通过读取设备节点获取按键状态（按下/释放）及触发次数。

环境依赖

  • RK3588 Linux内核源码树（本案例基于内核5.10版本）
  • 交叉编译工具链：aarch64-linux-gnu-gcc
  • 开发板系统：Ubuntu 20.04+（RK3588 EVB）

硬件连接

按键连接至GPIO3_B5（对应引脚编号：3*32 + 1*8 + 5 = 109），按下时接地（低电平有效），需启用内部上拉。请根据实际板卡原理图确认GPIO编号，本例以RK3588 EVB上可用的GPIO3_B5为例。

关键完整代码

// gpio_key_irq.c
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/gpio/consumer.h>
#include <linux/interrupt.h>
#include <linux/miscdevice.h>
#include <linux/uaccess.h>
#include <linux/atomic.h>

#define KEY_IRQ_GPIO  109   /* GPIO3_B5 */
#define KEY_PRESS      0x01
#define KEY_RELEASE    0x00

static struct gpio_desc *key_gpio;
static int key_irq;
static atomic_t press_count = ATOMIC_INIT(0);
static atomic_t last_state = ATOMIC_INIT(KEY_RELEASE);

static irqreturn_t key_irq_handler(int irq, void *dev_id)
{
    int val = gpiod_get_value(key_gpio);
    /* 消抖：等待20ms后再次确认电平 */
    usleep_range(20000, 25000);
    val = gpiod_get_value(key_gpio);

    if (val == 0) {  /* 按下（低电平） */
        atomic_set(&last_state, KEY_PRESS);
        atomic_inc(&press_count);
    } else {
        atomic_set(&last_state, KEY_RELEASE);
    }
    return IRQ_HANDLED;
}

static ssize_t key_read(struct file *file, char __user *buf,
                        size_t count, loff_t *ppos)
{
    char kbuf[32];
    int len;

    if (*ppos != 0)
        return 0;

    len = snprintf(kbuf, sizeof(kbuf), "%d %d\n",
                   atomic_read(&last_state),
                   atomic_read(&press_count));
    if (copy_to_user(buf, kbuf, len))
        return -EFAULT;

    *ppos = len;
    return len;
}

static const struct file_operations key_fops = {
    .owner = THIS_MODULE,
    .read = key_read,
};

static struct miscdevice key_miscdev = {
    .minor = MISC_DYNAMIC_MINOR,
    .name = "gpio_key",
    .fops = &key_fops,
};

static int key_probe(struct platform_device *pdev)
{
    int ret;

    key_gpio = gpio_to_desc(KEY_IRQ_GPIO);
    if (!key_gpio) {
        pr_err("Failed to get GPIO %d\n", KEY_IRQ_GPIO);
        return -EINVAL;
    }

    ret = gpiod_direction_input(key_gpio);
    if (ret) {
        pr_err("Failed to set GPIO direction\n");
        return ret;
    }

    ret = gpiod_set_debounce(key_gpio, 20000); /* 硬件消抖20ms */
    if (ret && ret != -ENOTSUPP)
        pr_warn("Debounce not supported, use software debounce\n");

    key_irq = gpiod_to_irq(key_gpio);
    if (key_irq < 0) {
        pr_err("Failed to map GPIO to IRQ\n");
        return key_irq;
    }

    ret = request_irq(key_irq, key_irq_handler,
                      IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
                      "gpio_key", NULL);
    if (ret) {
        pr_err("Failed to request IRQ %d\n", key_irq);
        return ret;
    }

    ret = misc_register(&key_miscdev);
    if (ret) {
        pr_err("Failed to register misc device\n");
        free_irq(key_irq, NULL);
        return ret;
    }

    pr_info("GPIO key driver probed, IRQ=%d\n", key_irq);
    return 0;
}

static int key_remove(struct platform_device *pdev)
{
    free_irq(key_irq, NULL);
    misc_deregister(&key_miscdev);
    return 0;
}

static const struct of_device_id key_of_match[] = {
    { .compatible = "rk3588,gpio-key-irq" },
    { }
};
MODULE_DEVICE_TABLE(of, key_of_match);

static struct platform_driver key_driver = {
    .probe = key_probe,
    .remove = key_remove,
    .driver = {
        .name = "gpio_key_irq",
        .of_match_table = key_of_match,
    },
};
module_platform_driver(key_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("RK3588 Driver Course");
MODULE_DESCRIPTION("GPIO Key Interrupt Driver for RK3588");

设备树配置

/* 在板级dts中添加 */
gpio_key_irq {
    compatible = "rk3588,gpio-key-irq";
    status = "okay";
};

编译与加载

# 1. 将驱动源码放入内核 drivers/misc/ 目录，并修改Kconfig/Makefile
# 2. 编译内核模块
make ARCH=arm64 CROSS_COMPILE=aarch64-linux-gnu- M=drivers/misc modules

# 3. 将生成的 gpio_key_irq.ko 拷贝到开发板，加载模块
insmod gpio_key_irq.ko

# 4. 确认设备节点生成
ls -l /dev/gpio_key

用户空间测试程序

// test_key.c
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

int main(void)
{
    int fd = open("/dev/gpio_key", O_RDONLY);
    if (fd < 0) {
        perror("open");
        return 1;
    }

    char buf[32];
    int state, count;
    while (1) {
        ssize_t n = read(fd, buf, sizeof(buf) - 1);
        if (n > 0) {
            buf[n] = '\0';
            sscanf(buf, "%d %d", &state, &count);
            printf("Key state: %s, press count: %d\n",
                   state ? "PRESSED" : "RELEASED", count);
        }
        usleep(100000); /* 100ms轮询 */
    }
    close(fd);
    return 0;
}

验证方法

  1. 编译并加载驱动后，确认内核日志出现 GPIO key driver probed 且 /dev/gpio_key 节点存在。
  2. 编译运行测试程序：gcc test_key.c -o test_key && ./test_key
  3. 手动按下并释放按键，观察程序输出：按下时显示 PRESSED，释放时显示 RELEASED，且计数递增。
  4. 判定通过标准：每次按下/释放操作均能在100ms内正确反映状态变化，且计数与按压次数一致。

常见问题

  • IRQ申请失败：确认GPIO编号正确且该引脚未被其他驱动占用，检查dts中pinctrl配置。
  • 按键无响应：检查按键接线是否连接至上拉电源，或改用 gpiod_set_value_cansleep 测试GPIO输出功能确认引脚可用。
  • 中断频繁触发：若硬件无RC滤波，需增大软件消抖延时（当前20ms），或检查按键是否存在机械抖动。
← 上一章 📖 返回目录 下一章 →