Eric Lee / smarc-uboot | Embedian Git Server

Commit 8327d41b19af08a331c62954fafd685426e617f4

Authored by Simon Glass 2017-05-19 10:09:53 +0800

cros_ec: Update the cros_ec keyboard driver to livetree

Update this driver and key_matrix to support a live device tree.

Signed-off-by: Simon Glass <sjg@chromium.org>

Showing 4 changed files with 23 additions and 26 deletions Inline Diff

drivers/input/cros_ec_keyb.c
drivers/input/key_matrix.c
drivers/input/tegra-kbc.c
include/key_matrix.h

drivers/input/cros_ec_keyb.c

Diff comments View file @ 8327d41

1	/*	1	/*
2	* Chromium OS Matrix Keyboard	2	* Chromium OS Matrix Keyboard
3	*	3	*
4	* Copyright (c) 2012 The Chromium OS Authors.	4	* Copyright (c) 2012 The Chromium OS Authors.
5	*	5	*
6	* SPDX-License-Identifier: GPL-2.0+	6	* SPDX-License-Identifier: GPL-2.0+
7	*/	7	*/
8		8
9	#include <common.h>	9	#include <common.h>
10	#include <cros_ec.h>	10	#include <cros_ec.h>
11	#include <dm.h>	11	#include <dm.h>
12	#include <errno.h>	12	#include <errno.h>
13	#include <fdtdec.h>
14	#include <input.h>	13	#include <input.h>
15	#include <keyboard.h>	14	#include <keyboard.h>
16	#include <key_matrix.h>	15	#include <key_matrix.h>
17	#include <stdio_dev.h>	16	#include <stdio_dev.h>
18		17
19	DECLARE_GLOBAL_DATA_PTR;	18	DECLARE_GLOBAL_DATA_PTR;
20		19
21	enum {	20	enum {
22	KBC_MAX_KEYS = 8, /* Maximum keys held down at once */	21	KBC_MAX_KEYS = 8, /* Maximum keys held down at once */
23	KBC_REPEAT_RATE_MS = 30,	22	KBC_REPEAT_RATE_MS = 30,
24	KBC_REPEAT_DELAY_MS = 240,	23	KBC_REPEAT_DELAY_MS = 240,
25	};	24	};
26		25
27	struct cros_ec_keyb_priv {	26	struct cros_ec_keyb_priv {
28	struct input_config input; / The input layer */	27	struct input_config input; / The input layer */
29	struct key_matrix matrix; /* The key matrix layer */	28	struct key_matrix matrix; /* The key matrix layer */
30	int key_rows; /* Number of keyboard rows */	29	int key_rows; /* Number of keyboard rows */
31	int key_cols; /* Number of keyboard columns */	30	int key_cols; /* Number of keyboard columns */
32	int ghost_filter; /* 1 to enable ghost filter, else 0 */	31	int ghost_filter; /* 1 to enable ghost filter, else 0 */
33	};	32	};
34		33
35		34
36	/**	35	/**
37	* Check the keyboard controller and return a list of key matrix positions	36	* Check the keyboard controller and return a list of key matrix positions
38	* for which a key is pressed	37	* for which a key is pressed
39	*	38	*
40	* @param dev Keyboard device	39	* @param dev Keyboard device
41	* @param keys List of keys that we have detected	40	* @param keys List of keys that we have detected
42	* @param max_count Maximum number of keys to return	41	* @param max_count Maximum number of keys to return
43	* @param samep Set to true if this scan repeats the last, else false	42	* @param samep Set to true if this scan repeats the last, else false
44	* @return number of pressed keys, 0 for none, -EIO on error	43	* @return number of pressed keys, 0 for none, -EIO on error
45	*/	44	*/
46	static int check_for_keys(struct udevice dev, struct key_matrix_key keys,	45	static int check_for_keys(struct udevice dev, struct key_matrix_key keys,
47	int max_count, bool *samep)	46	int max_count, bool *samep)
48	{	47	{
49	struct cros_ec_keyb_priv *priv = dev_get_priv(dev);	48	struct cros_ec_keyb_priv *priv = dev_get_priv(dev);
50	struct key_matrix_key *key;	49	struct key_matrix_key *key;
51	static struct mbkp_keyscan last_scan;	50	static struct mbkp_keyscan last_scan;
52	static bool last_scan_valid;	51	static bool last_scan_valid;
53	struct mbkp_keyscan scan;	52	struct mbkp_keyscan scan;
54	unsigned int row, col, bit, data;	53	unsigned int row, col, bit, data;
55	int num_keys;	54	int num_keys;
56		55
57	if (cros_ec_scan_keyboard(dev->parent, &scan)) {	56	if (cros_ec_scan_keyboard(dev->parent, &scan)) {
58	debug("%s: keyboard scan failed\n", __func__);	57	debug("%s: keyboard scan failed\n", __func__);
59	return -EIO;	58	return -EIO;
60	}	59	}
61	*samep = last_scan_valid && !memcmp(&last_scan, &scan, sizeof(scan));	60	*samep = last_scan_valid && !memcmp(&last_scan, &scan, sizeof(scan));
62		61
63	/*	62	/*
64	* This is a bit odd. The EC has no way to tell us that it has run	63	* This is a bit odd. The EC has no way to tell us that it has run
65	* out of key scans. It just returns the same scan over and over	64	* out of key scans. It just returns the same scan over and over
66	* again. So the only way to detect that we have run out is to detect	65	* again. So the only way to detect that we have run out is to detect
67	* that this scan is the same as the last.	66	* that this scan is the same as the last.
68	*/	67	*/
69	last_scan_valid = true;	68	last_scan_valid = true;
70	memcpy(&last_scan, &scan, sizeof(last_scan));	69	memcpy(&last_scan, &scan, sizeof(last_scan));
71		70
72	for (col = num_keys = bit = 0; col < priv->matrix.num_cols;	71	for (col = num_keys = bit = 0; col < priv->matrix.num_cols;
73	col++) {	72	col++) {
74	for (row = 0; row < priv->matrix.num_rows; row++) {	73	for (row = 0; row < priv->matrix.num_rows; row++) {
75	unsigned int mask = 1 << (bit & 7);	74	unsigned int mask = 1 << (bit & 7);
76		75
77	data = scan.data[bit / 8];	76	data = scan.data[bit / 8];
78	if ((data & mask) && num_keys < max_count) {	77	if ((data & mask) && num_keys < max_count) {
79	key = keys + num_keys++;	78	key = keys + num_keys++;
80	key->row = row;	79	key->row = row;
81	key->col = col;	80	key->col = col;
82	key->valid = 1;	81	key->valid = 1;
83	}	82	}
84	bit++;	83	bit++;
85	}	84	}
86	}	85	}
87		86
88	return num_keys;	87	return num_keys;
89	}	88	}
90		89
91	/**	90	/**
92	* Check the keyboard, and send any keys that are pressed.	91	* Check the keyboard, and send any keys that are pressed.
93	*	92	*
94	* This is called by input_tstc() and input_getc() when they need more	93	* This is called by input_tstc() and input_getc() when they need more
95	* characters	94	* characters
96	*	95	*
97	* @param input Input configuration	96	* @param input Input configuration
98	* @return 1, to indicate that we have something to look at	97	* @return 1, to indicate that we have something to look at
99	*/	98	*/
100	int cros_ec_kbc_check(struct input_config *input)	99	int cros_ec_kbc_check(struct input_config *input)
101	{	100	{
102	struct udevice *dev = input->dev;	101	struct udevice *dev = input->dev;
103	struct cros_ec_keyb_priv *priv = dev_get_priv(dev);	102	struct cros_ec_keyb_priv *priv = dev_get_priv(dev);
104	static struct key_matrix_key last_keys[KBC_MAX_KEYS];	103	static struct key_matrix_key last_keys[KBC_MAX_KEYS];
105	static int last_num_keys;	104	static int last_num_keys;
106	struct key_matrix_key keys[KBC_MAX_KEYS];	105	struct key_matrix_key keys[KBC_MAX_KEYS];
107	int keycodes[KBC_MAX_KEYS];	106	int keycodes[KBC_MAX_KEYS];
108	int num_keys, num_keycodes;	107	int num_keys, num_keycodes;
109	int irq_pending, sent;	108	int irq_pending, sent;
110	bool same = false;	109	bool same = false;
111		110
112	/*	111	/*
113	* Loop until the EC has no more keyscan records, or we have	112	* Loop until the EC has no more keyscan records, or we have
114	* received at least one character. This means we know that tstc()	113	* received at least one character. This means we know that tstc()
115	* will always return non-zero if keys have been pressed.	114	* will always return non-zero if keys have been pressed.
116	*	115	*
117	* Without this loop, a key release (which generates no new ascii	116	* Without this loop, a key release (which generates no new ascii
118	* characters) will cause us to exit this function, and just tstc()	117	* characters) will cause us to exit this function, and just tstc()
119	* may return 0 before all keys have been read from the EC.	118	* may return 0 before all keys have been read from the EC.
120	*/	119	*/
121	do {	120	do {
122	irq_pending = cros_ec_interrupt_pending(dev->parent);	121	irq_pending = cros_ec_interrupt_pending(dev->parent);
123	if (irq_pending) {	122	if (irq_pending) {
124	num_keys = check_for_keys(dev, keys, KBC_MAX_KEYS,	123	num_keys = check_for_keys(dev, keys, KBC_MAX_KEYS,
125	&same);	124	&same);
126	if (num_keys < 0)	125	if (num_keys < 0)
127	return 0;	126	return 0;
128	last_num_keys = num_keys;	127	last_num_keys = num_keys;
129	memcpy(last_keys, keys, sizeof(keys));	128	memcpy(last_keys, keys, sizeof(keys));
130	} else {	129	} else {
131	/*	130	/*
132	* EC doesn't want to be asked, so use keys from last	131	* EC doesn't want to be asked, so use keys from last
133	* time.	132	* time.
134	*/	133	*/
135	num_keys = last_num_keys;	134	num_keys = last_num_keys;
136	memcpy(keys, last_keys, sizeof(keys));	135	memcpy(keys, last_keys, sizeof(keys));
137	}	136	}
138		137
139	if (num_keys < 0)	138	if (num_keys < 0)
140	return -1;	139	return -1;
141	num_keycodes = key_matrix_decode(&priv->matrix, keys,	140	num_keycodes = key_matrix_decode(&priv->matrix, keys,
142	num_keys, keycodes, KBC_MAX_KEYS);	141	num_keys, keycodes, KBC_MAX_KEYS);
143	sent = input_send_keycodes(input, keycodes, num_keycodes);	142	sent = input_send_keycodes(input, keycodes, num_keycodes);
144		143
145	/*	144	/*
146	* For those ECs without an interrupt, stop scanning when we	145	* For those ECs without an interrupt, stop scanning when we
147	* see that the scan is the same as last time.	146	* see that the scan is the same as last time.
148	*/	147	*/
149	if ((irq_pending < 0) && same)	148	if ((irq_pending < 0) && same)
150	break;	149	break;
151	} while (irq_pending && !sent);	150	} while (irq_pending && !sent);
152		151
153	return 1;	152	return 1;
154	}	153	}
155		154
156	/**	155	/**
157	* Decode MBKP keyboard details from the device tree	156	* Decode MBKP keyboard details from the device tree
158	*	157	*
159	* @param blob Device tree blob	158	* @param blob Device tree blob
160	* @param node Node to decode from	159	* @param node Node to decode from
161	* @param config Configuration data read from fdt	160	* @param config Configuration data read from fdt
162	* @return 0 if ok, -1 on error	161	* @return 0 if ok, -1 on error
163	*/	162	*/
164	static int cros_ec_keyb_decode_fdt(const void *blob, int node,	163	static int cros_ec_keyb_decode_fdt(struct udevice *dev,
165	struct cros_ec_keyb_priv *config)	164	struct cros_ec_keyb_priv *config)
166	{	165	{
167	/*	166	/*
168	* Get keyboard rows and columns - at present we are limited to	167	* Get keyboard rows and columns - at present we are limited to
169	* 8 columns by the protocol (one byte per row scan)	168	* 8 columns by the protocol (one byte per row scan)
170	*/	169	*/
171	config->key_rows = fdtdec_get_int(blob, node, "keypad,num-rows", 0);	170	config->key_rows = dev_read_u32_default(dev, "keypad,num-rows", 0);
172	config->key_cols = fdtdec_get_int(blob, node, "keypad,num-columns", 0);	171	config->key_cols = dev_read_u32_default(dev, "keypad,num-columns", 0);
173	if (!config->key_rows \|\| !config->key_cols \|\|	172	if (!config->key_rows \|\| !config->key_cols \|\|
174	config->key_rows * config->key_cols / 8	173	config->key_rows * config->key_cols / 8
175	> CROS_EC_KEYSCAN_COLS) {	174	> CROS_EC_KEYSCAN_COLS) {
176	debug("%s: Invalid key matrix size %d x %d\n", __func__,	175	debug("%s: Invalid key matrix size %d x %d\n", __func__,
177	config->key_rows, config->key_cols);	176	config->key_rows, config->key_cols);
178	return -1;	177	return -1;
179	}	178	}
180	config->ghost_filter = fdtdec_get_bool(blob, node,	179	config->ghost_filter = dev_read_bool(dev, "google,needs-ghost-filter");
181	"google,needs-ghost-filter");	180
182	return 0;	181	return 0;
183	}	182	}
184		183
185	static int cros_ec_kbd_probe(struct udevice *dev)	184	static int cros_ec_kbd_probe(struct udevice *dev)
186	{	185	{
187	struct cros_ec_keyb_priv *priv = dev_get_priv(dev);	186	struct cros_ec_keyb_priv *priv = dev_get_priv(dev);
188	struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev);	187	struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev);
189	struct stdio_dev *sdev = &uc_priv->sdev;	188	struct stdio_dev *sdev = &uc_priv->sdev;
190	struct input_config *input = &uc_priv->input;	189	struct input_config *input = &uc_priv->input;
191	const void *blob = gd->fdt_blob;
192	int node = dev_of_offset(dev);
193	int ret;	190	int ret;
194		191
195	if (cros_ec_keyb_decode_fdt(blob, node, priv))	192	ret = cros_ec_keyb_decode_fdt(dev, priv);
196	return -1;	193	if (ret) {
		194	debug("%s: Cannot decode node (ret=%d)\n", __func__, ret);
		195	return -EINVAL;
		196	}
197	input_set_delays(input, KBC_REPEAT_DELAY_MS, KBC_REPEAT_RATE_MS);	197	input_set_delays(input, KBC_REPEAT_DELAY_MS, KBC_REPEAT_RATE_MS);
198	ret = key_matrix_init(&priv->matrix, priv->key_rows, priv->key_cols,	198	ret = key_matrix_init(&priv->matrix, priv->key_rows, priv->key_cols,
199	priv->ghost_filter);	199	priv->ghost_filter);
200	if (ret) {	200	if (ret) {
201	debug("%s: cannot init key matrix\n", __func__);	201	debug("%s: cannot init key matrix\n", __func__);
202	return ret;	202	return ret;
203	}	203	}
204	ret = key_matrix_decode_fdt(&priv->matrix, gd->fdt_blob, node);	204	ret = key_matrix_decode_fdt(dev, &priv->matrix);
205	if (ret) {	205	if (ret) {
206	debug("%s: Could not decode key matrix from fdt\n", __func__);	206	debug("%s: Could not decode key matrix from fdt\n", __func__);
207	return ret;	207	return ret;
208	}	208	}
209	debug("%s: Matrix keyboard %dx%d ready\n", __func__, priv->key_rows,	209	debug("%s: Matrix keyboard %dx%d ready\n", __func__, priv->key_rows,
210	priv->key_cols);	210	priv->key_cols);
211		211
212	priv->input = input;	212	priv->input = input;
213	input->dev = dev;	213	input->dev = dev;
214	input_add_tables(input, false);	214	input_add_tables(input, false);
215	input->read_keys = cros_ec_kbc_check;	215	input->read_keys = cros_ec_kbc_check;
216	strcpy(sdev->name, "cros-ec-keyb");	216	strcpy(sdev->name, "cros-ec-keyb");
217		217
218	/* Register the device. cros_ec_init_keyboard() will be called soon */	218	/* Register the device. cros_ec_init_keyboard() will be called soon */
219	return input_stdio_register(sdev);	219	return input_stdio_register(sdev);
220	}	220	}
221		221
222	static const struct keyboard_ops cros_ec_kbd_ops = {	222	static const struct keyboard_ops cros_ec_kbd_ops = {
223	};	223	};
224		224
225	static const struct udevice_id cros_ec_kbd_ids[] = {	225	static const struct udevice_id cros_ec_kbd_ids[] = {
226	{ .compatible = "google,cros-ec-keyb" },	226	{ .compatible = "google,cros-ec-keyb" },
227	{ }	227	{ }
228	};	228	};
229		229
230	U_BOOT_DRIVER(cros_ec_kbd) = {	230	U_BOOT_DRIVER(cros_ec_kbd) = {
231	.name = "cros_ec_kbd",	231	.name = "cros_ec_kbd",
232	.id = UCLASS_KEYBOARD,	232	.id = UCLASS_KEYBOARD,
233	.of_match = cros_ec_kbd_ids,	233	.of_match = cros_ec_kbd_ids,
234	.probe = cros_ec_kbd_probe,	234	.probe = cros_ec_kbd_probe,
235	.ops = &cros_ec_kbd_ops,	235	.ops = &cros_ec_kbd_ops,

drivers/input/key_matrix.c

Diff comments View file @ 8327d41

 /*
  * Manage Keyboard Matrices
  *
  * Copyright (c) 2012 The Chromium OS Authors.
  * (C) Copyright 2004 DENX Software Engineering, Wolfgang Denk, wd@denx.de
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
-#include <fdtdec.h>
+#include <dm.h>
 #include <key_matrix.h>
 #include <malloc.h>
 #include <linux/input.h>
 /**
  * Determine if the current keypress configuration can cause key ghosting
  *
  * We figure this out by seeing if we have two or more keys in the same
  * column, as well as two or more keys in the same row.
  *
  * @param config	Keyboard matrix config
  * @param keys		List of keys to check
  * @param valid		Number of valid keypresses to check
  * @return 0 if no ghosting is possible, 1 if it is
  */
 static int has_ghosting(struct key_matrix *config, struct key_matrix_key *keys,
 			int valid)
 {
 	int key_in_same_col = 0, key_in_same_row = 0;
 	int i, j;
 	if (!config->ghost_filter || valid < 3)
 		return 0;
 	for (i = 0; i < valid; i++) {
 		/*
 		 * Find 2 keys such that one key is in the same row
 		 * and the other is in the same column as the i-th key.
 		 */
 		for (j = i + 1; j < valid; j++) {
 			if (keys[j].col == keys[i].col)
 				key_in_same_col = 1;
 			if (keys[j].row == keys[i].row)
 				key_in_same_row = 1;
 		}
 	}
 	if (key_in_same_col && key_in_same_row)
 		return 1;
 	else
 		return 0;
 }
 int key_matrix_decode(struct key_matrix *config, struct key_matrix_key keys[],
 		      int num_keys, int keycode[], int max_keycodes)
 {
 	const u8 *keymap;
 	int valid, upto;
 	int pos;
 	debug("%s: num_keys = %d\n", __func__, num_keys);
 	keymap = config->plain_keycode;
 	for (valid = upto = 0; upto < num_keys; upto++) {
 		struct key_matrix_key *key = &keys[upto];
 		debug("  valid=%d, row=%d, col=%d\n", key->valid, key->row,
 		      key->col);
 		if (!key->valid)
 			continue;
 		pos = key->row * config->num_cols + key->col;
 		if (config->fn_keycode && pos == config->fn_pos)
 			keymap = config->fn_keycode;
 		/* Convert the (row, col) values into a keycode */
 		if (valid < max_keycodes)
 			keycode[valid++] = keymap[pos];
 		debug("    keycode=%d\n", keymap[pos]);
 	}
 	/* For a ghost key config, ignore the keypresses for this iteration. */
 	if (has_ghosting(config, keys, valid)) {
 		valid = 0;
 		debug("    ghosting detected!\n");
 	}
 	debug("  %d valid keycodes found\n", valid);
 	return valid;
 }
 /**
  * Create a new keycode map from some provided data
  *
  * This decodes a keycode map in the format used by the fdt, which is one
  * word per entry, with the row, col and keycode encoded in that word.
  *
  * We create a (row x col) size byte array with each entry containing the
  * keycode for that (row, col). We also search for map_keycode and return
  * its position if found (this is used for finding the Fn key).
  *
  * @param config        Key matrix dimensions structure
  * @param data          Keycode data
  * @param len           Number of entries in keycode table
  * @param map_keycode   Key code to find in the map
  * @param pos           Returns position of map_keycode, if found, else -1
  * @return map  Pointer to allocated map
  */
-static uchar *create_keymap(struct key_matrix *config, u32 *data, int len,
+static uchar *create_keymap(struct key_matrix *config, const u32 *data, int len,
 			    int map_keycode, int *pos)
 {
 	uchar *map;
 	if (pos)
 		*pos = -1;
 	map = (uchar *)calloc(1, config->key_count);
 	if (!map) {
 		debug("%s: failed to malloc %d bytes\n", __func__,
 			config->key_count);
 		return NULL;
 	}
 	for (; len >= sizeof(u32); data++, len -= 4) {
 		u32 tmp = fdt32_to_cpu(*data);
 		int key_code, row, col;
 		int entry;
 		row = (tmp >> 24) & 0xff;
 		col = (tmp >> 16) & 0xff;
 		key_code = tmp & 0xffff;
 		entry = row * config->num_cols + col;
 		map[entry] = key_code;
 		debug("   map %d, %d: pos=%d, keycode=%d\n", row, col,
 		      entry, key_code);
 		if (pos && map_keycode == key_code)
 			*pos = entry;
 	}
 	return map;
 }
-int key_matrix_decode_fdt(struct key_matrix *config, const void *blob, int node)
+int key_matrix_decode_fdt(struct udevice *dev, struct key_matrix *config)
 {
-	const struct fdt_property *prop;
+	const u32 *prop;
 	int proplen;
 	uchar *plain_keycode;
-	prop = fdt_get_property(blob, node, "linux,keymap", &proplen);
+	prop = dev_read_prop(dev, "linux,keymap", &proplen);
 	/* Basic keymap is required */
 	if (!prop) {
 		debug("%s: cannot find keycode-plain map\n", __func__);
 		return -1;
 	}
-	plain_keycode = create_keymap(config, (u32 *)prop->data,
+	plain_keycode = create_keymap(config, prop, proplen, KEY_FN,
-		proplen, KEY_FN, &config->fn_pos);
+				      &config->fn_pos);
 	config->plain_keycode = plain_keycode;
 	/* Conversion error -> fail */
 	if (!config->plain_keycode)
 		return -1;
-	prop = fdt_get_property(blob, node, "linux,fn-keymap", &proplen);
+	prop = dev_read_prop(dev, "linux,fn-keymap", &proplen);
 	/* fn keymap is optional */
 	if (!prop)
 		goto done;
-	config->fn_keycode = create_keymap(config, (u32 *)prop->data,
+	config->fn_keycode = create_keymap(config, prop, proplen, -1, NULL);
-		proplen, -1, NULL);
 	/* Conversion error -> fail */
 	if (!config->fn_keycode) {
 		free(plain_keycode);
 		return -1;
 	}
 done:
 	debug("%s: Decoded key maps %p, %p from fdt\n", __func__,
 	      config->plain_keycode, config->fn_keycode);
 	return 0;
 }
 int key_matrix_init(struct key_matrix *config, int rows, int cols,
 		    int ghost_filter)
 {
 	memset(config, '\0', sizeof(*config));
 	config->num_rows = rows;
 	config->num_cols = cols;
 	config->key_count = rows * cols;
 	config->ghost_filter = ghost_filter;
 	assert(config->key_count > 0);
 	return 0;
 }

drivers/input/tegra-kbc.c

Diff comments View file @ 8327d41

 /*
  *  (C) Copyright 2011
  *  NVIDIA Corporation <www.nvidia.com>
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #include <common.h>
 #include <dm.h>
 #include <fdtdec.h>
 #include <input.h>
 #include <keyboard.h>
 #include <key_matrix.h>
 #include <stdio_dev.h>
 #include <tegra-kbc.h>
 #include <asm/io.h>
 #include <asm/arch/clock.h>
 #include <asm/arch/funcmux.h>
 #include <asm/arch-tegra/timer.h>
 #include <linux/input.h>
 DECLARE_GLOBAL_DATA_PTR;
 enum {
 	KBC_MAX_GPIO		= 24,
 	KBC_MAX_KPENT		= 8,	/* size of keypress entry queue */
 };
 #define KBC_FIFO_TH_CNT_SHIFT		14
 #define KBC_DEBOUNCE_CNT_SHIFT		4
 #define KBC_CONTROL_FIFO_CNT_INT_EN	(1 << 3)
 #define KBC_CONTROL_KBC_EN		(1 << 0)
 #define KBC_INT_FIFO_CNT_INT_STATUS	(1 << 2)
 #define KBC_KPENT_VALID			(1 << 7)
 #define KBC_ST_STATUS			(1 << 3)
 enum {
 	KBC_DEBOUNCE_COUNT	= 2,
 	KBC_REPEAT_RATE_MS	= 30,
 	KBC_REPEAT_DELAY_MS	= 240,
 	KBC_CLOCK_KHZ		= 32,	/* Keyboard uses a 32KHz clock */
 };
 /* keyboard controller config and state */
 struct tegra_kbd_priv {
 	struct input_config *input;	/* The input layer */
 	struct key_matrix matrix;	/* The key matrix layer */
 	struct kbc_tegra *kbc;		/* tegra keyboard controller */
 	unsigned char inited;		/* 1 if keyboard has been inited */
 	unsigned char first_scan;	/* 1 if this is our first key scan */
 	/*
 	 * After init we must wait a short time before polling the keyboard.
 	 * This gives the tegra keyboard controller time to react after reset
 	 * and lets us grab keys pressed during reset.
 	 */
 	unsigned int init_dly_ms;	/* Delay before we can read keyboard */
 	unsigned int start_time_ms;	/* Time that we inited (in ms) */
 	unsigned int last_poll_ms;	/* Time we should last polled */
 	unsigned int next_repeat_ms;	/* Next time we repeat a key */
 };
 /**
  * reads the keyboard fifo for current keypresses
  *
  * @param priv		Keyboard private data
  * @param fifo		Place to put fifo results
  * @param max_keycodes	Maximum number of key codes to put in the fifo
  * @return number of items put into fifo
  */
 static int tegra_kbc_find_keys(struct tegra_kbd_priv *priv, int *fifo,
 			       int max_keycodes)
 {
 	struct key_matrix_key keys[KBC_MAX_KPENT], *key;
 	u32 kp_ent = 0;
 	int i;
 	for (key = keys, i = 0; i < KBC_MAX_KPENT; i++, key++) {
 		/* Get next word */
 		if (!(i & 3))
 			kp_ent = readl(&priv->kbc->kp_ent[i / 4]);
 		key->valid = (kp_ent & KBC_KPENT_VALID) != 0;
 		key->row = (kp_ent >> 3) & 0xf;
 		key->col = kp_ent & 0x7;
 		/* Shift to get next entry */
 		kp_ent >>= 8;
 	}
 	return key_matrix_decode(&priv->matrix, keys, KBC_MAX_KPENT, fifo,
 				 max_keycodes);
 }
 /**
  * Process all the keypress sequences in fifo and send key codes
  *
  * The fifo contains zero or more keypress sets. Each set
  * consists of from 1-8 keycodes, representing the keycodes which
  * were simultaneously pressed during that scan.
  *
  * This function works through each set and generates ASCII characters
  * for each. Not that one set may produce more than one ASCII characters -
  * for example holding down 'd' and 'f' at the same time will generate
  * two ASCII characters.
  *
  * Note: if fifo_cnt is 0, we will tell the input layer that no keys are
  * pressed.
  *
  * @param priv		Keyboard private data
  * @param fifo_cnt	Number of entries in the keyboard fifo
  */
 static void process_fifo(struct tegra_kbd_priv *priv, int fifo_cnt)
 {
 	int fifo[KBC_MAX_KPENT];
 	int cnt = 0;
 	/* Always call input_send_keycodes() at least once */
 	do {
 		if (fifo_cnt)
 			cnt = tegra_kbc_find_keys(priv, fifo, KBC_MAX_KPENT);
 		input_send_keycodes(priv->input, fifo, cnt);
 	} while (--fifo_cnt > 0);
 }
 /**
  * Check the keyboard controller and emit ASCII characters for any keys that
  * are pressed.
  *
  * @param priv		Keyboard private data
  */
 static void check_for_keys(struct tegra_kbd_priv *priv)
 {
 	int fifo_cnt;
 	if (!priv->first_scan &&
 	    get_timer(priv->last_poll_ms) < KBC_REPEAT_RATE_MS)
 		return;
 	priv->last_poll_ms = get_timer(0);
 	priv->first_scan = 0;
 	/*
 	 * Once we get here we know the keyboard has been scanned. So if there
 	 * scan waiting for us, we know that nothing is held down.
 	 */
 	fifo_cnt = (readl(&priv->kbc->interrupt) >> 4) & 0xf;
 	process_fifo(priv, fifo_cnt);
 }
 /**
  * In order to detect keys pressed on boot, wait for the hardware to
  * complete scanning the keys. This includes time to transition from
  * Wkup mode to Continous polling mode and the repoll time. We can
  * deduct the time that's already elapsed.
  *
  * @param priv		Keyboard private data
  */
 static void kbd_wait_for_fifo_init(struct tegra_kbd_priv *priv)
 {
 	if (!priv->inited) {
 		unsigned long elapsed_time;
 		long delay_ms;
 		elapsed_time = get_timer(priv->start_time_ms);
 		delay_ms = priv->init_dly_ms - elapsed_time;
 		if (delay_ms > 0) {
 			udelay(delay_ms * 1000);
 			debug("%s: delay %ldms\n", __func__, delay_ms);
 		}
 		priv->inited = 1;
 	}
 }
 /**
  * Check the tegra keyboard, and send any keys that are pressed.
  *
  * This is called by input_tstc() and input_getc() when they need more
  * characters
  *
  * @param input		Input configuration
  * @return 1, to indicate that we have something to look at
  */
 static int tegra_kbc_check(struct input_config *input)
 {
 	struct tegra_kbd_priv *priv = dev_get_priv(input->dev);
 	kbd_wait_for_fifo_init(priv);
 	check_for_keys(priv);
 	return 1;
 }
 /* configures keyboard GPIO registers to use the rows and columns */
 static void config_kbc_gpio(struct tegra_kbd_priv *priv, struct kbc_tegra *kbc)
 {
 	int i;
 	for (i = 0; i < KBC_MAX_GPIO; i++) {
 		u32 row_cfg, col_cfg;
 		u32 r_shift = 5 * (i % 6);
 		u32 c_shift = 4 * (i % 8);
 		u32 r_mask = 0x1f << r_shift;
 		u32 c_mask = 0xf << c_shift;
 		u32 r_offs = i / 6;
 		u32 c_offs = i / 8;
 		row_cfg = readl(&kbc->row_cfg[r_offs]);
 		col_cfg = readl(&kbc->col_cfg[c_offs]);
 		row_cfg &= ~r_mask;
 		col_cfg &= ~c_mask;
 		if (i < priv->matrix.num_rows) {
 			row_cfg |= ((i << 1) | 1) << r_shift;
 		} else {
 			col_cfg |= (((i - priv->matrix.num_rows) << 1) | 1)
 					<< c_shift;
 		}
 		writel(row_cfg, &kbc->row_cfg[r_offs]);
 		writel(col_cfg, &kbc->col_cfg[c_offs]);
 	}
 }
 /**
  * Start up the keyboard device
  */
 static void tegra_kbc_open(struct tegra_kbd_priv *priv)
 {
 	struct kbc_tegra *kbc = priv->kbc;
 	unsigned int scan_period;
 	u32 val;
 	/*
 	 * We will scan at twice the keyboard repeat rate, so that there is
 	 * always a scan ready when we check it in check_for_keys().
 	 */
 	scan_period = KBC_REPEAT_RATE_MS / 2;
 	writel(scan_period * KBC_CLOCK_KHZ, &kbc->rpt_dly);
 	writel(scan_period * KBC_CLOCK_KHZ, &kbc->init_dly);
 	/*
 	 * Before reading from the keyboard we must wait for the init_dly
 	 * plus the rpt_delay, plus 2ms for the row scan time.
 	 */
 	priv->init_dly_ms = scan_period * 2 + 2;
 	val = KBC_DEBOUNCE_COUNT << KBC_DEBOUNCE_CNT_SHIFT;
 	val |= 1 << KBC_FIFO_TH_CNT_SHIFT;	/* fifo interrupt threshold */
 	val |= KBC_CONTROL_KBC_EN;		/* enable */
 	writel(val, &kbc->control);
 	priv->start_time_ms = get_timer(0);
 	priv->last_poll_ms = get_timer(0);
 	priv->next_repeat_ms = priv->last_poll_ms;
 	priv->first_scan = 1;
 }
 static int tegra_kbd_start(struct udevice *dev)
 {
 	struct tegra_kbd_priv *priv = dev_get_priv(dev);
 	/* Set up pin mux and enable the clock */
 	funcmux_select(PERIPH_ID_KBC, FUNCMUX_DEFAULT);
 	clock_enable(PERIPH_ID_KBC);
 	config_kbc_gpio(priv, priv->kbc);
 	tegra_kbc_open(priv);
 	debug("%s: Tegra keyboard ready\n", __func__);
 	return 0;
 }
 /**
  * Set up the tegra keyboard. This is called by the stdio device handler
  *
  * We want to do this init when the keyboard is actually used rather than
  * at start-up, since keyboard input may not currently be selected.
  *
  * Once the keyboard starts there will be a period during which we must
  * wait for the keyboard to init. We do this only when a key is first
  * read - see kbd_wait_for_fifo_init().
  *
  * @return 0 if ok, -ve on error
  */
 static int tegra_kbd_probe(struct udevice *dev)
 {
 	struct tegra_kbd_priv *priv = dev_get_priv(dev);
 	struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev);
 	struct stdio_dev *sdev = &uc_priv->sdev;
 	struct input_config *input = &uc_priv->input;
-	int node = dev_of_offset(dev);
 	int ret;
 	priv->kbc = (struct kbc_tegra *)devfdt_get_addr(dev);
 	if ((fdt_addr_t)priv->kbc == FDT_ADDR_T_NONE) {
 		debug("%s: No keyboard register found\n", __func__);
 		return -EINVAL;
 	}
 	input_set_delays(input, KBC_REPEAT_DELAY_MS, KBC_REPEAT_RATE_MS);
 	/* Decode the keyboard matrix information (16 rows, 8 columns) */
 	ret = key_matrix_init(&priv->matrix, 16, 8, 1);
 	if (ret) {
 		debug("%s: Could not init key matrix: %d\n", __func__, ret);
 		return ret;
 	}
-	ret = key_matrix_decode_fdt(&priv->matrix, gd->fdt_blob, node);
+	ret = key_matrix_decode_fdt(dev, &priv->matrix);
 	if (ret) {
 		debug("%s: Could not decode key matrix from fdt: %d\n",
 		      __func__, ret);
 		return ret;
 	}
 	input_add_tables(input, false);
 	if (priv->matrix.fn_keycode) {
 		ret = input_add_table(input, KEY_FN, -1,
 				      priv->matrix.fn_keycode,
 				      priv->matrix.key_count);
 		if (ret) {
 			debug("%s: input_add_table() failed\n", __func__);
 			return ret;
 		}
 	}
 	/* Register the device. init_tegra_keyboard() will be called soon */
 	priv->input = input;
 	input->dev = dev;
 	input->read_keys = tegra_kbc_check;
 	strcpy(sdev->name, "tegra-kbc");
 	ret = input_stdio_register(sdev);
 	if (ret) {
 		debug("%s: input_stdio_register() failed\n", __func__);
 		return ret;
 	}
 	return 0;
 }
 static const struct keyboard_ops tegra_kbd_ops = {
 	.start	= tegra_kbd_start,
 };
 static const struct udevice_id tegra_kbd_ids[] = {
 	{ .compatible = "nvidia,tegra20-kbc" },
 	{ }
 };
 U_BOOT_DRIVER(tegra_kbd) = {
 	.name	= "tegra_kbd",
 	.id	= UCLASS_KEYBOARD,
 	.of_match = tegra_kbd_ids,
 	.probe = tegra_kbd_probe,
 	.ops	= &tegra_kbd_ops,
 	.priv_auto_alloc_size = sizeof(struct tegra_kbd_priv),
 };

include/key_matrix.h

Diff comments View file @ 8327d41

 /*
  * Keyboard matrix helper functions
  *
  * Copyright (c) 2012 The Chromium OS Authors.
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef _KEY_MATRIX_H
 #define _KEY_MATRIX_H
 #include <common.h>
 /* Information about a matrix keyboard */
 struct key_matrix {
 	/* Dimensions of the keyboard matrix, in rows and columns */
 	int num_rows;
 	int num_cols;
 	int key_count;	/* number of keys in the matrix (= rows * cols) */
 	/*
 	 * Information about keycode mappings. The plain_keycode array must
 	 * exist but fn may be NULL in which case it is not decoded.
 	 */
 	const u8 *plain_keycode;        /* key code for each row / column */
 	const u8 *fn_keycode;           /* ...when Fn held down */
 	int fn_pos;                     /* position of Fn key in key (or -1) */
 	int ghost_filter;		/* non-zero to enable ghost filter */
 };
 /* Information about a particular key (row, column pair) in the matrix */
 struct key_matrix_key {
 	uint8_t row;	/* row number (0 = first) */
 	uint8_t col;	/* column number (0 = first) */
 	uint8_t valid;	/* 1 if valid, 0 to ignore this */
 };
 /**
  * Decode a set of pressed keys into key codes
  *
  * Given a list of keys that are pressed, this converts this list into
  * a list of key codes. Each of the keys has a valid flag, which can be
  * used to mark a particular key as invalid (so that it is ignored).
  *
  * The plain keymap is used, unless the Fn key is detected along the way,
  * at which point we switch to the Fn key map.
  *
  * If key ghosting is detected, we simply ignore the keys and return 0.
  *
  * @param config        Keyboard matrix config
  * @param keys		List of keys to process (each is row, col)
  * @param num_keys	Number of keys to process
  * @param keycode	Returns a list of key codes, decoded from input
  * @param max_keycodes	Size of key codes array (suggest 8)
  *
  */
 int key_matrix_decode(struct key_matrix *config, struct key_matrix_key *keys,
 		      int num_keys, int keycode[], int max_keycodes);
 /**
  * Read the keyboard configuration out of the fdt.
  *
  * Decode properties of named "linux,<type>keymap" where <type> is either
  * empty, or "fn-". Then set up the plain key map (and the FN keymap if
  * present).
  *
  * @param config        Keyboard matrix config
  * @param blob          FDT blob
  * @param node          Node containing compatible data
  * @return 0 if ok, -1 on error
  */
-int key_matrix_decode_fdt(struct key_matrix *config, const void *blob,
+int key_matrix_decode_fdt(struct udevice *dev, struct key_matrix *config);
-			  int node);
 /**
  * Set up a new key matrix.
  *
  * @param config	Keyboard matrix config
  * @param rows		Number of rows in key matrix
  * @param cols		Number of columns in key matrix
  * @param ghost_filter	Non-zero to enable ghost filtering
  * @return 0 if ok, -1 on error
  */
 int key_matrix_init(struct key_matrix *config, int rows, int cols,
 		    int ghost_filter);
 #endif