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