2020-09-01

matrix_keypad 矩阵按键驱动分析

matrix_keypad 矩阵按键驱动分析

//主要函数调用过程

matrix_keypad_probe

	matrix_keypad_parse_dt //根据设备树构造 pdata

		pdata->num_row_gpios = nrow = of_gpio_named_count(np, "row-gpios");

		pdata->num_col_gpios = ncol = of_gpio_named_count(np, "col-gpios");

		of_get_property(np, "linux,no-autorepeat", NULL)

 

		of_get_property(np, "linux,wakeup", NULL)

 

		of_get_property(np, "gpio-activelow", NULL)

 

		of_property_read_u32(np, "debounce-delay-ms", &pdata->debounce_ms);

		of_property_read_u32(np, "col-scan-delay-us",&pdata->col_scan_delay_us);

		

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

			gpios[i] = of_get_named_gpio(np, "row-gpios", i);

 

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

			gpios[pdata->num_row_gpios + i] =  of_get_named_gpio(np, "col-gpios", i)	

 

	matrix_keypad_build_keymap

		matrix_keypad_parse_of_keymap

			 of_get_property(np, "linux,keymap", &proplen);

			 

			 matrix_keypad_map_key(input_dev, rows, cols, row_shift, key)

				unsigned int row = KEY_ROW(key);

				unsigned int col = KEY_COL(key);

				unsigned short code = KEY_VAL(key);

				

				keymap[MATRIX_SCAN_CODE(row, col, row_shift)] = code;

				__set_bit(code, input_dev->keybit);

	

	matrix_keypad_init_gpio

		gpio_request(pdata->col_gpios[i], "matrix_kbd_col")

		gpio_direction_output(pdata->col_gpios[i], !pdata->active_low);

		

		gpio_request(pdata->row_gpios[i], "matrix_kbd_row");

		gpio_direction_input(pdata->row_gpios[i]);

		

		request_any_context_irq

	

	input_register_device

 

 

 

 

//具体分析

//矩阵按键驱动源码在”drivers/input/keyboard/matrix_keypad.c”中

 

static int matrix_keypad_probe(struct platform_device *pdev)

{

	const struct matrix_keypad_platform_data *pdata;

	struct matrix_keypad *keypad;

	struct input_dev *input_dev;

	int err;

 

	pdata = dev_get_platdata(&pdev->dev);  // 获取设备的platform_data ；这个应该时传统的 平台设备匹配模型。

	if (!pdata) {

		//如果执行到这里，说明不是使用传统的平台设备模型，而是使用 设备树进行匹配的；

		// 那么接下来的重点就是分析 matrix_keypad_parse_dt

		pdata = matrix_keypad_parse_dt(&pdev->dev); //根据设备树的信息，构造 pdata

		if (IS_ERR(pdata)) {

			dev_err(&pdev->dev, "no platform data defined\n");

			return PTR_ERR(pdata);

		}

	} else if (!pdata->keymap_data) {

		dev_err(&pdev->dev, "no keymap data defined\n");

		return -EINVAL;

	}

 

	keypad = kzalloc(sizeof(struct matrix_keypad), GFP_KERNEL);

	input_dev = input_allocate_device();

	..

 

	keypad->input_dev = input_dev;

	keypad->pdata = pdata;

	keypad->row_shift = get_count_order(pdata->num_col_gpios);

	keypad->stopped = true;

	INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan);

	spin_lock_init(&keypad->lock);

 

	input_dev->name		= pdev->name;

	input_dev->id.bustype	= BUS_HOST;

	input_dev->dev.parent	= &pdev->dev;

	input_dev->open		= matrix_keypad_start;

	input_dev->close	= matrix_keypad_stop;

 

	err = matrix_keypad_build_keymap(pdata->keymap_data, NULL,

					 pdata->num_row_gpios,

					 pdata->num_col_gpios,

					 NULL, input_dev); //从 keymap_data 里分解出行列键对应的键码；或 从设备树里获取 keymap

	..

 

	if (!pdata->no_autorepeat)

		__set_bit(EV_REP, input_dev->evbit); //按键的重复性时间

	input_set_capability(input_dev, EV_MSC, MSC_SCAN);

	input_set_drvdata(input_dev, keypad); //设置输入设备的私有数据为 keypad

 

	err = matrix_keypad_init_gpio(pdev, keypad);//注册行线的中断号

	..

 

	err = input_register_device(keypad->input_dev);//注册输入设备

	..

 

	device_init_wakeup(&pdev->dev, pdata->wakeup);

	platform_set_drvdata(pdev, keypad);

 

	return 0;

 

...

	return err;

}

 

 

 

//根据设备树的信息，构造 pdata

static struct matrix_keypad_platform_data *matrix_keypad_parse_dt(struct device *dev)

{

	struct matrix_keypad_platform_data *pdata;

	struct device_node *np = dev->of_node;

	unsigned int *gpios;

	int i, nrow, ncol;

 

	..

 

	//分配一块内存给 pdata

	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);

	...

	pdata->num_row_gpios = nrow = of_gpio_named_count(np, "row-gpios");//获取GPIO引脚的个数

	pdata->num_col_gpios = ncol = of_gpio_named_count(np, "col-gpios");

	...

 

	if (of_get_property(np, "linux,no-autorepeat", NULL))

		pdata->no_autorepeat = true;

	if (of_get_property(np, "linux,wakeup", NULL))

		pdata->wakeup = true;

	if (of_get_property(np, "gpio-activelow", NULL))

		pdata->active_low = true;

 

	of_property_read_u32(np, "debounce-delay-ms", &pdata->debounce_ms);//按键的消抖延迟

	of_property_read_u32(np, "col-scan-delay-us",

						&pdata->col_scan_delay_us); //扫描延迟

 

	

	gpios = devm_kzalloc(dev,

			     sizeof(unsigned int) *

				(pdata->num_row_gpios + pdata->num_col_gpios),

			     GFP_KERNEL);

	...

	// 获取GPIO引脚

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

		gpios[i] = of_get_named_gpio(np, "row-gpios", i);//获取 属性为 "row-gpios" 的第 i 个数据

 

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

		gpios[pdata->num_row_gpios + i] =

			of_get_named_gpio(np, "col-gpios", i);

 

	pdata->row_gpios = gpios;

	pdata->col_gpios = &gpios[pdata->num_row_gpios];

 

	return pdata;

}

 

 

int matrix_keypad_build_keymap(const struct matrix_keymap_data *keymap_data,

			       const char *keymap_name,

			       unsigned int rows, unsigned int cols,

			       unsigned short *keymap,

			       struct input_dev *input_dev)

{

	unsigned int row_shift = get_count_order(cols);

	size_t max_keys = rows << row_shift;

	int i;

	int error;

 

	...

 

	if (!keymap) {

		keymap = devm_kzalloc(input_dev->dev.parent,

				      max_keys * sizeof(*keymap),

				      GFP_KERNEL);

		...

		}

	}

 

	input_dev->keycode = keymap;

	input_dev->keycodesize = sizeof(*keymap);

	input_dev->keycodemax = max_keys;

 

	__set_bit(EV_KEY, input_dev->evbit);

 

	if (keymap_data) {

		for (i = 0; i < keymap_data->keymap_size; i++) {

			unsigned int key = keymap_data->keymap[i];

 

			if (!matrix_keypad_map_key(input_dev, rows, cols,

						   row_shift, key))

				return -EINVAL;

		}

	} else {

	//如果 keymap_data 为NULL时，则从设备树里 获取 ； 那么重点就是解析设备树里的数据了

		error = matrix_keypad_parse_of_keymap(keymap_name, rows, cols,  input_dev);

		...

	}

 

	__clear_bit(KEY_RESERVED, input_dev->keybit);

 

	return 0;

}

 

//就是解析设备树节点里的 linux,keymap 属性

static int matrix_keypad_parse_of_keymap(const char *propname,

					 unsigned int rows, unsigned int cols,

					 struct input_dev *input_dev)

{

	struct device *dev = input_dev->dev.parent;

	struct device_node *np = dev->of_node;

	unsigned int row_shift = get_count_order(cols);

	unsigned int max_keys = rows << row_shift;

	unsigned int proplen, i, size;

	const __be32 *prop;

 

	if (!np)

		return -ENOENT;

 

	if (!propname)

		propname = "linux,keymap";

 

	// 获取节点属性值里的首地址

	prop = of_get_property(np, propname, &proplen);

	...

 

	size = proplen / sizeof(u32);

	...

 

	for (i = 0; i < size; i++) {

		unsigned int key = be32_to_cpup(prop + i);//获取属性值

 

		if (!matrix_keypad_map_key(input_dev, rows, cols, row_shift, key)) //设置 keymap

			return -EINVAL;

	}

 

	return 0;

}

 

 

 

static bool matrix_keypad_map_key(struct input_dev *input_dev,

				  unsigned int rows, unsigned int cols,

				  unsigned int row_shift, unsigned int key)

{

	unsigned short *keymap = input_dev->keycode;

	unsigned int row = KEY_ROW(key);

	unsigned int col = KEY_COL(key);

	unsigned short code = KEY_VAL(key);

 

	...

 

	keymap[MATRIX_SCAN_CODE(row, col, row_shift)] = code;

	__set_bit(code, input_dev->keybit);

 

	return true;

}

 

/*

 列线作为输出，行线作为中断输入

*/

static int matrix_keypad_init_gpio(struct platform_device *pdev,  struct matrix_keypad *keypad)

{

	const struct matrix_keypad_platform_data *pdata = keypad->pdata;

	int i, err;

 

	/* initialized strobe lines as outputs, activated */

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

		err = gpio_request(pdata->col_gpios[i], "matrix_kbd_col"); //请求IO 

		...

		gpio_direction_output(pdata->col_gpios[i], !pdata->active_low);//设置为输出

	}

 

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

		err = gpio_request(pdata->row_gpios[i], "matrix_kbd_row");//请求io

		...

		gpio_direction_input(pdata->row_gpios[i]);//设置为输入

	}

 

	if (pdata->clustered_irq > 0) {

		err = request_any_context_irq(pdata->clustered_irq,

				matrix_keypad_interrupt,

				pdata->clustered_irq_flags,

				"matrix-keypad", keypad);

		...

	} else {

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

			err = request_any_context_irq(

					gpio_to_irq(pdata->row_gpios[i]),

					matrix_keypad_interrupt,

					IRQF_TRIGGER_RISING |

					IRQF_TRIGGER_FALLING,

					"matrix-keypad", keypad);

			...

		}

	}

 

	/* initialized as disabled - enabled by input->open */

	disable_row_irqs(keypad);

	return 0;

 

...

 

	return err;

}

 

 

通过probe函数，可以确定我们写平台设备时只需通过platform_data成员提供平台驱动所需的信息，无需再提供resource.

 

再确定结构体matrix_keypad_platform_data的每个成员的作用即可,如不清楚具体用途，可以在驱动代码里通过查看对成员值的访问反推出用途.

 

在"include/linux/input/matrix_keypad.h"中有

 

#define KEY(row, col, val)  ((((row) & (MATRIX_MAX_ROWS - 1)) << 24) |\

                 (((col) & (MATRIX_MAX_COLS - 1)) << 16) |\

                 ((val) & 0xffff))

.....

#define KEY_ROW(k)      (((k) >> 24) & 0xff)

#define KEY_COL(k)      (((k) >> 16) & 0xff)

#define KEY_VAL(k)      ((k) & 0xffff)

.....

.....

#define MATRIX_SCAN_CODE(row, col, row_shift)   (((row) << (row_shift)) + (col))

 

 

......

......

struct matrix_keymap_data {

    const uint32_t *keymap; //装载按键对应的键码数组, 注意每个键码需要使用宏KEY来写。也就是一个32位数据里，行，列，键码各占用8, 8, 16位.

    unsigned int    keymap_size; //键码数组的元素个数

};

......

......

struct matrix_keypad_platform_data {

    const struct matrix_keymap_data *keymap_data; //键码数据对象的首地址

 

    const unsigned int *row_gpios; //行线用的IO口

    const unsigned int *col_gpios; //列线用的IO口

 

    unsigned int    num_row_gpios; //多少个行线

    unsigned int    num_col_gpios; //多少个列线

 

    unsigned int    col_scan_delay_us; //扫描列线时间隔时间

 

    unsigned int    debounce_ms; //防抖动的间隔时间

 

    unsigned int    clustered_irq; //行线是否共用一个中断, 设0则每个行线的中断是独立的

    unsigned int    clustered_irq_flags;

 

    bool        active_low; //键按下时，行线是否为低电平

    bool        wakeup;

    bool        no_autorepeat; //按键按下时是否重复提交按键, 设1就是不重复,设0重复

};

 

 

Linux中输入设备的事件类型有：

EV_SYN 0x00 同步事件

EV_KEY 0x01 按键事件，如KEY_VOLUMEDOWN

EV_REL 0x02 相对坐标,   如shubiao上报的坐标

EV_ABS 0x03 绝对坐标，如触摸屏上报的坐标

EV_MSC 0x04 其它

EV_LED 0x11 LED

EV_SND 0x12 声音

EV_REP 0x14 Repeat

EV_FF  0x15 力反馈 

 

 

IMX6UL上添加支持矩阵按键（里面有设备树的配置信息）：

https://blog.csdn.net/qq_39346729/article/details/103293553