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
 29static int wait_for_remote_debugger;
 30
 31struct 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
 84char *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
 98int 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
110void 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
117void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc)
118{
119	regs->ea = pc;
120}
121
122int 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
143asmlinkage 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
157int kgdb_arch_init(void)
158{
159	wait_for_remote_debugger = 1;
160	return 0;
161}
162
163void kgdb_arch_exit(void)
164{
165	/* Nothing to do */
166}
167
168struct kgdb_arch arch_kgdb_ops = {
169	/* Breakpoint instruction: trap 30 */
170	.gdb_bpt_instr = { 0xba, 0x6f, 0x3b, 0x00 },
171};