// SPDX-License-Identifier: GPL-2.0-or-later

/*
 * Copyright 2020 IBM Corp.
 *
 * Author: Bulent Abali <abali@us.ibm.com>
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/time.h>
#include <sys/fcntl.h>
#include <sys/mman.h>
#include <endian.h>
#include <bits/endian.h>
#include <sys/ioctl.h>
#include <assert.h>
#include <errno.h>
#include <signal.h>
#include "vas-api.h"
#include "nx.h"
#include "copy-paste.h"
#include "nxu.h"
#include "nx_dbg.h"
#include <sys/platform/ppc.h>

#define barrier()
#define hwsync()    ({ asm volatile("sync" ::: "memory"); })

#ifndef NX_NO_CPU_PRI
#define cpu_pri_default()  ({ asm volatile ("or 2, 2, 2"); })
#define cpu_pri_low()      ({ asm volatile ("or 31, 31, 31"); })
#else
#define cpu_pri_default()
#define cpu_pri_low()
#endif

void *nx_fault_storage_address;

struct nx_handle {
        int fd;
        int function;
        void *paste_addr;
};

static int open_device_nodes(char *devname, int pri, struct nx_handle *handle)
{
        int rc, fd;
        void *addr;
        struct vas_tx_win_open_attr txattr;

        fd = open(devname, O_RDWR);
        if (fd < 0) {
                fprintf(stderr, " open device name %s\n", devname);
                return -errno;
        }

        memset(&txattr, 0, sizeof(txattr));
        txattr.version = 1;
        txattr.vas_id = pri;
        rc = ioctl(fd, VAS_TX_WIN_OPEN, (unsigned long)&txattr);
        if (rc < 0) {
                fprintf(stderr, "ioctl() n %d, error %d\n", rc, errno);
                rc = -errno;
                goto out;
        }

        addr = mmap(NULL, 4096, PROT_READ|PROT_WRITE, MAP_SHARED, fd, 0ULL);
        if (addr == MAP_FAILED) {
                fprintf(stderr, "mmap() failed, errno %d\n", errno);
                rc = -errno;
                goto out;
        }
        handle->fd = fd;
        handle->paste_addr = (void *)((char *)addr + 0x400);

        rc = 0;
out:
        close(fd);
        return rc;
}

void *nx_function_begin(int function, int pri)
{
        int rc;
        char *devname = "/dev/crypto/nx-gzip";
        struct nx_handle *nxhandle;

        if (function != NX_FUNC_COMP_GZIP) {
                errno = EINVAL;
                fprintf(stderr, " NX_FUNC_COMP_GZIP not found\n");
                return NULL;
        }


        nxhandle = malloc(sizeof(*nxhandle));
        if (!nxhandle) {
                errno = ENOMEM;
                fprintf(stderr, " No memory\n");
                return NULL;
        }

        nxhandle->function = function;
        rc = open_device_nodes(devname, pri, nxhandle);
        if (rc < 0) {
                errno = -rc;
                fprintf(stderr, " open_device_nodes failed\n");
                return NULL;
        }

        return nxhandle;
}

int nx_function_end(void *handle)
{
        int rc = 0;
        struct nx_handle *nxhandle = handle;

        rc = munmap(nxhandle->paste_addr - 0x400, 4096);
        if (rc < 0) {
                fprintf(stderr, "munmap() failed, errno %d\n", errno);
                return rc;
        }
        close(nxhandle->fd);
        free(nxhandle);

        return rc;
}

static int nx_wait_for_csb(struct nx_gzip_crb_cpb_t *cmdp)
{
        long poll = 0;
        uint64_t t;

        /* Save power and let other threads use the h/w. top may show
         * 100% but only because OS doesn't know we slowed the this
         * h/w thread while polling. We're letting other threads have
         * higher throughput on the core.
         */
        cpu_pri_low();

#define CSB_MAX_POLL 200000000UL
#define USLEEP_TH     300000UL

        t = __ppc_get_timebase();

        while (getnn(cmdp->crb.csb, csb_v) == 0) {
                ++poll;
                hwsync();

                cpu_pri_low();

                /* usleep(0) takes around 29000 ticks ~60 us.
                 * 300000 is spinning for about 600 us then
                 * start sleeping.
                 */
                if ((__ppc_get_timebase() - t) > USLEEP_TH) {
                        cpu_pri_default();
                        usleep(1);
                }

                if (poll > CSB_MAX_POLL)
                        break;

                /* Fault address from signal handler */
                if (nx_fault_storage_address) {
                        cpu_pri_default();
                        return -EAGAIN;
                }

        }

        cpu_pri_default();

        /* hw has updated csb and output buffer */
        hwsync();

        /* Check CSB flags. */
        if (getnn(cmdp->crb.csb, csb_v) == 0) {
                fprintf(stderr, "CSB still not valid after %d polls.\n",
                        (int) poll);
                prt_err("CSB still not valid after %d polls, giving up.\n",
                        (int) poll);
                return -ETIMEDOUT;
        }

        return 0;
}

static int nxu_run_job(struct nx_gzip_crb_cpb_t *cmdp, void *handle)
{
        int i, ret, retries;
        struct nx_handle *nxhandle = handle;

        assert(handle != NULL);
        i = 0;
        retries = 5000;
        while (i++ < retries) {
                hwsync();
                vas_copy(&cmdp->crb, 0);
                ret = vas_paste(nxhandle->paste_addr, 0);
                hwsync();

                NXPRT(fprintf(stderr, "Paste attempt %d/%d returns 0x%x\n",
                                i, retries, ret));

                if ((ret == 2) || (ret == 3)) {

                        ret = nx_wait_for_csb(cmdp);
                        if (!ret) {
                                goto out;
                        } else if (ret == -EAGAIN) {
                                long x;

                                prt_err("Touching address %p, 0x%lx\n",
                                         nx_fault_storage_address,
                                         *(long *) nx_fault_storage_address);
                                x = *(long *) nx_fault_storage_address;
                                *(long *) nx_fault_storage_address = x;
                                nx_fault_storage_address = 0;
                                continue;
                        } else {
                                prt_err("wait_for_csb() returns %d\n", ret);
                                break;
                        }
                } else {
                        if (i < 10) {
                                /* spin for few ticks */
#define SPIN_TH 500UL
                                uint64_t fail_spin;

                                fail_spin = __ppc_get_timebase();
                                while ((__ppc_get_timebase() - fail_spin) <
                                         SPIN_TH)
                                        ;
                        } else {
                                /* sleep */
                                unsigned int pr = 0;

                                if (pr++ % 100 == 0) {
                                        prt_err("Paste attempt %d/", i);
                                        prt_err("%d, failed pid= %d\n", retries,
                                                getpid());
                                }
                                usleep(1);
                        }
                        continue;
                }
        }

out:
        cpu_pri_default();

        return ret;
}

int nxu_submit_job(struct nx_gzip_crb_cpb_t *cmdp, void *handle)
{
        int cc;

        cc = nxu_run_job(cmdp, handle);

        if (!cc)
                cc = getnn(cmdp->crb.csb, csb_cc);      /* CC Table 6-8 */

        return cc;
}


void nxu_sigsegv_handler(int sig, siginfo_t *info, void *ctx)
{
        fprintf(stderr, "%d: Got signal %d si_code %d, si_addr %p\n", getpid(),
                sig, info->si_code, info->si_addr);

        nx_fault_storage_address = info->si_addr;
}

/*
 * Fault in pages prior to NX job submission.  wr=1 may be required to
 * touch writeable pages.  System zero pages do not fault-in the page as
 * intended.  Typically set wr=1 for NX target pages and set wr=0 for NX
 * source pages.
 */
int nxu_touch_pages(void *buf, long buf_len, long page_len, int wr)
{
        char *begin = buf;
        char *end = (char *) buf + buf_len - 1;
        volatile char t;

        assert(buf_len >= 0 && !!buf);

        NXPRT(fprintf(stderr, "touch %p %p len 0x%lx wr=%d\n", buf,
                        (buf + buf_len), buf_len, wr));

        if (buf_len <= 0 || buf == NULL)
                return -1;

        do {
                t = *begin;
                if (wr)
                        *begin = t;
                begin = begin + page_len;
        } while (begin < end);

        /* When buf_sz is small or buf tail is in another page */
        t = *end;
        if (wr)
                *end = t;

        return 0;
}