/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 (c) 2000-2001 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*
 * This plugin creates memory configuration nodes and properties in the
 * PICL tree for Grover/Grover+ platform.
 *
 * Subtree of memory-controller in the physical aspect.
 * memory-controller --- memory-module
 * However, there is no memory controller node on Grover. Thus we need to
 * create it under platform.
 *
 * Subtree of memory in the logical aspect.
 * memory --- memory-segment
 * Add property _memory-module_ at memory-segment referring to the
 * memory-module since memory-segment equals to memory-module on Grover.
 *
 * Undo strategy:
 * Create all nodes and properties, or none if it fails in physical and
 * logical memory tree respectively. It keeps on creating logical
 * memory tree although it falis on physical logical tree, but no link to
 * memory module.
 *
 * NOTE:
 * It depends on PICL devtree plugin.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <alloca.h>
#include <syslog.h>
#include <string.h>
#include <libintl.h>
#include <picl.h>
#include <picltree.h>
#include <sys/types.h>
#include <sys/obpdefs.h>
#include "piclmemcfg.h"
#include "memcfg_impl.h"

static  void    piclmemcfg_register(void);
static  void    piclmemcfg_init(void);
static  void    piclmemcfg_fini(void);

#pragma init(piclmemcfg_register)

static picld_plugin_reg_t  my_reg_info = {
        PICLD_PLUGIN_VERSION_1,
        PICLD_PLUGIN_NON_CRITICAL,
        "SUNW_piclmemcfg",
        piclmemcfg_init,
        piclmemcfg_fini
};

/*
 * Create logical memory tree
 * memory --- memory-segment
 */
static int
create_logical_tree(picl_nodehdl_t memh, mmodinfo_t *mmodinfo)
{
        picl_nodehdl_t          msegh;
        picl_nodehdl_t          *memsegh;
        ptree_propinfo_t        propinfo;
        uint32_t                ifactor = INTERLEAVEFACTOR;
        int                     i;
        int                     err = PICL_SUCCESS;

        if ((memsegh = alloca(sizeof (picl_nodehdl_t) * TOTAL_MEM_SLOTS)) ==
            NULL)
                return (PICL_FAILURE);

        for (i = 0; i < TOTAL_MEM_SLOTS; i++) {
                /*
                 * It means no segment for the slot if size is zero
                 */
                if (mmodinfo[i].size == 0) {
                        memsegh[i] = 0;
                        continue;
                }

                /*
                 * Create memory-segment node under memory
                 */
                err = ptree_create_and_add_node(memh, PICL_NAME_MEMORY_SEGMENT,
                    PICL_CLASS_MEMORY_SEGMENT, &msegh);
                if (err != PICL_SUCCESS)
                        break;

                /*
                 * For undo easily later
                 */
                memsegh[i] = msegh;

                /*
                 * Add property, Size to memory-segment node
                 */
                err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
                    PICL_PTYPE_UNSIGNED_INT, PICL_READ,
                    sizeof (mmodinfo[i].size), PICL_PROP_SIZE, NULL, NULL);
                if (err != PICL_SUCCESS)
                        break;

                err = ptree_create_and_add_prop(msegh, &propinfo,
                    &mmodinfo[i].size, NULL);
                if (err != PICL_SUCCESS)
                        break;

                /*
                 * Add property, BaseAddress to memory-segment node
                 */
                err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
                    PICL_PTYPE_UNSIGNED_INT, PICL_READ,
                    sizeof (mmodinfo[i].base), PICL_PROP_BASEADDRESS, NULL,
                    NULL);
                if (err != PICL_SUCCESS)
                        break;

                err = ptree_create_and_add_prop(msegh, &propinfo,
                    &mmodinfo[i].base, NULL);
                if (err != PICL_SUCCESS)
                        break;

                /*
                 * Add property, InterleaveFactor to memory-segment node
                 */
                err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
                    PICL_PTYPE_UNSIGNED_INT, PICL_READ, sizeof (ifactor),
                    PICL_PROP_INTERLEAVE_FACTOR, NULL, NULL);
                if (err != PICL_SUCCESS)
                        break;

                err = ptree_create_and_add_prop(msegh, &propinfo, &ifactor,
                    NULL);
                if (err != PICL_SUCCESS)
                        break;

                /*
                 * Add reference property to the memory module if memory
                 * module node handle is not NULL.
                 */
                if (mmodinfo[i].memmodh == 0)
                        continue;

                err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
                    PICL_PTYPE_REFERENCE, PICL_READ, sizeof (picl_nodehdl_t),
                    PICL_REFPROP_MEMORY_MODULE, NULL, NULL);
                if (err != PICL_SUCCESS)
                        break;

                err = ptree_create_and_add_prop(msegh, &propinfo,
                    &mmodinfo[i].memmodh, NULL);
                if (err != PICL_SUCCESS)
                        break;
        }

        if (err != PICL_SUCCESS) {
                /*
                 * Undo in the logical memory tree
                 */
                for (i = 0; i < TOTAL_MEM_SLOTS; i++) {
                        if (memsegh[i] == 0)
                                continue;

                        (void) ptree_delete_node(memsegh[i]);
                        (void) ptree_destroy_node(memsegh[i]);
                }
        }

        return (err);
}

/*
 * Create physical memory tree
 * memory-controller --- memory-module
 */
static int
create_physical_tree(picl_nodehdl_t plfh, mmodinfo_t *mmodinfo)
{
        picl_nodehdl_t          mch, memmodh;
        ptree_propinfo_t        propinfo;
        int                     i;
        int                     err = PICL_SUCCESS;
        uint32_t                id;

        /*
         * Create memory-controller node under platform
         */
        err = ptree_create_and_add_node(plfh, PICL_NAME_MEMORY_CONTROLLER,
            PICL_CLASS_MEMORY_CONTROLLER, &mch);
        if (err != PICL_SUCCESS)
                return (err);

        /*
         * Create memory-module nodes and properties
         * Get all memory modules with dimm
         */
        for (i = 0; i < TOTAL_MEM_SLOTS; i++) {
                /*
                 * It means no dimm on the slot if size is zero
                 */
                if (mmodinfo[i].size == 0)
                        continue;

                /* Create memory-module node under memory-controller */
                err = ptree_create_and_add_node(mch, PICL_NAME_MEMORY_MODULE,
                    PICL_CLASS_MEMORY_MODULE, &memmodh);
                if (err != PICL_SUCCESS)
                        break;

                /*
                 * Update memory module node handle at mmodinfo
                 */
                mmodinfo[i].memmodh = memmodh;

                /*
                 * Add property, Size to memory-module node
                 */
                err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
                    PICL_PTYPE_UNSIGNED_INT, PICL_READ,
                    sizeof (mmodinfo[i].size), PICL_PROP_SIZE, NULL, NULL);
                if (err != PICL_SUCCESS)
                        break;

                err = ptree_create_and_add_prop(memmodh, &propinfo,
                    &mmodinfo[i].size, NULL);
                if (err != PICL_SUCCESS)
                        break;

                /*
                 * Add property, ID to memory-module node
                 */
                err = ptree_init_propinfo(&propinfo, PTREE_PROPINFO_VERSION,
                    PICL_PTYPE_INT, PICL_READ, sizeof (id), PICL_PROP_ID,
                    NULL, NULL);
                if (err != PICL_SUCCESS)
                        break;

                id = i;
                err = ptree_create_and_add_prop(memmodh, &propinfo, &id, NULL);
                if (err != PICL_SUCCESS)
                        break;
        }

        if (err != PICL_SUCCESS) {
                /*
                 * Clear out the saved memory module node handle so that
                 * logical memory tree won't link to memory module.
                 */
                for (i = 0; i < TOTAL_MEM_SLOTS; i++)
                        mmodinfo[i].memmodh = 0;

                /*
                 * Undo in the physical memory tree
                 */
                (void) ptree_delete_node(mch);
                (void) ptree_destroy_node(mch);
        }

        return (err);
}

/*
 * Get the memory module and memory segment information from
 * property reg of memory node.
 *
 * mmodinfo will be updated. Also, the pointers to mseginfo and
 * the number of segments will be passed to the caller.
 */
static int
get_reg_info(picl_nodehdl_t plfh, picl_nodehdl_t memh,
    mmodinfo_t *mmodinfo)
{
        picl_prophdl_t          proph;
        ptree_propinfo_t        pinfo;
        regspec_t               *memspec;
        int                     i, err;
        int                     pval;
        int                     nregspec;


        /*
         * Check if the #size-cells of the platform node is 2
         */
        err = ptree_get_propval_by_name(plfh, OBP_PROP_SIZE_CELLS, &pval,
            sizeof (pval));

        if (err == PICL_PROPNOTFOUND)
                pval = SUPPORTED_NUM_CELL_SIZE;
        else if (err != PICL_SUCCESS)
                return (err);

        /*
         * don't know to handle other vals
         */
        if (pval != SUPPORTED_NUM_CELL_SIZE)
                return (PICL_FAILURE);

        /*
         * Get property reg of memory node
         */
        err = ptree_get_prop_by_name(memh, OBP_REG, &proph);
        if (err != PICL_SUCCESS)
                return (err);

        err = ptree_get_propinfo(proph, &pinfo);
        if (err != PICL_SUCCESS)
                return (err);

        if ((memspec = alloca(pinfo.piclinfo.size)) == NULL)
                return (PICL_FAILURE);

        nregspec = pinfo.piclinfo.size / sizeof (*memspec);

        if ((nregspec == 0) || (nregspec > TOTAL_MEM_SLOTS))
                return (PICL_FAILURE);

        err = ptree_get_propval(proph, memspec, pinfo.piclinfo.size);
        if (err != PICL_SUCCESS)
                return (err);


        for (i = 0; i < nregspec; i++) {

                mmodinfo[i].base = memspec[i].physaddr;
                mmodinfo[i].size = memspec[i].size;

        }

        return (PICL_SUCCESS);
}

/*
 * executed as part of .init when the plugin is dlopen()ed
 */
static void
piclmemcfg_register(void)
{
        (void) picld_plugin_register(&my_reg_info);
}

/*
 * Init entry point of the plugin
 * Creates the PICL nodes and properties in the physical and logical aspects.
 */
static void
piclmemcfg_init(void)
{
        picl_nodehdl_t          plfh, memh;
        mmodinfo_t              mmodinfo[TOTAL_MEM_SLOTS];

        /*
         * Get platform node
         */
        if ((ptree_get_node_by_path(PLATFORM_PATH, &plfh)) != PICL_SUCCESS) {
                syslog(LOG_ERR, EM_INIT_FAILED);
                return;
        }

        /*
         * Find the memory node
         */
        if ((ptree_get_node_by_path(MEMORY_PATH, &memh)) != PICL_SUCCESS) {
                syslog(LOG_ERR, EM_INIT_FAILED);
                return;
        }

        /*
         * Initialize the mmodinfo and get segment information from reg
         */
        (void) memset(mmodinfo, 0, sizeof (mmodinfo));

        if ((get_reg_info(plfh, memh, mmodinfo)) != PICL_SUCCESS) {
                syslog(LOG_ERR, EM_INIT_FAILED);
                return;
        }

        /*
         * Create subtree of memory-controller in the physical aspect.
         * memory-controller --- memory-module
         */
        if ((create_physical_tree(plfh, mmodinfo)) != PICL_SUCCESS)
                syslog(LOG_ERR, EM_PHYSIC_MEM_TREE_FAILED);

        /*
         * Create subtree of memory in the logical aspect.
         * memory --- memory-segment
         */
        if ((create_logical_tree(memh, mmodinfo)) != PICL_SUCCESS)
                syslog(LOG_ERR, EM_LOGIC_MEM_TREE_FAILED);
}

/*
 * fini entry point of the plugin
 */
static void
piclmemcfg_fini(void)
{
}