ARM: DRA7xx: Lock DPLL_GMAC
[glsdk/glsdk-u-boot.git] / 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  */
24 #include <common.h>
25 #include <stdio_dev.h>
26 #include <watchdog.h>
27 #include <div64.h>
28 #include <post.h>
30 #ifdef CONFIG_SYS_POST_HOTKEYS_GPIO
31 #include <asm/gpio.h>
32 #endif
34 #ifdef CONFIG_LOGBUFFER
35 #include <logbuff.h>
36 #endif
38 DECLARE_GLOBAL_DATA_PTR;
40 #define POST_MAX_NUMBER         32
42 #define BOOTMODE_MAGIC  0xDEAD0000
44 int post_init_f(void)
45 {
46         int res = 0;
47         unsigned int i;
49         for (i = 0; i < post_list_size; i++) {
50                 struct post_test *test = post_list + i;
52                 if (test->init_f && test->init_f())
53                         res = -1;
54         }
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__);
60         return res;
61 }
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;
77         ret = gpio_request(gpio, "hotkeys");
78         if (ret) {
79                 printf("POST: gpio hotkey request failed\n");
80                 return 0;
81         }
83         gpio_direction_input(gpio);
84         ret = gpio_get_value(gpio);
85         gpio_free(gpio);
87         return ret;
88 #endif
90         return 0;       /* No hotkeys supported */
91 }
92 int post_hotkeys_pressed(void)
93         __attribute__((weak, alias("__post_hotkeys_pressed")));
96 void post_bootmode_init(void)
97 {
98         int bootmode = post_bootmode_get(0);
99         int newword;
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;
111         if (bootmode == 0)
112                 /* We are booting after power-on */
113                 newword |= POST_COLDBOOT;
115         post_word_store(newword);
117         /* Reset activity record */
118         gd->post_log_word = 0;
119         gd->post_log_res = 0;
122 int post_bootmode_get(unsigned int *last_test)
124         unsigned long word = post_word_load();
125         int bootmode;
127         if ((word & 0xFFFF0000) != BOOTMODE_MAGIC)
128                 return 0;
130         bootmode = word & 0x7F;
132         if (last_test && (bootmode & POST_POWERTEST))
133                 *last_test = (word >> 8) & 0xFF;
135         return bootmode;
138 /* POST tests run before relocation only mark status bits .... */
139 static void post_log_mark_start(unsigned long testid)
141         gd->post_log_word |= testid;
144 static void post_log_mark_succ(unsigned long testid)
146         gd->post_log_res |= testid;
149 /* ... and the messages are output once we are relocated */
150 void post_output_backlog(void)
152         int j;
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         }
167 static void post_bootmode_test_on(unsigned int last_test)
169         unsigned long word = post_word_load();
171         word |= POST_POWERTEST;
173         word |= (last_test & 0xFF) << 8;
175         post_word_store(word);
178 static void post_bootmode_test_off(void)
180         unsigned long word = post_word_load();
182         word &= ~POST_POWERTEST;
184         post_word_store(word);
187 #ifndef CONFIG_POST_SKIP_ENV_FLAGS
188 static void post_get_env_flags(int *test_flags)
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;
201         for (i = 0; i < varnum; i++) {
202                 if (getenv_f(var[i], list, sizeof(list)) <= 0)
203                         continue;
205                 for (j = 0; j < post_list_size; j++)
206                         test_flags[j] &= ~flag[i];
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;
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                         }
230                         if (j == post_list_size)
231                                 printf("No such test: %s\n", name);
233                         name = s + 1;
234                 }
235         }
237 #endif
239 static void post_get_flags(int *test_flags)
241         int j;
243         for (j = 0; j < post_list_size; j++)
244                 test_flags[j] = post_list[j].flags;
246 #ifndef CONFIG_POST_SKIP_ENV_FLAGS
247         post_get_env_flags(test_flags);
248 #endif
250         for (j = 0; j < post_list_size; j++)
251                 if (test_flags[j] & POST_POWERON)
252                         test_flags[j] |= POST_SLOWTEST;
255 void __show_post_progress(unsigned int test_num, int before, int result)
258 void show_post_progress(unsigned int, int, int)
259                         __attribute__((weak, alias("__show_post_progress")));
261 static int post_run_single(struct post_test *test,
262                                 int test_flags, int flags, unsigned int i)
264         if ((flags & test_flags & POST_ALWAYS) &&
265                 (flags & test_flags & POST_MEM)) {
266                 WATCHDOG_RESET();
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                         }
276                         if (test_flags & POST_PREREL)
277                                 post_log_mark_start(test->testid);
278                         else
279                                 post_log("POST %s ", test->cmd);
280                 }
282                 show_post_progress(i, POST_BEFORE, POST_FAILED);
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                 }
310                 if ((test_flags & POST_REBOOT) && !(flags & POST_MANUAL))
311                         post_bootmode_test_off();
313                 return 0;
314         } else {
315                 return -1;
316         }
319 int post_run(char *name, int flags)
321         unsigned int i;
322         int test_flags[POST_MAX_NUMBER];
324         post_get_flags(test_flags);
326         if (name == NULL) {
327                 unsigned int last;
329                 if (gd->flags & GD_FLG_POSTSTOP)
330                         return 0;
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)) {
341                                 post_run_single(post_list + last,
342                                                  test_flags[last],
343                                                  flags | POST_REBOOT, last);
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                 }
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                 }
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         }
381 static int post_info_single(struct post_test *test, int full)
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);
390                 return 0;
391         } else {
392                 return -1;
393         }
396 int post_info(char *name)
398         unsigned int i;
400         if (name == NULL) {
401                 for (i = 0; i < post_list_size; i++)
402                         post_info_single(post_list + i, 0);
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                 }
411                 if (i < post_list_size)
412                         return post_info_single(post_list + i, 1);
413                 else
414                         return -1;
415         }
418 int post_log(char *format, ...)
420         va_list args;
421         char printbuffer[CONFIG_SYS_PBSIZE];
423         va_start(args, format);
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);
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
439         return 0;
442 #ifdef CONFIG_NEEDS_MANUAL_RELOC
443 void post_reloc(void)
445         unsigned int i;
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;
454                 if (test->name) {
455                         addr = (ulong)(test->name) + gd->reloc_off;
456                         test->name = (char *)addr;
457                 }
459                 if (test->cmd) {
460                         addr = (ulong)(test->cmd) + gd->reloc_off;
461                         test->cmd = (char *)addr;
462                 }
464                 if (test->desc) {
465                         addr = (ulong)(test->desc) + gd->reloc_off;
466                         test->desc = (char *)addr;
467                 }
469                 if (test->test) {
470                         addr = (ulong)(test->test) + gd->reloc_off;
471                         test->test = (int (*)(int flags)) addr;
472                 }
474                 if (test->init_f) {
475                         addr = (ulong)(test->init_f) + gd->reloc_off;
476                         test->init_f = (int (*)(void)) addr;
477                 }
479                 if (test->reloc) {
480                         addr = (ulong)(test->reloc) + gd->reloc_off;
481                         test->reloc = (void (*)(void)) addr;
483                         test->reloc();
484                 }
485         }
487 #endif
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)
498 #if defined(CONFIG_PPC) || defined(CONFIG_BLACKFIN) || defined(CONFIG_ARM)
499         return (unsigned long)lldiv(get_ticks(), get_tbclk() / CONFIG_SYS_HZ)
500                 - base;
501 #else
502 #warning "Not implemented yet"
503         return 0; /* Not implemented yet */
504 #endif