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

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <stdio.h>
#include <limits.h>
#include <unistd.h>
#include <sys/systeminfo.h>
#include <pthread.h>
#include <syslog.h>
#include <picl.h>
#include <picltree.h>
#include <picldefs.h>
#include <string.h>
#include <libnvpair.h>
#include <libintl.h>
#include <librcm.h>
#include <stropts.h>
#include <smclib.h>
#include <sys/sysevent/dr.h>
#include "piclenvmond.h"
#include "picldr.h"

/* local defines */
#define	RESET_CPU "/usr/sbin/shutdown -y -g 0 -i6"
#define	SHUTDOWN_CPU "/usr/sbin/shutdown -y -g 0 -i0"
#define	RCM_ABSTRACT_RESOURCE	"SUNW_snowbird/board0/CPU1"
#define	CPU_SENSOR_GEO_ADDR	0xe
#define	IS_HEALTHY		0x01
#define	PICL_NODE_SYSMGMT	"sysmgmt"
#define	SYSMGMT_PATH 		PLATFORM_PATH"/pci/pci/isa/sysmgmt"
#define	BUF_SIZE		7

/* external functions */
extern picl_errno_t env_create_property(int, int, size_t, char *,
	int (*readfn)(ptree_rarg_t *, void *),
	int (*writefn)(ptree_warg_t *, const void *),
	picl_nodehdl_t, picl_prophdl_t *, void *);
extern picl_errno_t post_dr_req_event(picl_nodehdl_t, char *, uint8_t);
extern picl_errno_t post_dr_ap_state_change_event(picl_nodehdl_t, char *,
	uint8_t);
extern boolean_t env_admin_lock_enabled(picl_nodehdl_t);
extern picl_errno_t env_create_temp_sensor_node(picl_nodehdl_t, uint8_t);
extern void env_handle_sensor_event(void *);
extern int env_open_smc();

/* external variables */
extern int env_debug;
extern uint8_t cpu_geo_addr;
extern picl_nodehdl_t rooth, platformh, sysmgmth, sensorh;
extern picl_nodehdl_t chassis_nodehdl, cpu_nodehdl, cpu_lnodehdl;

/* locals */
static pthread_mutex_t env_dmc_mutex = PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t env_dmc_cond = PTHREAD_COND_INITIALIZER;
static boolean_t env_reset_cpu = B_FALSE;
static boolean_t env_shutdown_system = B_FALSE;
static env_state_event_t env_chassis_state = FRU_STATE_UNKNOWN;
static char *rcm_abstr_cp2300_name = RCM_ABSTRACT_RESOURCE;
static boolean_t env_got_dmc_msg = B_FALSE;
static long env_dmc_wait_time = 15;
static pthread_t dmc_thr_tid;

/*
 * issue halt or reboot based on the reset_cpu flag
 */
/*ARGSUSED*/
static void
shutdown_cpu(boolean_t force)
{
	if (env_shutdown_system) {
		if (env_reset_cpu) {
			(void) pclose(popen(RESET_CPU, "w"));
		} else {
			(void) pclose(popen(SHUTDOWN_CPU, "w"));
		}
	}
}

/*
 * inform RCM framework that the remove op is successful
 */
static void
confirm_rcm(char *abstr_name, rcm_handle_t *rhandle)
{
	rcm_notify_remove(rhandle, abstr_name, 0, NULL);
}

/*
 * inform RCM framework that the remove op is failed
 */
static void
fail_rcm(char *abstr_name, rcm_handle_t *rhandle)
{
	(void) rcm_notify_online(rhandle, abstr_name, 0, NULL);
}

/*
 * check RCM framework if it is ok to offline a device
 */
static int
check_rcm(char *rcm_abstr_cp2300_name, uint_t flags)
{
	rcm_info_t *rinfo;
	rcm_handle_t *rhandle;
	int rv;

	if (rcm_alloc_handle(NULL, 0, NULL, &rhandle) != RCM_SUCCESS) {
		return (RCM_FAILURE);
	}

	rv = rcm_request_offline(rhandle, rcm_abstr_cp2300_name,
		flags, &rinfo);

	if (rv == RCM_FAILURE) {
		rcm_free_info(rinfo);
		fail_rcm(rcm_abstr_cp2300_name, rhandle);
		rcm_free_handle(rhandle);
		return (RCM_FAILURE);
	}
	if (rv == RCM_CONFLICT) {
		rcm_free_info(rinfo);
		rcm_free_handle(rhandle);
		return (RCM_CONFLICT);
	}

	confirm_rcm(rcm_abstr_cp2300_name, rhandle);
	rcm_free_info(rinfo);
	rcm_free_handle(rhandle);
	return (RCM_SUCCESS);
}

/*
 * utility routine to send response to an IPMI message
 */
static int
send_response2remote_device(uint8_t ipmb_addr, uint8_t cmd, uint8_t reqseq_lun,
	uint8_t cc)
{
	int rc = SMC_SUCCESS;
	sc_reqmsg_t req_pkt;
	sc_rspmsg_t rsp_pkt;
	uint8_t data = cc; /* completion code */

	/* make a call to ctsmc lib */
	(void) smc_init_ipmi_msg(&req_pkt, cmd, DEFAULT_FD, 1, &data,
		(reqseq_lun >> 2), ipmb_addr, SMC_NETFN_APP_RSP,
		(reqseq_lun & 0x03));
	rc = smc_send_msg(DEFAULT_FD, &req_pkt, &rsp_pkt,
		POLL_TIMEOUT);

	if (rc != SMC_SUCCESS)
		syslog(LOG_ERR, gettext("SUNW_envmond:Error in sending response"
			" to %x, error = %d"), ipmb_addr, rc);
	return (rc);
}

/*
 * do all the checks like adminlock check, rcm check and initiate
 * shutdown
 */
/*ARGSUSED*/
static int
initiate_shutdown(boolean_t force)
{
	int rv;
	uint_t	rcmflags = 0;
	struct timespec rqtp, rmtp;

	if (!env_shutdown_system) {
		return (-1);
	}

	/* check the adminlock prop */
	if ((!force) && (env_admin_lock_enabled(cpu_nodehdl))) {
		syslog(LOG_ERR, gettext("SUNW_envmond: "
			"CPU in use! Cannot shutdown"));
		return (-1);
	}

	if (force) {
		rcmflags = RCM_FORCE;
	}

	/* check with rcm framework */
	rv = check_rcm(rcm_abstr_cp2300_name, rcmflags);

	if ((rv == RCM_FAILURE) || (rv == RCM_CONFLICT)) {
		syslog(LOG_ERR, gettext("SUNW_envmond: RCM error %d, Cannot"
			" shutdown"), rv);
		return (-1);
	}

	/*
	 * force events on chassis node
	 */
	if (force) {
		if (post_dr_req_event(chassis_nodehdl, DR_REQ_OUTGOING_RES,
			NO_WAIT) == PICL_SUCCESS) {
			/* wait a little for clean up of frutree */
			rqtp.tv_sec = 5;
			rqtp.tv_nsec = 0;
			(void) nanosleep(&rqtp, &rmtp);
		}
		/*
		 * If force option is set, do it right here for now
		 * since there is no way to pass this info via events
		 * to frutree framework.
		 */
		shutdown_cpu(force);
		return (0);
	}

	if (post_dr_req_event(chassis_nodehdl, DR_REQ_OUTGOING_RES, NO_WAIT)
		!= PICL_SUCCESS) {
		syslog(LOG_ERR, gettext("SUNW_envmond:cannot shutdown "
			"the host CPU."));
		return (-1);
	}
	return (0);
}

/*
 * get the HEALTHY# line state
 * Return -1 for Error
 *         0 for HEALTHY# down
 *         1 for HEALTHY# up
 */
static int
env_get_healthy_status()
{
	sc_reqmsg_t	req_pkt;
	sc_rspmsg_t	rsp_pkt;
	uint8_t		size = 0;

	/* initialize the request packet */
	(void) smc_init_smc_msg(&req_pkt, SMC_GET_EXECUTION_STATE,
		DEFAULT_SEQN, size);

	/* make a call to smc library to send cmd */
	if (smc_send_msg(DEFAULT_FD, &req_pkt, &rsp_pkt,
		POLL_TIMEOUT) != SMC_SUCCESS) {
		return (-1);
	}
	return (rsp_pkt.data[0] & IS_HEALTHY);
}

/*
 * initialization
 */
picl_errno_t
env_platmod_init()
{
	picl_errno_t rc =  PICL_SUCCESS;

	if (rooth == 0) {
		if (ptree_get_root(&rooth) != PICL_SUCCESS) {
			return (rc);
		}
	}

	if (chassis_nodehdl == 0) {
		if ((rc = ptree_get_node_by_path(PICL_FRUTREE_CHASSIS,
			&chassis_nodehdl)) != PICL_SUCCESS) {
			return (rc);
		}
	}
	if (post_dr_req_event(chassis_nodehdl, DR_REQ_INCOMING_RES,
		NO_WAIT) != PICL_SUCCESS) {
		syslog(LOG_ERR, gettext("SUNW_envmond: Error in "
			"Posting configure event for Chassis node"));
		rc = PICL_FAILURE;
	}
	return (rc);
}

/*
 * release all the resources
 */
void
env_platmod_fini()
{
	cpu_geo_addr = 0;
	rooth = platformh = sysmgmth = 0;
	chassis_nodehdl = cpu_nodehdl = cpu_lnodehdl = 0;
	env_chassis_state = FRU_STATE_UNKNOWN;
	(void) ptree_delete_node(sensorh);
	(void) ptree_destroy_node(sensorh);
}

/*
 * handle chassis state change
 */
static void
env_handle_chassis_state_event(char *state)
{
	if (strcmp(state, PICLEVENTARGVAL_CONFIGURING) == 0) {
		env_chassis_state = FRU_STATE_CONFIGURING;
		return;
	}

	if (strcmp(state, PICLEVENTARGVAL_UNCONFIGURED) == 0) {
		if (env_chassis_state == FRU_STATE_CONFIGURING ||
			env_chassis_state == FRU_STATE_UNKNOWN) {
			/* picl intialization is failed, dont issue shutdown */
			env_chassis_state = FRU_STATE_UNCONFIGURED;
			return;
		}
		env_chassis_state = FRU_STATE_UNCONFIGURED;
		if (env_reset_cpu) {
			(void) pclose(popen(RESET_CPU, "w"));
		} else {
			(void) pclose(popen(SHUTDOWN_CPU, "w"));
		}
		return;
	}

	if (strcmp(state, PICLEVENTARGVAL_CONFIGURED) == 0) {
		env_chassis_state = FRU_STATE_CONFIGURED;
	}
}

/*
 *  event handler for watchdog state change event
 */
static picl_errno_t
env_handle_watchdog_expiry(picl_nodehdl_t wd_nodehdl)
{
	picl_errno_t rc = PICL_SUCCESS;
	char class[PICL_CLASSNAMELEN_MAX];
	char value[PICL_PROPNAMELEN_MAX];
	char cond[BUF_SIZE];

	if ((rc = ptree_get_propval_by_name(wd_nodehdl,
		PICL_PROP_CLASSNAME, class,
		PICL_CLASSNAMELEN_MAX)) != PICL_SUCCESS) {
		return (rc);
	}

	/* if the event is not of watchdog-timer, return */
	if (strcmp(class, PICL_CLASS_WATCHDOG_TIMER) != 0) {
		return (PICL_INVALIDARG);
	}

	if ((rc = ptree_get_propval_by_name(wd_nodehdl,
		PICL_PROP_WATCHDOG_ACTION, value, sizeof (value))) !=
		PICL_SUCCESS) {
		return (rc);
	}

	/* if action is none, dont do anything */
	if (strcmp(value, PICL_PROPVAL_WD_ACTION_ALARM) != 0) {
		return (PICL_SUCCESS);
	}

	(void) strncpy(cond, PICLEVENTARGVAL_FAILED, sizeof (cond));
	/* update CPU condition to failed */
	if ((rc = ptree_update_propval_by_name(cpu_nodehdl,
		PICL_PROP_CONDITION, cond, sizeof (cond))) != PICL_SUCCESS) {
		return (rc);
	}

	/* post dr ap state change event */
	rc = post_dr_ap_state_change_event(cpu_nodehdl,
		DR_RESERVED_ATTR, NO_COND_TIMEDWAIT);
	return (rc);
}

/*
 * rotine that handles all the picl state and condition change events
 */
void
env_platmod_handle_event(const char *ename, const void *earg, size_t size)
{
	picl_errno_t		rc;
	picl_nodehdl_t		nodeh = 0;
	picl_prophdl_t		proph;
	nvlist_t		*nvlp;
	char			*value;
	boolean_t		state_event;
	env_state_event_t	event;
	char			result[PICL_PROPNAMELEN_MAX];
	uint64_t		status_time, cond_time;
	char 			cond[BUF_SIZE];

	if (!ename) {
		return;
	}
	if (strcmp(ename, PICLEVENT_STATE_CHANGE) == 0) {
		state_event = B_TRUE;
	} else if (strcmp(ename, PICLEVENT_CONDITION_CHANGE) == 0) {
		state_event = B_FALSE;
	} else {
		syslog(LOG_ERR, gettext("SUNW_envmond: unknown event:%s\n"),
			ename);
		return;
	}

	/* unpack the nvlist and get the information */
	if (nvlist_unpack((char *)earg, size, &nvlp, NULL)) {
		return;
	}
	if (nvlist_lookup_uint64(nvlp, PICLEVENTARG_NODEHANDLE, &nodeh) == -1) {
		nvlist_free(nvlp);
		return;
	}
	if (nvlist_lookup_string(nvlp, (state_event) ?
		PICLEVENTARG_STATE :
		PICLEVENTARG_CONDITION, &value) != 0) {
		nvlist_free(nvlp);
		return;
	}

	if (env_debug & PICLEVENTS) {
		if (ptree_get_propval_by_name(nodeh, PICL_PROP_NAME,
			result, sizeof (result)) != PICL_SUCCESS) {
			syslog(LOG_ERR, " SUNW_envmond: error in getting"
				" node name");
			nvlist_free(nvlp);
			return;
		}
		syslog(LOG_INFO, "SUNW_envmond: %s (%s) on %s",
			ename, value, result);
	}

	if (chassis_nodehdl == 0 && state_event) {
		if (ptree_get_propval_by_name(nodeh, PICL_PROP_NAME,
			result, sizeof (result)) != PICL_SUCCESS) {
			nvlist_free(nvlp);
			return;
		}
		if (strcmp(result, PICL_NODE_CHASSIS) == 0) {
			chassis_nodehdl = nodeh;
		}
	}

	if (nodeh == chassis_nodehdl && state_event) {
		env_handle_chassis_state_event(value);
		nvlist_free(nvlp);
		return;
	}

	if (strcmp(PICLEVENTARGVAL_DISCONNECTED, value) == 0) {
		event = LOC_STATE_DISCONNECTED;
	} else if (strcmp(PICLEVENTARGVAL_CONNECTED, value) == 0) {
		event = LOC_STATE_CONNECTED;
	} else if (strcmp(PICLEVENTARGVAL_EMPTY, value) == 0) {
		event = LOC_STATE_EMPTY;
	} else if (strcmp(PICLEVENTARGVAL_CONFIGURED, value) == 0) {
		event = FRU_STATE_CONFIGURED;
	} else if (strcmp(PICLEVENTARGVAL_UNCONFIGURED, value) == 0) {
		event = FRU_STATE_UNCONFIGURED;
	} else if (strcmp(PICL_PROPVAL_WD_STATE_EXPIRED, value) == 0) {
		/* watchdog expiry event */
		if ((rc = env_handle_watchdog_expiry(nodeh)) != PICL_SUCCESS) {
			syslog(LOG_ERR, gettext("SUNW_envmond:Error in handling"
				"watchdog expiry event"));
		}
		nvlist_free(nvlp);
		return;
	} else {
		nvlist_free(nvlp);
		return;
	}

	switch (event) {
	case LOC_STATE_EMPTY:
		break;

	case LOC_STATE_DISCONNECTED:
		if (nodeh == cpu_lnodehdl) {
			(void) initiate_shutdown(B_FALSE);
		}
		break;
	case LOC_STATE_CONNECTED:
		if (nodeh != cpu_lnodehdl) {
			break;
		}
		if (ptree_get_propval_by_name(cpu_lnodehdl,
			PICL_PROP_CHILD, &cpu_nodehdl,
			sizeof (picl_nodehdl_t)) != PICL_SUCCESS) {
			syslog(LOG_ERR, gettext("SUNW_envmond:Cannot "
				"initialize CPU node handle %llx"), nodeh);
			cpu_nodehdl = 0;
		}
		break;
	case FRU_STATE_CONFIGURED:
		if (nodeh != cpu_nodehdl) {
			break;
		}
		if (ptree_get_prop_by_name(cpu_nodehdl,
			PICL_PROP_STATUS_TIME, &proph) != PICL_SUCCESS) {
				status_time = (uint64_t)time(NULL);
				(void) env_create_property(PICL_PTYPE_TIMESTAMP,
					PICL_READ, sizeof (status_time),
					PICL_PROP_STATUS_TIME, NULLREAD,
					NULLWRITE, cpu_nodehdl, &proph,
					&status_time);
		}
		if (ptree_get_prop_by_name(cpu_nodehdl,
			PICL_PROP_CONDITION_TIME, &proph) != PICL_SUCCESS) {
				cond_time = (uint64_t)time(NULL);
				(void) env_create_property(PICL_PTYPE_TIMESTAMP,
					PICL_READ, sizeof (cond_time),
					PICL_PROP_CONDITION_TIME, NULLREAD,
					NULLWRITE, cpu_nodehdl, &proph,
					&cond_time);
			}
		env_shutdown_system = B_FALSE;
		/* if HEALTHY# is UP update the condition to "ok" */
		switch (env_get_healthy_status()) {
		case 0:
		/* update CPU condition to failed */
		(void) strncpy(cond, PICLEVENTARGVAL_FAILED, sizeof (cond));
		break;
		case 1:
		/* update CPU condition to ok */
		(void) strncpy(cond, PICLEVENTARGVAL_OK, sizeof (cond));
		break;
		case -1:	/*FALLTHRU*/
		default:
		/* update the condition to unknown */
		(void) strncpy(cond, PICLEVENTARGVAL_UNKNOWN, sizeof (cond));
			syslog(LOG_ERR, gettext("SUNW_envmond:Error in "
				"reading HEALTHY# status"));
		}

		if ((rc = ptree_update_propval_by_name(cpu_nodehdl,
			PICL_PROP_CONDITION, cond, sizeof (cond))) !=
			PICL_SUCCESS) {
			syslog(LOG_ERR, gettext("SUNW_envmond:Error in "
				"updating CPU condition, error = %d"), rc);
		}
		break;
	case FRU_STATE_UNCONFIGURED:
		if (env_reset_cpu && nodeh == cpu_nodehdl) {
			(void) initiate_shutdown(B_FALSE);
		}
		break;
	default:
	break;
	} /* end of switch */
	nvlist_free(nvlp);
}

/*
 * This thread waits for dmc message to come, as it has to send
 * response ACK back to DMC. Otherwise DMC may think that message
 * is lost and issues poweroff on a node. So there is a chance for
 * CPU to be powered off in the middle of shutdown process. If the
 * DMC message didnt come, then process the local shutdown request.
 */
/*ARGSUSED*/
static void *
env_wait_for_dmc_msg(void *args)
{
	struct timeval  ct;
	struct timespec to;

	(void) pthread_mutex_lock(&env_dmc_mutex);
	if (env_got_dmc_msg == B_TRUE) {
		(void) pthread_mutex_unlock(&env_dmc_mutex);
		return (NULL);
	}

	/*
	 * wait for specified time to check if dmc sends the
	 * shutdown request
	 */
	(void) gettimeofday(&ct, NULL);
	to.tv_sec = ct.tv_sec + env_dmc_wait_time;
	to.tv_nsec = 0;
	(void) pthread_cond_timedwait(&env_dmc_cond,
		&env_dmc_mutex, &to);
	if (env_got_dmc_msg == B_TRUE) {
		(void) pthread_mutex_unlock(&env_dmc_mutex);
		return (NULL);
	}
	(void) pthread_mutex_unlock(&env_dmc_mutex);

	env_shutdown_system = B_TRUE;
	env_reset_cpu = B_FALSE;
	(void) initiate_shutdown(B_FALSE);
	return (NULL);
}

/*
 * Handle the Latch open event(shutdown the node)
 */
picl_errno_t
env_platmod_handle_latch_open()
{
	/*
	 * create a thread to process local event after waiting for DMC CPU
	 * node state offline message
	 */
	if (pthread_create(&dmc_thr_tid, NULL, &env_wait_for_dmc_msg,
		NULL) != 0) {
		syslog(LOG_ERR, gettext("SUNW_envmond:Error in creating "
			"dmc thread"));
		return (PICL_FAILURE);
	}
	return (PICL_SUCCESS);
}

/*
 * For Sanibel, hotswap initialization is not reqd.
 */
picl_errno_t
env_platmod_setup_hotswap()
{
	return (PICL_SUCCESS);
}

/*
 * For sanibel this supoort is not required
 */
picl_errno_t
env_platmod_sp_monitor()
{
	return (PICL_SUCCESS);
}

/*
 * For sanibel this supoort is not required
 */
picl_errno_t
env_platmod_create_hotswap_prop()
{
	return (PICL_SUCCESS);
}

/*
 * For sanibel this supoort is not required
 */
/*ARGSUSED*/
void
process_platmod_sp_heartbeat(uint8_t data)
{
}

/*
 * For sanibel this supoort is not required
 */
/*ARGSUSED*/
int
process_platmod_async_msg_notif(void *resdatap)
{
	return (0);
}

/*
 * For sanibel this supoort is not required
 */
/*ARGSUSED*/
int
process_platmod_change_cpci_state(void *res_datap)
{
	return (0);
}

/*
 * handle request from service processor for shutdown/online
 */
int
process_platmod_change_cpu_node_state(void *res_datap)
{
	int rc = SMC_SUCCESS;
	uint8_t state = BYTE_7(res_datap);
	boolean_t force_flag = B_FALSE;

	switch (state & 1) {
	case CPU_NODE_STATE_OFFLINE:
		(void) pthread_mutex_lock(&env_dmc_mutex);
		env_got_dmc_msg = B_TRUE;
		(void) pthread_cond_signal(&env_dmc_cond);
		(void) pthread_mutex_unlock(&env_dmc_mutex);
		env_shutdown_system = B_TRUE;
		if ((state >> 2) & 1)
			env_reset_cpu = B_TRUE;
		if (state >> 1 & 1) {	/* force flag set? */
			force_flag = B_TRUE;
		} else {
			force_flag = B_FALSE;
		}

		if (initiate_shutdown(force_flag) == 0) {
			if ((rc = send_response2remote_device(SMC_BMC_ADDR,
				EVENT_MSG_CHANGE_CPU_NODE_STATE,
				BYTE_5(res_datap), 0x0)) != SMC_SUCCESS) {
				return (rc);
			}
		} else {
			if ((rc = send_response2remote_device(SMC_BMC_ADDR,
				EVENT_MSG_CHANGE_CPU_NODE_STATE,
				BYTE_5(res_datap), 0xFF)) != SMC_SUCCESS) {
				return (rc);
			}
			env_shutdown_system = B_FALSE;
			if ((state >> 2) & 1)
				env_reset_cpu = B_FALSE;
		}
		break;
	case CPU_NODE_STATE_ONLINE:
		if ((rc =  send_response2remote_device(SMC_BMC_ADDR,
			EVENT_MSG_CHANGE_CPU_NODE_STATE,
			BYTE_5(res_datap), 0x0)) != SMC_SUCCESS) {
			return (rc);
		}
		break;
	default:
		break;
	}
	return (0);
}

/*
 * Handle change in state of service processor
 */
int
process_platmod_sp_state_change_notif(void *res_datap)
{
	int rc = SMC_SUCCESS;
	uint8_t state = BYTE_7(res_datap);
	uint8_t rq_addr = BYTE_4(res_datap);

	if (rq_addr != SMC_BMC_ADDR) {
		return (PICL_FAILURE);
	}

	switch (state) {
	case CPU_NODE_STATE_ONLINE:
		/* Send ACK to service processor */
		if ((rc = send_response2remote_device(SMC_BMC_ADDR,
			EVENT_MSG_AC_STATE_CHANGE,
			BYTE_5(res_datap), 0x0)) != SMC_SUCCESS) {
			return (rc);
		}
		break;

	case CPU_NODE_STATE_OFFLINE:
		/* Send ACK to service processor */
		if ((rc = send_response2remote_device(SMC_BMC_ADDR,
			EVENT_MSG_AC_STATE_CHANGE,
			BYTE_5(res_datap), 0x0)) != SMC_SUCCESS) {
			return (rc);
		}
		break;

	default:
		if ((rc = send_response2remote_device(SMC_BMC_ADDR,
			EVENT_MSG_AC_STATE_CHANGE,
			BYTE_5(res_datap), 0xFF)) != SMC_SUCCESS) {
			return (rc);
		}
		break;
	}
	return (0);
}

/*
 * For sanibel this supoort is not required
 */
/*ARGSUSED*/
picl_errno_t
env_platmod_handle_bus_if_change(uint8_t data)
{
	return (PICL_SUCCESS);
}

/*
 * create the temperature sensor nodes
 */
picl_errno_t
env_platmod_create_sensors()
{
	picl_errno_t rc = PICL_SUCCESS;

	if (rooth == 0) {
		if ((rc = ptree_get_root(&rooth)) != PICL_SUCCESS) {
			return (rc);
		}
	}

	if (platformh == 0) {
		if ((rc = ptree_get_node_by_path(PLATFORM_PATH,
			&platformh)) != PICL_SUCCESS) {
			return (rc);
		}
	}

	if (sysmgmth == 0) {
		if ((rc = ptree_get_node_by_path(SYSMGMT_PATH,
			&sysmgmth)) != PICL_SUCCESS) {
			return (rc);
		}
	}

	rc = env_create_temp_sensor_node(sysmgmth, CPU_SENSOR_GEO_ADDR);
	return (rc);
}

/*
 * handler for sensor event
 */
void
env_platmod_handle_sensor_event(void *res_datap)
{
	if (BYTE_4(res_datap) != CPU_SENSOR_GEO_ADDR) {
		return;
	}
	env_handle_sensor_event(res_datap);
}