post.c 8.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421
  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. #include <common.h>
  24. #include <stdio_dev.h>
  25. #include <watchdog.h>
  26. #include <post.h>
  27. #ifdef CONFIG_LOGBUFFER
  28. #include <logbuff.h>
  29. #endif
  30. DECLARE_GLOBAL_DATA_PTR;
  31. #define POST_MAX_NUMBER 32
  32. #define BOOTMODE_MAGIC 0xDEAD0000
  33. int post_init_f(void)
  34. {
  35. int res = 0;
  36. unsigned int i;
  37. for (i = 0; i < post_list_size; i++) {
  38. struct post_test *test = post_list + i;
  39. if (test->init_f && test->init_f()) {
  40. res = -1;
  41. }
  42. }
  43. gd->post_init_f_time = post_time_ms(0);
  44. if (!gd->post_init_f_time) {
  45. printf
  46. ("post/post.c: post_time_ms seems not to be implemented\n");
  47. }
  48. return res;
  49. }
  50. void post_bootmode_init(void)
  51. {
  52. int bootmode = post_bootmode_get(0);
  53. int newword;
  54. if (post_hotkeys_pressed() && !(bootmode & POST_POWERTEST)) {
  55. newword = BOOTMODE_MAGIC | POST_SLOWTEST;
  56. } else if (bootmode == 0) {
  57. newword = BOOTMODE_MAGIC | POST_POWERON;
  58. } else if (bootmode == POST_POWERON || bootmode == POST_SLOWTEST) {
  59. newword = BOOTMODE_MAGIC | POST_NORMAL;
  60. } else {
  61. /* Use old value */
  62. newword = post_word_load() & ~POST_COLDBOOT;
  63. }
  64. if (bootmode == 0) {
  65. /* We are booting after power-on */
  66. newword |= POST_COLDBOOT;
  67. }
  68. post_word_store(newword);
  69. /* Reset activity record */
  70. gd->post_log_word = 0;
  71. }
  72. int post_bootmode_get(unsigned int *last_test)
  73. {
  74. unsigned long word = post_word_load();
  75. int bootmode;
  76. if ((word & 0xFFFF0000) != BOOTMODE_MAGIC) {
  77. return 0;
  78. }
  79. bootmode = word & 0x7F;
  80. if (last_test && (bootmode & POST_POWERTEST)) {
  81. *last_test = (word >> 8) & 0xFF;
  82. }
  83. return bootmode;
  84. }
  85. /* POST tests run before relocation only mark status bits .... */
  86. static void post_log_mark_start(unsigned long testid)
  87. {
  88. gd->post_log_word |= (testid) << 16;
  89. }
  90. static void post_log_mark_succ(unsigned long testid)
  91. {
  92. gd->post_log_word |= testid;
  93. }
  94. /* ... and the messages are output once we are relocated */
  95. void post_output_backlog(void)
  96. {
  97. int j;
  98. for (j = 0; j < post_list_size; j++) {
  99. if (gd->post_log_word & (post_list[j].testid << 16)) {
  100. post_log("POST %s ", post_list[j].cmd);
  101. if (gd->post_log_word & post_list[j].testid)
  102. post_log("PASSED\n");
  103. else {
  104. post_log("FAILED\n");
  105. show_boot_progress (-31);
  106. }
  107. }
  108. }
  109. }
  110. static void post_bootmode_test_on(unsigned int last_test)
  111. {
  112. unsigned long word = post_word_load();
  113. word |= POST_POWERTEST;
  114. word |= (last_test & 0xFF) << 8;
  115. post_word_store(word);
  116. }
  117. static void post_bootmode_test_off(void)
  118. {
  119. unsigned long word = post_word_load();
  120. word &= ~POST_POWERTEST;
  121. post_word_store(word);
  122. }
  123. static void post_get_flags(int *test_flags)
  124. {
  125. int flag[] = { POST_POWERON, POST_NORMAL, POST_SLOWTEST };
  126. char *var[] = { "post_poweron", "post_normal", "post_slowtest" };
  127. int varnum = sizeof(var) / sizeof(var[0]);
  128. char list[128]; /* long enough for POST list */
  129. char *name;
  130. char *s;
  131. int last;
  132. int i, j;
  133. for (j = 0; j < post_list_size; j++) {
  134. test_flags[j] = post_list[j].flags;
  135. }
  136. for (i = 0; i < varnum; i++) {
  137. if (getenv_r(var[i], list, sizeof(list)) <= 0)
  138. continue;
  139. for (j = 0; j < post_list_size; j++) {
  140. test_flags[j] &= ~flag[i];
  141. }
  142. last = 0;
  143. name = list;
  144. while (!last) {
  145. while (*name && *name == ' ')
  146. name++;
  147. if (*name == 0)
  148. break;
  149. s = name + 1;
  150. while (*s && *s != ' ')
  151. s++;
  152. if (*s == 0)
  153. last = 1;
  154. else
  155. *s = 0;
  156. for (j = 0; j < post_list_size; j++) {
  157. if (strcmp(post_list[j].cmd, name) == 0) {
  158. test_flags[j] |= flag[i];
  159. break;
  160. }
  161. }
  162. if (j == post_list_size) {
  163. printf("No such test: %s\n", name);
  164. }
  165. name = s + 1;
  166. }
  167. }
  168. for (j = 0; j < post_list_size; j++) {
  169. if (test_flags[j] & POST_POWERON) {
  170. test_flags[j] |= POST_SLOWTEST;
  171. }
  172. }
  173. }
  174. static int post_run_single(struct post_test *test,
  175. int test_flags, int flags, unsigned int i)
  176. {
  177. if ((flags & test_flags & POST_ALWAYS) &&
  178. (flags & test_flags & POST_MEM)) {
  179. WATCHDOG_RESET();
  180. if (!(flags & POST_REBOOT)) {
  181. if ((test_flags & POST_REBOOT)
  182. && !(flags & POST_MANUAL)) {
  183. post_bootmode_test_on(i);
  184. }
  185. if (test_flags & POST_PREREL)
  186. post_log_mark_start(test->testid);
  187. else
  188. post_log("POST %s ", test->cmd);
  189. }
  190. if (test_flags & POST_PREREL) {
  191. if ((*test->test) (flags) == 0)
  192. post_log_mark_succ(test->testid);
  193. } else {
  194. if ((*test->test) (flags) != 0) {
  195. post_log("FAILED\n");
  196. show_boot_progress (-32);
  197. } else
  198. post_log("PASSED\n");
  199. }
  200. if ((test_flags & POST_REBOOT) && !(flags & POST_MANUAL)) {
  201. post_bootmode_test_off();
  202. }
  203. return 0;
  204. } else {
  205. return -1;
  206. }
  207. }
  208. int post_run(char *name, int flags)
  209. {
  210. unsigned int i;
  211. int test_flags[POST_MAX_NUMBER];
  212. post_get_flags(test_flags);
  213. if (name == NULL) {
  214. unsigned int last;
  215. if (post_bootmode_get(&last) & POST_POWERTEST) {
  216. if (last < post_list_size &&
  217. (flags & test_flags[last] & POST_ALWAYS) &&
  218. (flags & test_flags[last] & POST_MEM)) {
  219. post_run_single(post_list + last,
  220. test_flags[last],
  221. flags | POST_REBOOT, last);
  222. for (i = last + 1; i < post_list_size; i++) {
  223. post_run_single(post_list + i,
  224. test_flags[i],
  225. flags, i);
  226. }
  227. }
  228. } else {
  229. for (i = 0; i < post_list_size; i++) {
  230. post_run_single(post_list + i,
  231. test_flags[i], flags, i);
  232. }
  233. }
  234. return 0;
  235. } else {
  236. for (i = 0; i < post_list_size; i++) {
  237. if (strcmp(post_list[i].cmd, name) == 0)
  238. break;
  239. }
  240. if (i < post_list_size) {
  241. return post_run_single(post_list + i,
  242. test_flags[i], flags, i);
  243. } else {
  244. return -1;
  245. }
  246. }
  247. }
  248. static int post_info_single(struct post_test *test, int full)
  249. {
  250. if (test->flags & POST_MANUAL) {
  251. if (full)
  252. printf("%s - %s\n"
  253. " %s\n", test->cmd, test->name, test->desc);
  254. else
  255. printf(" %-15s - %s\n", test->cmd, test->name);
  256. return 0;
  257. } else {
  258. return -1;
  259. }
  260. }
  261. int post_info(char *name)
  262. {
  263. unsigned int i;
  264. if (name == NULL) {
  265. for (i = 0; i < post_list_size; i++) {
  266. post_info_single(post_list + i, 0);
  267. }
  268. return 0;
  269. } else {
  270. for (i = 0; i < post_list_size; i++) {
  271. if (strcmp(post_list[i].cmd, name) == 0)
  272. break;
  273. }
  274. if (i < post_list_size) {
  275. return post_info_single(post_list + i, 1);
  276. } else {
  277. return -1;
  278. }
  279. }
  280. }
  281. int post_log(char *format, ...)
  282. {
  283. va_list args;
  284. uint i;
  285. char printbuffer[CONFIG_SYS_PBSIZE];
  286. va_start(args, format);
  287. /* For this to work, printbuffer must be larger than
  288. * anything we ever want to print.
  289. */
  290. i = vsprintf(printbuffer, format, args);
  291. va_end(args);
  292. #ifdef CONFIG_LOGBUFFER
  293. /* Send to the logbuffer */
  294. logbuff_log(printbuffer);
  295. #else
  296. /* Send to the stdout file */
  297. puts(printbuffer);
  298. #endif
  299. return 0;
  300. }
  301. void post_reloc(void)
  302. {
  303. unsigned int i;
  304. /*
  305. * We have to relocate the test table manually
  306. */
  307. for (i = 0; i < post_list_size; i++) {
  308. ulong addr;
  309. struct post_test *test = post_list + i;
  310. if (test->name) {
  311. addr = (ulong) (test->name) + gd->reloc_off;
  312. test->name = (char *)addr;
  313. }
  314. if (test->cmd) {
  315. addr = (ulong) (test->cmd) + gd->reloc_off;
  316. test->cmd = (char *)addr;
  317. }
  318. if (test->desc) {
  319. addr = (ulong) (test->desc) + gd->reloc_off;
  320. test->desc = (char *)addr;
  321. }
  322. if (test->test) {
  323. addr = (ulong) (test->test) + gd->reloc_off;
  324. test->test = (int (*)(int flags))addr;
  325. }
  326. if (test->init_f) {
  327. addr = (ulong) (test->init_f) + gd->reloc_off;
  328. test->init_f = (int (*)(void))addr;
  329. }
  330. if (test->reloc) {
  331. addr = (ulong) (test->reloc) + gd->reloc_off;
  332. test->reloc = (void (*)(void))addr;
  333. test->reloc();
  334. }
  335. }
  336. }
  337. /*
  338. * Some tests (e.g. SYSMON) need the time when post_init_f started,
  339. * but we cannot use get_timer() at this point.
  340. *
  341. * On PowerPC we implement it using the timebase register.
  342. */
  343. unsigned long post_time_ms(unsigned long base)
  344. {
  345. return (unsigned long)get_ticks() / (get_tbclk() / CONFIG_SYS_HZ) - base;
  346. }