/*
 * Kernel traps/events for Hexagon processor
 *
 * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 and
 * only version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

#include <linux/init.h>
#include <linux/sched.h>
#include <linux/module.h>
#include <linux/kallsyms.h>
#include <linux/kdebug.h>
#include <linux/syscalls.h>
#include <linux/signal.h>
#include <linux/tracehook.h>
#include <asm/traps.h>
#include <asm/vm_fault.h>
#include <asm/syscall.h>
#include <asm/registers.h>
#include <asm/unistd.h>
#include <asm/sections.h>
#ifdef CONFIG_KGDB
# include <linux/kgdb.h>
#endif

#define TRAP_SYSCALL    1
#define TRAP_DEBUG      0xdb

void __init trap_init(void)
{
}

#ifdef CONFIG_GENERIC_BUG
/* Maybe should resemble arch/sh/kernel/traps.c ?? */
int is_valid_bugaddr(unsigned long addr)
{
        return 1;
}
#endif /* CONFIG_GENERIC_BUG */

static const char *ex_name(int ex)
{
        switch (ex) {
        case HVM_GE_C_XPROT:
        case HVM_GE_C_XUSER:
                return "Execute protection fault";
        case HVM_GE_C_RPROT:
        case HVM_GE_C_RUSER:
                return "Read protection fault";
        case HVM_GE_C_WPROT:
        case HVM_GE_C_WUSER:
                return "Write protection fault";
        case HVM_GE_C_XMAL:
                return "Misaligned instruction";
        case HVM_GE_C_WREG:
                return "Multiple writes to same register in packet";
        case HVM_GE_C_PCAL:
                return "Program counter values that are not properly aligned";
        case HVM_GE_C_RMAL:
                return "Misaligned data load";
        case HVM_GE_C_WMAL:
                return "Misaligned data store";
        case HVM_GE_C_INVI:
        case HVM_GE_C_PRIVI:
                return "Illegal instruction";
        case HVM_GE_C_BUS:
                return "Precise bus error";
        case HVM_GE_C_CACHE:
                return "Cache error";

        case 0xdb:
                return "Debugger trap";

        default:
                return "Unrecognized exception";
        }
}

static void do_show_stack(struct task_struct *task, unsigned long *fp,
                          unsigned long ip)
{
        int kstack_depth_to_print = 24;
        unsigned long offset, size;
        const char *name = NULL;
        unsigned long *newfp;
        unsigned long low, high;
        char tmpstr[128];
        char *modname;
        int i;

        if (task == NULL)
                task = current;

        printk(KERN_INFO "CPU#%d, %s/%d, Call Trace:\n",
               raw_smp_processor_id(), task->comm,
               task_pid_nr(task));

        if (fp == NULL) {
                if (task == current) {
                        asm("%0 = r30" : "=r" (fp));
                } else {
                        fp = (unsigned long *)
                             ((struct hexagon_switch_stack *)
                             task->thread.switch_sp)->fp;
                }
        }

        if ((((unsigned long) fp) & 0x3) || ((unsigned long) fp < 0x1000)) {
                printk(KERN_INFO "-- Corrupt frame pointer %p\n", fp);
                return;
        }

        /* Saved link reg is one word above FP */
        if (!ip)
                ip = *(fp+1);

        /* Expect kernel stack to be in-bounds */
        low = (unsigned long)task_stack_page(task);
        high = low + THREAD_SIZE - 8;
        low += sizeof(struct thread_info);

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

                name = kallsyms_lookup(ip, &size, &offset, &modname, tmpstr);

                printk(KERN_INFO "[%p] 0x%lx: %s + 0x%lx", fp, ip, name,
                        offset);
                if (((unsigned long) fp < low) || (high < (unsigned long) fp))
                        printk(KERN_CONT " (FP out of bounds!)");
                if (modname)
                        printk(KERN_CONT " [%s] ", modname);
                printk(KERN_CONT "\n");

                newfp = (unsigned long *) *fp;

                if (((unsigned long) newfp) & 0x3) {
                        printk(KERN_INFO "-- Corrupt frame pointer %p\n",
                                newfp);
                        break;
                }

                /* Attempt to continue past exception. */
                if (0 == newfp) {
                        struct pt_regs *regs = (struct pt_regs *) (((void *)fp)
                                                + 8);

                        if (regs->syscall_nr != -1) {
                                printk(KERN_INFO "-- trap0 -- syscall_nr: %ld",
                                        regs->syscall_nr);
                                printk(KERN_CONT "  psp: %lx  elr: %lx\n",
                                         pt_psp(regs), pt_elr(regs));
                                break;
                        } else {
                                /* really want to see more ... */
                                kstack_depth_to_print += 6;
                                printk(KERN_INFO "-- %s (0x%lx)  badva: %lx\n",
                                        ex_name(pt_cause(regs)), pt_cause(regs),
                                        pt_badva(regs));
                        }

                        newfp = (unsigned long *) regs->r30;
                        ip = pt_elr(regs);
                } else {
                        ip = *(newfp + 1);
                }

                /* If link reg is null, we are done. */
                if (ip == 0x0)
                        break;

                /* If newfp isn't larger, we're tracing garbage. */
                if (newfp > fp)
                        fp = newfp;
                else
                        break;
        }
}

void show_stack(struct task_struct *task, unsigned long *fp)
{
        /* Saved link reg is one word above FP */
        do_show_stack(task, fp, 0);
}

int die(const char *str, struct pt_regs *regs, long err)
{
        static struct {
                spinlock_t lock;
                int counter;
        } die = {
                .lock = __SPIN_LOCK_UNLOCKED(die.lock),
                .counter = 0
        };

        console_verbose();
        oops_enter();

        spin_lock_irq(&die.lock);
        bust_spinlocks(1);
        printk(KERN_EMERG "Oops: %s[#%d]:\n", str, ++die.counter);

        if (notify_die(DIE_OOPS, str, regs, err, pt_cause(regs), SIGSEGV) ==
            NOTIFY_STOP)
                return 1;

        print_modules();
        show_regs(regs);
        do_show_stack(current, &regs->r30, pt_elr(regs));

        bust_spinlocks(0);
        add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE);

        spin_unlock_irq(&die.lock);

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

        if (panic_on_oops)
                panic("Fatal exception");

        oops_exit();
        do_exit(err);
        return 0;
}

int die_if_kernel(char *str, struct pt_regs *regs, long err)
{
        if (!user_mode(regs))
                return die(str, regs, err);
        else
                return 0;
}

/*
 * It's not clear that misaligned fetches are ever recoverable.
 */
static void misaligned_instruction(struct pt_regs *regs)
{
        die_if_kernel("Misaligned Instruction", regs, 0);
        force_sig(SIGBUS, current);
}

/*
 * Misaligned loads and stores, on the other hand, can be
 * emulated, and probably should be, some day.  But for now
 * they will be considered fatal.
 */
static void misaligned_data_load(struct pt_regs *regs)
{
        die_if_kernel("Misaligned Data Load", regs, 0);
        force_sig(SIGBUS, current);
}

static void misaligned_data_store(struct pt_regs *regs)
{
        die_if_kernel("Misaligned Data Store", regs, 0);
        force_sig(SIGBUS, current);
}

static void illegal_instruction(struct pt_regs *regs)
{
        die_if_kernel("Illegal Instruction", regs, 0);
        force_sig(SIGILL, current);
}

/*
 * Precise bus errors may be recoverable with a a retry,
 * but for now, treat them as irrecoverable.
 */
static void precise_bus_error(struct pt_regs *regs)
{
        die_if_kernel("Precise Bus Error", regs, 0);
        force_sig(SIGBUS, current);
}

/*
 * If anything is to be done here other than panic,
 * it will probably be complex and migrate to another
 * source module.  For now, just die.
 */
static void cache_error(struct pt_regs *regs)
{
        die("Cache Error", regs, 0);
}

/*
 * General exception handler
 */
void do_genex(struct pt_regs *regs)
{
        /*
         * Decode Cause and Dispatch
         */
        switch (pt_cause(regs)) {
        case HVM_GE_C_XPROT:
        case HVM_GE_C_XUSER:
                execute_protection_fault(regs);
                break;
        case HVM_GE_C_RPROT:
        case HVM_GE_C_RUSER:
                read_protection_fault(regs);
                break;
        case HVM_GE_C_WPROT:
        case HVM_GE_C_WUSER:
                write_protection_fault(regs);
                break;
        case HVM_GE_C_XMAL:
                misaligned_instruction(regs);
                break;
        case HVM_GE_C_WREG:
                illegal_instruction(regs);
                break;
        case HVM_GE_C_PCAL:
                misaligned_instruction(regs);
                break;
        case HVM_GE_C_RMAL:
                misaligned_data_load(regs);
                break;
        case HVM_GE_C_WMAL:
                misaligned_data_store(regs);
                break;
        case HVM_GE_C_INVI:
        case HVM_GE_C_PRIVI:
                illegal_instruction(regs);
                break;
        case HVM_GE_C_BUS:
                precise_bus_error(regs);
                break;
        case HVM_GE_C_CACHE:
                cache_error(regs);
                break;
        default:
                /* Halt and catch fire */
                panic("Unrecognized exception 0x%lx\n", pt_cause(regs));
                break;
        }
}

/* Indirect system call dispatch */
long sys_syscall(void)
{
        printk(KERN_ERR "sys_syscall invoked!\n");
        return -ENOSYS;
}

void do_trap0(struct pt_regs *regs)
{
        syscall_fn syscall;

        switch (pt_cause(regs)) {
        case TRAP_SYSCALL:
                /* System call is trap0 #1 */

                /* allow strace to catch syscall args  */
                if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE) &&
                        tracehook_report_syscall_entry(regs)))
                        return;  /*  return -ENOSYS somewhere?  */

                /* Interrupts should be re-enabled for syscall processing */
                __vmsetie(VM_INT_ENABLE);

                /*
                 * System call number is in r6, arguments in r0..r5.
                 * Fortunately, no Linux syscall has more than 6 arguments,
                 * and Hexagon ABI passes first 6 arguments in registers.
                 * 64-bit arguments are passed in odd/even register pairs.
                 * Fortunately, we have no system calls that take more
                 * than three arguments with more than one 64-bit value.
                 * Should that change, we'd need to redesign to copy
                 * between user and kernel stacks.
                 */
                regs->syscall_nr = regs->r06;

                /*
                 * GPR R0 carries the first parameter, and is also used
                 * to report the return value.  We need a backup of
                 * the user's value in case we need to do a late restart
                 * of the system call.
                 */
                regs->restart_r0 = regs->r00;

                if ((unsigned long) regs->syscall_nr >= __NR_syscalls) {
                        regs->r00 = -1;
                } else {
                        syscall = (syscall_fn)
                                  (sys_call_table[regs->syscall_nr]);
                        regs->r00 = syscall(regs->r00, regs->r01,
                                   regs->r02, regs->r03,
                                   regs->r04, regs->r05);
                }

                /* allow strace to get the syscall return state  */
                if (unlikely(test_thread_flag(TIF_SYSCALL_TRACE)))
                        tracehook_report_syscall_exit(regs, 0);

                break;
        case TRAP_DEBUG:
                /* Trap0 0xdb is debug breakpoint */
                if (user_mode(regs)) {
                        struct siginfo info;

                        info.si_signo = SIGTRAP;
                        info.si_errno = 0;
                        /*
                         * Some architecures add some per-thread state
                         * to distinguish between breakpoint traps and
                         * trace traps.  We may want to do that, and
                         * set the si_code value appropriately, or we
                         * may want to use a different trap0 flavor.
                         */
                        info.si_code = TRAP_BRKPT;
                        info.si_addr = (void __user *) pt_elr(regs);
                        send_sig_info(SIGTRAP, &info, current);
                } else {
#ifdef CONFIG_KGDB
                        kgdb_handle_exception(pt_cause(regs), SIGTRAP,
                                              TRAP_BRKPT, regs);
#endif
                }
                break;
        }
        /* Ignore other trap0 codes for now, especially 0 (Angel calls) */
}

/*
 * Machine check exception handler
 */
void do_machcheck(struct pt_regs *regs)
{
        /* Halt and catch fire */
        __vmstop();
}

/*
 * Treat this like the old 0xdb trap.
 */

void do_debug_exception(struct pt_regs *regs)
{
        regs->hvmer.vmest &= ~HVM_VMEST_CAUSE_MSK;
        regs->hvmer.vmest |= (TRAP_DEBUG << HVM_VMEST_CAUSE_SFT);
        do_trap0(regs);
}