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