// SPDX-License-Identifier: GPL-2.0
#define DEBUG

#include <linux/wait.h>
#include <linux/ptrace.h>

#include <asm/spu.h>
#include <asm/spu_priv1.h>
#include <asm/io.h>
#include <asm/unistd.h>

#include "spufs.h"

/* interrupt-level stop callback function. */
void spufs_stop_callback(struct spu *spu, int irq)
{
        struct spu_context *ctx = spu->ctx;

        /*
         * It should be impossible to preempt a context while an exception
         * is being processed, since the context switch code is specially
         * coded to deal with interrupts ... But, just in case, sanity check
         * the context pointer.  It is OK to return doing nothing since
         * the exception will be regenerated when the context is resumed.
         */
        if (ctx) {
                /* Copy exception arguments into module specific structure */
                switch(irq) {
                case 0 :
                        ctx->csa.class_0_pending = spu->class_0_pending;
                        ctx->csa.class_0_dar = spu->class_0_dar;
                        break;
                case 1 :
                        ctx->csa.class_1_dsisr = spu->class_1_dsisr;
                        ctx->csa.class_1_dar = spu->class_1_dar;
                        break;
                case 2 :
                        break;
                }

                /* ensure that the exception status has hit memory before a
                 * thread waiting on the context's stop queue is woken */
                smp_wmb();

                wake_up_all(&ctx->stop_wq);
        }
}

int spu_stopped(struct spu_context *ctx, u32 *stat)
{
        u64 dsisr;
        u32 stopped;

        stopped = SPU_STATUS_INVALID_INSTR | SPU_STATUS_SINGLE_STEP |
                SPU_STATUS_STOPPED_BY_HALT | SPU_STATUS_STOPPED_BY_STOP;

top:
        *stat = ctx->ops->status_read(ctx);
        if (*stat & stopped) {
                /*
                 * If the spu hasn't finished stopping, we need to
                 * re-read the register to get the stopped value.
                 */
                if (*stat & SPU_STATUS_RUNNING)
                        goto top;
                return 1;
        }

        if (test_bit(SPU_SCHED_NOTIFY_ACTIVE, &ctx->sched_flags))
                return 1;

        dsisr = ctx->csa.class_1_dsisr;
        if (dsisr & (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED))
                return 1;

        if (ctx->csa.class_0_pending)
                return 1;

        return 0;
}

static int spu_setup_isolated(struct spu_context *ctx)
{
        int ret;
        u64 __iomem *mfc_cntl;
        u64 sr1;
        u32 status;
        unsigned long timeout;
        const u32 status_loading = SPU_STATUS_RUNNING
                | SPU_STATUS_ISOLATED_STATE | SPU_STATUS_ISOLATED_LOAD_STATUS;

        ret = -ENODEV;
        if (!isolated_loader)
                goto out;

        /*
         * We need to exclude userspace access to the context.
         *
         * To protect against memory access we invalidate all ptes
         * and make sure the pagefault handlers block on the mutex.
         */
        spu_unmap_mappings(ctx);

        mfc_cntl = &ctx->spu->priv2->mfc_control_RW;

        /* purge the MFC DMA queue to ensure no spurious accesses before we
         * enter kernel mode */
        timeout = jiffies + HZ;
        out_be64(mfc_cntl, MFC_CNTL_PURGE_DMA_REQUEST);
        while ((in_be64(mfc_cntl) & MFC_CNTL_PURGE_DMA_STATUS_MASK)
                        != MFC_CNTL_PURGE_DMA_COMPLETE) {
                if (time_after(jiffies, timeout)) {
                        printk(KERN_ERR "%s: timeout flushing MFC DMA queue\n",
                                        __func__);
                        ret = -EIO;
                        goto out;
                }
                cond_resched();
        }

        /* clear purge status */
        out_be64(mfc_cntl, 0);

        /* put the SPE in kernel mode to allow access to the loader */
        sr1 = spu_mfc_sr1_get(ctx->spu);
        sr1 &= ~MFC_STATE1_PROBLEM_STATE_MASK;
        spu_mfc_sr1_set(ctx->spu, sr1);

        /* start the loader */
        ctx->ops->signal1_write(ctx, (unsigned long)isolated_loader >> 32);
        ctx->ops->signal2_write(ctx,
                        (unsigned long)isolated_loader & 0xffffffff);

        ctx->ops->runcntl_write(ctx,
                        SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);

        ret = 0;
        timeout = jiffies + HZ;
        while (((status = ctx->ops->status_read(ctx)) & status_loading) ==
                                status_loading) {
                if (time_after(jiffies, timeout)) {
                        printk(KERN_ERR "%s: timeout waiting for loader\n",
                                        __func__);
                        ret = -EIO;
                        goto out_drop_priv;
                }
                cond_resched();
        }

        if (!(status & SPU_STATUS_RUNNING)) {
                /* If isolated LOAD has failed: run SPU, we will get a stop-and
                 * signal later. */
                pr_debug("%s: isolated LOAD failed\n", __func__);
                ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
                ret = -EACCES;
                goto out_drop_priv;
        }

        if (!(status & SPU_STATUS_ISOLATED_STATE)) {
                /* This isn't allowed by the CBEA, but check anyway */
                pr_debug("%s: SPU fell out of isolated mode?\n", __func__);
                ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_STOP);
                ret = -EINVAL;
                goto out_drop_priv;
        }

out_drop_priv:
        /* Finished accessing the loader. Drop kernel mode */
        sr1 |= MFC_STATE1_PROBLEM_STATE_MASK;
        spu_mfc_sr1_set(ctx->spu, sr1);

out:
        return ret;
}

static int spu_run_init(struct spu_context *ctx, u32 *npc)
{
        unsigned long runcntl = SPU_RUNCNTL_RUNNABLE;
        int ret;

        spuctx_switch_state(ctx, SPU_UTIL_SYSTEM);

        /*
         * NOSCHED is synchronous scheduling with respect to the caller.
         * The caller waits for the context to be loaded.
         */
        if (ctx->flags & SPU_CREATE_NOSCHED) {
                if (ctx->state == SPU_STATE_SAVED) {
                        ret = spu_activate(ctx, 0);
                        if (ret)
                                return ret;
                }
        }

        /*
         * Apply special setup as required.
         */
        if (ctx->flags & SPU_CREATE_ISOLATE) {
                if (!(ctx->ops->status_read(ctx) & SPU_STATUS_ISOLATED_STATE)) {
                        ret = spu_setup_isolated(ctx);
                        if (ret)
                                return ret;
                }

                /*
                 * If userspace has set the runcntrl register (eg, to
                 * issue an isolated exit), we need to re-set it here
                 */
                runcntl = ctx->ops->runcntl_read(ctx) &
                        (SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);
                if (runcntl == 0)
                        runcntl = SPU_RUNCNTL_RUNNABLE;
        } else {
                unsigned long privcntl;

                if (test_thread_flag(TIF_SINGLESTEP))
                        privcntl = SPU_PRIVCNTL_MODE_SINGLE_STEP;
                else
                        privcntl = SPU_PRIVCNTL_MODE_NORMAL;

                ctx->ops->privcntl_write(ctx, privcntl);
                ctx->ops->npc_write(ctx, *npc);
        }

        ctx->ops->runcntl_write(ctx, runcntl);

        if (ctx->flags & SPU_CREATE_NOSCHED) {
                spuctx_switch_state(ctx, SPU_UTIL_USER);
        } else {

                if (ctx->state == SPU_STATE_SAVED) {
                        ret = spu_activate(ctx, 0);
                        if (ret)
                                return ret;
                } else {
                        spuctx_switch_state(ctx, SPU_UTIL_USER);
                }
        }

        set_bit(SPU_SCHED_SPU_RUN, &ctx->sched_flags);
        return 0;
}

static int spu_run_fini(struct spu_context *ctx, u32 *npc,
                               u32 *status)
{
        int ret = 0;

        spu_del_from_rq(ctx);

        *status = ctx->ops->status_read(ctx);
        *npc = ctx->ops->npc_read(ctx);

        spuctx_switch_state(ctx, SPU_UTIL_IDLE_LOADED);
        clear_bit(SPU_SCHED_SPU_RUN, &ctx->sched_flags);
        spu_switch_log_notify(NULL, ctx, SWITCH_LOG_EXIT, *status);
        spu_release(ctx);

        if (signal_pending(current))
                ret = -ERESTARTSYS;

        return ret;
}

/*
 * SPU syscall restarting is tricky because we violate the basic
 * assumption that the signal handler is running on the interrupted
 * thread. Here instead, the handler runs on PowerPC user space code,
 * while the syscall was called from the SPU.
 * This means we can only do a very rough approximation of POSIX
 * signal semantics.
 */
static int spu_handle_restartsys(struct spu_context *ctx, long *spu_ret,
                          unsigned int *npc)
{
        int ret;

        switch (*spu_ret) {
        case -ERESTARTSYS:
        case -ERESTARTNOINTR:
                /*
                 * Enter the regular syscall restarting for
                 * sys_spu_run, then restart the SPU syscall
                 * callback.
                 */
                *npc -= 8;
                ret = -ERESTARTSYS;
                break;
        case -ERESTARTNOHAND:
        case -ERESTART_RESTARTBLOCK:
                /*
                 * Restart block is too hard for now, just return -EINTR
                 * to the SPU.
                 * ERESTARTNOHAND comes from sys_pause, we also return
                 * -EINTR from there.
                 * Assume that we need to be restarted ourselves though.
                 */
                *spu_ret = -EINTR;
                ret = -ERESTARTSYS;
                break;
        default:
                printk(KERN_WARNING "%s: unexpected return code %ld\n",
                        __func__, *spu_ret);
                ret = 0;
        }
        return ret;
}

static int spu_process_callback(struct spu_context *ctx)
{
        struct spu_syscall_block s;
        u32 ls_pointer, npc;
        void __iomem *ls;
        long spu_ret;
        int ret;

        /* get syscall block from local store */
        npc = ctx->ops->npc_read(ctx) & ~3;
        ls = (void __iomem *)ctx->ops->get_ls(ctx);
        ls_pointer = in_be32(ls + npc);
        if (ls_pointer > (LS_SIZE - sizeof(s)))
                return -EFAULT;
        memcpy_fromio(&s, ls + ls_pointer, sizeof(s));

        /* do actual syscall without pinning the spu */
        ret = 0;
        spu_ret = -ENOSYS;
        npc += 4;

        if (s.nr_ret < NR_syscalls) {
                spu_release(ctx);
                /* do actual system call from here */
                spu_ret = spu_sys_callback(&s);
                if (spu_ret <= -ERESTARTSYS) {
                        ret = spu_handle_restartsys(ctx, &spu_ret, &npc);
                }
                mutex_lock(&ctx->state_mutex);
                if (ret == -ERESTARTSYS)
                        return ret;
        }

        /* need to re-get the ls, as it may have changed when we released the
         * spu */
        ls = (void __iomem *)ctx->ops->get_ls(ctx);

        /* write result, jump over indirect pointer */
        memcpy_toio(ls + ls_pointer, &spu_ret, sizeof(spu_ret));
        ctx->ops->npc_write(ctx, npc);
        ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
        return ret;
}

long spufs_run_spu(struct spu_context *ctx, u32 *npc, u32 *event)
{
        int ret;
        u32 status;

        if (mutex_lock_interruptible(&ctx->run_mutex))
                return -ERESTARTSYS;

        ctx->event_return = 0;

        ret = spu_acquire(ctx);
        if (ret)
                goto out_unlock;

        spu_enable_spu(ctx);

        spu_update_sched_info(ctx);

        ret = spu_run_init(ctx, npc);
        if (ret) {
                spu_release(ctx);
                goto out;
        }

        do {
                ret = spufs_wait(ctx->stop_wq, spu_stopped(ctx, &status));
                if (unlikely(ret)) {
                        /*
                         * This is nasty: we need the state_mutex for all the
                         * bookkeeping even if the syscall was interrupted by
                         * a signal. ewww.
                         */
                        mutex_lock(&ctx->state_mutex);
                        break;
                }
                if (unlikely(test_and_clear_bit(SPU_SCHED_NOTIFY_ACTIVE,
                                                &ctx->sched_flags))) {
                        if (!(status & SPU_STATUS_STOPPED_BY_STOP))
                                continue;
                }

                spuctx_switch_state(ctx, SPU_UTIL_SYSTEM);

                if ((status & SPU_STATUS_STOPPED_BY_STOP) &&
                    (status >> SPU_STOP_STATUS_SHIFT == 0x2104)) {
                        ret = spu_process_callback(ctx);
                        if (ret)
                                break;
                        status &= ~SPU_STATUS_STOPPED_BY_STOP;
                }
                ret = spufs_handle_class1(ctx);
                if (ret)
                        break;

                ret = spufs_handle_class0(ctx);
                if (ret)
                        break;

                if (signal_pending(current))
                        ret = -ERESTARTSYS;
        } while (!ret && !(status & (SPU_STATUS_STOPPED_BY_STOP |
                                      SPU_STATUS_STOPPED_BY_HALT |
                                       SPU_STATUS_SINGLE_STEP)));

        spu_disable_spu(ctx);
        ret = spu_run_fini(ctx, npc, &status);
        spu_yield(ctx);

        if ((status & SPU_STATUS_STOPPED_BY_STOP) &&
            (((status >> SPU_STOP_STATUS_SHIFT) & 0x3f00) == 0x2100))
                ctx->stats.libassist++;

        if ((ret == 0) ||
            ((ret == -ERESTARTSYS) &&
             ((status & SPU_STATUS_STOPPED_BY_HALT) ||
              (status & SPU_STATUS_SINGLE_STEP) ||
              ((status & SPU_STATUS_STOPPED_BY_STOP) &&
               (status >> SPU_STOP_STATUS_SHIFT != 0x2104)))))
                ret = status;

        /* Note: we don't need to force_sig SIGTRAP on single-step
         * since we have TIF_SINGLESTEP set, thus the kernel will do
         * it upon return from the syscall anyway.
         */
        if (unlikely(status & SPU_STATUS_SINGLE_STEP))
                ret = -ERESTARTSYS;

        else if (unlikely((status & SPU_STATUS_STOPPED_BY_STOP)
            && (status >> SPU_STOP_STATUS_SHIFT) == 0x3fff)) {
                force_sig(SIGTRAP);
                ret = -ERESTARTSYS;
        }

out:
        *event = ctx->event_return;
out_unlock:
        mutex_unlock(&ctx->run_mutex);
        return ret;
}