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 #ifndef MAX
  17 #define MAX(a,b) ((a) > (b) ? (a) : (b))
  18 #endif
  19
  20 extern void show_regs __P ((struct pt_regs *));
  21 extern int run_command __P ((const char *, int));
  22 extern char console_buffer[];
  23
  24 ulong dis_last_addr = 0;        /* Last address disassembled   */
  25 ulong dis_last_len = 20;        /* Default disassembler length */
  26 CPU_DEBUG_CTX bug_ctx;          /* Bedbug context structure    */
  27 \f
  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
  34 int bedbug_puts (const char *str)
  35 {
  36         /* -------------------------------------------------- */
  37
  38         printf ("%s\r\n", str);
  39         return 0;
  40 }                               /* bedbug_puts */
  41 \f
  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
  50 void 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 \f
  74
  75
  76 /* ======================================================================
  77  * Entry point from the interpreter to the disassembler.  Repeated calls
  78  * will resume from the last disassembled address.
  79  * ====================================================================== */
  80 int 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
 113 U_BOOT_CMD (ds, 3, 1, do_bedbug_dis,
 114             "ds      - disassemble memory\n",
 115             "ds <address> [# instructions]\n");
 116 \f
 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  * ====================================================================== */
 122 int 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
 166 U_BOOT_CMD (as, 2, 0, do_bedbug_asm,
 167             "as      - assemble memory\n", "as <address>\n");
 168 \f
 169 /* ======================================================================
 170  * Used to set a break point from the interpreter.  Simply calls into the
 171  * CPU-specific break point set routine.
 172  * ====================================================================== */
 173
 174 int 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
 183 U_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 \f
 190 /* ======================================================================
 191  * Called from the debug interrupt routine.  Simply calls the CPU-specific
 192  * breakpoint handling routine.
 193  * ====================================================================== */
 194
 195 void 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 \f
 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
 215 void 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 \f
 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  * ====================================================================== */
 270 int 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
 283 U_BOOT_CMD (continue, 1, 0, do_bedbug_continue,
 284             "continue- continue from a breakpoint\n",
 285             " - continue from a breakpoint.\n");
 286 \f
 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  * ====================================================================== */
 293 int 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
 314 U_BOOT_CMD (step, 1, 1, do_bedbug_step,
 315             "step    - single step execution.\n",
 316             " - single step execution.\n");
 317 \f
 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  * ====================================================================== */
 324 int 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
 345 U_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 \f
 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  * ====================================================================== */
 353 int 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
 390 U_BOOT_CMD (where, 1, 1, do_bedbug_stack,
 391             "where   - Print the running stack.\n",
 392             " - Print the running stack.\n");
 393 \f
 394 /* ======================================================================
 395  * Interpreter command to dump the registers.  Calls the CPU-specific
 396  * show registers routine.
 397  * ====================================================================== */
 398 int 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
 411 U_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  */