xref: /illumos-gate/usr/src/uts/sun4u/lw8/io/lw8.c (revision d1d6926f)

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


#include <sys/time.h>
#include <sys/errno.h>
#include <sys/kmem.h>
#include <sys/stat.h>
#include <sys/cmn_err.h>

#include <sys/conf.h>
#include <sys/modctl.h>
#include <sys/devops.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/callb.h>
#include <sys/disp.h>
#include <sys/strlog.h>

#include <sys/sgevents.h>
#include <sys/serengeti.h>
#include <sys/sgsbbc.h>
#include <sys/sgsbbc_iosram.h>
#include <sys/sgsbbc_mailbox.h>
#include <sys/uadmin.h>
#include <sys/machsystm.h>
#include <sys/sysevent.h>
#include <sys/sysevent/dr.h>
#include <sys/sysevent/eventdefs.h>
#include <sys/file.h>
#include <sys/lw8.h>
#include <sys/lw8_impl.h>
#include <sys/plat_ecc_unum.h>

/*
 * Global Variables - can be patched from Solaris
 * ==============================================
 */

/*
 * Module Variables
 * ================
 */

/*
 * functions local to this driver.
 */
static int	lw8_attach(dev_info_t *dip, ddi_attach_cmd_t cmd);
static int	lw8_detach(dev_info_t *dip, ddi_detach_cmd_t cmd);
static int	lw8_add_intr_handlers(void);
static int	lw8_remove_intr_handlers(void);
static void lw8_wakeup_sleepers(void);
static uint_t	lw8_fast_shutdown(char *arg);
static uint_t	lw8_slow_shutdown(char *arg);
static uint_t	lw8_event_data_handler(char *);
static uint_t	lw8_dr_data_handler(char *);
static uint_t	lw8_env_data_handler(char *);
static uint_t	lw8_cap_ecc_msg_handler(char *);
static int	lw8_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p);
static int	lw8_close(dev_t dev, int flag, int otyp, cred_t *cred_p);
static int	lw8_ioctl(dev_t dev, int cmd, intptr_t arg, int mode,
    cred_t *cred_p, int *rval_p);
static void	lw8_logger_start(void);
static void	lw8_logger_destroy(void);
static void	lw8_logger_wakeup(void);

/*
 * Driver entry points
 */
static struct cb_ops lw8_cb_ops = {
	lw8_open,	/* open */
	lw8_close,	/* close */
	nodev,		/* strategy() */
	nodev,		/* print() */
	nodev,		/* dump() */
	nodev,		/* read() */
	nodev,		/* write() */
	lw8_ioctl,	/* ioctl() */
	nodev,		/* devmap() */
	nodev,		/* mmap() */
	ddi_segmap,	/* segmap() */
	nochpoll,	/* poll() */
	ddi_prop_op,    /* prop_op() */
	NULL,		/* cb_str */
	D_NEW | D_MP	/* cb_flag */
};


static struct dev_ops lw8_ops = {
	DEVO_REV,
	0,			/* ref count */
	ddi_getinfo_1to1,	/* getinfo() */
	nulldev,		/* identify() */
	nulldev,		/* probe() */
	lw8_attach,		/* attach() */
	lw8_detach,		/* detach */
	nodev,			/* reset */
	&lw8_cb_ops,		/* pointer to cb_ops structure */
	(struct bus_ops *)NULL,
	nulldev,		/* power() */
	ddi_quiesce_not_needed,		/* quiesce() */
};

/*
 * Loadable module support.
 */
extern struct mod_ops mod_driverops;

static struct modldrv modldrv = {
	&mod_driverops,			/* Type of module. This is a driver */
	"Netra-T12 control driver",	/* Name of the module */
	&lw8_ops			/* pointer to the dev_ops structure */
};

static struct modlinkage modlinkage = {
	MODREV_1,
	&modldrv,
	NULL
};

/*
 * messages
 */
#define	SHUTDOWN_EVENT_MSG		"lw8: system shutdown due to " \
					"SC request.\n"
#define	VOLTAGE_EVENT_MSG		"lw8: system shutdown due to " \
					"voltage out of range.\n"
#define	TEMPERATURE_EVENT_MSG		"lw8: system shutdown due to " \
					"temperature exceeding limits.\n"
#define	FANFAIL_EVENT_MSG		"lw8: system shutdown due to " \
					"too many fan failures.\n"
#define	NO_SCC_EVENT_MSG		"lw8: system shutdown due to " \
					"no system configuration card.\n"

/*
 * led table - the following provides a cache of the led state - needed
 * to avoid the overhead of readoing from the SC each time
 */

struct led_info {
	char	id[MAX_ID_LEN];
	int	position;
	int	status;
	char	color[MAX_COLOR_LEN];
};

static struct fru_led_info {
	char    location[MAX_LOCATION_LEN];
	struct led_info led_info[MAX_LEDS_PER_FRU];
} fru_led_table[MAX_FRUS] = {
	"SB0", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"ok_to_remove", LOM_LED_POSITION_FRU, 0, "amber"},
	"PS0", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"predicted_fault", LOM_LED_POSITION_FRU, 0, "amber"},
	"SB2", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"ok_to_remove", LOM_LED_POSITION_FRU, 0, "amber"},
	"PS1", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"predicted_fault", LOM_LED_POSITION_FRU, 0, "amber"},
	"SB4", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"ok_to_remove", LOM_LED_POSITION_FRU, 0, "amber"},
	"PS2", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"predicted_fault", LOM_LED_POSITION_FRU, 0, "amber"},
	"IB6", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"ok_to_remove", LOM_LED_POSITION_FRU, 0, "amber"},
	"PS3", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"predicted_fault", LOM_LED_POSITION_FRU, 0, "amber"},
	"FT0", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"ok_to_remove", LOM_LED_POSITION_FRU, 0, "amber"},
	"FAN0", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"FAN1", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"FAN2", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"FAN3", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"FAN4", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"FAN5", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"FAN6", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"FAN7", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"FAN8", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"FAN9", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber"},
	"DISK0", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber",
		"power", LOM_LED_POSITION_LOCATION, 0, "green",
		"ok_to_remove", LOM_LED_POSITION_LOCATION, 0, "blue"},
	"DISK1", {"fault", LOM_LED_POSITION_LOCATION, 0, "amber",
		"power", LOM_LED_POSITION_LOCATION, 0, "green",
		"ok_to_remove", LOM_LED_POSITION_LOCATION, 0, "blue"},
	"RP0", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"ok_to_remove", LOM_LED_POSITION_FRU, 0, "amber"},
	"RP2", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"ok_to_remove", LOM_LED_POSITION_FRU, 0, "amber"},
	"chassis", {"fault", LOM_LED_POSITION_FRU, 0, "amber",
		"power", LOM_LED_POSITION_FRU, 0, "green",
		"locator", LOM_LED_POSITION_FRU, 0, "white",
		"top_access", LOM_LED_POSITION_FRU, 0, "amber",
		"alarm1", LOM_LED_POSITION_FRU, 0, "amber",
		"alarm2", LOM_LED_POSITION_FRU, 0, "amber",
		"system", LOM_LED_POSITION_FRU, 0, "green",
		"supplyA", LOM_LED_POSITION_FRU, 0, "green",
		"supplyB", LOM_LED_POSITION_FRU, 0, "green"},
};

char    *fru_locn[MAX_LOCATION_LEN] = {
	"SB0",
	"PS0",
	"SB2",
	"PS1",
	"SB4",
	"PS2",
	"IB6",
	"PS3",
	"SCC",
	"SSC1",
};

/*
 * mutexes which protect the interrupt handlers.
 */
static kmutex_t		lw8_shutdown_hdlr_lock;
static kmutex_t		lw8_dr_hdlr_lock;
static kmutex_t		lw8_env_hdlr_lock;
static kmutex_t		lw8_event_mutex;
static kmutex_t		lw8_logger_lock;
static kmutex_t		lw8_cap_msg_hdlr_lock;
static kcondvar_t	lw8_event_cv;
static kcondvar_t	lw8_logger_sig_cv;

/*
 * state booleans
 */
static boolean_t	lw8_event_pending = B_FALSE;
static boolean_t	led_state_cached = B_FALSE;

/*
 * Payloads of the event handlers.
 */
static lw8_event_t	lw8_shutdown_payload;
static sbbc_msg_t	lw8_shutdown_payload_msg;
static sg_system_fru_descriptor_t	lw8_dr_payload;
static sbbc_msg_t	lw8_dr_payload_msg;
static sg_event_fan_status_t		lw8_env_payload;
static sbbc_msg_t	lw8_env_payload_msg;
static plat_capability_data_t	lw8_cap_payload;
static sbbc_msg_t	lw8_cap_payload_msg;

/*
 * The IDs of the soft interrupts
 */
static ddi_softintr_t   lw8_slow_shutdown_softint_id;
static ddi_softintr_t   lw8_fast_shutdown_softint_id;

/*
 * Logger commands..
 */
#define	LW8_LOGGER_EXITNOW	-1
#define	LW8_LOGGER_WAIT	0
#define	LW8_LOGGER_PROCESSNOW	1

/*
 * Logger thread state
 */
static int lw8_logger_sig = LW8_LOGGER_WAIT;
static kt_did_t lw8_logger_tid = 0;

extern pri_t maxclsyspri;

int
_init(void)
{
	int	error = 0;

	mutex_init(&lw8_shutdown_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&lw8_dr_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&lw8_env_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&lw8_cap_msg_hdlr_lock, NULL, MUTEX_DEFAULT, NULL);
	mutex_init(&lw8_event_mutex, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&lw8_logger_lock, NULL, MUTEX_DRIVER, NULL);
	cv_init(&lw8_event_cv, NULL, CV_DRIVER, NULL);
	cv_init(&lw8_logger_sig_cv, NULL, CV_DRIVER, NULL);

	error = mod_install(&modlinkage);
	if (error) {
		cv_destroy(&lw8_logger_sig_cv);
		cv_destroy(&lw8_event_cv);
		mutex_destroy(&lw8_logger_lock);
		mutex_destroy(&lw8_event_mutex);
		mutex_destroy(&lw8_env_hdlr_lock);
		mutex_destroy(&lw8_cap_msg_hdlr_lock);
		mutex_destroy(&lw8_dr_hdlr_lock);
		mutex_destroy(&lw8_shutdown_hdlr_lock);
	}
	return (error);
}


int
_info(struct modinfo *modinfop)
{
	return (mod_info(&modlinkage, modinfop));
}


int
_fini(void)
{
	int	error = 0;

	error = mod_remove(&modlinkage);
	if (error)
		return (error);
	cv_destroy(&lw8_logger_sig_cv);
	cv_destroy(&lw8_event_cv);
	mutex_destroy(&lw8_logger_lock);
	mutex_destroy(&lw8_event_mutex);
	mutex_destroy(&lw8_env_hdlr_lock);
	mutex_destroy(&lw8_cap_msg_hdlr_lock);
	mutex_destroy(&lw8_dr_hdlr_lock);
	mutex_destroy(&lw8_shutdown_hdlr_lock);
	return (error);
}


static int
lw8_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
{
	int			instance;
	int			err;

	switch (cmd) {
	case DDI_ATTACH:
		/*
		 * only allow one instance
		 */
		instance = ddi_get_instance(dip);
		if (instance != 0)
			return (DDI_FAILURE);

		err = ddi_create_minor_node(dip, "lw8", S_IFCHR,
		    instance, DDI_PSEUDO, 0);
		if (err != DDI_SUCCESS)
			return (DDI_FAILURE);

		err = ddi_add_softintr(dip, DDI_SOFTINT_LOW,
		    &lw8_slow_shutdown_softint_id, NULL, NULL,
		    lw8_slow_shutdown, NULL);
		if (err != 0) {
			cmn_err(CE_WARN, "Failed to add polling softint"
			    "handler for lw8. Err=%d", err);
			ddi_remove_minor_node(dip, NULL);
			return (DDI_FAILURE);
		}

		err = ddi_add_softintr(dip, DDI_SOFTINT_LOW,
		    &lw8_fast_shutdown_softint_id, NULL, NULL,
		    lw8_fast_shutdown, NULL);
		if (err != 0) {
			cmn_err(CE_WARN, "Failed to add polling softint"
			    "handler for lw8. Err=%d", err);
			ddi_remove_softintr(lw8_slow_shutdown_softint_id);
			ddi_remove_minor_node(dip, NULL);
			return (DDI_FAILURE);
		}

		lw8_logger_start();

		/*
		 * Add the handlers which watch for unsolicited messages
		 * and post event to Sysevent Framework.
		 */
		err = lw8_add_intr_handlers();
		if (err != DDI_SUCCESS) {
			cmn_err(CE_WARN, "Failed to add event handlers");
			lw8_logger_destroy();
			ddi_remove_softintr(lw8_fast_shutdown_softint_id);
			ddi_remove_softintr(lw8_slow_shutdown_softint_id);
			ddi_remove_minor_node(dip, NULL);
			return (DDI_FAILURE);
		}

		ddi_report_dev(dip);
		return (DDI_SUCCESS);
	case DDI_RESUME:
		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}
}


static int
lw8_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
{
	int	instance;
	int	err;

	switch (cmd) {
	case DDI_DETACH:
		instance = ddi_get_instance(dip);
		if (instance != 0)
			return (DDI_FAILURE);

		/*
		 * Remove the handlers which watch for unsolicited messages
		 * and post event to Sysevent Framework.
		 */
		err = lw8_remove_intr_handlers();
		if (err != DDI_SUCCESS) {
			cmn_err(CE_WARN, "Failed to remove event handlers");
			return (DDI_FAILURE);
		}
		lw8_logger_destroy();
		ddi_remove_softintr(lw8_slow_shutdown_softint_id);
		ddi_remove_softintr(lw8_fast_shutdown_softint_id);
		ddi_remove_minor_node(dip, NULL);
		return (DDI_SUCCESS);
	case DDI_SUSPEND:
		return (DDI_SUCCESS);
	default:
		return (DDI_FAILURE);
	}
}

static int
lw8_add_intr_handlers()
{
	int	err;

	lw8_shutdown_payload_msg.msg_buf = (caddr_t)&lw8_shutdown_payload;
	lw8_shutdown_payload_msg.msg_len = sizeof (lw8_shutdown_payload);
	err = sbbc_mbox_reg_intr(MBOX_EVENT_LW8, lw8_event_data_handler,
	    &lw8_shutdown_payload_msg, NULL, &lw8_shutdown_hdlr_lock);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to register MBOX_EVENT_LW8 "
		    " handler. Err=%d", err);
		return (DDI_FAILURE);
	}

	lw8_dr_payload_msg.msg_buf = (caddr_t)&lw8_dr_payload;
	lw8_dr_payload_msg.msg_len = sizeof (lw8_dr_payload);
	err = sbbc_mbox_reg_intr(MBOX_EVENT_GENERIC, lw8_dr_data_handler,
	    &lw8_dr_payload_msg, NULL, &lw8_dr_hdlr_lock);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to register MBOX_EVENT_GENERIC "
		    " handler. Err=%d", err);
		(void) sbbc_mbox_unreg_intr(MBOX_EVENT_LW8,
		    lw8_event_data_handler);
		return (DDI_FAILURE);
	}

	lw8_env_payload_msg.msg_buf = (caddr_t)&lw8_env_payload;
	lw8_env_payload_msg.msg_len = sizeof (lw8_env_payload);
	err = sbbc_mbox_reg_intr(MBOX_EVENT_ENV, lw8_env_data_handler,
	    &lw8_env_payload_msg, NULL, &lw8_env_hdlr_lock);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to register MBOX_EVENT_ENV "
		    " handler. Err=%d", err);
		(void) sbbc_mbox_unreg_intr(MBOX_EVENT_GENERIC,
		    lw8_dr_data_handler);
		(void) sbbc_mbox_unreg_intr(MBOX_EVENT_LW8,
		    lw8_event_data_handler);
		return (DDI_FAILURE);
	}

	lw8_cap_payload_msg.msg_buf = (caddr_t)&lw8_cap_payload;
	lw8_cap_payload_msg.msg_len = sizeof (lw8_cap_payload);
	err = sbbc_mbox_reg_intr(INFO_MBOX, lw8_cap_ecc_msg_handler,
	    &lw8_cap_payload_msg, NULL, &lw8_cap_msg_hdlr_lock);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to register INFO_MBOX "
		    " handler. Err=%d", err);
		(void) sbbc_mbox_unreg_intr(MBOX_EVENT_GENERIC,
		    lw8_dr_data_handler);
		(void) sbbc_mbox_unreg_intr(MBOX_EVENT_LW8,
		    lw8_event_data_handler);
		(void) sbbc_mbox_unreg_intr(INFO_MBOX,
		    lw8_cap_ecc_msg_handler);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

static int
lw8_remove_intr_handlers(void)
{
	int	rv = DDI_SUCCESS;
	int	err;

	err = sbbc_mbox_unreg_intr(MBOX_EVENT_LW8, lw8_event_data_handler);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to unregister MBOX_EVENT_LW8 "
		    "handler. Err=%d", err);
		rv = DDI_FAILURE;
	}
	err = sbbc_mbox_unreg_intr(MBOX_EVENT_GENERIC, lw8_dr_data_handler);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to unregister MBOX_EVENT_GENERIC "
		    "handler. Err=%d", err);
		rv = DDI_FAILURE;
	}
	err = sbbc_mbox_unreg_intr(MBOX_EVENT_ENV, lw8_env_data_handler);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to unregister MBOX_EVENT_ENV "
		    "handler. Err=%d", err);
		rv = DDI_FAILURE;
	}
	err = sbbc_mbox_unreg_intr(INFO_MBOX, lw8_cap_ecc_msg_handler);
	if (err != 0) {
		cmn_err(CE_WARN, "Failed to unregister INFO_MBOX "
		    "handler. Err=%d", err);
		rv = DDI_FAILURE;
	}
	return (rv);
}

static uint_t
lw8_dr_data_handler(char *arg)
{
	sg_system_fru_descriptor_t	*payload;
	sbbc_msg_t			*msg;
	int				hint;
	sysevent_t			*ev;
	sysevent_id_t			eid;
	int				rv = 0;
	sysevent_value_t		evnt_val;
	sysevent_attr_list_t		*evnt_attr_list = NULL;
	char				attach_pnt[MAXPATHLEN];

	msg = (sbbc_msg_t *)arg;
	if (msg == NULL) {
		return (DDI_INTR_CLAIMED);
	}
	payload = (sg_system_fru_descriptor_t *)msg->msg_buf;
	if (payload == NULL) {
		return (DDI_INTR_CLAIMED);
	}
	if (payload->slot < 0 || payload->slot >= sizeof (fru_locn) /
	    sizeof (char *)) {
		return (DDI_INTR_CLAIMED);
	}

	/*
	 * if not SB send sysevent (SBs send sysevent from ssm driver)
	 */
	if (strncmp(fru_locn[payload->slot], "SB", 2) != 0) {
		switch (payload->event_details) {
		case SG_EVT_BOARD_ABSENT:
			hint = SE_HINT_REMOVE;
			break;
		case SG_EVT_BOARD_PRESENT:
			hint = SE_HINT_INSERT;
			break;
		default:
			hint = SE_NO_HINT;
			break;
		}
		(void) snprintf(attach_pnt, sizeof (attach_pnt), "ssm0:N0.%s",
		    fru_locn[payload->slot]);
		ev = sysevent_alloc(EC_DR, ESC_DR_AP_STATE_CHANGE, EP_DDI,
		    KM_NOSLEEP);
		if (ev == NULL) {
			cmn_err(CE_WARN, "Failed to allocate %s event", EC_DR);
			return (DDI_INTR_CLAIMED);
		}
		evnt_val.value_type = SE_DATA_TYPE_STRING;
		evnt_val.value.sv_string = attach_pnt;
		rv = sysevent_add_attr(&evnt_attr_list, DR_AP_ID, &evnt_val,
		    KM_NOSLEEP);
		if (rv != 0) {
			cmn_err(CE_WARN, "Failed to add attr [%s] for %s event",
			    DR_AP_ID, EC_DR);
			sysevent_free(ev);
			return (DDI_INTR_CLAIMED);
		}

		/*
		 * Add the hint
		 */
		evnt_val.value_type = SE_DATA_TYPE_STRING;
		evnt_val.value.sv_string = SE_HINT2STR(hint);
		rv = sysevent_add_attr(&evnt_attr_list, DR_HINT, &evnt_val,
		    KM_NOSLEEP);
		if (rv != 0) {
			cmn_err(CE_WARN, "Failed to add attr [%s] for %s event",
			    DR_HINT, EC_DR);
			sysevent_free_attr(evnt_attr_list);
			sysevent_free(ev);
			return (DDI_INTR_CLAIMED);
		}
		if (sysevent_attach_attributes(ev, evnt_attr_list) != 0) {
			cmn_err(CE_WARN, "Failed to attach attr list for %s "
			    "event", EC_DR);
			sysevent_free_attr(evnt_attr_list);
			sysevent_free(ev);
			return (DDI_INTR_CLAIMED);
		}
		rv = log_sysevent(ev, KM_NOSLEEP, &eid);
		if (rv != 0) {
			cmn_err(CE_WARN,
			    "lw8_dr_event_handler: failed to log event");
		}
		sysevent_free(ev);
	}
	lw8_wakeup_sleepers();
	return (DDI_INTR_CLAIMED);
}

static uint_t
lw8_cap_ecc_msg_handler(char *addr)
{
	sbbc_msg_t *msg = NULL;
	plat_capability_data_t *cap = NULL;

	msg = (sbbc_msg_t *)addr;
	if (msg == NULL || msg->msg_buf == NULL)
		return (DDI_INTR_CLAIMED);

	cap = (plat_capability_data_t *)msg->msg_buf;
	switch (cap->capd_msg_type) {
	case PLAT_ECC_CAPABILITY_MESSAGE:
		plat_ecc_capability_sc_set(cap->capd_capability);
		break;
	default:
		break;
	}

	return (DDI_INTR_CLAIMED);
}

/*ARGSUSED*/
static uint_t
lw8_env_data_handler(char *arg)
{
	lw8_wakeup_sleepers();
	return (DDI_INTR_CLAIMED);
}

/*
 * wakeup sleepers + mark led cache for this fru as invalid
 */
static void
lw8_wakeup_sleepers()
{
	mutex_enter(&lw8_event_mutex);
	lw8_event_pending = B_TRUE;
	cv_broadcast(&lw8_event_cv);
	led_state_cached = B_FALSE;
	mutex_exit(&lw8_event_mutex);
}

/*
 * This function is triggered by a soft interrupt and it's purpose is to call
 * to kadmin() to shutdown the system.
 */
/*ARGSUSED*/
static uint_t
lw8_fast_shutdown(char *arg)
{
	(void) kadmin(A_SHUTDOWN, AD_POWEROFF, NULL, kcred);

	/*
	 * If kadmin fails for some reason then we bring the system down
	 * via power_down(), or failing that using halt().
	 */
	power_down("kadmin() failed, trying power_down()");

	halt("power_down() failed, trying halt()");

	/*
	 * We should never make it this far, so something must have gone
	 * horribly, horribly wrong.
	 */
	/*NOTREACHED*/
	return (DDI_INTR_UNCLAIMED);
}

/*
 * This function is triggered by a soft interrupt and it's purpose is to call
 * to do_shutdown() to shutdown the system.
 */
/*ARGSUSED*/
static uint_t
lw8_slow_shutdown(char *arg)
{
	do_shutdown();
	return (DDI_SUCCESS);
}

static uint_t
lw8_event_data_handler(char *arg)
{
	lw8_event_t	*payload;
	sbbc_msg_t	*msg;

	if (arg == NULL) {
		return (DDI_INTR_CLAIMED);
	}

	msg = (sbbc_msg_t *)arg;
	if (msg->msg_buf == NULL) {
		return (DDI_INTR_CLAIMED);
	}

	payload = (lw8_event_t *)msg->msg_buf;
	switch (payload->event_type) {
	case LW8_EVENT_REQUESTED_SHUTDOWN:

		/*
		 * Let the user know why the domain is going down.
		 */
		cmn_err(CE_WARN, "%s", SHUTDOWN_EVENT_MSG);
		ddi_trigger_softintr(lw8_slow_shutdown_softint_id);

		/*NOTREACHED*/
		break;

	case LW8_EVENT_VOLTAGE_SHUTDOWN:

		/*
		 * Let the user know why the domain is going down.
		 */
		cmn_err(CE_WARN, "%s", VOLTAGE_EVENT_MSG);
		ddi_trigger_softintr(lw8_fast_shutdown_softint_id);

		/*NOTREACHED*/
		break;

	case LW8_EVENT_TEMPERATURE_SHUTDOWN:

		/*
		 * Let the user know why the domain is going down.
		 */
		cmn_err(CE_WARN, "%s", TEMPERATURE_EVENT_MSG);
		ddi_trigger_softintr(lw8_fast_shutdown_softint_id);

		/*NOTREACHED*/
		break;

	case LW8_EVENT_FANFAIL_SHUTDOWN:

		/*
		 * Let the user know why the domain is going down.
		 */
		cmn_err(CE_WARN, "%s", FANFAIL_EVENT_MSG);
		ddi_trigger_softintr(lw8_fast_shutdown_softint_id);

		/*NOTREACHED*/
		break;

	case LW8_EVENT_NO_SCC_SHUTDOWN:

		/*
		 * Let the user know why the domain is going down.
		 */
		cmn_err(CE_WARN, "%s", NO_SCC_EVENT_MSG);
		ddi_trigger_softintr(lw8_fast_shutdown_softint_id);

		/*NOTREACHED*/
		break;

	case LW8_EVENT_NEW_LOG_MSG:

		/*
		 * Wake up the log retrieval thread.
		 */
		lw8_logger_wakeup();

		break;

	default:
		return (DDI_INTR_CLAIMED);
	}

	return (DDI_INTR_CLAIMED);
}

/*ARGSUSED*/
static int
lw8_open(dev_t *dev_p, int flag, int otyp, cred_t *cred_p)
{
	int error = 0;
	int instance = getminor(*dev_p);
	static fn_t f = "lw8_open";

	if (instance != 0)
		return (ENXIO);

	if ((error = drv_priv(cred_p)) != 0) {
		cmn_err(CE_WARN, "lw8:%s: inst %d drv_priv failed",
		    f, instance);
		return (error);
	}
	return (error);
}

/*ARGSUSED*/
static int
lw8_close(dev_t dev, int flag, int otyp, cred_t *cred_p)
{
	return (DDI_SUCCESS);
}

static int
lw8_lomcmd(int cmd, intptr_t arg)
{
	sbbc_msg_t request, *reqp = &request;
	sbbc_msg_t response, *resp = &response;
	int rv = 0;
	lom_eventreq_t *eventreqp;

	bzero((caddr_t)&request, sizeof (request));
	reqp->msg_type.type = LW8_MBOX;
	reqp->msg_type.sub_type = cmd;
	bzero((caddr_t)&response, sizeof (response));
	resp->msg_type.type = LW8_MBOX;
	resp->msg_type.sub_type = cmd;

	switch (cmd) {
	case LW8_MBOX_GET_INFO:
		reqp->msg_len = 0;
		reqp->msg_buf = (caddr_t)NULL;
		resp->msg_len = sizeof (lom2_info_t);
		resp->msg_buf = (caddr_t)arg;
		break;
	case LW8_MBOX_SET_CTL:
		reqp->msg_len = sizeof (lom_ctl2_t);
		reqp->msg_buf = (caddr_t)arg;
		resp->msg_len = 0;
		resp->msg_buf = (caddr_t)NULL;
		break;
	case LW8_MBOX_UPDATE_FW:
		reqp->msg_len = sizeof (lom_prog_t);
		reqp->msg_buf = (caddr_t)arg;
		resp->msg_len = 0;
		resp->msg_buf = (caddr_t)NULL;
		break;
	case LW8_MBOX_GET_LED:
		reqp->msg_len = sizeof (lw8_get_led_payload_t);
		reqp->msg_buf = (caddr_t)arg;
		resp->msg_len = sizeof (lw8_get_led_payload_t);
		resp->msg_buf = (caddr_t)arg;
		break;
	case LW8_MBOX_SET_LED:
		reqp->msg_len = sizeof (lw8_set_led_payload_t);
		reqp->msg_buf = (caddr_t)arg;
		resp->msg_len = 0;
		resp->msg_buf = (caddr_t)NULL;
		break;
	case LW8_MBOX_GET_EVENTS:
		/*
		 * cast as lom_eventreq_t to minimise data traffic
		 */
		eventreqp = (lom_eventreq_t *)arg;
		reqp->msg_len = sizeof (lom_eventreq_t);
		reqp->msg_buf = (caddr_t)arg;
		resp->msg_len = sizeof (lom_eventreq_t) +
		    (eventreqp->num * MAX_EVENT_STR);
		resp->msg_buf = (caddr_t)arg;
		break;
	case LW8_MBOX_GET_NEXT_MSG:
		reqp->msg_len = 0;
		reqp->msg_buf = (caddr_t)NULL;
		resp->msg_len = sizeof (lw8_logmsg_t);
		resp->msg_buf = (caddr_t)arg;
		break;
	default:
		return (EINVAL);
	}

	rv = sbbc_mbox_request_response(reqp, resp,
	    LW8_DEFAULT_MAX_MBOX_WAIT_TIME);

	if ((rv) || (resp->msg_status != SG_MBOX_STATUS_SUCCESS)) {

		/* errors from sgsbbc */
		if (resp->msg_status > 0) {
			return (resp->msg_status);
		}

		/* errors from SCAPP */
		switch (resp->msg_status) {

		case SG_MBOX_STATUS_COMMAND_FAILURE:
			/* internal SCAPP error */
			return (EINTR);

		case SG_MBOX_STATUS_HARDWARE_FAILURE:
			/* seprom read/write errors */
			return (EIO);

		case SG_MBOX_STATUS_ILLEGAL_PARAMETER:
			/* illegal ioctl parameter */
			return (EINVAL);

		case SG_MBOX_STATUS_BOARD_ACCESS_DENIED:
			/* board access denied */
			return (EACCES);

		case SG_MBOX_STATUS_STALE_CONTENTS:
			/* stale contents */
			return (ESTALE);

		case SG_MBOX_STATUS_STALE_OBJECT:
			/* stale handle */
			return (ENOENT);

		case SG_MBOX_STATUS_NO_SEPROM_SPACE:
			/* seprom lacks space */
			return (ENOSPC);

		case SG_MBOX_STATUS_NO_MEMORY:
			/* user prog. lacks space */
			return (ENOMEM);

		case SG_MBOX_STATUS_NOT_SUPPORTED:
			/* unsupported operation */
			return (ENOTSUP);

		default:
			return (EIO);
		}
	}
	return (0);
}

/*
 * set the requested led, and mark cache as empty
 */
static int
lw8_setled(lom_set_led_t *set_ledp)
{
	int retval;
	int i, j;
	struct led_info *lip;
	lw8_set_led_payload_t lw8_set_led;

	for (i = 0; i < MAX_FRUS; i++) {
		if (strncmp(set_ledp->location, fru_led_table[i].location,
		    MAX_LOCATION_LEN) != 0)
			continue;
		for (j = 0; j < MAX_LEDS_PER_FRU; j++) {
			lip = &fru_led_table[i].led_info[j];
			if (lip->id == NULL)
				continue;
			if (strncmp(set_ledp->id, lip->id, MAX_ID_LEN) != 0)
				continue;
			lw8_set_led.value = set_ledp->status;

			/*
			 * to minimise data transfer, the SC maintains
			 * just  3 values per fru - except for
			 * the chassis itself at the end which has
			 * MAX_LEDS_PER_FRU
			 */
			lw8_set_led.offset = (i * 3) + j;
			retval = lw8_lomcmd(LW8_MBOX_SET_LED,
			    (intptr_t)&lw8_set_led);
			if (retval != 0)
				return (retval);
			mutex_enter(&lw8_event_mutex);
			led_state_cached = B_FALSE;
			mutex_exit(&lw8_event_mutex);
			return (0);
		}
	}
	return (EINVAL);
}

/*
 * read led value from cache if possible, otherwise read from sc and
 * update the cache
 */
static int
lw8_getled(lom_get_led_t *get_ledp)
{
	int retval;
	int i, j, k;
	struct led_info *lip;
	lw8_get_led_payload_t lw8_get_led;

	for (i = 0; i < MAX_FRUS; i++) {
		if (strncmp(get_ledp->location, fru_led_table[i].location,
		    MAX_LOCATION_LEN) != 0)
			continue;
		if (get_ledp->id[0] == '\0') {
			(void) strncpy(get_ledp->next_id,
			    fru_led_table[i].led_info[0].id, MAX_ID_LEN);
			return (0);
		}
		for (j = 0; j < MAX_LEDS_PER_FRU; j++) {
			lip = &fru_led_table[i].led_info[j];
			if (lip->id == NULL)
				continue;
			if (strncmp(get_ledp->id, lip->id, MAX_ID_LEN) != 0)
				continue;
			mutex_enter(&lw8_event_mutex);
			if (!led_state_cached) {
				mutex_exit(&lw8_event_mutex);
				retval = lw8_lomcmd(LW8_MBOX_GET_LED,
				    (intptr_t)&lw8_get_led);
				if (retval != 0)
					return (retval);
				mutex_enter(&lw8_event_mutex);

				/*
				 * to minimise data transfer, the
				 * lw8_get_led_payload_t structure just has 3
				 * values per fru - except for the chassis
				 * itself at the end which has MAX_LEDS_PER_FRU
				 */
				for (k = 0; k < (MAX_FRUS - 1) * 3; k++) {
					fru_led_table[k / 3].led_info[k % 3].
					    status = lw8_get_led.value[k];
				}
				for (k = 0; k < MAX_LEDS_PER_FRU; k++) {
					fru_led_table[MAX_FRUS - 1].led_info[k].
					    status = lw8_get_led.value[k +
					    ((MAX_FRUS - 1) * 3)];
				}
				led_state_cached = B_TRUE;
			}
			get_ledp->status = lip->status;
			mutex_exit(&lw8_event_mutex);
			get_ledp->position = lip->position;
			(void) strncpy(get_ledp->color, lip->color,
			    MAX_COLOR_LEN);
			if (j == MAX_LEDS_PER_FRU - 1) {
				get_ledp->next_id[0] = '\0';
				return (0);
			}
			(void) strncpy(get_ledp->next_id,
			    fru_led_table[i].led_info[j + 1].id, MAX_ID_LEN);
			return (0);
		}
	}
	if (get_ledp->id[0] == '\0') {
		get_ledp->next_id[0] = '\0';
		return (0);
	}
	return (EINVAL);
}

/*ARGSUSED*/
static int
lw8_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred_p,
    int *rval_p)
{
	int instance = getminor(dev);
	lom2_info_t lw8_info2;
	lom_ctl_t lw8_ctl;
	lom_ctl2_t lw8_ctl2;
	lom_mprog_t lw8_mprog;
	lom_fled_info_t lw8_fled_info;
	lom_info_t lw8_info;
	lom_aldata_t lw8_aldata;
	lom_get_led_t lw8_get_led;
	lom_set_led_t lw8_set_led;
	lom_prog_t *lw8_progp;
	lom_eventlog2_t *lw8_eventlogp;
	lom_eventresp_t *lw8_eventresp;
	int retval = 0;
	int i, j;

	if (instance != 0)
		return (ENXIO);

	switch (cmd) {
	case LOMIOCWTMON:
		mutex_enter(&lw8_event_mutex);
		if (!lw8_event_pending) {
			if (cv_wait_sig(&lw8_event_cv, &lw8_event_mutex) == 0) {
				mutex_exit(&lw8_event_mutex);
				retval = EINTR;
				break;
			}
		}
		lw8_event_pending = B_FALSE;
		mutex_exit(&lw8_event_mutex);
		break;
	case LOMIOCMREAD:
		bzero((caddr_t)&lw8_mprog, sizeof (lw8_mprog));
		lw8_mprog.config = 4;
		if (ddi_copyout((caddr_t)&lw8_mprog, (caddr_t)arg,
		    sizeof (lw8_mprog), mode) != 0) {
			retval = EFAULT;
		}
		break;
	case LOMIOCCTL2:
		if (ddi_copyin((caddr_t)arg, (caddr_t)&lw8_ctl2,
		    sizeof (lw8_ctl2), mode) != 0) {
			retval = EFAULT;
			break;
		}
		retval = lw8_lomcmd(LW8_MBOX_SET_CTL, (intptr_t)&lw8_ctl2);
		break;
	case LOMIOCPROG:
		lw8_progp = kmem_alloc(sizeof (*lw8_progp), KM_SLEEP);
		if (ddi_copyin((caddr_t)arg, (caddr_t)lw8_progp,
		    sizeof (*lw8_progp), mode) != 0) {
			kmem_free(lw8_progp, sizeof (*lw8_progp));
			retval = EFAULT;
			break;
		}
		retval = lw8_lomcmd(LW8_MBOX_UPDATE_FW, (intptr_t)lw8_progp);
		kmem_free(lw8_progp, sizeof (*lw8_progp));
		break;
	case LOMIOCINFO2:
		bzero((caddr_t)&lw8_info2, sizeof (lw8_info2));
		retval = lw8_lomcmd(LW8_MBOX_GET_INFO, (intptr_t)&lw8_info2);
		if (retval != 0)
			break;
		if (ddi_copyout((caddr_t)&lw8_info2, (caddr_t)arg,
		    sizeof (lw8_info2), mode) != 0) {
			retval = EFAULT;
		}
		break;
	case LOMIOCINFO:
		bzero((caddr_t)&lw8_info2, sizeof (lw8_info2));
		retval = lw8_lomcmd(LW8_MBOX_GET_INFO, (intptr_t)&lw8_info2);
		if (retval != 0)
			break;
		bzero((caddr_t)&lw8_info, sizeof (lw8_info));
		lw8_info.ser_char = lw8_info2.escape_chars[0];
		lw8_info.fver = lw8_info2.fver;
		lw8_info.fchksum = lw8_info2.fchksum;
		lw8_info.prod_rev = lw8_info2.prod_rev;
		(void) strncpy(lw8_info.prod_id, lw8_info2.prod_id, MAX_ID_LEN);
		if (ddi_copyout((caddr_t)&lw8_info, (caddr_t)arg,
		    sizeof (lw8_info), mode) != 0) {
			retval = EFAULT;
		}
		break;
	case LOMIOCFLEDSTATE:
		bzero((caddr_t)&lw8_get_led, sizeof (lw8_get_led));
		(void) strncpy(lw8_get_led.location, "chassis",
		    MAX_LOCATION_LEN);
		(void) strncpy(lw8_get_led.id, "fault", MAX_ID_LEN);
		retval = lw8_getled(&lw8_get_led);
		if (retval != 0)
			break;
		lw8_fled_info.on = lw8_get_led.status;
		if (ddi_copyout((caddr_t)&lw8_fled_info, (caddr_t)arg,
		    sizeof (lw8_fled_info), mode) != 0) {
			retval = EFAULT;
		}
		break;
	case LOMIOCALSTATE:
		if (ddi_copyin((caddr_t)arg, (caddr_t)&lw8_aldata,
		    sizeof (lw8_aldata), mode) != 0) {
			retval = EFAULT;
			break;
		}
		bzero((caddr_t)&lw8_get_led, sizeof (lw8_get_led));
		(void) strncpy(lw8_get_led.location, "chassis",
		    MAX_LOCATION_LEN);
		if (lw8_aldata.alarm_no == 3)
			(void) snprintf(lw8_get_led.id, MAX_ID_LEN, "system");
		else
			(void) snprintf(lw8_get_led.id, MAX_ID_LEN, "alarm%d",
			    lw8_aldata.alarm_no);
		retval = lw8_getled(&lw8_get_led);
		if (retval != 0)
			break;
		lw8_aldata.state = lw8_get_led.status;
		if (ddi_copyout((caddr_t)&lw8_aldata, (caddr_t)arg,
		    sizeof (lw8_aldata), mode) != 0) {
			retval = EFAULT;
		}
		break;
	case LOMIOCGETLED:
		if (ddi_copyin((caddr_t)arg, (caddr_t)&lw8_get_led,
		    sizeof (lw8_get_led), mode) != 0) {
			retval = EFAULT;
			break;
		}
		retval = lw8_getled(&lw8_get_led);
		if (retval != 0)
			break;
		if (ddi_copyout((caddr_t)&lw8_get_led, (caddr_t)arg,
		    sizeof (lw8_get_led), mode) != 0) {
			retval = EFAULT;
		}
		break;
	case LOMIOCEVENTLOG2:
		lw8_eventlogp = kmem_alloc(sizeof (*lw8_eventlogp), KM_SLEEP);
		lw8_eventresp = kmem_zalloc(sizeof (*lw8_eventresp), KM_SLEEP);
		if (ddi_copyin((caddr_t)arg, (caddr_t)lw8_eventlogp,
		    sizeof (*lw8_eventlogp), mode) != 0) {
			kmem_free(lw8_eventlogp, sizeof (*lw8_eventlogp));
			kmem_free(lw8_eventresp, sizeof (*lw8_eventresp));
			retval = EFAULT;
			break;
		}
		lw8_eventresp->num = lw8_eventlogp->num;
		lw8_eventresp->level = lw8_eventlogp->level;
		retval = lw8_lomcmd(LW8_MBOX_GET_EVENTS,
		    (intptr_t)lw8_eventresp);
		if (retval == 0) {
			lw8_eventlogp->num = lw8_eventresp->num;
			for (i = 0; i < lw8_eventresp->num; i++) {
				for (j = 0; j < MAX_EVENT_STR; j++) {
					lw8_eventlogp->string[i][j] =
					    lw8_eventresp->string[i][j];
				}
			}
			if (ddi_copyout((caddr_t)lw8_eventlogp, (caddr_t)arg,
			    sizeof (*lw8_eventlogp), mode) != 0) {
				retval = EFAULT;
			}
		}
		kmem_free(lw8_eventlogp, sizeof (*lw8_eventlogp));
		kmem_free(lw8_eventresp, sizeof (*lw8_eventresp));
		break;
	case LOMIOCALCTL:
		if (ddi_copyin((caddr_t)arg, (caddr_t)&lw8_aldata,
		    sizeof (lw8_aldata), mode) != 0) {
			retval = EFAULT;
			break;
		}
		bzero((caddr_t)&lw8_set_led, sizeof (lw8_set_led));
		(void) strncpy(lw8_set_led.location, "chassis",
		    MAX_LOCATION_LEN);
		if (lw8_aldata.alarm_no == 3)
			(void) snprintf(lw8_set_led.id, MAX_ID_LEN, "system");
		else
			(void) snprintf(lw8_set_led.id, MAX_ID_LEN, "alarm%d",
			    lw8_aldata.alarm_no);
		lw8_set_led.status = lw8_aldata.state;
		retval = lw8_setled(&lw8_set_led);
		break;
	case LOMIOCSETLED:
		if (ddi_copyin((caddr_t)arg, (caddr_t)&lw8_set_led,
		    sizeof (lw8_set_led), mode) != 0) {
			retval = EFAULT;
			break;
		}
		retval = lw8_setled(&lw8_set_led);
		break;
	case LOMIOCCTL:
		/*
		 * for this ioctl, as well as setting the fault led in the
		 * LOMIOCCTL case in lw8_lomcmd(), we also need to set the
		 * escape character. To do this we must use LW8_MBOX_SET_CTL,
		 * but this also needs the serial_event value which we have
		 * to get via LW8_MBOX_GET_INFO
		 */
		if (ddi_copyin((caddr_t)arg, (caddr_t)&lw8_ctl,
		    sizeof (lw8_ctl), mode) != 0) {
			retval = EFAULT;
			break;
		}
		bzero((caddr_t)&lw8_info2, sizeof (lw8_info2));
		retval = lw8_lomcmd(LW8_MBOX_GET_INFO, (intptr_t)&lw8_info2);
		if (retval != 0)
			break;
		bzero((caddr_t)&lw8_ctl2, sizeof (lw8_ctl2));
		lw8_ctl2.escape_chars[0] = lw8_ctl.ser_char;
		lw8_ctl2.serial_events = lw8_info2.serial_events;
		retval = lw8_lomcmd(LW8_MBOX_SET_CTL, (intptr_t)&lw8_ctl2);
		if (retval != 0)
			break;

		/*
		 * if fault_led != 0, then set the led
		 */
		if (lw8_ctl.fault_led == 0)
			break;
		bzero((caddr_t)&lw8_set_led, sizeof (lw8_set_led));
		(void) strncpy(lw8_set_led.location, "chassis",
		    MAX_LOCATION_LEN);
		(void) strncpy(lw8_set_led.id, "fault", MAX_ID_LEN);
		lw8_set_led.status = lw8_ctl.fault_led - 1;
		retval = lw8_setled(&lw8_set_led);
		break;
	default:
		retval = ENOTSUP;
		break;
	}
	return (retval);
}

/* ARGSUSED */
static void
lw8_logger(caddr_t arg)
{
	callb_cpr_t	cprinfo;
	lw8_logmsg_t	*lw8_logmsgp;
	boolean_t	more_waiting;
	char		level;
	int		retval;

	CALLB_CPR_INIT(&cprinfo, &lw8_logger_lock, callb_generic_cpr,
	    "lw8_logger");

	lw8_logmsgp = kmem_zalloc(sizeof (*lw8_logmsgp), KM_SLEEP);
	mutex_enter(&lw8_logger_lock);
	for (;;) {

		/*
		 * Wait for someone to tell me to continue.
		 */
		while (lw8_logger_sig == LW8_LOGGER_WAIT) {
			CALLB_CPR_SAFE_BEGIN(&cprinfo);
			cv_wait(&lw8_logger_sig_cv, &lw8_logger_lock);
			CALLB_CPR_SAFE_END(&cprinfo, &lw8_logger_lock);
		}

		/* LW8_LOGGER_EXITNOW implies signal by _detach(). */
		if (lw8_logger_sig == LW8_LOGGER_EXITNOW) {
			lw8_logger_sig = LW8_LOGGER_WAIT;

			kmem_free(lw8_logmsgp, sizeof (*lw8_logmsgp));

			/* lw8_logger_lock is held at this point! */
			CALLB_CPR_EXIT(&cprinfo);

			thread_exit();
			/* NOTREACHED */
		}

		ASSERT(lw8_logger_sig == LW8_LOGGER_PROCESSNOW);
		lw8_logger_sig = LW8_LOGGER_WAIT;

		mutex_exit(&lw8_logger_lock);

		/* Do lw8_event logging */

		/*
		 * Get one message per iteration. We do not sleep if
		 * there are more to process. This makes exit from the
		 * routine much more reliable.
		 */
		more_waiting = B_FALSE;

		retval = lw8_lomcmd(LW8_MBOX_GET_NEXT_MSG,
		    (intptr_t)lw8_logmsgp);
		if (retval == 0) {
			if (lw8_logmsgp->msg_valid) {

				switch (lw8_logmsgp->level) {
				case 0:	/* LOG_EMERG */
					level = SL_FATAL;
					break;
				case 1:	/* LOG_ALERT */
					level = SL_FATAL;
					break;
				case 2:	/* LOG_CRIT */
					level = SL_FATAL;
					break;
				case 3:	/* LOG_ERR */
					level = SL_ERROR;
					break;
				case 4:	/* LOG_WARNING */
					level = SL_WARN;
					break;
				case 5:	/* LOG_NOTICE */
					level = SL_NOTE;
					break;
				case 6:	/* LOG_INFO */
					level = SL_NOTE;
					break;
				case 7:	/* LOG_DEBUG */
					level = SL_TRACE;
					break;
				default:	/* unknown */
					level = SL_NOTE;
					break;
				}

				/* Ensure NUL termination */
				lw8_logmsgp->msg[
				    sizeof (lw8_logmsgp->msg) - 1] = '\0';
				(void) strlog(0, 0, 0, SL_CONSOLE | level,
				    lw8_logmsgp->msg);
			}

			if (lw8_logmsgp->num_remaining > 0)
				more_waiting = B_TRUE;
		}

		/*
		 * Re-enter the lock to prepare for another iteration.
		 * We must have the lock here to protect lw8_logger_sig.
		 */
		mutex_enter(&lw8_logger_lock);
		if ((lw8_logger_sig == LW8_LOGGER_WAIT) && more_waiting)
			/* We need to get more events */
			lw8_logger_sig = LW8_LOGGER_PROCESSNOW;
	}
}

static void
lw8_logger_start(void)
{
	kthread_t *tp;

	mutex_enter(&lw8_logger_lock);

	if (lw8_logger_tid == 0) {
		/* Force retrieval of any pending messages */
		lw8_logger_sig = LW8_LOGGER_PROCESSNOW;

		tp = thread_create(NULL, 0, lw8_logger, NULL, 0,
		    &p0, TS_RUN, maxclsyspri);
		lw8_logger_tid = tp->t_did;
	}

	mutex_exit(&lw8_logger_lock);
}

static void
lw8_logger_destroy(void)
{
	kt_did_t tid;

	mutex_enter(&lw8_logger_lock);
	tid = lw8_logger_tid;
	if (tid != 0) {
		lw8_logger_sig = LW8_LOGGER_EXITNOW;
		cv_signal(&lw8_logger_sig_cv);
		lw8_logger_tid = 0;
	}
	mutex_exit(&lw8_logger_lock);

	/*
	 * Wait for lw8_logger() to finish.
	 */
	if (tid != 0)
		thread_join(tid);
}

static void
lw8_logger_wakeup(void)
{
	mutex_enter(&lw8_logger_lock);

	if (lw8_logger_sig != LW8_LOGGER_EXITNOW)
		lw8_logger_sig = LW8_LOGGER_PROCESSNOW;
	cv_signal(&lw8_logger_sig_cv);

	mutex_exit(&lw8_logger_lock);
}