1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * (C) Copyright 2012 4 * Ивайло Димитров <freemangordon@abv.bg> 5 * 6 * (C) Copyright 2011-2012 7 * Pali Rohár <pali.rohar@gmail.com> 8 * 9 * (C) Copyright 2010 10 * Alistair Buxton <a.j.buxton@gmail.com> 11 * 12 * Derived from Beagle Board and 3430 SDP code: 13 * (C) Copyright 2004-2008 14 * Texas Instruments, <www.ti.com> 15 * 16 * Author : 17 * Sunil Kumar <sunilsaini05@gmail.com> 18 * Shashi Ranjan <shashiranjanmca05@gmail.com> 19 * 20 * Richard Woodruff <r-woodruff2@ti.com> 21 * Syed Mohammed Khasim <khasim@ti.com> 22 */ 23 24 #include <common.h> 25 #include <watchdog.h> 26 #include <malloc.h> 27 #include <twl4030.h> 28 #include <i2c.h> 29 #include <video_fb.h> 30 #include <asm/io.h> 31 #include <asm/setup.h> 32 #include <asm/bitops.h> 33 #include <asm/mach-types.h> 34 #include <asm/arch/mux.h> 35 #include <asm/arch/sys_proto.h> 36 #include <asm/arch/mmc_host_def.h> 37 38 #include "rx51.h" 39 #include "tag_omap.h" 40 41 DECLARE_GLOBAL_DATA_PTR; 42 43 GraphicDevice gdev; 44 45 const omap3_sysinfo sysinfo = { 46 DDR_STACKED, 47 "Nokia RX-51", 48 "OneNAND" 49 }; 50 51 /* This structure contains default omap tags needed for booting Maemo 5 */ 52 static struct tag_omap omap[] = { 53 OMAP_TAG_UART_CONFIG(0x04), 54 OMAP_TAG_SERIAL_CONSOLE_CONFIG(0x03, 0x01C200), 55 OMAP_TAG_LCD_CONFIG("acx565akm", "internal", 90, 0x18), 56 OMAP_TAG_GPIO_SWITCH_CONFIG("cam_focus", 0x44, 0x1, 0x2, 0x0), 57 OMAP_TAG_GPIO_SWITCH_CONFIG("cam_launch", 0x45, 0x1, 0x2, 0x0), 58 OMAP_TAG_GPIO_SWITCH_CONFIG("cam_shutter", 0x6e, 0x1, 0x0, 0x0), 59 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_apeslpx", 0x46, 0x2, 0x2, 0x0), 60 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_bsi", 0x9d, 0x2, 0x2, 0x0), 61 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_en", 0x4a, 0x2, 0x2, 0x0), 62 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_rst", 0x4b, 0x6, 0x2, 0x0), 63 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_rst_rq", 0x49, 0x6, 0x2, 0x0), 64 OMAP_TAG_GPIO_SWITCH_CONFIG("cmt_wddis", 0x0d, 0x2, 0x2, 0x0), 65 OMAP_TAG_GPIO_SWITCH_CONFIG("headphone", 0xb1, 0x1, 0x1, 0x0), 66 OMAP_TAG_GPIO_SWITCH_CONFIG("kb_lock", 0x71, 0x1, 0x0, 0x0), 67 OMAP_TAG_GPIO_SWITCH_CONFIG("proximity", 0x59, 0x0, 0x0, 0x0), 68 OMAP_TAG_GPIO_SWITCH_CONFIG("sleep_ind", 0xa2, 0x2, 0x2, 0x0), 69 OMAP_TAG_GPIO_SWITCH_CONFIG("slide", GPIO_SLIDE, 0x0, 0x0, 0x0), 70 OMAP_TAG_WLAN_CX3110X_CONFIG(0x25, 0xff, 87, 42, -1), 71 OMAP_TAG_PARTITION_CONFIG(PART1_NAME, PART1_SIZE * PART1_MULL, 72 PART1_OFFS, PART1_MASK), 73 OMAP_TAG_PARTITION_CONFIG(PART2_NAME, PART2_SIZE * PART2_MULL, 74 PART2_OFFS, PART2_MASK), 75 OMAP_TAG_PARTITION_CONFIG(PART3_NAME, PART3_SIZE * PART3_MULL, 76 PART3_OFFS, PART3_MASK), 77 OMAP_TAG_PARTITION_CONFIG(PART4_NAME, PART4_SIZE * PART4_MULL, 78 PART4_OFFS, PART4_MASK), 79 OMAP_TAG_PARTITION_CONFIG(PART5_NAME, PART5_SIZE * PART5_MULL, 80 PART5_OFFS, PART5_MASK), 81 OMAP_TAG_PARTITION_CONFIG(PART6_NAME, PART6_SIZE * PART6_MULL, 82 PART6_OFFS, PART6_MASK), 83 OMAP_TAG_BOOT_REASON_CONFIG("pwr_key"), 84 OMAP_TAG_VERSION_STR_CONFIG("product", "RX-51"), 85 OMAP_TAG_VERSION_STR_CONFIG("hw-build", "2101"), 86 OMAP_TAG_VERSION_STR_CONFIG("nolo", "1.4.14"), 87 OMAP_TAG_VERSION_STR_CONFIG("boot-mode", "normal"), 88 { } 89 }; 90 91 static char *boot_reason_ptr; 92 static char *hw_build_ptr; 93 static char *nolo_version_ptr; 94 static char *boot_mode_ptr; 95 96 /* 97 * Routine: init_omap_tags 98 * Description: Initialize pointers to values in tag_omap 99 */ 100 static void init_omap_tags(void) 101 { 102 char *component; 103 char *version; 104 int i = 0; 105 while (omap[i].hdr.tag) { 106 switch (omap[i].hdr.tag) { 107 case OMAP_TAG_BOOT_REASON: 108 boot_reason_ptr = omap[i].u.boot_reason.reason_str; 109 break; 110 case OMAP_TAG_VERSION_STR: 111 component = omap[i].u.version.component; 112 version = omap[i].u.version.version; 113 if (strcmp(component, "hw-build") == 0) 114 hw_build_ptr = version; 115 else if (strcmp(component, "nolo") == 0) 116 nolo_version_ptr = version; 117 else if (strcmp(component, "boot-mode") == 0) 118 boot_mode_ptr = version; 119 break; 120 default: 121 break; 122 } 123 i++; 124 } 125 } 126 127 static void reuse_omap_atags(struct tag_omap *t) 128 { 129 char *component; 130 char *version; 131 while (t->hdr.tag) { 132 switch (t->hdr.tag) { 133 case OMAP_TAG_BOOT_REASON: 134 memset(boot_reason_ptr, 0, 12); 135 strcpy(boot_reason_ptr, t->u.boot_reason.reason_str); 136 break; 137 case OMAP_TAG_VERSION_STR: 138 component = t->u.version.component; 139 version = t->u.version.version; 140 if (strcmp(component, "hw-build") == 0) { 141 memset(hw_build_ptr, 0, 12); 142 strcpy(hw_build_ptr, version); 143 } else if (strcmp(component, "nolo") == 0) { 144 memset(nolo_version_ptr, 0, 12); 145 strcpy(nolo_version_ptr, version); 146 } else if (strcmp(component, "boot-mode") == 0) { 147 memset(boot_mode_ptr, 0, 12); 148 strcpy(boot_mode_ptr, version); 149 } 150 break; 151 default: 152 break; 153 } 154 t = tag_omap_next(t); 155 } 156 } 157 158 /* 159 * Routine: reuse_atags 160 * Description: Reuse atags from previous bootloader. 161 * Reuse only only HW build, boot reason, boot mode and nolo 162 */ 163 static void reuse_atags(void) 164 { 165 struct tag *t = (struct tag *)gd->bd->bi_boot_params; 166 167 /* First tag must be ATAG_CORE */ 168 if (t->hdr.tag != ATAG_CORE) 169 return; 170 171 if (!boot_reason_ptr || !hw_build_ptr) 172 return; 173 174 /* Last tag must be ATAG_NONE */ 175 while (t->hdr.tag != ATAG_NONE) { 176 switch (t->hdr.tag) { 177 case ATAG_REVISION: 178 memset(hw_build_ptr, 0, 12); 179 sprintf(hw_build_ptr, "%x", t->u.revision.rev); 180 break; 181 case ATAG_BOARD: 182 reuse_omap_atags((struct tag_omap *)&t->u); 183 break; 184 default: 185 break; 186 } 187 t = tag_next(t); 188 } 189 } 190 191 /* 192 * Routine: board_init 193 * Description: Early hardware init. 194 */ 195 int board_init(void) 196 { 197 /* in SRAM or SDRAM, finish GPMC */ 198 gpmc_init(); 199 /* boot param addr */ 200 gd->bd->bi_boot_params = OMAP34XX_SDRC_CS0 + 0x100; 201 return 0; 202 } 203 204 /* 205 * Routine: get_board_revision 206 * Description: Return board revision. 207 */ 208 u32 get_board_rev(void) 209 { 210 return simple_strtol(hw_build_ptr, NULL, 16); 211 } 212 213 /* 214 * Routine: setup_board_tags 215 * Description: Append board specific boot tags. 216 */ 217 void setup_board_tags(struct tag **in_params) 218 { 219 int setup_console_atag; 220 char *setup_boot_reason_atag; 221 char *setup_boot_mode_atag; 222 char *str; 223 int i; 224 int size; 225 int total_size; 226 struct tag *params; 227 struct tag_omap *t; 228 229 params = (struct tag *)gd->bd->bi_boot_params; 230 231 params->u.core.flags = 0x0; 232 params->u.core.pagesize = 0x1000; 233 params->u.core.rootdev = 0x0; 234 235 /* append omap atag only if env setup_omap_atag is set to 1 */ 236 str = env_get("setup_omap_atag"); 237 if (!str || str[0] != '1') 238 return; 239 240 str = env_get("setup_console_atag"); 241 if (str && str[0] == '1') 242 setup_console_atag = 1; 243 else 244 setup_console_atag = 0; 245 246 setup_boot_reason_atag = env_get("setup_boot_reason_atag"); 247 setup_boot_mode_atag = env_get("setup_boot_mode_atag"); 248 249 params = *in_params; 250 t = (struct tag_omap *)¶ms->u; 251 total_size = sizeof(struct tag_header); 252 253 for (i = 0; omap[i].hdr.tag; i++) { 254 255 /* skip serial console tag */ 256 if (!setup_console_atag && 257 omap[i].hdr.tag == OMAP_TAG_SERIAL_CONSOLE) 258 continue; 259 260 size = omap[i].hdr.size + sizeof(struct tag_omap_header); 261 memcpy(t, &omap[i], size); 262 263 /* set uart tag to 0 - disable serial console */ 264 if (!setup_console_atag && omap[i].hdr.tag == OMAP_TAG_UART) 265 t->u.uart.enabled_uarts = 0; 266 267 /* change boot reason */ 268 if (setup_boot_reason_atag && 269 omap[i].hdr.tag == OMAP_TAG_BOOT_REASON) { 270 memset(t->u.boot_reason.reason_str, 0, 12); 271 strcpy(t->u.boot_reason.reason_str, 272 setup_boot_reason_atag); 273 } 274 275 /* change boot mode */ 276 if (setup_boot_mode_atag && 277 omap[i].hdr.tag == OMAP_TAG_VERSION_STR && 278 strcmp(omap[i].u.version.component, "boot-mode") == 0) { 279 memset(t->u.version.version, 0, 12); 280 strcpy(t->u.version.version, setup_boot_mode_atag); 281 } 282 283 total_size += size; 284 t = tag_omap_next(t); 285 286 } 287 288 params->hdr.tag = ATAG_BOARD; 289 params->hdr.size = total_size >> 2; 290 params = tag_next(params); 291 292 *in_params = params; 293 } 294 295 /* 296 * Routine: video_hw_init 297 * Description: Set up the GraphicDevice depending on sys_boot. 298 */ 299 void *video_hw_init(void) 300 { 301 /* fill in Graphic Device */ 302 gdev.frameAdrs = 0x8f9c0000; 303 gdev.winSizeX = 800; 304 gdev.winSizeY = 480; 305 gdev.gdfBytesPP = 2; 306 gdev.gdfIndex = GDF_16BIT_565RGB; 307 memset((void *)gdev.frameAdrs, 0, 0xbb800); 308 return (void *) &gdev; 309 } 310 311 /* 312 * Routine: twl4030_regulator_set_mode 313 * Description: Set twl4030 regulator mode over i2c powerbus. 314 */ 315 static void twl4030_regulator_set_mode(u8 id, u8 mode) 316 { 317 u16 msg = MSG_SINGULAR(DEV_GRP_P1, id, mode); 318 twl4030_i2c_write_u8(TWL4030_CHIP_PM_MASTER, 319 TWL4030_PM_MASTER_PB_WORD_MSB, msg >> 8); 320 twl4030_i2c_write_u8(TWL4030_CHIP_PM_MASTER, 321 TWL4030_PM_MASTER_PB_WORD_LSB, msg & 0xff); 322 } 323 324 static void omap3_emu_romcode_call(u32 service_id, u32 *parameters) 325 { 326 u32 i, num_params = *parameters; 327 u32 *sram_scratch_space = (u32 *)OMAP3_PUBLIC_SRAM_SCRATCH_AREA; 328 329 /* 330 * copy the parameters to an un-cached area to avoid coherency 331 * issues 332 */ 333 for (i = 0; i < num_params; i++) { 334 __raw_writel(*parameters, sram_scratch_space); 335 parameters++; 336 sram_scratch_space++; 337 } 338 339 /* Now make the PPA call */ 340 do_omap3_emu_romcode_call(service_id, OMAP3_PUBLIC_SRAM_SCRATCH_AREA); 341 } 342 343 void omap3_set_aux_cr_secure(u32 acr) 344 { 345 struct emu_hal_params_rx51 emu_romcode_params = { 0, }; 346 347 emu_romcode_params.num_params = 2; 348 emu_romcode_params.param1 = acr; 349 350 omap3_emu_romcode_call(OMAP3_EMU_HAL_API_WRITE_ACR, 351 (u32 *)&emu_romcode_params); 352 } 353 354 /* 355 * Routine: omap3_update_aux_cr_secure_rx51 356 * Description: Modify the contents Auxiliary Control Register. 357 * Parameters: 358 * set_bits - bits to set in ACR 359 * clr_bits - bits to clear in ACR 360 */ 361 static void omap3_update_aux_cr_secure_rx51(u32 set_bits, u32 clear_bits) 362 { 363 u32 acr; 364 365 /* Read ACR */ 366 asm volatile ("mrc p15, 0, %0, c1, c0, 1" : "=r" (acr)); 367 acr &= ~clear_bits; 368 acr |= set_bits; 369 omap3_set_aux_cr_secure(acr); 370 } 371 372 /* 373 * Routine: misc_init_r 374 * Description: Configure board specific parts. 375 */ 376 int misc_init_r(void) 377 { 378 char buf[12]; 379 u8 state; 380 381 /* reset lp5523 led */ 382 i2c_set_bus_num(1); 383 state = 0xff; 384 i2c_write(0x32, 0x3d, 1, &state, 1); 385 i2c_set_bus_num(0); 386 387 /* initialize twl4030 power managment */ 388 twl4030_power_init(); 389 390 /* set VSIM to 1.8V */ 391 twl4030_pmrecv_vsel_cfg(TWL4030_PM_RECEIVER_VSIM_DEDICATED, 392 TWL4030_PM_RECEIVER_VSIM_VSEL_18, 393 TWL4030_PM_RECEIVER_VSIM_DEV_GRP, 394 TWL4030_PM_RECEIVER_DEV_GRP_P1); 395 396 /* store I2C access state */ 397 twl4030_i2c_read_u8(TWL4030_CHIP_PM_MASTER, TWL4030_PM_MASTER_PB_CFG, 398 &state); 399 400 /* enable I2C access to powerbus (needed for twl4030 regulator) */ 401 twl4030_i2c_write_u8(TWL4030_CHIP_PM_MASTER, TWL4030_PM_MASTER_PB_CFG, 402 0x02); 403 404 /* set VAUX3, VSIM and VMMC1 state to active - enable eMMC memory */ 405 twl4030_regulator_set_mode(RES_VAUX3, RES_STATE_ACTIVE); 406 twl4030_regulator_set_mode(RES_VSIM, RES_STATE_ACTIVE); 407 twl4030_regulator_set_mode(RES_VMMC1, RES_STATE_ACTIVE); 408 409 /* restore I2C access state */ 410 twl4030_i2c_write_u8(TWL4030_CHIP_PM_MASTER, TWL4030_PM_MASTER_PB_CFG, 411 state); 412 413 /* set env variable attkernaddr for relocated kernel */ 414 sprintf(buf, "%#x", KERNEL_ADDRESS); 415 env_set("attkernaddr", buf); 416 417 /* initialize omap tags */ 418 init_omap_tags(); 419 420 /* reuse atags from previous bootloader */ 421 reuse_atags(); 422 423 omap_die_id_display(); 424 print_cpuinfo(); 425 426 /* 427 * Cortex-A8(r1p0..r1p2) errata 430973 workaround 428 * Set IBE bit in Auxiliary Control Register 429 * 430 * Call this routine only on real secure device 431 * Qemu does not implement secure PPA and crash 432 */ 433 if (get_device_type() == HS_DEVICE) 434 omap3_update_aux_cr_secure_rx51(1 << 6, 0); 435 436 return 0; 437 } 438 439 /* 440 * Routine: set_muxconf_regs 441 * Description: Setting up the configuration Mux registers specific to the 442 * hardware. Many pins need to be moved from protect to primary 443 * mode. 444 */ 445 void set_muxconf_regs(void) 446 { 447 MUX_RX51(); 448 } 449 450 static unsigned long int twl_wd_time; /* last time of watchdog reset */ 451 static unsigned long int twl_i2c_lock; 452 453 /* 454 * Routine: hw_watchdog_reset 455 * Description: Reset timeout of twl4030 watchdog. 456 */ 457 void hw_watchdog_reset(void) 458 { 459 u8 timeout = 0; 460 461 /* do not reset watchdog too often - max every 4s */ 462 if (get_timer(twl_wd_time) < 4 * CONFIG_SYS_HZ) 463 return; 464 465 /* localy lock twl4030 i2c bus */ 466 if (test_and_set_bit(0, &twl_i2c_lock)) 467 return; 468 469 /* read actual watchdog timeout */ 470 twl4030_i2c_read_u8(TWL4030_CHIP_PM_RECEIVER, 471 TWL4030_PM_RECEIVER_WATCHDOG_CFG, &timeout); 472 473 /* timeout 0 means watchdog is disabled */ 474 /* reset watchdog timeout to 31s (maximum) */ 475 if (timeout != 0) 476 twl4030_i2c_write_u8(TWL4030_CHIP_PM_RECEIVER, 477 TWL4030_PM_RECEIVER_WATCHDOG_CFG, 31); 478 479 /* store last watchdog reset time */ 480 twl_wd_time = get_timer(0); 481 482 /* localy unlock twl4030 i2c bus */ 483 test_and_clear_bit(0, &twl_i2c_lock); 484 } 485 486 /* 487 * TWL4030 keypad handler for cfb_console 488 */ 489 490 static const char keymap[] = { 491 /* normal */ 492 'q', 'o', 'p', ',', '\b', 0, 'a', 's', 493 'w', 'd', 'f', 'g', 'h', 'j', 'k', 'l', 494 'e', '.', 0, '\r', 0, 'z', 'x', 'c', 495 'r', 'v', 'b', 'n', 'm', ' ', ' ', 0, 496 't', 0, 0, 0, 0, 0, 0, 0, 497 'y', 0, 0, 0, 0, 0, 0, 0, 498 'u', 0, 0, 0, 0, 0, 0, 0, 499 'i', 5, 6, 0, 0, 0, 0, 0, 500 /* fn */ 501 '1', '9', '0', '=', '\b', 0, '*', '+', 502 '2', '#', '-', '_', '(', ')', '&', '!', 503 '3', '?', '^', '\r', 0, 156, '$', 238, 504 '4', '/', '\\', '"', '\'', '@', 0, '<', 505 '5', '|', '>', 0, 0, 0, 0, 0, 506 '6', 0, 0, 0, 0, 0, 0, 0, 507 '7', 0, 0, 0, 0, 0, 0, 0, 508 '8', 16, 17, 0, 0, 0, 0, 0, 509 }; 510 511 static u8 keys[8]; 512 static u8 old_keys[8] = {0, 0, 0, 0, 0, 0, 0, 0}; 513 #define KEYBUF_SIZE 32 514 static u8 keybuf[KEYBUF_SIZE]; 515 static u8 keybuf_head; 516 static u8 keybuf_tail; 517 518 /* 519 * Routine: rx51_kp_init 520 * Description: Initialize HW keyboard. 521 */ 522 int rx51_kp_init(void) 523 { 524 int ret = 0; 525 u8 ctrl; 526 ret = twl4030_i2c_read_u8(TWL4030_CHIP_KEYPAD, 527 TWL4030_KEYPAD_KEYP_CTRL_REG, &ctrl); 528 529 if (ret) 530 return ret; 531 532 /* turn on keyboard and use hardware scanning */ 533 ctrl |= TWL4030_KEYPAD_CTRL_KBD_ON; 534 ctrl |= TWL4030_KEYPAD_CTRL_SOFT_NRST; 535 ctrl |= TWL4030_KEYPAD_CTRL_SOFTMODEN; 536 ret |= twl4030_i2c_write_u8(TWL4030_CHIP_KEYPAD, 537 TWL4030_KEYPAD_KEYP_CTRL_REG, ctrl); 538 /* enable key event status */ 539 ret |= twl4030_i2c_write_u8(TWL4030_CHIP_KEYPAD, 540 TWL4030_KEYPAD_KEYP_IMR1, 0xfe); 541 /* enable interrupt generation on rising and falling */ 542 /* this is a workaround for qemu twl4030 emulation */ 543 ret |= twl4030_i2c_write_u8(TWL4030_CHIP_KEYPAD, 544 TWL4030_KEYPAD_KEYP_EDR, 0x57); 545 /* enable ISR clear on read */ 546 ret |= twl4030_i2c_write_u8(TWL4030_CHIP_KEYPAD, 547 TWL4030_KEYPAD_KEYP_SIH_CTRL, 0x05); 548 return 0; 549 } 550 551 static void rx51_kp_fill(u8 k, u8 mods) 552 { 553 /* check if some cursor key without meta fn key was pressed */ 554 if (!(mods & 2) && (k == 18 || k == 31 || k == 33 || k == 34)) { 555 keybuf[keybuf_tail++] = '\e'; 556 keybuf_tail %= KEYBUF_SIZE; 557 keybuf[keybuf_tail++] = '['; 558 keybuf_tail %= KEYBUF_SIZE; 559 if (k == 18) /* up */ 560 keybuf[keybuf_tail++] = 'A'; 561 else if (k == 31) /* left */ 562 keybuf[keybuf_tail++] = 'D'; 563 else if (k == 33) /* down */ 564 keybuf[keybuf_tail++] = 'B'; 565 else if (k == 34) /* right */ 566 keybuf[keybuf_tail++] = 'C'; 567 keybuf_tail %= KEYBUF_SIZE; 568 return; 569 } 570 571 if (mods & 2) { /* fn meta key was pressed */ 572 k = keymap[k+64]; 573 } else { 574 k = keymap[k]; 575 if (mods & 1) { /* ctrl key was pressed */ 576 if (k >= 'a' && k <= 'z') 577 k -= 'a' - 1; 578 } 579 if (mods & 4) { /* shift key was pressed */ 580 if (k >= 'a' && k <= 'z') 581 k += 'A' - 'a'; 582 else if (k == '.') 583 k = ':'; 584 else if (k == ',') 585 k = ';'; 586 } 587 } 588 keybuf[keybuf_tail++] = k; 589 keybuf_tail %= KEYBUF_SIZE; 590 } 591 592 /* 593 * Routine: rx51_kp_tstc 594 * Description: Test if key was pressed (from buffer). 595 */ 596 int rx51_kp_tstc(struct stdio_dev *sdev) 597 { 598 u8 c, r, dk, i; 599 u8 intr; 600 u8 mods; 601 602 /* localy lock twl4030 i2c bus */ 603 if (test_and_set_bit(0, &twl_i2c_lock)) 604 return 0; 605 606 /* twl4030 remembers up to 2 events */ 607 for (i = 0; i < 2; i++) { 608 609 /* check interrupt register for events */ 610 twl4030_i2c_read_u8(TWL4030_CHIP_KEYPAD, 611 TWL4030_KEYPAD_KEYP_ISR1 + (2 * i), &intr); 612 613 /* no event */ 614 if (!(intr&1)) 615 continue; 616 617 /* read the key state */ 618 i2c_read(TWL4030_CHIP_KEYPAD, 619 TWL4030_KEYPAD_FULL_CODE_7_0, 1, keys, 8); 620 621 /* cut out modifier keys from the keystate */ 622 mods = keys[4] >> 4; 623 keys[4] &= 0x0f; 624 625 for (c = 0; c < 8; c++) { 626 627 /* get newly pressed keys only */ 628 dk = ((keys[c] ^ old_keys[c])&keys[c]); 629 old_keys[c] = keys[c]; 630 631 /* fill the keybuf */ 632 for (r = 0; r < 8; r++) { 633 if (dk&1) 634 rx51_kp_fill((c*8)+r, mods); 635 dk = dk >> 1; 636 } 637 638 } 639 640 } 641 642 /* localy unlock twl4030 i2c bus */ 643 test_and_clear_bit(0, &twl_i2c_lock); 644 645 return (KEYBUF_SIZE + keybuf_tail - keybuf_head)%KEYBUF_SIZE; 646 } 647 648 /* 649 * Routine: rx51_kp_getc 650 * Description: Get last pressed key (from buffer). 651 */ 652 int rx51_kp_getc(struct stdio_dev *sdev) 653 { 654 keybuf_head %= KEYBUF_SIZE; 655 while (!rx51_kp_tstc(sdev)) 656 WATCHDOG_RESET(); 657 return keybuf[keybuf_head++]; 658 } 659 660 /* 661 * Routine: board_mmc_init 662 * Description: Initialize mmc devices. 663 */ 664 int board_mmc_init(bd_t *bis) 665 { 666 omap_mmc_init(0, 0, 0, -1, -1); 667 omap_mmc_init(1, 0, 0, -1, -1); 668 return 0; 669 } 670 671 void board_mmc_power_init(void) 672 { 673 twl4030_power_mmc_init(0); 674 twl4030_power_mmc_init(1); 675 } 676