[mirror_ubuntu-artful-kernel.git] / arch / mn10300 / kernel / kgdb.c

/* kgdb support for MN10300
 *
 * Copyright (C) 2010 Red Hat, Inc. All Rights Reserved.
 * Written by David Howells (dhowells@redhat.com)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public Licence
 * as published by the Free Software Foundation; either version
 * 2 of the Licence, or (at your option) any later version.
 */

#include <linux/slab.h>
#include <linux/ptrace.h>
#include <linux/kgdb.h>
#include <linux/uaccess.h>
#include <unit/leds.h>
#include <unit/serial.h>
#include <asm/debugger.h>
#include <asm/serial-regs.h>
#include "internal.h"

/*
 * Software single-stepping breakpoint save (used by __switch_to())
 */
static struct thread_info *kgdb_sstep_thread;
u8 *kgdb_sstep_bp_addr[2];
u8 kgdb_sstep_bp[2];

/*
 * Copy kernel exception frame registers to the GDB register file
 */
void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
{
	unsigned long ssp = (unsigned long) (regs + 1);

	gdb_regs[GDB_FR_D0]	= regs->d0;
	gdb_regs[GDB_FR_D1]	= regs->d1;
	gdb_regs[GDB_FR_D2]	= regs->d2;
	gdb_regs[GDB_FR_D3]	= regs->d3;
	gdb_regs[GDB_FR_A0]	= regs->a0;
	gdb_regs[GDB_FR_A1]	= regs->a1;
	gdb_regs[GDB_FR_A2]	= regs->a2;
	gdb_regs[GDB_FR_A3]	= regs->a3;
	gdb_regs[GDB_FR_SP]	= (regs->epsw & EPSW_nSL) ? regs->sp : ssp;
	gdb_regs[GDB_FR_PC]	= regs->pc;
	gdb_regs[GDB_FR_MDR]	= regs->mdr;
	gdb_regs[GDB_FR_EPSW]	= regs->epsw;
	gdb_regs[GDB_FR_LIR]	= regs->lir;
	gdb_regs[GDB_FR_LAR]	= regs->lar;
	gdb_regs[GDB_FR_MDRQ]	= regs->mdrq;
	gdb_regs[GDB_FR_E0]	= regs->e0;
	gdb_regs[GDB_FR_E1]	= regs->e1;
	gdb_regs[GDB_FR_E2]	= regs->e2;
	gdb_regs[GDB_FR_E3]	= regs->e3;
	gdb_regs[GDB_FR_E4]	= regs->e4;
	gdb_regs[GDB_FR_E5]	= regs->e5;
	gdb_regs[GDB_FR_E6]	= regs->e6;
	gdb_regs[GDB_FR_E7]	= regs->e7;
	gdb_regs[GDB_FR_SSP]	= ssp;
	gdb_regs[GDB_FR_MSP]	= 0;
	gdb_regs[GDB_FR_USP]	= regs->sp;
	gdb_regs[GDB_FR_MCRH]	= regs->mcrh;
	gdb_regs[GDB_FR_MCRL]	= regs->mcrl;
	gdb_regs[GDB_FR_MCVF]	= regs->mcvf;
	gdb_regs[GDB_FR_DUMMY0]	= 0;
	gdb_regs[GDB_FR_DUMMY1]	= 0;
	gdb_regs[GDB_FR_FS0]	= 0;
}

/*
 * Extracts kernel SP/PC values understandable by gdb from the values
 * saved by switch_to().
 */
void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
{
	gdb_regs[GDB_FR_SSP]	= p->thread.sp;
	gdb_regs[GDB_FR_PC]	= p->thread.pc;
	gdb_regs[GDB_FR_A3]	= p->thread.a3;
	gdb_regs[GDB_FR_USP]	= p->thread.usp;
	gdb_regs[GDB_FR_FPCR]	= p->thread.fpu_state.fpcr;
}

/*
 * Fill kernel exception frame registers from the GDB register file
 */
void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)
{
	regs->d0	= gdb_regs[GDB_FR_D0];
	regs->d1	= gdb_regs[GDB_FR_D1];
	regs->d2	= gdb_regs[GDB_FR_D2];
	regs->d3	= gdb_regs[GDB_FR_D3];
	regs->a0	= gdb_regs[GDB_FR_A0];
	regs->a1	= gdb_regs[GDB_FR_A1];
	regs->a2	= gdb_regs[GDB_FR_A2];
	regs->a3	= gdb_regs[GDB_FR_A3];
	regs->sp	= gdb_regs[GDB_FR_SP];
	regs->pc	= gdb_regs[GDB_FR_PC];
	regs->mdr	= gdb_regs[GDB_FR_MDR];
	regs->epsw	= gdb_regs[GDB_FR_EPSW];
	regs->lir	= gdb_regs[GDB_FR_LIR];
	regs->lar	= gdb_regs[GDB_FR_LAR];
	regs->mdrq	= gdb_regs[GDB_FR_MDRQ];
	regs->e0	= gdb_regs[GDB_FR_E0];
	regs->e1	= gdb_regs[GDB_FR_E1];
	regs->e2	= gdb_regs[GDB_FR_E2];
	regs->e3	= gdb_regs[GDB_FR_E3];
	regs->e4	= gdb_regs[GDB_FR_E4];
	regs->e5	= gdb_regs[GDB_FR_E5];
	regs->e6	= gdb_regs[GDB_FR_E6];
	regs->e7	= gdb_regs[GDB_FR_E7];
	regs->sp	= gdb_regs[GDB_FR_SSP];
	/* gdb_regs[GDB_FR_MSP]; */
	// regs->usp	= gdb_regs[GDB_FR_USP];
	regs->mcrh	= gdb_regs[GDB_FR_MCRH];
	regs->mcrl	= gdb_regs[GDB_FR_MCRL];
	regs->mcvf	= gdb_regs[GDB_FR_MCVF];
	/* gdb_regs[GDB_FR_DUMMY0]; */
	/* gdb_regs[GDB_FR_DUMMY1]; */

	// regs->fpcr	= gdb_regs[GDB_FR_FPCR];
	// regs->fs0	= gdb_regs[GDB_FR_FS0];
}

struct kgdb_arch arch_kgdb_ops = {
	.gdb_bpt_instr	= { 0xff },
	.flags		= KGDB_HW_BREAKPOINT,
};

static const unsigned char mn10300_kgdb_insn_sizes[256] =
{
	/* 1  2  3  4  5  6  7  8  9  a  b  c  d  e  f */
	1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3,	/* 0 */
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 1 */
	2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, /* 2 */
	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, /* 3 */
	1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, /* 4 */
	1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, /* 5 */
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6 */
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 7 */
	2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 8 */
	2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 9 */
	2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* a */
	2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* b */
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 2, /* c */
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* d */
	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* e */
	0, 2, 2, 2, 2, 2, 2, 4, 0, 3, 0, 4, 0, 6, 7, 1  /* f */
};

/*
 * Attempt to emulate single stepping by means of breakpoint instructions.
 * Although there is a single-step trace flag in EPSW, its use is not
 * sufficiently documented and is only intended for use with the JTAG debugger.
 */
static int kgdb_arch_do_singlestep(struct pt_regs *regs)
{
	unsigned long arg;
	unsigned size;
	u8 *pc = (u8 *)regs->pc, *sp = (u8 *)(regs + 1), cur;
	u8 *x = NULL, *y = NULL;
	int ret;

	ret = probe_kernel_read(&cur, pc, 1);
	if (ret < 0)
		return ret;

	size = mn10300_kgdb_insn_sizes[cur];
	if (size > 0) {
		x = pc + size;
		goto set_x;
	}

	switch (cur) {
		/* Bxx (d8,PC) */
	case 0xc0 ... 0xca:
		ret = probe_kernel_read(&arg, pc + 1, 1);
		if (ret < 0)
			return ret;
		x = pc + 2;
		if (arg >= 0 && arg <= 2)
			goto set_x;
		y = pc + (s8)arg;
		goto set_x_and_y;

		/* LXX (d8,PC) */
	case 0xd0 ... 0xda:
		x = pc + 1;
		if (regs->pc == regs->lar)
			goto set_x;
		y = (u8 *)regs->lar;
		goto set_x_and_y;

		/* SETLB - loads the next four bytes into the LIR register
		 * (which mustn't include a breakpoint instruction) */
	case 0xdb:
		x = pc + 5;
		goto set_x;

		/* JMP (d16,PC) or CALL (d16,PC) */
	case 0xcc:
	case 0xcd:
		ret = probe_kernel_read(&arg, pc + 1, 2);
		if (ret < 0)
			return ret;
		x = pc + (s16)arg;
		goto set_x;

		/* JMP (d32,PC) or CALL (d32,PC) */
	case 0xdc:
	case 0xdd:
		ret = probe_kernel_read(&arg, pc + 1, 4);
		if (ret < 0)
			return ret;
		x = pc + (s32)arg;
		goto set_x;

		/* RETF */
	case 0xde:
		x = (u8 *)regs->mdr;
		goto set_x;

		/* RET */
	case 0xdf:
		ret = probe_kernel_read(&arg, pc + 2, 1);
		if (ret < 0)
			return ret;
		ret = probe_kernel_read(&x, sp + (s8)arg, 4);
		if (ret < 0)
			return ret;
		goto set_x;

	case 0xf0:
		ret = probe_kernel_read(&cur, pc + 1, 1);
		if (ret < 0)
			return ret;

		if (cur >= 0xf0 && cur <= 0xf7) {
			/* JMP (An) / CALLS (An) */
			switch (cur & 3) {
			case 0: x = (u8 *)regs->a0; break;
			case 1: x = (u8 *)regs->a1; break;
			case 2: x = (u8 *)regs->a2; break;
			case 3: x = (u8 *)regs->a3; break;
			}
			goto set_x;
		} else if (cur == 0xfc) {
			/* RETS */
			ret = probe_kernel_read(&x, sp, 4);
			if (ret < 0)
				return ret;
			goto set_x;
		} else if (cur == 0xfd) {
			/* RTI */
			ret = probe_kernel_read(&x, sp + 4, 4);
			if (ret < 0)
				return ret;
			goto set_x;
		} else {
			x = pc + 2;
			goto set_x;
		}
		break;

		/* potential 3-byte conditional branches */
	case 0xf8:
		ret = probe_kernel_read(&cur, pc + 1, 1);
		if (ret < 0)
			return ret;
		x = pc + 3;

		if (cur >= 0xe8 && cur <= 0xeb) {
			ret = probe_kernel_read(&arg, pc + 2, 1);
			if (ret < 0)
				return ret;
			if (arg >= 0 && arg <= 3)
				goto set_x;
			y = pc + (s8)arg;
			goto set_x_and_y;
		}
		goto set_x;

	case 0xfa:
		ret = probe_kernel_read(&cur, pc + 1, 1);
		if (ret < 0)
			return ret;

		if (cur == 0xff) {
			/* CALLS (d16,PC) */
			ret = probe_kernel_read(&arg, pc + 2, 2);
			if (ret < 0)
				return ret;
			x = pc + (s16)arg;
			goto set_x;
		}

		x = pc + 4;
		goto set_x;

	case 0xfc:
		ret = probe_kernel_read(&cur, pc + 1, 1);
		if (ret < 0)
			return ret;

		if (cur == 0xff) {
			/* CALLS (d32,PC) */
			ret = probe_kernel_read(&arg, pc + 2, 4);
			if (ret < 0)
				return ret;
			x = pc + (s32)arg;
			goto set_x;
		}

		x = pc + 6;
		goto set_x;
	}

	return 0;

set_x:
	kgdb_sstep_bp_addr[0] = x;
	kgdb_sstep_bp_addr[1] = NULL;
	ret = probe_kernel_read(&kgdb_sstep_bp[0], x, 1);
	if (ret < 0)
		return ret;
	ret = probe_kernel_write(x, &arch_kgdb_ops.gdb_bpt_instr, 1);
	if (ret < 0)
		return ret;
	kgdb_sstep_thread = current_thread_info();
	debugger_local_cache_flushinv_one(x);
	return ret;

set_x_and_y:
	kgdb_sstep_bp_addr[0] = x;
	kgdb_sstep_bp_addr[1] = y;
	ret = probe_kernel_read(&kgdb_sstep_bp[0], x, 1);
	if (ret < 0)
		return ret;
	ret = probe_kernel_read(&kgdb_sstep_bp[1], y, 1);
	if (ret < 0)
		return ret;
	ret = probe_kernel_write(x, &arch_kgdb_ops.gdb_bpt_instr, 1);
	if (ret < 0)
		return ret;
	ret = probe_kernel_write(y, &arch_kgdb_ops.gdb_bpt_instr, 1);
	if (ret < 0) {
		probe_kernel_write(kgdb_sstep_bp_addr[0],
				   &kgdb_sstep_bp[0], 1);
	} else {
		kgdb_sstep_thread = current_thread_info();
	}
	debugger_local_cache_flushinv_one(x);
	debugger_local_cache_flushinv_one(y);
	return ret;
}

/*
 * Remove emplaced single-step breakpoints, returning true if we hit one of
 * them.
 */
static bool kgdb_arch_undo_singlestep(struct pt_regs *regs)
{
	bool hit = false;
	u8 *x = kgdb_sstep_bp_addr[0], *y = kgdb_sstep_bp_addr[1];
	u8 opcode;

	if (kgdb_sstep_thread == current_thread_info()) {
		if (x) {
			if (x == (u8 *)regs->pc)
				hit = true;
			if (probe_kernel_read(&opcode, x,
					      1) < 0 ||
			    opcode != 0xff)
				BUG();
			probe_kernel_write(x, &kgdb_sstep_bp[0], 1);
			debugger_local_cache_flushinv_one(x);
		}
		if (y) {
			if (y == (u8 *)regs->pc)
				hit = true;
			if (probe_kernel_read(&opcode, y,
					      1) < 0 ||
			    opcode != 0xff)
				BUG();
			probe_kernel_write(y, &kgdb_sstep_bp[1], 1);
			debugger_local_cache_flushinv_one(y);
		}
	}

	kgdb_sstep_bp_addr[0] = NULL;
	kgdb_sstep_bp_addr[1] = NULL;
	kgdb_sstep_thread = NULL;
	return hit;
}

/*
 * Catch a single-step-pending thread being deleted and make sure the global
 * single-step state is cleared.  At this point the breakpoints should have
 * been removed by __switch_to().
 */
void arch_release_thread_stack(unsigned long *stack)
{
	struct thread_info *ti = (void *)stack;
	if (kgdb_sstep_thread == ti) {
		kgdb_sstep_thread = NULL;

		/* However, we may now be running in degraded mode, with most
		 * of the CPUs disabled until such a time as KGDB is reentered,
		 * so force immediate reentry */
		kgdb_breakpoint();
	}
}

/*
 * Handle unknown packets and [CcsDk] packets
 * - at this point breakpoints have been installed
 */
int kgdb_arch_handle_exception(int vector, int signo, int err_code,
			       char *remcom_in_buffer, char *remcom_out_buffer,
			       struct pt_regs *regs)
{
	long addr;
	char *ptr;

	switch (remcom_in_buffer[0]) {
	case 'c':
	case 's':
		/* try to read optional parameter, pc unchanged if no parm */
		ptr = &remcom_in_buffer[1];
		if (kgdb_hex2long(&ptr, &addr))
			regs->pc = addr;
	case 'D':
	case 'k':
		atomic_set(&kgdb_cpu_doing_single_step, -1);

		if (remcom_in_buffer[0] == 's') {
			kgdb_arch_do_singlestep(regs);
			kgdb_single_step = 1;
			atomic_set(&kgdb_cpu_doing_single_step,
				   raw_smp_processor_id());
		}
		return 0;
	}
	return -1; /* this means that we do not want to exit from the handler */
}

/*
 * Handle event interception
 * - returns 0 if the exception should be skipped, -ERROR otherwise.
 */
int debugger_intercept(enum exception_code excep, int signo, int si_code,
		       struct pt_regs *regs)
{
	int ret;

	if (kgdb_arch_undo_singlestep(regs)) {
		excep = EXCEP_TRAP;
		signo = SIGTRAP;
		si_code = TRAP_TRACE;
	}

	ret = kgdb_handle_exception(excep, signo, si_code, regs);

	debugger_local_cache_flushinv();

	return ret;
}

/*
 * Determine if we've hit a debugger special breakpoint
 */
int at_debugger_breakpoint(struct pt_regs *regs)
{
	return regs->pc == (unsigned long)&__arch_kgdb_breakpoint;
}

/*
 * Initialise kgdb
 */
int kgdb_arch_init(void)
{
	return 0;
}

/*
 * Do something, perhaps, but don't know what.
 */
void kgdb_arch_exit(void)
{
}

#ifdef CONFIG_SMP
void debugger_nmi_interrupt(struct pt_regs *regs, enum exception_code code)
{
	kgdb_nmicallback(arch_smp_processor_id(), regs);
	debugger_local_cache_flushinv();
}

void kgdb_roundup_cpus(unsigned long flags)
{
	smp_jump_to_debugger();
}
#endif
Commit	Line	Data
e460d644 DH	1	/* kgdb support for MN10300
	2	*
	3	* Copyright (C) 2010 Red Hat, Inc. All Rights Reserved.
	4	* Written by David Howells (dhowells@redhat.com)
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public Licence
	8	* as published by the Free Software Foundation; either version
	9	* 2 of the Licence, or (at your option) any later version.
	10	*/
	11
5141c46c	12	#include <linux/slab.h>
e460d644 DH	13	#include <linux/ptrace.h>
	14	#include <linux/kgdb.h>
	15	#include <linux/uaccess.h>
	16	#include <unit/leds.h>
	17	#include <unit/serial.h>
	18	#include <asm/debugger.h>
	19	#include <asm/serial-regs.h>
	20	#include "internal.h"
	21
5141c46c DH	22	/*
	23	* Software single-stepping breakpoint save (used by __switch_to())
	24	*/
	25	static struct thread_info *kgdb_sstep_thread;
	26	u8 *kgdb_sstep_bp_addr[2];
	27	u8 kgdb_sstep_bp[2];
	28
e460d644 DH	29	/*
	30	* Copy kernel exception frame registers to the GDB register file
	31	*/
	32	void pt_regs_to_gdb_regs(unsigned long gdb_regs, struct pt_regs regs)
	33	{
	34	unsigned long ssp = (unsigned long) (regs + 1);
	35
	36	gdb_regs[GDB_FR_D0] = regs->d0;
	37	gdb_regs[GDB_FR_D1] = regs->d1;
	38	gdb_regs[GDB_FR_D2] = regs->d2;
	39	gdb_regs[GDB_FR_D3] = regs->d3;
	40	gdb_regs[GDB_FR_A0] = regs->a0;
	41	gdb_regs[GDB_FR_A1] = regs->a1;
	42	gdb_regs[GDB_FR_A2] = regs->a2;
	43	gdb_regs[GDB_FR_A3] = regs->a3;
	44	gdb_regs[GDB_FR_SP] = (regs->epsw & EPSW_nSL) ? regs->sp : ssp;
	45	gdb_regs[GDB_FR_PC] = regs->pc;
	46	gdb_regs[GDB_FR_MDR] = regs->mdr;
	47	gdb_regs[GDB_FR_EPSW] = regs->epsw;
	48	gdb_regs[GDB_FR_LIR] = regs->lir;
	49	gdb_regs[GDB_FR_LAR] = regs->lar;
	50	gdb_regs[GDB_FR_MDRQ] = regs->mdrq;
	51	gdb_regs[GDB_FR_E0] = regs->e0;
	52	gdb_regs[GDB_FR_E1] = regs->e1;
	53	gdb_regs[GDB_FR_E2] = regs->e2;
	54	gdb_regs[GDB_FR_E3] = regs->e3;
	55	gdb_regs[GDB_FR_E4] = regs->e4;
	56	gdb_regs[GDB_FR_E5] = regs->e5;
	57	gdb_regs[GDB_FR_E6] = regs->e6;
	58	gdb_regs[GDB_FR_E7] = regs->e7;
	59	gdb_regs[GDB_FR_SSP] = ssp;
	60	gdb_regs[GDB_FR_MSP] = 0;
	61	gdb_regs[GDB_FR_USP] = regs->sp;
	62	gdb_regs[GDB_FR_MCRH] = regs->mcrh;
	63	gdb_regs[GDB_FR_MCRL] = regs->mcrl;
	64	gdb_regs[GDB_FR_MCVF] = regs->mcvf;
	65	gdb_regs[GDB_FR_DUMMY0] = 0;
	66	gdb_regs[GDB_FR_DUMMY1] = 0;
	67	gdb_regs[GDB_FR_FS0] = 0;
	68	}
	69
	70	/*
	71	* Extracts kernel SP/PC values understandable by gdb from the values
	72	* saved by switch_to().
	73	*/
	74	void sleeping_thread_to_gdb_regs(unsigned long gdb_regs, struct task_struct p)
	75	{
	76	gdb_regs[GDB_FR_SSP] = p->thread.sp;
	77	gdb_regs[GDB_FR_PC] = p->thread.pc;
	78	gdb_regs[GDB_FR_A3] = p->thread.a3;
	79	gdb_regs[GDB_FR_USP] = p->thread.usp;
	80	gdb_regs[GDB_FR_FPCR] = p->thread.fpu_state.fpcr;
	81	}
	82
	83	/*
	84	* Fill kernel exception frame registers from the GDB register file
	85	*/
	86	void gdb_regs_to_pt_regs(unsigned long gdb_regs, struct pt_regs regs)
	87	{
	88	regs->d0 = gdb_regs[GDB_FR_D0];
	89	regs->d1 = gdb_regs[GDB_FR_D1];
	90	regs->d2 = gdb_regs[GDB_FR_D2];
	91	regs->d3 = gdb_regs[GDB_FR_D3];
	92	regs->a0 = gdb_regs[GDB_FR_A0];
93	regs->a1 = gdb_regs[GDB_FR_A1];
94	regs->a2 = gdb_regs[GDB_FR_A2];
95	regs->a3 = gdb_regs[GDB_FR_A3];
96	regs->sp = gdb_regs[GDB_FR_SP];
97	regs->pc = gdb_regs[GDB_FR_PC];
98	regs->mdr = gdb_regs[GDB_FR_MDR];
99	regs->epsw = gdb_regs[GDB_FR_EPSW];
100	regs->lir = gdb_regs[GDB_FR_LIR];
101	regs->lar = gdb_regs[GDB_FR_LAR];
102	regs->mdrq = gdb_regs[GDB_FR_MDRQ];
103	regs->e0 = gdb_regs[GDB_FR_E0];
104	regs->e1 = gdb_regs[GDB_FR_E1];
105	regs->e2 = gdb_regs[GDB_FR_E2];
106	regs->e3 = gdb_regs[GDB_FR_E3];
107	regs->e4 = gdb_regs[GDB_FR_E4];
108	regs->e5 = gdb_regs[GDB_FR_E5];
109	regs->e6 = gdb_regs[GDB_FR_E6];
110	regs->e7 = gdb_regs[GDB_FR_E7];
111	regs->sp = gdb_regs[GDB_FR_SSP];
112	/* gdb_regs[GDB_FR_MSP]; */
113	// regs->usp = gdb_regs[GDB_FR_USP];
114	regs->mcrh = gdb_regs[GDB_FR_MCRH];
115	regs->mcrl = gdb_regs[GDB_FR_MCRL];
116	regs->mcvf = gdb_regs[GDB_FR_MCVF];
117	/* gdb_regs[GDB_FR_DUMMY0]; */
118	/* gdb_regs[GDB_FR_DUMMY1]; */
119
120	// regs->fpcr = gdb_regs[GDB_FR_FPCR];
121	// regs->fs0 = gdb_regs[GDB_FR_FS0];
122	}
123
124	struct kgdb_arch arch_kgdb_ops = {
125	.gdb_bpt_instr = { 0xff },
126	.flags = KGDB_HW_BREAKPOINT,
127	};
128
5141c46c DH	129	static const unsigned char mn10300_kgdb_insn_sizes[256] =
	130	{
	131	/* 1 2 3 4 5 6 7 8 9 a b c d e f */
	132	1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, 1, 3, 3, 3, /* 0 */
	133	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 1 */
	134	2, 2, 2, 2, 3, 3, 3, 3, 2, 2, 2, 2, 3, 3, 3, 3, /* 2 */
	135	3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 1, 1, 1, 1, /* 3 */
	136	1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, 1, 1, 2, 2, /* 4 */
	137	1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, /* 5 */
	138	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 6 */
	139	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 7 */
	140	2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 8 */
	141	2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* 9 */
	142	2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* a */
	143	2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 2, /* b */
	144	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 2, 2, /* c */
	145	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* d */
	146	1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* e */
	147	0, 2, 2, 2, 2, 2, 2, 4, 0, 3, 0, 4, 0, 6, 7, 1 /* f */
	148	};
	149
e460d644	150	/*
5141c46c DH	151	* Attempt to emulate single stepping by means of breakpoint instructions.
	152	* Although there is a single-step trace flag in EPSW, its use is not
	153	* sufficiently documented and is only intended for use with the JTAG debugger.
	154	*/
	155	static int kgdb_arch_do_singlestep(struct pt_regs *regs)
	156	{
	157	unsigned long arg;
	158	unsigned size;
	159	u8 pc = (u8 )regs->pc, sp = (u8 )(regs + 1), cur;
	160	u8 x = NULL, y = NULL;
	161	int ret;
	162
	163	ret = probe_kernel_read(&cur, pc, 1);
	164	if (ret < 0)
	165	return ret;
	166
	167	size = mn10300_kgdb_insn_sizes[cur];
	168	if (size > 0) {
	169	x = pc + size;
	170	goto set_x;
	171	}
	172
	173	switch (cur) {
	174	/* Bxx (d8,PC) */
	175	case 0xc0 ... 0xca:
	176	ret = probe_kernel_read(&arg, pc + 1, 1);
	177	if (ret < 0)
	178	return ret;
	179	x = pc + 2;
	180	if (arg >= 0 && arg <= 2)
	181	goto set_x;
	182	y = pc + (s8)arg;
	183	goto set_x_and_y;
	184
	185	/* LXX (d8,PC) */
	186	case 0xd0 ... 0xda:
	187	x = pc + 1;
	188	if (regs->pc == regs->lar)
	189	goto set_x;
	190	y = (u8 *)regs->lar;
	191	goto set_x_and_y;
	192
	193	/* SETLB - loads the next four bytes into the LIR register
	194	* (which mustn't include a breakpoint instruction) */
	195	case 0xdb:
	196	x = pc + 5;
	197	goto set_x;
	198
	199	/* JMP (d16,PC) or CALL (d16,PC) */
	200	case 0xcc:
	201	case 0xcd:
	202	ret = probe_kernel_read(&arg, pc + 1, 2);
	203	if (ret < 0)
	204	return ret;
	205	x = pc + (s16)arg;
	206	goto set_x;
	207
	208	/* JMP (d32,PC) or CALL (d32,PC) */
	209	case 0xdc:
	210	case 0xdd:
	211	ret = probe_kernel_read(&arg, pc + 1, 4);
	212	if (ret < 0)
	213	return ret;
	214	x = pc + (s32)arg;
215	goto set_x;
216
217	/* RETF */
218	case 0xde:
219	x = (u8 *)regs->mdr;
220	goto set_x;
221
222	/* RET */
223	case 0xdf:
224	ret = probe_kernel_read(&arg, pc + 2, 1);
225	if (ret < 0)
226	return ret;
227	ret = probe_kernel_read(&x, sp + (s8)arg, 4);
228	if (ret < 0)
229	return ret;
230	goto set_x;
231
232	case 0xf0:
233	ret = probe_kernel_read(&cur, pc + 1, 1);
234	if (ret < 0)
235	return ret;
236
237	if (cur >= 0xf0 && cur <= 0xf7) {
238	/* JMP (An) / CALLS (An) */
239	switch (cur & 3) {
240	case 0: x = (u8 *)regs->a0; break;
241	case 1: x = (u8 *)regs->a1; break;
242	case 2: x = (u8 *)regs->a2; break;
243	case 3: x = (u8 *)regs->a3; break;
244	}
245	goto set_x;
246	} else if (cur == 0xfc) {
247	/* RETS */
248	ret = probe_kernel_read(&x, sp, 4);
249	if (ret < 0)
250	return ret;
251	goto set_x;
252	} else if (cur == 0xfd) {
253	/* RTI */
254	ret = probe_kernel_read(&x, sp + 4, 4);
255	if (ret < 0)
256	return ret;
257	goto set_x;
258	} else {
259	x = pc + 2;
260	goto set_x;
261	}
262	break;
263
264	/* potential 3-byte conditional branches */
265	case 0xf8:
266	ret = probe_kernel_read(&cur, pc + 1, 1);
267	if (ret < 0)
268	return ret;
269	x = pc + 3;
270
271	if (cur >= 0xe8 && cur <= 0xeb) {
272	ret = probe_kernel_read(&arg, pc + 2, 1);
273	if (ret < 0)
274	return ret;
275	if (arg >= 0 && arg <= 3)
276	goto set_x;
277	y = pc + (s8)arg;
278	goto set_x_and_y;
279	}
280	goto set_x;
281
282	case 0xfa:
283	ret = probe_kernel_read(&cur, pc + 1, 1);
284	if (ret < 0)
285	return ret;
286
287	if (cur == 0xff) {
288	/* CALLS (d16,PC) */
289	ret = probe_kernel_read(&arg, pc + 2, 2);
290	if (ret < 0)
291	return ret;
292	x = pc + (s16)arg;
293	goto set_x;
294	}
295
296	x = pc + 4;
297	goto set_x;
298
299	case 0xfc:
300	ret = probe_kernel_read(&cur, pc + 1, 1);
301	if (ret < 0)
302	return ret;
303
304	if (cur == 0xff) {
305	/* CALLS (d32,PC) */
306	ret = probe_kernel_read(&arg, pc + 2, 4);
307	if (ret < 0)
308	return ret;
309	x = pc + (s32)arg;
310	goto set_x;
311	}
312
313	x = pc + 6;
314	goto set_x;
315	}
316
317	return 0;
318
319	set_x:
320	kgdb_sstep_bp_addr[0] = x;
321	kgdb_sstep_bp_addr[1] = NULL;
322	ret = probe_kernel_read(&kgdb_sstep_bp[0], x, 1);
323	if (ret < 0)
324	return ret;
325	ret = probe_kernel_write(x, &arch_kgdb_ops.gdb_bpt_instr, 1);
326	if (ret < 0)
327	return ret;
328	kgdb_sstep_thread = current_thread_info();
329	debugger_local_cache_flushinv_one(x);
330	return ret;
331
332	set_x_and_y:
333	kgdb_sstep_bp_addr[0] = x;
334	kgdb_sstep_bp_addr[1] = y;
335	ret = probe_kernel_read(&kgdb_sstep_bp[0], x, 1);
336	if (ret < 0)
337	return ret;
338	ret = probe_kernel_read(&kgdb_sstep_bp[1], y, 1);
339	if (ret < 0)
340	return ret;
341	ret = probe_kernel_write(x, &arch_kgdb_ops.gdb_bpt_instr, 1);
342	if (ret < 0)
343	return ret;
344	ret = probe_kernel_write(y, &arch_kgdb_ops.gdb_bpt_instr, 1);
345	if (ret < 0) {
346	probe_kernel_write(kgdb_sstep_bp_addr[0],
347	&kgdb_sstep_bp[0], 1);
348	} else {
349	kgdb_sstep_thread = current_thread_info();
350	}
351	debugger_local_cache_flushinv_one(x);
352	debugger_local_cache_flushinv_one(y);
353	return ret;
354	}
355
356	/*
357	* Remove emplaced single-step breakpoints, returning true if we hit one of
358	* them.
359	*/
360	static bool kgdb_arch_undo_singlestep(struct pt_regs *regs)
361	{
362	bool hit = false;
363	u8 x = kgdb_sstep_bp_addr[0], y = kgdb_sstep_bp_addr[1];
364	u8 opcode;
365
366	if (kgdb_sstep_thread == current_thread_info()) {
367	if (x) {
368	if (x == (u8 *)regs->pc)
369	hit = true;
370	if (probe_kernel_read(&opcode, x,
371	1) < 0 \|\|
372	opcode != 0xff)
373	BUG();
374	probe_kernel_write(x, &kgdb_sstep_bp[0], 1);
375	debugger_local_cache_flushinv_one(x);
376	}
377	if (y) {
378	if (y == (u8 *)regs->pc)
379	hit = true;
380	if (probe_kernel_read(&opcode, y,
381	1) < 0 \|\|
382	opcode != 0xff)
383	BUG();
384	probe_kernel_write(y, &kgdb_sstep_bp[1], 1);
385	debugger_local_cache_flushinv_one(y);
386	}
387	}
388
389	kgdb_sstep_bp_addr[0] = NULL;
390	kgdb_sstep_bp_addr[1] = NULL;
391	kgdb_sstep_thread = NULL;
392	return hit;
393	}
394
395	/*
396	* Catch a single-step-pending thread being deleted and make sure the global
397	* single-step state is cleared. At this point the breakpoints should have
398	* been removed by __switch_to().
399	*/
b235beea	400	void arch_release_thread_stack(unsigned long *stack)
5141c46c	401	{
b235beea	402	struct thread_info ti = (void )stack;
5141c46c DH	403	if (kgdb_sstep_thread == ti) {
	404	kgdb_sstep_thread = NULL;
	405
	406	/* However, we may now be running in degraded mode, with most
	407	* of the CPUs disabled until such a time as KGDB is reentered,
	408	* so force immediate reentry */
	409	kgdb_breakpoint();
	410	}
5141c46c DH	411	}
	412
	413	/*
	414	* Handle unknown packets and [CcsDk] packets
	415	* - at this point breakpoints have been installed
e460d644 DH	416	*/
	417	int kgdb_arch_handle_exception(int vector, int signo, int err_code,
	418	char remcom_in_buffer, char remcom_out_buffer,
	419	struct pt_regs *regs)
	420	{
	421	long addr;
	422	char *ptr;
	423
	424	switch (remcom_in_buffer[0]) {
	425	case 'c':
5141c46c	426	case 's':
e460d644 DH	427	/* try to read optional parameter, pc unchanged if no parm */
	428	ptr = &remcom_in_buffer[1];
	429	if (kgdb_hex2long(&ptr, &addr))
	430	regs->pc = addr;
5141c46c DH	431	case 'D':
	432	case 'k':
	433	atomic_set(&kgdb_cpu_doing_single_step, -1);
e460d644	434
5141c46c DH	435	if (remcom_in_buffer[0] == 's') {
	436	kgdb_arch_do_singlestep(regs);
	437	kgdb_single_step = 1;
	438	atomic_set(&kgdb_cpu_doing_single_step,
	439	raw_smp_processor_id());
	440	}
	441	return 0;
e460d644 DH	442	}
	443	return -1; /* this means that we do not want to exit from the handler */
	444	}
	445
	446	/*
	447	* Handle event interception
	448	* - returns 0 if the exception should be skipped, -ERROR otherwise.
	449	*/
	450	int debugger_intercept(enum exception_code excep, int signo, int si_code,
	451	struct pt_regs *regs)
	452	{
	453	int ret;
	454
5141c46c DH	455	if (kgdb_arch_undo_singlestep(regs)) {
	456	excep = EXCEP_TRAP;
	457	signo = SIGTRAP;
	458	si_code = TRAP_TRACE;
	459	}
	460
e460d644 DH	461	ret = kgdb_handle_exception(excep, signo, si_code, regs);
	462
	463	debugger_local_cache_flushinv();
	464
	465	return ret;
	466	}
	467
	468	/*
	469	* Determine if we've hit a debugger special breakpoint
	470	*/
	471	int at_debugger_breakpoint(struct pt_regs *regs)
	472	{
	473	return regs->pc == (unsigned long)&__arch_kgdb_breakpoint;
	474	}
	475
	476	/*
	477	* Initialise kgdb
	478	*/
	479	int kgdb_arch_init(void)
	480	{
	481	return 0;
	482	}
	483
	484	/*
	485	* Do something, perhaps, but don't know what.
	486	*/
	487	void kgdb_arch_exit(void)
	488	{
	489	}
	490
	491	#ifdef CONFIG_SMP
	492	void debugger_nmi_interrupt(struct pt_regs *regs, enum exception_code code)
	493	{
	494	kgdb_nmicallback(arch_smp_processor_id(), regs);
	495	debugger_local_cache_flushinv();
	496	}
	497
	498	void kgdb_roundup_cpus(unsigned long flags)
	499	{
	500	smp_jump_to_debugger();
	501	}
	502	#endif