[net-next-2.6.git] / arch / sparc / kernel / muldiv.c

/*
 * muldiv.c: Hardware multiply/division illegal instruction trap
 *		for sun4c/sun4 (which do not have those instructions)
 *
 * Copyright (C) 1996 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
 * Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
 *
 * 2004-12-25	Krzysztof Helt (krzysztof.h1@wp.pl) 
 *		- fixed registers constrains in inline assembly declarations
 */

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/mm.h>
#include <asm/ptrace.h>
#include <asm/processor.h>
#include <asm/system.h>
#include <asm/uaccess.h>

#include "kernel.h"

/* #define DEBUG_MULDIV */

static inline int has_imm13(int insn)
{
	return (insn & 0x2000);
}

static inline int is_foocc(int insn)
{
	return (insn & 0x800000);
}

static inline int sign_extend_imm13(int imm)
{
	return imm << 19 >> 19;
}

static inline void advance(struct pt_regs *regs)
{
	regs->pc   = regs->npc;
	regs->npc += 4;
}

static inline void maybe_flush_windows(unsigned int rs1, unsigned int rs2,
				       unsigned int rd)
{
	if(rs2 >= 16 || rs1 >= 16 || rd >= 16) {
		/* Wheee... */
		__asm__ __volatile__("save %sp, -0x40, %sp\n\t"
				     "save %sp, -0x40, %sp\n\t"
				     "save %sp, -0x40, %sp\n\t"
				     "save %sp, -0x40, %sp\n\t"
				     "save %sp, -0x40, %sp\n\t"
				     "save %sp, -0x40, %sp\n\t"
				     "save %sp, -0x40, %sp\n\t"
				     "restore; restore; restore; restore;\n\t"
				     "restore; restore; restore;\n\t");
	}
}

#define fetch_reg(reg, regs) ({						\
	struct reg_window32 __user *win;					\
	register unsigned long ret;					\
									\
	if (!(reg)) ret = 0;						\
	else if ((reg) < 16) {						\
		ret = regs->u_regs[(reg)];				\
	} else {							\
		/* Ho hum, the slightly complicated case. */		\
		win = (struct reg_window32 __user *)regs->u_regs[UREG_FP];\
		if (get_user (ret, &win->locals[(reg) - 16])) return -1;\
	}								\
	ret;								\
})

static inline int
store_reg(unsigned int result, unsigned int reg, struct pt_regs *regs)
{
	struct reg_window32 __user *win;

	if (!reg)
		return 0;
	if (reg < 16) {
		regs->u_regs[reg] = result;
		return 0;
	} else {
		/* need to use put_user() in this case: */
		win = (struct reg_window32 __user *) regs->u_regs[UREG_FP];
		return (put_user(result, &win->locals[reg - 16]));
	}
}

/* Should return 0 if mul/div emulation succeeded and SIGILL should
 * not be issued.
 */
int do_user_muldiv(struct pt_regs *regs, unsigned long pc)
{
	unsigned int insn;
	int inst;
	unsigned int rs1, rs2, rdv;

	if (!pc)
		return -1; /* This happens to often, I think */
	if (get_user (insn, (unsigned int __user *)pc))
		return -1;
	if ((insn & 0xc1400000) != 0x80400000)
		return -1;
	inst = ((insn >> 19) & 0xf);
	if ((inst & 0xe) != 10 && (inst & 0xe) != 14)
		return -1;

	/* Now we know we have to do something with umul, smul, udiv or sdiv */
	rs1 = (insn >> 14) & 0x1f;
	rs2 = insn & 0x1f;
	rdv = (insn >> 25) & 0x1f;
	if (has_imm13(insn)) {
		maybe_flush_windows(rs1, 0, rdv);
		rs2 = sign_extend_imm13(insn);
	} else {
		maybe_flush_windows(rs1, rs2, rdv);
		rs2 = fetch_reg(rs2, regs);
	}
	rs1 = fetch_reg(rs1, regs);
	switch (inst) {
	case 10: /* umul */
#ifdef DEBUG_MULDIV	
		printk ("unsigned muldiv: 0x%x * 0x%x = ", rs1, rs2);
#endif		
		__asm__ __volatile__ ("\n\t"
			"mov	%0, %%o0\n\t"
			"call	.umul\n\t"
			" mov	%1, %%o1\n\t"
			"mov	%%o0, %0\n\t"
			"mov	%%o1, %1\n\t"
			: "=r" (rs1), "=r" (rs2)
		        : "0" (rs1), "1" (rs2)
			: "o0", "o1", "o2", "o3", "o4", "o5", "o7", "cc");
#ifdef DEBUG_MULDIV
		printk ("0x%x%08x\n", rs2, rs1);
#endif
		if (store_reg(rs1, rdv, regs))
			return -1;
		regs->y = rs2;
		break;
	case 11: /* smul */
#ifdef DEBUG_MULDIV
		printk ("signed muldiv: 0x%x * 0x%x = ", rs1, rs2);
#endif
		__asm__ __volatile__ ("\n\t"
			"mov	%0, %%o0\n\t"
			"call	.mul\n\t"
			" mov	%1, %%o1\n\t"
			"mov	%%o0, %0\n\t"
			"mov	%%o1, %1\n\t"
			: "=r" (rs1), "=r" (rs2)
		        : "0" (rs1), "1" (rs2)
			: "o0", "o1", "o2", "o3", "o4", "o5", "o7", "cc");
#ifdef DEBUG_MULDIV
		printk ("0x%x%08x\n", rs2, rs1);
#endif
		if (store_reg(rs1, rdv, regs))
			return -1;
		regs->y = rs2;
		break;
	case 14: /* udiv */
#ifdef DEBUG_MULDIV
		printk ("unsigned muldiv: 0x%x%08x / 0x%x = ", regs->y, rs1, rs2);
#endif
		if (!rs2) {
#ifdef DEBUG_MULDIV
			printk ("DIVISION BY ZERO\n");
#endif
			handle_hw_divzero (regs, pc, regs->npc, regs->psr);
			return 0;
		}
		__asm__ __volatile__ ("\n\t"
			"mov	%2, %%o0\n\t"
			"mov	%0, %%o1\n\t"
			"mov	%%g0, %%o2\n\t"
			"call	__udivdi3\n\t"
			" mov	%1, %%o3\n\t"
			"mov	%%o1, %0\n\t"
			"mov	%%o0, %1\n\t"
			: "=r" (rs1), "=r" (rs2)
			: "r" (regs->y), "0" (rs1), "1" (rs2)
			: "o0", "o1", "o2", "o3", "o4", "o5", "o7",
			  "g1", "g2", "g3", "cc");
#ifdef DEBUG_MULDIV
		printk ("0x%x\n", rs1);
#endif
		if (store_reg(rs1, rdv, regs))
			return -1;
		break;
	case 15: /* sdiv */
#ifdef DEBUG_MULDIV
		printk ("signed muldiv: 0x%x%08x / 0x%x = ", regs->y, rs1, rs2);
#endif
		if (!rs2) {
#ifdef DEBUG_MULDIV
			printk ("DIVISION BY ZERO\n");
#endif
			handle_hw_divzero (regs, pc, regs->npc, regs->psr);
			return 0;
		}
		__asm__ __volatile__ ("\n\t"
			"mov	%2, %%o0\n\t"
			"mov	%0, %%o1\n\t"
			"mov	%%g0, %%o2\n\t"
			"call	__divdi3\n\t"
			" mov	%1, %%o3\n\t"
			"mov	%%o1, %0\n\t"
			"mov	%%o0, %1\n\t"
			: "=r" (rs1), "=r" (rs2)
			: "r" (regs->y), "0" (rs1), "1" (rs2)
			: "o0", "o1", "o2", "o3", "o4", "o5", "o7",
			  "g1", "g2", "g3", "cc");
#ifdef DEBUG_MULDIV
		printk ("0x%x\n", rs1);
#endif
		if (store_reg(rs1, rdv, regs))
			return -1;
		break;
	}
	if (is_foocc (insn)) {
		regs->psr &= ~PSR_ICC;
		if ((inst & 0xe) == 14) {
			/* ?div */
			if (rs2) regs->psr |= PSR_V;
		}
		if (!rs1) regs->psr |= PSR_Z;
		if (((int)rs1) < 0) regs->psr |= PSR_N;
#ifdef DEBUG_MULDIV
		printk ("psr muldiv: %08x\n", regs->psr);
#endif
	}
	advance(regs);
	return 0;
}
Commit	Line	Data
88278ca2	1	/*
1da177e4 LT	2	* muldiv.c: Hardware multiply/division illegal instruction trap
	3	* for sun4c/sun4 (which do not have those instructions)
	4	*
	5	* Copyright (C) 1996 Jakub Jelinek (jj@sunsite.mff.cuni.cz)
	6	* Copyright (C) 1996 David S. Miller (davem@caip.rutgers.edu)
	7	*
	8	* 2004-12-25 Krzysztof Helt (krzysztof.h1@wp.pl)
	9	* - fixed registers constrains in inline assembly declarations
	10	*/
	11
	12	#include <linux/kernel.h>
	13	#include <linux/sched.h>
	14	#include <linux/mm.h>
	15	#include <asm/ptrace.h>
	16	#include <asm/processor.h>
	17	#include <asm/system.h>
	18	#include <asm/uaccess.h>
	19
8d74e32a SR	20	#include "kernel.h"
8d74e32a SR	21
1da177e4 LT	22	/* #define DEBUG_MULDIV */
	23
	24	static inline int has_imm13(int insn)
	25	{
	26	return (insn & 0x2000);
	27	}
	28
	29	static inline int is_foocc(int insn)
	30	{
	31	return (insn & 0x800000);
	32	}
	33
	34	static inline int sign_extend_imm13(int imm)
	35	{
	36	return imm << 19 >> 19;
	37	}
	38
	39	static inline void advance(struct pt_regs *regs)
	40	{
	41	regs->pc = regs->npc;
	42	regs->npc += 4;
	43	}
	44
	45	static inline void maybe_flush_windows(unsigned int rs1, unsigned int rs2,
	46	unsigned int rd)
	47	{
	48	if(rs2 >= 16 \|\| rs1 >= 16 \|\| rd >= 16) {
	49	/* Wheee... */
	50	__asm__ __volatile__("save %sp, -0x40, %sp\n\t"
	51	"save %sp, -0x40, %sp\n\t"
	52	"save %sp, -0x40, %sp\n\t"
	53	"save %sp, -0x40, %sp\n\t"
	54	"save %sp, -0x40, %sp\n\t"
	55	"save %sp, -0x40, %sp\n\t"
	56	"save %sp, -0x40, %sp\n\t"
	57	"restore; restore; restore; restore;\n\t"
	58	"restore; restore; restore;\n\t");
	59	}
	60	}
	61
	62	#define fetch_reg(reg, regs) ({ \
4d7b92ad	63	struct reg_window32 __user *win; \
1da177e4 LT	64	register unsigned long ret; \
	65	\
	66	if (!(reg)) ret = 0; \
	67	else if ((reg) < 16) { \
	68	ret = regs->u_regs[(reg)]; \
	69	} else { \
	70	/* Ho hum, the slightly complicated case. */ \
4d7b92ad	71	win = (struct reg_window32 __user *)regs->u_regs[UREG_FP];\
1da177e4 LT	72	if (get_user (ret, &win->locals[(reg) - 16])) return -1;\
	73	} \
	74	ret; \
	75	})
	76
	77	static inline int
	78	store_reg(unsigned int result, unsigned int reg, struct pt_regs *regs)
	79	{
4d7b92ad	80	struct reg_window32 __user *win;
1da177e4 LT	81
	82	if (!reg)
	83	return 0;
	84	if (reg < 16) {
	85	regs->u_regs[reg] = result;
	86	return 0;
	87	} else {
	88	/* need to use put_user() in this case: */
4d7b92ad	89	win = (struct reg_window32 __user *) regs->u_regs[UREG_FP];
1da177e4 LT	90	return (put_user(result, &win->locals[reg - 16]));
	91	}
	92	}
1da177e4 LT	93
	94	/* Should return 0 if mul/div emulation succeeded and SIGILL should
	95	* not be issued.
	96	*/
	97	int do_user_muldiv(struct pt_regs *regs, unsigned long pc)
	98	{
	99	unsigned int insn;
	100	int inst;
	101	unsigned int rs1, rs2, rdv;
	102
	103	if (!pc)
	104	return -1; /* This happens to often, I think */
	105	if (get_user (insn, (unsigned int __user *)pc))
	106	return -1;
	107	if ((insn & 0xc1400000) != 0x80400000)
	108	return -1;
	109	inst = ((insn >> 19) & 0xf);
	110	if ((inst & 0xe) != 10 && (inst & 0xe) != 14)
	111	return -1;
	112
	113	/* Now we know we have to do something with umul, smul, udiv or sdiv */
	114	rs1 = (insn >> 14) & 0x1f;
	115	rs2 = insn & 0x1f;
	116	rdv = (insn >> 25) & 0x1f;
	117	if (has_imm13(insn)) {
	118	maybe_flush_windows(rs1, 0, rdv);
	119	rs2 = sign_extend_imm13(insn);
	120	} else {
	121	maybe_flush_windows(rs1, rs2, rdv);
	122	rs2 = fetch_reg(rs2, regs);
	123	}
	124	rs1 = fetch_reg(rs1, regs);
	125	switch (inst) {
	126	case 10: /* umul */
	127	#ifdef DEBUG_MULDIV
	128	printk ("unsigned muldiv: 0x%x * 0x%x = ", rs1, rs2);
	129	#endif
	130	__asm__ __volatile__ ("\n\t"
	131	"mov %0, %%o0\n\t"
	132	"call .umul\n\t"
	133	" mov %1, %%o1\n\t"
	134	"mov %%o0, %0\n\t"
	135	"mov %%o1, %1\n\t"
	136	: "=r" (rs1), "=r" (rs2)
	137	: "0" (rs1), "1" (rs2)
	138	: "o0", "o1", "o2", "o3", "o4", "o5", "o7", "cc");
	139	#ifdef DEBUG_MULDIV
	140	printk ("0x%x%08x\n", rs2, rs1);
	141	#endif
	142	if (store_reg(rs1, rdv, regs))
	143	return -1;
	144	regs->y = rs2;
	145	break;
	146	case 11: /* smul */
	147	#ifdef DEBUG_MULDIV
	148	printk ("signed muldiv: 0x%x * 0x%x = ", rs1, rs2);
	149	#endif
	150	__asm__ __volatile__ ("\n\t"
	151	"mov %0, %%o0\n\t"
	152	"call .mul\n\t"
	153	" mov %1, %%o1\n\t"
	154	"mov %%o0, %0\n\t"
	155	"mov %%o1, %1\n\t"
	156	: "=r" (rs1), "=r" (rs2)
157	: "0" (rs1), "1" (rs2)
158	: "o0", "o1", "o2", "o3", "o4", "o5", "o7", "cc");
159	#ifdef DEBUG_MULDIV
160	printk ("0x%x%08x\n", rs2, rs1);
161	#endif
162	if (store_reg(rs1, rdv, regs))
163	return -1;
164	regs->y = rs2;
165	break;
166	case 14: /* udiv */
167	#ifdef DEBUG_MULDIV
168	printk ("unsigned muldiv: 0x%x%08x / 0x%x = ", regs->y, rs1, rs2);
169	#endif
170	if (!rs2) {
171	#ifdef DEBUG_MULDIV
172	printk ("DIVISION BY ZERO\n");
173	#endif
174	handle_hw_divzero (regs, pc, regs->npc, regs->psr);
175	return 0;
176	}
177	__asm__ __volatile__ ("\n\t"
178	"mov %2, %%o0\n\t"
179	"mov %0, %%o1\n\t"
180	"mov %%g0, %%o2\n\t"
181	"call __udivdi3\n\t"
182	" mov %1, %%o3\n\t"
183	"mov %%o1, %0\n\t"
184	"mov %%o0, %1\n\t"
185	: "=r" (rs1), "=r" (rs2)
186	: "r" (regs->y), "0" (rs1), "1" (rs2)
187	: "o0", "o1", "o2", "o3", "o4", "o5", "o7",
188	"g1", "g2", "g3", "cc");
189	#ifdef DEBUG_MULDIV
190	printk ("0x%x\n", rs1);
191	#endif
192	if (store_reg(rs1, rdv, regs))
193	return -1;
194	break;
195	case 15: /* sdiv */
196	#ifdef DEBUG_MULDIV
197	printk ("signed muldiv: 0x%x%08x / 0x%x = ", regs->y, rs1, rs2);
198	#endif
199	if (!rs2) {
200	#ifdef DEBUG_MULDIV
201	printk ("DIVISION BY ZERO\n");
202	#endif
203	handle_hw_divzero (regs, pc, regs->npc, regs->psr);
204	return 0;
205	}
206	__asm__ __volatile__ ("\n\t"
207	"mov %2, %%o0\n\t"
208	"mov %0, %%o1\n\t"
209	"mov %%g0, %%o2\n\t"
210	"call __divdi3\n\t"
211	" mov %1, %%o3\n\t"
212	"mov %%o1, %0\n\t"
213	"mov %%o0, %1\n\t"
214	: "=r" (rs1), "=r" (rs2)
215	: "r" (regs->y), "0" (rs1), "1" (rs2)
216	: "o0", "o1", "o2", "o3", "o4", "o5", "o7",
217	"g1", "g2", "g3", "cc");
218	#ifdef DEBUG_MULDIV
219	printk ("0x%x\n", rs1);
220	#endif
221	if (store_reg(rs1, rdv, regs))
222	return -1;
223	break;
224	}
225	if (is_foocc (insn)) {
226	regs->psr &= ~PSR_ICC;
227	if ((inst & 0xe) == 14) {
228	/* ?div */
229	if (rs2) regs->psr \|= PSR_V;
230	}
231	if (!rs1) regs->psr \|= PSR_Z;
232	if (((int)rs1) < 0) regs->psr \|= PSR_N;
233	#ifdef DEBUG_MULDIV
234	printk ("psr muldiv: %08x\n", regs->psr);
235	#endif
236	}
237	advance(regs);
238	return 0;
239	}