mirror of
https://github.com/brain-hackers/u-boot-brain
synced 2024-08-20 00:48:52 +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>
353 lines
9.4 KiB
C
353 lines
9.4 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* (C) Copyright 2011
|
|
* NVIDIA Corporation <www.nvidia.com>
|
|
*/
|
|
|
|
#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>
|
|
|
|
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 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(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),
|
|
};
|