6324 Add an `ndp' tool for manipulating the neighbors table

[illumos-gate.git] / usr / src / uts / sun4u / io / zuluvm.c

/*
 * 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.
 */

/*
 * zuluvm module
 *
 * Provides services required by the XVR-4000 graphics accelerator (zulu)
 * that are not provided by the ddi. See PSARC 2002/231.
 *
 * Zulu has 2 dma engines with built in MMUs. zuluvm provides TLB miss
 * interrupt support obtaining virtual to physical address translations
 * using the XHAT interface PSARC/2003/517.
 *
 * The module has 3 components. This file, sun4u/vm/zulu_hat.c, and the
 * assembly language routines in sun4u/ml/zulu_asm.s and
 * sun4u/ml/zulu_hat_asm.s.
 *
 * The interrupt handler is a data bearing mondo interrupt handled at TL=1
 * If no translation is found in the zulu hat's tsb, or if the tsb is locked by
 * C code, the handler posts a soft interrupt which wakes up a parked
 * thread belonging to zuludaemon(1M).
 */

#include <sys/conf.h>
#include <sys/types.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/modctl.h>
#include <sys/autoconf.h>
#include <sys/ddi_impldefs.h>
#include <sys/ddi_subrdefs.h>
#include <sys/intr.h>
#include <sys/ddi.h>
#include <sys/sunndi.h>
#include <sys/proc.h>
#include <sys/thread.h>
#include <sys/machsystm.h>
#include <sys/ivintr.h>
#include <sys/tnf_probe.h>
#include <sys/intreg.h>
#include <sys/atomic.h>
#include <vm/as.h>
#include <vm/seg_enum.h>
#include <vm/faultcode.h>
#include <sys/dmv.h>
#include <sys/zulumod.h>
#include <sys/zulu_hat.h>

#define ZULUVM_GET_PAGE(val) \
        (caddr_t)((uintptr_t)(val) & PAGEMASK)
#define ZULUVM_GET_AS   curthread->t_procp->p_as

#define ZULUVM_LOCK   mutex_enter(&(zdev->dev_lck))
#define ZULUVM_UNLOCK mutex_exit(&(zdev->dev_lck))

#define ZULUVM_SET_STATE(_z, b, c) \
        atomic_cas_32((uint32_t *)&((_z)->zvm.state), c, b)
#define ZULUVM_GET_STATE(_z) \
        (_z)->zvm.state
#define ZULUVM_SET_IDLE(_z) \
        (_z)->zvm.state = ZULUVM_STATE_IDLE;

#define ZULUVM_INO_MASK ((1<<INO_SIZE)-1)
#define ZULUVM_IGN_MASK ((1<<IGN_SIZE)-1)
#define ZULUVM_MONDO(_zdev, _n) \
        ((ZULUVM_IGN_MASK & _zdev->agentid) << INO_SIZE) | \
        (ZULUVM_INO_MASK & (_n))

static void zuluvm_stop(zuluvm_state_t *, int, char *);
static zuluvm_proc_t *zuluvm_find_proc(zuluvm_state_t *, struct as *);
static int zuluvm_proc_release(zuluvm_state_t *zdev, zuluvm_proc_t *proc);
static int zuluvm_get_intr_props(zuluvm_state_t *zdev, dev_info_t *devi);
static int zuluvm_driver_attach(zuluvm_state_t *);
static int zuluvm_driver_detach(zuluvm_state_t *);
static void zuluvm_retarget_intr(void *arg);
static void zuluvm_do_retarget(zuluvm_state_t *zdev);

extern const unsigned int _mmu_pageshift;

extern int zuluvm_base_pgsize;
static int zuluvm_pagesizes[ZULUM_MAX_PG_SIZES + 1];

int zuluvm_fast_tlb = 1;

zuluvm_state_t *zuluvm_devtab[ZULUVM_MAX_DEV];
kmutex_t zuluvm_lck;

#ifdef DEBUG
int zuluvm_debug_state = 0;
#endif

unsigned long zuluvm_ctx_locked = 0;

/*
 * Module linkage information for the kernel.
 */
extern struct mod_ops mod_miscops;

static struct modlmisc modlmisc = {
        &mod_miscops,
        "sun4u support " ZULUVM_MOD_VERSION
};

static struct modlinkage modlinkage = {
        MODREV_1,
        (void *)&modlmisc,
        NULL
};

int
_init(void)
{
        zuluvm_base_pgsize = (_mmu_pageshift - 13) / 3;
        if (zulu_hat_init() != 0) {
                return (ZULUVM_ERROR);
        }
        mutex_init(&zuluvm_lck, NULL, MUTEX_DEFAULT, NULL);
        return (mod_install(&modlinkage));
}

int
_fini(void)
{
        mutex_destroy(&zuluvm_lck);
        (void) zulu_hat_destroy();
        return (mod_remove(&modlinkage));
}

int
_info(struct modinfo *modinfop)
{
        return (mod_info(&modlinkage, modinfop));
}

/*
 * currently the kernel driver makes the following assumptions:
 * - there is only one TLB miss per zulu device handled at
 *   any given time
 *   ==> we only need local data storage per device, not per DMA
 *   ==> a page fault will block the DMA engine until the fault
 *       is resolved
 *   ==> a pagefault will not trigger a zulu DMA context switch
 *
 * If we want to implement asynnchronous zulu page fault, then we
 * need to keep track of outstanding faults while zulu DMA runs
 * in a different context.
 */
static int
zuluvm_write_tte(zuluvm_state_t *zdev, void *arg, caddr_t addr,
    int t_pfn, int t_perm, int t_size, uint64_t tag,
    int tlbtype, int *size)
{
        int error;

        (void) addr;

        ZULUVM_STATS_MISS(zdev, t_size);

        if (tag == 0) { /* not coming from preload */
                int state = ZULUVM_SET_STATE(zdev, ZULUVM_STATE_WRITE_TTE,
                                ZULUVM_STATE_INTR_PENDING);
                if (state != ZULUVM_STATE_INTR_PENDING) {
                        zuluvm_stop(zdev, state, "zuluvm_write_tte");
                        return (ZULUVM_MISS_CANCELED);
                }
        }

        if (!(tlbtype & ZULUVM_ITLB_FLAG) &&
            t_size != zuluvm_base_pgsize &&
            t_size != ZULU_TTE4M) {
                t_size = zuluvm_base_pgsize;
                TNF_PROBE_2(zuluvm_write_tte_new_pfn, "zuluvm", /* */,
                    tnf_opaque, t_pfn, t_pfn, tnf_int, pagesize, t_size);
        }
        TNF_PROBE_1(zuluvm_write_tte, "zuluvm", /* */,
            tnf_opaque, t_pfn, t_pfn);
        /*
         * if the caller is zuluvm_preload, then we need to pass
         * back the page size so it can add the right offset.
         */
        if (size)
                *size = t_size;

        error = zulud_write_tte(zdev, arg, t_size, tag, t_pfn,
                    t_perm, tlbtype);

        return (error);
}

static void
zuluvm_stop(zuluvm_state_t *zdev, int state, char *tag)
{
        int ostate = state;
        while (state != ZULUVM_STATE_STOPPED) {
                state = ZULUVM_SET_STATE(zdev,
                            ZULUVM_STATE_STOPPED, state);
#ifdef DEBUG
                if (zuluvm_debug_state)
                        cmn_err(CE_NOTE, "zuluvm_stop(%s): (loop) state %d\n",
                            tag, state);
#endif
        }
        TNF_PROBE_2(zuluvm_stop, "zuluvm", /* */,
            tnf_string, tag, tag,
            tnf_int, state, ostate);
        ZULUVM_STATS_CANCEL(zdev);
}

/*
 * Executed with the context of the parked zulu deamon thread,
 * uses zulu_hat_load to resolve the miss.
 * The tte is loaded and miss done called by the function zuluvm_load_tte
 * which is called from zulu_hat
 *
 * This function is synchronized with the zuluvm_as_free.
 * zuluvm_as_free will block until miss servicing is complete.
 *
 * There is a race condition between as_free and the zulu tlb miss
 * soft interrupt:
 *      - queue zulu interrupt
 *      - process dies, as_free runs
 *      - interrupt gets scheduled and runs as_fault on the
 *        already freed as.
 * This is solved by keeping track of current zulu dma processes
 * and invalidating them in zuluvm_as_free.
 */
uint_t
zuluvm_tlb_handler(caddr_t data)
{
        zuluvm_state_t *zdev = (zuluvm_state_t *)data;
        int     error;
        int     flag = 0;
        int     wait = 0;
        zuluvm_proc_t *proc = NULL;
        struct zulu_hat *zhat = NULL;
        caddr_t addr;
        int     tlbtype;
        void    *arg;
        int     state, newstate;

        TNF_PROBE_1(zuluvm_tlb_handler_lwp, "zuluvm", /* */,
            tnf_opaque, lwp, ttolwp(curthread));

        ZULUVM_LOCK;
        error   = ZULUVM_GET_TLB_ERRCODE(zdev);
        addr    = (caddr_t)ZULUVM_GET_TLB_ADDR(zdev);
        tlbtype = ZULUVM_GET_TLB_TYPE(zdev);
        arg = zdev->zvm.arg;

        /*
         * select the correct dma engine and remember the
         * the as_free synchronization flags.
         */
        switch (tlbtype) {
        case ZULUVM_ITLB1:
        case ZULUVM_DMA1:
                proc = zdev->zvm.proc1;
                flag |= ZULUVM_DO_INTR1;
                wait |= ZULUVM_WAIT_INTR1;
                break;
        case ZULUVM_ITLB2:
        case ZULUVM_DMA2:
                proc = zdev->zvm.proc2;
                flag |= ZULUVM_DO_INTR2;
                wait |= ZULUVM_WAIT_INTR2;
                break;
        }

        state = ZULUVM_SET_STATE(zdev, ZULUVM_STATE_INTR_PENDING,
                    ZULUVM_STATE_INTR_QUEUED);
        newstate = ZULUVM_GET_STATE(zdev);

        TNF_PROBE_2(zuluvm_tlb_handler_state, "zuluvm", /* */,
            tnf_int, oldstate, state,
            tnf_int, newstate, newstate);
#ifdef DEBUG
        if (zuluvm_debug_state)
                cmn_err(CE_NOTE, "zuluvm_tlb_handler: state %d\n", state);
#endif
        if (state != ZULUVM_STATE_INTR_PENDING &&
                state != ZULUVM_STATE_INTR_QUEUED) {
                ZULUVM_UNLOCK;

                zuluvm_stop(zdev, state, "softintr1");
                zulud_tlb_done(zdev, arg, tlbtype, ZULUVM_MISS_CANCELED);
                return (1);
        }

        /*
         * block the as_free callback in case it comes in
         */
        zdev->intr_flags |= flag;
        ZULUVM_UNLOCK;

        mutex_enter(&zdev->proc_lck);
        /*
         * check if this as is still valid
         */
        if (proc == NULL || proc->valid == 0 || proc->zhat == NULL) {
                mutex_exit(&zdev->proc_lck);
                /*
                 * we are on our way out, wake up the as_free
                 * callback if it is waiting for us
                 */
                ZULUVM_LOCK;
                zdev->intr_flags &= ~flag;
                if (zdev->intr_flags | wait)
                        cv_broadcast(&zdev->intr_wait);
                ZULUVM_UNLOCK;
                state = ZULUVM_SET_STATE(zdev, ZULUVM_STATE_IDLE,
                            ZULUVM_STATE_INTR_PENDING);
                if (state != ZULUVM_STATE_INTR_PENDING) {
                        zuluvm_stop(zdev, state, "softintr3");
                }
                zulud_tlb_done(zdev, arg, tlbtype, ZULUVM_NO_HAT);
                return (1);
        }
        zhat = proc->zhat;
        mutex_exit(&zdev->proc_lck);

        TNF_PROBE_1(zuluvm_tlb_handler, "zuluvm", /* */,
            tnf_opaque, addr, addr);

        switch (error) {
        case ZULUVM_CTX_LOCKED:
                /*
                 * trap handler found that zulu_hat had the lock bit set
                 * rather than block in the fast trap handler, it punts
                 * in this rare instance
                 */
                ++zuluvm_ctx_locked;
                TNF_PROBE_1(zuluvm_ctx_locked, "zuluvm", /* CSTYLED */,
                        tnf_ulong, zuluvm_ctx_locked, zuluvm_ctx_locked);

                /*FALLTHROUGH*/

        case ZULUVM_TTE_DELAY:
                /*
                 * fast tlb handler was skipped, see zuluvm_fast_tlb flag
                 */
                /*FALLTHROUGH*/

        case ZULUVM_NO_TTE:
                /*
                 * no TSB entry and TTE in the hash
                 */
                mutex_enter(&zdev->load_lck);
                zdev->in_intr = 1;
                error = zulu_hat_load(zhat,  addr,
                        (tlbtype == ZULUVM_DMA2) ? S_WRITE : S_READ, NULL);
                zdev->in_intr = 0;
                mutex_exit(&zdev->load_lck);
                if (error) {

                        error = ZULUVM_NO_MAP;
                } else {
                        error = ZULUVM_SUCCESS;
                        TNF_PROBE_1(zuluvm_tlb_handler_done, "zuluvm", /* */,
                                    tnf_int, error, error);
                        return (1);
                }

        default:
                /*
                 * error case, fall through and tell zulu driver to abort DMA
                 */
                break;
        }

        if (error != ZULUVM_MISS_CANCELED) {
                state = ZULUVM_SET_STATE(zdev, ZULUVM_STATE_IDLE,
                            ZULUVM_STATE_WRITE_TTE);
                newstate = ZULUVM_GET_STATE(zdev);
                TNF_PROBE_2(zuluvm_tlb_handler_state_done, "zuluvm", /* */,
                    tnf_int, oldstate, state,
                    tnf_int, newstate, newstate);
                if (state != ZULUVM_STATE_WRITE_TTE) {
                        zuluvm_stop(zdev, state, "softintr4");
                }
        }
        /*
         * synchronize with as_free callback
         * It will set the wait flag, in that case we send
         * a wake up.
         */
        ZULUVM_LOCK;
        zdev->intr_flags &= ~flag;
        if (zdev->intr_flags | wait)
                cv_broadcast(&zdev->intr_wait);
        ZULUVM_UNLOCK;

        TNF_PROBE_1(zuluvm_tlb_handler_done, "zuluvm", /* */,
            tnf_int, error, error);

        zulud_tlb_done(zdev, arg, tlbtype, error);

        return (1);
}


void
zuluvm_load_tte(struct zulu_hat  *zhat, caddr_t addr, uint64_t pfn,
                int perm, int size)
{
        zuluvm_state_t *zdev = zhat->zdev;
        int             tlbtype = ZULUVM_GET_TLB_TYPE(zdev);

        ASSERT(MUTEX_HELD(&zdev->load_lck));
        ASSERT(pfn != 0);

        if (zdev->in_intr) {
                int             error;
                int             flag = 0;
                int             wait = 0;

                error = zuluvm_write_tte(zdev, zdev->zvm.arg, addr, pfn,
                                        perm, size, 0, tlbtype, NULL);

                if (error != ZULUVM_MISS_CANCELED) {
                        int     state, newstate;

                        state = ZULUVM_SET_STATE(zdev, ZULUVM_STATE_IDLE,
                                    ZULUVM_STATE_WRITE_TTE);
                        newstate = ZULUVM_GET_STATE(zdev);
                        TNF_PROBE_2(zuluvm_tlb_handler_state_done, "zuluvm",
                                    /* */, tnf_int, oldstate, state,
                                    tnf_int, newstate, newstate);
                        if (state != ZULUVM_STATE_WRITE_TTE) {
                                zuluvm_stop(zdev, state, "softintr4");
                        }
                }
                /*
                 * synchronize with as_free callback
                 * It will set the wait flag, in that case we send
                 * a wake up.
                 */
                switch (tlbtype) {
                case ZULUVM_ITLB1:
                case ZULUVM_DMA1:
                        flag = ZULUVM_DO_INTR1;
                        wait = ZULUVM_WAIT_INTR1;
                        break;
                case ZULUVM_ITLB2:
                case ZULUVM_DMA2:
                        flag = ZULUVM_DO_INTR2;
                        wait = ZULUVM_WAIT_INTR2;
                        break;
                }

                ZULUVM_LOCK;
                zdev->intr_flags &= ~flag;
                if (zdev->intr_flags | wait)
                        cv_broadcast(&zdev->intr_wait);
                ZULUVM_UNLOCK;

                zulud_tlb_done(zdev, zdev->zvm.arg, tlbtype, error);
        } else {
                (void) zuluvm_write_tte(zdev, zdev->zvm.arg, addr, pfn,
                                        perm, size, (uint64_t)addr |
                                        zhat->zulu_ctx, tlbtype, NULL);
        }
}




/*
 * This function provides the faulting thread for zulu page faults
 * It is call from the device driver in response to an ioctl issued
 * by a zuludaemon thread.
 * It sits in cv_wait_sig until it gets woken up by a signal or
 * zulu tlb miss soft interrupt.
 */
int
zuluvm_park(zuluvm_info_t devp)
{
        int rval;
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;
        mutex_enter(&zdev->park_lck);
        zdev->parking = 1;
        for (;;) {
                rval = cv_wait_sig(&zdev->park_cv, &zdev->park_lck);
                if (rval == 0)
                        break;
                rval = zuluvm_tlb_handler(devp);
        }
        zdev->parking = 0;
        mutex_exit(&zdev->park_lck);
        return (rval);
}

/*
 * zulu soft interrupt handler, just triggers the parked zulu fault
 * thread
 */
/*ARGSUSED*/
uint_t
zuluvm_softintr(caddr_t devp, caddr_t arg2)
{
        int tlbtype;
        void *arg;
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;
        mutex_enter(&zdev->park_lck);
        if (zdev->parking) {
                cv_signal(&zdev->park_cv);
                mutex_exit(&zdev->park_lck);
                TNF_PROBE_1(zuluvm_fast_intr, "zuluvm", /* */,
                    tnf_opaque, devp, devp);
        } else {
                mutex_exit(&zdev->park_lck);
                cmn_err(CE_NOTE, "zuluvm: no page fault thread\n");
                ZULUVM_LOCK;
                tlbtype = ZULUVM_GET_TLB_TYPE(zdev);
                arg = zdev->zvm.arg;
                ZULUVM_UNLOCK;
                TNF_PROBE_0(zuluvm_fast_intr, "zuluvm", /* */);
                zuluvm_stop(zdev, ZULUVM_STATE_INTR_QUEUED, "fast_intr");
                zulud_tlb_done(zdev, arg, tlbtype, ZULUVM_NO_TTE);
        }
        return (1);
}

/* ***** public interface for process mapping events (hat layer) ***** */

/*
 * If the page size matches the Zulu page sizes then just pass
 * it thru. If not then emulate the page demap with demaps of
 * smaller page size.
 */
/* ARGSUSED */
void
zuluvm_demap_page(void *arg, struct hat *hat_ptr, short ctx,
    caddr_t vaddr, uint_t size)
{
        void *ddarg;
        zuluvm_state_t *zdev = (zuluvm_state_t *)arg;

        if (arg == NULL)
                return;

        ZULUVM_STATS_DEMAP_PAGE(zdev);

        ddarg = zdev->zvm.arg;

        TNF_PROBE_3(zuluvm_demap_page, "zuluvm", /* */,
            tnf_opaque, addr, vaddr,
            tnf_int, size, size,
            tnf_int, ctx, ctx);

        if (ddarg != NULL) {
                if (size != zuluvm_base_pgsize &&
                    size != ZULU_TTE4M) {
                        int i;
                        int cnt = size - zuluvm_base_pgsize;
                        cnt = ZULU_HAT_SZ_SHIFT(cnt);
                        for (i = 0; i < cnt; i++) {
                                uintptr_t addr = (uintptr_t)vaddr |
                                    i << ZULU_HAT_BP_SHIFT;
                                zulud_demap_page(zdev, ddarg,
                                                (caddr_t)addr, ctx);
                        }
                } else {
                        zulud_demap_page(zdev, ddarg, vaddr, ctx);
                }
                TNF_PROBE_0(zuluvm_demap_page_done, "zuluvm", /* */);
        } else {
                TNF_PROBE_0(zuluvm_demap_page_null_ddarg, "zuluvm", /* */);
        }
}

/*
 * An entire context has gone away, just pass it thru
 */
void
zuluvm_demap_ctx(void *arg, short ctx)
{
        void *ddarg;
        zuluvm_state_t *zdev = (zuluvm_state_t *)arg;

        if (arg == NULL)
                return;

        ZULUVM_STATS_DEMAP_CTX(zdev);

        TNF_PROBE_1(zuluvm_demap_ctx, "zuluvm", /* */,
            tnf_int, ctx, ctx);
        ddarg = zdev->zvm.arg;

        if (ddarg != NULL)
                zulud_demap_ctx(zdev, ddarg, ctx);
}

static int
zuluvm_driver_attach(zuluvm_state_t *zdev)
{
        int i;
        mutex_enter(&zuluvm_lck);
        for (i = 0; i < ZULUVM_MAX_DEV; i++) {
                if (zuluvm_devtab[i] == NULL) {
                        zuluvm_devtab[i] = zdev;
                        ZULUVM_SET_IDLE(zdev);
                        break;
                }
        }
        mutex_exit(&zuluvm_lck);
        if (i >= ZULUVM_MAX_DEV)
                return (ZULUVM_ERROR);

        if (zulu_hat_attach((void *)zdev) != 0) {
                return (ZULUVM_ERROR);
        }

        mutex_init(&zdev->dev_lck, NULL, MUTEX_DEFAULT, NULL);
        mutex_init(&zdev->load_lck, NULL, MUTEX_DEFAULT, NULL);
        mutex_init(&zdev->proc_lck, NULL, MUTEX_DEFAULT, NULL);
        mutex_init(&zdev->park_lck, NULL, MUTEX_DEFAULT, NULL);
        cv_init(&zdev->park_cv, NULL, CV_DEFAULT, NULL);
        cv_init(&zdev->intr_wait, NULL, CV_DEFAULT, NULL);
        zdev->parking = 0;

#ifdef ZULUVM_STATS
        zdev->zvm.cancel        = 0;
        zdev->zvm.pagefault     = 0;
        zdev->zvm.no_mapping    = 0;
        zdev->zvm.preload       = 0;
        zdev->zvm.migrate       = 0;
        zdev->zvm.pagesize      = 0;
        zdev->zvm.tlb_miss[0]   = 0;
        zdev->zvm.tlb_miss[1]   = 0;
        zdev->zvm.tlb_miss[2]   = 0;
        zdev->zvm.tlb_miss[3]   = 0;
        zdev->zvm.itlb1miss     = 0;
        zdev->zvm.dtlb1miss     = 0;
        zdev->zvm.itlb2miss     = 0;
        zdev->zvm.dtlb2miss     = 0;
#endif
        zdev->zvm.pfncnt = 0;
        for (i = 0; i < 50; i++)
                zdev->zvm.pfnbuf[i] = 0;

        zdev->zvm.mmu_pa        = NULL;
        zdev->zvm.proc1         = NULL;
        zdev->zvm.proc2         = NULL;
        zdev->procs = NULL;
        return (ZULUVM_SUCCESS);
}

static int
zuluvm_driver_detach(zuluvm_state_t *zdev)
{
        int i;
        cv_destroy(&zdev->intr_wait);
        cv_destroy(&zdev->park_cv);
        mutex_destroy(&zdev->park_lck);
        mutex_destroy(&zdev->proc_lck);
        mutex_destroy(&zdev->dev_lck);
        mutex_destroy(&zdev->load_lck);
        zdev->dops = NULL;

        mutex_enter(&zuluvm_lck);
        for (i = 0; i < ZULUVM_MAX_DEV; i++) {
                if (zuluvm_devtab[i] == zdev) {
                        zuluvm_devtab[i] = NULL;
                        break;
                }
        }
        mutex_exit(&zuluvm_lck);

        if (zulu_hat_detach((void *)zdev) == 0) {
                return (ZULUVM_SUCCESS);
        } else {
                return (ZULUVM_ERROR);
        }
}

zulud_ops_t *zuluvm_dops = NULL;

/*
 * init the zulu kernel driver (variables, locks, etc)
 */
int
zuluvm_init(zulud_ops_t *ops, int **pagesizes)
{
        int error = ZULUVM_SUCCESS;
        int i;
        int size = zuluvm_base_pgsize; /* MMU_PAGESIZE; */

        if (ops->version != ZULUVM_INTERFACE_VERSION)
                return (ZULUVM_VERSION_MISMATCH);

        zuluvm_dops = ops;
        for (i = 0; i < ZULUM_MAX_PG_SIZES && size <= ZULU_TTE4M; i++) {
                zuluvm_pagesizes[i] = size++;
        }
        zuluvm_pagesizes[i] = -1;
        *pagesizes = zuluvm_pagesizes;

        return (error);
}

/*
 * cleanup afterwards
 */
int
zuluvm_fini(void)
{
        zuluvm_dops = NULL;
        return (ZULUVM_SUCCESS);
}

/*
 *     allocate a zulu kernel driver instance for this zulu device
 */
int
zuluvm_alloc_device(dev_info_t *devi, void *arg, zuluvm_info_t *devp,
    caddr_t mmu, caddr_t imr)
{
        uint64_t intr_num;
        zuluvm_state_t *zdev;
        int error = ZULUVM_SUCCESS;

        TNF_PROBE_3(zuluvm_alloc_device, "zuluvm", /* */,
            tnf_opaque, arg, arg,
            tnf_opaque, mmu, mmu,
            tnf_opaque, imr, imr);

        zdev = kmem_zalloc(sizeof (zuluvm_state_t), KM_SLEEP);
        zdev->dip = devi;
        zdev->dops = zuluvm_dops;
        error = zuluvm_driver_attach(zdev);
        if (error != ZULUVM_SUCCESS) {
                kmem_free(zdev, sizeof (zuluvm_state_t));
                return (ZULUVM_NO_DEV);
        }

        ZULUVM_LOCK;
        error = zuluvm_get_intr_props(zdev, devi);
        if (error != ZULUVM_SUCCESS) {
                ZULUVM_UNLOCK;
                error = zuluvm_driver_detach(zdev);
                if (error != ZULUVM_SUCCESS)
                        return (error);
                kmem_free(zdev, sizeof (zuluvm_state_t));
                return (ZULUVM_NO_DEV);
        }
        zdev->zvm.arg = arg;
        zdev->zvm.mmu_pa = (uint64_t)va_to_pa((void *)mmu);
        zdev->imr = (uint64_t *)imr;
        zdev->zvm.dmv_intr = dmv_add_softintr(zuluvm_dmv_tlbmiss_tl1,
            (void *)zdev);
        zulud_set_itlb_pc(zdev, arg, DMV_MAKE_DMV(zdev->zvm.dmv_intr,
            (void *)zdev));
        zulud_set_dtlb_pc(zdev, arg, DMV_MAKE_DMV(zdev->zvm.dmv_intr,
            (void *)zdev));
        intr_dist_add(zuluvm_retarget_intr, (void *)zdev);
        zuluvm_do_retarget(zdev);
        intr_num = add_softintr(ZULUVM_PIL, zuluvm_softintr,
            (caddr_t)zdev, SOFTINT_ST);
        zdev->zvm.intr_num = intr_num;
        *devp = (caddr_t)zdev;
        ZULUVM_UNLOCK;
        TNF_PROBE_1(zuluvm_alloc_device_done, "zuluvm", /* */,
            tnf_opaque, devp, *devp);
        return (ZULUVM_SUCCESS);
}

/*
 *    free a zulu kernel driver instance
 */
int
zuluvm_free_device(zuluvm_info_t devp)
{
        int error;
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;

        TNF_PROBE_1(zuluvm_free_device, "zuluvm", /* */,
            tnf_opaque, zdev, zdev);

        if (zdev == NULL)
                return (ZULUVM_NO_DEV);
        ZULUVM_LOCK;
        if (zdev->zvm.arg == NULL) {
                ZULUVM_UNLOCK;
                TNF_PROBE_1(zuluvm_free_device_done, "zuluvm", /* */,
                    tnf_int, error, ZULUVM_NO_DEV);
                return (ZULUVM_NO_DEV);
        }
        (void) dmv_rem_intr(zdev->zvm.dmv_intr);
        (void) rem_softintr(zdev->zvm.intr_num);
        intr_dist_rem(zuluvm_retarget_intr, (void *)zdev);
        zdev->zvm.arg = NULL;
        ZULUVM_UNLOCK;
        error = zuluvm_driver_detach(zdev);
        if (error != ZULUVM_SUCCESS)
                return (error);
        zdev->dops = NULL;
        kmem_free(zdev, sizeof (zuluvm_state_t));

        TNF_PROBE_0(zuluvm_free_device_done, "zuluvm", /* */);
        return (ZULUVM_SUCCESS);
}

/*
 * find the as in the list of active zulu processes
 * The caller has to hold zdev->proc_lck
 */
static zuluvm_proc_t *
zuluvm_find_proc(zuluvm_state_t *zdev, struct as *asp)
{
        zuluvm_proc_t *p;
        TNF_PROBE_2(zuluvm_find_proc, "zuluvm", /* */,
            tnf_opaque, zdev, zdev,
            tnf_opaque, asp, asp);
        for (p = zdev->procs; p != NULL; p = p->next) {
                if (ZULU_HAT2AS(p->zhat) == asp) {
                        TNF_PROBE_1(zuluvm_find_proc_done,
                            "zuluvm", /* */, tnf_opaque, proc, p);
                        return (p);
                }
        }
        TNF_PROBE_0(zuluvm_find_proc_fail, "zuluvm", /* */);
        return (NULL);
}

void
zuluvm_as_free(struct as *as, void *arg, uint_t events)
{
        zuluvm_proc_t *proc = (zuluvm_proc_t *)arg;
        zuluvm_state_t *zdev = proc->zdev;
        int wait = 0;
        int flag = 0;
        int valid;

        (void) events;

        TNF_PROBE_1(zuluvm_as_free, "zuluvm", /* */,
            tnf_opaque, arg, arg);

        (void) as_delete_callback(as, arg);
        /*
         * if this entry is still valid, then we need to sync
         * with zuluvm_tlb_handler rountine.
         */
        mutex_enter(&zdev->proc_lck);
        valid = proc->valid;
        proc->valid = 0;
        mutex_exit(&zdev->proc_lck);

        if (valid) {
                ZULUVM_LOCK;
                if (proc == zdev->zvm.proc1) {
                        flag |= ZULUVM_WAIT_INTR1;
                        wait |= ZULUVM_DO_INTR1;
                }
                if (proc == zdev->zvm.proc2) {
                        flag |= ZULUVM_WAIT_INTR2;
                        wait |= ZULUVM_DO_INTR2;
                }
                if (flag) {
                        zdev->intr_flags |= flag;
                        /*
                         * wait until the tlb miss is resloved
                         */
                        while (zdev->intr_flags & wait) {
                                cv_wait(&zdev->intr_wait, &zdev->dev_lck);
                        }
                        zdev->intr_flags &= ~flag;
                }
                ZULUVM_UNLOCK;
        }

        if (proc->zhat != NULL) {
                /*
                 * prevent any further tlb miss processing for this hat
                 */
                zulu_hat_terminate(proc->zhat);
        }

        /*
         * decrement the ref count and do the appropriate
         * if it drops to zero.
         */
        mutex_enter(&zdev->proc_lck);
        (void) zuluvm_proc_release(zdev, proc);
        mutex_exit(&zdev->proc_lck);
}

/*
 *      notify zulu vm driver about a new process going to
 *      use zulu DMA. Create a zulu_hat.
 */
int
zuluvm_dma_add_proc(zuluvm_info_t devp, uint64_t *cookie)
{
        zuluvm_proc_t *proc;
        int refcnt;
        struct as *asp = ZULUVM_GET_AS;
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;

        TNF_PROBE_1(zuluvm_dma_add_proc, "zuluvm", /* */,
            tnf_opaque, zdev, zdev);
        mutex_enter(&zdev->proc_lck);
        proc = zuluvm_find_proc(zdev, asp);
        if (proc == NULL) {
                proc = kmem_zalloc(sizeof (zuluvm_proc_t), KM_SLEEP);
                proc->zhat = zulu_hat_proc_attach(asp, zdev);
                if (proc->zhat == NULL) {
                        mutex_exit(&zdev->proc_lck);
                        kmem_free(proc, sizeof (zuluvm_proc_t));
                        TNF_PROBE_2(zuluvm_dma_add_proc_done, "zuluvm", /* */,
                            tnf_int, valid, 0,
                            tnf_int, error, ZULUVM_ERROR);
                        return (ZULUVM_ERROR);
                }
                proc->zdev = zdev;
                proc->valid = 1;
                proc->refcnt = 1;
                proc->next = zdev->procs;
                if (zdev->procs)
                        zdev->procs->prev = proc;
                proc->prev = NULL;
                zdev->procs = proc;
                proc->refcnt++;
                (void) as_add_callback(asp, zuluvm_as_free, proc,
                        AS_FREE_EVENT, 0, -1, KM_SLEEP);
        } else {
                if (proc->valid == 0) {
                        mutex_exit(&zdev->proc_lck);
                        TNF_PROBE_2(zuluvm_dma_add_proc_done, "zuluvm", /* */,
                            tnf_int, valid, 0,
                            tnf_int, error, ZULUVM_ERROR);
                        return (ZULUVM_ERROR);
                }
                proc->refcnt++;
        }
        refcnt = proc->refcnt;
        mutex_exit(&zdev->proc_lck);
        *cookie = (uint64_t)proc;
        TNF_PROBE_2(zuluvm_dma_add_proc_done, "zuluvm", /* */,
            tnf_int, refcnt, refcnt,
            tnf_int, error, ZULUVM_SUCCESS);
        return (ZULUVM_SUCCESS);
}

void
zuluvm_proc_hold(zuluvm_state_t *zdev, zuluvm_proc_t *proc)
{
        mutex_enter(&zdev->proc_lck);
        proc->refcnt++;
        mutex_exit(&zdev->proc_lck);
}

/*
 * decrement ref count and free data if it drops to zero
 */
static int
zuluvm_proc_release(zuluvm_state_t *zdev, zuluvm_proc_t *proc)
{
        int refcnt;
        ASSERT(MUTEX_HELD(&zdev->proc_lck));
        refcnt = --proc->refcnt;
        TNF_PROBE_3(zuluvm_proc_release, "zuluvm", /* */,
            tnf_opaque, zdev, zdev,
            tnf_opaque, proc, proc,
            tnf_int, refcnt, refcnt);
        if (refcnt == 0) {
                if (proc->next)
                        proc->next->prev = proc->prev;
                if (proc->prev)
                        proc->prev->next = proc->next;
                else
                        zdev->procs = proc->next;
                kmem_free(proc, sizeof (zuluvm_proc_t));
        }
        return (refcnt);
}

/*
 *      this process is not longer using DMA, all entries
 *      have been removed from the TLB.
 */
int
zuluvm_dma_delete_proc(zuluvm_info_t devp, uint64_t cookie)
{
        int refcnt;
        zuluvm_proc_t *proc = (zuluvm_proc_t *)cookie;
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;

        TNF_PROBE_2(zuluvm_dma_delete_proc, "zuluvm", /* */,
            tnf_opaque, zdev, zdev,
            tnf_opaque, cookie, cookie);
        mutex_enter(&zdev->proc_lck);
        if (proc != NULL) {
                TNF_PROBE_1(zuluvm_dma_delete_proc, "zuluvm", /* */,
                    tnf_opaque, proc, proc);
                if (proc->zhat != NULL) {
                        zulu_hat_proc_detach(proc->zhat);
                        proc->zhat = NULL;
                }
                refcnt = zuluvm_proc_release(zdev, proc);
        }
        mutex_exit(&zdev->proc_lck);

        TNF_PROBE_2(zuluvm_dma_delete_proc_done, "zuluvm", /* */,
            tnf_int, refcnt, refcnt,
            tnf_int, error, ZULUVM_SUCCESS);
        return (ZULUVM_SUCCESS);
}

/*
 * barrier sync for device driver
 * blocks until zuluvm_tlbmiss_tl1 function is done
 */
void
zuluvm_fast_tlb_wait(caddr_t devp)
{
        int state;
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;
        int cnt = 0;

        do {
                state = ZULUVM_GET_STATE(zdev);
                cnt++;
        } while (state == ZULUVM_STATE_TLB_PENDING);
        TNF_PROBE_1(zuluvm_fast_tlb_wait, "zuluvm", /* */,
            tnf_int, loop_cnt, cnt);
}

/*
 *     setup DMA handling for this handle
 */
int
zuluvm_dma_alloc_ctx(zuluvm_info_t devp, int dma, short *mmuctx,
    uint64_t *tsbreg)
{
        struct as       *asp = ZULUVM_GET_AS;
        int             error = ZULUVM_NO_DEV;
        zuluvm_state_t    *zdev = (zuluvm_state_t *)devp;
        int             state, newstate;

        if (asp == NULL) {
                TNF_PROBE_1(zuluvm_dma_alloc_ctx_done, "zuluvm", /* */,
                    tnf_int, error, ZULUVM_NO_HAT);
                return (ZULUVM_NO_HAT);
        }

        *tsbreg = 0;
        state = ZULUVM_SET_STATE(zdev, ZULUVM_STATE_IDLE,
                    ZULUVM_STATE_STOPPED);
        newstate = ZULUVM_GET_STATE(zdev);
        TNF_PROBE_4(zuluvm_dma_alloc_ctx, "zuluvm", /* */,
            tnf_opaque, devp, devp,
            tnf_int, dma, dma,
            tnf_int, oldstate, state,
            tnf_int, newstate, newstate);
#ifdef DEBUG
        if (zuluvm_debug_state)
                cmn_err(CE_NOTE, "zuluvm_dma_alloc_ctx: state %d\n", state);
#endif
        if (state != ZULUVM_STATE_STOPPED && state != ZULUVM_STATE_IDLE) {
                while (state != ZULUVM_STATE_IDLE) {
                        state = ZULUVM_SET_STATE(zdev, ZULUVM_STATE_IDLE,
                                    ZULUVM_STATE_STOPPED);
#ifdef DEBUG
                        if (zuluvm_debug_state)
                                cmn_err(CE_NOTE, "zuluvm_dma_alloc_ctx: (loop)"
                                    " state %d\n", state);
#endif
                        if (state != ZULUVM_STATE_IDLE)
                                delay(1);
                }
        }

        if (zdev->zvm.arg != NULL) {
                struct zulu_hat *zhat;
                zuluvm_proc_t *proc;

                mutex_enter(&zdev->proc_lck);
                proc = zuluvm_find_proc(zdev, asp);
                if (proc != NULL) {
                        zhat = proc->zhat;
                        proc->refcnt++;
                }
                mutex_exit(&zdev->proc_lck);

                switch (dma) {
                case ZULUVM_DMA1:
                        ZULUVM_LOCK;
                        zdev->zvm.proc1 = proc;
                        ZULUVM_UNLOCK;
                        error = ZULUVM_SUCCESS;
                        break;
                case ZULUVM_DMA2:
                        ZULUVM_LOCK;
                        zdev->zvm.proc2 = proc;
                        ZULUVM_UNLOCK;
                        error = ZULUVM_SUCCESS;
                        break;
                default:
                        mutex_enter(&zdev->proc_lck);
                        (void) zuluvm_proc_release(zdev, proc);
                        mutex_exit(&zdev->proc_lck);
                }

                if (error == ZULUVM_SUCCESS) {
                        zulu_hat_validate_ctx(zhat);
                        if (zhat->zulu_ctx >= 0) {
                                *mmuctx = zhat->zulu_ctx;
                        } else {
                                printf("invalid context value: %d\n",
                                        zhat->zulu_ctx);

                                mutex_enter(&zdev->proc_lck);
                                (void) zuluvm_proc_release(zdev, proc);
                                mutex_exit(&zdev->proc_lck);

                                error = ZULUVM_ERROR;
                        }
                } else {
                        error = ZULUVM_ERROR;
                }
        }
        TNF_PROBE_1(zuluvm_dma_alloc_ctx_done, "zuluvm", /* */,
            tnf_int, error, error);
        return (error);
}

/*
 * preload TLB
 * this will try to pre-set the zulu tlb, mainly used for dma engine 2,
 * video read-back.
 */
int
zuluvm_dma_preload(zuluvm_info_t devp, int dma,
                        int num, zulud_preload_t *list)
{
        int i;
        int error = ZULUVM_SUCCESS;
        struct zulu_hat *zhat;
        zuluvm_proc_t *proc = NULL;

        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;

        TNF_PROBE_4(zuluvm_dma_preload, "zuluvm", /* */,
            tnf_opaque, devp, devp,
            tnf_int, dma, dma,
            tnf_int, num, num,
            tnf_opaque, list, list);
        ZULUVM_LOCK;
        switch (dma) {
        case ZULUVM_DMA1:
                proc = zdev->zvm.proc1;
                break;
        case ZULUVM_DMA2:
                proc = zdev->zvm.proc2;
                break;
        }

        mutex_enter(&zdev->proc_lck);
        if (proc == NULL || proc->valid == 0 || proc->zhat == NULL) {
                mutex_exit(&zdev->proc_lck);
                ZULUVM_UNLOCK;
                return (ZULUVM_NO_HAT);
        }
        mutex_exit(&zdev->proc_lck);

        zhat = proc->zhat;
        /*
         * need to release this to avoid recursive enter in zuluvm_load_tte
         * which gets called from zulu_hat_memload()
         */
        ZULUVM_UNLOCK;

        mutex_enter(&zdev->load_lck);
        for (i = 0; i < num; i++) {
                int pg_size;
                int res;
                int first = 1;
                caddr_t addr = ZULUVM_GET_PAGE(list[i].addr);
                int64_t size = (int64_t)list[i].len;
                while (size > 0) {
                        if (list[i].tlbtype & ~ZULUVM_DMA_MASK) {
                                error = ZULUVM_INVALID_MISS;
                                break;
                        }
                        res = zulu_hat_load(zhat, addr,
                            (list[i].tlbtype == ZULUVM_DMA2) ? S_WRITE : S_READ,
                            &pg_size);
                        if ((res != 0) || (pg_size < 0)) {
                                error = ZULUVM_NO_MAP;
                                break;
                        }
                        ZULUVM_STATS_PRELOAD(zdev);
                        TNF_PROBE_2(zuluvm_dma_preload_addr, "zuluvm", /* */,
                            tnf_opaque, addr, addr,
                            tnf_opaque, size, size);
                        if (first) {
                                first = 0;
                                size -= ZULU_HAT_PGDIFF(list[i].addr,
                                                        pg_size);
                        } else {
                                size -= ZULU_HAT_PGSZ(pg_size);
                        }
                        addr += ZULU_HAT_PGSZ(pg_size);
                }
        }
        mutex_exit(&zdev->load_lck);
        TNF_PROBE_1(zuluvm_dma_preload_done, "zuluvm", /* */,
            tnf_int, error, error);
        return (ZULUVM_SUCCESS);
}

/*
 * destroy DMA handling for this handle
 */
int
zuluvm_dma_free_ctx(zuluvm_info_t devp, int dma)
{
        int error = ZULUVM_NO_DEV;
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;
        int state, newstate;

        state = ZULUVM_SET_STATE(zdev, ZULUVM_STATE_STOPPED,
                    ZULUVM_STATE_IDLE);
        newstate = ZULUVM_GET_STATE(zdev);
        TNF_PROBE_4(zuluvm_dma_free_ctx, "zuluvm", /* */,
            tnf_opaque, devp, devp,
            tnf_int, dma, dma,
            tnf_int, oldstate, state,
            tnf_int, newstate, newstate);
#ifdef DEBUG
        if (zuluvm_debug_state)
                cmn_err(CE_NOTE, "zuluvm_dma_free_ctx: state %d\n", state);
#endif
        if (state != ZULUVM_STATE_IDLE && state != ZULUVM_STATE_STOPPED) {
                int doit = 1;
                while (doit) {
                        switch (state) {
                        case ZULUVM_STATE_CANCELED:
                        case ZULUVM_STATE_STOPPED:
                                doit = 0;
                                break;
                        case ZULUVM_STATE_IDLE:
                                state = ZULUVM_SET_STATE(zdev,
                                            ZULUVM_STATE_STOPPED,
                                            ZULUVM_STATE_IDLE);
                                break;
                        default:
                                state = ZULUVM_SET_STATE(zdev,
                                            ZULUVM_STATE_CANCELED, state);
                        }
                        TNF_PROBE_1(zuluvm_dma_free_ctx, "zuluvm", /* */,
                            tnf_int, state, state);
#ifdef DEBUG
                        if (zuluvm_debug_state)
                                cmn_err(CE_NOTE, "zuluvm_dma_free_ctx: (loop1)"
                                    " state %d\n", state);
#endif
                }
        }
        TNF_PROBE_1(zuluvm_dma_free_ctx, "zuluvm", /* */,
            tnf_int, state, state);

        error = ZULUVM_SUCCESS;
        while (state != ZULUVM_STATE_STOPPED) {
                state = ZULUVM_GET_STATE(zdev);
#ifdef DEBUG
                if (zuluvm_debug_state)
                        cmn_err(CE_NOTE, "zuluvm_dma_free: (loop2) state %d\n",
                            state);
#endif
                if (state != ZULUVM_STATE_STOPPED)
                        delay(1);
        }
        ZULUVM_LOCK;
        if (zdev->zvm.arg != NULL) {
                zuluvm_proc_t *proc = NULL;
                switch (dma) {
                case ZULUVM_DMA1:
                        proc = zdev->zvm.proc1;
                        zdev->zvm.proc1 = NULL;
                        break;
                case ZULUVM_DMA2:
                        proc = zdev->zvm.proc2;
                        zdev->zvm.proc2 = NULL;
                        break;
                default:
                        error = ZULUVM_NO_DEV;
                }
                ZULUVM_UNLOCK;
                if (proc) {
                        mutex_enter(&zdev->proc_lck);
                        (void) zuluvm_proc_release(zdev, proc);
                        mutex_exit(&zdev->proc_lck);
                }
        } else {
                ZULUVM_UNLOCK;
                error = ZULUVM_NO_DEV;
        }
        TNF_PROBE_1(zuluvm_dma_free_ctx_done, "zuluvm", /* */,
            tnf_int, error, error);
        return (error);
}

static void
zuluvm_do_retarget(zuluvm_state_t *zdev)
{
        int i, idx;
        uint_t cpu;
        for (i = 0; i < ZULUVM_MAX_INTR; i++) {
                if (zdev->interrupts[i].ino != -1) {
                        cpu = intr_dist_cpuid();
                        idx = zdev->interrupts[i].offset;
                        if (zdev->imr[idx] & ZULUVM_IMR_V_MASK)
                                zdev->imr[idx] = ZULUVM_IMR_V_MASK |
                                    (cpu<<ZULUVM_IMR_TARGET_SHIFT);
                        else
                                zdev->imr[idx] =
                                    cpu<<ZULUVM_IMR_TARGET_SHIFT;
                }
        }
}

static void
zuluvm_retarget_intr(void *arg)
{
        zuluvm_state_t *zdev = (zuluvm_state_t *)arg;
        ZULUVM_LOCK;
        zuluvm_do_retarget(zdev);
        ZULUVM_UNLOCK;
}

int
zuluvm_add_intr(zuluvm_info_t devp, int ino,
                uint_t (*handler)(caddr_t), caddr_t arg)
{
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;
        if (devp == NULL) {
                TNF_PROBE_1(zuluvm_add_intr_done, "zuluvm", /* */,
                    tnf_int, error, ZULUVM_NO_DEV);
                return (ZULUVM_NO_DEV);
        }
        if (ddi_add_intr(zdev->dip, ino, NULL, NULL, handler, arg)
                != DDI_SUCCESS) {
                TNF_PROBE_1(zuluvm_add_intr_done, "zuluvm", /* */,
                    tnf_int, error, ZULUVM_ERROR);
                return (ZULUVM_ERROR);
        }
        return (ZULUVM_SUCCESS);
}

int
zuluvm_rem_intr(zuluvm_info_t devp, int ino)
{
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;
        if (devp == NULL) {
                TNF_PROBE_1(zuluvm_rem_intr_done, "zuluvm", /* */,
                    tnf_int, error, ZULUVM_NO_DEV);
                return (ZULUVM_NO_DEV);
        }
        /* remove from distributin list */
        ZULUVM_LOCK;
        zdev->imr[zdev->interrupts[ino].offset] &= ~ZULUVM_IMR_V_MASK;
        ZULUVM_UNLOCK;
        ddi_remove_intr(zdev->dip, ino, NULL);
        return (ZULUVM_SUCCESS);
}

int
zuluvm_enable_intr(zuluvm_info_t devp, int num)
{
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;

        TNF_PROBE_2(zuluvm_enable_intr, "zuluvm_intr", /* */,
            tnf_opaque, devp, devp,
            tnf_int, num, num);
        if (devp == NULL) {
                TNF_PROBE_1(zuluvm_enable_intr_done, "zuluvm", /* */,
                    tnf_int, error, ZULUVM_NO_DEV);
                return (ZULUVM_NO_DEV);
        }
        if (num < 0 || num > ZULUVM_IMR_MAX) {
                TNF_PROBE_1(zuluvm_enable_intr_done, "zuluvm", /* */,
                    tnf_int, error, ZULUVM_BAD_IDX);
                return (ZULUVM_BAD_IDX);
        }
        ZULUVM_LOCK;
        zdev->imr[num] |= ZULUVM_IMR_V_MASK;
        ZULUVM_UNLOCK;
        TNF_PROBE_1(zuluvm_enable_intr_done, "zuluvm_intr", /* */,
            tnf_int, error, ZULUVM_SUCCESS);
        return (ZULUVM_SUCCESS);
}

int
zuluvm_disable_intr(zuluvm_info_t devp, int num)
{
        zuluvm_state_t *zdev = (zuluvm_state_t *)devp;

        TNF_PROBE_2(zuluvm_disable_intr, "zuluvm_intr", /* */,
            tnf_opaque, devp, devp,
            tnf_int, num, num);
        if (devp == NULL) {
                TNF_PROBE_1(zuluvm_disable_intr_done, "zuluvm", /* */,
                    tnf_int, error, ZULUVM_NO_DEV);
                return (ZULUVM_NO_DEV);
        }
        if (num < 0 || num > ZULUVM_IMR_MAX) {
                TNF_PROBE_1(zuluvm_disable_intr_done, "zuluvm", /* */,
                    tnf_int, error, ZULUVM_BAD_IDX);
                return (ZULUVM_BAD_IDX);
        }
        ZULUVM_LOCK;
        zdev->imr[num] &= ~ZULUVM_IMR_V_MASK;
        ZULUVM_UNLOCK;
        TNF_PROBE_1(zuluvm_disable_intr_done, "zuluvm_intr", /* */,
            tnf_int, error, ZULUVM_SUCCESS);
        return (ZULUVM_SUCCESS);
}

static int
zuluvm_get_intr_props(zuluvm_state_t *zdev,
                        dev_info_t *devi)
{
        int *intr;
        int i;
        uint_t nintr;

        zdev->agentid = ddi_getprop(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
            "portid", -1);
        if (zdev->agentid == -1) {
                cmn_err(CE_WARN, "%s%d: no portid property",
                    ddi_get_name(devi),
                    ddi_get_instance(devi));
                return (ZULUVM_ERROR);
        }

        for (i = 0; i < ZULUVM_MAX_INTR; i++) {
                zdev->interrupts[i].offset = 0;
                zdev->interrupts[i].ino = -1;
        }

        if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, devi, DDI_PROP_DONTPASS,
            "interrupts", &intr, &nintr) == DDI_PROP_SUCCESS) {

                if (nintr == 0) {
                        cmn_err(CE_WARN, "%s%d: no interrupts in property",
                            ddi_get_name(devi),
                            ddi_get_instance(devi));
                        ddi_prop_free(intr);
                        return (ZULUVM_ERROR);
                }
                if (nintr >= ZULUVM_MAX_INTR) {
                        cmn_err(CE_WARN, "%s%d: to many interrupts (%d)",
                            ddi_get_name(devi),
                            ddi_get_instance(devi), nintr);
                        ddi_prop_free(intr);
                        return (ZULUVM_ERROR);
                }
                for (i = 0; i < nintr; i++) {
                        zdev->interrupts[i].offset = intr[i];
                        zdev->interrupts[i].ino = i;
                }
                ddi_prop_free(intr);
        } else {
                cmn_err(CE_WARN, "%s%d: no interrupts property",
                    ddi_get_name(devi),
                    ddi_get_instance(devi));
        }
        return (ZULUVM_SUCCESS);
}

/* *** enf of zulu *** */