mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-25 19:38:52 +09:00
![Wolfgang Denk](/assets/img/avatar_default.png)
Signed-off-by: Wolfgang Denk <wd@denx.de> [trini: Fixup common/cmd_io.c] Signed-off-by: Tom Rini <trini@ti.com>
192 lines
5.0 KiB
C
192 lines
5.0 KiB
C
/*
|
|
* 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 <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,
|
|
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)
|
|
{
|
|
const struct fdt_property *prop;
|
|
int proplen;
|
|
uchar *plain_keycode;
|
|
|
|
prop = fdt_get_property(blob, node, "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,
|
|
proplen, KEY_FN, &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);
|
|
/* fn keymap is optional */
|
|
if (!prop)
|
|
goto done;
|
|
|
|
config->fn_keycode = create_keymap(config, (u32 *)prop->data,
|
|
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;
|
|
}
|