[U-Boot] [PATCH] Add KGDB support for ARM platforms

Tonny Tzeng tonny.tzeng at gmail.com
Thu Apr 8 11:40:02 CEST 2010


These patches add kgdb support for ARM platforms.

The add and invocation of the bad_restore_user_regs macro in
cpu/arm720t/start.S should be made to other cpu/arm*/start.S
files as well.

Signed-off-by: Tonny Tzeng <tonny.tzeng at gmail.com>
---
 common/kgdb.c          |   30 ++++++
 cpu/arm720t/start.S    |    7 ++
 include/asm-arm/kgdb.h |   67 ++++++++++++
 include/kgdb.h         |   33 ++++++
 lib_arm/Makefile       |    1 +
 lib_arm/board.c        |    6 +
 lib_arm/interrupts.c   |   10 ++
 lib_arm/kgdb.c         |  262 ++++++++++++++++++++++++++++++++++++++++++++++++
 8 files changed, 416 insertions(+), 0 deletions(-)
 create mode 100644 include/asm-arm/kgdb.h
 create mode 100644 lib_arm/kgdb.c

diff --git a/common/kgdb.c b/common/kgdb.c
index 0531452..15ff6e8 100644
--- a/common/kgdb.c
+++ b/common/kgdb.c
@@ -220,6 +220,29 @@ hexToInt(char **ptr, int *intValue)
       return (numChars);
 }

+/* Handle the 'z' or 'Z' breakpoint remove or set packets */
+static void gdb_cmd_break(kgdb_data *kdp)
+{
+       /*
+        * Since GDB-5.3, it's been drafted that '0' is a software
+        * breakpoint, '1' is a hardware breakpoint, so let's do that.
+        */
+       char *bpt_type = &remcomInBuffer[1];
+       char *ptr = &remcomInBuffer[2];
+       int addr, length;
+
+       if (*bpt_type != '0')
+               return;         /* Unsupported. */
+       if (*ptr++ != ',' || !hexToInt(&ptr, &addr) ||
+           *ptr++ != ',' || !hexToInt(&ptr, &length)) {
+               kgdb_error(KGDBERR_BADPARAMS);
+       }
+
+       if (kdp->hook_break &&
+           !(*kdp->hook_break)(remcomInBuffer[0] == 'Z', addr))
+               strcpy(remcomOutBuffer, "OK");
+}
+
 /* scan for the sequence $<data>#<checksum>     */
 static void
 getpacket(char *buffer)
@@ -341,11 +364,14 @@ handle_exception (struct pt_regs *regs)

       kgdb_interruptible(0);

+#ifdef KGDB_DEBUG
       printf("kgdb: handle_exception; trap [0x%x]\n", kgdb_trap(regs));
+#endif

       if (kgdb_setjmp(error_jmp_buf) != 0)
               panic("kgdb: error or fault in entry init!\n");

+       memset(&kd, 0, sizeof(kgdb_data));
       kgdb_enter(regs, &kd);

       if (first_entry) {
@@ -516,6 +542,10 @@ handle_exception (struct pt_regs *regs)
                               kgdb_error(KGDBERR_BADPARAMS);
                       }
                       break;
+               case 'Z': /* [Z|z]N,AA..AA,LLLL Set/Remove breakpoint
type N LLLL bytes at address AA.AA return OK */
+               case 'z':
+                       gdb_cmd_break(&kd);
+                       break;
               }                       /* switch */

               if (errnum != 0)
diff --git a/cpu/arm720t/start.S b/cpu/arm720t/start.S
index 022b873..a59e186 100644
--- a/cpu/arm720t/start.S
+++ b/cpu/arm720t/start.S
@@ -455,6 +455,12 @@ lock_loop:
       mov     r0, sp
       .endm

+       .macro  bad_restore_user_regs
+       ldr     lr, [sp, #S_PSR]                @ Get SVC cpsr
+       msr     spsr_cxsf, lr
+       ldmia   sp, {r0 - pc}^                  @ Restore SVC registers
+       .endm
+
       .macro  irq_save_user_regs
       sub     sp, sp, #S_FRAME_SIZE
       stmia   sp, {r0 - r12}                  @ Calling r0-r12
@@ -506,6 +512,7 @@ undefined_instruction:
       get_bad_stack
       bad_save_user_regs
       bl      do_undefined_instruction
+       bad_restore_user_regs

       .align  5
 software_interrupt:
diff --git a/include/asm-arm/kgdb.h b/include/asm-arm/kgdb.h
new file mode 100644
index 0000000..c33254b
--- /dev/null
+++ b/include/asm-arm/kgdb.h
@@ -0,0 +1,67 @@
+/*
+ * ARM KGDB support
+ *
+ * Author: Deepak Saxena <dsaxena at mvista.com>
+ *
+ * Copyright (C) 2002 MontaVista Software Inc.
+ *
+ */
+
+#ifndef __ARM_KGDB_H__
+#define __ARM_KGDB_H__
+
+#define BREAK_INSTR_SIZE       4
+#define KGDB_COMPILED_BREAK    0xe7ffdeff
+
+#ifndef        __ASSEMBLY__
+
+static inline void arch_kgdb_breakpoint(void)
+{
+       asm(".word 0xe7ffdeff");
+}
+
+#endif /* !__ASSEMBLY__ */
+
+/*
+ * From Kevin Hilman:
+ *
+ * gdb is expecting the following registers layout.
+ *
+ * r0-r15: 1 long word each
+ * f0-f7:  unused, 3 long words each !!
+ * fps:    unused, 1 long word
+ * cpsr:   1 long word
+ *
+ * Even though f0-f7 and fps are not used, they need to be
+ * present in the registers sent for correct processing in
+ * the host-side gdb.
+ *
+ * In particular, it is crucial that CPSR is in the right place,
+ * otherwise gdb will not be able to correctly interpret stepping over
+ * conditional branches.
+ */
+#define _GP_REGS               16
+#define _FP_REGS               8
+#define _EXTRA_REGS            2
+#define GDB_MAX_REGS           (_GP_REGS + (_FP_REGS * 3) + _EXTRA_REGS)
+
+#define _R0                    0
+#define _R1                    1
+#define _R2                    2
+#define _R3                    3
+#define _R4                    4
+#define _R5                    5
+#define _R6                    6
+#define _R7                    7
+#define _R8                    8
+#define _R9                    9
+#define _R10                   10
+#define _FP                    11
+#define _IP                    12
+#define _SPT                   13
+#define _LR                    14
+#define _PC                    15
+#define _CPSR                  (GDB_MAX_REGS - 1)
+
+#endif /* __ASM_KGDB_H__ */
+
diff --git a/include/kgdb.h b/include/kgdb.h
index f543cd6..b4c5d81 100644
--- a/include/kgdb.h
+++ b/include/kgdb.h
@@ -8,6 +8,38 @@
 #define KGDBERR_MEMFAULT       3
 #define KGDBERR_NOSPACE                4
 #define KGDBERR_ALIGNFAULT     5
+#define KGDBERR_BPEXIST                6
+#define KGDBERR_BPNOENT                7
+
+#ifndef BREAK_INSTR_SIZE
+#define BREAK_INSTR_SIZE       4
+#endif
+
+#ifndef KGDB_MAX_BREAKPOINTS
+#define KGDB_MAX_BREAKPOINTS   1000
+#endif
+
+enum kgdb_bptype {
+       BP_BREAKPOINT = 0,
+       BP_HARDWARE_BREAKPOINT,
+       BP_WRITE_WATCHPOINT,
+       BP_READ_WATCHPOINT,
+       BP_ACCESS_WATCHPOINT
+};
+
+enum kgdb_bpstate {
+       BP_UNDEFINED = 0,
+       BP_REMOVED,
+       BP_SET,
+       BP_ACTIVE
+};
+
+struct kgdb_bkpt {
+       unsigned long           bpt_addr;
+       unsigned char           saved_instr[BREAK_INSTR_SIZE];
+       enum kgdb_bptype        type;
+       enum kgdb_bpstate       state;
+};

 #define KGDBDATA_MAXREGS       8
 #define KGDBDATA_MAXPRIV       8
@@ -35,6 +67,7 @@ typedef
               int nregs;
               kgdb_reg regs[KGDBDATA_MAXREGS];
               unsigned long private[KGDBDATA_MAXPRIV];
+               int (*hook_break)(int set, int addr);
       }
 kgdb_data;

diff --git a/lib_arm/Makefile b/lib_arm/Makefile
index 0293348..36fe528 100644
--- a/lib_arm/Makefile
+++ b/lib_arm/Makefile
@@ -44,6 +44,7 @@ COBJS-y       += cache-cp15.o
 endif
 COBJS-y        += interrupts.o
 COBJS-y        += reset.o
+COBJS-$(CONFIG_CMD_KGDB) += kgdb.o

 SRCS   := $(GLSOBJS:.o=.S) $(GLCOBJS:.o=.c) \
          $(SOBJS-y:.o=.S) $(COBJS-y:.o=.c)
diff --git a/lib_arm/board.c b/lib_arm/board.c
index f5660a9..edc2120 100644
--- a/lib_arm/board.c
+++ b/lib_arm/board.c
@@ -39,6 +39,7 @@
 */

 #include <common.h>
+#include <watchdog.h>
 #include <command.h>
 #include <malloc.h>
 #include <stdio_dev.h>
@@ -381,6 +382,11 @@ void start_armboot (void)
       /* miscellaneous platform dependent initialisations */
       misc_init_r ();
 #endif
+#if defined(CONFIG_CMD_KGDB)
+       WATCHDOG_RESET();
+       puts("KGDB:  ");
+       kgdb_init();
+#endif

       /* enable exceptions */
       enable_interrupts ();
diff --git a/lib_arm/interrupts.c b/lib_arm/interrupts.c
index 1f2b815..d62b355 100644
--- a/lib_arm/interrupts.c
+++ b/lib_arm/interrupts.c
@@ -37,6 +37,10 @@

 #include <common.h>
 #include <asm/proc-armv/ptrace.h>
+#include <kgdb.h>
+#ifdef CONFIG_CMD_KGDB
+#include <asm/kgdb.h>
+#endif

 #ifdef CONFIG_USE_IRQ
 DECLARE_GLOBAL_DATA_PTR;
@@ -137,6 +141,12 @@ void show_regs (struct pt_regs *regs)

 void do_undefined_instruction (struct pt_regs *pt_regs)
 {
+#ifdef CONFIG_CMD_KGDB
+       if (*(unsigned long *)(instruction_pointer(pt_regs) - 4) ==
KGDB_COMPILED_BREAK) {
+               (*debugger_exception_handler)(pt_regs);
+               return;
+       }
+#endif
       printf ("undefined instruction\n");
       show_regs (pt_regs);
       bad_mode ();
diff --git a/lib_arm/kgdb.c b/lib_arm/kgdb.c
new file mode 100644
index 0000000..b76b8ed
--- /dev/null
+++ b/lib_arm/kgdb.c
@@ -0,0 +1,262 @@
+/*
+ * Functions in this file are excerpt from the Linux KGDB
+ * supports in the following sources
+ *
+ * (1) linux/kernel/kgdb.c, contributed by:
+ *     David Grothe <dave at gcom.com>,
+ *     Tigran Aivazian <tigran at sco.com>
+ *     Jason Wessel ( jason.wessel at windriver.com )
+ *     George Anzinger <george at mvista.com>
+ *     Anurekh Saxena (anurekh.saxena at timesys.com)
+ *     Lake Stevens Instrument Division (Glenn Engel)
+ *     Jim Kingdon, Cygnus Support.
+ *
+ * (2) linux/arch/arm/kernel/kgdb.c
+ *     Copyright (c) 2002-2004 MontaVista Software, Inc
+ *     Copyright (c) 2008 Wind River Systems, Inc.
+ *     Authors:  George Davis <davis_g at mvista.com>
+ *               Deepak Saxena <dsaxena at plexity.net>
+ */
+#include <common.h>
+#include <asm-generic/signal.h>
+#include <asm/kgdb.h>
+#include <kgdb.h>
+
+/*
+ * kgdb_breakpoint - generate breakpoint exception
+ *
+ * This function will generate a breakpoint exception.  It is used at the
+ * beginning of a program to sync up with a debugger and can be used
+ * otherwise as a quick means to stop program execution and "break" into
+ * the debugger.
+ */
+void kgdb_breakpoint (int argc, char *argv[])
+{
+       arch_kgdb_breakpoint();
+}
+
+/*
+ * Holds information about breakpoints in a kernel. These breakpoints are
+ * added and removed by gdb.
+ */
+static struct kgdb_bkpt        kgdb_break[KGDB_MAX_BREAKPOINTS];
+
+static int kgdb_set_sw_break(int addr)
+{
+       int i, breakno = -1;
+       struct kgdb_bkpt *bkpt;
+
+       for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+               if ((kgdb_break[i].state == BP_SET) &&
+                   (kgdb_break[i].bpt_addr == addr))
+                       return -KGDBERR_BPEXIST;
+               if ((kgdb_break[i].state == BP_REMOVED) &&
+                   (kgdb_break[i].bpt_addr == addr)) {
+                       breakno = i;
+                       break;
+               }
+       }
+       if (breakno == -1)
+               for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+                       if (kgdb_break[i].state == BP_UNDEFINED) {
+                               breakno = i;
+                               break;
+                       }
+               }
+       if (breakno == -1)
+               return -KGDBERR_BPNOENT;
+
+       bkpt = kgdb_break + breakno;
+       bkpt->state = BP_SET;
+       bkpt->type = BP_BREAKPOINT;
+       bkpt->bpt_addr = addr;
+       memcpy(bkpt->saved_instr, addr, BREAK_INSTR_SIZE);
+       *(unsigned long *)addr = KGDB_COMPILED_BREAK;
+
+       return 0;
+}
+
+static int kgdb_remove_sw_break(int addr)
+{
+       int i;
+       struct kgdb_bkpt *bkpt;
+
+       for (i = 0; i < KGDB_MAX_BREAKPOINTS; i++) {
+               bkpt = kgdb_break + i;
+               if ((bkpt->state == BP_SET) && (bkpt->bpt_addr == addr)) {
+                       bkpt->state = BP_REMOVED;
+                       memcpy(addr, bkpt->saved_instr, BREAK_INSTR_SIZE);
+                       return 0;
+               }
+       }
+       return -KGDBERR_BPNOENT;
+}
+
+static int kgdb_sw_break(int set, int addr)
+{
+       return (set) ? kgdb_set_sw_break(addr) : kgdb_remove_sw_break(addr);
+}
+
+int kgdb_setjmp(long *buf)
+{
+       asm("   stmia   r0, {r0-r14}\n  \
+               str     lr,[r0, #60]\n  \
+               mrs     r1,cpsr\n       \
+               str     r1,[r0,#64]\n   \
+               ldr     r1,[r0,#4]\n    \
+           ");
+       return 0;
+}
+
+void kgdb_longjmp(long *buf, int val)
+{
+       asm("   str     r1,[r0]\n       \
+               ldr     r1,[r0, #64]\n  \
+               msr     spsr,r1\n       \
+               ldmia   r0,{r0-pc}^\n   \
+           ");
+}
+
+int kgdb_trap(struct pt_regs *regs)
+{
+       return SIGTRAP;
+}
+
+void kgdb_enter(struct pt_regs *regs, kgdb_data *kdp)
+{
+       kdp->sigval = kgdb_trap(regs);
+       kdp->nregs = 0;
+       kdp->hook_break = kgdb_sw_break;
+}
+
+void kgdb_exit(struct pt_regs *regs, kgdb_data *kdp)
+{
+}
+
+int kgdb_getregs(struct pt_regs *regs, char *buf, int max)
+{
+       int i;
+       unsigned long *gdb_regs = (unsigned long *)buf;
+
+       if (max < (GDB_MAX_REGS * sizeof(unsigned long)))
+               kgdb_error(KGDBERR_NOSPACE);
+
+       /* Initialize all to zero. */
+       for (i = 0; i < GDB_MAX_REGS; i++)
+               gdb_regs[i] = 0;
+
+       gdb_regs[_R0]   = regs->ARM_r0;
+       gdb_regs[_R1]   = regs->ARM_r1;
+       gdb_regs[_R2]   = regs->ARM_r2;
+       gdb_regs[_R3]   = regs->ARM_r3;
+       gdb_regs[_R4]   = regs->ARM_r4;
+       gdb_regs[_R5]   = regs->ARM_r5;
+       gdb_regs[_R6]   = regs->ARM_r6;
+       gdb_regs[_R7]   = regs->ARM_r7;
+       gdb_regs[_R8]   = regs->ARM_r8;
+       gdb_regs[_R9]   = regs->ARM_r9;
+       gdb_regs[_R10]  = regs->ARM_r10;
+       gdb_regs[_FP]   = regs->ARM_fp;
+       gdb_regs[_IP]   = regs->ARM_ip;
+       gdb_regs[_SPT]  = regs->ARM_sp;
+       gdb_regs[_LR]   = regs->ARM_lr;
+       gdb_regs[_PC]   = regs->ARM_pc;
+       gdb_regs[_CPSR] = regs->ARM_cpsr;
+
+       return GDB_MAX_REGS *sizeof(unsigned long);
+}
+
+void kgdb_putreg(struct pt_regs *regs, int regno, char *buf, int length)
+{
+       unsigned long val, *ptr = (unsigned long *)buf;
+
+       if (regno < 0 || GDB_MAX_REGS <= regno)
+               kgdb_error(KGDBERR_BADPARAMS);
+       else {
+               if (length < 4)
+                       kgdb_error(KGDBERR_NOSPACE);
+       }
+       if ((unsigned long)ptr & 3)
+               kgdb_error(KGDBERR_ALIGNFAULT);
+       else
+               val = *ptr;
+
+       switch (regno) {
+       case _R0:
+               regs->ARM_r0 = val; break;
+       case _R1:
+               regs->ARM_r1 = val; break;
+       case _R2:
+               regs->ARM_r2 = val; break;
+       case _R3:
+               regs->ARM_r3 = val; break;
+       case _R4:
+               regs->ARM_r4 = val; break;
+       case _R5:
+               regs->ARM_r5 = val; break;
+       case _R6:
+               regs->ARM_r6 = val; break;
+       case _R7:
+               regs->ARM_r7 = val; break;
+       case _R8:
+               regs->ARM_r8 = val; break;
+       case _R9:
+               regs->ARM_r9 = val; break;
+       case _R10:
+               regs->ARM_r10 = val; break;
+       case _FP:
+               regs->ARM_fp = val; break;
+       case _IP:
+               regs->ARM_ip = val; break;
+       case _SPT:
+               regs->ARM_sp = val; break;
+       case _LR:
+               regs->ARM_lr = val; break;
+       case _PC:
+               regs->ARM_pc = val; break;
+       case 0x19:
+               regs->ARM_cpsr = val; break;
+       default:
+               kgdb_error(KGDBERR_BADPARAMS);
+       }
+}
+
+void kgdb_putregs(struct pt_regs *regs, char *buf, int length)
+{
+       unsigned long *gdb_regs = (unsigned long *)buf;
+
+       if (length < (GDB_MAX_REGS *sizeof(unsigned long)))
+               kgdb_error(KGDBERR_NOSPACE);
+
+       if ((unsigned long)gdb_regs & 3)
+               kgdb_error(KGDBERR_ALIGNFAULT);
+
+       regs->ARM_r0    = gdb_regs[_R0];
+       regs->ARM_r1    = gdb_regs[_R1];
+       regs->ARM_r2    = gdb_regs[_R2];
+       regs->ARM_r3    = gdb_regs[_R3];
+       regs->ARM_r4    = gdb_regs[_R4];
+       regs->ARM_r5    = gdb_regs[_R5];
+       regs->ARM_r6    = gdb_regs[_R6];
+       regs->ARM_r7    = gdb_regs[_R7];
+       regs->ARM_r8    = gdb_regs[_R8];
+       regs->ARM_r9    = gdb_regs[_R9];
+       regs->ARM_r10   = gdb_regs[_R10];
+       regs->ARM_fp    = gdb_regs[_FP];
+       regs->ARM_ip    = gdb_regs[_IP];
+       regs->ARM_sp    = gdb_regs[_SPT];
+       regs->ARM_lr    = gdb_regs[_LR];
+       regs->ARM_pc    = gdb_regs[_PC];
+       regs->ARM_cpsr  = gdb_regs[_CPSR];
+}
+
+void kgdb_interruptible(int yes)
+{
+#ifdef CONFIG_USE_IRQ
+       if (yes)
+               enable_interrupts();
+       else
+               disable_interrupts();
+#endif
+}
+
--
1.6.0.6


More information about the U-Boot mailing list