[deliverable/linux.git] / arch / sparc / kernel / kgdb_64.c

/* kgdb.c: KGDB support for 64-bit sparc.
 *
 * Copyright (C) 2008 David S. Miller <davem@davemloft.net>
 */

#include <linux/kgdb.h>
#include <linux/kdebug.h>

#include <asm/kdebug.h>
#include <asm/ptrace.h>
#include <asm/irq.h>

void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs)
{
	struct reg_window *win;
	int i;

	gdb_regs[GDB_G0] = 0;
	for (i = 0; i < 15; i++)
		gdb_regs[GDB_G1 + i] = regs->u_regs[UREG_G1 + i];

	win = (struct reg_window *) (regs->u_regs[UREG_FP] + STACK_BIAS);
	for (i = 0; i < 8; i++)
		gdb_regs[GDB_L0 + i] = win->locals[i];
	for (i = 0; i < 8; i++)
		gdb_regs[GDB_I0 + i] = win->ins[i];

	for (i = GDB_F0; i <= GDB_F62; i++)
		gdb_regs[i] = 0;

	gdb_regs[GDB_PC] = regs->tpc;
	gdb_regs[GDB_NPC] = regs->tnpc;
	gdb_regs[GDB_STATE] = regs->tstate;
	gdb_regs[GDB_FSR] = 0;
	gdb_regs[GDB_FPRS] = 0;
	gdb_regs[GDB_Y] = regs->y;
}

void sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p)
{
	struct thread_info *t = task_thread_info(p);
	extern unsigned int switch_to_pc;
	extern unsigned int ret_from_syscall;
	struct reg_window *win;
	unsigned long pc, cwp;
	int i;

	for (i = GDB_G0; i < GDB_G6; i++)
		gdb_regs[i] = 0;
	gdb_regs[GDB_G6] = (unsigned long) t;
	gdb_regs[GDB_G7] = (unsigned long) p;
	for (i = GDB_O0; i < GDB_SP; i++)
		gdb_regs[i] = 0;
	gdb_regs[GDB_SP] = t->ksp;
	gdb_regs[GDB_O7] = 0;

	win = (struct reg_window *) (t->ksp + STACK_BIAS);
	for (i = 0; i < 8; i++)
		gdb_regs[GDB_L0 + i] = win->locals[i];
	for (i = 0; i < 8; i++)
		gdb_regs[GDB_I0 + i] = win->ins[i];

	for (i = GDB_F0; i <= GDB_F62; i++)
		gdb_regs[i] = 0;

	if (t->new_child)
		pc = (unsigned long) &ret_from_syscall;
	else
		pc = (unsigned long) &switch_to_pc;

	gdb_regs[GDB_PC] = pc;
	gdb_regs[GDB_NPC] = pc + 4;

	cwp = __thread_flag_byte_ptr(t)[TI_FLAG_BYTE_CWP];

	gdb_regs[GDB_STATE] = (TSTATE_PRIV | TSTATE_IE | cwp);
	gdb_regs[GDB_FSR] = 0;
	gdb_regs[GDB_FPRS] = 0;
	gdb_regs[GDB_Y] = 0;
}

void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs)
{
	struct reg_window *win;
	int i;

	for (i = 0; i < 15; i++)
		regs->u_regs[UREG_G1 + i] = gdb_regs[GDB_G1 + i];

	/* If the TSTATE register is changing, we have to preserve
	 * the CWP field, otherwise window save/restore explodes.
	 */
	if (regs->tstate != gdb_regs[GDB_STATE]) {
		unsigned long cwp = regs->tstate & TSTATE_CWP;

		regs->tstate = (gdb_regs[GDB_STATE] & ~TSTATE_CWP) | cwp;
	}

	regs->tpc = gdb_regs[GDB_PC];
	regs->tnpc = gdb_regs[GDB_NPC];
	regs->y = gdb_regs[GDB_Y];

	win = (struct reg_window *) (regs->u_regs[UREG_FP] + STACK_BIAS);
	for (i = 0; i < 8; i++)
		win->locals[i] = gdb_regs[GDB_L0 + i];
	for (i = 0; i < 8; i++)
		win->ins[i] = gdb_regs[GDB_I0 + i];
}

#ifdef CONFIG_SMP
void smp_kgdb_capture_client(struct pt_regs *regs)
{
	unsigned long flags;

	__asm__ __volatile__("rdpr      %%pstate, %0\n\t"
			     "wrpr      %0, %1, %%pstate"
			     : "=r" (flags)
			     : "i" (PSTATE_IE));

	flushw_all();

	if (atomic_read(&kgdb_active) != -1)
		kgdb_nmicallback(raw_smp_processor_id(), regs);

	__asm__ __volatile__("wrpr	%0, 0, %%pstate"
			     : : "r" (flags));
}
#endif

int kgdb_arch_handle_exception(int e_vector, int signo, int err_code,
			       char *remcomInBuffer, char *remcomOutBuffer,
			       struct pt_regs *linux_regs)
{
	unsigned long addr;
	char *ptr;

	switch (remcomInBuffer[0]) {
	case 'c':
		/* try to read optional parameter, pc unchanged if no parm */
		ptr = &remcomInBuffer[1];
		if (kgdb_hex2long(&ptr, &addr)) {
			linux_regs->tpc = addr;
			linux_regs->tnpc = addr + 4;
		}
		/* fallthru */

	case 'D':
	case 'k':
		if (linux_regs->tpc == (unsigned long) arch_kgdb_breakpoint) {
			linux_regs->tpc = linux_regs->tnpc;
			linux_regs->tnpc += 4;
		}
		return 0;
	}
	return -1;
}

asmlinkage void kgdb_trap(unsigned long trap_level, struct pt_regs *regs)
{
	unsigned long flags;

	if (user_mode(regs)) {
		bad_trap(regs, trap_level);
		return;
	}

	flushw_all();

	local_irq_save(flags);
	kgdb_handle_exception(0x172, SIGTRAP, 0, regs);
	local_irq_restore(flags);
}

int kgdb_arch_init(void)
{
	return 0;
}

void kgdb_arch_exit(void)
{
}

struct kgdb_arch arch_kgdb_ops = {
	/* Breakpoint instruction: ta 0x72 */
	.gdb_bpt_instr		= { 0x91, 0xd0, 0x20, 0x72 },
};
Commit	Line	Data
e2fdd7fd DM	1	/* kgdb.c: KGDB support for 64-bit sparc.
	2	*
	3	* Copyright (C) 2008 David S. Miller <davem@davemloft.net>
	4	*/
	5
	6	#include <linux/kgdb.h>
	7	#include <linux/kdebug.h>
	8
	9	#include <asm/kdebug.h>
	10	#include <asm/ptrace.h>
	11	#include <asm/irq.h>
	12
	13	void pt_regs_to_gdb_regs(unsigned long gdb_regs, struct pt_regs regs)
	14	{
	15	struct reg_window *win;
	16	int i;
	17
	18	gdb_regs[GDB_G0] = 0;
	19	for (i = 0; i < 15; i++)
	20	gdb_regs[GDB_G1 + i] = regs->u_regs[UREG_G1 + i];
	21
	22	win = (struct reg_window *) (regs->u_regs[UREG_FP] + STACK_BIAS);
	23	for (i = 0; i < 8; i++)
	24	gdb_regs[GDB_L0 + i] = win->locals[i];
	25	for (i = 0; i < 8; i++)
	26	gdb_regs[GDB_I0 + i] = win->ins[i];
	27
	28	for (i = GDB_F0; i <= GDB_F62; i++)
	29	gdb_regs[i] = 0;
	30
	31	gdb_regs[GDB_PC] = regs->tpc;
	32	gdb_regs[GDB_NPC] = regs->tnpc;
	33	gdb_regs[GDB_STATE] = regs->tstate;
	34	gdb_regs[GDB_FSR] = 0;
	35	gdb_regs[GDB_FPRS] = 0;
	36	gdb_regs[GDB_Y] = regs->y;
	37	}
	38
	39	void sleeping_thread_to_gdb_regs(unsigned long gdb_regs, struct task_struct p)
	40	{
	41	struct thread_info *t = task_thread_info(p);
	42	extern unsigned int switch_to_pc;
	43	extern unsigned int ret_from_syscall;
	44	struct reg_window *win;
	45	unsigned long pc, cwp;
	46	int i;
	47
	48	for (i = GDB_G0; i < GDB_G6; i++)
	49	gdb_regs[i] = 0;
	50	gdb_regs[GDB_G6] = (unsigned long) t;
	51	gdb_regs[GDB_G7] = (unsigned long) p;
	52	for (i = GDB_O0; i < GDB_SP; i++)
	53	gdb_regs[i] = 0;
	54	gdb_regs[GDB_SP] = t->ksp;
	55	gdb_regs[GDB_O7] = 0;
	56
	57	win = (struct reg_window *) (t->ksp + STACK_BIAS);
	58	for (i = 0; i < 8; i++)
	59	gdb_regs[GDB_L0 + i] = win->locals[i];
	60	for (i = 0; i < 8; i++)
	61	gdb_regs[GDB_I0 + i] = win->ins[i];
	62
	63	for (i = GDB_F0; i <= GDB_F62; i++)
	64	gdb_regs[i] = 0;
65
66	if (t->new_child)
67	pc = (unsigned long) &ret_from_syscall;
68	else
69	pc = (unsigned long) &switch_to_pc;
70
71	gdb_regs[GDB_PC] = pc;
72	gdb_regs[GDB_NPC] = pc + 4;
73
74	cwp = __thread_flag_byte_ptr(t)[TI_FLAG_BYTE_CWP];
75
76	gdb_regs[GDB_STATE] = (TSTATE_PRIV \| TSTATE_IE \| cwp);
77	gdb_regs[GDB_FSR] = 0;
78	gdb_regs[GDB_FPRS] = 0;
79	gdb_regs[GDB_Y] = 0;
80	}
81
82	void gdb_regs_to_pt_regs(unsigned long gdb_regs, struct pt_regs regs)
83	{
84	struct reg_window *win;
85	int i;
86
87	for (i = 0; i < 15; i++)
88	regs->u_regs[UREG_G1 + i] = gdb_regs[GDB_G1 + i];
89
90	/* If the TSTATE register is changing, we have to preserve
91	* the CWP field, otherwise window save/restore explodes.
92	*/
93	if (regs->tstate != gdb_regs[GDB_STATE]) {
94	unsigned long cwp = regs->tstate & TSTATE_CWP;
95
96	regs->tstate = (gdb_regs[GDB_STATE] & ~TSTATE_CWP) \| cwp;
97	}
98
99	regs->tpc = gdb_regs[GDB_PC];
100	regs->tnpc = gdb_regs[GDB_NPC];
101	regs->y = gdb_regs[GDB_Y];
102
103	win = (struct reg_window *) (regs->u_regs[UREG_FP] + STACK_BIAS);
104	for (i = 0; i < 8; i++)
105	win->locals[i] = gdb_regs[GDB_L0 + i];
106	for (i = 0; i < 8; i++)
107	win->ins[i] = gdb_regs[GDB_I0 + i];
108	}
109
110	#ifdef CONFIG_SMP
111	void smp_kgdb_capture_client(struct pt_regs *regs)
112	{
113	unsigned long flags;
114
115	__asm__ __volatile__("rdpr %%pstate, %0\n\t"
116	"wrpr %0, %1, %%pstate"
117	: "=r" (flags)
118	: "i" (PSTATE_IE));
119
120	flushw_all();
121
122	if (atomic_read(&kgdb_active) != -1)
123	kgdb_nmicallback(raw_smp_processor_id(), regs);
124
125	__asm__ __volatile__("wrpr %0, 0, %%pstate"
126	: : "r" (flags));
127	}
128	#endif
129
130	int kgdb_arch_handle_exception(int e_vector, int signo, int err_code,
131	char remcomInBuffer, char remcomOutBuffer,
132	struct pt_regs *linux_regs)
133	{
134	unsigned long addr;
135	char *ptr;
136
137	switch (remcomInBuffer[0]) {
138	case 'c':
139	/* try to read optional parameter, pc unchanged if no parm */
140	ptr = &remcomInBuffer[1];
141	if (kgdb_hex2long(&ptr, &addr)) {
142	linux_regs->tpc = addr;
143	linux_regs->tnpc = addr + 4;
144	}
145	/* fallthru */
146
147	case 'D':
148	case 'k':
149	if (linux_regs->tpc == (unsigned long) arch_kgdb_breakpoint) {
150	linux_regs->tpc = linux_regs->tnpc;
151	linux_regs->tnpc += 4;
152	}
153	return 0;
154	}
155	return -1;
156	}
157
158	asmlinkage void kgdb_trap(unsigned long trap_level, struct pt_regs *regs)
159	{
160	unsigned long flags;
161
162	if (user_mode(regs)) {
163	bad_trap(regs, trap_level);
164	return;
165	}
166
167	flushw_all();
168
169	local_irq_save(flags);
170	kgdb_handle_exception(0x172, SIGTRAP, 0, regs);
171	local_irq_restore(flags);
172	}
173
174	int kgdb_arch_init(void)
175	{
176	return 0;
177	}
178
179	void kgdb_arch_exit(void)
180	{
181	}
182
183	struct kgdb_arch arch_kgdb_ops = {
184	/* Breakpoint instruction: ta 0x72 */
185	.gdb_bpt_instr = { 0x91, 0xd0, 0x20, 0x72 },
186	};