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