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