1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <common.h>
25#include <stdio_dev.h>
26#include <watchdog.h>
27#include <div64.h>
28#include <post.h>
29
30#ifdef CONFIG_SYS_POST_HOTKEYS_GPIO
31#include <asm/gpio.h>
32#endif
33
34#ifdef CONFIG_LOGBUFFER
35#include <logbuff.h>
36#endif
37
38DECLARE_GLOBAL_DATA_PTR;
39
40#define POST_MAX_NUMBER 32
41
42#define BOOTMODE_MAGIC 0xDEAD0000
43
44int post_init_f(void)
45{
46 int res = 0;
47 unsigned int i;
48
49 for (i = 0; i < post_list_size; i++) {
50 struct post_test *test = post_list + i;
51
52 if (test->init_f && test->init_f())
53 res = -1;
54 }
55
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__);
59
60 return res;
61}
62
63
64
65
66
67
68
69
70
71int __post_hotkeys_pressed(void)
72{
73#ifdef CONFIG_SYS_POST_HOTKEYS_GPIO
74 int ret;
75 unsigned gpio = CONFIG_SYS_POST_HOTKEYS_GPIO;
76
77 ret = gpio_request(gpio, "hotkeys");
78 if (ret) {
79 printf("POST: gpio hotkey request failed\n");
80 return 0;
81 }
82
83 gpio_direction_input(gpio);
84 ret = gpio_get_value(gpio);
85 gpio_free(gpio);
86
87 return ret;
88#endif
89
90 return 0;
91}
92int post_hotkeys_pressed(void)
93 __attribute__((weak, alias("__post_hotkeys_pressed")));
94
95
96void post_bootmode_init(void)
97{
98 int bootmode = post_bootmode_get(0);
99 int newword;
100
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
109 newword = post_word_load() & ~POST_COLDBOOT;
110
111 if (bootmode == 0)
112
113 newword |= POST_COLDBOOT;
114
115 post_word_store(newword);
116
117
118 gd->post_log_word = 0;
119 gd->post_log_res = 0;
120}
121
122int post_bootmode_get(unsigned int *last_test)
123{
124 unsigned long word = post_word_load();
125 int bootmode;
126
127 if ((word & 0xFFFF0000) != BOOTMODE_MAGIC)
128 return 0;
129
130 bootmode = word & 0x7F;
131
132 if (last_test && (bootmode & POST_POWERTEST))
133 *last_test = (word >> 8) & 0xFF;
134
135 return bootmode;
136}
137
138
139static void post_log_mark_start(unsigned long testid)
140{
141 gd->post_log_word |= testid;
142}
143
144static void post_log_mark_succ(unsigned long testid)
145{
146 gd->post_log_res |= testid;
147}
148
149
150void post_output_backlog(void)
151{
152 int j;
153
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 }
165}
166
167static void post_bootmode_test_on(unsigned int last_test)
168{
169 unsigned long word = post_word_load();
170
171 word |= POST_POWERTEST;
172
173 word |= (last_test & 0xFF) << 8;
174
175 post_word_store(word);
176}
177
178static void post_bootmode_test_off(void)
179{
180 unsigned long word = post_word_load();
181
182 word &= ~POST_POWERTEST;
183
184 post_word_store(word);
185}
186
187#ifndef CONFIG_POST_SKIP_ENV_FLAGS
188static void post_get_env_flags(int *test_flags)
189{
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];
196 char *name;
197 char *s;
198 int last;
199 int i, j;
200
201 for (i = 0; i < varnum; i++) {
202 if (getenv_f(var[i], list, sizeof(list)) <= 0)
203 continue;
204
205 for (j = 0; j < post_list_size; j++)
206 test_flags[j] &= ~flag[i];
207
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;
222
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 }
229
230 if (j == post_list_size)
231 printf("No such test: %s\n", name);
232
233 name = s + 1;
234 }
235 }
236}
237#endif
238
239static void post_get_flags(int *test_flags)
240{
241 int j;
242
243 for (j = 0; j < post_list_size; j++)
244 test_flags[j] = post_list[j].flags;
245
246#ifndef CONFIG_POST_SKIP_ENV_FLAGS
247 post_get_env_flags(test_flags);
248#endif
249
250 for (j = 0; j < post_list_size; j++)
251 if (test_flags[j] & POST_POWERON)
252 test_flags[j] |= POST_SLOWTEST;
253}
254
255void __show_post_progress(unsigned int test_num, int before, int result)
256{
257}
258void show_post_progress(unsigned int, int, int)
259 __attribute__((weak, alias("__show_post_progress")));
260
261static int post_run_single(struct post_test *test,
262 int test_flags, int flags, unsigned int i)
263{
264 if ((flags & test_flags & POST_ALWAYS) &&
265 (flags & test_flags & POST_MEM)) {
266 WATCHDOG_RESET();
267
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 }
275
276 if (test_flags & POST_PREREL)
277 post_log_mark_start(test->testid);
278 else
279 post_log("POST %s ", test->cmd);
280 }
281
282 show_post_progress(i, POST_BEFORE, POST_FAILED);
283
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 }
309
310 if ((test_flags & POST_REBOOT) && !(flags & POST_MANUAL))
311 post_bootmode_test_off();
312
313 return 0;
314 } else {
315 return -1;
316 }
317}
318
319int post_run(char *name, int flags)
320{
321 unsigned int i;
322 int test_flags[POST_MAX_NUMBER];
323
324 post_get_flags(test_flags);
325
326 if (name == NULL) {
327 unsigned int last;
328
329 if (gd->flags & GD_FLG_POSTSTOP)
330 return 0;
331
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)) {
340
341 post_run_single(post_list + last,
342 test_flags[last],
343 flags | POST_REBOOT, last);
344
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 }
362
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 }
369
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 }
379}
380
381static int post_info_single(struct post_test *test, int full)
382{
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);
389
390 return 0;
391 } else {
392 return -1;
393 }
394}
395
396int post_info(char *name)
397{
398 unsigned int i;
399
400 if (name == NULL) {
401 for (i = 0; i < post_list_size; i++)
402 post_info_single(post_list + i, 0);
403
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 }
410
411 if (i < post_list_size)
412 return post_info_single(post_list + i, 1);
413 else
414 return -1;
415 }
416}
417
418int post_log(char *format, ...)
419{
420 va_list args;
421 char printbuffer[CONFIG_SYS_PBSIZE];
422
423 va_start(args, format);
424
425
426
427
428 vsprintf(printbuffer, format, args);
429 va_end(args);
430
431#ifdef CONFIG_LOGBUFFER
432
433 logbuff_log(printbuffer);
434#else
435
436 puts(printbuffer);
437#endif
438
439 return 0;
440}
441
442#ifdef CONFIG_NEEDS_MANUAL_RELOC
443void post_reloc(void)
444{
445 unsigned int i;
446
447
448
449
450 for (i = 0; i < post_list_size; i++) {
451 ulong addr;
452 struct post_test *test = post_list + i;
453
454 if (test->name) {
455 addr = (ulong)(test->name) + gd->reloc_off;
456 test->name = (char *)addr;
457 }
458
459 if (test->cmd) {
460 addr = (ulong)(test->cmd) + gd->reloc_off;
461 test->cmd = (char *)addr;
462 }
463
464 if (test->desc) {
465 addr = (ulong)(test->desc) + gd->reloc_off;
466 test->desc = (char *)addr;
467 }
468
469 if (test->test) {
470 addr = (ulong)(test->test) + gd->reloc_off;
471 test->test = (int (*)(int flags)) addr;
472 }
473
474 if (test->init_f) {
475 addr = (ulong)(test->init_f) + gd->reloc_off;
476 test->init_f = (int (*)(void)) addr;
477 }
478
479 if (test->reloc) {
480 addr = (ulong)(test->reloc) + gd->reloc_off;
481 test->reloc = (void (*)(void)) addr;
482
483 test->reloc();
484 }
485 }
486}
487#endif
488
489
490
491
492
493
494
495
496unsigned long post_time_ms(unsigned long base)
497{
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;
504#endif
505}
506
