1 /* 2 * (C) Copyright 2002 3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de. 4 * 5 * See file CREDITS for list of people who contributed to this 6 * project. 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of 11 * the License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 21 * MA 02111-1307 USA 22 */ 23 24 #include <common.h> 25 #include <stdio_dev.h> 26 #include <watchdog.h> 27 #include <div64.h> 28 #include <post.h> 29 30 #ifdef CONFIG_SYS_POST_HOTKEYS_GPIO 31 #include <asm/gpio.h> 32 #endif 33 34 #ifdef CONFIG_LOGBUFFER 35 #include <logbuff.h> 36 #endif 37 38 DECLARE_GLOBAL_DATA_PTR; 39 40 #define POST_MAX_NUMBER 32 41 42 #define BOOTMODE_MAGIC 0xDEAD0000 43 44 int post_init_f(void) 45 { 46 int res = 0; 47 unsigned int i; 48 49 for (i = 0; i < post_list_size; i++) { 50 struct post_test *test = post_list + i; 51 52 if (test->init_f && test->init_f()) 53 res = -1; 54 } 55 56 gd->post_init_f_time = post_time_ms(0); 57 if (!gd->post_init_f_time) 58 printf("%s: post_time_ms not implemented\n", __FILE__); 59 60 return res; 61 } 62 63 /* 64 * Supply a default implementation for post_hotkeys_pressed() for boards 65 * without hotkey support. We always return 0 here, so that the 66 * long-running tests won't be started. 67 * 68 * Boards with hotkey support can override this weak default function 69 * by defining one in their board specific code. 70 */ 71 int __post_hotkeys_pressed(void) 72 { 73 #ifdef CONFIG_SYS_POST_HOTKEYS_GPIO 74 int ret; 75 unsigned gpio = CONFIG_SYS_POST_HOTKEYS_GPIO; 76 77 ret = gpio_request(gpio, "hotkeys"); 78 if (ret) { 79 printf("POST: gpio hotkey request failed\n"); 80 return 0; 81 } 82 83 gpio_direction_input(gpio); 84 ret = gpio_get_value(gpio); 85 gpio_free(gpio); 86 87 return ret; 88 #endif 89 90 return 0; /* No hotkeys supported */ 91 } 92 int post_hotkeys_pressed(void) 93 __attribute__((weak, alias("__post_hotkeys_pressed"))); 94 95 96 void post_bootmode_init(void) 97 { 98 int bootmode = post_bootmode_get(0); 99 int newword; 100 101 if (post_hotkeys_pressed() && !(bootmode & POST_POWERTEST)) 102 newword = BOOTMODE_MAGIC | POST_SLOWTEST; 103 else if (bootmode == 0) 104 newword = BOOTMODE_MAGIC | POST_POWERON; 105 else if (bootmode == POST_POWERON || bootmode == POST_SLOWTEST) 106 newword = BOOTMODE_MAGIC | POST_NORMAL; 107 else 108 /* Use old value */ 109 newword = post_word_load() & ~POST_COLDBOOT; 110 111 if (bootmode == 0) 112 /* We are booting after power-on */ 113 newword |= POST_COLDBOOT; 114 115 post_word_store(newword); 116 117 /* Reset activity record */ 118 gd->post_log_word = 0; 119 gd->post_log_res = 0; 120 } 121 122 int post_bootmode_get(unsigned int *last_test) 123 { 124 unsigned long word = post_word_load(); 125 int bootmode; 126 127 if ((word & 0xFFFF0000) != BOOTMODE_MAGIC) 128 return 0; 129 130 bootmode = word & 0x7F; 131 132 if (last_test && (bootmode & POST_POWERTEST)) 133 *last_test = (word >> 8) & 0xFF; 134 135 return bootmode; 136 } 137 138 /* POST tests run before relocation only mark status bits .... */ 139 static void post_log_mark_start(unsigned long testid) 140 { 141 gd->post_log_word |= testid; 142 } 143 144 static void post_log_mark_succ(unsigned long testid) 145 { 146 gd->post_log_res |= testid; 147 } 148 149 /* ... and the messages are output once we are relocated */ 150 void post_output_backlog(void) 151 { 152 int j; 153 154 for (j = 0; j < post_list_size; j++) { 155 if (gd->post_log_word & (post_list[j].testid)) { 156 post_log("POST %s ", post_list[j].cmd); 157 if (gd->post_log_res & post_list[j].testid) 158 post_log("PASSED\n"); 159 else { 160 post_log("FAILED\n"); 161 bootstage_error(BOOTSTAGE_ID_POST_FAIL_R); 162 } 163 } 164 } 165 } 166 167 static void post_bootmode_test_on(unsigned int last_test) 168 { 169 unsigned long word = post_word_load(); 170 171 word |= POST_POWERTEST; 172 173 word |= (last_test & 0xFF) << 8; 174 175 post_word_store(word); 176 } 177 178 static void post_bootmode_test_off(void) 179 { 180 unsigned long word = post_word_load(); 181 182 word &= ~POST_POWERTEST; 183 184 post_word_store(word); 185 } 186 187 #ifndef CONFIG_POST_SKIP_ENV_FLAGS 188 static void post_get_env_flags(int *test_flags) 189 { 190 int flag[] = { POST_POWERON, POST_NORMAL, POST_SLOWTEST, 191 POST_CRITICAL }; 192 char *var[] = { "post_poweron", "post_normal", "post_slowtest", 193 "post_critical" }; 194 int varnum = ARRAY_SIZE(var); 195 char list[128]; /* long enough for POST list */ 196 char *name; 197 char *s; 198 int last; 199 int i, j; 200 201 for (i = 0; i < varnum; i++) { 202 if (getenv_f(var[i], list, sizeof(list)) <= 0) 203 continue; 204 205 for (j = 0; j < post_list_size; j++) 206 test_flags[j] &= ~flag[i]; 207 208 last = 0; 209 name = list; 210 while (!last) { 211 while (*name && *name == ' ') 212 name++; 213 if (*name == 0) 214 break; 215 s = name + 1; 216 while (*s && *s != ' ') 217 s++; 218 if (*s == 0) 219 last = 1; 220 else 221 *s = 0; 222 223 for (j = 0; j < post_list_size; j++) { 224 if (strcmp(post_list[j].cmd, name) == 0) { 225 test_flags[j] |= flag[i]; 226 break; 227 } 228 } 229 230 if (j == post_list_size) 231 printf("No such test: %s\n", name); 232 233 name = s + 1; 234 } 235 } 236 } 237 #endif 238 239 static void post_get_flags(int *test_flags) 240 { 241 int j; 242 243 for (j = 0; j < post_list_size; j++) 244 test_flags[j] = post_list[j].flags; 245 246 #ifndef CONFIG_POST_SKIP_ENV_FLAGS 247 post_get_env_flags(test_flags); 248 #endif 249 250 for (j = 0; j < post_list_size; j++) 251 if (test_flags[j] & POST_POWERON) 252 test_flags[j] |= POST_SLOWTEST; 253 } 254 255 void __show_post_progress(unsigned int test_num, int before, int result) 256 { 257 } 258 void show_post_progress(unsigned int, int, int) 259 __attribute__((weak, alias("__show_post_progress"))); 260 261 static int post_run_single(struct post_test *test, 262 int test_flags, int flags, unsigned int i) 263 { 264 if ((flags & test_flags & POST_ALWAYS) && 265 (flags & test_flags & POST_MEM)) { 266 WATCHDOG_RESET(); 267 268 if (!(flags & POST_REBOOT)) { 269 if ((test_flags & POST_REBOOT) && 270 !(flags & POST_MANUAL)) { 271 post_bootmode_test_on( 272 (gd->flags & GD_FLG_POSTFAIL) ? 273 POST_FAIL_SAVE | i : i); 274 } 275 276 if (test_flags & POST_PREREL) 277 post_log_mark_start(test->testid); 278 else 279 post_log("POST %s ", test->cmd); 280 } 281 282 show_post_progress(i, POST_BEFORE, POST_FAILED); 283 284 if (test_flags & POST_PREREL) { 285 if ((*test->test)(flags) == 0) { 286 post_log_mark_succ(test->testid); 287 show_post_progress(i, POST_AFTER, POST_PASSED); 288 } else { 289 show_post_progress(i, POST_AFTER, POST_FAILED); 290 if (test_flags & POST_CRITICAL) 291 gd->flags |= GD_FLG_POSTFAIL; 292 if (test_flags & POST_STOP) 293 gd->flags |= GD_FLG_POSTSTOP; 294 } 295 } else { 296 if ((*test->test)(flags) != 0) { 297 post_log("FAILED\n"); 298 bootstage_error(BOOTSTAGE_ID_POST_FAIL_R); 299 show_post_progress(i, POST_AFTER, POST_FAILED); 300 if (test_flags & POST_CRITICAL) 301 gd->flags |= GD_FLG_POSTFAIL; 302 if (test_flags & POST_STOP) 303 gd->flags |= GD_FLG_POSTSTOP; 304 } else { 305 post_log("PASSED\n"); 306 show_post_progress(i, POST_AFTER, POST_PASSED); 307 } 308 } 309 310 if ((test_flags & POST_REBOOT) && !(flags & POST_MANUAL)) 311 post_bootmode_test_off(); 312 313 return 0; 314 } else { 315 return -1; 316 } 317 } 318 319 int post_run(char *name, int flags) 320 { 321 unsigned int i; 322 int test_flags[POST_MAX_NUMBER]; 323 324 post_get_flags(test_flags); 325 326 if (name == NULL) { 327 unsigned int last; 328 329 if (gd->flags & GD_FLG_POSTSTOP) 330 return 0; 331 332 if (post_bootmode_get(&last) & POST_POWERTEST) { 333 if (last & POST_FAIL_SAVE) { 334 last &= ~POST_FAIL_SAVE; 335 gd->flags |= GD_FLG_POSTFAIL; 336 } 337 if (last < post_list_size && 338 (flags & test_flags[last] & POST_ALWAYS) && 339 (flags & test_flags[last] & POST_MEM)) { 340 341 post_run_single(post_list + last, 342 test_flags[last], 343 flags | POST_REBOOT, last); 344 345 for (i = last + 1; i < post_list_size; i++) { 346 if (gd->flags & GD_FLG_POSTSTOP) 347 break; 348 post_run_single(post_list + i, 349 test_flags[i], 350 flags, i); 351 } 352 } 353 } else { 354 for (i = 0; i < post_list_size; i++) { 355 if (gd->flags & GD_FLG_POSTSTOP) 356 break; 357 post_run_single(post_list + i, 358 test_flags[i], 359 flags, i); 360 } 361 } 362 363 return 0; 364 } else { 365 for (i = 0; i < post_list_size; i++) { 366 if (strcmp(post_list[i].cmd, name) == 0) 367 break; 368 } 369 370 if (i < post_list_size) { 371 WATCHDOG_RESET(); 372 return post_run_single(post_list + i, 373 test_flags[i], 374 flags, i); 375 } else { 376 return -1; 377 } 378 } 379 } 380 381 static int post_info_single(struct post_test *test, int full) 382 { 383 if (test->flags & POST_MANUAL) { 384 if (full) 385 printf("%s - %s\n" 386 " %s\n", test->cmd, test->name, test->desc); 387 else 388 printf(" %-15s - %s\n", test->cmd, test->name); 389 390 return 0; 391 } else { 392 return -1; 393 } 394 } 395 396 int post_info(char *name) 397 { 398 unsigned int i; 399 400 if (name == NULL) { 401 for (i = 0; i < post_list_size; i++) 402 post_info_single(post_list + i, 0); 403 404 return 0; 405 } else { 406 for (i = 0; i < post_list_size; i++) { 407 if (strcmp(post_list[i].cmd, name) == 0) 408 break; 409 } 410 411 if (i < post_list_size) 412 return post_info_single(post_list + i, 1); 413 else 414 return -1; 415 } 416 } 417 418 int post_log(char *format, ...) 419 { 420 va_list args; 421 char printbuffer[CONFIG_SYS_PBSIZE]; 422 423 va_start(args, format); 424 425 /* For this to work, printbuffer must be larger than 426 * anything we ever want to print. 427 */ 428 vsprintf(printbuffer, format, args); 429 va_end(args); 430 431 #ifdef CONFIG_LOGBUFFER 432 /* Send to the logbuffer */ 433 logbuff_log(printbuffer); 434 #else 435 /* Send to the stdout file */ 436 puts(printbuffer); 437 #endif 438 439 return 0; 440 } 441 442 #ifdef CONFIG_NEEDS_MANUAL_RELOC 443 void post_reloc(void) 444 { 445 unsigned int i; 446 447 /* 448 * We have to relocate the test table manually 449 */ 450 for (i = 0; i < post_list_size; i++) { 451 ulong addr; 452 struct post_test *test = post_list + i; 453 454 if (test->name) { 455 addr = (ulong)(test->name) + gd->reloc_off; 456 test->name = (char *)addr; 457 } 458 459 if (test->cmd) { 460 addr = (ulong)(test->cmd) + gd->reloc_off; 461 test->cmd = (char *)addr; 462 } 463 464 if (test->desc) { 465 addr = (ulong)(test->desc) + gd->reloc_off; 466 test->desc = (char *)addr; 467 } 468 469 if (test->test) { 470 addr = (ulong)(test->test) + gd->reloc_off; 471 test->test = (int (*)(int flags)) addr; 472 } 473 474 if (test->init_f) { 475 addr = (ulong)(test->init_f) + gd->reloc_off; 476 test->init_f = (int (*)(void)) addr; 477 } 478 479 if (test->reloc) { 480 addr = (ulong)(test->reloc) + gd->reloc_off; 481 test->reloc = (void (*)(void)) addr; 482 483 test->reloc(); 484 } 485 } 486 } 487 #endif 488 489 490 /* 491 * Some tests (e.g. SYSMON) need the time when post_init_f started, 492 * but we cannot use get_timer() at this point. 493 * 494 * On PowerPC we implement it using the timebase register. 495 */ 496 unsigned long post_time_ms(unsigned long base) 497 { 498 #if defined(CONFIG_PPC) || defined(CONFIG_BLACKFIN) || \ 499 (defined(CONFIG_ARM) && !defined(CONFIG_KIRKWOOD)) 500 return (unsigned long)lldiv(get_ticks(), get_tbclk() / CONFIG_SYS_HZ) 501 - base; 502 #else 503 #warning "Not implemented yet" 504 return 0; /* Not implemented yet */ 505 #endif 506 } 507