讯为ITOP4412的按键驱动分析

一、前言

安卓上用得比较多的按键有：home，back，power，volup，voldown，原理图如下：

程序里面只要检测到低电平就能知道按键按下了。但是程序是如何实现的呢？下面一步步去揭开其神秘的面纱。

二、按键驱动位置

按键驱动位置：drivers/input/keyboard/gpio_keys.c
按键IO定义位置：arch/arm/mach-exynos/mach-itop4412.c

三、按键驱动分析

1.按键驱动功能概括

2.注册按键驱动

static int __devinit gpio_keys_probe(struct platform_device *pdev)
{
    struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;
    struct gpio_keys_drvdata *ddata;
    struct device *dev = &pdev->dev;
    struct input_dev *input;
    int i, error;
    int wakeup = 0;

    ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +
            pdata->nbuttons * sizeof(struct gpio_button_data),
            GFP_KERNEL);
    input = input_allocate_device();
    if (!ddata || !input) {
        dev_err(dev, "failed to allocate state\n");
        error = -ENOMEM;
        goto fail1;
    }

    ddata->input = input;
    ddata->n_buttons = pdata->nbuttons;
    ddata->enable = pdata->enable;
    ddata->disable = pdata->disable;
    mutex_init(&ddata->disable_lock);

    platform_set_drvdata(pdev, ddata);
    input_set_drvdata(input, ddata);

    input->name = pdata->name ? : pdev->name;
    input->phys = "gpio-keys/input0";
    input->dev.parent = &pdev->dev;
    input->open = gpio_keys_open;
    input->close = gpio_keys_close;

    input->id.bustype = BUS_HOST;
    input->id.vendor = 0x0001;
    input->id.product = 0x0001;
    input->id.version = 0x0100;

    /* Enable auto repeat feature of Linux input subsystem */
    if (pdata->rep)
        __set_bit(EV_REP, input->evbit);

    for (i = 0; i < pdata->nbuttons; i++) {
        struct gpio_keys_button *button = &pdata->buttons[i];
        struct gpio_button_data *bdata = &ddata->data[i];
        unsigned int type = button->type ?: EV_KEY;

        bdata->input = input;
        bdata->button = button;

        error = gpio_keys_setup_key(pdev, bdata, button);
        if (error)
            goto fail2;

        if (button->wakeup)
            wakeup = 1;

        input_set_capability(input, type, button->code);
    }

    error = sysfs_create_group(&pdev->dev.kobj, &gpio_keys_attr_group);
    if (error) {
        dev_err(dev, "Unable to export keys/switches, error: %d\n",
            error);
        goto fail2;
    }
    /*注册输入设备*/
    error = input_register_device(input);
    if (error) {
        dev_err(dev, "Unable to register input device, error: %d\n",
            error);
        goto fail3;
    }

    /* get current state of buttons */
    for (i = 0; i < pdata->nbuttons; i++)
        gpio_keys_report_event(&ddata->data[i]);
    input_sync(input);

    device_init_wakeup(&pdev->dev, wakeup);

    return 0;

 fail3:
    sysfs_remove_group(&pdev->dev.kobj, &gpio_keys_attr_group);
 fail2:
    while (--i >= 0) {
        free_irq(gpio_to_irq(pdata->buttons[i].gpio), &ddata->data[i]);
        if (ddata->data[i].timer_debounce)
            del_timer_sync(&ddata->data[i].timer);
        cancel_work_sync(&ddata->data[i].work);
        gpio_free(pdata->buttons[i].gpio);
    }

    platform_set_drvdata(pdev, NULL);
 fail1:
    input_free_device(input);
    kfree(ddata);

    return error;
}

3.获取按键资源

static int __devinit gpio_keys_setup_key(struct platform_device *pdev,
                     struct gpio_button_data *bdata,
                     struct gpio_keys_button *button)
{
    const char *desc = button->desc ? button->desc : "gpio_keys";
    struct device *dev = &pdev->dev;
    unsigned long irqflags;
    int irq, error;

    setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata);
    INIT_WORK(&bdata->work, gpio_keys_work_func);
    /*获取按键资源，desc="gpio_keys",这个按键资源其实定义在mach-itop4412.c文件的gpio_buttons数组里*/
    error = gpio_request(button->gpio, desc);
    if (error < 0) {
        dev_err(dev, "failed to request GPIO %d, error %d\n",
            button->gpio, error);
        goto fail2;
    }

    error = gpio_direction_input(button->gpio);
    if (error < 0) {
        dev_err(dev, "failed to configure"
            " direction for GPIO %d, error %d\n",
            button->gpio, error);
        goto fail3;
    }

    if (button->debounce_interval) {
        error = gpio_set_debounce(button->gpio,
                      button->debounce_interval * 1000);
        /* use timer if gpiolib doesn't provide debounce */
        if (error < 0)
            bdata->timer_debounce = button->debounce_interval;
    }

    irq = gpio_to_irq(button->gpio);
    if (irq < 0) {
        error = irq;
        dev_err(dev, "Unable to get irq number for GPIO %d, error %d\n",
            button->gpio, error);
        goto fail3;
    }

    irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;
    /*
     * If platform has specified that the button can be disabled,
     * we don't want it to share the interrupt line.
     */
    if (!button->can_disable)
        irqflags |= IRQF_SHARED;

    error = request_any_context_irq(irq, gpio_keys_isr, irqflags, desc, bdata);
    if (error < 0) {
        dev_err(dev, "Unable to claim irq %d; error %d\n",
            irq, error);
        goto fail3;
    }

    return 0;

fail3:
    gpio_free(button->gpio);
fail2:
    return error;
}