mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-29 05:18:51 +09:00
![Tom Rini](/assets/img/avatar_default.png)
When U-Boot started using SPDX tags we were among the early adopters and there weren't a lot of other examples to borrow from. So we picked the area of the file that usually had a full license text and replaced it with an appropriate SPDX-License-Identifier: entry. Since then, the Linux Kernel has adopted SPDX tags and they place it as the very first line in a file (except where shebangs are used, then it's second line) and with slightly different comment styles than us. In part due to community overlap, in part due to better tag visibility and in part for other minor reasons, switch over to that style. This commit changes all instances where we have a single declared license in the tag as both the before and after are identical in tag contents. There's also a few places where I found we did not have a tag and have introduced one. Signed-off-by: Tom Rini <trini@konsulko.com>
190 lines
4.9 KiB
C
190 lines
4.9 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* Manage Keyboard Matrices
|
|
*
|
|
* Copyright (c) 2012 The Chromium OS Authors.
|
|
* (C) Copyright 2004 DENX Software Engineering, Wolfgang Denk, wd@denx.de
|
|
*/
|
|
|
|
#include <common.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, 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 udevice *dev, struct key_matrix *config)
|
|
{
|
|
const u32 *prop;
|
|
int proplen;
|
|
uchar *plain_keycode;
|
|
|
|
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, prop, proplen, KEY_FN,
|
|
&config->fn_pos);
|
|
config->plain_keycode = plain_keycode;
|
|
/* Conversion error -> fail */
|
|
if (!config->plain_keycode)
|
|
return -1;
|
|
|
|
prop = dev_read_prop(dev, "linux,fn-keymap", &proplen);
|
|
/* fn keymap is optional */
|
|
if (!prop)
|
|
goto done;
|
|
|
|
config->fn_keycode = create_keymap(config, prop, 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;
|
|
}
|