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