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

/*
 * The PRI plug-in picks up memory configuration data from the PRI
 * and injects this into PICL's /platform tree.  It only populates
 * the logical view of memory: memory, memory-segment, memory-bank.
 * It does not populate the /device tree since there are no memory
 * controller devices on sun4v.
 */

#include "priplugin.h"
#include "../../common/memcfg/piclmemcfg.h"

static void
add_memory_props(picl_nodehdl_t node, mde_cookie_t memorylistp, md_t *mdp,
	uint64_t size);

static void
add_bank_props(picl_nodehdl_t node, mde_cookie_t banklistp,
	md_t *mdp, uint64_t *size, uint64_t *mask, unsigned int id);
static uint64_t countbits(uint64_t v);

static void
add_segment_props(picl_nodehdl_t node, mde_cookie_t segmentlistp,
	md_t *mdp, uint64_t interleave, uint64_t *size, uint64_t base);

/*
 * Callback function for picl_walk_tree_by_class().
 * NOTE: picl_walk_tree_by_class() maps the return codes PICL_WALK_CONTINUE
 * and PICL_WALK_TERMINATE to PICL_SUCCESS.
 */
int
add_mem_prop(picl_nodehdl_t node, void *args)
{
	mde_cookie_t *memorylistp, *segmentlistp, *banklistp;
	picl_prophdl_t memh, segmenth, bankh;
	mde_cookie_t *buf, md_rootnode;
	int j, k, num_nodes, interleave, err;
	int nsegments, nbanks, nmemory;
	uint64_t memsize, segsize, segbase;
	uint64_t size, mask;
	md_t *mdp = (md_t *)args;

	if (mdp == NULL)
		return (PICL_WALK_CONTINUE);

	md_rootnode = md_root_node(mdp);

	/*
	 * An absence of nodes or failure to obtain memory for searches
	 * or absence of the /memory node will cause this to fail.
	 * Return PICL_WALK_SUCCESS to allow the plug-in to continue.
	 */
	num_nodes = md_node_count(mdp);
	if (num_nodes == 0) {
		pri_debug(LOG_NOTICE, "add_mem_prop: no nodes to walk\n");
		return (PICL_SUCCESS);
	}
	buf = (mde_cookie_t *)malloc(sizeof (mde_cookie_t) * num_nodes * 3);
	if (buf == NULL) {
		pri_debug(LOG_NOTICE, "add_mem_prop: can't allocate memory\n");
		return (PICL_SUCCESS);
	}

	memorylistp = &buf[0];
	segmentlistp = &buf[num_nodes];
	banklistp = &buf[num_nodes * 2];

	if ((ptree_get_node_by_path(MEMORY_PATH, &memh)) != PICL_SUCCESS) {
		pri_debug(LOG_NOTICE,
		    "add_mem_prop: can't find /memory node in platform tree\n");
		free(buf);
		return (PICL_SUCCESS);
	}

	/*
	 * There should be only one memory node.
	 * If we can't find what we're looking for in the DAG then
	 * return PICL_PROPNOTFOUND to get the caller to re-try with
	 * a different property name.
	 */
	nmemory = md_scan_dag(mdp, md_rootnode, md_find_name(mdp,
	    "memory-segments"), md_find_name(mdp, "fwd"), memorylistp);
	if (nmemory != 1) {
		pri_debug(LOG_NOTICE,
		    "add_mem_prop: wrong number of memory dags: expected "
		    "1, got %d\n", nmemory);
		free(buf);
		return (PICL_PROPNOTFOUND);
	}

	nsegments = md_scan_dag(mdp, memorylistp[0],
	    md_find_name(mdp, "memory-segment"),
	    md_find_name(mdp, "fwd"),
	    segmentlistp);

	if (nsegments == 0) {
		pri_debug(LOG_NOTICE, "add_mem_prop: wrong number of memory "
		    "segments: expected >0, got %d\n", nsegments);
		free(buf);
		return (PICL_PROPNOTFOUND);
	}

	/*
	 * Add memory segments, keep running total of system memory.
	 */
	for (memsize = 0, segsize = 0, j = 0; j < nsegments;
	    ++j, memsize += segsize) {
		nbanks = 0;
		err = ptree_create_and_add_node(memh,
		    PICL_NAME_MEMORY_SEGMENT,
		    PICL_CLASS_MEMORY_SEGMENT, &segmenth);
		if (err == PICL_SUCCESS) {
			size = 0;
			mask = 0;

			/*
			 * Need to pull this out here since it's used for
			 * the ID.
			 */
			if (md_get_prop_val(mdp, segmentlistp[j], "base",
			    &segbase))
				segbase = 0ULL;

			/*
			 * Add banks under each segment.
			 */
			nbanks = md_scan_dag(mdp, segmentlistp[j],
			    md_find_name(mdp, "memory-bank"),
			    md_find_name(mdp, "fwd"),
			    banklistp);

			if (nbanks <= 0) {
				pri_debug(LOG_NOTICE, "add_mem_prop: no banks "
				    "found for segment %d\n", j);
			} else {
				for (k = 0; k < nbanks; ++k) {
					err =
					    ptree_create_and_add_node(segmenth,
					    PICL_NAME_MEMORY_BANK,
					    PICL_CLASS_MEMORY_BANK, &bankh);
					if (err == PICL_SUCCESS) {
						/*
						 * Add AddressMatch,
						 * AddressMask, Size, and
						 * ID to each bank.
						 */
						add_bank_props(bankh,
						    banklistp[k],
						    mdp,
						    &size, &mask,
						    (segbase >> 32) * j + k);
					}
				}
			}
		}

		/*
		 * Add Interleave, BaseAddress, and Size to each segment.
		 */
		interleave = 2 << (countbits(mask & (size - 1)) - 1);
		add_segment_props(segmenth, segmentlistp[j],
		    mdp, interleave, &segsize, segbase);
	}

	/*
	 * Add TransferSize and Size (total memory) to this node.
	 */
	add_memory_props(memh, memorylistp[0], mdp, memsize);

	free(buf);
	return (PICL_WALK_CONTINUE);
}

static void
add_bank_props(picl_nodehdl_t bankh, mde_cookie_t banklistp,
	md_t *mdp, uint64_t *size, uint64_t *mask, unsigned int id)
{
	uint64_t int_value;
	mde_cookie_t *dimmlistp;
	int node_count, i, type_size, nac_size, status;
	uint8_t *type;
	char *pc, *nac;
	picl_prophdl_t dimmh;

	*size = 0ULL;
	*mask = 0ULL;

	node_count = md_node_count(mdp);
	dimmlistp = (mde_cookie_t *)malloc(node_count * sizeof (mde_cookie_t));
	if (dimmlistp == NULL) {
		pri_debug(LOG_NOTICE,
		    "add_bank_props: can't allocate memory\n");
		return;
	}

	if (!md_get_prop_val(mdp, banklistp, "size", &int_value)) {
		add_md_prop(bankh, sizeof (int_value), PICL_PROP_SIZE,
		    &int_value, PICL_PTYPE_UNSIGNED_INT);
		*size = int_value;
	}
	if (!md_get_prop_val(mdp, banklistp, "mask",
	    &int_value)) {
		add_md_prop(bankh, sizeof (int_value),
		    PICL_PROP_ADDRESSMASK,
		    &int_value, PICL_PTYPE_UNSIGNED_INT);
		*mask = int_value;
	}
	if (!md_get_prop_val(mdp, banklistp, "match",
	    &int_value)) {
		add_md_prop(bankh, sizeof (int_value),
		    PICL_PROP_ADDRESSMATCH,
		    &int_value, PICL_PTYPE_UNSIGNED_INT);
	}

	add_md_prop(bankh, sizeof (id), PICL_PROP_ID, &id,
	    PICL_PTYPE_INT);

	node_count = md_scan_dag(mdp, banklistp, md_find_name(mdp, "component"),
	    md_find_name(mdp, "fwd"), dimmlistp);

	for (i = 0; i < node_count; ++i) {
		status = md_get_prop_str(mdp, dimmlistp[i], "type",
		    (char **)&type);
		if (status == -1) {
			status = md_get_prop_data(mdp, dimmlistp[i],
			    "type", &type, &type_size);
		}
		if (status == -1) /* can't get node type - just skip */
			continue;
		if (strcmp((const char *)type, "dimm") == 0) {
			if (md_get_prop_str(mdp, dimmlistp[i], "nac",
			    (char **)&nac) == 0) {
				nac_size = strlen(nac) + 1;
				if (ptree_create_and_add_node(bankh,
				    PICL_NAME_MEMORY_MODULE,
				    PICL_CLASS_MEMORY_MODULE, &dimmh) ==
				    PICL_SUCCESS) {
					add_md_prop(dimmh, nac_size,
					    "nac", nac,
					    PICL_PTYPE_CHARSTRING);
					if ((pc = strrchr(nac, '/')) != NULL)
						nac = ++pc;
					nac_size = strlen(nac) + 1;
					add_md_prop(dimmh, nac_size,
					    PICL_PROP_LABEL, nac,
					    PICL_PTYPE_CHARSTRING);
				}
			}
		}
	}
	free(dimmlistp);
}

static uint64_t
countbits(uint64_t v)
{
	uint64_t c;	/* c accumulates the total bits set in v */

	for (c = 0; v; c++)
		v &= v - 1;	/* clear the least significant bit set */
	return (c);
}

static void
add_segment_props(picl_nodehdl_t node, mde_cookie_t segmentlistp,
    md_t *mdp, uint64_t interleave, uint64_t *size, uint64_t base)
{
	uint64_t int_value;

	*size = 0;
	if (!md_get_prop_val(mdp, segmentlistp, "size", &int_value)) {
		add_md_prop(node, sizeof (int_value),
		    PICL_PROP_SIZE, &int_value,
		    PICL_PTYPE_UNSIGNED_INT);
		*size = int_value;
	}
	add_md_prop(node, sizeof (base), PICL_PROP_BASEADDRESS,
	    &base, PICL_PTYPE_UNSIGNED_INT);

	add_md_prop(node, sizeof (interleave), PICL_PROP_INTERLEAVE_FACTOR,
	    &interleave, PICL_PTYPE_UNSIGNED_INT);
}

static void
add_memory_props(picl_nodehdl_t node, mde_cookie_t memorylistp, md_t *mdp,
	uint64_t size)
{
	uint64_t int_value;

	/*
	 * If the top-level node has a size property then use that,
	 * otherwise use the size that was calculated by the caller
	 * and passed in.
	 */
	if (md_get_prop_val(mdp, memorylistp, "size", &int_value))
		int_value = size;
	add_md_prop(node, sizeof (int_value), PICL_PROP_SIZE, &int_value,
	    PICL_PTYPE_UNSIGNED_INT);
	if (!md_get_prop_val(mdp, memorylistp, "transfer_size",
	    &int_value)) {
		add_md_prop(node, sizeof (int_value),
		    PICL_PROP_TRANSFER_SIZE,
		    &int_value, PICL_PTYPE_UNSIGNED_INT);
	}
}