source: SVN/rincon/u-boot/common/cmd_bedbug.c @ 55

Last change on this file since 55 was 55, checked in by Tim Harvey, 22 months ago

rincon: added latest u-boot source

restored form server backup

Signed-off-by: Tim Harvey <tharvey@…>

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