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