i.MX53 GPIO 按键驱动

Freescale i.MX53 GPIO 按键驱动

硬件平台：IMX53-QSB
内核版本：LINUX-2.6.35.3
系统版本：ANDROID 2.3.4

一、GPIO 的使用 

按键的处理需要读取相应 IO 引脚的值，阅读 IMX53 处理器芯片手册，得知将 GPIO 读模式大的步骤如下：
1. 通过设置 IOMUX 将相应引脚配置为 GPIO 模式，控制的寄存器是 IOMUXC_SW_MUX_CTL_PAD_XXX
2. 配置 GPIO 的方向为输入，控制的寄存器是 GPIOx_GDIR ，0表示输入，1表示输出
3. 读取相应 GPIO 引脚的值，读取的寄存器为 GPIOx_PSR

第1步，配置为 gpio 模式（以 MX53_PAD_GPIO_2__GPIO1_2 为例）

在文件 arch/arm/mach-mx5/mx53_loco.c 中
板子初始化函数 mxc_board_init 中，调用了 io 初始化函数 mx53_loco_io_init ：
static void __init mxc_board_init(void)
{
    mx53_loco_io_init();
}

mx53_loco_io_init 函数中调用 mxc_iomux_v3_setup_multiple_pads 函数配置引脚：
static void __init mx53_loco_io_init(void)
{
    mxc_iomux_v3_setup_multiple_pads(mx53_loco_pads,ARRAY_SIZE(mx53_loco_pads));
}

mx53_loco_pads 为一 u64 类型的数组：
static iomux_v3_cfg_t mx53_loco_pads[] = {
    MX53_PAD_GPIO_2__GPIO1_2, 
};

MX53_PAD_GPIO_2__GPIO1_2 定义在 arch/arm/plat-mxc/include/mach/iomux-mx53.h
#define MX53_PAD_GPIO_2__GPIO1_2  (_MX53_PAD_GPIO_2__GPIO1_2 | MUX_PAD_CTRL(NO_PAD_CTRL))

MX53_PAD_GPIO_2__GPIO1_2 由 _MX53_PAD_GPIO_2__GPIO1_2 与 MUX_PAD_CTRL(NO_PAD_CTRL) 按位或得到，
先来看 _MX53_PAD_GPIO_2__GPIO1_2 ：
#define _MX53_PAD_GPIO_2__GPIO1_2  IOMUX_PAD(0x6B8, 0x328, 1, 0x0, 0, 0)

IOMUX_PAD 的定义在 arch/arm/plat-mxc/include/mach/iomux-v3.h
#define IOMUX_PAD(_pad_ctrl_ofs, _mux_ctrl_ofs, _mux_mode, _sel_input_ofs,_sel_input, _pad_ctrl)  \
 ( ((iomux_v3_cfg_t)(_mux_ctrl_ofs) << MUX_CTRL_OFS_SHIFT) | \
 ((iomux_v3_cfg_t)(_mux_mode) << MUX_MODE_SHIFT) | \
 ((iomux_v3_cfg_t)(_pad_ctrl_ofs) << MUX_PAD_CTRL_OFS_SHIFT) | \
 ((iomux_v3_cfg_t)(_pad_ctrl) << MUX_PAD_CTRL_SHIFT) | \
 ((iomux_v3_cfg_t)(_sel_input_ofs) << MUX_SEL_INPUT_OFS_SHIFT) | \
 ((iomux_v3_cfg_t)(_sel_input) << MUX_SEL_INPUT_SHIFT) )

#define MUX_CTRL_OFS_SHIFT 0
#define MUX_PAD_CTRL_OFS_SHIFT 12
#define MUX_SEL_INPUT_OFS_SHIFT 24
#define MUX_MODE_SHIFT 36
#define MUX_PAD_CTRL_SHIFT 41
#define MUX_SEL_INPUT_SHIFT 58

那么 IOMUX_PAD 是这个样子：
 __________
 |61|60|59|58|
 _sel_input  
 __________________________________________
 |57|56|55|54|53|52|51|50|49|48|47|46|45|44|43|42|41|
                                     _pad_ctrl                        
 _____________
 |40|39|38|37|36|
  _mux_mode   
 ______________________________
 |35|34|33|32|31|30|29|28|27|26|25|24|
               _sel_input_ofs                      
 ______________________________
 |23|22|21|20|19|18|17|16|15|14|13|12|
                   _pad_ctrl_ofs                    
 ________________________
 |11|10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0|
              _mux_ctrl_ofs         

这样 _MX53_PAD_GPIO_2__GPIO1_2 即 IOMUX_PAD(0x6B8, 0x328, 1, 0x0, 0, 0) 是这个样子：
 __________
 |61|60|59|58|
          0         
 __________________________________________
 |57|56|55|54|53|52|51|50|49|48|47|46|45|44|43|42|41|
                                                0                                        
 ____________
 |40|39|38|37|36|
            1            
 ______________________________
 |35|34|33|32|31|30|29|28|27|26|25|24|
                         0x0                              
 ______________________________
 |23|22|21|20|19|18|17|16|15|14|13|12|
                               0x6B8                    
 ________________________
 |11|10| 9| 8| 7| 6| 5| 4| 3| 2| 1| 0|
                  0x328                      

再来看看 MUX_PAD_CTRL(NO_PAD_CTRL)
#define MUX_PAD_CTRL(x)  ((iomux_v3_cfg_t)(x) << MUX_PAD_CTRL_SHIFT)
#define NO_PAD_CTRL  ((iomux_v3_cfg_t)1 << (MUX_PAD_CTRL_SHIFT + 16))
这 MUX_PAD_CTRL(NO_PAD_CTRL) 将 1 左移了 98 位，代表什么意思？
这样 MX53_PAD_GPIO_2__GPIO1_2 的值就确定了。

mxc_iomux_v3_setup_multiple_pads 定义在 arch/arm/plat-mxc/iomux-v3.c ：
int mxc_iomux_v3_setup_multiple_pads(iomux_v3_cfg_t *pad_list, unsigned count)
{
    iomux_v3_cfg_t *p = pad_list;
    int i;

    /* 通过一个循环将 mx53_loco_pads 中的每个成员都使用 mxc_iomux_v3_get_pad 进行配置 */
    for (i = 0; i < count; i++) {
        mxc_iomux_v3_get_pad(p);
        p++;
    }
    return 0;
}

mxc_iomux_v3_setup_pad 函数定义：
int mxc_iomux_v3_setup_pad(iomux_v3_cfg_t pad)
{
    /* 这里的 pad 即是 mx53_loco_pads 数组中的 MX53_PAD_GPIO_2__GPIO1_2 
    * 以下 6 行即获得 MX53_PAD_GPIO_2__GPIO1_2 中的 
    * _pad_ctrl_ofs, _mux_ctrl_ofs, _mux_mode, _sel_input_ofs,_sel_input, _pad_ctrl
    */
    u32 mux_ctrl_ofs = (pad & MUX_CTRL_OFS_MASK) >> MUX_CTRL_OFS_SHIFT;       // 0x328
    u32 mux_mode = (pad & MUX_MODE_MASK) >> MUX_MODE_SHIFT;
    u32 sel_input_ofs = (pad & MUX_SEL_INPUT_OFS_MASK) >> MUX_SEL_INPUT_OFS_SHIFT;
    u32 sel_input = (pad & MUX_SEL_INPUT_MASK) >> MUX_SEL_INPUT_SHIFT;
    u32 pad_ctrl_ofs = (pad & MUX_PAD_CTRL_OFS_MASK) >> MUX_PAD_CTRL_OFS_SHIFT;
    u32 pad_ctrl = (pad & MUX_PAD_CTRL_MASK) >> MUX_PAD_CTRL_SHIFT;

    /* 将相关配置值写入相应的寄存器 */
    if (mux_ctrl_ofs)
    /* 地址偏移 0x328 的寄存器是 IOMUXC_SW_MUX_CTL_PAD_GPIO_2 ，mux_mode = 1 即为 gpio 模式 */
    __raw_writel(mux_mode, base + mux_ctrl_ofs);

    if (sel_input_ofs)
    /* 地址偏移 0x0 的寄存器是 IOMUXC_GPR0 */
    __raw_writel(sel_input, base + sel_input_ofs);

    if (!(pad_ctrl & NO_PAD_CTRL) && pad_ctrl_ofs)
    /* 地址偏移 0x6B8 的寄存器是 IOMUXC_SW_PAD_CTL_PAD_GPIO_2 */
    __raw_writel(pad_ctrl, base + pad_ctrl_ofs);

    return 0;
}

如果需要将某 IO 引脚 XXX_GPIO_XXX 设置为 GPIO 模式，将 XXX_GPIO_XXX 添加到 mx53_loco_pads 数组即可。

第2步，将 gpio 设置为输入

使用的函数为 int gpio_direction_input(unsigned gpio) 
定义在 drivers/gpio/gpiolib.c
int gpio_direction_input(unsigned gpio)
{
    unsigned long flags;
    struct gpio_chip *chip;
    struct gpio_desc *desc = &gpio_desc[gpio];
    int status = -EINVAL;

    spin_lock_irqsave(&gpio_lock, flags);

    if (!gpio_is_valid(gpio))
        goto fail;
    chip = desc->chip;
    if (!chip || !chip->get || !chip->direction_input)
        goto fail;
    gpio -= chip->base;
    if (gpio >= chip->ngpio)
        goto fail;
    status = gpio_ensure_requested(desc, gpio);
    if (status < 0)
        goto fail;

    /* now we know the gpio is valid and chip won't vanish */
    spin_unlock_irqrestore(&gpio_lock, flags);

    might_sleep_if(extra_checks && chip->can_sleep);

    if (status) {
        status = chip->request(chip, gpio);
        if (status < 0) {
            pr_debug("GPIO-%d: chip request fail, %d\n",
            chip->base + gpio, status);
            /* and it's not available to anyone else ...
            * gpio_request() is the fully clean solution.
            */
            goto lose;
        }
    } 

    status = chip->direction_input(chip, gpio);
    if (status == 0)
        clear_bit(FLAG_IS_OUT, &desc->flags);
    lose:
    return status;
    fail:
    spin_unlock_irqrestore(&gpio_lock, flags);
    if (status)
        pr_debug("%s: gpio-%d status %d\n",
    __func__, gpio, status);
    return status;
}

该函数调用了 chip->direction_input(chip, gpio);
最终调用到的是 arch/arm/plat-mxc/gpio.c 文件中的函数 mxc_gpio_direction_input ，原型如下：
static int mxc_gpio_direction_input(struct gpio_chip *chip, unsigned offset)
{
    /* 调用 _set_gpio_direction ，传递的第 3 个参数为 0 ，方向设置为输入 */
    _set_gpio_direction(chip, offset, 0);
    return 0;
}

_set_gpio_direction 函数原型：
static void _set_gpio_direction(struct gpio_chip *chip, unsigned offset,int dir)
{
    struct mxc_gpio_port *port =
        container_of(chip, struct mxc_gpio_port, chip);
    u32 l;
    unsigned long flags;

    spin_lock_irqsave(&port->lock, flags);
    l = __raw_readl(port->base + GPIO_GDIR);
    if (dir)
        l |= 1 << offset;
    else
        l &= ~(1 << offset);
    /* 传入的参数 dir=0，故向相应 GPIO 的 GDIR 寄存器写入 0  */
    __raw_writel(l, port->base + GPIO_GDIR);
    spin_unlock_irqrestore(&port->lock, flags);
}

第3步，获取 GPIO 引脚的值

使用的宏为 gpio_get_value
arch/arm/plat-mxc/include/mach/gpio.h
#define gpio_get_value      __gpio_get_value
__gpio_get_value 函数原型定义在 drivers/gpio/gpiolib.c
int __gpio_get_value(unsigned gpio)
{
    struct gpio_chip *chip;

    chip = gpio_to_chip(gpio);
    WARN_ON(extra_checks && chip->can_sleep);
    return chip->get ? chip->get(chip, gpio - chip->base) : 0;
}

__gpio_get_value 调用 chip->get ，实际调用到的是 arch/arm/plat-mxc/gpio.c 文件中 mxc_gpio_get 函数
static int mxc_gpio_get(struct gpio_chip *chip, unsigned offset)
{
    struct mxc_gpio_port *port =
container_of(chip, struct mxc_gpio_port, chip);

/* 读取相关寄存器的 PSR 寄存器 */
    return (__raw_readl(port->base + GPIO_PSR) >> offset) & 1;
}

二、PLATFORM DEVICE

GPIO按键作为系统的一种设备，挂载到platform总线上，相应的platform device定义在arch/arm/mach-mx5/mx53_loco.c:
static struct platform_device loco_button_device = {
    .name              = "gpio-keys",
    .id                = -1,
    .num_resources     = 0,
    .dev               = {
        .platform_data = &loco_button_data,
    }
};

loco_button_data 信息如下：  
static struct gpio_keys_platform_data loco_button_data = {
    .buttons    = loco_buttons,
    .nbuttons   = ARRAY_SIZE(loco_buttons),
};

loco_buttons 定义了5个按键：power、back、home、volumeup、volumedown和menu。
static struct gpio_keys_button loco_buttons[] = {
    GPIO_BUTTON(MX53_nONKEY, KEY_POWER,      1, "power",      0),
    GPIO_BUTTON(USER_UI1,    KEY_BACK,       1, "back",       0),
    GPIO_BUTTON(USER_UI2,    KEY_HOME,       1, "home",       0),
    GPIO_BUTTON(KEY_VOLUP,   KEY_VOLUMEUP,   1, "volumeup",   0),
    GPIO_BUTTON(KEY_VOLDOWN, KEY_VOLUMEDOWN, 1, "volumedown", 0),
    GPIO_BUTTON(KEY_SET,     KEY_MENU,       1, "menu",       0),
}; 

宏 GPIO_BUTTON 的内容为：
#define GPIO_BUTTON(gpio_num, ev_code, act_low, descr, wake)    \
{                                    \
    .gpio       = gpio_num,          \
    .type       = EV_KEY,            \
    .code       = ev_code,           \
    .active_low = act_low,           \
    .desc       = "btn " descr,      \
    .wakeup     = wake,              \
}
第一个参数为 gpio 引脚，第二个参数为按键的键值。

loco_buttons 使用的 gpio 定义如下：
#define MX53_nONKEY         (0*32 + 8)  /* GPIO_1_8  */
#define USER_UI1            (1*32 + 14) /* GPIO_2_14 */
#define USER_UI2            (1*32 + 15) /* GPIO_2_15 */
#define KEY_VOLUP           (6*32 + 13) /* GPIO_7_13 */
#define KEY_VOLDOWN         (0*32 + 4)  /* GPIO_1_4  */
#define KEY_SET             (0*32 + 2)  /* GPIO_1_2  */

键值定义在 include/linux/input.h 文件中：
#define KEY_HOME        102
#define KEY_VOLUMEDOWN  114
#define KEY_VOLUMEUP    115
#define KEY_POWER       116 /* SC System Power Down */
#define KEY_MENU        139 /* Menu (show menu) */
#define KEY_BACK        158 /* AC Back */

在板子初始化函数 static void __init mxc_board_init(void) 中
调用了 loco_add_device_buttons() 函数将loco_button_device加入到系统中，
这样驱动即可匹配 .name 找到我们的设备loco_button_device。

loco_add_device_buttons() 函数定义如下：
static void __init loco_add_device_buttons(void)
{
    platform_device_register(&loco_button_device);
}

三、PLATFORM DRIVER

GPIO按键的驱动文件为：drivers/input/keyboard/gpio_keys.c
通过 module_init ，在总线上注册 name 为 gpio-keys 的驱动，并通过 module_exit 相应的将其注销：
static int __init gpio_keys_init(void)
{
    return platform_driver_register(&gpio_keys_device_driver);
}

static void __exit gpio_keys_exit(void)
{
    platform_driver_unregister(&gpio_keys_device_driver);
}

module_init(gpio_keys_init);
module_exit(gpio_keys_exit);

platform driver - gpio_keys_device_driver 如下：
static struct platform_driver gpio_keys_device_driver = {
    .probe      = gpio_keys_probe,
    .remove     = __devexit_p(gpio_keys_remove),
    .driver     = {
        .name   = "gpio-keys",
        .owner  = THIS_MODULE,
#ifdef CONFIG_PM
        .pm     = &gpio_keys_pm_ops,
#endif
    }
};

在探测到 name 匹配的 device 之后，gpio_keys_probe 得以执行：

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 分配空间 */
    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;
    mutex_init(&ddata->disable_lock);

    /* 将 pdev 与 ddata 联系在一起，ddata 成为了 pdev 的平台data */
    platform_set_drvdata(pdev, ddata);
    input->name = pdev->name;
    input->phys = "gpio-keys/input0";
    input->dev.parent = &pdev->dev;

    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);

    /* 设置 loco_buttons 中各个 gpio 的中断及按键功能 */
    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);
    }

    /* 将我们的设备添加到 sys 文件系统 */
    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 (pdata->buttons[i].debounce_interval)
            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;
}

gpio_keys_setup_key 函数内容 ：

static int __devinit gpio_keys_setup_key(struct platform_device *pdev,
    struct gpio_button_data *bdata,
    struct gpio_keys_button *button)
{
    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);
    /* 初始化工作队列，当调度 &bdata->work 时，函数 gpio_keys_work_func 得以执行 */
    INIT_WORK(&bdata->work, gpio_keys_work_func);

    /* 请求 gpio */
    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;
    }

    /* 设置 loco_buttons 中涉及的 gpio 为输入模式 */
    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;
    }

    /* 获取 gpio 中断号 */
    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_irq(irq, gpio_keys_isr, irqflags, desc, bdata);
    if (error) {
        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;
}

中断处理函数 gpio_keys_isr 定义如下：
static irqreturn_t gpio_keys_isr(int irq, void *dev_id)
{
    /* 获取对应的按键信息 */
    struct gpio_button_data *bdata = dev_id;
    struct gpio_keys_button *button = bdata->button;

    BUG_ON(irq != gpio_to_irq(button->gpio));

    /* 这里 button->debounce_interval = 0 */
    if (button->debounce_interval)
        mod_timer(&bdata->timer,
            jiffies + msecs_to_jiffies(button->debounce_interval));
    else
        /* 调度 &bdata->work，gpio_keys_work_func 的以执行 */
        schedule_work(&bdata->work);

    return IRQ_HANDLED;
}

gpio_keys_work_func 的定义：
static void gpio_keys_work_func(struct work_struct *work)
{
    struct gpio_button_data *bdata =
        container_of(work, struct gpio_button_data, work);

    /* 获取按键状态并且上报 */

    gpio_keys_report_event(bdata);

}

函数 gpio_keys_report_event 内容：
static void gpio_keys_report_event(struct gpio_button_data *bdata)
{
    struct gpio_keys_button *button = bdata->button;
    struct input_dev *input = bdata->input;
    unsigned int type = button->type ?: EV_KEY;
    /* 获取按键状态 */
    int state = (gpio_get_value(button->gpio) ? 1 : 0) ^ button->active_low;

    /* 将相应功能按键的相应状态上报给 input 子系统 */
    input_event(input, type, button->code, !!state);
    /* 同步事件，通知事件的接收方，本次事件已完成 */
    input_sync(input);
}

如果要添加或是修改 android 的按键功能，需保证 device/fsl/imx53_loco/gpio-keys.kl 文件中有相应的键值，可以参考 qwerty.kl 文件修改。

以上内容为个人对 IMX53 GPIO 按键驱动的认识，如有不妥之处，还望批评指正。