/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/promif_impl.h>
#include <sys/machsystm.h>
#include <sys/lpad.h>
#include <sys/vmsystm.h>
#include <sys/prom_plat.h>
#include <sys/ldoms.h>
#include <sys/kobj.h>
#include <sys/reboot.h>
#include <sys/hypervisor_api.h>
#include <sys/mdesc.h>
#include <sys/mach_descrip.h>
#include <sys/cpu_module.h>
#include <vm/seg_kmem.h>

#ifndef _KMDB
#include <sys/pte.h>
#include <vm/hat_sfmmu.h>
#include <sys/memlist_impl.h>

static processorid_t cif_cpu;
static struct translation *cif_prom_trans;
static size_t cif_prom_ntrans;

int cif_cpu_mp_ready;
int (*prom_cif_handler)(void *) = NULL;

extern struct memlist *phys_avail;
extern struct vnode promvp;
extern void kdi_tlb_page_unlock(caddr_t, int);

#define COMBINE(hi, lo) (((uint64_t)(uint32_t)(hi) << 32) | (uint32_t)(lo))
#define OFW_PT_START_ADDR       0xfffffffc00000000      /* OBP PT start */
#define OFW_PT_END_ADDR         0xffffffffffffffff      /* OBP PT end */

#define PROM_ADDR(a)    (((a) >= OFW_START_ADDR && (a) <= OFW_END_ADDR) || \
                        ((a) >= OFW_PT_START_ADDR && (a) <= OFW_PT_END_ADDR))
#endif

#ifdef DEBUG
uint_t cif_debug;
int prom_free_debug;
#define PMFREE_DEBUG(args...) if (prom_free_debug) printf(args)
#else
#define PMFREE_DEBUG(args...)
#endif

extern int (*cif_handler)(void *);

typedef struct {
        char            *name;
        cif_func_t      func;
} cif_callback_t;

static cif_callback_t cb_table[] = {
        { "getprop",                    promif_getprop              },
        { "getproplen",                 promif_getproplen           },
        { "nextprop",                   promif_nextprop             },
        { "peer",                       promif_nextnode             },
        { "child",                      promif_childnode            },
        { "parent",                     promif_parentnode           },
        { "enter",                      promif_enter_mon            },
        { "exit",                       promif_exit_to_mon          },
        { "boot",                       promif_reboot               },
        { "write",                      promif_write                },
        { "read",                       promif_read                 },
        { "interpret",                  promif_interpret            },
        { "finddevice",                 promif_finddevice           },
        { "instance-to-package",        promif_instance_to_package  },
#ifndef _KMDB
        { "setprop",                    promif_setprop              },
        { "test",                       promif_test                 },
        { "instance-to-path",           promif_instance_to_path     },
        { "SUNW,power-off",             promif_power_off            },
        { "SUNW,asr-list-keys-len",     promif_asr_list_keys_len    },
        { "SUNW,asr-list-keys",         promif_asr_list_keys        },
        { "SUNW,asr-export-len",        promif_asr_export_len       },
        { "SUNW,asr-export",            promif_asr_export           },
        { "SUNW,set-security-key",      promif_set_security_key     },
        { "SUNW,get-security-key",      promif_get_security_key     },
        { "SUNW,start-cpu-by-cpuid",    promif_start_cpu            },
        { "SUNW,set-trap-table",        promif_set_mmfsa_traptable  },
        { "SUNW,set-sun4v-api-version", promif_set_sun4v_api_version },
        { "SUNW,get-sun4v-api-version", promif_get_sun4v_api_version },
#endif
        { NULL,                         NULL                        }
};

cif_func_t
promif_find_cif_callback(char *opname)
{
        cif_callback_t  *cb;

        if (opname == NULL)
                return (NULL);

        for (cb = cb_table; cb->name; cb++) {
                if (prom_strcmp(cb->name, opname) == 0)
                        break;
        }

        return (cb->func);
}

static int
kern_cif_handler(void *p)
{
        cell_t          *ci = (cell_t *)p;
        char            *opname;
        cif_func_t      func;
        int             rv;

        ASSERT(cif_handler == kern_cif_handler);

#ifndef _KMDB
        cif_cpu = getprocessorid();
#endif

        opname = p1275_cell2ptr(ci[0]);

        /* lookup the callback for the desired operation */
        func = promif_find_cif_callback(opname);

        if (func == NULL) {
#ifdef _KMDB
                prom_fatal_error("sun4v unsupported CIFs\n");
#else
                cmn_err(CE_CONT, "!sun4v unsupported CIF: %s\n", opname);
                return (-1);
#endif
        }

        /* callback found, execute it */
        rv = func(p);

#ifndef _KMDB
        cif_cpu = -1;
#endif

        return (rv);
}

#ifdef _KMDB

void
cif_init(char *pgmname, caddr_t root, ihandle_t in, ihandle_t out,
    phandle_t pin, phandle_t pout, pnode_t chosen, pnode_t options)
{
        /* initialize pointer to a copy of OBP device tree */
        promif_stree_setroot(root);

        promif_set_nodes(chosen, options);

        /* initialize io parameters */
        promif_io_init(in, out, pin, pout);

        /*
         * Switch CIF handler to the kernel.
         */
        if (pgmname != NULL)
                prom_init(pgmname, (void *)kern_cif_handler);
        else
                cif_handler = kern_cif_handler;
}

#else

static struct translation *
read_prom_mappings(size_t *ntransp)
{
        char *prop = "translations";
        pnode_t node;
        size_t translen;
        ihandle_t immu;
        struct translation *transroot;

        *ntransp = 0;

        /*
         * the "translations" property is associated with the mmu node
         */
        if ((immu = prom_mmu_ihandle()) == (ihandle_t)-1) {
                PMFREE_DEBUG("no mmu ihandle");
                return (NULL);
        }
        node = (pnode_t)prom_getphandle(immu);
        if (node == OBP_NONODE || node == OBP_BADNODE) {
                PMFREE_DEBUG("no mmu node");
                return (NULL);
        }

        if ((translen = prom_getproplen(node, prop)) == -1) {
                PMFREE_DEBUG("no translations property");
                return (NULL);
        }
        transroot = (struct translation *)kmem_zalloc(translen, KM_SLEEP);

        if (prom_getprop(node, prop, (caddr_t)transroot) == -1) {
                PMFREE_DEBUG("translations getprop failed");
                kmem_free(transroot, translen);
                return (NULL);
        }
        *ntransp = translen / sizeof (*transroot);

        return (transroot);
}

static void
unmap_prom_mappings(struct translation *transroot, size_t ntransroot)
{
        int i, j, rv;
        int npgs, nunmapped, nfreed, nskipped, nskipped_io;
        char *p;
        tte_t tte;
        pfn_t pfn;
        page_t *pp;
        uint64_t vaddr;
        struct translation *promt;
        cpuset_t other_cpus;

        /*
         * During startup isa_list is allocated in OBP address space
         * so it needs to be re-allocated in kernel address space
         * before OBP memory is unmapped.
         *
         * see cpu_setup_common().
         */
        p = kmem_zalloc(strlen(isa_list) + 1, KM_SLEEP);
        (void) strcpy(p, isa_list);
        isa_list = p;

        nfreed = 0;
        nunmapped = 0;
        nskipped = 0;
        nskipped_io = 0;

        for (i = 0, promt = transroot; i < ntransroot; i++, promt++) {
                ASSERT(promt->tte_hi != 0);
                ASSERT32(promt->virt_hi == 0 && promt->size_hi == 0);

                vaddr = COMBINE(promt->virt_hi, promt->virt_lo);

                if (!PROM_ADDR(vaddr)) {
                        nskipped++;
                        continue;
                }

                npgs = mmu_btopr(COMBINE(promt->size_hi, promt->size_lo));

                if (npgs > 1) {
                        PMFREE_DEBUG("large trans vaddr=0x%lx, npgs=%d\n",
                            vaddr, npgs);
                }
                for (j = 0; j < npgs; j++) {

                        pfn = sfmmu_vatopfn((caddr_t)vaddr, KHATID, &tte);

                        if (pfn == PFN_INVALID) {
                                tte.tte_inthi = promt->tte_hi;
                                tte.tte_intlo = promt->tte_lo;
                                pfn = TTE_TO_PFN((caddr_t)COMBINE(
                                    promt->virt_hi, promt->virt_lo), &tte);
                                PMFREE_DEBUG(
                                    "no mapping for vaddr=0x%lx (opfn=0x%lx)\n",
                                    vaddr, pfn);
                                break;
                        }
                        ASSERT(!TTE_IS_LOCKED(&tte));
                        ASSERT(TTE_IS_8K(&tte));

                        /*
                         * Unload the current mapping for the pfn and
                         * if it is the last mapping for a memory page,
                         * free the page.
                         */
                        PMFREE_DEBUG("unmap vaddr=0x%lx pfn=0x%lx", vaddr, pfn);

                        hat_unload(kas.a_hat, (caddr_t)vaddr, PAGESIZE,
                            HAT_UNLOAD_UNLOCK);

                        if (pf_is_memory(pfn)) {
                                pp = page_numtopp_nolock(pfn);
                                PMFREE_DEBUG(" pp=0x%p", (void *)pp);
                                ASSERT(pp);
                                ASSERT(PAGE_EXCL(pp));
                                ASSERT(PP_ISNORELOC(pp));
                                ASSERT(!PP_ISFREE(pp));
                                ASSERT(page_find(&promvp, pfn));
                                ASSERT(page_get_pagecnt(pp->p_szc) == 1);

                                if (pp->p_mapping) {
                                        PMFREE_DEBUG(" skip\n");
                                } else {
                                        PP_CLRNORELOC(pp);
                                        page_destroy(pp, 0);
                                        memlist_write_lock();
                                        rv = memlist_add_span(pfn << PAGESHIFT,
                                            PAGESIZE, &phys_avail);
                                        ASSERT(rv == MEML_SPANOP_OK);
                                        memlist_write_unlock();
                                        PMFREE_DEBUG(" free\n");
                                        nfreed++;
                                }
                        } else {
                                nskipped_io++;
                                PMFREE_DEBUG(" skip IO\n");
                        }
                        nunmapped++;
                        vaddr += PAGESIZE;
                }
        }

        if (transroot) {
                PMFREE_DEBUG(
                    "nunmapped=%d nfreed=%d nskipped=%d nskipped_io=%d\n",
                    nunmapped, nfreed, nskipped, nskipped_io);
                kmem_free(transroot, ntransroot * sizeof (*transroot));
        }

        /*
         * Unload OBP permanent mappings.
         */
        kdi_tlb_page_unlock((caddr_t)OFW_START_ADDR, 1);
        kpreempt_disable();
        other_cpus = cpu_ready_set;
        CPUSET_DEL(other_cpus, CPU->cpu_id);
        xt_some(other_cpus, vtag_unmap_perm_tl1, (uint64_t)OFW_START_ADDR,
            KCONTEXT);
        kpreempt_enable();
}

static void cache_prom_data(void);

/*
 * This function returns 1 if the current thread is executing in
 * the CIF and 0 otherwise. This is useful information to know
 * since code that implements CIF handlers can assume that it has
 * gone through the kern_preprom() entry point, implying it is
 * running single threaded, has preemption disabled, etc.
 */
int
promif_in_cif(void)
{
        int     mycpuid = getprocessorid();

        return ((cif_cpu == mycpuid) ? 1 : 0);
}

/*
 * Check that all cpus in the MD are within range (< NCPU).  Attempt
 * to stop any that aren't.
 */
static void
cif_check_cpus(void)
{
        md_t            *mdp;
        mde_cookie_t    rootnode;
        size_t          listsz;
        int             i;
        mde_cookie_t    *listp = NULL;
        int             num_nodes;
        uint64_t        cpuid;
        int             status;

        mdp = md_get_handle();
        ASSERT(mdp);

        rootnode = md_root_node(mdp);
        ASSERT(rootnode != MDE_INVAL_ELEM_COOKIE);

        num_nodes = md_node_count(mdp);
        ASSERT(num_nodes > 0);

        listsz = num_nodes * sizeof (mde_cookie_t);
        listp = kmem_zalloc(listsz, KM_SLEEP);

        num_nodes = md_scan_dag(mdp, rootnode, md_find_name(mdp, "cpu"),
            md_find_name(mdp, "fwd"), listp);

        if (num_nodes <= 0)
                goto done;

        for (i = 0; i < num_nodes; i++) {
                if (md_get_prop_val(mdp, listp[i], "id", &cpuid)) {
                        cmn_err(CE_WARN, "cif_check_cpus: "
                            "CPU instance %d has no 'id' property", i);
                        continue;
                }

                mutex_enter(&cpu_lock);

                if (cpuid >= NCPU) {
                        status = stopcpu_bycpuid(cpuid);
                        if (status != 0 && status != ENOTSUP)
                                cmn_err(CE_PANIC, "failed to stop cpu %lu (%d)",
                                    cpuid, status);
                }

                mutex_exit(&cpu_lock);
        }

done:
        kmem_free(listp, listsz);
        (void) md_fini_handle(mdp);
}

void
cif_init(void)
{
        void (*kmdb_cb)(void);
        uint64_t rtba;
        uint64_t rv;
        size_t ntransroot;
        struct translation *transroot;

        /*
         * Check if domaining is enabled. If not, do not
         * initialize the kernel CIF handler.
         */
        if (!domaining_enabled())
                return;

        transroot = read_prom_mappings(&ntransroot);

        /*
         * Cache PROM data that is needed later, e.g. a shadow
         * copy of the device tree, IO mappings, etc.
         */
        cache_prom_data();

        /*
         * Prepare to take over the get/set of environmental variables.
         */
        promif_prop_init();

        /*
         * Switch CIF handler to the kernel.
         */
        prom_cif_handler = cif_handler;

        promif_preprom();
        cif_handler = kern_cif_handler;

        /*
         * Take over rtba for the boot CPU. The rtba for
         * all other CPUs are set as they enter the system.
         */
        rtba = va_to_pa(&trap_table);
        if ((rv = hv_cpu_set_rtba(&rtba)) != H_EOK)
                panic("hv_cpu_set_rtba failed: %ld\n", rv);

        promif_postprom();

        /*
         * If the system has been booted with kmdb we need kmdb to
         * use the kernel cif handler instead of the PROM cif handler.
         */
        if (boothowto & RB_KMDB) {
                kmdb_cb = (void (*)(void))modlookup("misc/kmdbmod",
                    "kctl_switch_promif");
                ASSERT(kmdb_cb != NULL);
                (*kmdb_cb)();
        }

        cif_check_cpus();

        if (transroot != NULL)
                unmap_prom_mappings(transroot, ntransroot);
}

static void
cache_prom_data(void)
{
        /* initialize copy of OBP device tree */
        promif_stree_init();

        /* initialize io parameters */
        promif_io_init();
}

#endif  /* _KMDB */