Merge branch 'master' of /home/stefan/git/u-boot/u-boot
[platform/kernel/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  */
23
24 #include <common.h>
25 #include <console.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
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 void post_bootmode_init (void)
62 {
63         int bootmode = post_bootmode_get (0);
64         int newword;
65
66         if (post_hotkeys_pressed() && !(bootmode & POST_POWERTEST)) {
67                 newword = BOOTMODE_MAGIC | POST_SLOWTEST;
68         } else if (bootmode == 0) {
69                 newword = BOOTMODE_MAGIC | POST_POWERON;
70         } else if (bootmode == POST_POWERON || bootmode == POST_SLOWTEST) {
71                 newword = BOOTMODE_MAGIC | POST_NORMAL;
72         } else {
73                 /* Use old value */
74                 newword = post_word_load () & ~POST_COLDBOOT;
75         }
76
77         if (bootmode == 0)
78         {
79                 /* We are booting after power-on */
80                 newword |= POST_COLDBOOT;
81         }
82
83         post_word_store (newword);
84
85         /* Reset activity record */
86         gd->post_log_word = 0;
87 }
88
89 int post_bootmode_get (unsigned int *last_test)
90 {
91         unsigned long word = post_word_load ();
92         int bootmode;
93
94         if ((word & 0xFFFF0000) != BOOTMODE_MAGIC) {
95                 return 0;
96         }
97
98         bootmode = word & 0x7F;
99
100         if (last_test && (bootmode & POST_POWERTEST)) {
101                 *last_test = (word >> 8) & 0xFF;
102         }
103
104         return bootmode;
105 }
106
107 /* POST tests run before relocation only mark status bits .... */
108 static void post_log_mark_start ( unsigned long testid )
109 {
110         gd->post_log_word |= (testid)<<16;
111 }
112
113 static void post_log_mark_succ ( unsigned long testid )
114 {
115         gd->post_log_word |= testid;
116 }
117
118 /* ... and the messages are output once we are relocated */
119 void post_output_backlog ( void )
120 {
121         int j;
122
123         for (j = 0; j < post_list_size; j++) {
124                 if (gd->post_log_word & (post_list[j].testid<<16)) {
125                         post_log ("POST %s ", post_list[j].cmd);
126                         if (gd->post_log_word & post_list[j].testid)
127                                 post_log ("PASSED\n");
128                         else {
129                                 post_log ("FAILED\n");
130                                 show_boot_progress (-31);
131                         }
132                 }
133         }
134 }
135
136 static void post_bootmode_test_on (unsigned int last_test)
137 {
138         unsigned long word = post_word_load ();
139
140         word |= POST_POWERTEST;
141
142         word |= (last_test & 0xFF) << 8;
143
144         post_word_store (word);
145 }
146
147 static void post_bootmode_test_off (void)
148 {
149         unsigned long word = post_word_load ();
150
151         word &= ~POST_POWERTEST;
152
153         post_word_store (word);
154 }
155
156 static void post_get_flags (int *test_flags)
157 {
158         int  flag[] = {  POST_POWERON,   POST_NORMAL,   POST_SLOWTEST,
159                          POST_CRITICAL };
160         char *var[] = { "post_poweron", "post_normal", "post_slowtest",
161                         "post_critical" };
162         int varnum = sizeof (var) / sizeof (var[0]);
163         char list[128];                 /* long enough for POST list */
164         char *name;
165         char *s;
166         int last;
167         int i, j;
168
169         for (j = 0; j < post_list_size; j++) {
170                 test_flags[j] = post_list[j].flags;
171         }
172
173         for (i = 0; i < varnum; i++) {
174                 if (getenv_r (var[i], list, sizeof (list)) <= 0)
175                         continue;
176
177                 for (j = 0; j < post_list_size; j++) {
178                         test_flags[j] &= ~flag[i];
179                 }
180
181                 last = 0;
182                 name = list;
183                 while (!last) {
184                         while (*name && *name == ' ')
185                                 name++;
186                         if (*name == 0)
187                                 break;
188                         s = name + 1;
189                         while (*s && *s != ' ')
190                                 s++;
191                         if (*s == 0)
192                                 last = 1;
193                         else
194                                 *s = 0;
195
196                         for (j = 0; j < post_list_size; j++) {
197                                 if (strcmp (post_list[j].cmd, name) == 0) {
198                                         test_flags[j] |= flag[i];
199                                         break;
200                                 }
201                         }
202
203                         if (j == post_list_size) {
204                                 printf ("No such test: %s\n", name);
205                         }
206
207                         name = s + 1;
208                 }
209         }
210
211         for (j = 0; j < post_list_size; j++) {
212                 if (test_flags[j] & POST_POWERON) {
213                         test_flags[j] |= POST_SLOWTEST;
214                 }
215         }
216 }
217
218 static int post_run_single (struct post_test *test,
219                                 int test_flags, int flags, unsigned int i)
220 {
221         if ((flags & test_flags & POST_ALWAYS) &&
222                 (flags & test_flags & POST_MEM)) {
223                 WATCHDOG_RESET ();
224
225                 if (!(flags & POST_REBOOT)) {
226                         if ((test_flags & POST_REBOOT) && !(flags & POST_MANUAL)) {
227                                 post_bootmode_test_on (
228                                         (gd->flags & GD_FLG_POSTFAIL) ?
229                                                 POST_FAIL_SAVE | i : i);
230                         }
231
232                         if (test_flags & POST_PREREL)
233                                 post_log_mark_start ( test->testid );
234                         else
235                         post_log ("POST %s ", test->cmd);
236                 }
237
238                 if (test_flags & POST_PREREL) {
239                         if ((*test->test) (flags) == 0)
240                                 post_log_mark_succ ( test->testid );
241                         else {
242                                 if (test_flags & POST_CRITICAL)
243                                         gd->flags |= GD_FLG_POSTFAIL;
244                                 if (test_flags & POST_STOP)
245                                         gd->flags |= GD_FLG_POSTSTOP;
246                         }
247                 } else {
248                 if ((*test->test) (flags) != 0) {
249                         post_log ("FAILED\n");
250                         show_boot_progress (-32);
251                         if (test_flags & POST_CRITICAL)
252                                 gd->flags |= GD_FLG_POSTFAIL;
253                         if (test_flags & POST_STOP)
254                                 gd->flags |= GD_FLG_POSTSTOP;
255                 }
256                 else
257                         post_log ("PASSED\n");
258                 }
259
260                 if ((test_flags & POST_REBOOT) && !(flags & POST_MANUAL)) {
261                         post_bootmode_test_off ();
262                 }
263
264                 return 0;
265         } else {
266                 return -1;
267         }
268 }
269
270 int post_run (char *name, int flags)
271 {
272         unsigned int i;
273         int test_flags[POST_MAX_NUMBER];
274
275         post_get_flags (test_flags);
276
277         if (name == NULL) {
278                 unsigned int last;
279
280                 if (gd->flags & GD_FLG_POSTSTOP)
281                         return 0;
282
283                 if (post_bootmode_get (&last) & POST_POWERTEST) {
284                         if (last & POST_FAIL_SAVE) {
285                                 last &= ~POST_FAIL_SAVE;
286                                 gd->flags |= GD_FLG_POSTFAIL;
287                         }
288                         if (last < post_list_size &&
289                                 (flags & test_flags[last] & POST_ALWAYS) &&
290                                 (flags & test_flags[last] & POST_MEM)) {
291
292                                 post_run_single (post_list + last,
293                                                  test_flags[last],
294                                                  flags | POST_REBOOT, last);
295
296                                 for (i = last + 1; i < post_list_size; i++) {
297                                         if (gd->flags & GD_FLG_POSTSTOP)
298                                                 break;
299                                         post_run_single (post_list + i,
300                                                          test_flags[i],
301                                                          flags, i);
302                                 }
303                         }
304                 } else {
305                         for (i = 0; i < post_list_size; i++) {
306                                 if (gd->flags & GD_FLG_POSTSTOP)
307                                         break;
308                                 post_run_single (post_list + i,
309                                                  test_flags[i],
310                                                  flags, i);
311                         }
312                 }
313
314                 return 0;
315         } else {
316                 for (i = 0; i < post_list_size; i++) {
317                         if (strcmp (post_list[i].cmd, name) == 0)
318                                 break;
319                 }
320
321                 if (i < post_list_size) {
322                         return post_run_single (post_list + i,
323                                                 test_flags[i],
324                                                 flags, i);
325                 } else {
326                         return -1;
327                 }
328         }
329 }
330
331 static int post_info_single (struct post_test *test, int full)
332 {
333         if (test->flags & POST_MANUAL) {
334                 if (full)
335                         printf ("%s - %s\n"
336                                 "  %s\n", test->cmd, test->name, test->desc);
337                 else
338                         printf ("  %-15s - %s\n", test->cmd, test->name);
339
340                 return 0;
341         } else {
342                 return -1;
343         }
344 }
345
346 int post_info (char *name)
347 {
348         unsigned int i;
349
350         if (name == NULL) {
351                 for (i = 0; i < post_list_size; i++) {
352                         post_info_single (post_list + i, 0);
353                 }
354
355                 return 0;
356         } else {
357                 for (i = 0; i < post_list_size; i++) {
358                         if (strcmp (post_list[i].cmd, name) == 0)
359                                 break;
360                 }
361
362                 if (i < post_list_size) {
363                         return post_info_single (post_list + i, 1);
364                 } else {
365                         return -1;
366                 }
367         }
368 }
369
370 int post_log (char *format, ...)
371 {
372         va_list args;
373         uint i;
374         char printbuffer[CFG_PBSIZE];
375
376         va_start (args, format);
377
378         /* For this to work, printbuffer must be larger than
379          * anything we ever want to print.
380          */
381         i = vsprintf (printbuffer, format, args);
382         va_end (args);
383
384 #ifdef CONFIG_LOGBUFFER
385         /* Send to the logbuffer */
386         logbuff_log (printbuffer);
387 #else
388         /* Send to the stdout file */
389         puts (printbuffer);
390 #endif
391
392         return 0;
393 }
394
395 void post_reloc (void)
396 {
397         unsigned int i;
398
399         /*
400          * We have to relocate the test table manually
401          */
402         for (i = 0; i < post_list_size; i++) {
403                 ulong addr;
404                 struct post_test *test = post_list + i;
405
406                 if (test->name) {
407                         addr = (ulong) (test->name) + gd->reloc_off;
408                         test->name = (char *) addr;
409                 }
410
411                 if (test->cmd) {
412                         addr = (ulong) (test->cmd) + gd->reloc_off;
413                         test->cmd = (char *) addr;
414                 }
415
416                 if (test->desc) {
417                         addr = (ulong) (test->desc) + gd->reloc_off;
418                         test->desc = (char *) addr;
419                 }
420
421                 if (test->test) {
422                         addr = (ulong) (test->test) + gd->reloc_off;
423                         test->test = (int (*)(int flags)) addr;
424                 }
425
426                 if (test->init_f) {
427                         addr = (ulong) (test->init_f) + gd->reloc_off;
428                         test->init_f = (int (*)(void)) addr;
429                 }
430
431                 if (test->reloc) {
432                         addr = (ulong) (test->reloc) + gd->reloc_off;
433                         test->reloc = (void (*)(void)) addr;
434
435                         test->reloc();
436                 }
437         }
438 }
439
440
441 /*
442  * Some tests (e.g. SYSMON) need the time when post_init_f started,
443  * but we cannot use get_timer() at this point.
444  *
445  * On PowerPC we implement it using the timebase register.
446  */
447 unsigned long post_time_ms (unsigned long base)
448 {
449 #ifdef CONFIG_PPC
450         return (unsigned long)(get_ticks () / (get_tbclk () / CFG_HZ)) - base;
451 #else
452 #warning "Not implemented yet"
453         return 0; /* Not implemented yet */
454 #endif
455 }