/*
 * 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.
 */

/*
 * IPMI entities are a strange beast.  A reasonable assumption for those
 * unfamiliar with the spec would be that there was a command to iterate over
 * all entities, and a command to iterate over sensors associated with each
 * entity.  Instead, the entire IPMI world is derived from the SDR repository.
 * Entities only exist in the sense that they are referenced by a SDR record.
 *
 * In addition, entities can be associated into groups, and determining entity
 * presence is quite complicated.  The IPMI spec dedicates an entire chapter
 * (40) to the process of handling sensor associations.
 *
 * The above logic is implemented via the ipmi_entity_present() function.  We
 * make a first pass over the SDR repository to discover entities, creating
 * entity groups and associating SDR records with the each.
 *
 * We don't currently support device-relative entities.
 */

#include <libipmi.h>
#include <ipmi_impl.h>
#include <stddef.h>

typedef struct ipmi_entity_sdr {
	ipmi_list_t			ies_list;
	const char			*ies_name;
	ipmi_sdr_t			*ies_sdr;
} ipmi_entity_sdr_t;

typedef struct ipmi_entity_impl {
	ipmi_list_t			ie_list;
	ipmi_entity_t			ie_entity;
	struct ipmi_entity_impl		*ie_parent;
	ipmi_hash_link_t		ie_link;
	ipmi_list_t			ie_child_list;
	ipmi_list_t			ie_sdr_list;
} ipmi_entity_impl_t;

#define	ENTITY_TO_IMPL(ep)	\
	((ipmi_entity_impl_t *)((char *)(ep) - \
	offsetof(ipmi_entity_impl_t, ie_entity)))

static int
ipmi_entity_add_assoc(ipmi_handle_t *ihp, ipmi_entity_impl_t *eip,
    uint8_t id, uint8_t instance)
{
	ipmi_entity_impl_t *cp;
	ipmi_entity_t search;

	search.ie_type = id;
	search.ie_instance = instance;

	if ((cp = ipmi_hash_lookup(ihp->ih_entities, &search)) == NULL) {
		if ((cp = ipmi_zalloc(ihp,
		    sizeof (ipmi_entity_impl_t))) == NULL)
			return (-1);

		cp->ie_entity.ie_type = id;
		cp->ie_entity.ie_instance = instance;

		ipmi_hash_insert(ihp->ih_entities, cp);
	}

	if (cp->ie_parent != NULL) {
		/*
		 * This should never happen.  However, we want to be tolerant of
		 * pathologically broken IPMI implementations, so we ignore this
		 * error, and the first parent wins.
		 */
		return (0);
	}

	cp->ie_parent = eip;
	ipmi_list_append(&eip->ie_child_list, cp);
	eip->ie_entity.ie_children++;

	return (0);
}

static int
ipmi_entity_sdr_parse(ipmi_sdr_t *sdrp, uint8_t *id, uint8_t *instance,
    boolean_t *logical)
{
	switch (sdrp->is_type) {
	case IPMI_SDR_TYPE_FULL_SENSOR:
		{
			ipmi_sdr_full_sensor_t *fsp =
			    (ipmi_sdr_full_sensor_t *)sdrp->is_record;
			*id = fsp->is_fs_entity_id;
			*instance = fsp->is_fs_entity_instance;
			*logical = fsp->is_fs_entity_logical;
			break;
		}

	case IPMI_SDR_TYPE_COMPACT_SENSOR:
		{
			ipmi_sdr_compact_sensor_t *csp =
			    (ipmi_sdr_compact_sensor_t *)sdrp->is_record;
			*id = csp->is_cs_entity_id;
			*instance = csp->is_cs_entity_instance;
			*logical = csp->is_cs_entity_logical;
			break;
		}

	case IPMI_SDR_TYPE_EVENT_ONLY:
		{
			ipmi_sdr_event_only_t *eop =
			    (ipmi_sdr_event_only_t *)sdrp->is_record;
			*id = eop->is_eo_entity_id;
			*instance = eop->is_eo_entity_instance;
			*logical = eop->is_eo_entity_logical;
			break;
		}

	case IPMI_SDR_TYPE_ENTITY_ASSOCIATION:
		{
			ipmi_sdr_entity_association_t *eap =
			    (ipmi_sdr_entity_association_t *)sdrp->is_record;
			*id = eap->is_ea_entity_id;
			*instance = eap->is_ea_entity_instance;
			*logical = B_TRUE;
			break;
		}

	case IPMI_SDR_TYPE_GENERIC_LOCATOR:
		{
			ipmi_sdr_generic_locator_t *glp =
			    (ipmi_sdr_generic_locator_t *)sdrp->is_record;
			*id = glp->is_gl_entity;
			*instance = glp->is_gl_instance;
			*logical = B_FALSE;
			break;
		}

	case IPMI_SDR_TYPE_FRU_LOCATOR:
		{
			ipmi_sdr_fru_locator_t *flp =
			    (ipmi_sdr_fru_locator_t *)sdrp->is_record;
			*id = flp->is_fl_entity;
			*instance = flp->is_fl_instance;
			*logical = B_FALSE;
			break;
		}

	case IPMI_SDR_TYPE_MANAGEMENT_LOCATOR:
		{
			ipmi_sdr_management_locator_t *mlp =
			    (ipmi_sdr_management_locator_t *)sdrp->is_record;
			*id = mlp->is_ml_entity_id;
			*instance = mlp->is_ml_entity_instance;
			*logical = B_FALSE;
			break;
		}

	default:
		return (-1);
	}

	return (0);
}

/*
 * This function is responsible for gathering all entities, inserting them into
 * the global hash, and establishing any associations.
 */
/*ARGSUSED*/
static int
ipmi_entity_visit(ipmi_handle_t *ihp, const char *name, ipmi_sdr_t *sdrp,
    void *unused)
{
	uint8_t id, instance;
	boolean_t logical;
	ipmi_entity_t search;
	ipmi_entity_impl_t *eip;
	ipmi_entity_sdr_t *esp;

	if (ipmi_entity_sdr_parse(sdrp, &id, &instance, &logical) != 0)
		return (0);

	search.ie_type = id;
	search.ie_instance = instance;

	if ((eip = ipmi_hash_lookup(ihp->ih_entities, &search)) == NULL) {
		if ((eip = ipmi_zalloc(ihp,
		    sizeof (ipmi_entity_impl_t))) == NULL)
			return (-1);

		eip->ie_entity.ie_type = id;
		eip->ie_entity.ie_instance = instance;

		ipmi_hash_insert(ihp->ih_entities, eip);
	}

	eip->ie_entity.ie_logical |= logical;

	if (sdrp->is_type == IPMI_SDR_TYPE_ENTITY_ASSOCIATION) {
		uint8_t start, end;
		uint8_t i, type;

		ipmi_sdr_entity_association_t *eap =
		    (ipmi_sdr_entity_association_t *)sdrp->is_record;

		if (eap->is_ea_range) {

			type = eap->is_ea_sub[0].is_ea_sub_id;
			start = eap->is_ea_sub[0].is_ea_sub_instance;
			end = eap->is_ea_sub[1].is_ea_sub_instance;

			if (type != 0) {
				for (i = start; i <= end; i++) {
					if (ipmi_entity_add_assoc(ihp, eip,
					    type, i) != 0)
						return (-1);
				}
			}

			type = eap->is_ea_sub[2].is_ea_sub_id;
			start = eap->is_ea_sub[2].is_ea_sub_instance;
			end = eap->is_ea_sub[3].is_ea_sub_instance;

			if (type != 0) {
				for (i = start; i <= end; i++) {
					if (ipmi_entity_add_assoc(ihp, eip,
					    type, i) != 0)
						return (-1);
				}
			}
		} else {
			for (i = 0; i < 4; i++) {
				type = eap->is_ea_sub[i].is_ea_sub_id;
				instance = eap->is_ea_sub[i].is_ea_sub_instance;

				if (type == 0)
					continue;

				if (ipmi_entity_add_assoc(ihp, eip, type,
				    instance) != 0)
					return (-1);
			}
		}
	} else {
		if ((esp = ipmi_zalloc(ihp,
		    sizeof (ipmi_entity_sdr_t))) == NULL)
			return (-1);

		esp->ies_sdr = sdrp;
		esp->ies_name = name;
		ipmi_list_append(&eip->ie_sdr_list, esp);
	}

	return (0);
}

/*
 * Given a SDR record, return boolean values indicating whether the sensor
 * indicates explicit presence.
 *
 * XXX this should really share code with entity_present()
 */
int
ipmi_entity_present_sdr(ipmi_handle_t *ihp, ipmi_sdr_t *sdrp,
    boolean_t *valp)
{
	uint16_t mask;
	uint8_t number, sensor_type, reading_type;
	ipmi_sdr_compact_sensor_t *csp;
	ipmi_sdr_full_sensor_t *fsp;
	ipmi_sensor_reading_t *srp;

	switch (sdrp->is_type) {
	case IPMI_SDR_TYPE_COMPACT_SENSOR:
		csp = (ipmi_sdr_compact_sensor_t *)sdrp->is_record;
		number = csp->is_cs_number;
		sensor_type = csp->is_cs_type;
		reading_type = csp->is_cs_reading_type;
		break;

	case IPMI_SDR_TYPE_FULL_SENSOR:
		fsp = (ipmi_sdr_full_sensor_t *)sdrp->is_record;
		number = fsp->is_fs_number;
		sensor_type = fsp->is_fs_type;
		reading_type = fsp->is_fs_reading_type;
		break;

	default:
		*valp = B_FALSE;
		return (0);
	}

	switch (reading_type) {
	case IPMI_RT_PRESENT:
		mask = IPMI_SR_PRESENT_ASSERT;
		break;

	case IPMI_RT_SPECIFIC:
		switch (sensor_type) {
		case IPMI_ST_PROCESSOR:
			mask = IPMI_EV_PROCESSOR_PRESENT;
			break;

		case IPMI_ST_POWER_SUPPLY:
			mask = IPMI_EV_POWER_SUPPLY_PRESENT;
			break;

		case IPMI_ST_MEMORY:
			mask = IPMI_EV_MEMORY_PRESENT;
			break;

		case IPMI_ST_BAY:
			mask = IPMI_EV_BAY_PRESENT;
			break;

		default:
			*valp = B_FALSE;
			return (0);
		}
		break;

	default:
		*valp = B_FALSE;
		return (0);
	}

	/*
	 * If we've reached here, then we have a dedicated sensor that
	 * indicates presence.
	 */
	if ((srp = ipmi_get_sensor_reading(ihp, number)) == NULL) {
		if (ipmi_errno(ihp) == EIPMI_NOT_PRESENT) {
			*valp = B_FALSE;
			return (0);
		}

		return (-1);
	}

	*valp = (srp->isr_state & mask) != 0;
	return (0);
}

/*
 * This function follows the procedure documented in section 40 of the spec.
 * To quote the conclusion from section 40.2:
 *
 * 	Thus, the steps to detecting an Entity are:
 *
 * 	a) Scan the SDRs for sensors associated with the entity.
 *
 * 	b) If there is an active sensor that includes a presence bit, or the
 *	   entity has an active Entity Presence sensor, use the sensor to
 *	   determine the presence of the entity.
 *
 * 	c) Otherwise, check to see that there is at least one active sensor
 *	   associated with the entity.  Do this by doing 'Get Sensor Readings'
 *	   to the sensors associated with the entity until a scanning sensor is
 *	   found.
 *
 * 	d) If there are no active sensors directly associated with the entity,
 *	   check the SDRs to see if the entity is a container entity in an
 *	   entity-association.  If so, check to see if any of the contained
 *	   entities are present, if so, assume the container entity exists.
 *	   Note that this may need to be iterative, since it's possible to have
 *	   multi-level entity associations.
 *
 * 	e) If there are no active sensors for the entity, and the entity is not
 *	   the container entity in an active entity-assocation, then the entity
 *         is present if (sic) there there is a FRU device for the entity, and
 *         the FRU device is present.
 *
 *	It should not be considered an error if a FRU device locator record is
 *	present for a FRU device, but the FRU device is not there.
 *
 */
int
ipmi_entity_present(ipmi_handle_t *ihp, ipmi_entity_t *ep, boolean_t *valp)
{
	/* LINTED - alignment */
	ipmi_entity_impl_t *eip = ENTITY_TO_IMPL(ep);
	ipmi_entity_impl_t *cp;
	ipmi_entity_sdr_t *esp;
	ipmi_sdr_t *sdrp;
	uint16_t mask;
	uint8_t number, sensor_type, reading_type;
	ipmi_sensor_reading_t *srp;
	ipmi_sdr_compact_sensor_t *csp;
	ipmi_sdr_full_sensor_t *fsp;
	ipmi_sdr_fru_locator_t *frup;
	char *frudata;

	/*
	 * Search the sensors for a present sensor or a discrete sensor that
	 * indicates presence.
	 */
	for (esp = ipmi_list_next(&eip->ie_sdr_list); esp != NULL;
	    esp = ipmi_list_next(esp)) {
		sdrp = esp->ies_sdr;
		switch (sdrp->is_type) {
		case IPMI_SDR_TYPE_COMPACT_SENSOR:
			csp = (ipmi_sdr_compact_sensor_t *)sdrp->is_record;
			number = csp->is_cs_number;
			sensor_type = csp->is_cs_type;
			reading_type = csp->is_cs_reading_type;
			break;

		case IPMI_SDR_TYPE_FULL_SENSOR:
			fsp = (ipmi_sdr_full_sensor_t *)sdrp->is_record;
			number = fsp->is_fs_number;
			sensor_type = fsp->is_fs_type;
			reading_type = fsp->is_fs_reading_type;
			break;

		default:
			continue;
		}

		switch (reading_type) {
		case IPMI_RT_PRESENT:
			mask = IPMI_SR_PRESENT_ASSERT;
			break;

		case IPMI_RT_SPECIFIC:
			switch (sensor_type) {
			case IPMI_ST_PROCESSOR:
				mask = IPMI_EV_PROCESSOR_PRESENT;
				break;

			case IPMI_ST_POWER_SUPPLY:
				mask = IPMI_EV_POWER_SUPPLY_PRESENT;
				break;

			case IPMI_ST_MEMORY:
				mask = IPMI_EV_MEMORY_PRESENT;
				break;

			case IPMI_ST_BAY:
				mask = IPMI_EV_BAY_PRESENT;
				break;

			default:
				continue;
			}
			break;

		default:
			continue;
		}

		/*
		 * If we've reached here, then we have a dedicated sensor that
		 * indicates presence.
		 */
		if ((srp = ipmi_get_sensor_reading(ihp, number)) == NULL) {
			if (ipmi_errno(ihp) == EIPMI_NOT_PRESENT) {
				*valp = B_FALSE;
				return (0);
			}

			return (-1);
		}

		*valp = (srp->isr_state & mask) != 0;
		return (0);
	}

	/*
	 * No explicit presence sensor was found.  See if there is at least one
	 * active sensor associated with the entity.
	 */
	for (esp = ipmi_list_next(&eip->ie_sdr_list); esp != NULL;
	    esp = ipmi_list_next(esp)) {
		sdrp = esp->ies_sdr;
		switch (sdrp->is_type) {
		case IPMI_SDR_TYPE_COMPACT_SENSOR:
			csp = (ipmi_sdr_compact_sensor_t *)sdrp->is_record;
			number = csp->is_cs_number;
			break;

		case IPMI_SDR_TYPE_FULL_SENSOR:
			fsp = (ipmi_sdr_full_sensor_t *)sdrp->is_record;
			number = fsp->is_fs_number;
			break;

		default:
			continue;
		}

		if ((srp = ipmi_get_sensor_reading(ihp, number)) == NULL) {
			if (ipmi_errno(ihp) == EIPMI_NOT_PRESENT)
				continue;

			return (-1);
		}

		if (srp->isr_scanning_enabled) {
			*valp = B_TRUE;
			return (0);
		}
	}

	/*
	 * If this entity has children, then it is present if any of its
	 * children are present.
	 */
	for (cp = ipmi_list_next(&eip->ie_child_list); cp != NULL;
	    cp = ipmi_list_next(cp)) {
		if (ipmi_entity_present(ihp, &cp->ie_entity, valp) != 0)
			return (-1);

		if (*valp)
			return (0);
	}

	/*
	 * If the FRU device is present, then the entity is present.
	 */
	for (esp = ipmi_list_next(&eip->ie_sdr_list); esp != NULL;
	    esp = ipmi_list_next(esp)) {
		sdrp = esp->ies_sdr;
		if (sdrp->is_type != IPMI_SDR_TYPE_FRU_LOCATOR)
			continue;

		frup = (ipmi_sdr_fru_locator_t *)sdrp->is_record;
		if (ipmi_fru_read(ihp, frup, &frudata) >= 0) {
			ipmi_free(ihp, frudata);
			*valp = B_TRUE;
			return (0);
		}

		if (ipmi_errno(ihp) != EIPMI_NOT_PRESENT)
			return (-1);
	}

	*valp = B_FALSE;
	return (0);
}

static int
ipmi_entity_refresh(ipmi_handle_t *ihp)
{
	if (ipmi_hash_first(ihp->ih_entities) != NULL &&
	    !ipmi_sdr_changed(ihp))
		return (0);

	if (ipmi_sdr_iter(ihp, ipmi_entity_visit, NULL) != 0)
		return (-1);

	return (0);
}

int
ipmi_entity_iter(ipmi_handle_t *ihp, int (*func)(ipmi_handle_t *,
    ipmi_entity_t *, void *), void *data)
{
	ipmi_entity_impl_t *eip;
	int ret;

	if (ipmi_entity_refresh(ihp) != 0)
		return (-1);

	for (eip = ipmi_hash_first(ihp->ih_entities); eip != NULL;
	    eip = ipmi_hash_next(ihp->ih_entities, eip)) {
		if (eip->ie_parent != NULL)
			continue;

		if ((ret = func(ihp, &eip->ie_entity, data)) != 0)
			return (ret);
	}

	return (0);
}

int
ipmi_entity_iter_sdr(ipmi_handle_t *ihp, ipmi_entity_t *ep,
    int (*func)(ipmi_handle_t *, ipmi_entity_t *, const char *, ipmi_sdr_t *,
    void *), void *data)
{
	/* LINTED - alignment */
	ipmi_entity_impl_t *eip = ENTITY_TO_IMPL(ep);
	ipmi_entity_sdr_t *isp;
	int ret;

	for (isp = ipmi_list_next(&eip->ie_sdr_list); isp != NULL;
	    isp = ipmi_list_next(isp)) {
		if ((ret = func(ihp, ep, isp->ies_name,
		    isp->ies_sdr, data)) != 0)
			return (ret);
	}

	return (0);
}

int
ipmi_entity_iter_children(ipmi_handle_t *ihp, ipmi_entity_t *ep,
    int (*func)(ipmi_handle_t *, ipmi_entity_t *, void *), void *data)
{
	/* LINTED - alignment */
	ipmi_entity_impl_t *eip = ENTITY_TO_IMPL(ep);
	ipmi_entity_impl_t *cp;
	int ret;

	for (cp = ipmi_list_next(&eip->ie_child_list); cp != NULL;
	    cp = ipmi_list_next(cp)) {
		if ((ret = func(ihp, &cp->ie_entity, data)) != 0)
			return (ret);
	}

	return (0);
}

ipmi_entity_t *
ipmi_entity_parent(ipmi_handle_t *ihp, ipmi_entity_t *ep)
{
	/* LINTED - alignment */
	ipmi_entity_impl_t *eip = ENTITY_TO_IMPL(ep);

	if (eip->ie_parent == NULL) {
		(void) ipmi_set_error(ihp, EIPMI_NOT_PRESENT, NULL);
		return (NULL);
	}

	return (&eip->ie_parent->ie_entity);
}

ipmi_entity_t *
ipmi_entity_lookup(ipmi_handle_t *ihp, uint8_t type, uint8_t instance)
{
	ipmi_entity_t search;
	ipmi_entity_impl_t *eip;

	if (ipmi_entity_refresh(ihp) != 0)
		return (NULL);

	search.ie_type = type;
	search.ie_instance = instance;

	if ((eip = ipmi_hash_lookup(ihp->ih_entities, &search)) == NULL) {
		(void) ipmi_set_error(ihp, EIPMI_NOT_PRESENT, NULL);
		return (NULL);
	}

	return (&eip->ie_entity);
}

ipmi_entity_t *
ipmi_entity_lookup_sdr(ipmi_handle_t *ihp, const char *name)
{
	ipmi_sdr_t *sdrp;
	uint8_t id, instance;
	boolean_t logical;

	if ((sdrp = ipmi_sdr_lookup(ihp, name)) == NULL)
		return (NULL);

	if (ipmi_entity_sdr_parse(sdrp, &id, &instance, &logical) != 0) {
		(void) ipmi_set_error(ihp, EIPMI_NOT_PRESENT,
		    "SDR record %s has no associated entity", name);
		return (NULL);
	}

	return (ipmi_entity_lookup(ihp, id, instance));
}

static const void *
ipmi_entity_hash_convert(const void *p)
{
	const ipmi_entity_impl_t *eip = p;

	return (&eip->ie_entity);
}

static ulong_t
ipmi_entity_hash_compute(const void *p)
{
	const ipmi_entity_t *ep = p;

	return ((ep->ie_type << 8) | ep->ie_instance);
}

static int
ipmi_entity_hash_compare(const void *a, const void *b)
{
	const ipmi_entity_t *ea = a;
	const ipmi_entity_t *eb = b;

	if (ea->ie_type == eb->ie_type &&
	    ea->ie_instance == eb->ie_instance)
		return (0);
	else
		return (-1);
}

int
ipmi_entity_init(ipmi_handle_t *ihp)
{
	if ((ihp->ih_entities = ipmi_hash_create(ihp,
	    offsetof(ipmi_entity_impl_t, ie_link),
	    ipmi_entity_hash_convert,
	    ipmi_entity_hash_compute,
	    ipmi_entity_hash_compare)) == NULL)
		return (-1);

	return (0);
}

void
ipmi_entity_clear(ipmi_handle_t *ihp)
{
	ipmi_entity_impl_t *eip;
	ipmi_entity_sdr_t *esp;

	while ((eip = ipmi_hash_first(ihp->ih_entities)) != NULL) {
		while ((esp = ipmi_list_next(&eip->ie_sdr_list)) != NULL) {
			ipmi_list_delete(&eip->ie_sdr_list, esp);
			ipmi_free(ihp, esp);
		}
		ipmi_hash_remove(ihp->ih_entities, eip);
		ipmi_free(ihp, eip);
	}
}

void
ipmi_entity_fini(ipmi_handle_t *ihp)
{
	if (ihp->ih_entities != NULL) {
		ipmi_entity_clear(ihp);
		ipmi_hash_destroy(ihp->ih_entities);
	}
}