1 /* 2 * Nios2 KGDB support 3 * 4 * Copyright (C) 2015 Altera Corporation 5 * Copyright (C) 2011 Tobias Klauser <tklauser@distanz.ch> 6 * 7 * Based on the code posted by Kazuyasu on the Altera Forum at: 8 * http://www.alteraforum.com/forum/showpost.php?p=77003&postcount=20 9 * 10 * This program is free software; you can redistribute it and/or modify 11 * it under the terms of the GNU General Public License as published by 12 * the Free Software Foundation; either version 2 of the License, or 13 * (at your option) any later version. 14 * 15 * This program is distributed in the hope that it will be useful, 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 * GNU General Public License for more details. 19 * 20 * You should have received a copy of the GNU General Public License 21 * along with this program. If not, see <http://www.gnu.org/licenses/>. 22 * 23 */ 24 #include <linux/ptrace.h> 25 #include <linux/kgdb.h> 26 #include <linux/kdebug.h> 27 #include <linux/io.h> 28 29 static int wait_for_remote_debugger; 30 31 struct dbg_reg_def_t dbg_reg_def[DBG_MAX_REG_NUM] = 32 { 33 { "zero", GDB_SIZEOF_REG, -1 }, 34 { "at", GDB_SIZEOF_REG, offsetof(struct pt_regs, r1) }, 35 { "r2", GDB_SIZEOF_REG, offsetof(struct pt_regs, r2) }, 36 { "r3", GDB_SIZEOF_REG, offsetof(struct pt_regs, r3) }, 37 { "r4", GDB_SIZEOF_REG, offsetof(struct pt_regs, r4) }, 38 { "r5", GDB_SIZEOF_REG, offsetof(struct pt_regs, r5) }, 39 { "r6", GDB_SIZEOF_REG, offsetof(struct pt_regs, r6) }, 40 { "r7", GDB_SIZEOF_REG, offsetof(struct pt_regs, r7) }, 41 { "r8", GDB_SIZEOF_REG, offsetof(struct pt_regs, r8) }, 42 { "r9", GDB_SIZEOF_REG, offsetof(struct pt_regs, r9) }, 43 { "r10", GDB_SIZEOF_REG, offsetof(struct pt_regs, r10) }, 44 { "r11", GDB_SIZEOF_REG, offsetof(struct pt_regs, r11) }, 45 { "r12", GDB_SIZEOF_REG, offsetof(struct pt_regs, r12) }, 46 { "r13", GDB_SIZEOF_REG, offsetof(struct pt_regs, r13) }, 47 { "r14", GDB_SIZEOF_REG, offsetof(struct pt_regs, r14) }, 48 { "r15", GDB_SIZEOF_REG, offsetof(struct pt_regs, r15) }, 49 { "r16", GDB_SIZEOF_REG, -1 }, 50 { "r17", GDB_SIZEOF_REG, -1 }, 51 { "r18", GDB_SIZEOF_REG, -1 }, 52 { "r19", GDB_SIZEOF_REG, -1 }, 53 { "r20", GDB_SIZEOF_REG, -1 }, 54 { "r21", GDB_SIZEOF_REG, -1 }, 55 { "r22", GDB_SIZEOF_REG, -1 }, 56 { "r23", GDB_SIZEOF_REG, -1 }, 57 { "et", GDB_SIZEOF_REG, -1 }, 58 { "bt", GDB_SIZEOF_REG, -1 }, 59 { "gp", GDB_SIZEOF_REG, offsetof(struct pt_regs, gp) }, 60 { "sp", GDB_SIZEOF_REG, offsetof(struct pt_regs, sp) }, 61 { "fp", GDB_SIZEOF_REG, offsetof(struct pt_regs, fp) }, 62 { "ea", GDB_SIZEOF_REG, -1 }, 63 { "ba", GDB_SIZEOF_REG, -1 }, 64 { "ra", GDB_SIZEOF_REG, offsetof(struct pt_regs, ra) }, 65 { "pc", GDB_SIZEOF_REG, offsetof(struct pt_regs, ea) }, 66 { "status", GDB_SIZEOF_REG, -1 }, 67 { "estatus", GDB_SIZEOF_REG, offsetof(struct pt_regs, estatus) }, 68 { "bstatus", GDB_SIZEOF_REG, -1 }, 69 { "ienable", GDB_SIZEOF_REG, -1 }, 70 { "ipending", GDB_SIZEOF_REG, -1}, 71 { "cpuid", GDB_SIZEOF_REG, -1 }, 72 { "ctl6", GDB_SIZEOF_REG, -1 }, 73 { "exception", GDB_SIZEOF_REG, -1 }, 74 { "pteaddr", GDB_SIZEOF_REG, -1 }, 75 { "tlbacc", GDB_SIZEOF_REG, -1 }, 76 { "tlbmisc", GDB_SIZEOF_REG, -1 }, 77 { "eccinj", GDB_SIZEOF_REG, -1 }, 78 { "badaddr", GDB_SIZEOF_REG, -1 }, 79 { "config", GDB_SIZEOF_REG, -1 }, 80 { "mpubase", GDB_SIZEOF_REG, -1 }, 81 { "mpuacc", GDB_SIZEOF_REG, -1 }, 82 }; 83 84 char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs) 85 { 86 if (regno >= DBG_MAX_REG_NUM || regno < 0) 87 return NULL; 88 89 if (dbg_reg_def[regno].offset != -1) 90 memcpy(mem, (void *)regs + dbg_reg_def[regno].offset, 91 dbg_reg_def[regno].size); 92 else 93 memset(mem, 0, dbg_reg_def[regno].size); 94 95 return dbg_reg_def[regno].name; 96 } 97 98 int dbg_set_reg(int regno, void *mem, struct pt_regs *regs) 99 { 100 if (regno >= DBG_MAX_REG_NUM || regno < 0) 101 return -EINVAL; 102 103 if (dbg_reg_def[regno].offset != -1) 104 memcpy((void *)regs + dbg_reg_def[regno].offset, mem, 105 dbg_reg_def[regno].size); 106 107 return 0; 108 } 109 110 void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p) 111 { 112 memset((char *)gdb_regs, 0, NUMREGBYTES); 113 gdb_regs[GDB_SP] = p->thread.kregs->sp; 114 gdb_regs[GDB_PC] = p->thread.kregs->ea; 115 } 116 117 void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc) 118 { 119 regs->ea = pc; 120 } 121 122 int kgdb_arch_handle_exception(int vector, int signo, int err_code, 123 char *remcom_in_buffer, char *remcom_out_buffer, 124 struct pt_regs *regs) 125 { 126 char *ptr; 127 unsigned long addr; 128 129 switch (remcom_in_buffer[0]) { 130 case 's': 131 case 'c': 132 /* handle the optional parameters */ 133 ptr = &remcom_in_buffer[1]; 134 if (kgdb_hex2long(&ptr, &addr)) 135 regs->ea = addr; 136 137 return 0; 138 } 139 140 return -1; /* this means that we do not want to exit from the handler */ 141 } 142 143 asmlinkage void kgdb_breakpoint_c(struct pt_regs *regs) 144 { 145 /* 146 * The breakpoint entry code has moved the PC on by 4 bytes, so we must 147 * move it back. This could be done on the host but we do it here 148 */ 149 if (!wait_for_remote_debugger) 150 regs->ea -= 4; 151 else /* pass the first trap 30 code */ 152 wait_for_remote_debugger = 0; 153 154 kgdb_handle_exception(30, SIGTRAP, 0, regs); 155 } 156 157 int kgdb_arch_init(void) 158 { 159 wait_for_remote_debugger = 1; 160 return 0; 161 } 162 163 void kgdb_arch_exit(void) 164 { 165 /* Nothing to do */ 166 } 167 168 const struct kgdb_arch arch_kgdb_ops = { 169 /* Breakpoint instruction: trap 30 */ 170 .gdb_bpt_instr = { 0xba, 0x6f, 0x3b, 0x00 }, 171 }; 172