Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 226eb1ef authored by Robin Getz's avatar Robin Getz Committed by Bryan Wu
Browse files

Blackfin arch: cleanup arch/blackfin/kernel/traps.c handling code. 



 - move the CONFIG_KGDB into one block, for easier reading
 - remove printk from printk_address, and pass around buffers. Also
   print out the labels when decoding CPLB errors, so you know exactly
   where the error was.
 - Do not use fixed addresses, becuase people do not know where they come from.
 - Turn the printing level down on the dump, so if you don't want,
   only the signal prints out - just like on other archs. If a kernel/interrupt
   crashes, it should dump everything all the time

Signed-off-by: default avatarRobin Getz <robin.getz@analog.com>
Signed-off-by: default avatarBryan Wu <bryan.wu@analog.com>
parent a15c2dcf

arch/blackfin/kernel/traps.c

+179 −139
Original line number Diff line number Diff line
@@ -37,10 +37,24 @@ 
#include <asm/blackfin.h>

#include <asm/irq_handler.h>

#include <asm/trace.h>

#include <asm/fixed_code.h>



#ifdef CONFIG_KGDB

# include <linux/debugger.h>

# include <linux/kgdb.h>



# define CHK_DEBUGGER_TRAP() \

	do { \

		CHK_DEBUGGER(trapnr, sig, info.si_code, fp, ); \

	} while (0)

# define CHK_DEBUGGER_TRAP_MAYBE() \

	do { \

		if (kgdb_connected) \

			CHK_DEBUGGER_TRAP(); \

	} while (0)

#else

# define CHK_DEBUGGER_TRAP() do { } while (0)

# define CHK_DEBUGGER_TRAP_MAYBE() do { } while (0)

#endif



/* Initiate the event table handler */
@@ -53,8 +67,7 @@ void __init trap_init(void) 


int kstack_depth_to_print = 48;



#ifdef CONFIG_DEBUG_BFIN_HWTRACE_ON

static void printk_address(unsigned long address)

static void decode_address(char *buf, unsigned long address)

{

	struct vm_list_struct *vml;

	struct task_struct *p;
@@ -76,7 +89,7 @@ static void printk_address(unsigned long address) 
		/* yeah! kernel space! */

		if (!modname)

			modname = delim = "";

		printk("<0x%p> { %s%s%s%s + 0x%lx }",

		sprintf(buf, "<0x%p> { %s%s%s%s + 0x%lx }",

		              (void *)address, delim, modname, delim, symname,

		              (unsigned long)offset);

		return;
@@ -84,6 +97,18 @@ static void printk_address(unsigned long address) 
	}

#endif



	/* Problem in fixed code section? */

	if (address >= FIXED_CODE_START && address < FIXED_CODE_END) {

		sprintf(buf, "<0x%p> /* Maybe fixed code section */", (void *)address);

		return;

	}



	/* Problem somewhere before the kernel start address */

	if (address < CONFIG_BOOT_LOAD) {

		sprintf(buf, "<0x%p> /* Maybe null pointer? */", (void *)address);

		return;

	}



	/* looks like we're off in user-land, so let's walk all the

	 * mappings of all our processes and see if we can't be a whee

	 * bit more specific
@@ -119,7 +144,7 @@ static void printk_address(unsigned long address) 
				else

					offset = (address - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);



				printk("<0x%p> [ %s + 0x%lx ]",

				sprintf(buf, "<0x%p> [ %s + 0x%lx ]",

					(void *)address, name, offset);

				if (!in_exception)

					mmput(mm);
@@ -133,15 +158,16 @@ static void printk_address(unsigned long address) 
	}



	/* we were unable to find this address anywhere */

	printk("[<0x%p>]", (void *)address);

	sprintf(buf, "[<0x%p>]", (void *)address);



done:

	write_unlock_irqrestore(&tasklist_lock, flags);

}

#endif



asmlinkage void double_fault_c(struct pt_regs *fp)

{

	console_verbose();

	oops_in_progress = 1;

	printk(KERN_EMERG "\n" KERN_EMERG "Double Fault\n");

	dump_bfin_regs(fp, (void *)fp->retx);

	panic("Double Fault - unrecoverable event\n");
@@ -157,22 +183,29 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	siginfo_t info;

	unsigned long trapnr = fp->seqstat & SEQSTAT_EXCAUSE;



	trace_buffer_save(j);



	/* Important - be very careful dereferncing pointers - will lead to

	 * double faults if the stack has become corrupt

	 */



	/* If the fault was caused by a kernel thread, or interrupt handler

	 * we will kernel panic, so the system reboots.

	 * If KGDB is enabled, don't set this for kernel breakpoints

	*/

	if ((bfin_read_IPEND() & 0xFFC0)

#ifdef CONFIG_KGDB

# define CHK_DEBUGGER_TRAP() \

	do { \

		CHK_DEBUGGER(trapnr, sig, info.si_code, fp, ); \

	} while (0)

# define CHK_DEBUGGER_TRAP_MAYBE() \

	do { \

		if (kgdb_connected) \

			CHK_DEBUGGER_TRAP(); \

	} while (0)

#else

# define CHK_DEBUGGER_TRAP() do { } while (0)

# define CHK_DEBUGGER_TRAP_MAYBE() do { } while (0)

		&& trapnr != VEC_EXCPT02

#endif



	trace_buffer_save(j);

	){

		console_verbose();

		oops_in_progress = 1;

	} else if (current) {

		if (current->mm == NULL) {

			console_verbose();

			oops_in_progress = 1;

		}

	}



	/* trap_c() will be called for exceptions. During exceptions

	 * processing, the pc value should be set with retx value.
@@ -217,7 +250,7 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	case VEC_EXCPT03:

		info.si_code = SEGV_STACKFLOW;

		sig = SIGSEGV;

		printk(KERN_EMERG EXC_0x03);

		printk(KERN_NOTICE EXC_0x03);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x04 - User Defined, Caught by default */
@@ -246,7 +279,7 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	case VEC_OVFLOW:

		info.si_code = TRAP_TRACEFLOW;

		sig = SIGTRAP;

		printk(KERN_EMERG EXC_0x11);

		printk(KERN_NOTICE EXC_0x11);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x12 - Reserved, Caught by default */
@@ -268,14 +301,14 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	case VEC_UNDEF_I:

		info.si_code = ILL_ILLOPC;

		sig = SIGILL;

		printk(KERN_EMERG EXC_0x21);

		printk(KERN_NOTICE EXC_0x21);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x22 - Illegal Instruction Combination, handled here */

	case VEC_ILGAL_I:

		info.si_code = ILL_ILLPARAOP;

		sig = SIGILL;

		printk(KERN_EMERG EXC_0x22);

		printk(KERN_NOTICE EXC_0x22);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x23 - Data CPLB Protection Violation,
@@ -283,21 +316,21 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	case VEC_CPLB_VL:

		info.si_code = ILL_CPLB_VI;

		sig = SIGILL;

		printk(KERN_EMERG EXC_0x23);

		printk(KERN_NOTICE EXC_0x23);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x24 - Data access misaligned, handled here */

	case VEC_MISALI_D:

		info.si_code = BUS_ADRALN;

		sig = SIGBUS;

		printk(KERN_EMERG EXC_0x24);

		printk(KERN_NOTICE EXC_0x24);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x25 - Unrecoverable Event, handled here */

	case VEC_UNCOV:

		info.si_code = ILL_ILLEXCPT;

		sig = SIGILL;

		printk(KERN_EMERG EXC_0x25);

		printk(KERN_NOTICE EXC_0x25);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x26 - Data CPLB Miss, normal case is handled in _cplb_hdr,
@@ -305,7 +338,7 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	case VEC_CPLB_M:

		info.si_code = BUS_ADRALN;

		sig = SIGBUS;

		printk(KERN_EMERG EXC_0x26);

		printk(KERN_NOTICE EXC_0x26);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x27 - Data CPLB Multiple Hits - Linux Trap Zero, handled here */
@@ -313,11 +346,10 @@ asmlinkage void trap_c(struct pt_regs *fp) 
		info.si_code = ILL_CPLB_MULHIT;

#ifdef CONFIG_DEBUG_HUNT_FOR_ZERO

		sig = SIGSEGV;

		printk(KERN_EMERG "\n"

			KERN_EMERG "NULL pointer access (probably)\n");

		printk(KERN_NOTICE "NULL pointer access (probably)\n");

#else

		sig = SIGILL;

		printk(KERN_EMERG EXC_0x27);

		printk(KERN_NOTICE EXC_0x27);

#endif

		CHK_DEBUGGER_TRAP();

		break;
@@ -337,7 +369,7 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	case VEC_ISTRU_VL:      /* ADSP-BF535 only (MH) */

		info.si_code = BUS_OPFETCH;

		sig = SIGBUS;

		printk(KERN_EMERG "BF535: VEC_ISTRU_VL\n");

		printk(KERN_NOTICE "BF535: VEC_ISTRU_VL\n");

		CHK_DEBUGGER_TRAP();

		break;

#else
@@ -347,7 +379,7 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	case VEC_MISALI_I:

		info.si_code = BUS_ADRALN;

		sig = SIGBUS;

		printk(KERN_EMERG EXC_0x2A);

		printk(KERN_NOTICE EXC_0x2A);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x2B - Instruction CPLB protection Violation,
@@ -355,14 +387,14 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	case VEC_CPLB_I_VL:

		info.si_code = ILL_CPLB_VI;

		sig = SIGILL;

		printk(KERN_EMERG EXC_0x2B);

		printk(KERN_NOTICE EXC_0x2B);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x2C - Instruction CPLB miss, handled in _cplb_hdr */

	case VEC_CPLB_I_M:

		info.si_code = ILL_CPLB_MISS;

		sig = SIGBUS;

		printk(KERN_EMERG EXC_0x2C);

		printk(KERN_NOTICE EXC_0x2C);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x2D - Instruction CPLB Multiple Hits, handled here */
@@ -370,10 +402,10 @@ asmlinkage void trap_c(struct pt_regs *fp) 
		info.si_code = ILL_CPLB_MULHIT;

#ifdef CONFIG_DEBUG_HUNT_FOR_ZERO

		sig = SIGSEGV;

		printk(KERN_EMERG "\n\nJump to address 0 - 0x0fff\n");

		printk(KERN_NOTICE "Jump to address 0 - 0x0fff\n");

#else

		sig = SIGILL;

		printk(KERN_EMERG EXC_0x2D);

		printk(KERN_NOTICE EXC_0x2D);

#endif

		CHK_DEBUGGER_TRAP();

		break;
@@ -381,7 +413,7 @@ asmlinkage void trap_c(struct pt_regs *fp) 
	case VEC_ILL_RES:

		info.si_code = ILL_PRVOPC;

		sig = SIGILL;

		printk(KERN_EMERG EXC_0x2E);

		printk(KERN_NOTICE EXC_0x2E);

		CHK_DEBUGGER_TRAP();

		break;

	/* 0x2F - Reserved, Caught by default */
@@ -410,38 +442,40 @@ asmlinkage void trap_c(struct pt_regs *fp) 
		break;

	}



	if (sig != 0 && sig != SIGTRAP) {

	BUG_ON(sig == 0);



	if (sig != SIGTRAP) {

		unsigned long stack;

		dump_bfin_regs(fp, (void *)fp->retx);



		/* Print out the trace buffer if it makes sense */

#ifndef CONFIG_DEBUG_BFIN_NO_KERN_HWTRACE

		if (trapnr == VEC_CPLB_I_M || trapnr == VEC_CPLB_M)

			printk(KERN_NOTICE "No trace since you do not have "

				"CONFIG_DEBUG_BFIN_NO_KERN_HWTRACE enabled\n"

				KERN_NOTICE "\n");

		else

#endif

			dump_bfin_trace_buffer();

		show_stack(current, &stack);

		if (current->mm == NULL)

		if (oops_in_progress) {

#ifndef CONFIG_ACCESS_CHECK

			printk(KERN_EMERG "Hey - dork - please turn on "

				"CONFIG_ACCESS_CHECK\n");

#endif

			panic("Kernel exception");

		}



		/* Ensure that bad return addresses don't end up in an infinite

		 * loop, due to speculative loads/reads

		 */

		fp->pc = SAFE_USER_INSTRUCTION;

	}

	info.si_signo = sig;

	info.si_errno = 0;

	info.si_addr = (void *)fp->pc;

	force_sig_info(sig, &info, current);



	/* if the address that we are about to return to is not valid, set it

	 * to a valid address, if we have a current application or panic

	 */

	if (!(fp->pc <= physical_mem_end

#if L1_CODE_LENGTH != 0

	    || (fp->pc >= L1_CODE_START &&

	        fp->pc <= (L1_CODE_START + L1_CODE_LENGTH))

#endif

	)) {

		if (current->mm) {

			fp->pc = current->mm->start_code;

		} else {

			printk(KERN_EMERG

				"I can't return to memory that doesn't exist"

				" - bad things happen\n");

			panic("Help - I've fallen and can't get up\n");

		}

	}



	trace_buffer_restore(j);

	return;

}
@@ -454,21 +488,21 @@ void dump_bfin_trace_buffer(void) 
{

#ifdef CONFIG_DEBUG_BFIN_HWTRACE_ON

	int tflags, i = 0;

	char buf[150];

#ifdef CONFIG_DEBUG_BFIN_HWTRACE_EXPAND

	int j, index;

#endif



	trace_buffer_save(tflags);



	printk(KERN_EMERG "Hardware Trace:\n");

	printk(KERN_NOTICE "Hardware Trace:\n");



	if (likely(bfin_read_TBUFSTAT() & TBUFCNT)) {

		for (; bfin_read_TBUFSTAT() & TBUFCNT; i++) {

			printk(KERN_EMERG "%4i Target : ", i);

			printk_address((unsigned long)bfin_read_TBUF());

			printk("\n" KERN_EMERG "     Source : ");

			printk_address((unsigned long)bfin_read_TBUF());

			printk("\n");

			decode_address(buf, (unsigned long)bfin_read_TBUF());

			printk(KERN_NOTICE "%4i Target : %s\n", i, buf);

			decode_address(buf, (unsigned long)bfin_read_TBUF());

			printk(KERN_NOTICE "     Source : %s\n", buf);

		}

	}
@@ -480,17 +514,16 @@ void dump_bfin_trace_buffer(void) 


	j = (1 << CONFIG_DEBUG_BFIN_HWTRACE_EXPAND_LEN) * 128;

	while (j) {

		printk(KERN_EMERG "%4i Target : ", i);

		printk_address(software_trace_buff[index]);

		decode_address(buf, software_trace_buff[index]);

		printk(KERN_NOTICE "%4i Target : %s\n", i, buf);

		index -= 1;

		if (index < 0 )

			index = EXPAND_LEN;

		printk("\n" KERN_EMERG "     Source : ");

		printk_address(software_trace_buff[index]);

		decode_address(buf, software_trace_buff[index]);

		printk(KERN_NOTICE "     Source : %s\n", buf);

		index -= 1;

		if (index < 0)

			index = EXPAND_LEN;

		printk("\n");

		j--;

		i++;

	}
@@ -505,10 +538,7 @@ static void show_trace(struct task_struct *tsk, unsigned long *sp) 
{

	unsigned long addr;



	printk("\nCall Trace:");

#ifdef CONFIG_KALLSYMS

	printk("\n");

#endif

	printk(KERN_NOTICE "\n" KERN_NOTICE "Call Trace:\n");



	while (!kstack_end(sp)) {

		addr = *sp++;
@@ -524,7 +554,7 @@ static void show_trace(struct task_struct *tsk, unsigned long *sp) 
			print_ip_sym(addr);

	}



	printk("\n");

	printk(KERN_NOTICE "\n");

}



void show_stack(struct task_struct *task, unsigned long *stack)
@@ -546,14 +576,15 @@ void show_stack(struct task_struct *task, unsigned long *stack) 
	addr = (unsigned long)stack;

	endstack = (unsigned long *)PAGE_ALIGN(addr);



	printk(KERN_EMERG "Stack from %08lx:", (unsigned long)stack);

	printk(KERN_NOTICE "Stack from %08lx:", (unsigned long)stack);

	for (i = 0; i < kstack_depth_to_print; i++) {

		if (stack + 1 > endstack)

			break;

		if (i % 8 == 0)

			printk("\n" KERN_EMERG "       ");

			printk("\n" KERN_NOTICE "       ");

		printk(" %08lx", *stack++);

	}

	printk("\n");



	show_trace(task, stack);

}
@@ -574,22 +605,17 @@ EXPORT_SYMBOL(dump_stack); 


void dump_bfin_regs(struct pt_regs *fp, void *retaddr)

{

	if (current->pid) {

		printk(KERN_EMERG "\n" KERN_EMERG "CURRENT PROCESS:\n"

			KERN_EMERG "\n");

		printk(KERN_EMERG "COMM=%s PID=%d\n",

	char buf [150];



	if (!oops_in_progress) {

		if (current->pid && current->mm) {

			printk(KERN_NOTICE "\n" KERN_NOTICE "CURRENT PROCESS:\n");

			printk(KERN_NOTICE "COMM=%s PID=%d\n",

				current->comm, current->pid);

	} else {

		printk

		    (KERN_EMERG "\n" KERN_EMERG

		     "No Valid pid - Either things are really messed up,"

		     " or you are in the kernel\n");

	}



	if (current->mm) {

		printk(KERN_EMERG "TEXT = 0x%p-0x%p  DATA = 0x%p-0x%p\n"

		       KERN_EMERG "BSS = 0x%p-0x%p   USER-STACK = 0x%p\n"

		       KERN_EMERG "\n",

			printk(KERN_NOTICE "TEXT = 0x%p-0x%p  DATA = 0x%p-0x%p\n"

				KERN_NOTICE "BSS = 0x%p-0x%p   USER-STACK = 0x%p\n"

				KERN_NOTICE "\n",

				(void *)current->mm->start_code,

				(void *)current->mm->end_code,

				(void *)current->mm->start_data,
@@ -597,10 +623,16 @@ void dump_bfin_regs(struct pt_regs *fp, void *retaddr) 
				(void *)current->mm->end_data,

				(void *)current->mm->brk,

				(void *)current->mm->start_stack);

		} else {

			printk (KERN_NOTICE "\n" KERN_NOTICE

			     "No Valid pid - Either things are really messed up,"

			     " or you are in the kernel\n");

		}

	} else {

		printk(KERN_NOTICE "Kernel or interrupt exception\n");

	}



	printk(KERN_EMERG "return address: [0x%p]; contents of:", retaddr);

	if (retaddr != 0 && retaddr <= (void *)physical_mem_end

	if (retaddr >= (void *)FIXED_CODE_START  && retaddr < (void *)physical_mem_end

#if L1_CODE_LENGTH != 0

	    /* FIXME: Copy the code out of L1 Instruction SRAM through dma

	       memcpy.  */
@@ -610,18 +642,20 @@ void dump_bfin_regs(struct pt_regs *fp, void *retaddr) 
	) {

		int i = ((unsigned int)retaddr & 0xFFFFFFF0) - 32;

		unsigned short x = 0;

		printk(KERN_NOTICE "return address: [0x%p]; contents of:", retaddr);

		for (; i < ((unsigned int)retaddr & 0xFFFFFFF0) + 32; i += 2) {

			if (!(i & 0xF))

				printk("\n" KERN_EMERG "0x%08x: ", i);

				printk("\n" KERN_NOTICE "0x%08x: ", i);



			if (get_user(x, (unsigned short *)i))

				break;

#ifndef CONFIG_DEBUG_HWERR

			/* If one of the last few instructions was a STI

			 * it is likely that the error occured awhile ago

			 * and we just noticed

			 * and we just noticed. This only happens in kernel

			 * context, which should mean an oops is happening

			 */

			if (x >= 0x0040 && x <= 0x0047 && i <= 0)

			if (oops_in_progress && x >= 0x0040 && x <= 0x0047 && i <= 0)

				panic("\n\nWARNING : You should reconfigure"

					" the kernel to turn on\n"

					" 'Hardware error interrupt"
@@ -634,56 +668,60 @@ void dump_bfin_regs(struct pt_regs *fp, void *retaddr) 
			else

				printk(" %04x ", x);

		}

		printk("\n" KERN_EMERG "\n");

		printk("\n");

	} else

		printk(KERN_EMERG

		printk("\n" KERN_NOTICE

			"Cannot look at the [PC] for it is"

			"in unreadable L1 SRAM - sorry\n");

			" in unreadable memory - sorry\n");



	printk(KERN_NOTICE "\n" KERN_NOTICE "SEQUENCER STATUS:\n");

	printk(KERN_NOTICE " SEQSTAT: %08lx  IPEND: %04lx  SYSCFG: %04lx\n",

		(long)fp->seqstat, fp->ipend, fp->syscfg);



	printk(KERN_EMERG

		"RETE:  %08lx  RETN: %08lx  RETX: %08lx  RETS: %08lx\n",

		fp->rete, fp->retn, fp->retx, fp->rets);

	printk(KERN_EMERG "IPEND: %04lx  SYSCFG: %04lx\n",

		fp->ipend, fp->syscfg);

	printk(KERN_EMERG "SEQSTAT: %08lx    SP: %08lx\n",

		(long)fp->seqstat, (long)fp);

	printk(KERN_EMERG "R0: %08lx    R1: %08lx    R2: %08lx    R3: %08lx\n",

	decode_address(buf, fp->rete);

	printk(KERN_NOTICE " RETE: %s\n", buf);

	decode_address(buf, fp->retn);

	printk(KERN_NOTICE " RETN: %s\n", buf);

	decode_address(buf, fp->retx);

	printk(KERN_NOTICE " RETX: %s\n", buf);

	decode_address(buf, fp->rets);

	printk(KERN_NOTICE " RETS: %s\n", buf);



	if ((long)fp->seqstat & SEQSTAT_EXCAUSE) {

		decode_address(buf, bfin_read_DCPLB_FAULT_ADDR());

		printk(KERN_NOTICE "DCPLB_FAULT_ADDR: %s\n", buf);

		decode_address(buf, bfin_read_ICPLB_FAULT_ADDR());

		printk(KERN_NOTICE "ICPLB_FAULT_ADDR: %s\n", buf);

	}



	printk(KERN_NOTICE "\n" KERN_NOTICE "PROCESSOR STATE:\n");

	printk(KERN_NOTICE " R0 : %08lx    R1 : %08lx    R2 : %08lx    R3 : %08lx\n",

		fp->r0, fp->r1, fp->r2, fp->r3);

	printk(KERN_EMERG "R4: %08lx    R5: %08lx    R6: %08lx    R7: %08lx\n",

	printk(KERN_NOTICE " R4 : %08lx    R5 : %08lx    R6 : %08lx    R7 : %08lx\n",

		fp->r4, fp->r5, fp->r6, fp->r7);

	printk(KERN_EMERG "P0: %08lx    P1: %08lx    P2: %08lx    P3: %08lx\n",

	printk(KERN_NOTICE " P0 : %08lx    P1 : %08lx    P2 : %08lx    P3 : %08lx\n",

		fp->p0, fp->p1, fp->p2, fp->p3);

	printk(KERN_EMERG

		"P4: %08lx    P5: %08lx    FP: %08lx\n",

		fp->p4, fp->p5, fp->fp);

	printk(KERN_EMERG

		"A0.w: %08lx    A0.x: %08lx    A1.w: %08lx    A1.x: %08lx\n",

		fp->a0w, fp->a0x, fp->a1w, fp->a1x);



	printk(KERN_EMERG "LB0: %08lx  LT0: %08lx  LC0: %08lx\n",

	printk(KERN_NOTICE " P4 : %08lx    P5 : %08lx    FP : %08lx    SP : %08lx\n",

		fp->p4, fp->p5, fp->fp, (long)fp);

	printk(KERN_NOTICE " LB0: %08lx    LT0: %08lx    LC0: %08lx\n",

		fp->lb0, fp->lt0, fp->lc0);

	printk(KERN_EMERG "LB1: %08lx  LT1: %08lx  LC1: %08lx\n",

	printk(KERN_NOTICE " LB1: %08lx    LT1: %08lx    LC1: %08lx\n",

		fp->lb1, fp->lt1, fp->lc1);

	printk(KERN_EMERG "B0: %08lx  L0: %08lx  M0: %08lx  I0: %08lx\n",

	printk(KERN_NOTICE " B0 : %08lx    L0 : %08lx    M0 : %08lx    I0 : %08lx\n",

		fp->b0, fp->l0, fp->m0, fp->i0);

	printk(KERN_EMERG "B1: %08lx  L1: %08lx  M1: %08lx  I1: %08lx\n",

	printk(KERN_NOTICE " B1 : %08lx    L1 : %08lx    M1 : %08lx    I1 : %08lx\n",

		fp->b1, fp->l1, fp->m1, fp->i1);

	printk(KERN_EMERG "B2: %08lx  L2: %08lx  M2: %08lx  I2: %08lx\n",

	printk(KERN_NOTICE " B2 : %08lx    L2 : %08lx    M2 : %08lx    I2 : %08lx\n",

		fp->b2, fp->l2, fp->m2, fp->i2);

	printk(KERN_EMERG "B3: %08lx  L3: %08lx  M3: %08lx  I3: %08lx\n",

	printk(KERN_NOTICE " B3 : %08lx    L3 : %08lx    M3 : %08lx    I3 : %08lx\n",

		fp->b3, fp->l3, fp->m3, fp->i3);

	printk(KERN_NOTICE "A0.w: %08lx   A0.x: %08lx   A1.w: %08lx   A1.x: %08lx\n",

		fp->a0w, fp->a0x, fp->a1w, fp->a1x);



	printk(KERN_EMERG "\n" KERN_EMERG "USP: %08lx   ASTAT: %08lx\n",

	printk(KERN_NOTICE "USP : %08lx  ASTAT: %08lx\n",

		rdusp(), fp->astat);

	if ((long)fp->seqstat & SEQSTAT_EXCAUSE) {

		printk(KERN_EMERG "DCPLB_FAULT_ADDR=%p\n",

			(void *)bfin_read_DCPLB_FAULT_ADDR());

		printk(KERN_EMERG "ICPLB_FAULT_ADDR=%p\n",

			(void *)bfin_read_ICPLB_FAULT_ADDR());

	}



	printk("\n\n");

	printk(KERN_NOTICE "\n");

}



#ifdef CONFIG_SYS_BFIN_SPINLOCK_L1
@@ -758,6 +796,8 @@ void panic_cplb_error(int cplb_panic, struct pt_regs *fp) 
		break;

	}



	oops_in_progress = 1;



	printk(KERN_EMERG "DCPLB_FAULT_ADDR=%p\n", (void *)bfin_read_DCPLB_FAULT_ADDR());

	printk(KERN_EMERG "ICPLB_FAULT_ADDR=%p\n", (void *)bfin_read_ICPLB_FAULT_ADDR());

	dump_bfin_regs(fp, (void *)fp->retx);