gpio matrix keypad linux driver

Linuxkernel & device driver programming

Cross-Referenced Linuxand Device DriverCode

[ source navigation ] [diffmarkup ] [ identifiersearch ] [ freetextsearch ] [ filesearch ]

Version: [ 2.6.11.8 ][ 2.6.25 ][ 2.6.25.8 ][ 2.6.31.13 ] Architecture:[ i386 ]

   /*
    *  GPIO driven matrix keyboard driver
    *
    *  Copyright (c) 2008 Marek Vasut <[email protected]>
    *
    *  Based on corgikbd.c
    *
    *  This program is free software; you can redistribute it and/or modify
    *  it under the terms of the GNU General Public License version 2 as
   *  published by the Free Software Foundation.
   *
   */
  
  #include <linux/types.h>
  #include <linux/delay.h>
  #include <linux/platform_device.h>
  #include <linux/init.h>
  #include <linux/input.h>
  #include <linux/irq.h>
  #include <linux/interrupt.h>
  #include <linux/jiffies.h>
  #include <linux/module.h>
  #include <linux/gpio.h>
  #include <linux/input/matrix_keypad.h>
  
  struct matrix_keypad {
          const struct matrix_keypad_platform_data *pdata;
          struct input_dev *input_dev;
          unsigned short *keycodes;
          unsigned int row_shift;
  
          uint32_t last_key_state[MATRIX_MAX_COLS];
          struct delayed_work work;
          bool scan_pending;
          bool stopped;
          spinlock_t lock;
  };
  
  /*
   * NOTE: normally the GPIO has to be put into HiZ when de-activated to cause
   * minmal side effect when scanning other columns, here it is configured to
   * be input, and it should work on most platforms.
   */
  static void __activate_col(const struct matrix_keypad_platform_data *pdata,
                             int col, bool on)
  {
          bool level_on = !pdata->active_low;
  
          if (on) {
                  gpio_direction_output(pdata->col_gpios[col], level_on);
          } else {
                  gpio_set_value_cansleep(pdata->col_gpios[col], !level_on);
                  gpio_direction_input(pdata->col_gpios[col]);
          }
  }
  
  static void activate_col(const struct matrix_keypad_platform_data *pdata,
                           int col, bool on)
  {
          __activate_col(pdata, col, on);
  
          if (on && pdata->col_scan_delay_us)
                  udelay(pdata->col_scan_delay_us);
  }
  
  static void activate_all_cols(const struct matrix_keypad_platform_data *pdata,
                                bool on)
  {
          int col;
  
          for (col = 0; col < pdata->num_col_gpios; col++)
                  __activate_col(pdata, col, on);
  }
  
  static bool row_asserted(const struct matrix_keypad_platform_data *pdata,
                           int row)
  {
          return gpio_get_value_cansleep(pdata->row_gpios[row]) ?
                          !pdata->active_low : pdata->active_low;
  }
  
  static void enable_row_irqs(struct matrix_keypad *keypad)
  {
          const struct matrix_keypad_platform_data *pdata = keypad->pdata;
          int i;
  
          for (i = 0; i < pdata->num_row_gpios; i++)
			//使能中断。
                  enable_irq(gpio_to_irq(pdata->row_gpios[i]));
  }
  
  static void disable_row_irqs(struct matrix_keypad *keypad)
  {
          const struct matrix_keypad_platform_data *pdata = keypad->pdata;
          int i;
  
          for (i = 0; i < pdata->num_row_gpios; i++)

			这个是关中断，记得以前使用disable_irq()时有时候会出错。
			所以使用disable_irq_nosync()会更好友好一些。
                  disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
  }
  

使用input子系统的一般流程为：
input_allocate_device（）申请一个input_dev设备――>
初始化该input_dev――>
input_register_device（）向子系统注册该设备――>
中断时input_event（）向子系 统报告事件。

 /*
  * This gets the keys from keyboard and reports it to input subsystem
  */
	这就是延后的工作的函数体，依次进行列行扫描来判断哪个按键被按下，然后使用report_key（）向
	input core提交按键事件。