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
dbg_get_reg(int regno,void * mem,struct pt_regs * regs)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
dbg_set_reg(int regno,void * mem,struct pt_regs * regs)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
sleeping_thread_to_gdb_regs(unsigned long * gdb_regs,struct task_struct * p)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
kgdb_arch_set_pc(struct pt_regs * regs,unsigned long pc)117 void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
118 {
119 regs->ea = pc;
120 }
121
kgdb_arch_handle_exception(int vector,int signo,int err_code,char * remcom_in_buffer,char * remcom_out_buffer,struct pt_regs * regs)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
kgdb_breakpoint_c(struct pt_regs * regs)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
kgdb_arch_init(void)157 int kgdb_arch_init(void)
158 {
159 wait_for_remote_debugger = 1;
160 return 0;
161 }
162
kgdb_arch_exit(void)163 void kgdb_arch_exit(void)
164 {
165 /* Nothing to do */
166 }
167
168 struct kgdb_arch arch_kgdb_ops = {
169 /* Breakpoint instruction: trap 30 */
170 .gdb_bpt_instr = { 0xba, 0x6f, 0x3b, 0x00 },
171 };
172