/*
 * 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 2007 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/systm.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/ddi_impldefs.h>
#include <sys/obpdefs.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/vmem.h>
#include <sys/debug.h>
#include <sys/sysmacros.h>
#include <sys/machsystm.h>
#include <sys/machparam.h>
#include <sys/modctl.h>
#include <sys/fhc.h>
#include <sys/ac.h>
#include <sys/vm.h>
#include <sys/cpu_module.h>
#include <vm/seg_kmem.h>
#include <vm/hat_sfmmu.h>
#include <sys/mem_config.h>
#include <sys/mem_cage.h>

extern ac_err_t ac_kpm_err_cvt(int);

int ac_del_clean = 0;

/*
 * Default timeout, in seconds, for delete.
 * Time is counted when no progress is being made.
 */
static int ac_del_timeout = 60;

#define DEL_PAGESIZE    MMU_PAGESIZE

struct del_status {
        struct del_status *next;
        memhandle_t     handle;
        volatile int    its_done;
        int             done_error;
        kcondvar_t      ac_del_cv;
        int             del_timeout;
        int             del_noprogress;
        ac_err_t        cancel_code;
        timeout_id_t    to_id;
        pgcnt_t         last_collected;
};
static struct del_status *ac_del_list;
static kmutex_t ac_del_mutex;

static struct del_status *
ac_del_alloc_status()
{
        struct del_status *dsp;

        dsp = (struct del_status *)kmem_zalloc(sizeof (*dsp), KM_SLEEP);
        mutex_enter(&ac_del_mutex);
        dsp->next = ac_del_list;
        ac_del_list = dsp;
        mutex_exit(&ac_del_mutex);

        return (dsp);
}

static void
ac_del_free_status(struct del_status *dsp)
{
        struct del_status **dspp;

        mutex_enter(&ac_del_mutex);
        dspp = &ac_del_list;
        while (*dspp != NULL) {
                if (*dspp == dsp)
                        break;
                dspp = &(*dspp)->next;
        }
        ASSERT(*dspp == dsp);
        if (*dspp == dsp) {
                *dspp = dsp->next;
        }
        mutex_exit(&ac_del_mutex);
        kmem_free((void *)dsp, sizeof (*dsp));
}

static void
del_comp(void *arg, int error)
{
        struct del_status *dsp;

        dsp = (struct del_status *)arg;
        mutex_enter(&ac_del_mutex);
#ifdef DEBUG
        {
                struct del_status *adsp;
                for (adsp = ac_del_list; adsp != NULL; adsp = adsp->next) {
                        if (adsp == dsp)
                                break;
                }
                ASSERT(adsp != NULL);
        }
#endif /* DEBUG */
        dsp->its_done = 1;
        dsp->done_error = error;
        cv_signal(&dsp->ac_del_cv);
        mutex_exit(&ac_del_mutex);
}

/*ARGSUSED*/
static void
del_to_scan(void *arg)
{
        struct del_status *dsp;
        int do_cancel;
        memdelstat_t dstat;
        int err;

        dsp = arg;

#ifdef DEBUG
        {
                struct del_status *adsp;

                mutex_enter(&ac_del_mutex);
                for (adsp = ac_del_list; adsp != NULL; adsp = adsp->next) {
                        if (adsp == dsp)
                                break;
                }
                ASSERT(adsp != NULL);
                mutex_exit(&ac_del_mutex);
        }
#endif /* DEBUG */
        do_cancel = 0;
        err = kphysm_del_status(dsp->handle, &dstat);
        mutex_enter(&ac_del_mutex);
        if (dsp->its_done) {
                mutex_exit(&ac_del_mutex);
                return;
        }
        if ((err == KPHYSM_OK) &&
            (dsp->last_collected != dstat.collected)) {
                dsp->del_noprogress = 0;
                dsp->last_collected = dstat.collected;
        } else {
                dsp->del_noprogress++;
                if (dsp->del_noprogress >= dsp->del_timeout) {
                        if (dsp->cancel_code == 0)
                                dsp->cancel_code = AC_ERR_TIMEOUT;
                        do_cancel = 1;
                }
        }
        if (!do_cancel)
                dsp->to_id = timeout(del_to_scan, arg, hz);
        else
                dsp->to_id = 0;
        mutex_exit(&ac_del_mutex);
        if (do_cancel)
                (void) kphysm_del_cancel(dsp->handle);
}

static void
del_to_start(struct del_status *dsp)
{
        if (dsp->del_timeout != 0)
                dsp->to_id = timeout(del_to_scan, dsp, hz);
}

static void
del_to_stop(struct del_status *dsp)
{
        timeout_id_t tid;

        while ((tid = dsp->to_id) != 0) {
                dsp->to_id = 0;
                mutex_exit(&ac_del_mutex);
                (void) untimeout(tid);
                mutex_enter(&ac_del_mutex);
        }
}

static int
ac_del_bank_add_span(
        memhandle_t handle,
        ac_cfga_pkt_t *pkt)
{
        uint64_t                decode;
        uint64_t                base_pa;
        uint64_t                bank_size;
        pfn_t                   base;
        pgcnt_t                 npgs;
        int                     errs;
        int                     ret;
        struct ac_soft_state    *asp = pkt->softsp;
        uint_t                  ilv;

        /*
         * Cannot delete interleaved banks at the moment.
         */
        ilv = (pkt->bank == Bank0) ?
            INTLV0(*asp->ac_memctl) : INTLV1(*asp->ac_memctl);
        if (ilv != 1) {
                AC_ERR_SET(pkt, AC_ERR_MEM_DEINTLV);
                return (EINVAL);
        }
        /*
         * Determine the physical location of the selected bank
         */
        decode = (pkt->bank == Bank0) ?
            *asp->ac_memdecode0 : *asp->ac_memdecode1;
        base_pa = GRP_REALBASE(decode);
        bank_size = GRP_UK2SPAN(decode);

        base = base_pa >> PAGESHIFT;
        npgs = bank_size >> PAGESHIFT;

        /*
         * Delete the pages from the cage growth list.
         */
        ret = kcage_range_delete(base, npgs);
        if (ret != 0) {
                /* TODO: Should this be a separate error? */
                AC_ERR_SET(pkt, AC_ERR_KPM_NONRELOC);
                return (EINVAL);
        }

        /*
         * Add to delete memory list.
         */

        if ((errs = kphysm_del_span(handle, base, npgs)) != KPHYSM_OK) {
                AC_ERR_SET(pkt, ac_kpm_err_cvt(errs));
                /*
                 * Restore the pages to the cage growth list.
                 * TODO: We should not unconditionally add back
                 * if we conditionally add at memory add time.
                 */
                errs = kcage_range_add(base, npgs, KCAGE_DOWN);
                /* TODO: deal with error return. */
                if (errs != 0) {
                        AC_ERR_SET(pkt, ac_kpm_err_cvt(errs));
                        cmn_err(CE_NOTE, "ac_del_bank_add_span(): "
                            "board %d, bank %d, "
                            "kcage_range_add() returned %d",
                            pkt->softsp->board, pkt->bank, errs);
                }
                return (EINVAL);
        }
        return (0);
}

static void
ac_del_bank_add_cage(
        struct bd_list *del,
        enum ac_bank_id bank)
{
        uint64_t                decode;
        uint64_t                base_pa;
        uint64_t                bank_size;
        pfn_t                   base;
        pgcnt_t                 npgs;
        int                     errs;
        struct ac_soft_state    *asp = (struct ac_soft_state *)(del->ac_softsp);

        /*
         * Determine the physical location of the selected bank
         */
        decode = (bank == Bank0) ? *asp->ac_memdecode0 : *asp->ac_memdecode1;
        base_pa = GRP_REALBASE(decode);
        bank_size = GRP_UK2SPAN(decode);

        base = base_pa >> PAGESHIFT;
        npgs = bank_size >> PAGESHIFT;

        /*
         * Restore the pages to the cage growth list.
         * TODO: We should not unconditionally add back
         * if we conditionally add at memory add time.
         */
        errs = kcage_range_add(base, npgs, KCAGE_DOWN);
        /* TODO: deal with error return. */
        if (errs != 0)
                cmn_err(CE_NOTE, "ac_del_bank_add_cage(): "
                    "board %d, bank %d, "
                    "kcage_range_add() returned %d",
                    del->sc.board, bank, errs);
}

static int
ac_del_bank_run(struct del_status *dsp, ac_cfga_pkt_t *pkt)
{
        int errs;

        dsp->its_done = 0;
        if ((errs = kphysm_del_start(dsp->handle, del_comp, (void *)dsp)) !=
            KPHYSM_OK) {
                AC_ERR_SET(pkt, ac_kpm_err_cvt(errs));
                return (EINVAL);
        }
        /* Wait for it to complete. */
        mutex_enter(&ac_del_mutex);
        del_to_start(dsp);
        while (!dsp->its_done) {
                if (!cv_wait_sig(&dsp->ac_del_cv, &ac_del_mutex)) {
                        if (dsp->cancel_code == 0)
                                dsp->cancel_code = AC_ERR_INTR;
                        mutex_exit(&ac_del_mutex);
                        errs = kphysm_del_cancel(dsp->handle);
                        mutex_enter(&ac_del_mutex);
                        if (errs != KPHYSM_OK) {
                                ASSERT(errs == KPHYSM_ENOTRUNNING);
                        }
                        break;
                }
        }
        /*
         * If the loop exited due to a signal, we must continue to wait
         * using cv_wait() as the signal is pending until syscall exit.
         */
        while (!dsp->its_done) {
                cv_wait(&dsp->ac_del_cv, &ac_del_mutex);
        }
        if (dsp->done_error != KPHYSM_OK) {
                AC_ERR_SET(pkt, ac_kpm_err_cvt(dsp->done_error));
                if ((dsp->done_error == KPHYSM_ECANCELLED) ||
                    (dsp->done_error == KPHYSM_EREFUSED)) {
                        errs = EINTR;
                        if (dsp->cancel_code != 0) {
                                AC_ERR_SET(pkt, dsp->cancel_code);
                        }
                } else {
                        errs = EINVAL;
                }
        } else
                errs = 0;
        del_to_stop(dsp);
        mutex_exit(&ac_del_mutex);

        return (errs);
}


/*
 * set the memory to known state for debugging
 */
static void
ac_bank_write_pattern(struct bd_list *del, enum ac_bank_id bank)
{
        uint64_t                decode;
        uint64_t                base_pa;
        uint64_t                limit_pa;
        uint64_t                bank_size;
        uint64_t                current_pa;
        caddr_t                 base_va;
        caddr_t                 fill_buf;
        struct ac_soft_state    *asp = (struct ac_soft_state *)(del->ac_softsp);
        int                     linesize;

        /*
         * Determine the physical location of the selected bank
         */
        decode = (bank == Bank0) ? *asp->ac_memdecode0 : *asp->ac_memdecode1;
        base_pa = GRP_REALBASE(decode);
        bank_size = GRP_UK2SPAN(decode);
        limit_pa = base_pa + bank_size;
        linesize = cpunodes[CPU->cpu_id].ecache_linesize;

        /*
         * We need a page_va and a fill buffer for this operation
         */
        base_va = vmem_alloc(heap_arena, PAGESIZE, VM_SLEEP);
        fill_buf = kmem_zalloc(DEL_PAGESIZE, KM_SLEEP);
        {
                typedef uint32_t patt_t;
                patt_t *bf, *bfe, patt;

                bf = (patt_t *)fill_buf;
                bfe = (patt_t *)((char *)fill_buf + DEL_PAGESIZE);
                patt = 0xbeaddeed;
                while (bf < bfe)
                        *bf++ = patt;
        }

        /*
         * 'empty' the memory
         */
        kpreempt_disable();
        for (current_pa = base_pa; current_pa < limit_pa;
            current_pa += DEL_PAGESIZE) {

                /* map current pa */
                ac_mapin(current_pa, base_va);

                /* fill the target page */
                ac_blkcopy(fill_buf, base_va,
                        DEL_PAGESIZE/linesize, linesize);

                /* tear down translation */
                ac_unmap(base_va);
        }
        kpreempt_enable();

        /*
         * clean up temporary resources
         */
        {
                /* Distinguish the fill buf from memory deleted! */
                typedef uint32_t patt_t;
                patt_t *bf, *bfe, patt;

                bf = (patt_t *)fill_buf;
                bfe = (patt_t *)((char *)fill_buf + DEL_PAGESIZE);
                patt = 0xbeadfeed;
                while (bf < bfe)
                        *bf++ = patt;
        }
        kmem_free(fill_buf, DEL_PAGESIZE);
        vmem_free(heap_arena, base_va, PAGESIZE);
}

int
ac_del_memory(ac_cfga_pkt_t *pkt)
{
        struct bd_list *board;
        struct ac_mem_info *mem_info;
        int busy_set;
        struct del_status *dsp;
        memdelstat_t dstat;
        int retval;
        int r_errs;
        struct ac_soft_state *asp;

        if (!kcage_on) {
                static int cage_msg_done = 0;

                if (!cage_msg_done) {
                        cage_msg_done = 1;
                        cmn_err(CE_NOTE, "ac: memory delete"
                            " refused: cage is off");
                }
                AC_ERR_SET(pkt, ac_kpm_err_cvt(KPHYSM_ENONRELOC));
                return (EINVAL);
        }

        dsp = ac_del_alloc_status();
        if ((retval = kphysm_del_gethandle(&dsp->handle)) != KPHYSM_OK) {
                ac_del_free_status(dsp);
                AC_ERR_SET(pkt, ac_kpm_err_cvt(retval));
                return (EINVAL);
        }
        retval = 0;
        busy_set = 0;

        board = fhc_bdlist_lock(pkt->softsp->board);
        if (board == NULL || board->ac_softsp == NULL) {
                fhc_bdlist_unlock();
                AC_ERR_SET(pkt, AC_ERR_BD);
                retval = EINVAL;
                goto out;
        }
        ASSERT(pkt->softsp == board->ac_softsp);
        asp = pkt->softsp;

        /* verify the board is of the correct type */
        switch (board->sc.type) {
        case CPU_BOARD:
        case MEM_BOARD:
                break;
        default:
                fhc_bdlist_unlock();
                AC_ERR_SET(pkt, AC_ERR_BD_TYPE);
                retval = EINVAL;
                goto out;
        }

        /* verify the memory condition is acceptable */
        mem_info = &asp->bank[pkt->bank];
        if (!MEM_BOARD_VISIBLE(board) || mem_info->busy ||
            fhc_bd_busy(pkt->softsp->board) ||
            mem_info->rstate != SYSC_CFGA_RSTATE_CONNECTED ||
            mem_info->ostate != SYSC_CFGA_OSTATE_CONFIGURED) {
                fhc_bdlist_unlock();
                AC_ERR_SET(pkt, AC_ERR_BD_STATE);
                retval = EINVAL;
                goto out;
        }

        if ((dsp->del_timeout = pkt->cmd_cfga.arg) == -1)
                dsp->del_timeout = ac_del_timeout;

        /*
         * at this point, we have an available bank to del.
         * mark it busy and initiate the del function.
         */
        mem_info->busy = TRUE;
        fhc_bdlist_unlock();

        busy_set = 1;

        retval = ac_del_bank_add_span(dsp->handle, pkt);
out:
        if (retval != 0) {
                r_errs = kphysm_del_release(dsp->handle);
                ASSERT(r_errs == KPHYSM_OK);

                if (busy_set) {
                        board = fhc_bdlist_lock(pkt->softsp->board);
                        ASSERT(board != NULL && board->ac_softsp != NULL);

                        ASSERT(board->sc.type == CPU_BOARD ||
                            board->sc.type == MEM_BOARD);
                        ASSERT(asp ==
                            (struct ac_soft_state *)(board->ac_softsp));
                        mem_info = &asp->bank[pkt->bank];
                        ASSERT(mem_info->busy != FALSE);
                        ASSERT(mem_info->ostate == SYSC_CFGA_OSTATE_CONFIGURED);
                        mem_info->busy = FALSE;
                        fhc_bdlist_unlock();
                }

                ac_del_free_status(dsp);
                return (retval);
        }

        (void) kphysm_del_status(dsp->handle, &dstat);

        retval = ac_del_bank_run(dsp, pkt);

        r_errs = kphysm_del_release(dsp->handle);
        ASSERT(r_errs == KPHYSM_OK);

        board = fhc_bdlist_lock(pkt->softsp->board);
        ASSERT(board != NULL && board->ac_softsp != NULL);

        ASSERT(board->sc.type == CPU_BOARD || board->sc.type == MEM_BOARD);
        ASSERT(asp == (struct ac_soft_state *)(board->ac_softsp));
        mem_info = &asp->bank[pkt->bank];
        ASSERT(mem_info->busy != FALSE);
        ASSERT(mem_info->ostate == SYSC_CFGA_OSTATE_CONFIGURED);
        mem_info->busy = FALSE;
        if (retval == 0) {
                mem_info->ostate = SYSC_CFGA_OSTATE_UNCONFIGURED;
                mem_info->status_change = ddi_get_time();

                if (ac_del_clean) {
                        /* DEBUG - set memory to known state */
                        ac_bank_write_pattern(board, pkt->bank);
                }
        } else {
                /*
                 * Restore the pages to the cage growth list.
                 */
                ac_del_bank_add_cage(board, pkt->bank);
        }
        fhc_bdlist_unlock();

        ac_del_free_status(dsp);

        return (retval);
}