下面的文章是基於mini2440的gpio按鍵來講解input子系統。

以mini2440為例，用該板的bsp檔案，進行input子系統的講解.所用的版本為android4.0.

先來看下板級支援檔案都註冊了那些資源。

下面是五個按鍵的資源：

#define KEY_POWER           116  /* SC System Power Down */

#define KEY_F1                   59

#define KEY_F2                   60

#define KEY_F3                   61

#define KEY_F5                   63

struct gpio_keys_button {

       /* Configuration parameters */

       unsigned int code;  /* input event code (KEY_*, SW_*) *///上報事件的code

int gpio;//所用的gpio引腳

int active_low;//是否低電平有效

const char *desc; //該按鍵的描述符

       unsigned int type;   /* input event type (EV_KEY, EV_SW, EV_ABS) */

       int wakeup;            /* configure the button as a wake-up source */

       int debounce_interval;    /* debounce ticks interval in msecs */

       bool can_disable;

       int value;        /* axis value for EV_ABS */

};

static struct gpio_keys_button mini2440_buttons[] = {

       {

              .gpio              = S3C2410_GPG(0),            /* K1 */

              .code             = KEY_F1,

              .desc              = "Button 1",

              .active_low     = 1,

       },

       {

              .gpio              = S3C2410_GPG(3),            /* K2 */

              .code             = KEY_F2,

              .desc              = "Button 2",

              .active_low     = 1,

       },

       {

              .gpio              = S3C2410_GPG(5),            /* K3 */

              .code             = KEY_F3,

              .desc              = "Button 3",

              .active_low     = 1,

       },

       {

              .gpio              = S3C2410_GPG(6),            /* K4 */

              .code             = KEY_POWER,

              .desc              = "Power",

              .active_low     = 1,

       },

       {

              .gpio              = S3C2410_GPG(7),            /* K5 */

              .code             = KEY_F5,

              .desc              = "Button 5",

              .active_low     = 1,

       },

};

/*下面是平臺數據的宣告*/

struct gpio_keys_platform_data {

struct gpio_keys_button *buttons;

int nbuttons;

       unsigned int poll_interval;      /* polling interval in msecs -

                                      for polling driver only */

       unsigned int rep:1;         /* enable input subsystem auto repeat */

       int (*enable)(struct device *dev);

       void (*disable)(struct device *dev);

       const char *name;         /* input device name */

};

static struct gpio_keys_platform_data mini2440_button_data = {

       .buttons   = mini2440_buttons,

       .nbuttons = ARRAY_SIZE(mini2440_buttons),

};

/*下面是平臺裝置的宣告*/

struct platform_device {

const char      * name;

int           id;

struct device   dev;

       u32         num_resources;

       struct resource       * resource;

       const struct platform_device_id    *id_entry;

       /* MFD cell pointer */

       struct mfd_cell *mfd_cell;

       /* arch specific additions */

       struct pdev_archdata     archdata;

};

static struct platform_device mini2440_button_device = {

       .name             = "gpio-keys",

       .id           = -1,

       .dev        = {

              .platform_data = &mini2440_button_data,

       }

};

static struct platform_device *mini2440_devices[] __initdata = {

       ...................

&mini2440_button_device,

       ………

};

static void __init mini2440_init(void)

{

       .............................

       platform_add_devices(mini2440_devices, ARRAY_SIZE(mini2440_devices));

       ……………

}

MACHINE_START(MINI2440, "MINI2440")

       /* Maintainer: Michel Pollet <[email protected]> */

       .boot_params  = S3C2410_SDRAM_PA + 0x100,

       .map_io          = mini2440_map_io,

       .init_machine  = mini2440_init,

       .init_irq   = s3c24xx_init_irq,

       .timer             = &s3c24xx_timer,

MACHINE_END

上面是把該設備註冊到平臺總線上。

下面看下平臺驅動的註冊：

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,

       }

};

static int __init gpio_keys_init(void)

{

       return platform_driver_register(&gpio_keys_device_driver);

}

module_init(gpio_keys_init);

在註冊平臺驅動時，如果成功匹配平臺裝置後，會呼叫平臺驅動的probe函式。

下面看下該驅動的probe函式。

static int __devinit gpio_keys_probe(struct platform_device *pdev)

{

       /*取出再bsp檔案註冊的平臺數據*/

       struct gpio_keys_platform_data *pdata = pdev->dev.platform_data;

       /*這裡出現了一個新的結構體，該結構體定義如下*/

/*struct gpio_keys_drvdata {

       struct input_dev *input;

       struct mutex disable_lock;

       unsigned int n_buttons;

       int (*enable)(struct device *dev);

       void (*disable)(struct device *dev);

       struct gpio_button_data data[0];

};*/

       struct gpio_keys_drvdata *ddata;

       struct device *dev = &pdev->dev;

       struct input_dev *input;

       /*分配gpio_keys_drvdata結構體記憶體*/

       ddata = kzalloc(sizeof(struct gpio_keys_drvdata) +

                     pdata->nbuttons * sizeof(struct gpio_button_data),

                     GFP_KERNEL);

       /*分配一個input結構體，並初始化部分成員*/

       input = input_allocate_device();

       /*為ddata的各個成員變數賦值*/

       ddata->input = input;

       ddata->n_buttons = pdata->nbuttons;

       mutex_init(&ddata->disable_lock);

       /*把ddata裝置pdev平臺裝置的driver data*/

       platform_set_drvdata(pdev, ddata);

       /*把ddata裝置input裝置的driver data*/

       input_set_drvdata(input, ddata);

       /*設定input裝置的各個成員變數*/

       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;

       /* 根據pdata的rep成員值，裝置input子系統的功能*/

       if (pdata->rep)

              __set_bit(EV_REP, input->evbit);

       /*取出pdata中得資源進行賦值*/

       for (i = 0; i < pdata->nbuttons; i++) {

              struct gpio_keys_button *button = &pdata->buttons[i];

              struct gpio_button_data *bdata = &ddata->data[i];

              /*為三目運算子，相當於button->type ?: button->type:EV_KEY;*/

              unsigned int type = button->type ?: EV_KEY;

              bdata->input = input;//

              bdata->button = button;

              error = gpio_keys_setup_key(pdev, bdata, button);

if (button->wakeup)//該鍵能否作為喚醒源？

                     wakeup = 1;

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

       }

       }

       error = input_register_device(input);

       /* 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;

}

下面逐步分解上面標成粉色的函式。

第一個分配一個input dev並進行初始化

struct input_dev *input_allocate_device(void)

{

       struct input_dev *dev;

       dev = kzalloc(sizeof(struct input_dev), GFP_KERNEL);

       if (dev) {

dev->dev.type = &input_dev_type;

dev->dev.class = &input_class;

              device_initialize(&dev->dev);

              mutex_init(&dev->mutex);

              spin_lock_init(&dev->event_lock);

              INIT_LIST_HEAD(&dev->h_list);

              INIT_LIST_HEAD(&dev->node);

       }

       return dev;

}

分析第二個：

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;

       /*設定該bdata的定時器函式*/

       setup_timer(&bdata->timer, gpio_keys_timer, (unsigned long)bdata);

       /*設定該bdata的work函式*/

       INIT_WORK(&bdata->work, gpio_keys_work_func);

       /*申請button的gpio*/

       error = gpio_request(button->gpio, desc);

       /*設定gpio的方向*/

       error = gpio_direction_input(button->gpio);

       if (button->debounce_interval) { //設定gpio的去抖間隔

              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); //該gpio引腳對應分配的中斷

       irqflags = IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING;

       if (!button->can_disable)

              irqflags |= IRQF_SHARED;

       /*註冊該irq的中斷處理函式，並設定標記*/

       error = request_any_context_irq(irq, gpio_keys_isr, irqflags, desc, bdata);

其中中斷處理函式如下：

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

       if (bdata->timer_debounce)//如果有去抖間隔則修改定時器

              mod_timer(&bdata->timer,

                     jiffies + msecs_to_jiffies(bdata->timer_debounce));

       else

              schedule_work(&bdata->work);//如果沒有，直接執行work

       return IRQ_HANDLED;

}

}

如果定時器到期，則執行定時器處理函式：

static void gpio_keys_timer(unsigned long _data)

{

       struct gpio_button_data *data = (struct gpio_button_data *)_data;

       schedule_work(&data->work);//執行相應的work

}

中斷處理的結果是執行相應的work。看下work函式

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);//用input子系統，向上層報事件

}

第三個函式，設定該input dev的能力記錄本裝置對那些事件感興趣

void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)

{

       switch (type) {

       case EV_KEY:

              __set_bit(code, dev->keybit);//比如按鍵,應該對哪些鍵值的按鍵進行處理(對於其它按鍵不予理睬)

              break;

       __set_bit(type, dev->evbit);

}

第四個函式：向input核心註冊input裝置

int input_register_device(struct input_dev *dev)

{

       static atomic_t input_no = ATOMIC_INIT(0);

       struct input_handler *handler;

       const char *path;

       int error;

       /* Every input device generates EV_SYN/SYN_REPORT events. */

       __set_bit(EV_SYN, dev->evbit); //設定支援的能力

       /* KEY_RESERVED is not supposed to be transmitted to userspace. */

       __clear_bit(KEY_RESERVED, dev->keybit);//清除該支援的能力

       /* Make sure that bitmasks not mentioned in dev->evbit are clean. */

       input_cleanse_bitmasks(dev);//確保在dev->evbit中沒有支援的能力被清除掉

       if (!dev->hint_events_per_packet)

              dev->hint_events_per_packet = input_estimate_events_per_packet(dev);

       /*

        * If delay and period are pre-set by the driver, then autorepeating

        * is handled by the driver itself and we don't do it in input.c.

        */

       init_timer(&dev->timer);

       if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD]) {

              dev->timer.data = (long) dev;

              dev->timer.function = input_repeat_key;

              dev->rep[REP_DELAY] = 250;

              dev->rep[REP_PERIOD] = 33;

       }

       /*設定input dev成員變數的處理函式*/

       if (!dev->getkeycode)

              dev->getkeycode = input_default_getkeycode;

       if (!dev->setkeycode)

              dev->setkeycode = input_default_setkeycode;

       /*設定該dev name*/

       dev_set_name(&dev->dev, "input%ld",

                   (unsigned long) atomic_inc_return(&input_no) - 1);

       error = device_add(&dev->dev);//把該裝置增加到裝置驅動模型中

       /*把該dev加入到input_dev_list 連結串列*/

       list_add_tail(&dev->node, &input_dev_list);

       /*遍歷input_hander_list連結串列中得hander，以便匹配input dev*/

       list_for_each_entry(handler, &input_handler_list, node)

              input_attach_handler(dev, handler);

       return 0;

}

下面看下匹配函式：

static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)

{

       const struct input_device_id *id;

       id = input_match_device(handler, dev);//返回匹配成功的id

       error = handler->connect(handler, dev, id);//如果匹配成功，則呼叫hander的connect函式

       return error;

}

下面主要看下match的過程：

static const struct input_device_id *input_match_device(struct input_handler *handler,

                                                 struct input_dev *dev)

{

       const struct input_device_id *id;

       for (id = handler->id_table; id->flags || id->driver_info; id++) {

              if (id->flags & INPUT_DEVICE_ID_MATCH_BUS)//如果是匹配bus，則比較id.bus

                     if (id->bustype != dev->id.bustype)

                            continue;

if (id->flags & INPUT_DEVICE_ID_MATCH_VENDOR) //如果是匹配vender則比較id.vender

                     if (id->vendor != dev->id.vendor)

                            continue;

//如果是匹配product則比較id.product

              if (id->flags & INPUT_DEVICE_ID_MATCH_PRODUCT)

                     if (id->product != dev->id.product)

                            continue;

//如果是匹配versiont則比較id.version

              if (id->flags & INPUT_DEVICE_ID_MATCH_VERSION)

                     if (id->version != dev->id.version)

                            continue;

/*如果hander支援該能力，則dev也要支援，否則不匹配*/

MATCH_BIT(evbit,  EV_MAX);

              MATCH_BIT(keybit, KEY_MAX);

              MATCH_BIT(relbit, REL_MAX);

              MATCH_BIT(absbit, ABS_MAX);

              MATCH_BIT(mscbit, MSC_MAX);

              MATCH_BIT(ledbit, LED_MAX);

              MATCH_BIT(sndbit, SND_MAX);

              MATCH_BIT(ffbit,  FF_MAX);

              MATCH_BIT(swbit,  SW_MAX);

下面看下這個巨集：

#define MATCH_BIT(bit, max) \

              for (i = 0; i < BITS_TO_LONGS(max); i++) \

                     if ((id->bit[i] & dev->bit[i]) != id->bit[i]) \

                            break; \

              if (i != BITS_TO_LONGS(max)) \

                     continue;

/*如果hander的match空，則返回該id，或者呼叫match繼續匹配，匹配成員的話也返回id*/

              if (!handler->match || handler->match(handler, dev))

                     return id;

       }

       return NULL;

}

上面input dev已經註冊完了，下面看看hander的註冊.

static const struct input_device_id evdev_ids[] = {

{ .driver_info = 1 },      /* Matches all devices 來則不拒，公交車*/

       { },                /* Terminating zero entry */

};

MODULE_DEVICE_TABLE(input, evdev_ids);

static struct input_handler evdev_handler = {

       .event             = evdev_event,

       .connect  = evdev_connect,

       .disconnect     = evdev_disconnect,

       .fops              = &evdev_fops,

       .minor            = EVDEV_MINOR_BASE,

       .name             = "evdev",

       .id_table  = evdev_ids,//匹配的列表

};

static int __init evdev_init(void)

{

       return input_register_handler(&evdev_handler);

}

module_init(evdev_init);

下面看下hander的註冊：

static struct input_handler *input_table[8];

int input_register_handler(struct input_handler *handler)

{

       struct input_dev *dev;

       int retval;

       INIT_LIST_HEAD(&handler->h_list);

       if (handler->fops != NULL) {

              if (input_table[handler->minor >> 5]) {//判斷input_table的相應項是否被佔用

                     retval = -EBUSY;

                     goto out;

              }

              input_table[handler->minor >> 5] = handler; // 如果沒有佔用，則把hander填入

       }

/*把要註冊的hander加入input_handler_list連結串列中*/

       list_add_tail(&handler->node, &input_handler_list);

       /*遍歷input_dev_list連結串列上得每一個dev，去匹配該hander*/

       list_for_each_entry(dev, &input_dev_list, node)

              input_attach_handler(dev, handler);//開始進行匹配

}

匹配成功後，返回匹配成功的id，然後呼叫該handler的connect函式。

static struct evdev *evdev_table[EVDEV_MINORS]; //evdev的容器

static int evdev_connect(struct input_handler *handler, struct input_dev *dev,

                      const struct input_device_id *id)

{

       struct evdev *evdev;

       int minor;

       /*在容器中找個空閒的地方*/

       for (minor = 0; minor < EVDEV_MINORS; minor++)

              if (!evdev_table[minor])

                     break;

       /*分配一個evdev變數*/

       evdev = kzalloc(sizeof(struct evdev), GFP_KERNEL);

       /*初始化該evdev的成員變數*/

       INIT_LIST_HEAD(&evdev->client_list);

       spin_lock_init(&evdev->client_lock);

       mutex_init(&evdev->mutex);

       init_waitqueue_head(&evdev->wait);

       dev_set_name(&evdev->dev, "event%d", minor);

       evdev->exist = true;

       evdev->minor = minor;

/*初始化該evdev的成員變數handle，handle相當於是紅娘連線input dev和相應的hander*/

       evdev->handle.dev = input_get_device(dev);//增加該dev的引用計數

       evdev->handle.name = dev_name(&evdev->dev);//設定該evdev的name

       evdev->handle.handler = handler;

       evdev->handle.private = evdev;//設定hander的私有資料,這個在下面會用到

       /*初始化該evdev的成員變數dev*/

       evdev->dev.devt = MKDEV(INPUT_MAJOR, EVDEV_MINOR_BASE + minor);

       evdev->dev.class = &input_class;

       evdev->dev.parent = &dev->dev;

       evdev->dev.release = evdev_free;

       device_initialize(&evdev->dev);

       /*註冊上面初始化好的handle*/

       error = input_register_handle(&evdev->handle);

       /*安裝evdev，其實就是放到全域性的evdev_table 陣列中*/

error = evdev_install_chrdev(evdev);

該函式如下：

static int evdev_install_chrdev(struct evdev *evdev)

{

evdev_table[evdev->minor] = evdev;

return 0;

}

/*把該evdev裝置增加到裝置驅動模型中*/

       error = device_add(&evdev->dev);

       return 0;

}

下面主要看input_register_handle幹了啥活？

int input_register_handle(struct input_handle *handle)

{

       struct input_handler *handler = handle->handler;

       struct input_dev *dev = handle->dev;

       list_add_tail_rcu(&handle->d_node, &dev->h_list);//加入到dev hist連結串列的末尾

       list_add_tail_rcu(&handle->h_node, &handler->h_list);//加入到hander的hist尾部

       return 0;

註冊的過程也就是把該handle加入dev和hander的連結串列中

}

上面input dev和handler用網上的一個圖可以表示：

該圖形象的描述了三者的關係.

 

該搭的關係已經搞好啦，下面就是要用啦，用的時候看三者是怎麼配合的。

下面看現在中斷處理中，是如何用的？

上面有說過，在中斷髮生後，會呼叫work，在work中去處理上報鍵值：上報函式如下：

static void gpio_keys_report_event(struct gpio_button_data *bdata)

{

       struct gpio_keys_button *button = bdata->button;//取出每一個鍵的結構體

       struct input_dev *input = bdata->input;        //把該鍵的input裝置也取出來

       unsigned int type = button->type ?: EV_KEY;   //型別為key

       int state = (gpio_get_value_cansleep(button->gpio) ? 1 : 0) ^ button->active_low;

       input_event(input, type, button->code, !!state);

       input_sync(input);

}

繼續分析：

void input_event(struct input_dev *dev,unsigned int type, unsigned int code, int value)

{

       if (is_event_supported(type, dev->evbit, EV_MAX)) {//判斷該事件是否被支援

              ……….

              input_handle_event(dev, type, code, value);

              ..................

       }

}

下面繼續跟蹤：

static void input_handle_event(struct input_dev *dev,unsigned int type, unsigned int code, int value)

{

       int disposition = INPUT_IGNORE_EVENT;

       switch (type) {

       case EV_KEY:

              if (is_event_supported(code, dev->keybit, KEY_MAX) &&  /判斷該code是否被支援

                  !!test_bit(code, dev->key) != value) {

                     if (value != 2) {

                            __change_bit(code, dev->key);

                            if (value)

                                   input_start_autorepeat(dev, code);

                            else

                                   input_stop_autorepeat(dev);

                     }

                     disposition = INPUT_PASS_TO_HANDLERS;

              }

              break;

       }

       if (disposition != INPUT_IGNORE_EVENT && type != EV_SYN)

              dev->sync = false;

if (disposition & INPUT_PASS_TO_HANDLERS)

input_pass_event(dev, type, code, value);

}

繼續跟蹤該函式：

static void input_pass_event(struct input_dev *dev,

                          unsigned int type, unsigned int code, int value)

{

       struct input_handler *handler;

       struct input_handle *handle;

              list_for_each_entry_rcu(handle, &dev->h_list, d_node) {

                     if (!handle->open)//如果該handle沒有被開啟，則找下一個handle

                            continue;

相關推薦