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