xref: /openbmc/u-boot/post/post.c (revision a3f3897b)
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 
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  */
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 
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 
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 .... */
124 static void post_log_mark_start ( unsigned long testid )
125 {
126 	gd->post_log_word |= (testid)<<16;
127 }
128 
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 */
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 
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 
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 
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 
234 static int post_run_single (struct post_test *test,
235 				int test_flags, int flags, unsigned int i)
236 {
237 	if ((flags & test_flags & POST_ALWAYS) &&
238 		(flags & test_flags & POST_MEM)) {
239 		WATCHDOG_RESET ();
240 
241 		if (!(flags & POST_REBOOT)) {
242 			if ((test_flags & POST_REBOOT) && !(flags & POST_MANUAL)) {
243 				post_bootmode_test_on (
244 					(gd->flags & GD_FLG_POSTFAIL) ?
245 						POST_FAIL_SAVE | i : i);
246 			}
247 
248 			if (test_flags & POST_PREREL)
249 				post_log_mark_start ( test->testid );
250 			else
251 			post_log ("POST %s ", test->cmd);
252 		}
253 
254 		if (test_flags & POST_PREREL) {
255 			if ((*test->test) (flags) == 0)
256 				post_log_mark_succ ( test->testid );
257 			else {
258 				if (test_flags & POST_CRITICAL)
259 					gd->flags |= GD_FLG_POSTFAIL;
260 				if (test_flags & POST_STOP)
261 					gd->flags |= GD_FLG_POSTSTOP;
262 			}
263 		} else {
264 		if ((*test->test) (flags) != 0) {
265 			post_log ("FAILED\n");
266 			show_boot_progress (-32);
267 			if (test_flags & POST_CRITICAL)
268 				gd->flags |= GD_FLG_POSTFAIL;
269 			if (test_flags & POST_STOP)
270 				gd->flags |= GD_FLG_POSTSTOP;
271 		}
272 		else
273 			post_log ("PASSED\n");
274 		}
275 
276 		if ((test_flags & POST_REBOOT) && !(flags & POST_MANUAL)) {
277 			post_bootmode_test_off ();
278 		}
279 
280 		return 0;
281 	} else {
282 		return -1;
283 	}
284 }
285 
286 int post_run (char *name, int flags)
287 {
288 	unsigned int i;
289 	int test_flags[POST_MAX_NUMBER];
290 
291 	post_get_flags (test_flags);
292 
293 	if (name == NULL) {
294 		unsigned int last;
295 
296 		if (gd->flags & GD_FLG_POSTSTOP)
297 			return 0;
298 
299 		if (post_bootmode_get (&last) & POST_POWERTEST) {
300 			if (last & POST_FAIL_SAVE) {
301 				last &= ~POST_FAIL_SAVE;
302 				gd->flags |= GD_FLG_POSTFAIL;
303 			}
304 			if (last < post_list_size &&
305 				(flags & test_flags[last] & POST_ALWAYS) &&
306 				(flags & test_flags[last] & POST_MEM)) {
307 
308 				post_run_single (post_list + last,
309 						 test_flags[last],
310 						 flags | POST_REBOOT, last);
311 
312 				for (i = last + 1; i < post_list_size; i++) {
313 					if (gd->flags & GD_FLG_POSTSTOP)
314 						break;
315 					post_run_single (post_list + i,
316 							 test_flags[i],
317 							 flags, i);
318 				}
319 			}
320 		} else {
321 			for (i = 0; i < post_list_size; i++) {
322 				if (gd->flags & GD_FLG_POSTSTOP)
323 					break;
324 				post_run_single (post_list + i,
325 						 test_flags[i],
326 						 flags, i);
327 			}
328 		}
329 
330 		return 0;
331 	} else {
332 		for (i = 0; i < post_list_size; i++) {
333 			if (strcmp (post_list[i].cmd, name) == 0)
334 				break;
335 		}
336 
337 		if (i < post_list_size) {
338 			WATCHDOG_RESET();
339 			return post_run_single (post_list + i,
340 						test_flags[i],
341 						flags, i);
342 		} else {
343 			return -1;
344 		}
345 	}
346 }
347 
348 static int post_info_single (struct post_test *test, int full)
349 {
350 	if (test->flags & POST_MANUAL) {
351 		if (full)
352 			printf ("%s - %s\n"
353 				"  %s\n", test->cmd, test->name, test->desc);
354 		else
355 			printf ("  %-15s - %s\n", test->cmd, test->name);
356 
357 		return 0;
358 	} else {
359 		return -1;
360 	}
361 }
362 
363 int post_info (char *name)
364 {
365 	unsigned int i;
366 
367 	if (name == NULL) {
368 		for (i = 0; i < post_list_size; i++) {
369 			post_info_single (post_list + i, 0);
370 		}
371 
372 		return 0;
373 	} else {
374 		for (i = 0; i < post_list_size; i++) {
375 			if (strcmp (post_list[i].cmd, name) == 0)
376 				break;
377 		}
378 
379 		if (i < post_list_size) {
380 			return post_info_single (post_list + i, 1);
381 		} else {
382 			return -1;
383 		}
384 	}
385 }
386 
387 int post_log (char *format, ...)
388 {
389 	va_list args;
390 	uint i;
391 	char printbuffer[CONFIG_SYS_PBSIZE];
392 
393 	va_start (args, format);
394 
395 	/* For this to work, printbuffer must be larger than
396 	 * anything we ever want to print.
397 	 */
398 	i = vsprintf (printbuffer, format, args);
399 	va_end (args);
400 
401 #ifdef CONFIG_LOGBUFFER
402 	/* Send to the logbuffer */
403 	logbuff_log (printbuffer);
404 #else
405 	/* Send to the stdout file */
406 	puts (printbuffer);
407 #endif
408 
409 	return 0;
410 }
411 
412 #ifndef CONFIG_RELOC_FIXUP_WORKS
413 void post_reloc (void)
414 {
415 	unsigned int i;
416 
417 	/*
418 	 * We have to relocate the test table manually
419 	 */
420 	for (i = 0; i < post_list_size; i++) {
421 		ulong addr;
422 		struct post_test *test = post_list + i;
423 
424 		if (test->name) {
425 			addr = (ulong) (test->name) + gd->reloc_off;
426 			test->name = (char *) addr;
427 		}
428 
429 		if (test->cmd) {
430 			addr = (ulong) (test->cmd) + gd->reloc_off;
431 			test->cmd = (char *) addr;
432 		}
433 
434 		if (test->desc) {
435 			addr = (ulong) (test->desc) + gd->reloc_off;
436 			test->desc = (char *) addr;
437 		}
438 
439 		if (test->test) {
440 			addr = (ulong) (test->test) + gd->reloc_off;
441 			test->test = (int (*)(int flags)) addr;
442 		}
443 
444 		if (test->init_f) {
445 			addr = (ulong) (test->init_f) + gd->reloc_off;
446 			test->init_f = (int (*)(void)) addr;
447 		}
448 
449 		if (test->reloc) {
450 			addr = (ulong) (test->reloc) + gd->reloc_off;
451 			test->reloc = (void (*)(void)) addr;
452 
453 			test->reloc();
454 		}
455 	}
456 }
457 #endif
458 
459 
460 /*
461  * Some tests (e.g. SYSMON) need the time when post_init_f started,
462  * but we cannot use get_timer() at this point.
463  *
464  * On PowerPC we implement it using the timebase register.
465  */
466 unsigned long post_time_ms (unsigned long base)
467 {
468 #ifdef CONFIG_PPC
469 	return (unsigned long)(get_ticks () / (get_tbclk () / CONFIG_SYS_HZ)) - base;
470 #else
471 #warning "Not implemented yet"
472 	return 0; /* Not implemented yet */
473 #endif
474 }
475