Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/vapier/blackfin

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/vapier/blackfin: (30 commits)
  Blackfin: SMP: fix continuation lines
  Blackfin: acvilon: fix timeout usage for I2C
  Blackfin: fix typo in BF537 IRQ comment
  Blackfin: unify duplicate MEM_MT48LC32M8A2_75 kconfig options
  Blackfin: set ARCH_KMALLOC_MINALIGN
  Blackfin: use atomic kmalloc in L1 alloc so it too can be atomic
  Blackfin: another year of changes (update copyright in boot log)
  Blackfin: optimize strncpy a bit
  Blackfin: isram: clean up ITEST_COMMAND macro and improve the selftests
  Blackfin: move string functions to normal lib/ assembly
  Blackfin: SIC: cut down on IAR MMR reads a bit
  Blackfin: bf537-minotaur: fix build errors due to header changes
  Blackfin: kgdb: pass up the CC register instead of a 0 stub
  Blackfin: handle HW errors in the new "FAULT" printing code
  Blackfin: show the whole accumulator in the pseudo DBG insn
  Blackfin: support all possible registers in the pseudo instructions
  Blackfin: add support for the DBG (debug output) pseudo insn
  Blackfin: change the BUG opcode to an unused 16-bit opcode
  Blackfin: allow NMI watchdog to be used w/RETN as a scratch reg
  Blackfin: add support for the DBGA (debug assert) pseudo insn
  ...

1 files changed, 174 insertions, 0 deletions

diff --git a/arch/blackfin/kernel/dumpstack.c b/arch/blackfin/kernel/dumpstack.c
new file mode 100644
index 000000000000..5cfbaa298211
--- /dev/null
+++ b/arch/blackfin/kernel/dumpstack.c
@@ -0,0 +1,174 @@
+/* Provide basic stack dumping functions
+ *
+ * Copyright 2004-2009 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later
+ */
+
+#include <linux/kernel.h>
+#include <linux/thread_info.h>
+#include <linux/mm.h>
+#include <linux/uaccess.h>
+#include <linux/module.h>
+#include <asm/trace.h>
+
+/*
+ * Checks to see if the address pointed to is either a
+ * 16-bit CALL instruction, or a 32-bit CALL instruction
+ */
+static bool is_bfin_call(unsigned short *addr)
+{
+        unsigned int opcode;
+
+        if (!get_instruction(&opcode, addr))
+                return false;
+
+        if ((opcode >= 0x0060 && opcode <= 0x0067) ||
+            (opcode >= 0x0070 && opcode <= 0x0077) ||
+            (opcode >= 0xE3000000 && opcode <= 0xE3FFFFFF))
+                return true;
+
+        return false;
+
+}
+
+void show_stack(struct task_struct *task, unsigned long *stack)
+{
+#ifdef CONFIG_PRINTK
+        unsigned int *addr, *endstack, *fp = 0, *frame;
+        unsigned short *ins_addr;
+        char buf[150];
+        unsigned int i, j, ret_addr, frame_no = 0;
+
+        /*
+         * If we have been passed a specific stack, use that one otherwise
+         *    if we have been passed a task structure, use that, otherwise
+         *    use the stack of where the variable "stack" exists
+         */
+
+        if (stack == NULL) {
+                if (task) {
+                        /* We know this is a kernel stack, so this is the start/end */
+                        stack = (unsigned long *)task->thread.ksp;
+                        endstack = (unsigned int *)(((unsigned int)(stack) & ~(THREAD_SIZE - 1)) + THREAD_SIZE);
+                } else {
+                        /* print out the existing stack info */
+                        stack = (unsigned long *)&stack;
+                        endstack = (unsigned int *)PAGE_ALIGN((unsigned int)stack);
+                }
+        } else
+                endstack = (unsigned int *)PAGE_ALIGN((unsigned int)stack);
+
+        printk(KERN_NOTICE "Stack info:\n");
+        decode_address(buf, (unsigned int)stack);
+        printk(KERN_NOTICE " SP: [0x%p] %s\n", stack, buf);
+
+        if (!access_ok(VERIFY_READ, stack, (unsigned int)endstack - (unsigned int)stack)) {
+                printk(KERN_NOTICE "Invalid stack pointer\n");
+                return;
+        }
+
+        /* First thing is to look for a frame pointer */
+        for (addr = (unsigned int *)((unsigned int)stack & ~0xF); addr < endstack; addr++) {
+                if (*addr & 0x1)
+                        continue;
+                ins_addr = (unsigned short *)*addr;
+                ins_addr--;
+                if (is_bfin_call(ins_addr))
+                        fp = addr - 1;
+
+                if (fp) {
+                        /* Let's check to see if it is a frame pointer */
+                        while (fp >= (addr - 1) && fp < endstack
+                               && fp && ((unsigned int) fp & 0x3) == 0)
+                                fp = (unsigned int *)*fp;
+                        if (fp == 0 || fp == endstack) {
+                                fp = addr - 1;
+                                break;
+                        }
+                        fp = 0;
+                }
+        }
+        if (fp) {
+                frame = fp;
+                printk(KERN_NOTICE " FP: (0x%p)\n", fp);
+        } else
+                frame = 0;
+
+        /*
+         * Now that we think we know where things are, we
+         * walk the stack again, this time printing things out
+         * incase there is no frame pointer, we still look for
+         * valid return addresses
+         */
+
+        /* First time print out data, next time, print out symbols */
+        for (j = 0; j <= 1; j++) {
+                if (j)
+                        printk(KERN_NOTICE "Return addresses in stack:\n");
+                else
+                        printk(KERN_NOTICE " Memory from 0x%08lx to %p", ((long unsigned int)stack & ~0xF), endstack);
+
+                fp = frame;
+                frame_no = 0;
+
+                for (addr = (unsigned int *)((unsigned int)stack & ~0xF), i = 0;
+                     addr < endstack; addr++, i++) {
+
+                        ret_addr = 0;
+                        if (!j && i % 8 == 0)
+                                printk(KERN_NOTICE "%p:", addr);
+
+                        /* if it is an odd address, or zero, just skip it */
+                        if (*addr & 0x1 || !*addr)
+                                goto print;
+
+                        ins_addr = (unsigned short *)*addr;
+
+                        /* Go back one instruction, and see if it is a CALL */
+                        ins_addr--;
+                        ret_addr = is_bfin_call(ins_addr);
+ print:
+                        if (!j && stack == (unsigned long *)addr)
+                                printk("[%08x]", *addr);
+                        else if (ret_addr)
+                                if (j) {
+                                        decode_address(buf, (unsigned int)*addr);
+                                        if (frame == addr) {
+                                                printk(KERN_NOTICE "   frame %2i : %s\n", frame_no, buf);
+                                                continue;
+                                        }
+                                        printk(KERN_NOTICE "    address : %s\n", buf);
+                                } else
+                                        printk("<%08x>", *addr);
+                        else if (fp == addr) {
+                                if (j)
+                                        frame = addr+1;
+                                else
+                                        printk("(%08x)", *addr);
+
+                                fp = (unsigned int *)*addr;
+                                frame_no++;
+
+                        } else if (!j)
+                                printk(" %08x ", *addr);
+                }
+                if (!j)
+                        printk("\n");
+        }
+#endif
+}
+EXPORT_SYMBOL(show_stack);
+
+void dump_stack(void)
+{
+        unsigned long stack;
+#ifdef CONFIG_DEBUG_BFIN_HWTRACE_ON
+        int tflags;
+#endif
+        trace_buffer_save(tflags);
+        dump_bfin_trace_buffer();
+        show_stack(current, &stack);
+        trace_buffer_restore(tflags);
+}
+EXPORT_SYMBOL(dump_stack);