bedbug.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422
  1. /*
  2. * BedBug Functions
  3. */
  4. #include <common.h>
  5. #include <cli.h>
  6. #include <command.h>
  7. #include <console.h>
  8. #include <linux/ctype.h>
  9. #include <net.h>
  10. #include <bedbug/type.h>
  11. #include <bedbug/bedbug.h>
  12. #include <bedbug/regs.h>
  13. #include <bedbug/ppc.h>
  14. DECLARE_GLOBAL_DATA_PTR;
  15. extern void show_regs __P ((struct pt_regs *));
  16. extern int run_command __P ((const char *, int));
  17. ulong dis_last_addr = 0; /* Last address disassembled */
  18. ulong dis_last_len = 20; /* Default disassembler length */
  19. CPU_DEBUG_CTX bug_ctx; /* Bedbug context structure */
  20. /* ======================================================================
  21. * U-Boot's puts function does not append a newline, so the bedbug stuff
  22. * will use this for the output of the dis/assembler.
  23. * ====================================================================== */
  24. int bedbug_puts (const char *str)
  25. {
  26. /* -------------------------------------------------- */
  27. printf ("%s\r\n", str);
  28. return 0;
  29. } /* bedbug_puts */
  30. /* ======================================================================
  31. * Initialize the bug_ctx structure used by the bedbug debugger. This is
  32. * specific to the CPU since each has different debug registers and
  33. * settings.
  34. * ====================================================================== */
  35. void bedbug_init (void)
  36. {
  37. /* -------------------------------------------------- */
  38. #if defined(CONFIG_4xx)
  39. void bedbug405_init (void);
  40. bedbug405_init ();
  41. #elif defined(CONFIG_8xx)
  42. void bedbug860_init (void);
  43. bedbug860_init ();
  44. #endif
  45. #if defined(CONFIG_MPC824X) || defined(CONFIG_MPC8260)
  46. /* Processors that are 603e core based */
  47. void bedbug603e_init (void);
  48. bedbug603e_init ();
  49. #endif
  50. return;
  51. } /* bedbug_init */
  52. /* ======================================================================
  53. * Entry point from the interpreter to the disassembler. Repeated calls
  54. * will resume from the last disassembled address.
  55. * ====================================================================== */
  56. int do_bedbug_dis (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  57. {
  58. ulong addr; /* Address to start disassembly from */
  59. ulong len; /* # of instructions to disassemble */
  60. /* -------------------------------------------------- */
  61. /* Setup to go from the last address if none is given */
  62. addr = dis_last_addr;
  63. len = dis_last_len;
  64. if (argc < 2)
  65. return CMD_RET_USAGE;
  66. if ((flag & CMD_FLAG_REPEAT) == 0) {
  67. /* New command */
  68. addr = simple_strtoul (argv[1], NULL, 16);
  69. /* If an extra param is given then it is the length */
  70. if (argc > 2)
  71. len = simple_strtoul (argv[2], NULL, 16);
  72. }
  73. /* Run the disassembler */
  74. disppc ((unsigned char *) addr, 0, len, bedbug_puts, F_RADHEX);
  75. dis_last_addr = addr + (len * 4);
  76. dis_last_len = len;
  77. return 0;
  78. } /* do_bedbug_dis */
  79. U_BOOT_CMD (ds, 3, 1, do_bedbug_dis,
  80. "disassemble memory",
  81. "ds <address> [# instructions]");
  82. /* ======================================================================
  83. * Entry point from the interpreter to the assembler. Assembles
  84. * instructions in consecutive memory locations until a '.' (period) is
  85. * entered on a line by itself.
  86. * ====================================================================== */
  87. int do_bedbug_asm (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  88. {
  89. long mem_addr; /* Address to assemble into */
  90. unsigned long instr; /* Machine code for text */
  91. char prompt[15]; /* Prompt string for user input */
  92. int asm_err; /* Error code from the assembler */
  93. /* -------------------------------------------------- */
  94. int rcode = 0;
  95. if (argc < 2)
  96. return CMD_RET_USAGE;
  97. printf ("\nEnter '.' when done\n");
  98. mem_addr = simple_strtoul (argv[1], NULL, 16);
  99. while (1) {
  100. putc ('\n');
  101. disppc ((unsigned char *) mem_addr, 0, 1, bedbug_puts,
  102. F_RADHEX);
  103. sprintf (prompt, "%08lx: ", mem_addr);
  104. cli_readline(prompt);
  105. if (console_buffer[0] && strcmp (console_buffer, ".")) {
  106. if ((instr =
  107. asmppc (mem_addr, console_buffer,
  108. &asm_err)) != 0) {
  109. *(unsigned long *) mem_addr = instr;
  110. mem_addr += 4;
  111. } else {
  112. printf ("*** Error: %s ***\n",
  113. asm_error_str (asm_err));
  114. rcode = 1;
  115. }
  116. } else {
  117. break;
  118. }
  119. }
  120. return rcode;
  121. } /* do_bedbug_asm */
  122. U_BOOT_CMD (as, 2, 0, do_bedbug_asm,
  123. "assemble memory", "as <address>");
  124. /* ======================================================================
  125. * Used to set a break point from the interpreter. Simply calls into the
  126. * CPU-specific break point set routine.
  127. * ====================================================================== */
  128. int do_bedbug_break (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  129. {
  130. /* -------------------------------------------------- */
  131. if (bug_ctx.do_break)
  132. (*bug_ctx.do_break) (cmdtp, flag, argc, argv);
  133. return 0;
  134. } /* do_bedbug_break */
  135. U_BOOT_CMD (break, 3, 0, do_bedbug_break,
  136. "set or clear a breakpoint",
  137. " - Set or clear a breakpoint\n"
  138. "break <address> - Break at an address\n"
  139. "break off <bp#> - Disable breakpoint.\n"
  140. "break show - List breakpoints.");
  141. /* ======================================================================
  142. * Called from the debug interrupt routine. Simply calls the CPU-specific
  143. * breakpoint handling routine.
  144. * ====================================================================== */
  145. void do_bedbug_breakpoint (struct pt_regs *regs)
  146. {
  147. /* -------------------------------------------------- */
  148. if (bug_ctx.break_isr)
  149. (*bug_ctx.break_isr) (regs);
  150. return;
  151. } /* do_bedbug_breakpoint */
  152. /* ======================================================================
  153. * Called from the CPU-specific breakpoint handling routine. Enter a
  154. * mini main loop until the stopped flag is cleared from the breakpoint
  155. * context.
  156. *
  157. * This handles the parts of the debugger that are common to all CPU's.
  158. * ====================================================================== */
  159. void bedbug_main_loop (unsigned long addr, struct pt_regs *regs)
  160. {
  161. int len; /* Length of command line */
  162. int flag; /* Command flags */
  163. int rc = 0; /* Result from run_command */
  164. char prompt_str[20]; /* Prompt string */
  165. static char lastcommand[CONFIG_SYS_CBSIZE] = { 0 }; /* previous command */
  166. /* -------------------------------------------------- */
  167. if (bug_ctx.clear)
  168. (*bug_ctx.clear) (bug_ctx.current_bp);
  169. printf ("Breakpoint %d: ", bug_ctx.current_bp);
  170. disppc ((unsigned char *) addr, 0, 1, bedbug_puts, F_RADHEX);
  171. bug_ctx.stopped = 1;
  172. bug_ctx.regs = regs;
  173. sprintf (prompt_str, "BEDBUG.%d =>", bug_ctx.current_bp);
  174. /* A miniature main loop */
  175. while (bug_ctx.stopped) {
  176. len = cli_readline(prompt_str);
  177. flag = 0; /* assume no special flags for now */
  178. if (len > 0)
  179. strcpy (lastcommand, console_buffer);
  180. else if (len == 0)
  181. flag |= CMD_FLAG_REPEAT;
  182. if (len == -1)
  183. printf ("<INTERRUPT>\n");
  184. else
  185. rc = run_command_repeatable(lastcommand, flag);
  186. if (rc <= 0) {
  187. /* invalid command or not repeatable, forget it */
  188. lastcommand[0] = 0;
  189. }
  190. }
  191. bug_ctx.regs = NULL;
  192. bug_ctx.current_bp = 0;
  193. return;
  194. } /* bedbug_main_loop */
  195. /* ======================================================================
  196. * Interpreter command to continue from a breakpoint. Just clears the
  197. * stopped flag in the context so that the breakpoint routine will
  198. * return.
  199. * ====================================================================== */
  200. int do_bedbug_continue (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  201. {
  202. /* -------------------------------------------------- */
  203. if (!bug_ctx.stopped) {
  204. printf ("Not at a breakpoint\n");
  205. return 1;
  206. }
  207. bug_ctx.stopped = 0;
  208. return 0;
  209. } /* do_bedbug_continue */
  210. U_BOOT_CMD (continue, 1, 0, do_bedbug_continue,
  211. "continue from a breakpoint",
  212. "");
  213. /* ======================================================================
  214. * Interpreter command to continue to the next instruction, stepping into
  215. * subroutines. Works by calling the find_next_addr() routine to compute
  216. * the address passes control to the CPU-specific set breakpoint routine
  217. * for the current breakpoint number.
  218. * ====================================================================== */
  219. int do_bedbug_step (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  220. {
  221. unsigned long addr; /* Address to stop at */
  222. /* -------------------------------------------------- */
  223. if (!bug_ctx.stopped) {
  224. printf ("Not at a breakpoint\n");
  225. return 1;
  226. }
  227. if (!find_next_address((unsigned char *) &addr, false, bug_ctx.regs))
  228. return 1;
  229. if (bug_ctx.set)
  230. (*bug_ctx.set) (bug_ctx.current_bp, addr);
  231. bug_ctx.stopped = 0;
  232. return 0;
  233. } /* do_bedbug_step */
  234. U_BOOT_CMD (step, 1, 1, do_bedbug_step,
  235. "single step execution.",
  236. "");
  237. /* ======================================================================
  238. * Interpreter command to continue to the next instruction, stepping over
  239. * subroutines. Works by calling the find_next_addr() routine to compute
  240. * the address passes control to the CPU-specific set breakpoint routine
  241. * for the current breakpoint number.
  242. * ====================================================================== */
  243. int do_bedbug_next (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  244. {
  245. unsigned long addr; /* Address to stop at */
  246. /* -------------------------------------------------- */
  247. if (!bug_ctx.stopped) {
  248. printf ("Not at a breakpoint\n");
  249. return 1;
  250. }
  251. if (!find_next_address((unsigned char *) &addr, true, bug_ctx.regs))
  252. return 1;
  253. if (bug_ctx.set)
  254. (*bug_ctx.set) (bug_ctx.current_bp, addr);
  255. bug_ctx.stopped = 0;
  256. return 0;
  257. } /* do_bedbug_next */
  258. U_BOOT_CMD (next, 1, 1, do_bedbug_next,
  259. "single step execution, stepping over subroutines.",
  260. "");
  261. /* ======================================================================
  262. * Interpreter command to print the current stack. This assumes an EABI
  263. * architecture, so it starts with GPR R1 and works back up the stack.
  264. * ====================================================================== */
  265. int do_bedbug_stack (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  266. {
  267. unsigned long sp; /* Stack pointer */
  268. unsigned long func; /* LR from stack */
  269. int depth; /* Stack iteration level */
  270. int skip = 1; /* Flag to skip the first entry */
  271. unsigned long top; /* Top of memory address */
  272. /* -------------------------------------------------- */
  273. if (!bug_ctx.stopped) {
  274. printf ("Not at a breakpoint\n");
  275. return 1;
  276. }
  277. top = gd->bd->bi_memstart + gd->bd->bi_memsize;
  278. depth = 0;
  279. printf ("Depth PC\n");
  280. printf ("----- --------\n");
  281. printf ("%5d %08lx\n", depth++, bug_ctx.regs->nip);
  282. sp = bug_ctx.regs->gpr[1];
  283. func = *(unsigned long *) (sp + 4);
  284. while ((func < top) && (sp < top)) {
  285. if (!skip)
  286. printf ("%5d %08lx\n", depth++, func);
  287. else
  288. --skip;
  289. sp = *(unsigned long *) sp;
  290. func = *(unsigned long *) (sp + 4);
  291. }
  292. return 0;
  293. } /* do_bedbug_stack */
  294. U_BOOT_CMD (where, 1, 1, do_bedbug_stack,
  295. "Print the running stack.",
  296. "");
  297. /* ======================================================================
  298. * Interpreter command to dump the registers. Calls the CPU-specific
  299. * show registers routine.
  300. * ====================================================================== */
  301. int do_bedbug_rdump (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
  302. {
  303. /* -------------------------------------------------- */
  304. if (!bug_ctx.stopped) {
  305. printf ("Not at a breakpoint\n");
  306. return 1;
  307. }
  308. show_regs (bug_ctx.regs);
  309. return 0;
  310. } /* do_bedbug_rdump */
  311. U_BOOT_CMD (rdump, 1, 1, do_bedbug_rdump,
  312. "Show registers.", "");
  313. /* ====================================================================== */
  314. /*
  315. * Copyright (c) 2001 William L. Pitts
  316. * All rights reserved.
  317. *
  318. * Redistribution and use in source and binary forms are freely
  319. * permitted provided that the above copyright notice and this
  320. * paragraph and the following disclaimer are duplicated in all
  321. * such forms.
  322. *
  323. * This software is provided "AS IS" and without any express or
  324. * implied warranties, including, without limitation, the implied
  325. * warranties of merchantability and fitness for a particular
  326. * purpose.
  327. */