1 /* 2 * (C) Copyright 2011 3 * NVIDIA Corporation <www.nvidia.com> 4 * 5 * SPDX-License-Identifier: GPL-2.0+ 6 */ 7 8 #include <common.h> 9 #include <dm.h> 10 #include <fdtdec.h> 11 #include <input.h> 12 #include <keyboard.h> 13 #include <key_matrix.h> 14 #include <stdio_dev.h> 15 #include <tegra-kbc.h> 16 #include <asm/io.h> 17 #include <asm/arch/clock.h> 18 #include <asm/arch/funcmux.h> 19 #include <asm/arch-tegra/timer.h> 20 #include <linux/input.h> 21 22 enum { 23 KBC_MAX_GPIO = 24, 24 KBC_MAX_KPENT = 8, /* size of keypress entry queue */ 25 }; 26 27 #define KBC_FIFO_TH_CNT_SHIFT 14 28 #define KBC_DEBOUNCE_CNT_SHIFT 4 29 #define KBC_CONTROL_FIFO_CNT_INT_EN (1 << 3) 30 #define KBC_CONTROL_KBC_EN (1 << 0) 31 #define KBC_INT_FIFO_CNT_INT_STATUS (1 << 2) 32 #define KBC_KPENT_VALID (1 << 7) 33 #define KBC_ST_STATUS (1 << 3) 34 35 enum { 36 KBC_DEBOUNCE_COUNT = 2, 37 KBC_REPEAT_RATE_MS = 30, 38 KBC_REPEAT_DELAY_MS = 240, 39 KBC_CLOCK_KHZ = 32, /* Keyboard uses a 32KHz clock */ 40 }; 41 42 /* keyboard controller config and state */ 43 struct tegra_kbd_priv { 44 struct input_config *input; /* The input layer */ 45 struct key_matrix matrix; /* The key matrix layer */ 46 47 struct kbc_tegra *kbc; /* tegra keyboard controller */ 48 unsigned char inited; /* 1 if keyboard has been inited */ 49 unsigned char first_scan; /* 1 if this is our first key scan */ 50 51 /* 52 * After init we must wait a short time before polling the keyboard. 53 * This gives the tegra keyboard controller time to react after reset 54 * and lets us grab keys pressed during reset. 55 */ 56 unsigned int init_dly_ms; /* Delay before we can read keyboard */ 57 unsigned int start_time_ms; /* Time that we inited (in ms) */ 58 unsigned int last_poll_ms; /* Time we should last polled */ 59 unsigned int next_repeat_ms; /* Next time we repeat a key */ 60 }; 61 62 /** 63 * reads the keyboard fifo for current keypresses 64 * 65 * @param priv Keyboard private data 66 * @param fifo Place to put fifo results 67 * @param max_keycodes Maximum number of key codes to put in the fifo 68 * @return number of items put into fifo 69 */ 70 static int tegra_kbc_find_keys(struct tegra_kbd_priv *priv, int *fifo, 71 int max_keycodes) 72 { 73 struct key_matrix_key keys[KBC_MAX_KPENT], *key; 74 u32 kp_ent = 0; 75 int i; 76 77 for (key = keys, i = 0; i < KBC_MAX_KPENT; i++, key++) { 78 /* Get next word */ 79 if (!(i & 3)) 80 kp_ent = readl(&priv->kbc->kp_ent[i / 4]); 81 82 key->valid = (kp_ent & KBC_KPENT_VALID) != 0; 83 key->row = (kp_ent >> 3) & 0xf; 84 key->col = kp_ent & 0x7; 85 86 /* Shift to get next entry */ 87 kp_ent >>= 8; 88 } 89 return key_matrix_decode(&priv->matrix, keys, KBC_MAX_KPENT, fifo, 90 max_keycodes); 91 } 92 93 /** 94 * Process all the keypress sequences in fifo and send key codes 95 * 96 * The fifo contains zero or more keypress sets. Each set 97 * consists of from 1-8 keycodes, representing the keycodes which 98 * were simultaneously pressed during that scan. 99 * 100 * This function works through each set and generates ASCII characters 101 * for each. Not that one set may produce more than one ASCII characters - 102 * for example holding down 'd' and 'f' at the same time will generate 103 * two ASCII characters. 104 * 105 * Note: if fifo_cnt is 0, we will tell the input layer that no keys are 106 * pressed. 107 * 108 * @param priv Keyboard private data 109 * @param fifo_cnt Number of entries in the keyboard fifo 110 */ 111 static void process_fifo(struct tegra_kbd_priv *priv, int fifo_cnt) 112 { 113 int fifo[KBC_MAX_KPENT]; 114 int cnt = 0; 115 116 /* Always call input_send_keycodes() at least once */ 117 do { 118 if (fifo_cnt) 119 cnt = tegra_kbc_find_keys(priv, fifo, KBC_MAX_KPENT); 120 121 input_send_keycodes(priv->input, fifo, cnt); 122 } while (--fifo_cnt > 0); 123 } 124 125 /** 126 * Check the keyboard controller and emit ASCII characters for any keys that 127 * are pressed. 128 * 129 * @param priv Keyboard private data 130 */ 131 static void check_for_keys(struct tegra_kbd_priv *priv) 132 { 133 int fifo_cnt; 134 135 if (!priv->first_scan && 136 get_timer(priv->last_poll_ms) < KBC_REPEAT_RATE_MS) 137 return; 138 priv->last_poll_ms = get_timer(0); 139 priv->first_scan = 0; 140 141 /* 142 * Once we get here we know the keyboard has been scanned. So if there 143 * scan waiting for us, we know that nothing is held down. 144 */ 145 fifo_cnt = (readl(&priv->kbc->interrupt) >> 4) & 0xf; 146 process_fifo(priv, fifo_cnt); 147 } 148 149 /** 150 * In order to detect keys pressed on boot, wait for the hardware to 151 * complete scanning the keys. This includes time to transition from 152 * Wkup mode to Continous polling mode and the repoll time. We can 153 * deduct the time that's already elapsed. 154 * 155 * @param priv Keyboard private data 156 */ 157 static void kbd_wait_for_fifo_init(struct tegra_kbd_priv *priv) 158 { 159 if (!priv->inited) { 160 unsigned long elapsed_time; 161 long delay_ms; 162 163 elapsed_time = get_timer(priv->start_time_ms); 164 delay_ms = priv->init_dly_ms - elapsed_time; 165 if (delay_ms > 0) { 166 udelay(delay_ms * 1000); 167 debug("%s: delay %ldms\n", __func__, delay_ms); 168 } 169 170 priv->inited = 1; 171 } 172 } 173 174 /** 175 * Check the tegra keyboard, and send any keys that are pressed. 176 * 177 * This is called by input_tstc() and input_getc() when they need more 178 * characters 179 * 180 * @param input Input configuration 181 * @return 1, to indicate that we have something to look at 182 */ 183 static int tegra_kbc_check(struct input_config *input) 184 { 185 struct tegra_kbd_priv *priv = dev_get_priv(input->dev); 186 187 kbd_wait_for_fifo_init(priv); 188 check_for_keys(priv); 189 190 return 1; 191 } 192 193 /* configures keyboard GPIO registers to use the rows and columns */ 194 static void config_kbc_gpio(struct tegra_kbd_priv *priv, struct kbc_tegra *kbc) 195 { 196 int i; 197 198 for (i = 0; i < KBC_MAX_GPIO; i++) { 199 u32 row_cfg, col_cfg; 200 u32 r_shift = 5 * (i % 6); 201 u32 c_shift = 4 * (i % 8); 202 u32 r_mask = 0x1f << r_shift; 203 u32 c_mask = 0xf << c_shift; 204 u32 r_offs = i / 6; 205 u32 c_offs = i / 8; 206 207 row_cfg = readl(&kbc->row_cfg[r_offs]); 208 col_cfg = readl(&kbc->col_cfg[c_offs]); 209 210 row_cfg &= ~r_mask; 211 col_cfg &= ~c_mask; 212 213 if (i < priv->matrix.num_rows) { 214 row_cfg |= ((i << 1) | 1) << r_shift; 215 } else { 216 col_cfg |= (((i - priv->matrix.num_rows) << 1) | 1) 217 << c_shift; 218 } 219 220 writel(row_cfg, &kbc->row_cfg[r_offs]); 221 writel(col_cfg, &kbc->col_cfg[c_offs]); 222 } 223 } 224 225 /** 226 * Start up the keyboard device 227 */ 228 static void tegra_kbc_open(struct tegra_kbd_priv *priv) 229 { 230 struct kbc_tegra *kbc = priv->kbc; 231 unsigned int scan_period; 232 u32 val; 233 234 /* 235 * We will scan at twice the keyboard repeat rate, so that there is 236 * always a scan ready when we check it in check_for_keys(). 237 */ 238 scan_period = KBC_REPEAT_RATE_MS / 2; 239 writel(scan_period * KBC_CLOCK_KHZ, &kbc->rpt_dly); 240 writel(scan_period * KBC_CLOCK_KHZ, &kbc->init_dly); 241 /* 242 * Before reading from the keyboard we must wait for the init_dly 243 * plus the rpt_delay, plus 2ms for the row scan time. 244 */ 245 priv->init_dly_ms = scan_period * 2 + 2; 246 247 val = KBC_DEBOUNCE_COUNT << KBC_DEBOUNCE_CNT_SHIFT; 248 val |= 1 << KBC_FIFO_TH_CNT_SHIFT; /* fifo interrupt threshold */ 249 val |= KBC_CONTROL_KBC_EN; /* enable */ 250 writel(val, &kbc->control); 251 252 priv->start_time_ms = get_timer(0); 253 priv->last_poll_ms = get_timer(0); 254 priv->next_repeat_ms = priv->last_poll_ms; 255 priv->first_scan = 1; 256 } 257 258 static int tegra_kbd_start(struct udevice *dev) 259 { 260 struct tegra_kbd_priv *priv = dev_get_priv(dev); 261 262 /* Set up pin mux and enable the clock */ 263 funcmux_select(PERIPH_ID_KBC, FUNCMUX_DEFAULT); 264 clock_enable(PERIPH_ID_KBC); 265 config_kbc_gpio(priv, priv->kbc); 266 267 tegra_kbc_open(priv); 268 debug("%s: Tegra keyboard ready\n", __func__); 269 270 return 0; 271 } 272 273 /** 274 * Set up the tegra keyboard. This is called by the stdio device handler 275 * 276 * We want to do this init when the keyboard is actually used rather than 277 * at start-up, since keyboard input may not currently be selected. 278 * 279 * Once the keyboard starts there will be a period during which we must 280 * wait for the keyboard to init. We do this only when a key is first 281 * read - see kbd_wait_for_fifo_init(). 282 * 283 * @return 0 if ok, -ve on error 284 */ 285 static int tegra_kbd_probe(struct udevice *dev) 286 { 287 struct tegra_kbd_priv *priv = dev_get_priv(dev); 288 struct keyboard_priv *uc_priv = dev_get_uclass_priv(dev); 289 struct stdio_dev *sdev = &uc_priv->sdev; 290 struct input_config *input = &uc_priv->input; 291 int ret; 292 293 priv->kbc = (struct kbc_tegra *)devfdt_get_addr(dev); 294 if ((fdt_addr_t)priv->kbc == FDT_ADDR_T_NONE) { 295 debug("%s: No keyboard register found\n", __func__); 296 return -EINVAL; 297 } 298 input_set_delays(input, KBC_REPEAT_DELAY_MS, KBC_REPEAT_RATE_MS); 299 300 /* Decode the keyboard matrix information (16 rows, 8 columns) */ 301 ret = key_matrix_init(&priv->matrix, 16, 8, 1); 302 if (ret) { 303 debug("%s: Could not init key matrix: %d\n", __func__, ret); 304 return ret; 305 } 306 ret = key_matrix_decode_fdt(dev, &priv->matrix); 307 if (ret) { 308 debug("%s: Could not decode key matrix from fdt: %d\n", 309 __func__, ret); 310 return ret; 311 } 312 input_add_tables(input, false); 313 if (priv->matrix.fn_keycode) { 314 ret = input_add_table(input, KEY_FN, -1, 315 priv->matrix.fn_keycode, 316 priv->matrix.key_count); 317 if (ret) { 318 debug("%s: input_add_table() failed\n", __func__); 319 return ret; 320 } 321 } 322 323 /* Register the device. init_tegra_keyboard() will be called soon */ 324 priv->input = input; 325 input->dev = dev; 326 input->read_keys = tegra_kbc_check; 327 strcpy(sdev->name, "tegra-kbc"); 328 ret = input_stdio_register(sdev); 329 if (ret) { 330 debug("%s: input_stdio_register() failed\n", __func__); 331 return ret; 332 } 333 334 return 0; 335 } 336 337 static const struct keyboard_ops tegra_kbd_ops = { 338 .start = tegra_kbd_start, 339 }; 340 341 static const struct udevice_id tegra_kbd_ids[] = { 342 { .compatible = "nvidia,tegra20-kbc" }, 343 { } 344 }; 345 346 U_BOOT_DRIVER(tegra_kbd) = { 347 .name = "tegra_kbd", 348 .id = UCLASS_KEYBOARD, 349 .of_match = tegra_kbd_ids, 350 .probe = tegra_kbd_probe, 351 .ops = &tegra_kbd_ops, 352 .priv_auto_alloc_size = sizeof(struct tegra_kbd_priv), 353 }; 354