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 <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  */