/*
 * 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/types.h>
#include <sys/kmem.h>
#include <sys/mc.h>
#include <sys/nvpair.h>
#include <sys/fm/protocol.h>
#include <sys/cmn_err.h>
#include <sys/sunddi.h>
#include <sys/mc_intel.h>
#include "nb_log.h"
#include "rank.h"
#include "dimm_phys.h"
#include "nb5000.h"

struct rank_base *rank_base;

static int
fmri2unum(nvlist_t *nvl, mc_unum_t *unump)
{
        int i;
        uint64_t offset;
        nvlist_t **hcl, *hcsp;
        uint_t npr;

        if (nvlist_lookup_nvlist(nvl, FM_FMRI_HC_SPECIFIC, &hcsp) != 0 ||
            (nvlist_lookup_uint64(hcsp, "asru-" FM_FMRI_HC_SPECIFIC_OFFSET,
            &offset) != 0 && nvlist_lookup_uint64(hcsp,
            FM_FMRI_HC_SPECIFIC_OFFSET, &offset) != 0) ||
            nvlist_lookup_nvlist_array(nvl, FM_FMRI_HC_LIST, &hcl, &npr) != 0)
                return (0);


        bzero(unump, sizeof (mc_unum_t));
        for (i = 0; i < MC_UNUM_NDIMM; i++)
                unump->unum_dimms[i] = MC_INVALNUM;

        for (i = 0; i < npr; i++) {
                char *hcnm, *hcid;
                long v;

                if (nvlist_lookup_string(hcl[i], FM_FMRI_HC_NAME, &hcnm) != 0 ||
                    nvlist_lookup_string(hcl[i], FM_FMRI_HC_ID, &hcid) != 0 ||
                    ddi_strtol(hcid, NULL, 0, &v) != 0)
                        return (0);

                if (strcmp(hcnm, "motherboard") == 0)
                        unump->unum_board = (int)v;
                else if (strcmp(hcnm, "memory-controller") == 0)
                        unump->unum_mc = (int)v;
                else if (strcmp(hcnm, "dram-channel") == 0)
                        unump->unum_cs = (int)v;
                else if (strcmp(hcnm, "dimm") == 0)
                        unump->unum_dimms[0] = (int)v;
                else if (strcmp(hcnm, "rank") == 0)
                        unump->unum_rank = (int)v;
        }

        return (1);
}

/*ARGSUSED*/
static cmi_errno_t
inb_patounum(void *arg, uint64_t pa, uint8_t valid_hi, uint8_t valid_lo,
    uint32_t synd, int syndtype, mc_unum_t *unump)
{
        struct rank_base *rp;
        int i;
        int last;
        uint64_t offset;
        cmi_errno_t rt = CMIERR_UNKNOWN;

        last = nb_dimms_per_channel * nb_number_memory_controllers;
        for (i = 0; i < last; i++) {
                rp = &rank_base[i];
                if (rp && pa >= rp->base && pa < rp->limit)
                        break;
        }
        if (i < last) {
                offset = pa - rp->base;
                if (offset > rp->hole)
                        offset -= rp->hole_size;
                unump->unum_offset = offset / rp->interleave;
                unump->unum_mc = i / nb_dimms_per_channel;
                unump->unum_cs = 0;
                unump->unum_rank = i % nb_dimms_per_channel;
                rt = CMI_SUCCESS;
        }
        return (rt);
}

/*ARGSUSED*/
static cmi_errno_t
inb_unumtopa(void *arg, mc_unum_t *unump, nvlist_t *nvl, uint64_t *pap)
{
        int num_ranks_per_branch;
        mc_unum_t unum;
        uint64_t pa;
        struct rank_base *rp;

        if (unump == NULL) {
                if (!fmri2unum(nvl, &unum))
                        return (CMI_SUCCESS);
                unump = &unum;
        }
        if ((unump->unum_offset & OFFSET_ROW_BANK_COL)) {
                if (&dimm_getphys) {
                        pa = dimm_getphys(unump->unum_mc,
                            TCODE_OFFSET_RANK(unump->unum_offset),
                            TCODE_OFFSET_BANK(unump->unum_offset),
                            TCODE_OFFSET_RAS(unump->unum_offset),
                            TCODE_OFFSET_CAS(unump->unum_offset));
                        if (pa >= MAXPHYS_ADDR)
                                return (CMIERR_MC_NOADDR);
                } else {
                        return (CMIERR_MC_NOADDR);
                }
                *pap = pa;
                return (CMI_SUCCESS);
        }


        /* max number of ranks per branch */
        num_ranks_per_branch = (nb_chipset == INTEL_NB_5100) ?
            NB_5100_RANKS_PER_CHANNEL :
            nb_dimms_per_channel * nb_channels_per_branch;
        rp = &rank_base[(unump->unum_mc * num_ranks_per_branch) +
            unump->unum_rank];
        pa = rp->base + (unump->unum_offset * rp->interleave);

        if (rp->hole && pa >= rp->hole)
                pa += rp->hole_size;
        *pap = pa;
        return (CMI_SUCCESS);
}

void
dimm_init()
{
        int num_ranks_per_branch;


        /* max number of ranks per branch */
        num_ranks_per_branch = (nb_chipset == INTEL_NB_5100) ?
            NB_5100_RANKS_PER_CHANNEL :
            nb_dimms_per_channel * nb_channels_per_branch;

        rank_base = kmem_zalloc(sizeof (struct rank_base) *
            nb_number_memory_controllers * num_ranks_per_branch, KM_SLEEP);
}

void
dimm_fini()
{
        int num_ranks_per_branch;


        /* max number of ranks per branch */
        num_ranks_per_branch = (nb_chipset == INTEL_NB_5100) ?
            NB_5100_RANKS_PER_CHANNEL :
            nb_dimms_per_channel * nb_channels_per_branch;

        kmem_free(rank_base, sizeof (struct rank_base) *
            nb_number_memory_controllers * num_ranks_per_branch);
        rank_base = 0;
}

void
dimm_add_rank(int branch, int rank, int branch_interleave, int way,
    uint64_t base, uint32_t hole, uint32_t hole_size, int interleave,
    uint64_t limit)
{
        struct rank_base *rp;
        int num_ranks_per_branch;

        /* max number of ranks per branch */
        num_ranks_per_branch = (nb_chipset == INTEL_NB_5100) ?
            NB_5100_RANKS_PER_CHANNEL :
            nb_dimms_per_channel * nb_channels_per_branch;
        rp = &rank_base[(branch * num_ranks_per_branch) + rank];
        rp->branch_interleave = branch_interleave;
        rp->way = way;
        rp->base = base;
        rp->hole = hole;
        rp->hole_size = hole_size;
        rp->interleave = interleave;
        rp->limit = limit;
}

static const cmi_mc_ops_t inb_mc_ops = {
        inb_patounum,
        inb_unumtopa,
        nb_error_trap                   /* cmi_mc_logout */
};

/*ARGSUSED*/
int
inb_mc_register(cmi_hdl_t hdl, void *arg1, void *arg2, void *arg3)
{
        cmi_mc_register(hdl, &inb_mc_ops, NULL);
        return (CMI_HDL_WALK_NEXT);
}