/*
 * 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 (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <unistd.h>
#include <ctype.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/devfm.h>
#include <libnvpair.h>
#include <sys/smbios.h>
#include <fm/topo_mod.h>
#include <sys/fm/protocol.h>
#include <sys/smbios_impl.h>

#include "chip.h"

#define	CPU_SLOTS	64
#define	DIMM_SLOTS	512
#define	MC_INSTANCES	128

#define	MAXNAMELEN	256
#define	LABEL		1

#define	SKIP_CS		9999


typedef struct cpu_smbios {
	id_t cpu_id;
	uint8_t status;
	uint8_t fru;
}csmb_t;

typedef struct dimm_smbios {
	id_t dimm_id;
	id_t extdimm_id;
	const char *bankloc;
}dsmb_t;

typedef struct mct_smbios {
	id_t extmct_id;
	id_t mct_id;
	id_t p_id;
}msmb_t;

csmb_t cpusmb[CPU_SLOTS];
dsmb_t dimmsmb[DIMM_SLOTS];
msmb_t mctsmb[MC_INSTANCES];

static int ncpu_ids = 0;
static int bb_count = 0;
static int ndimm_ids, nmct_ids = 0;

static int fill_chip_smbios = 0;
typedef int smbios_rec_f(topo_mod_t *, const smbios_struct_t *);

static smbios_struct_t *
smb_export(const smb_struct_t *stp, smbios_struct_t *sp)
{
	const smb_header_t *hdr;

	if (stp == NULL)
		return (NULL);

	hdr = stp->smbst_hdr;
	sp->smbstr_id = hdr->smbh_hdl;
	sp->smbstr_type = hdr->smbh_type;
	sp->smbstr_data = hdr;
	sp->smbstr_size = (size_t)(stp->smbst_end - (uchar_t *)hdr);

	return (sp);
}

static int
extdimmslot_to_dimmslot(topo_mod_t *mod, id_t chip_smbid, int channum,
    int csnum)
{
	smbios_memdevice_ext_t emd;
	smbios_memdevice_t md;
	int i, j;
	int match = 0;
	smbios_hdl_t *shp;

	shp = topo_mod_smbios(mod);
	if (shp == NULL)
		return (-1);

	if (chip_smbid == IGNORE_ID && bb_count <= 1 && nmct_ids <= 1) {
		for (i = 0; i < ndimm_ids; i++) {
			if (smbios_info_extmemdevice(shp, dimmsmb[i].extdimm_id,
			    &emd) != 0) {
				continue;
			}

			if (emd.smbmdeve_drch == channum) {
				uint_t ncs;
				uint8_t *cs;

				if (csnum == SKIP_CS) {
					return (emd.smbmdeve_md);
				}

				if (smbios_info_extmemdevice_cs(shp,
				    dimmsmb[i].extdimm_id, &ncs, &cs) != 0) {
					continue;
				}

				for (uint_t k = 0; k < ncs; k++) {
					if (cs[k] != csnum) {
						continue;
					}

					smbios_info_extmemdevice_cs_free(shp,
					    ncs, cs);
					return (emd.smbmdeve_md);
				}

				smbios_info_extmemdevice_cs_free(shp, ncs, cs);
			}
		}
	}

	for (j = 0; j < nmct_ids; j++) {
		if (mctsmb[j].p_id == chip_smbid) {
			for (i = 0; i < ndimm_ids; i++) {
				if (smbios_info_extmemdevice(shp,
				    dimmsmb[i].extdimm_id, &emd) != 0) {
					continue;
				}

				(void) smbios_info_memdevice(shp,
				    emd.smbmdeve_md, &md);
				if (md.smbmd_array == mctsmb[j].mct_id &&
				    emd.smbmdeve_drch == channum) {
					match = 1;
					break;
				}
			}
			if (match) {
				uint_t ncs;
				uint8_t *cs;

				if (csnum == SKIP_CS) {
					return (emd.smbmdeve_md);
				}

				if (smbios_info_extmemdevice_cs(shp,
				    dimmsmb[i].extdimm_id, &ncs, &cs) != 0) {
					continue;
				}

				for (uint_t k = 0; k < ncs; k++) {
					if (cs[k] != csnum) {
						continue;
					}

					smbios_info_extmemdevice_cs_free(shp,
					    ncs, cs);
					return (emd.smbmdeve_md);
				}
				smbios_info_extmemdevice_cs_free(shp, ncs, cs);
			}
		}
	}

	return (-1);
}

id_t
memnode_to_smbiosid(topo_mod_t *mod, uint16_t chip_smbid, const char *name,
    uint64_t nodeid, void *data)
{

	if (strcmp(name, CS_NODE_NAME) == 0) {
		int channum, csnum;
		id_t dimmslot = -1;

		if (data == NULL)
			return (-1);
		channum = *(int *)data;
		csnum = nodeid;
		/*
		 * Set the DIMM Slot label to the Chip Select Node
		 * Set the "data" to carry the DIMM instance
		 */
		dimmslot = extdimmslot_to_dimmslot(mod, chip_smbid, channum,
		    csnum);
		if (dimmslot != -1 && dimmsmb[0].dimm_id != 0)
			*((id_t *)data) = dimmslot % (dimmsmb[0].dimm_id);
		else
			*((id_t *)data) = -1;

		return (dimmslot);

	} else if (strcmp(name, DIMM_NODE_NAME) == 0) {
		static int dimmnum = 0;

		/*
		 * On certain Intel Chips, topology does not have
		 * chip-select nodes, it has the below layout
		 * chip/memory-controller/dram-channel/dimm
		 * so we check if channel instance is passed
		 * and get the SMBIOS ID based on the channel
		 */
		if (data != NULL) {
			int channum;
			id_t dimmslot = -1;

			channum = *(int *)data;
			dimmslot = extdimmslot_to_dimmslot(mod, chip_smbid,
			    channum, SKIP_CS);

			return (dimmslot);
		}
		dimmnum = nodeid;
		return (dimmsmb[dimmnum].dimm_id);
	}

	return (-1);
}


int
chip_get_smbstruct(topo_mod_t *mod, const smbios_struct_t *sp)
{
	smbios_processor_t p;
	smbios_memdevice_t md;
	smbios_processor_ext_t extp;
	smbios_memarray_ext_t extma;
	smbios_memdevice_ext_t extmd;
	int ext_match = 0;
	smbios_hdl_t *shp;

	shp = topo_mod_smbios(mod);
	if (shp == NULL)
		return (-1);

	switch (sp->smbstr_type) {
	case SMB_TYPE_BASEBOARD:
		bb_count++;
		break;
	case SMB_TYPE_MEMARRAY:
		mctsmb[nmct_ids].mct_id = sp->smbstr_id;
		nmct_ids++;
		break;
	case SUN_OEM_EXT_MEMARRAY:
		if (shp != NULL) {
			if (smbios_info_extmemarray(shp,
			    sp->smbstr_id, &extma) != 0) {
				topo_mod_dprintf(mod, "chip_get_smbstruct : "
				    "smbios_info_extmemarray()"
				    "failed\n");
				return (-1);
			}
		} else
			return (-1);
		for (int i = 0; i < nmct_ids; i++) {
			if (extma.smbmae_ma == mctsmb[i].mct_id) {
				mctsmb[i].extmct_id = sp->smbstr_id;
				mctsmb[i].p_id = extma.smbmae_comp;
				ext_match = 1;
				break;
			}
		}
		if (!ext_match) {
			topo_mod_dprintf(mod, "chip_get_smbstruct : "
			    "EXT_MEMARRAY-MEMARRAY records are mismatched\n");
			ext_match = 0;
			return (-1);
		}
		break;
	case SMB_TYPE_MEMDEVICE:
		dimmsmb[ndimm_ids].dimm_id = sp->smbstr_id;
		if (shp != NULL) {
			if (smbios_info_memdevice(shp,
			    sp->smbstr_id, &md) != 0)
				return (-1);
		} else
			return (-1);
		dimmsmb[ndimm_ids].bankloc = md.smbmd_bloc;
		ndimm_ids++;
		break;
	/*
	 * Every SMB_TYPE_MEMDEVICE SHOULD have a
	 * corresponding SUN_OEM_EXT_MEMDEVICE
	 */
	case SUN_OEM_EXT_MEMDEVICE:
		if (smbios_info_extmemdevice(shp,
		    sp->smbstr_id, &extmd) != 0) {
			topo_mod_dprintf(mod, "chip_get_smbstruct : "
			    "smbios_info_extmemdevice()"
			    "failed\n");
			return (-1);
		}
		for (int i = 0; i < ndimm_ids; i++) {
			if (extmd.smbmdeve_md == dimmsmb[i].dimm_id) {
				dimmsmb[i].extdimm_id = sp->smbstr_id;
				ext_match = 1;
				break;
			}
		}
		if (!ext_match) {
			topo_mod_dprintf(mod, "chip_get_smbstruct : "
			    "EXT_MEMDEVICE-MEMDEVICE records are mismatched\n");
			ext_match = 0;
			return (-1);
		}
		break;
	case SMB_TYPE_PROCESSOR:
		cpusmb[ncpu_ids].cpu_id = sp->smbstr_id;
		if (shp != NULL) {
			if (smbios_info_processor(shp,
			    sp->smbstr_id, &p) != 0) {
				topo_mod_dprintf(mod, "chip_get_smbstruct : "
				    "smbios_info_processor()"
				    "failed\n");
				return (-1);
			}
		}
		cpusmb[ncpu_ids].status = p.smbp_status;
		ncpu_ids++;
		break;
	/*
	 * Every SMB_TYPE_PROCESSOR SHOULD have a
	 * corresponding SUN_OEM_EXT_PROCESSOR
	 */
	case SUN_OEM_EXT_PROCESSOR:
		if (smbios_info_extprocessor(shp,
		    sp->smbstr_id, &extp) != 0) {
			topo_mod_dprintf(mod, "chip_get_smbstruct : "
			    "smbios_info_extprocessor()"
			    "failed\n");
			return (-1);
		}
		for (int i = 0; i < ncpu_ids; i++) {
			if (extp.smbpe_processor == cpusmb[i].cpu_id) {
				cpusmb[i].fru = extp.smbpe_fru;
				ext_match = 1;
				break;
			}
		}
		if (!ext_match) {
			topo_mod_dprintf(mod, "chip_get_smbstruct : "
			    "EXT_PROCESSOR-PROCESSOR records are mismatched\n");
			ext_match = 0;
			return (-1);
		}
		break;
	}
	return (0);
}

static int
chip_smbios_iterate(topo_mod_t *mod, smbios_rec_f *func_iter)
{
	const smb_struct_t *sp;
	smbios_struct_t s;
	int i, rv = 0;
	smbios_hdl_t *shp;

	shp = topo_mod_smbios(mod);
	if (shp == NULL)
		return (rv);

	sp = shp->sh_structs;
	for (i = 0; i < shp->sh_nstructs; i++, sp++) {
		if (sp->smbst_hdr->smbh_type != SMB_TYPE_INACTIVE &&
		    (rv = func_iter(mod, smb_export(sp, &s))) != 0)
			break;
	}
	return (rv);
}

int
init_chip_smbios(topo_mod_t *mod)
{
	if (!fill_chip_smbios) {
		if (chip_smbios_iterate(mod, chip_get_smbstruct) == -1)
			return (-1);
		fill_chip_smbios = 1;
	}

	return (0);
}

int
chip_status_smbios_get(topo_mod_t *mod, id_t smb_id)
{
	/*
	 * Type-4 Socket Status bit definitions per SMBIOS Version 2.6
	 *
	 * STATUS
	 * CPU Socket Populated
	 * CPU Socket Unpopulated
	 * Populated : Enabled
	 * Populated : Disabled by BIOS (Setup)
	 * Populated : Disabled by BIOS (Error)
	 * Populated : Idle
	 */
	uint8_t	enabled = 0x01;
	uint8_t	populated = 0x40;

	for (int i = 0; i < ncpu_ids; i++) {
		if (smb_id == cpusmb[i].cpu_id) {
			if (cpusmb[i].status  == (enabled | populated))
				return (1);
		}
	}

	topo_mod_dprintf(mod, "chip_status_smbios_get() failed"
	    " considering that Type 4 ID : %ld is disabled", smb_id);
	return (0);
}

int
chip_fru_smbios_get(topo_mod_t *mod, id_t smb_id)
{
	/*
	 * smbios_processor_ext_t->smbpe_fru : if set to 1
	 * processor is a FRU
	 */
	uint8_t	fru = 1;

	for (int i = 0; i < ncpu_ids; i++) {
		if (smb_id == cpusmb[i].cpu_id) {
			if (cpusmb[i].fru == fru)
				return (1);
			else
				return (0);
		}
	}

	topo_mod_dprintf(mod, "chip_fru_smbios_get() failed"
	    " considering that Type 4 ID : %ld is not a FRU", smb_id);
	return (0);
}

/*
 * This could be defined as topo_mod_strlen()
 */
size_t
chip_strlen(const char *str)
{
	int len = 0;

	if (str != NULL)
		len = strlen(str);

	return (len);
}

/*
 * We clean Serials, Revisions, Part No. strings, to
 * avoid getting lost when fmd synthesizes these
 * strings. :, =, /, ' ' characters are replaced
 * with character '-' any non-printable characters
 * as seen with !isprint() is also replaced with '-'
 * Labels are checked only for non-printable characters.
 */
static const char *
chip_cleanup_smbios_str(topo_mod_t *mod, const char *begin, int str_type)
{
	char buf[MAXNAMELEN];
	const char *end, *cp;
	char *pp;
	char c;
	int i;

	end = begin + strlen(begin);

	while (begin < end && isspace(*begin))
		begin++;
	while (begin < end && isspace(*(end - 1)))
		end--;

	if (begin >= end)
		return (NULL);

	cp = begin;
	for (i = 0; i < MAXNAMELEN - 1; i++) {
		if (cp >= end)
			break;
		c = *cp;
		if (str_type == LABEL) {
			if (!isprint(c))
				buf[i] = '-';
			else
				buf[i] = c;
		} else {
			if (c == ':' || c == '=' || c == '/' ||
			    isspace(c) || !isprint(c))
				buf[i] = '-';
			else
				buf[i] = c;
		}
		cp++;
	}
	buf[i] = 0;

	pp = topo_mod_strdup(mod, buf);

	if (str_type == LABEL)
		topo_mod_strfree(mod, (char *)begin);

	return (pp);
}

const char *
chip_label_smbios_get(topo_mod_t *mod, tnode_t *pnode, id_t smb_id,
    char *ksmbios_label)
{
	smbios_info_t c;
	char *label = NULL;
	char *buf = NULL;
	const char *lsmbios_label = NULL;
	int bufsz = 0;
	char *delim = NULL, *blank = " ";
	const char *dimm_bank = NULL;
	const char *clean_label = NULL;
	int err;
	smbios_hdl_t *shp;

	shp = topo_mod_smbios(mod);
	if (shp != NULL) {
		/*
		 * Get Parent FRU's label
		 */
		if (topo_prop_get_string(pnode, TOPO_PGROUP_PROTOCOL,
		    TOPO_PROP_LABEL, &label, &err) == -1)
			topo_mod_dprintf(mod, "Failed to get"
			    " Label of Parent Node error : %d\n", err);

		if (label != NULL)
			label = (char *)chip_cleanup_smbios_str(mod,
			    label, LABEL);

		/*
		 * On Intel the driver gets the label from ksmbios
		 * so we check if we already have it, if not we
		 * get it from libsmbios
		 */
		if (ksmbios_label == NULL && smb_id != -1) {
			if (smbios_info_common(shp, smb_id, &c) != SMB_ERR) {
				for (int i = 0; i < ndimm_ids; i++) {
					if (smb_id == dimmsmb[i].dimm_id) {
						dimm_bank = dimmsmb[i].bankloc;
						break;
					}
				}
				if (dimm_bank != NULL) {
					bufsz += chip_strlen(blank) +
					    chip_strlen(dimm_bank);
				}
				lsmbios_label = c.smbi_location;
			}
		} else
			lsmbios_label = ksmbios_label;

		if (label != NULL && lsmbios_label != NULL)
			delim = "/";

		bufsz += chip_strlen(label) + chip_strlen(delim) +
		    chip_strlen(lsmbios_label) + 1;

		buf = topo_mod_alloc(mod, bufsz);

		if (buf != NULL) {
			if (label != NULL) {
				(void) strlcpy(buf, label, bufsz);
				if (lsmbios_label != NULL) {
					(void) strlcat(buf, delim, bufsz);
					/*
					 * If we are working on a DIMM
					 * and we are deriving from libsmbios
					 * smbi_location has the Device Locator.
					 * add the Device Locator
					 * add Bank Locator latter
					 */
					(void) strlcat(buf, lsmbios_label,
					    bufsz);
				}
			} else if (lsmbios_label != NULL)
				(void) strlcpy(buf, lsmbios_label,
				    bufsz);

			if (dimm_bank != NULL) {
				(void) strlcat(buf, blank, bufsz);
				(void) strlcat(buf, dimm_bank, bufsz);
			}
		}

		clean_label = chip_cleanup_smbios_str(mod, buf, LABEL);
		topo_mod_strfree(mod, label);

		return (clean_label);
	}

	topo_mod_dprintf(mod, "Failed to get Label\n");
	return (NULL);
}


const char *
chip_serial_smbios_get(topo_mod_t *mod, id_t smb_id)
{
	smbios_info_t c;
	const char *clean_serial = NULL;
	smbios_hdl_t *shp;

	shp = topo_mod_smbios(mod);
	if (shp != NULL && smb_id != -1)
		if (smbios_info_common(shp, smb_id, &c) != SMB_ERR) {
			clean_serial = chip_cleanup_smbios_str(mod,
			    c.smbi_serial, 0);
			return (clean_serial);
		}

	topo_mod_dprintf(mod, "Failed to get Serial \n");
	return (NULL);
}


const char *
chip_part_smbios_get(topo_mod_t *mod, id_t smb_id)
{
	smbios_info_t c;
	const char *clean_part = NULL;
	smbios_hdl_t *shp;

	shp = topo_mod_smbios(mod);
	if (shp != NULL && smb_id != -1)
		if (smbios_info_common(shp, smb_id, &c) != SMB_ERR) {
			clean_part = chip_cleanup_smbios_str(mod,
			    c.smbi_part, 0);
			return (clean_part);
		}

	topo_mod_dprintf(mod, "Failed to get Part\n");
	return (NULL);
}

const char *
chip_rev_smbios_get(topo_mod_t *mod, id_t smb_id)
{
	smbios_info_t c;
	const char *clean_rev = NULL;
	smbios_hdl_t *shp;

	shp = topo_mod_smbios(mod);
	if (shp != NULL && smb_id != -1)
		if (smbios_info_common(shp, smb_id, &c) != SMB_ERR) {
			clean_rev = chip_cleanup_smbios_str(mod,
			    c.smbi_version, 0);
			return (clean_rev);
		}

	topo_mod_dprintf(mod, "Failed to get Revision\n");
	return (NULL);
}