post/post.c

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