post/post.c

   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 }