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

#include <stddef.h>
#include <string.h>
#include <strings.h>
#include <libnvpair.h>

#include <scsi/libses.h>
#include <scsi/plugins/ses/framework/ses2_impl.h>

static int
enc_parse_sd(ses2_elem_status_impl_t *esip, nvlist_t *nvl)
{
	ses2_enclosure_status_impl_t *sdp;
	int nverr;

	sdp = (ses2_enclosure_status_impl_t *)esip;

	SES_NV_ADD(uint64, nverr, nvl, SES_PROP_STATUS_CODE,
	    sdp->sesi_common.sesi_status_code);
	SES_NV_ADD(boolean_value, nverr, nvl, SES_PROP_SWAP,
	    sdp->sesi_common.sesi_swap);
	SES_NV_ADD(boolean_value, nverr, nvl, SES_PROP_DISABLED,
	    sdp->sesi_common.sesi_disabled);
	SES_NV_ADD(boolean_value, nverr, nvl, SES_PROP_PRDFAIL,
	    sdp->sesi_common.sesi_prdfail);

	SES_NV_ADD(boolean_value, nverr, nvl, SES_PROP_IDENT, sdp->sesi_ident);
	SES_NV_ADD(boolean_value, nverr, nvl, SES_PROP_WARN,
	    sdp->sesi_warning_indication);
	SES_NV_ADD(boolean_value, nverr, nvl, SES_PROP_FAIL,
	    sdp->sesi_failure_indication);
	SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_POWER_DELAY,
	    sdp->sesi_power_delay);
	SES_NV_ADD(boolean_value, nverr, nvl, SES_PROP_WARN_REQ,
	    sdp->sesi_warning_requested);
	SES_NV_ADD(boolean_value, nverr, nvl, SES_PROP_FAIL_REQ,
	    sdp->sesi_warning_requested);
	SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_POWER_DURATION,
	    sdp->sesi_power_duration);

	return (0);
}

static int
enc_parse_help(ses_plugin_t *sp, ses_node_t *np)
{
	ses_snap_t *snap = ses_node_snapshot(np);
	ses2_help_page_impl_t *hpip;
	ses2_subhelp_page_impl_t *shpip;
	ses2_subhelp_text_impl_t *tip;
	nvlist_t *nvl = ses_node_props(np);
	uint64_t eid;
	size_t len, textlen;
	off_t pos;
	int nverr;

	if (nvlist_lookup_uint64(nvl, SES_EN_PROP_EID, &eid) != 0)
		return (0);

	if ((shpip = ses_plugin_page_lookup(sp, snap,
	    SES2_DIAGPAGE_SUBENCLOSURE_HELP_TEXT, np, &len)) != NULL) {
		pos = 0;
		for (tip = (ses2_subhelp_text_impl_t *)shpip->sspi_data;
		    pos < SCSI_READ16(&shpip->sspi_page_length);
		    pos += SES2_SUBHELP_LEN(tip),
		    tip = (ses2_subhelp_text_impl_t *)((uint8_t *)tip + pos)) {
			if (!SES_WITHIN_PAGE_STRUCT(tip, shpip, len))
				break;

			if (tip->ssti_subenclosure_identifier != eid)
				continue;

			textlen = SCSI_READ16(
			    &tip->ssti_subenclosure_help_text_length);

			if (!SES_WITHIN_PAGE(tip->ssti_subenclosure_help_text,
			    textlen, shpip, len))
				break;

			SES_NV_ADD(fixed_string, nverr, nvl, SES_EN_PROP_HELP,
			    tip->ssti_subenclosure_help_text, textlen);
			return (0);
		}
	}

	if (eid == 0 && (hpip = ses_plugin_page_lookup(sp, snap,
	    SES2_DIAGPAGE_HELP_TEXT, np, &len)) != NULL) {
		if (!SES_WITHIN_PAGE_STRUCT(hpip, hpip, len))
			return (0);

		if (!SES_WITHIN_PAGE(hpip->shpi_help_text,
		    SCSI_READ16(&hpip->shpi_page_length), hpip, len))
			return (0);

		SES_NV_ADD(fixed_string, nverr, nvl, SES_EN_PROP_HELP,
		    hpip->shpi_help_text, SCSI_READ16(&hpip->shpi_page_length));
	}

	return (0);
}

static int
enc_parse_string_in(ses_plugin_t *sp, ses_node_t *np)
{
	ses_snap_t *snap = ses_node_snapshot(np);
	ses2_string_in_page_impl_t *sip;
	ses2_substring_in_page_impl_t *ssip;
	ses2_substring_in_data_impl_t *dip;
	nvlist_t *nvl = ses_node_props(np);
	uint64_t eid;
	off_t pos;
	size_t len, textlen;
	int nverr;

	if (nvlist_lookup_uint64(nvl, SES_EN_PROP_EID, &eid) != 0)
		return (0);

	if ((ssip = ses_plugin_page_lookup(sp, snap,
	    SES2_DIAGPAGE_SUBENCLOSURE_STRING_IO, np, &len)) != NULL) {
		pos = 0;
		for (dip = (ses2_substring_in_data_impl_t *)ssip->ssipi_data;
		    pos < SCSI_READ16(&ssip->ssipi_page_length);
		    pos += SES2_SUBSTR_LEN(dip),
		    dip = (ses2_substring_in_data_impl_t *)
		    ((uint8_t *)dip + pos)) {
			if (!SES_WITHIN_PAGE_STRUCT(dip, ssip, len))
				break;

			if (dip->ssidi_subenclosure_identifier != eid)
				continue;

			textlen =
			    SCSI_READ16(&dip->ssidi_substring_data_length);

			if (!SES_WITHIN_PAGE(dip->ssidi_data, textlen,
			    ssip, len))
				break;

			SES_NV_ADD(fixed_string, nverr, nvl, SES_EN_PROP_STRING,
			    (char *)dip->ssidi_data, textlen);
			return (0);
		}
	}

	if (eid == 0 && (sip = ses_plugin_page_lookup(sp, snap,
	    SES2_DIAGPAGE_STRING_IO, np, &len)) != NULL) {
		if (!SES_WITHIN_PAGE_STRUCT(sip, sip, len))
			return (0);

		textlen = SCSI_READ16(&sip->ssipi_page_length);

		if (!SES_WITHIN_PAGE(sip->ssipi_data, textlen, sip, len))
			return (0);

		SES_NV_ADD(byte_array, nverr, nvl, SES_EN_PROP_STRING,
		    sip->ssipi_data, textlen);
	}

	return (0);
}

static int
enc_parse_descr(ses_plugin_t *sp, ses_node_t *np)
{
	char *desc;
	nvlist_t *props = ses_node_props(np);
	int nverr;
	size_t len;

	if ((desc = ses_plugin_page_lookup(sp, ses_node_snapshot(np),
	    SES2_DIAGPAGE_ELEMENT_DESC, np, &len)) == NULL)
		return (0);

	SES_NV_ADD(fixed_string, nverr, props, SES_PROP_DESCRIPTION,
	    desc, len);

	return (0);
}

static int
enc_parse_dlucode(ses_plugin_t *sp, ses_node_t *np)
{
	ses_snap_t *snap = ses_node_snapshot(np);
	ses2_ucode_status_page_impl_t *upip;
	ses2_ucode_status_descr_impl_t *dip;
	nvlist_t *nvl = ses_node_props(np);
	int nverr, i;
	size_t len;
	uint64_t eid;

	if ((upip = ses_plugin_page_lookup(sp, snap,
	    SES2_DIAGPAGE_DL_MICROCODE_CTL_STATUS, np, &len)) == NULL)
		return (0);

	if (nvlist_lookup_uint64(nvl, SES_EN_PROP_EID, &eid) != 0)
		return (0);

	if (!SES_WITHIN_PAGE_STRUCT(upip, upip, len))
		return (0);

	/*
	 * The number of subenclosures excludes the primary subenclosure, which
	 * is always part of the response.
	 */
	for (dip = &upip->suspi_descriptors[0], i = 0;
	    i <= upip->suspi_n_subenclosures;
	    i++, dip++) {
		if (!SES_WITHIN_PAGE_STRUCT(dip, upip, len))
			break;

		if (dip->susdi_subenclosure_identifier != eid)
			continue;
		SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_UCODE,
		    dip->susdi_subenclosure_dl_status);
		SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_UCODE_A,
		    dip->susdi_subenclosure_dl_addl_status);
		SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_UCODE_SZ,
		    SCSI_READ32(&dip->susdi_subenclosure_dl_max_size));
		SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_UCODE_BUF,
		    dip->susdi_subenclosure_dl_buffer_id);
		SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_UCODE_OFF,
		    dip->susdi_subenclosure_dl_buffer_offset);
		break;
	}

	return (0);
}

static int
enc_parse_subnick(ses_plugin_t *sp, ses_node_t *np)
{
	ses_snap_t *snap = ses_node_snapshot(np);
	ses2_subnick_status_page_impl_t *spip;
	ses2_subnick_descr_impl_t *dip;
	nvlist_t *nvl = ses_node_props(np);
	int nverr, i;
	size_t len;
	uint64_t eid;

	if (nvlist_lookup_uint64(nvl, SES_EN_PROP_EID, &eid) != 0)
		return (0);

	if ((spip = ses_plugin_page_lookup(sp, snap,
	    SES2_DIAGPAGE_SUBENCLOSURE_NICKNAME_CTL_STATUS,
	    np, &len)) == NULL)
		return (0);

	if (!SES_WITHIN_PAGE_STRUCT(spip, spip, len))
		return (0);

	for (dip = &spip->sspci_subnicks[0], i = 0;
	    i <= spip->sspci_n_subenclosures;
	    i++, dip++) {
		if (!SES_WITHIN_PAGE_STRUCT(dip, spip, len))
			break;

		if (dip->ssdi_subenclosure_identifier != eid)
			continue;
		SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_NICK_STATUS,
		    dip->ssdi_subenclosure_nick_status);
		SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_NICK_ADDL_STATUS,
		    dip->ssdi_subenclosure_nick_addl_status);
		SES_NV_ADD_FS(nverr, nvl, SES_EN_PROP_NICK,
		    dip->ssdi_subenclosure_nickname);
		SES_NV_ADD(uint64, nverr, nvl, SES_EN_PROP_NICK_LANG,
		    dip->ssdi_subenclosure_nick_lang_code);
		break;
	}

	return (0);
}

int
ses2_fill_enclosure_node(ses_plugin_t *sp, ses_node_t *np)
{
	ses_snap_t *snap = ses_node_snapshot(np);
	nvlist_t *props = ses_node_props(np);
	ses2_elem_status_impl_t *esip;
	int err;
	size_t len;

	if ((esip = ses_plugin_page_lookup(sp, snap,
	    SES2_DIAGPAGE_ENCLOSURE_CTL_STATUS, np, &len)) != NULL) {
		if ((err = enc_parse_sd(esip, props)) != 0)
			return (err);
	}

	if ((err = enc_parse_help(sp, np)) != 0)
		return (err);

	if ((err = enc_parse_string_in(sp, np)) != 0)
		return (err);

	if ((err = enc_parse_descr(sp, np)) != 0)
		return (err);

	if ((err = enc_parse_dlucode(sp, np)) != 0)
		return (err);

	if ((err = enc_parse_subnick(sp, np)) != 0)
		return (err);

	return (0);
}