/*
 * 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 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident   "%Z%%M% %I%     %E% SMI"

#include <sys/types.h>
#include <sys/machsystm.h>
#include <sys/machparam.h>
#include <sys/cmn_err.h>
#include <sys/cpuvar.h>
#include <sys/note.h>
#include <sys/hypervisor_api.h>
#include <sys/lpad.h>

typedef struct {
        uint64_t        inuse;
        uint64_t        buf[LPAD_SIZE / sizeof (uint64_t)];
} lpad_t;

/*
 * A global pool of landing pad memory. Currently, CPUs are only
 * brought into the system one at a time, so the pool is only a
 * single landing pad. In the future, it may be desirable to bring
 * CPUs into the systems in parallel. At that time, the size of
 * the pool can be increased by changing the pool size constant.
 */
#define LPAD_POOL_SIZE  1

static lpad_t   lpad_pool[LPAD_POOL_SIZE];

#ifdef DEBUG
static int lpad_dbg = 0;

#define LPAD_DBG                if (lpad_dbg) printf
#define LPAD_DUMP_DATA          lpad_dump_data

static void lpad_dump_data(uint64_t *lpd_start, uint64_t *lpd_end);

#else /* DEBUG */

#define LPAD_DBG                _NOTE(CONSTCOND) if (0) printf
#define LPAD_DUMP_DATA
#endif /* DEBUG */

extern void mach_cpu_startup(uint64_t rabase, uint64_t memsize);
extern void mach_cpu_startup_end(void);
extern int promif_in_cif(void);

static lpad_t *lpad_alloc(void);

uint64_t *
lpad_setup(int cpuid, uint64_t pc, uint64_t arg)
{
        lpad_t          *lpp;
        uint64_t        textsz;
        uint64_t        datasz;
        lpad_data_t     *lpd;
        lpad_map_t      *lpm;

        /* external parameters */
        extern caddr_t  textva;
        extern caddr_t  datava;
        extern tte_t    ktext_tte;
        extern tte_t    kdata_tte;
        extern caddr_t  mmu_fault_status_area;

        LPAD_DBG("lpad_setup...\n");

        if ((cpuid < 0) || (cpuid > NCPU)) {
                cmn_err(CE_PANIC, "lpad_setup: invalid cpuid");
        }

        /* allocate our landing pad */
        if ((lpp = lpad_alloc()) == NULL) {
                cmn_err(CE_PANIC, "lpad_setup: unable to allocate lpad");
        }

        /* calculate the size of our text */
        textsz = (uint64_t)mach_cpu_startup_end - (uint64_t)mach_cpu_startup;

        LPAD_DBG("lpad textsz=%ld\n", textsz);

        ASSERT(textsz <= LPAD_TEXT_SIZE);

        /* copy over text section */
        bcopy((void *)mach_cpu_startup, lpp->buf, textsz);

        lpd = (lpad_data_t *)(((caddr_t)lpp->buf) + LPAD_TEXT_SIZE);
        lpm = (lpad_map_t *)lpd->map;

        ASSERT(mmu_fault_status_area);

        bzero(lpd, LPAD_TEXT_SIZE);
        lpd->magic = LPAD_MAGIC_VAL;
        lpd->inuse = &(lpp->inuse);
        lpd->mmfsa_ra = va_to_pa(mmu_fault_status_area) + (MMFSA_SIZE * cpuid);
        lpd->pc = pc;
        lpd->arg = arg;

        /*
         * List of mappings:
         *
         *    - permanent inst/data mapping for kernel text
         *    - permanent data mapping for kernel data
         *    - non-permanent inst mapping for kernel data,
         *      required for landing pad text
         */
        lpd->nmap = 3;

        /* verify the lpad has enough room for the data */
        datasz = sizeof (lpad_data_t);
        datasz += (lpd->nmap - 1) * sizeof (lpad_map_t);

        ASSERT(datasz <= LPAD_DATA_SIZE);

        /*
         * Kernel Text Mapping
         */
        lpm->va = (uint64_t)textva;
        lpm->tte = ktext_tte;
        lpm->flag_mmuflags = (MAP_ITLB | MAP_DTLB);
        lpm->flag_perm = 1;
        lpm++;

        /*
         * Kernel Data Mapping
         */
        lpm->va = (uint64_t)datava;
        lpm->tte = kdata_tte;
        lpm->flag_mmuflags = MAP_DTLB;
        lpm->flag_perm = 1;
        lpm++;

        /*
         * Landing Pad Text Mapping
         *
         * Because this mapping should not be permanent,
         * the permanent mapping above cannot be used.
         */
        lpm->va = (uint64_t)datava;
        lpm->tte = kdata_tte;
        lpm->flag_mmuflags = MAP_ITLB;
        lpm->flag_perm = 0;
        lpm++;

        ASSERT(((uint64_t)lpm - (uint64_t)lpd) == datasz);

        LPAD_DBG("copied %ld bytes of data into lpad\n", datasz);

        LPAD_DUMP_DATA((uint64_t *)lpd, (uint64_t *)lpm);

        return (lpp->buf);
}

static lpad_t *
lpad_alloc(void)
{
        int     idx;

        /*
         * No locking is required for the global lpad pool since
         * it should only be accessed while in the CIF which is
         * single threaded. If this assumption changes, locking
         * would be required.
         */
        ASSERT(promif_in_cif());

        /*
         * Wait until an lpad buffer becomes available.
         */
        for (;;) {
                LPAD_DBG("checking lpad pool:\n");

                /* walk the lpad buffer array */
                for (idx = 0; idx < LPAD_POOL_SIZE; idx++) {

                        LPAD_DBG("\tchecking lpad_pool[%d]\n", idx);

                        if (lpad_pool[idx].inuse == 0) {
                                LPAD_DBG("found empty lpad (%d)\n", idx);

                                /* mark the buffer as busy */
                                lpad_pool[idx].inuse = 1;

                                return (&lpad_pool[idx]);
                        }
                }
        }
}

#ifdef DEBUG
static void
lpad_dump_data(uint64_t *lpd_start, uint64_t *lpd_end)
{
        uint64_t        *lp;
        uint_t          offset = 0;

        if (lpad_dbg == 0)
                return;

        printf("lpad data:\n");

        for (lp = lpd_start; lp < lpd_end; lp++) {
                printf("\t0x%02x  0x%016lx\n", offset, *lp);
                offset += sizeof (uint64_t);
        }
}
#endif /* DEBUG */