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