traps.c 37.6 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5
/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
6
 * Copyright (C) 1994 - 1999, 2000, 01, 06 Ralf Baechle
L
Linus Torvalds 已提交
7 8 9 10 11
 * Copyright (C) 1995, 1996 Paul M. Antoine
 * Copyright (C) 1998 Ulf Carlsson
 * Copyright (C) 1999 Silicon Graphics, Inc.
 * Kevin D. Kissell, kevink@mips.com and Carsten Langgaard, carstenl@mips.com
 * Copyright (C) 2000, 01 MIPS Technologies, Inc.
12
 * Copyright (C) 2002, 2003, 2004, 2005  Maciej W. Rozycki
L
Linus Torvalds 已提交
13
 */
14
#include <linux/bug.h>
L
Linus Torvalds 已提交
15 16 17 18 19 20 21
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/sched.h>
#include <linux/smp.h>
#include <linux/spinlock.h>
#include <linux/kallsyms.h>
22
#include <linux/bootmem.h>
23
#include <linux/interrupt.h>
L
Linus Torvalds 已提交
24 25 26 27 28

#include <asm/bootinfo.h>
#include <asm/branch.h>
#include <asm/break.h>
#include <asm/cpu.h>
29
#include <asm/dsp.h>
L
Linus Torvalds 已提交
30
#include <asm/fpu.h>
R
Ralf Baechle 已提交
31 32
#include <asm/mipsregs.h>
#include <asm/mipsmtregs.h>
L
Linus Torvalds 已提交
33 34 35 36 37 38 39 40 41 42
#include <asm/module.h>
#include <asm/pgtable.h>
#include <asm/ptrace.h>
#include <asm/sections.h>
#include <asm/system.h>
#include <asm/tlbdebug.h>
#include <asm/traps.h>
#include <asm/uaccess.h>
#include <asm/mmu_context.h>
#include <asm/types.h>
43
#include <asm/stacktrace.h>
L
Linus Torvalds 已提交
44

45
extern asmlinkage void handle_int(void);
L
Linus Torvalds 已提交
46 47 48 49 50 51 52 53 54 55
extern asmlinkage void handle_tlbm(void);
extern asmlinkage void handle_tlbl(void);
extern asmlinkage void handle_tlbs(void);
extern asmlinkage void handle_adel(void);
extern asmlinkage void handle_ades(void);
extern asmlinkage void handle_ibe(void);
extern asmlinkage void handle_dbe(void);
extern asmlinkage void handle_sys(void);
extern asmlinkage void handle_bp(void);
extern asmlinkage void handle_ri(void);
56 57
extern asmlinkage void handle_ri_rdhwr_vivt(void);
extern asmlinkage void handle_ri_rdhwr(void);
L
Linus Torvalds 已提交
58 59 60 61 62 63
extern asmlinkage void handle_cpu(void);
extern asmlinkage void handle_ov(void);
extern asmlinkage void handle_tr(void);
extern asmlinkage void handle_fpe(void);
extern asmlinkage void handle_mdmx(void);
extern asmlinkage void handle_watch(void);
R
Ralf Baechle 已提交
64
extern asmlinkage void handle_mt(void);
65
extern asmlinkage void handle_dsp(void);
L
Linus Torvalds 已提交
66 67 68
extern asmlinkage void handle_mcheck(void);
extern asmlinkage void handle_reserved(void);

R
Ralf Baechle 已提交
69
extern int fpu_emulator_cop1Handler(struct pt_regs *xcp,
70
	struct mips_fpu_struct *ctx, int has_fpu);
L
Linus Torvalds 已提交
71 72 73

void (*board_be_init)(void);
int (*board_be_handler)(struct pt_regs *regs, int is_fixup);
74 75 76
void (*board_nmi_handler_setup)(void);
void (*board_ejtag_handler_setup)(void);
void (*board_bind_eic_interrupt)(int irq, int regset);
L
Linus Torvalds 已提交
77 78


F
Franck Bui-Huu 已提交
79
static void show_raw_backtrace(unsigned long reg29)
80
{
F
Franck Bui-Huu 已提交
81
	unsigned long *sp = (unsigned long *)reg29;
82 83 84 85 86 87
	unsigned long addr;

	printk("Call Trace:");
#ifdef CONFIG_KALLSYMS
	printk("\n");
#endif
88 89 90 91
	while (!kstack_end(sp)) {
		addr = *sp++;
		if (__kernel_text_address(addr))
			print_ip_sym(addr);
92 93 94 95
	}
	printk("\n");
}

96
#ifdef CONFIG_KALLSYMS
97
int raw_show_trace;
98 99 100 101 102 103
static int __init set_raw_show_trace(char *str)
{
	raw_show_trace = 1;
	return 1;
}
__setup("raw_show_trace", set_raw_show_trace);
104
#endif
F
Franck Bui-Huu 已提交
105

106
static void show_backtrace(struct task_struct *task, struct pt_regs *regs)
107
{
F
Franck Bui-Huu 已提交
108 109
	unsigned long sp = regs->regs[29];
	unsigned long ra = regs->regs[31];
110 111 112
	unsigned long pc = regs->cp0_epc;

	if (raw_show_trace || !__kernel_text_address(pc)) {
113
		show_raw_backtrace(sp);
114 115 116
		return;
	}
	printk("Call Trace:\n");
F
Franck Bui-Huu 已提交
117
	do {
118
		print_ip_sym(pc);
119
		pc = unwind_stack(task, &sp, pc, &ra);
F
Franck Bui-Huu 已提交
120
	} while (pc);
121 122 123
	printk("\n");
}

L
Linus Torvalds 已提交
124 125 126 127
/*
 * This routine abuses get_user()/put_user() to reference pointers
 * with at least a bit of error checking ...
 */
128
static void show_stacktrace(struct task_struct *task, struct pt_regs *regs)
L
Linus Torvalds 已提交
129 130 131 132
{
	const int field = 2 * sizeof(unsigned long);
	long stackdata;
	int i;
133
	unsigned long *sp = (unsigned long *)regs->regs[29];
L
Linus Torvalds 已提交
134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153

	printk("Stack :");
	i = 0;
	while ((unsigned long) sp & (PAGE_SIZE - 1)) {
		if (i && ((i % (64 / field)) == 0))
			printk("\n       ");
		if (i > 39) {
			printk(" ...");
			break;
		}

		if (__get_user(stackdata, sp++)) {
			printk(" (Bad stack address)");
			break;
		}

		printk(" %0*lx", field, stackdata);
		i++;
	}
	printk("\n");
154
	show_backtrace(task, regs);
155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
}

void show_stack(struct task_struct *task, unsigned long *sp)
{
	struct pt_regs regs;
	if (sp) {
		regs.regs[29] = (unsigned long)sp;
		regs.regs[31] = 0;
		regs.cp0_epc = 0;
	} else {
		if (task && task != current) {
			regs.regs[29] = task->thread.reg29;
			regs.regs[31] = 0;
			regs.cp0_epc = task->thread.reg31;
		} else {
			prepare_frametrace(&regs);
		}
	}
	show_stacktrace(task, &regs);
L
Linus Torvalds 已提交
174 175 176 177 178 179 180
}

/*
 * The architecture-independent dump_stack generator
 */
void dump_stack(void)
{
F
Franck Bui-Huu 已提交
181
	struct pt_regs regs;
L
Linus Torvalds 已提交
182

F
Franck Bui-Huu 已提交
183 184
	prepare_frametrace(&regs);
	show_backtrace(current, &regs);
L
Linus Torvalds 已提交
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230
}

EXPORT_SYMBOL(dump_stack);

void show_code(unsigned int *pc)
{
	long i;

	printk("\nCode:");

	for(i = -3 ; i < 6 ; i++) {
		unsigned int insn;
		if (__get_user(insn, pc + i)) {
			printk(" (Bad address in epc)\n");
			break;
		}
		printk("%c%08x%c", (i?' ':'<'), insn, (i?' ':'>'));
	}
}

void show_regs(struct pt_regs *regs)
{
	const int field = 2 * sizeof(unsigned long);
	unsigned int cause = regs->cp0_cause;
	int i;

	printk("Cpu %d\n", smp_processor_id());

	/*
	 * Saved main processor registers
	 */
	for (i = 0; i < 32; ) {
		if ((i % 4) == 0)
			printk("$%2d   :", i);
		if (i == 0)
			printk(" %0*lx", field, 0UL);
		else if (i == 26 || i == 27)
			printk(" %*s", field, "");
		else
			printk(" %0*lx", field, regs->regs[i]);

		i++;
		if ((i % 4) == 0)
			printk("\n");
	}

231 232 233
#ifdef CONFIG_CPU_HAS_SMARTMIPS
	printk("Acx    : %0*lx\n", field, regs->acx);
#endif
L
Linus Torvalds 已提交
234 235 236 237 238 239 240 241 242 243 244 245 246 247
	printk("Hi    : %0*lx\n", field, regs->hi);
	printk("Lo    : %0*lx\n", field, regs->lo);

	/*
	 * Saved cp0 registers
	 */
	printk("epc   : %0*lx ", field, regs->cp0_epc);
	print_symbol("%s ", regs->cp0_epc);
	printk("    %s\n", print_tainted());
	printk("ra    : %0*lx ", field, regs->regs[31]);
	print_symbol("%s\n", regs->regs[31]);

	printk("Status: %08x    ", (uint32_t) regs->cp0_status);

248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
	if (current_cpu_data.isa_level == MIPS_CPU_ISA_I) {
		if (regs->cp0_status & ST0_KUO)
			printk("KUo ");
		if (regs->cp0_status & ST0_IEO)
			printk("IEo ");
		if (regs->cp0_status & ST0_KUP)
			printk("KUp ");
		if (regs->cp0_status & ST0_IEP)
			printk("IEp ");
		if (regs->cp0_status & ST0_KUC)
			printk("KUc ");
		if (regs->cp0_status & ST0_IEC)
			printk("IEc ");
	} else {
		if (regs->cp0_status & ST0_KX)
			printk("KX ");
		if (regs->cp0_status & ST0_SX)
			printk("SX ");
		if (regs->cp0_status & ST0_UX)
			printk("UX ");
		switch (regs->cp0_status & ST0_KSU) {
		case KSU_USER:
			printk("USER ");
			break;
		case KSU_SUPERVISOR:
			printk("SUPERVISOR ");
			break;
		case KSU_KERNEL:
			printk("KERNEL ");
			break;
		default:
			printk("BAD_MODE ");
			break;
		}
		if (regs->cp0_status & ST0_ERL)
			printk("ERL ");
		if (regs->cp0_status & ST0_EXL)
			printk("EXL ");
		if (regs->cp0_status & ST0_IE)
			printk("IE ");
L
Linus Torvalds 已提交
288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
	}
	printk("\n");

	printk("Cause : %08x\n", cause);

	cause = (cause & CAUSEF_EXCCODE) >> CAUSEB_EXCCODE;
	if (1 <= cause && cause <= 5)
		printk("BadVA : %0*lx\n", field, regs->cp0_badvaddr);

	printk("PrId  : %08x\n", read_c0_prid());
}

void show_registers(struct pt_regs *regs)
{
	show_regs(regs);
	print_modules();
	printk("Process %s (pid: %d, threadinfo=%p, task=%p)\n",
	        current->comm, current->pid, current_thread_info(), current);
306
	show_stacktrace(current, regs);
L
Linus Torvalds 已提交
307 308 309 310 311 312
	show_code((unsigned int *) regs->cp0_epc);
	printk("\n");
}

static DEFINE_SPINLOCK(die_lock);

313
void __noreturn die(const char * str, struct pt_regs * regs)
L
Linus Torvalds 已提交
314 315
{
	static int die_counter;
316 317 318
#ifdef CONFIG_MIPS_MT_SMTC
	unsigned long dvpret = dvpe();
#endif /* CONFIG_MIPS_MT_SMTC */
L
Linus Torvalds 已提交
319 320 321

	console_verbose();
	spin_lock_irq(&die_lock);
322 323 324 325
	bust_spinlocks(1);
#ifdef CONFIG_MIPS_MT_SMTC
	mips_mt_regdump(dvpret);
#endif /* CONFIG_MIPS_MT_SMTC */
326
	printk("%s[#%d]:\n", str, ++die_counter);
L
Linus Torvalds 已提交
327 328
	show_registers(regs);
	spin_unlock_irq(&die_lock);
329 330 331 332 333 334 335 336 337 338

	if (in_interrupt())
		panic("Fatal exception in interrupt");

	if (panic_on_oops) {
		printk(KERN_EMERG "Fatal exception: panic in 5 seconds\n");
		ssleep(5);
		panic("Fatal exception");
	}

L
Linus Torvalds 已提交
339 340 341 342 343 344
	do_exit(SIGSEGV);
}

extern const struct exception_table_entry __start___dbe_table[];
extern const struct exception_table_entry __stop___dbe_table[];

345 346 347
__asm__(
"	.section	__dbe_table, \"a\"\n"
"	.previous			\n");
L
Linus Torvalds 已提交
348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409

/* Given an address, look for it in the exception tables. */
static const struct exception_table_entry *search_dbe_tables(unsigned long addr)
{
	const struct exception_table_entry *e;

	e = search_extable(__start___dbe_table, __stop___dbe_table - 1, addr);
	if (!e)
		e = search_module_dbetables(addr);
	return e;
}

asmlinkage void do_be(struct pt_regs *regs)
{
	const int field = 2 * sizeof(unsigned long);
	const struct exception_table_entry *fixup = NULL;
	int data = regs->cp0_cause & 4;
	int action = MIPS_BE_FATAL;

	/* XXX For now.  Fixme, this searches the wrong table ...  */
	if (data && !user_mode(regs))
		fixup = search_dbe_tables(exception_epc(regs));

	if (fixup)
		action = MIPS_BE_FIXUP;

	if (board_be_handler)
		action = board_be_handler(regs, fixup != 0);

	switch (action) {
	case MIPS_BE_DISCARD:
		return;
	case MIPS_BE_FIXUP:
		if (fixup) {
			regs->cp0_epc = fixup->nextinsn;
			return;
		}
		break;
	default:
		break;
	}

	/*
	 * Assume it would be too dangerous to continue ...
	 */
	printk(KERN_ALERT "%s bus error, epc == %0*lx, ra == %0*lx\n",
	       data ? "Data" : "Instruction",
	       field, regs->cp0_epc, field, regs->regs[31]);
	die_if_kernel("Oops", regs);
	force_sig(SIGBUS, current);
}

/*
 * ll/sc emulation
 */

#define OPCODE 0xfc000000
#define BASE   0x03e00000
#define RT     0x001f0000
#define OFFSET 0x0000ffff
#define LL     0xc0000000
#define SC     0xe0000000
R
Ralf Baechle 已提交
410 411 412 413
#define SPEC3  0x7c000000
#define RD     0x0000f800
#define FUNC   0x0000003f
#define RDHWR  0x0000003b
L
Linus Torvalds 已提交
414 415 416 417 418 419 420 421 422 423 424

/*
 * The ll_bit is cleared by r*_switch.S
 */

unsigned long ll_bit;

static struct task_struct *ll_task = NULL;

static inline void simulate_ll(struct pt_regs *regs, unsigned int opcode)
{
R
Ralf Baechle 已提交
425
	unsigned long value, __user *vaddr;
L
Linus Torvalds 已提交
426 427 428 429 430 431 432 433 434 435 436 437 438
	long offset;
	int signal = 0;

	/*
	 * analyse the ll instruction that just caused a ri exception
	 * and put the referenced address to addr.
	 */

	/* sign extend offset */
	offset = opcode & OFFSET;
	offset <<= 16;
	offset >>= 16;

R
Ralf Baechle 已提交
439 440
	vaddr = (unsigned long __user *)
	        ((unsigned long)(regs->regs[(opcode & BASE) >> 21]) + offset);
L
Linus Torvalds 已提交
441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461

	if ((unsigned long)vaddr & 3) {
		signal = SIGBUS;
		goto sig;
	}
	if (get_user(value, vaddr)) {
		signal = SIGSEGV;
		goto sig;
	}

	preempt_disable();

	if (ll_task == NULL || ll_task == current) {
		ll_bit = 1;
	} else {
		ll_bit = 0;
	}
	ll_task = current;

	preempt_enable();

462 463
	compute_return_epc(regs);

L
Linus Torvalds 已提交
464 465 466 467 468 469 470 471 472 473
	regs->regs[(opcode & RT) >> 16] = value;

	return;

sig:
	force_sig(signal, current);
}

static inline void simulate_sc(struct pt_regs *regs, unsigned int opcode)
{
R
Ralf Baechle 已提交
474 475
	unsigned long __user *vaddr;
	unsigned long reg;
L
Linus Torvalds 已提交
476 477 478 479 480 481 482 483 484 485 486 487 488
	long offset;
	int signal = 0;

	/*
	 * analyse the sc instruction that just caused a ri exception
	 * and put the referenced address to addr.
	 */

	/* sign extend offset */
	offset = opcode & OFFSET;
	offset <<= 16;
	offset >>= 16;

R
Ralf Baechle 已提交
489 490
	vaddr = (unsigned long __user *)
	        ((unsigned long)(regs->regs[(opcode & BASE) >> 21]) + offset);
L
Linus Torvalds 已提交
491 492 493 494 495 496 497 498 499 500
	reg = (opcode & RT) >> 16;

	if ((unsigned long)vaddr & 3) {
		signal = SIGBUS;
		goto sig;
	}

	preempt_disable();

	if (ll_bit == 0 || ll_task != current) {
501
		compute_return_epc(regs);
L
Linus Torvalds 已提交
502 503 504 505 506 507 508 509 510 511 512 513
		regs->regs[reg] = 0;
		preempt_enable();
		return;
	}

	preempt_enable();

	if (put_user(regs->regs[reg], vaddr)) {
		signal = SIGSEGV;
		goto sig;
	}

514
	compute_return_epc(regs);
L
Linus Torvalds 已提交
515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
	regs->regs[reg] = 1;

	return;

sig:
	force_sig(signal, current);
}

/*
 * ll uses the opcode of lwc0 and sc uses the opcode of swc0.  That is both
 * opcodes are supposed to result in coprocessor unusable exceptions if
 * executed on ll/sc-less processors.  That's the theory.  In practice a
 * few processors such as NEC's VR4100 throw reserved instruction exceptions
 * instead, so we're doing the emulation thing in both exception handlers.
 */
static inline int simulate_llsc(struct pt_regs *regs)
{
	unsigned int opcode;

534 535
	if (get_user(opcode, (unsigned int __user *) exception_epc(regs)))
		goto out_sigsegv;
L
Linus Torvalds 已提交
536 537 538 539 540 541 542 543 544 545 546

	if ((opcode & OPCODE) == LL) {
		simulate_ll(regs, opcode);
		return 0;
	}
	if ((opcode & OPCODE) == SC) {
		simulate_sc(regs, opcode);
		return 0;
	}

	return -EFAULT;			/* Strange things going on ... */
547 548 549 550

out_sigsegv:
	force_sig(SIGSEGV, current);
	return -EFAULT;
L
Linus Torvalds 已提交
551 552
}

R
Ralf Baechle 已提交
553 554 555 556 557 558 559
/*
 * Simulate trapping 'rdhwr' instructions to provide user accessible
 * registers not implemented in hardware.  The only current use of this
 * is the thread area pointer.
 */
static inline int simulate_rdhwr(struct pt_regs *regs)
{
A
Al Viro 已提交
560
	struct thread_info *ti = task_thread_info(current);
R
Ralf Baechle 已提交
561 562
	unsigned int opcode;

563 564
	if (get_user(opcode, (unsigned int __user *) exception_epc(regs)))
		goto out_sigsegv;
R
Ralf Baechle 已提交
565 566 567 568 569 570 571 572 573 574

	if (unlikely(compute_return_epc(regs)))
		return -EFAULT;

	if ((opcode & OPCODE) == SPEC3 && (opcode & FUNC) == RDHWR) {
		int rd = (opcode & RD) >> 11;
		int rt = (opcode & RT) >> 16;
		switch (rd) {
			case 29:
				regs->regs[rt] = ti->tp_value;
D
Daniel Jacobowitz 已提交
575
				return 0;
R
Ralf Baechle 已提交
576 577 578 579 580
			default:
				return -EFAULT;
		}
	}

D
Daniel Jacobowitz 已提交
581 582
	/* Not ours.  */
	return -EFAULT;
583 584 585 586

out_sigsegv:
	force_sig(SIGSEGV, current);
	return -EFAULT;
R
Ralf Baechle 已提交
587 588
}

L
Linus Torvalds 已提交
589 590 591 592
asmlinkage void do_ov(struct pt_regs *regs)
{
	siginfo_t info;

593 594
	die_if_kernel("Integer overflow", regs);

L
Linus Torvalds 已提交
595 596 597
	info.si_code = FPE_INTOVF;
	info.si_signo = SIGFPE;
	info.si_errno = 0;
R
Ralf Baechle 已提交
598
	info.si_addr = (void __user *) regs->cp0_epc;
L
Linus Torvalds 已提交
599 600 601 602 603 604 605 606
	force_sig_info(SIGFPE, &info, current);
}

/*
 * XXX Delayed fp exceptions when doing a lazy ctx switch XXX
 */
asmlinkage void do_fpe(struct pt_regs *regs, unsigned long fcr31)
{
607 608
	die_if_kernel("FP exception in kernel code", regs);

L
Linus Torvalds 已提交
609 610 611 612
	if (fcr31 & FPU_CSR_UNI_X) {
		int sig;

		/*
613
		 * Unimplemented operation exception.  If we've got the full
L
Linus Torvalds 已提交
614 615 616 617 618 619 620 621
		 * software emulator on-board, let's use it...
		 *
		 * Force FPU to dump state into task/thread context.  We're
		 * moving a lot of data here for what is probably a single
		 * instruction, but the alternative is to pre-decode the FP
		 * register operands before invoking the emulator, which seems
		 * a bit extreme for what should be an infrequent event.
		 */
622
		/* Ensure 'resume' not overwrite saved fp context again. */
623
		lose_fpu(1);
L
Linus Torvalds 已提交
624 625

		/* Run the emulator */
626
		sig = fpu_emulator_cop1Handler (regs, &current->thread.fpu, 1);
L
Linus Torvalds 已提交
627 628 629 630 631

		/*
		 * We can't allow the emulated instruction to leave any of
		 * the cause bit set in $fcr31.
		 */
632
		current->thread.fpu.fcr31 &= ~FPU_CSR_ALL_X;
L
Linus Torvalds 已提交
633 634

		/* Restore the hardware register state */
635
		own_fpu(1);	/* Using the FPU again.  */
L
Linus Torvalds 已提交
636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651

		/* If something went wrong, signal */
		if (sig)
			force_sig(sig, current);

		return;
	}

	force_sig(SIGFPE, current);
}

asmlinkage void do_bp(struct pt_regs *regs)
{
	unsigned int opcode, bcode;
	siginfo_t info;

652
	if (__get_user(opcode, (unsigned int __user *) exception_epc(regs)))
653
		goto out_sigsegv;
L
Linus Torvalds 已提交
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673

	/*
	 * There is the ancient bug in the MIPS assemblers that the break
	 * code starts left to bit 16 instead to bit 6 in the opcode.
	 * Gas is bug-compatible, but not always, grrr...
	 * We handle both cases with a simple heuristics.  --macro
	 */
	bcode = ((opcode >> 6) & ((1 << 20) - 1));
	if (bcode < (1 << 10))
		bcode <<= 10;

	/*
	 * (A short test says that IRIX 5.3 sends SIGTRAP for all break
	 * insns, even for break codes that indicate arithmetic failures.
	 * Weird ...)
	 * But should we continue the brokenness???  --macro
	 */
	switch (bcode) {
	case BRK_OVERFLOW << 10:
	case BRK_DIVZERO << 10:
674
		die_if_kernel("Break instruction in kernel code", regs);
L
Linus Torvalds 已提交
675 676 677 678 679 680
		if (bcode == (BRK_DIVZERO << 10))
			info.si_code = FPE_INTDIV;
		else
			info.si_code = FPE_INTOVF;
		info.si_signo = SIGFPE;
		info.si_errno = 0;
R
Ralf Baechle 已提交
681
		info.si_addr = (void __user *) regs->cp0_epc;
L
Linus Torvalds 已提交
682 683
		force_sig_info(SIGFPE, &info, current);
		break;
684 685 686
	case BRK_BUG:
		die("Kernel bug detected", regs);
		break;
L
Linus Torvalds 已提交
687
	default:
688
		die_if_kernel("Break instruction in kernel code", regs);
L
Linus Torvalds 已提交
689 690
		force_sig(SIGTRAP, current);
	}
691
	return;
692 693 694

out_sigsegv:
	force_sig(SIGSEGV, current);
L
Linus Torvalds 已提交
695 696 697 698 699 700 701
}

asmlinkage void do_tr(struct pt_regs *regs)
{
	unsigned int opcode, tcode = 0;
	siginfo_t info;

702
	if (__get_user(opcode, (unsigned int __user *) exception_epc(regs)))
703
		goto out_sigsegv;
L
Linus Torvalds 已提交
704 705 706 707 708 709 710 711 712 713 714 715 716 717

	/* Immediate versions don't provide a code.  */
	if (!(opcode & OPCODE))
		tcode = ((opcode >> 6) & ((1 << 10) - 1));

	/*
	 * (A short test says that IRIX 5.3 sends SIGTRAP for all trap
	 * insns, even for trap codes that indicate arithmetic failures.
	 * Weird ...)
	 * But should we continue the brokenness???  --macro
	 */
	switch (tcode) {
	case BRK_OVERFLOW:
	case BRK_DIVZERO:
718
		die_if_kernel("Trap instruction in kernel code", regs);
L
Linus Torvalds 已提交
719 720 721 722 723 724
		if (tcode == BRK_DIVZERO)
			info.si_code = FPE_INTDIV;
		else
			info.si_code = FPE_INTOVF;
		info.si_signo = SIGFPE;
		info.si_errno = 0;
R
Ralf Baechle 已提交
725
		info.si_addr = (void __user *) regs->cp0_epc;
L
Linus Torvalds 已提交
726 727
		force_sig_info(SIGFPE, &info, current);
		break;
728 729 730
	case BRK_BUG:
		die("Kernel bug detected", regs);
		break;
L
Linus Torvalds 已提交
731
	default:
732
		die_if_kernel("Trap instruction in kernel code", regs);
L
Linus Torvalds 已提交
733 734
		force_sig(SIGTRAP, current);
	}
735
	return;
736 737 738

out_sigsegv:
	force_sig(SIGSEGV, current);
L
Linus Torvalds 已提交
739 740 741 742 743 744 745 746 747 748
}

asmlinkage void do_ri(struct pt_regs *regs)
{
	die_if_kernel("Reserved instruction in kernel code", regs);

	if (!cpu_has_llsc)
		if (!simulate_llsc(regs))
			return;

R
Ralf Baechle 已提交
749 750 751
	if (!simulate_rdhwr(regs))
		return;

L
Linus Torvalds 已提交
752 753 754
	force_sig(SIGILL, current);
}

755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781
/*
 * MIPS MT processors may have fewer FPU contexts than CPU threads. If we've
 * emulated more than some threshold number of instructions, force migration to
 * a "CPU" that has FP support.
 */
static void mt_ase_fp_affinity(void)
{
#ifdef CONFIG_MIPS_MT_FPAFF
	if (mt_fpemul_threshold > 0 &&
	     ((current->thread.emulated_fp++ > mt_fpemul_threshold))) {
		/*
		 * If there's no FPU present, or if the application has already
		 * restricted the allowed set to exclude any CPUs with FPUs,
		 * we'll skip the procedure.
		 */
		if (cpus_intersects(current->cpus_allowed, mt_fpu_cpumask)) {
			cpumask_t tmask;

			cpus_and(tmask, current->thread.user_cpus_allowed,
			         mt_fpu_cpumask);
			set_cpus_allowed(current, tmask);
			current->thread.mflags |= MF_FPUBOUND;
		}
	}
#endif /* CONFIG_MIPS_MT_FPAFF */
}

L
Linus Torvalds 已提交
782 783 784 785
asmlinkage void do_cpu(struct pt_regs *regs)
{
	unsigned int cpid;

786 787
	die_if_kernel("do_cpu invoked from kernel context!", regs);

L
Linus Torvalds 已提交
788 789 790 791
	cpid = (regs->cp0_cause >> CAUSEB_CE) & 3;

	switch (cpid) {
	case 0:
R
Ralf Baechle 已提交
792 793 794
		if (!cpu_has_llsc)
			if (!simulate_llsc(regs))
				return;
L
Linus Torvalds 已提交
795

R
Ralf Baechle 已提交
796
		if (!simulate_rdhwr(regs))
L
Linus Torvalds 已提交
797
			return;
R
Ralf Baechle 已提交
798

L
Linus Torvalds 已提交
799 800 801
		break;

	case 1:
802 803 804
		if (used_math())	/* Using the FPU again.  */
			own_fpu(1);
		else {			/* First time FPU user.  */
L
Linus Torvalds 已提交
805 806 807 808
			init_fpu();
			set_used_math();
		}

809
		if (!raw_cpu_has_fpu) {
810 811 812
			int sig;
			sig = fpu_emulator_cop1Handler(regs,
						&current->thread.fpu, 0);
L
Linus Torvalds 已提交
813 814
			if (sig)
				force_sig(sig, current);
815 816
			else
				mt_ase_fp_affinity();
L
Linus Torvalds 已提交
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
		}

		return;

	case 2:
	case 3:
		break;
	}

	force_sig(SIGILL, current);
}

asmlinkage void do_mdmx(struct pt_regs *regs)
{
	force_sig(SIGILL, current);
}

asmlinkage void do_watch(struct pt_regs *regs)
{
	/*
	 * We use the watch exception where available to detect stack
	 * overflows.
	 */
	dump_tlb_all();
	show_regs(regs);
	panic("Caught WATCH exception - probably caused by stack overflow.");
}

asmlinkage void do_mcheck(struct pt_regs *regs)
{
847 848 849
	const int field = 2 * sizeof(unsigned long);
	int multi_match = regs->cp0_status & ST0_TS;

L
Linus Torvalds 已提交
850
	show_regs(regs);
851 852 853 854 855 856 857 858 859 860 861 862 863

	if (multi_match) {
		printk("Index   : %0x\n", read_c0_index());
		printk("Pagemask: %0x\n", read_c0_pagemask());
		printk("EntryHi : %0*lx\n", field, read_c0_entryhi());
		printk("EntryLo0: %0*lx\n", field, read_c0_entrylo0());
		printk("EntryLo1: %0*lx\n", field, read_c0_entrylo1());
		printk("\n");
		dump_tlb_all();
	}

	show_code((unsigned int *) regs->cp0_epc);

L
Linus Torvalds 已提交
864 865 866 867 868 869
	/*
	 * Some chips may have other causes of machine check (e.g. SB1
	 * graduation timer)
	 */
	panic("Caught Machine Check exception - %scaused by multiple "
	      "matching entries in the TLB.",
870
	      (multi_match) ? "" : "not ");
L
Linus Torvalds 已提交
871 872
}

R
Ralf Baechle 已提交
873 874
asmlinkage void do_mt(struct pt_regs *regs)
{
875 876 877 878 879 880
	int subcode;

	subcode = (read_vpe_c0_vpecontrol() & VPECONTROL_EXCPT)
			>> VPECONTROL_EXCPT_SHIFT;
	switch (subcode) {
	case 0:
881
		printk(KERN_DEBUG "Thread Underflow\n");
882 883
		break;
	case 1:
884
		printk(KERN_DEBUG "Thread Overflow\n");
885 886
		break;
	case 2:
887
		printk(KERN_DEBUG "Invalid YIELD Qualifier\n");
888 889
		break;
	case 3:
890
		printk(KERN_DEBUG "Gating Storage Exception\n");
891 892
		break;
	case 4:
893
		printk(KERN_DEBUG "YIELD Scheduler Exception\n");
894 895
		break;
	case 5:
896
		printk(KERN_DEBUG "Gating Storage Schedulier Exception\n");
897 898
		break;
	default:
899
		printk(KERN_DEBUG "*** UNKNOWN THREAD EXCEPTION %d ***\n",
900 901 902
			subcode);
		break;
	}
R
Ralf Baechle 已提交
903 904 905 906 907 908
	die_if_kernel("MIPS MT Thread exception in kernel", regs);

	force_sig(SIGILL, current);
}


909 910 911 912 913 914 915 916
asmlinkage void do_dsp(struct pt_regs *regs)
{
	if (cpu_has_dsp)
		panic("Unexpected DSP exception\n");

	force_sig(SIGILL, current);
}

L
Linus Torvalds 已提交
917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936
asmlinkage void do_reserved(struct pt_regs *regs)
{
	/*
	 * Game over - no way to handle this if it ever occurs.  Most probably
	 * caused by a new unknown cpu type or after another deadly
	 * hard/software error.
	 */
	show_regs(regs);
	panic("Caught reserved exception %ld - should not happen.",
	      (regs->cp0_cause & 0x7f) >> 2);
}

/*
 * Some MIPS CPUs can enable/disable for cache parity detection, but do
 * it different ways.
 */
static inline void parity_protection_init(void)
{
	switch (current_cpu_data.cputype) {
	case CPU_24K:
937
	case CPU_34K:
L
Linus Torvalds 已提交
938
	case CPU_5KC:
939 940 941 942 943
		write_c0_ecc(0x80000000);
		back_to_back_c0_hazard();
		/* Set the PE bit (bit 31) in the c0_errctl register. */
		printk(KERN_INFO "Cache parity protection %sabled\n",
		       (read_c0_ecc() & 0x80000000) ? "en" : "dis");
L
Linus Torvalds 已提交
944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980
		break;
	case CPU_20KC:
	case CPU_25KF:
		/* Clear the DE bit (bit 16) in the c0_status register. */
		printk(KERN_INFO "Enable cache parity protection for "
		       "MIPS 20KC/25KF CPUs.\n");
		clear_c0_status(ST0_DE);
		break;
	default:
		break;
	}
}

asmlinkage void cache_parity_error(void)
{
	const int field = 2 * sizeof(unsigned long);
	unsigned int reg_val;

	/* For the moment, report the problem and hang. */
	printk("Cache error exception:\n");
	printk("cp0_errorepc == %0*lx\n", field, read_c0_errorepc());
	reg_val = read_c0_cacheerr();
	printk("c0_cacheerr == %08x\n", reg_val);

	printk("Decoded c0_cacheerr: %s cache fault in %s reference.\n",
	       reg_val & (1<<30) ? "secondary" : "primary",
	       reg_val & (1<<31) ? "data" : "insn");
	printk("Error bits: %s%s%s%s%s%s%s\n",
	       reg_val & (1<<29) ? "ED " : "",
	       reg_val & (1<<28) ? "ET " : "",
	       reg_val & (1<<26) ? "EE " : "",
	       reg_val & (1<<25) ? "EB " : "",
	       reg_val & (1<<24) ? "EI " : "",
	       reg_val & (1<<23) ? "E1 " : "",
	       reg_val & (1<<22) ? "E0 " : "");
	printk("IDX: 0x%08x\n", reg_val & ((1<<22)-1));

981
#if defined(CONFIG_CPU_MIPS32) || defined(CONFIG_CPU_MIPS64)
L
Linus Torvalds 已提交
982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
	if (reg_val & (1<<22))
		printk("DErrAddr0: 0x%0*lx\n", field, read_c0_derraddr0());

	if (reg_val & (1<<23))
		printk("DErrAddr1: 0x%0*lx\n", field, read_c0_derraddr1());
#endif

	panic("Can't handle the cache error!");
}

/*
 * SDBBP EJTAG debug exception handler.
 * We skip the instruction and return to the next instruction.
 */
void ejtag_exception_handler(struct pt_regs *regs)
{
	const int field = 2 * sizeof(unsigned long);
	unsigned long depc, old_epc;
	unsigned int debug;

1002
	printk(KERN_DEBUG "SDBBP EJTAG debug exception - not handled yet, just ignored!\n");
L
Linus Torvalds 已提交
1003 1004
	depc = read_c0_depc();
	debug = read_c0_debug();
1005
	printk(KERN_DEBUG "c0_depc = %0*lx, DEBUG = %08x\n", field, depc, debug);
L
Linus Torvalds 已提交
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
	if (debug & 0x80000000) {
		/*
		 * In branch delay slot.
		 * We cheat a little bit here and use EPC to calculate the
		 * debug return address (DEPC). EPC is restored after the
		 * calculation.
		 */
		old_epc = regs->cp0_epc;
		regs->cp0_epc = depc;
		__compute_return_epc(regs);
		depc = regs->cp0_epc;
		regs->cp0_epc = old_epc;
	} else
		depc += 4;
	write_c0_depc(depc);

#if 0
1023
	printk(KERN_DEBUG "\n\n----- Enable EJTAG single stepping ----\n\n");
L
Linus Torvalds 已提交
1024 1025 1026 1027 1028 1029 1030 1031 1032
	write_c0_debug(debug | 0x100);
#endif
}

/*
 * NMI exception handler.
 */
void nmi_exception_handler(struct pt_regs *regs)
{
1033 1034 1035 1036 1037 1038 1039
#ifdef CONFIG_MIPS_MT_SMTC
	unsigned long dvpret = dvpe();
	bust_spinlocks(1);
	printk("NMI taken!!!!\n");
	mips_mt_regdump(dvpret);
#else
	bust_spinlocks(1);
L
Linus Torvalds 已提交
1040
	printk("NMI taken!!!!\n");
1041
#endif /* CONFIG_MIPS_MT_SMTC */
L
Linus Torvalds 已提交
1042 1043 1044 1045
	die("NMI", regs);
	while(1) ;
}

1046 1047 1048
#define VECTORSPACING 0x100	/* for EI/VI mode */

unsigned long ebase;
L
Linus Torvalds 已提交
1049
unsigned long exception_handlers[32];
1050
unsigned long vi_handlers[64];
L
Linus Torvalds 已提交
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063

/*
 * As a side effect of the way this is implemented we're limited
 * to interrupt handlers in the address range from
 * KSEG0 <= x < KSEG0 + 256mb on the Nevada.  Oh well ...
 */
void *set_except_vector(int n, void *addr)
{
	unsigned long handler = (unsigned long) addr;
	unsigned long old_handler = exception_handlers[n];

	exception_handlers[n] = handler;
	if (n == 0 && cpu_has_divec) {
1064
		*(volatile u32 *)(ebase + 0x200) = 0x08000000 |
L
Linus Torvalds 已提交
1065
		                                 (0x03ffffff & (handler >> 2));
1066 1067 1068 1069 1070
		flush_icache_range(ebase + 0x200, ebase + 0x204);
	}
	return (void *)old_handler;
}

1071
#ifdef CONFIG_CPU_MIPSR2_SRS
1072
/*
1073
 * MIPSR2 shadow register set allocation
1074 1075 1076
 * FIXME: SMP...
 */

1077 1078 1079 1080 1081 1082 1083 1084 1085
static struct shadow_registers {
	/*
	 * Number of shadow register sets supported
	 */
	unsigned long sr_supported;
	/*
	 * Bitmap of allocated shadow registers
	 */
	unsigned long sr_allocated;
1086 1087
} shadow_registers;

R
Ralf Baechle 已提交
1088
static void mips_srs_init(void)
1089 1090
{
	shadow_registers.sr_supported = ((read_c0_srsctl() >> 26) & 0x0f) + 1;
1091
	printk(KERN_INFO "%ld MIPSR2 register sets available\n",
1092
	       shadow_registers.sr_supported);
1093 1094 1095 1096 1097 1098 1099 1100
	shadow_registers.sr_allocated = 1;	/* Set 0 used by kernel */
}

int mips_srs_max(void)
{
	return shadow_registers.sr_supported;
}

R
Ralf Baechle 已提交
1101
int mips_srs_alloc(void)
1102 1103 1104 1105
{
	struct shadow_registers *sr = &shadow_registers;
	int set;

1106 1107 1108 1109
again:
	set = find_first_zero_bit(&sr->sr_allocated, sr->sr_supported);
	if (set >= sr->sr_supported)
		return -1;
1110

1111 1112
	if (test_and_set_bit(set, &sr->sr_allocated))
		goto again;
1113

1114
	return set;
1115 1116
}

1117
void mips_srs_free(int set)
1118 1119 1120
{
	struct shadow_registers *sr = &shadow_registers;

1121
	clear_bit(set, &sr->sr_allocated);
1122 1123
}

1124 1125 1126 1127 1128 1129
static asmlinkage void do_default_vi(void)
{
	show_regs(get_irq_regs());
	panic("Caught unexpected vectored interrupt.");
}

1130
static void *set_vi_srs_handler(int n, vi_handler_t addr, int srs)
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
{
	unsigned long handler;
	unsigned long old_handler = vi_handlers[n];
	u32 *w;
	unsigned char *b;

	if (!cpu_has_veic && !cpu_has_vint)
		BUG();

	if (addr == NULL) {
		handler = (unsigned long) do_default_vi;
		srs = 0;
1143
	} else
1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154
		handler = (unsigned long) addr;
	vi_handlers[n] = (unsigned long) addr;

	b = (unsigned char *)(ebase + 0x200 + n*VECTORSPACING);

	if (srs >= mips_srs_max())
		panic("Shadow register set %d not supported", srs);

	if (cpu_has_veic) {
		if (board_bind_eic_interrupt)
			board_bind_eic_interrupt (n, srs);
1155
	} else if (cpu_has_vint) {
1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168
		/* SRSMap is only defined if shadow sets are implemented */
		if (mips_srs_max() > 1)
			change_c0_srsmap (0xf << n*4, srs << n*4);
	}

	if (srs == 0) {
		/*
		 * If no shadow set is selected then use the default handler
		 * that does normal register saving and a standard interrupt exit
		 */

		extern char except_vec_vi, except_vec_vi_lui;
		extern char except_vec_vi_ori, except_vec_vi_end;
1169 1170 1171 1172 1173 1174 1175 1176 1177
#ifdef CONFIG_MIPS_MT_SMTC
		/*
		 * We need to provide the SMTC vectored interrupt handler
		 * not only with the address of the handler, but with the
		 * Status.IM bit to be masked before going there.
		 */
		extern char except_vec_vi_mori;
		const int mori_offset = &except_vec_vi_mori - &except_vec_vi;
#endif /* CONFIG_MIPS_MT_SMTC */
1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
		const int handler_len = &except_vec_vi_end - &except_vec_vi;
		const int lui_offset = &except_vec_vi_lui - &except_vec_vi;
		const int ori_offset = &except_vec_vi_ori - &except_vec_vi;

		if (handler_len > VECTORSPACING) {
			/*
			 * Sigh... panicing won't help as the console
			 * is probably not configured :(
			 */
			panic ("VECTORSPACING too small");
		}

		memcpy (b, &except_vec_vi, handler_len);
1191
#ifdef CONFIG_MIPS_MT_SMTC
1192 1193
		BUG_ON(n > 7);	/* Vector index %d exceeds SMTC maximum. */

1194 1195 1196
		w = (u32 *)(b + mori_offset);
		*w = (*w & 0xffff0000) | (0x100 << n);
#endif /* CONFIG_MIPS_MT_SMTC */
1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
		w = (u32 *)(b + lui_offset);
		*w = (*w & 0xffff0000) | (((u32)handler >> 16) & 0xffff);
		w = (u32 *)(b + ori_offset);
		*w = (*w & 0xffff0000) | ((u32)handler & 0xffff);
		flush_icache_range((unsigned long)b, (unsigned long)(b+handler_len));
	}
	else {
		/*
		 * In other cases jump directly to the interrupt handler
		 *
		 * It is the handlers responsibility to save registers if required
		 * (eg hi/lo) and return from the exception using "eret"
		 */
		w = (u32 *)b;
		*w++ = 0x08000000 | (((u32)handler >> 2) & 0x03fffff); /* j handler */
		*w = 0;
		flush_icache_range((unsigned long)b, (unsigned long)(b+8));
L
Linus Torvalds 已提交
1214
	}
1215

L
Linus Torvalds 已提交
1216 1217 1218
	return (void *)old_handler;
}

1219
void *set_vi_handler(int n, vi_handler_t addr)
1220
{
R
Ralf Baechle 已提交
1221
	return set_vi_srs_handler(n, addr, 0);
1222
}
1223 1224 1225 1226 1227 1228 1229 1230

#else

static inline void mips_srs_init(void)
{
}

#endif /* CONFIG_CPU_MIPSR2_SRS */
1231

L
Linus Torvalds 已提交
1232 1233 1234
/*
 * This is used by native signal handling
 */
1235 1236
asmlinkage int (*save_fp_context)(struct sigcontext __user *sc);
asmlinkage int (*restore_fp_context)(struct sigcontext __user *sc);
L
Linus Torvalds 已提交
1237

1238 1239
extern asmlinkage int _save_fp_context(struct sigcontext __user *sc);
extern asmlinkage int _restore_fp_context(struct sigcontext __user *sc);
L
Linus Torvalds 已提交
1240

1241 1242
extern asmlinkage int fpu_emulator_save_context(struct sigcontext __user *sc);
extern asmlinkage int fpu_emulator_restore_context(struct sigcontext __user *sc);
L
Linus Torvalds 已提交
1243

1244
#ifdef CONFIG_SMP
1245
static int smp_save_fp_context(struct sigcontext __user *sc)
1246
{
1247
	return raw_cpu_has_fpu
1248 1249 1250 1251
	       ? _save_fp_context(sc)
	       : fpu_emulator_save_context(sc);
}

1252
static int smp_restore_fp_context(struct sigcontext __user *sc)
1253
{
1254
	return raw_cpu_has_fpu
1255 1256 1257 1258 1259
	       ? _restore_fp_context(sc)
	       : fpu_emulator_restore_context(sc);
}
#endif

L
Linus Torvalds 已提交
1260 1261
static inline void signal_init(void)
{
1262 1263 1264 1265 1266
#ifdef CONFIG_SMP
	/* For now just do the cpu_has_fpu check when the functions are invoked */
	save_fp_context = smp_save_fp_context;
	restore_fp_context = smp_restore_fp_context;
#else
L
Linus Torvalds 已提交
1267 1268 1269 1270 1271 1272 1273
	if (cpu_has_fpu) {
		save_fp_context = _save_fp_context;
		restore_fp_context = _restore_fp_context;
	} else {
		save_fp_context = fpu_emulator_save_context;
		restore_fp_context = fpu_emulator_restore_context;
	}
1274
#endif
L
Linus Torvalds 已提交
1275 1276 1277 1278 1279 1280 1281
}

#ifdef CONFIG_MIPS32_COMPAT

/*
 * This is used by 32-bit signal stuff on the 64-bit kernel
 */
1282 1283
asmlinkage int (*save_fp_context32)(struct sigcontext32 __user *sc);
asmlinkage int (*restore_fp_context32)(struct sigcontext32 __user *sc);
L
Linus Torvalds 已提交
1284

1285 1286
extern asmlinkage int _save_fp_context32(struct sigcontext32 __user *sc);
extern asmlinkage int _restore_fp_context32(struct sigcontext32 __user *sc);
L
Linus Torvalds 已提交
1287

1288 1289
extern asmlinkage int fpu_emulator_save_context32(struct sigcontext32 __user *sc);
extern asmlinkage int fpu_emulator_restore_context32(struct sigcontext32 __user *sc);
L
Linus Torvalds 已提交
1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304

static inline void signal32_init(void)
{
	if (cpu_has_fpu) {
		save_fp_context32 = _save_fp_context32;
		restore_fp_context32 = _restore_fp_context32;
	} else {
		save_fp_context32 = fpu_emulator_save_context32;
		restore_fp_context32 = fpu_emulator_restore_context32;
	}
}
#endif

extern void cpu_cache_init(void);
extern void tlb_init(void);
1305
extern void flush_tlb_handlers(void);
L
Linus Torvalds 已提交
1306 1307 1308 1309 1310

void __init per_cpu_trap_init(void)
{
	unsigned int cpu = smp_processor_id();
	unsigned int status_set = ST0_CU0;
1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324
#ifdef CONFIG_MIPS_MT_SMTC
	int secondaryTC = 0;
	int bootTC = (cpu == 0);

	/*
	 * Only do per_cpu_trap_init() for first TC of Each VPE.
	 * Note that this hack assumes that the SMTC init code
	 * assigns TCs consecutively and in ascending order.
	 */

	if (((read_c0_tcbind() & TCBIND_CURTC) != 0) &&
	    ((read_c0_tcbind() & TCBIND_CURVPE) == cpu_data[cpu - 1].vpe_id))
		secondaryTC = 1;
#endif /* CONFIG_MIPS_MT_SMTC */
L
Linus Torvalds 已提交
1325 1326 1327 1328 1329 1330 1331

	/*
	 * Disable coprocessors and select 32-bit or 64-bit addressing
	 * and the 16/32 or 32/32 FPR register model.  Reset the BEV
	 * flag that some firmware may have left set and the TS bit (for
	 * IP27).  Set XX for ISA IV code to work.
	 */
1332
#ifdef CONFIG_64BIT
L
Linus Torvalds 已提交
1333 1334 1335 1336
	status_set |= ST0_FR|ST0_KX|ST0_SX|ST0_UX;
#endif
	if (current_cpu_data.isa_level == MIPS_CPU_ISA_IV)
		status_set |= ST0_XX;
R
Ralf Baechle 已提交
1337
	change_c0_status(ST0_CU|ST0_MX|ST0_RE|ST0_FR|ST0_BEV|ST0_TS|ST0_KX|ST0_SX|ST0_UX,
L
Linus Torvalds 已提交
1338 1339
			 status_set);

1340 1341 1342
	if (cpu_has_dsp)
		set_c0_status(ST0_MX);

1343
#ifdef CONFIG_CPU_MIPSR2
1344 1345 1346 1347 1348 1349 1350 1351
	if (cpu_has_mips_r2) {
		unsigned int enable = 0x0000000f;

		if (cpu_has_userlocal)
			enable |= (1 << 29);

		write_c0_hwrena(enable);
	}
1352 1353
#endif

1354 1355 1356 1357
#ifdef CONFIG_MIPS_MT_SMTC
	if (!secondaryTC) {
#endif /* CONFIG_MIPS_MT_SMTC */

1358 1359 1360 1361 1362
	if (cpu_has_veic || cpu_has_vint) {
		write_c0_ebase (ebase);
		/* Setting vector spacing enables EI/VI mode  */
		change_c0_intctl (0x3e0, VECTORSPACING);
	}
R
Ralf Baechle 已提交
1363 1364 1365 1366 1367 1368 1369 1370
	if (cpu_has_divec) {
		if (cpu_has_mipsmt) {
			unsigned int vpflags = dvpe();
			set_c0_cause(CAUSEF_IV);
			evpe(vpflags);
		} else
			set_c0_cause(CAUSEF_IV);
	}
1371 1372 1373 1374 1375 1376 1377 1378 1379 1380

	/*
	 * Before R2 both interrupt numbers were fixed to 7, so on R2 only:
	 *
	 *  o read IntCtl.IPTI to determine the timer interrupt
	 *  o read IntCtl.IPPCI to determine the performance counter interrupt
	 */
	if (cpu_has_mips_r2) {
		cp0_compare_irq = (read_c0_intctl () >> 29) & 7;
		cp0_perfcount_irq = (read_c0_intctl () >> 26) & 7;
1381
		if (cp0_perfcount_irq == cp0_compare_irq)
1382
			cp0_perfcount_irq = -1;
1383 1384 1385
	} else {
		cp0_compare_irq = CP0_LEGACY_COMPARE_IRQ;
		cp0_perfcount_irq = -1;
1386 1387
	}

1388 1389 1390
#ifdef CONFIG_MIPS_MT_SMTC
	}
#endif /* CONFIG_MIPS_MT_SMTC */
L
Linus Torvalds 已提交
1391 1392 1393 1394 1395 1396 1397 1398 1399

	cpu_data[cpu].asid_cache = ASID_FIRST_VERSION;
	TLBMISS_HANDLER_SETUP();

	atomic_inc(&init_mm.mm_count);
	current->active_mm = &init_mm;
	BUG_ON(current->mm);
	enter_lazy_tlb(&init_mm, current);

1400 1401 1402 1403 1404 1405
#ifdef CONFIG_MIPS_MT_SMTC
	if (bootTC) {
#endif /* CONFIG_MIPS_MT_SMTC */
		cpu_cache_init();
		tlb_init();
#ifdef CONFIG_MIPS_MT_SMTC
1406 1407 1408 1409 1410 1411 1412
	} else if (!secondaryTC) {
		/*
		 * First TC in non-boot VPE must do subset of tlb_init()
		 * for MMU countrol registers.
		 */
		write_c0_pagemask(PM_DEFAULT_MASK);
		write_c0_wired(0);
1413 1414
	}
#endif /* CONFIG_MIPS_MT_SMTC */
L
Linus Torvalds 已提交
1415 1416
}

1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
/* Install CPU exception handler */
void __init set_handler (unsigned long offset, void *addr, unsigned long size)
{
	memcpy((void *)(ebase + offset), addr, size);
	flush_icache_range(ebase + offset, ebase + offset + size);
}

/* Install uncached CPU exception handler */
void __init set_uncached_handler (unsigned long offset, void *addr, unsigned long size)
{
#ifdef CONFIG_32BIT
	unsigned long uncached_ebase = KSEG1ADDR(ebase);
#endif
#ifdef CONFIG_64BIT
	unsigned long uncached_ebase = TO_UNCAC(ebase);
#endif

	memcpy((void *)(uncached_ebase + offset), addr, size);
}

1437 1438 1439 1440 1441 1442 1443 1444 1445
static int __initdata rdhwr_noopt;
static int __init set_rdhwr_noopt(char *str)
{
	rdhwr_noopt = 1;
	return 1;
}

__setup("rdhwr_noopt", set_rdhwr_noopt);

L
Linus Torvalds 已提交
1446 1447 1448 1449 1450 1451
void __init trap_init(void)
{
	extern char except_vec3_generic, except_vec3_r4000;
	extern char except_vec4;
	unsigned long i;

1452 1453 1454 1455 1456 1457 1458
	if (cpu_has_veic || cpu_has_vint)
		ebase = (unsigned long) alloc_bootmem_low_pages (0x200 + VECTORSPACING*64);
	else
		ebase = CAC_BASE;

	mips_srs_init();

L
Linus Torvalds 已提交
1459 1460 1461 1462 1463 1464 1465
	per_cpu_trap_init();

	/*
	 * Copy the generic exception handlers to their final destination.
	 * This will be overriden later as suitable for a particular
	 * configuration.
	 */
1466
	set_handler(0x180, &except_vec3_generic, 0x80);
L
Linus Torvalds 已提交
1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477

	/*
	 * Setup default vectors
	 */
	for (i = 0; i <= 31; i++)
		set_except_vector(i, handle_reserved);

	/*
	 * Copy the EJTAG debug exception vector handler code to it's final
	 * destination.
	 */
1478 1479
	if (cpu_has_ejtag && board_ejtag_handler_setup)
		board_ejtag_handler_setup ();
L
Linus Torvalds 已提交
1480 1481 1482 1483 1484 1485 1486 1487

	/*
	 * Only some CPUs have the watch exceptions.
	 */
	if (cpu_has_watch)
		set_except_vector(23, handle_watch);

	/*
1488
	 * Initialise interrupt handlers
L
Linus Torvalds 已提交
1489
	 */
1490 1491 1492
	if (cpu_has_veic || cpu_has_vint) {
		int nvec = cpu_has_veic ? 64 : 8;
		for (i = 0; i < nvec; i++)
R
Ralf Baechle 已提交
1493
			set_vi_handler(i, NULL);
1494 1495 1496
	}
	else if (cpu_has_divec)
		set_handler(0x200, &except_vec4, 0x8);
L
Linus Torvalds 已提交
1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511

	/*
	 * Some CPUs can enable/disable for cache parity detection, but does
	 * it different ways.
	 */
	parity_protection_init();

	/*
	 * The Data Bus Errors / Instruction Bus Errors are signaled
	 * by external hardware.  Therefore these two exceptions
	 * may have board specific handlers.
	 */
	if (board_be_init)
		board_be_init();

1512
	set_except_vector(0, handle_int);
L
Linus Torvalds 已提交
1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524
	set_except_vector(1, handle_tlbm);
	set_except_vector(2, handle_tlbl);
	set_except_vector(3, handle_tlbs);

	set_except_vector(4, handle_adel);
	set_except_vector(5, handle_ades);

	set_except_vector(6, handle_ibe);
	set_except_vector(7, handle_dbe);

	set_except_vector(8, handle_sys);
	set_except_vector(9, handle_bp);
1525 1526 1527
	set_except_vector(10, rdhwr_noopt ? handle_ri :
			  (cpu_has_vtag_icache ?
			   handle_ri_rdhwr_vivt : handle_ri_rdhwr));
L
Linus Torvalds 已提交
1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545
	set_except_vector(11, handle_cpu);
	set_except_vector(12, handle_ov);
	set_except_vector(13, handle_tr);

	if (current_cpu_data.cputype == CPU_R6000 ||
	    current_cpu_data.cputype == CPU_R6000A) {
		/*
		 * The R6000 is the only R-series CPU that features a machine
		 * check exception (similar to the R4000 cache error) and
		 * unaligned ldc1/sdc1 exception.  The handlers have not been
		 * written yet.  Well, anyway there is no R6000 machine on the
		 * current list of targets for Linux/MIPS.
		 * (Duh, crap, there is someone with a triple R6k machine)
		 */
		//set_except_vector(14, handle_mc);
		//set_except_vector(15, handle_ndc);
	}

1546 1547 1548 1549

	if (board_nmi_handler_setup)
		board_nmi_handler_setup();

1550 1551 1552 1553 1554 1555 1556 1557
	if (cpu_has_fpu && !cpu_has_nofpuex)
		set_except_vector(15, handle_fpe);

	set_except_vector(22, handle_mdmx);

	if (cpu_has_mcheck)
		set_except_vector(24, handle_mcheck);

R
Ralf Baechle 已提交
1558 1559 1560
	if (cpu_has_mipsmt)
		set_except_vector(25, handle_mt);

1561
	set_except_vector(26, handle_dsp);
1562 1563 1564 1565 1566 1567 1568 1569 1570

	if (cpu_has_vce)
		/* Special exception: R4[04]00 uses also the divec space. */
		memcpy((void *)(CAC_BASE + 0x180), &except_vec3_r4000, 0x100);
	else if (cpu_has_4kex)
		memcpy((void *)(CAC_BASE + 0x180), &except_vec3_generic, 0x80);
	else
		memcpy((void *)(CAC_BASE + 0x080), &except_vec3_generic, 0x80);

L
Linus Torvalds 已提交
1571 1572 1573 1574 1575
	signal_init();
#ifdef CONFIG_MIPS32_COMPAT
	signal32_init();
#endif

1576
	flush_icache_range(ebase, ebase + 0x400);
1577
	flush_tlb_handlers();
L
Linus Torvalds 已提交
1578
}