xref: /titanic_51/usr/src/uts/sun4u/montecarlo/io/hsc.c (revision 07d06da50d310a325b457d6330165aebab1e0064)

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

/*
 * MonteCarlo HotSwap Controller functionality
 */

#include	<sys/types.h>
#include	<sys/stropts.h>
#include	<sys/stream.h>
#include	<sys/strsun.h>
#include	<sys/kmem.h>
#include	<sys/cmn_err.h>
#include	<sys/errno.h>
#include	<sys/cpuvar.h>
#include	<sys/open.h>
#include	<sys/stat.h>
#include	<sys/conf.h>
#include	<sys/ddi.h>
#include	<sys/sunddi.h>
#include	<sys/modctl.h>
#include	<sys/promif.h>
#include	<sys/hotplug/hpcsvc.h>

#include	<sys/hscimpl.h>
#include	<sys/hsc.h>

#include	<sys/mct_topology.h>
#include	<sys/scsbioctl.h>
#include	<sys/scsb.h>

#define	HOTSWAP_MODE_PROP	"hotswap-mode"
#define	ALARM_CARD_ON_SLOT	1
#define	SCSB_HSC_FORCE_REMOVE	1	/* force remove enum intr handler */

/* TUNABLE PARAMETERS. Some are Debug Only. Please take care when using. */

/*
 * Set this flag to 1, to enable full hotswap mode at boot time.
 * Since HPS is threaded, it is not recommended that we set this flag
 * to 1 because enabling full hotswap interrupt can invoke the ENUM
 * event handler accessing the slot data structure which may have not
 * been initialized in the hotplug framework since the HPS may not yet
 * have called the slot registration function with the bus nexus.
 */
static int	scsb_hsc_enable_fhs = 0;

/*
 * Every time  a slot is registered with the hotswap framework, the
 * framework calls back. This variable keeps a count on how many
 * callbacks are done.
 */
static int scsb_hsc_numReg = 0;
/*
 * When this flag is set, the board is taken offline (put in reset) after
 * a unconfigure operation, in Basic Hotswap mode.
 */
static int	scsb_hsc_bhs_slot_reset = 1;
/*
 * When this flag is set, we take the board to reset after unconfigure
 * operation when operating in full hotswap mode.
 */
static int	scsb_hsc_fhs_slot_reset = 1;
/*
 * Implementation of this counter will work only on Montecarlo since
 * the ENUM# Interrupt line is not shared with other interrupts.
 * When the hardware routing changes, then there may be need to remove
 * or change this functionality.
 * This functionality is provided so that a bad or non friendly full hotswap
 * board does not hang the system in full hotswap mode. Atleast the
 * intent is that! Eventually Solaris kernel will provide similar support
 * for recovering from a stuck interrupt line. Till then, lets do this.
 */
static int	scsb_hsc_max_intr_count = 8;
/*
 * Since the hardware does not support enabling/disabling ENUM#, the
 * following flag can be used for imitating that behaviour.
 * Currently we can set this flag and use the remove op to remove the
 * interrupt handler from the system. Care must be taken when using this
 * function since trying to remove the interrupt handler when the interrupts
 * are pending may hang the system permanently.
 * Since the hardware does not support this functionality, we adopt this
 * approach for debugs.
 */
static int	scsb_hsc_enum_switch = 0;

/*
 * When the board loses Healthy# at runtime (with the board being configured),
 * cPCI specs states that a Reset has to be asserted immediately.
 * We dont do this currently, until satellite processor support is given
 * and the implications of such a act is fully understood.
 * To adopt the cPCI specs recommendation, set this flag to 1.
 */
static	int	scsb_hsc_healthy_reset = 0;

/*
 * According to PCI 2.2 specification, once a board comes out of PCI_RST#,
 * it may take upto 2^25 clock cycles to respond to config cycles. For
 * montecarlo using a 33MHz cPCI bus, it's around 1.024 s. The variable
 * will specify the time in ms to wait before attempting config access.
 */
static	int scsb_connect_delay = 1025;

/*
 * slot map property for MC should be
 *
 *	hsc-slot-map="/pci@1f,0/pci@1/pci@1","15","2",
 *               "/pci@1f,0/pci@1/pci@1","14","3",
 *               "/pci@1f,0/pci@1/pci@1","13","4",
 *               "/pci@1f,0/pci@1/pci@1","12","5"
 *               "/pci@1f,0/pci@1/pci@1","11","6"
 *               "/pci@1f,0/pci@1/pci@1","10","7"
 *               "/pci@1f,0/pci@1/pci@1","8","8";
 *
 * slot map property for Tonga should be
 *	hsc-slot-map="/pci@1f,0/pci@1/pci@1","8","1"
 *		"/pci@1f,0/pci@1/pci@1", "15", "2"
 *		"/pci@1f,0/pci@1/pci@1", "14", "4"
 *		"/pci@1f,0/pci@1/pci@1", "13", "5"
 *
 * Please note that the CPU slot number is 3 for Tonga.
 */

/*
 * Services we require from the SCSB
 */
extern int	scsb_get_slot_state(void *, int, int *);
extern int	scsb_read_bhealthy(scsb_state_t *scsb);
extern int	scsb_read_slot_health(scsb_state_t *scsb, int pslotnum);
extern int	scsb_connect_slot(void *, int, int);
extern int	scsb_disconnect_slot(void *, int, int);

static void	*hsc_state;

static uint_t	hsc_enum_intr(char *);
static hsc_slot_t *hsc_get_slot_info(hsc_state_t *, int);
static int	scsb_enable_enum(hsc_state_t *);
static int	scsb_disable_enum(hsc_state_t *, int);
static int	atoi(const char *);
static int	isdigit(int);
static hsc_slot_t *hsc_find_slot(int);
static void	hsc_led_op(hsc_slot_t *, int, hpc_led_t, hpc_led_state_t);
static int	hsc_led_state(hsc_slot_t *, int, hpc_led_info_t *);
static int	scsb_hsc_disable_slot(hsc_slot_t *);
static int	scsb_hsc_enable_slot(hsc_slot_t *);
#ifndef	lint
static int hsc_clear_all_enum(hsc_state_t *);
#endif
static int	hsc_slot_register(hsc_state_t *, char *, uint16_t, uint_t,
					boolean_t);
static int	hsc_slot_unregister(int);
static int	scsb_hsc_init_slot_state(hsc_state_t *, hsc_slot_t *);
static int	hsc_slot_autoconnect(hsc_slot_t *);

static hpc_slot_ops_t	*hsc_slotops;
static hsc_slot_t	*hsc_slot_list;		/* linked list of slots */

/*
 * This mutex protects the following variables:
 *	hsc_slot_list
 */
static kmutex_t		hsc_mutex;


/* ARGSUSED */
static int
hsc_connect(caddr_t ops_arg, hpc_slot_t slot_hdl, void *data, uint_t flags)
{
	hsc_slot_t *hsp = (hsc_slot_t *)ops_arg;
	int rc, rstate;
	hsc_state_t	*hsc;

	DEBUG2("hsc_connect: slot %d, healthy %d", hsp->hs_slot_number,
						hsp->hs_board_healthy);

	if (!(hsp->hs_flags & (HSC_ENABLED|HSC_SLOT_ENABLED)))
		return (HPC_ERR_FAILED);
	/* if SCB hotswapped, do not allow connect operations */
	if (hsp->hs_flags & HSC_SCB_HOTSWAPPED)
		return (HPC_ERR_FAILED);
	/*
	 * if previous occupant stayed configured, do not allow another
	 * occupant to be connected.
	 * This behaviour is an indication that the slot state
	 * is not clean.
	 */
	if (hsp->hs_flags & HSC_SLOT_BAD_STATE) {
		/*
		 * In the current implementation, we turn both fault
		 * and active LEDs to ON state in this situation.
		 */
		hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
							HPC_LED_ON);
		return (HPC_ERR_FAILED);
	}
	/*
	 * Get the actual status from the i2c bus
	 */
	rc = scsb_get_slot_state(hsp->hs_hpchandle, hsp->hs_slot_number,
								&rstate);
	if (rc != DDI_SUCCESS)
		return (HPC_ERR_FAILED);

	hsp->hs_slot_state = rstate;
	if (hsp->hs_slot_state == HPC_SLOT_EMPTY) {
#ifdef DEBUG
		cmn_err(CE_CONT,
			"?hsc_connect: slot %d is empty\n",
			hsp->hs_slot_number);
#endif
		return (HPC_ERR_FAILED);
	}

	if (hsp->hs_slot_state == HPC_SLOT_CONNECTED)
		return (HPC_SUCCESS);

	rc = HPC_SUCCESS;
	/*
	 * call scsb to connect the slot. This also makes sure board is healthy
	 */
	if (scsb_connect_slot(hsp->hs_hpchandle, hsp->hs_slot_number,
				hsp->hs_board_healthy) != DDI_SUCCESS) {
		DEBUG1("hsc_connect: slot %d connection failed",
				hsp->hs_slot_number);
		rc = HPC_ERR_FAILED;
	} else {
		if (hsp->hs_slot_state != HPC_SLOT_CONNECTED) {
			if (hsp->hs_board_healthy == B_FALSE) {
				cmn_err(CE_NOTE, "HEALTHY# not asserted on "
					" slot %d", hsp->hs_slot_number);
				return (HPC_ERR_FAILED);
			}
			hsc = hsp->hsc;
			hsc->hsp_last = hsp;
			if (scsb_reset_slot(hsp->hs_hpchandle,
				hsp->hs_slot_number, SCSB_UNRESET_SLOT) != 0) {

				return (HPC_ERR_FAILED);
			}
			/*
			 * Unresetting a board may have caused an interrupt
			 * burst in case of non friendly boards. So it is
			 * important to make sure that the ISR has not
			 * put this board back to disconnect state.
			 */
			delay(1);
			if (hsp->hs_flags & HSC_ENUM_FAILED) {
				hsp->hs_flags &= ~HSC_ENUM_FAILED;
				return (HPC_ERR_FAILED);
			}
			DEBUG1("hsc_connect: slot %d connected",
						hsp->hs_slot_number);
			rc = HPC_SUCCESS;
			hsp->hs_slot_state = HPC_SLOT_CONNECTED;
			(void) hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
				HPC_FAULT_LED, HPC_LED_OFF);
		}
	}

	/*
	 * PCI 2.2 specs recommend that the probe software wait
	 * for upto 2^25 PCI clock cycles after deassertion of
	 * PCI_RST# before the board is able to respond to config
	 * cycles. So, before we return, we wait for ~1 sec.
	 */
	delay(drv_usectohz(scsb_connect_delay * 1000));
	return (rc);
}


/* ARGSUSED */
static int
hsc_disconnect(caddr_t ops_arg, hpc_slot_t slot_hdl, void *data, uint_t flags)
{
	hsc_slot_t		*hsp = (hsc_slot_t *)ops_arg;
	hsc_state_t		*hsc;
#ifdef	DEBUG
	static const char	func[] = "hsc_disconnect";
#endif

	DEBUG1("hsc_disconnect: slot %d", hsp->hs_slot_number);

	if (hsp->hs_board_configured) {
#ifdef	DEBUG
		cmn_err(CE_NOTE,
			"%s: cannot disconnect configured board in slot %d",
			func, hsp->hs_slot_number);
#endif
		return (HPC_ERR_FAILED);
	}

	if (hsp->hs_slot_state == HPC_SLOT_EMPTY) {
#ifdef	DEBUG
		cmn_err(CE_NOTE, "%s: slot %d is empty",
			func, hsp->hs_slot_number);
#endif
		return (HPC_SUCCESS);
	}

	if (hsp->hs_slot_state == HPC_SLOT_DISCONNECTED) {
		/*
		 * if already disconnected, just return success
		 * Duplicate disconnect messages should not be failed!
		 */
		return (HPC_SUCCESS);
	}
	/* if SCB hotswapped, do not allow disconnect operations */
	if (hsp->hs_flags & HSC_SCB_HOTSWAPPED)
		return (HPC_ERR_FAILED);

	/* call scsb to disconnect the slot */
	if (scsb_disconnect_slot(hsp->hs_hpchandle, B_TRUE, hsp->hs_slot_number)
			!= DDI_SUCCESS)
		return (HPC_ERR_FAILED);
	hsc = hsp->hsc;
	if (hsc->hsp_last == hsp)
		hsc->hsp_last = NULL;

	return (HPC_SUCCESS);
}


/*
 * In the cPCI world, this operation is not applicable.
 * However, we use this function to enable full hotswap mode in debug mode.
 */
/* ARGSUSED */
static int
hsc_insert(caddr_t ops_arg, hpc_slot_t slot_hdl, void *data, uint_t flags)
{
	hsc_slot_t		*hsp = (hsc_slot_t *)ops_arg;

	if (scsb_hsc_enum_switch &&
			(scsb_enable_enum(hsp->hsc) == DDI_SUCCESS)) {
		return (HPC_SUCCESS);
	}
	return (HPC_ERR_NOTSUPPORTED);
}


/*
 * In the cPCI world, this operation is not applicable.
 * However, we use this function to disable full hotswap mode in debug mode.
 */
/* ARGSUSED */
static int
hsc_remove(caddr_t ops_arg, hpc_slot_t slot_hdl, void *data, uint_t flags)
{
	hsc_slot_t		*hsp = (hsc_slot_t *)ops_arg;

	if (scsb_hsc_enum_switch &&
			(scsb_disable_enum(hsp->hsc, SCSB_HSC_FORCE_REMOVE)
					== DDI_SUCCESS)) {
		hsp->hs_flags &= ~HSC_ENUM_FAILED;
		return (HPC_SUCCESS);
	}
	return (HPC_ERR_NOTSUPPORTED);
}

static void
hsc_led_op(hsc_slot_t *hsp, int cmd, hpc_led_t led, hpc_led_state_t led_state)
{
	hpc_led_info_t	ledinfo;

	ledinfo.led = led;
	ledinfo.state = led_state;
	(void) hsc_led_state(hsp, cmd, &ledinfo);
}

static int
hsc_led_state(hsc_slot_t *hsp, int cmd, hpc_led_info_t *hlip)
{
	hpc_led_state_t	*hlsp;
	scsb_uinfo_t	sunit;
	int		res;

	DEBUG3("hsc_led_state: slot %d, led %x, state %x",
		hsp->hs_slot_number, hlip->led, hlip->state);

	sunit.unit_type = SLOT;
	sunit.unit_number = hsp->hs_slot_number;
	/*
	 * We ignore operations on LEDs that we don't support
	 */
	switch (hlip->led) {
		case HPC_FAULT_LED:
			sunit.led_type = NOK;
			hlsp = &hsp->hs_fault_led_state;
			break;
		case HPC_ACTIVE_LED:
			sunit.led_type = OK;
			hlsp = &hsp->hs_active_led_state;
			break;
		default:
			return (HPC_ERR_NOTSUPPORTED);
	}

	switch (hlip->state) {
		case HPC_LED_BLINK:
			sunit.unit_state = BLINK;
			if (hlip->led != HPC_ACTIVE_LED)
				return (HPC_ERR_NOTSUPPORTED);
			break;
		case HPC_LED_ON:
			sunit.unit_state = ON;
			break;
		case HPC_LED_OFF:
			sunit.unit_state = OFF;
			break;
		default:
			break;
	}

	switch (cmd) {
	case HPC_CTRL_SET_LED_STATE:
		res = scsb_led_set(hsp->hs_hpchandle, &sunit, sunit.led_type);
		if (res != 0)
			return (HPC_ERR_FAILED);
		*hlsp = (hpc_led_state_t)sunit.unit_state;
		break;

	case HPC_CTRL_GET_LED_STATE:
		res = scsb_led_get(hsp->hs_hpchandle, &sunit, sunit.led_type);
		if (res)
			return (HPC_ERR_FAILED);
		/* hlip->state = sunit.unit_state; */
		break;

	default:
		return (HPC_ERR_INVALID);
	}

	return (HPC_SUCCESS);

}


static int
hsc_get_slot_state(hsc_slot_t *hsp, hpc_slot_state_t *hssp)
{
	int rstate = 0;
	int rc;
#ifdef	DEBUG
	int orstate;	/* original rstate */
#endif

	DEBUG1("hsc_get_slot_state: slot %d", hsp->hs_slot_number);
	rc = scsb_get_slot_state(hsp->hs_hpchandle, hsp->hs_slot_number,
								&rstate);
	if (rc != DDI_SUCCESS)
		return (HPC_ERR_FAILED);
#ifdef	DEBUG
	orstate = hsp->hs_slot_state;
#endif
	hsp->hs_slot_state = rstate;
	switch (hsp->hs_slot_state) {
	case HPC_SLOT_EMPTY:
		DEBUG0("empty");
		break;
	case HPC_SLOT_CONNECTED:
		DEBUG0("connected");
		break;
	case HPC_SLOT_DISCONNECTED:
		DEBUG0("disconnected");
		break;
	}

	*hssp = hsp->hs_slot_state;

	/* doing get-state above may have caused a freeze operation */
	if ((hsp->hs_flags & HSC_SCB_HOTSWAPPED) &&
			(rstate == HPC_SLOT_DISCONNECTED)) {
		/* freeze puts disconnected boards to connected state */
		*hssp = HPC_SLOT_CONNECTED;
#if 0
		/* in FHS, deassertion of reset may have configured the board */
		if (hsp->hs_board_configured == B_TRUE) {
			hsp->hs_slot_state = *hssp;
		}
#endif
	}
#ifdef	DEBUG
	/* a SCB hotswap may have forced a state change on the receptacle */
	if (orstate != *hssp) {
		cmn_err(CE_NOTE, "hsc_get_state: slot%d state change due"
			" to SCB hotswap!", hsp->hs_slot_number);
	}
#endif
	return (HPC_SUCCESS);
}


static int
hsc_set_config_state(hsc_slot_t *hsp, int cmd)
{
	hsc_state_t	*hsc = hsp->hsc;

	DEBUG1("hsc_set_config_state: slot %d", hsp->hs_slot_number);

	switch (cmd) {
	case HPC_CTRL_DEV_CONFIGURED:
		/*
		 * Closing of the Ejector switch in configured/busy state can
		 * cause duplicate CONFIGURED messages to come down.
		 * Make sure our LED states are fine.
		 */
		if (hsp->hs_board_configured == B_TRUE) {
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
								HPC_LED_ON);
			break;
		}
		hsp->hs_board_configured = B_TRUE;
		hsp->hs_board_configuring = B_FALSE;
		if ((hsc->state & HSC_ATTACHED) == HSC_ATTACHED &&
			hsp->hs_flags & HSC_ALARM_CARD_PRES)
			(void) scsb_hsc_ac_op(hsp->hs_hpchandle,
				hsp->hs_slot_number, SCSB_HSC_AC_CONFIGURED);
		/* LED must be OFF on the occupant. */
		(void) hpc_slot_event_notify(hsp->hs_slot_handle,
					HPC_EVENT_SLOT_BLUE_LED_OFF, 0);
		if (hsp->hs_flags & HSC_AUTOCFG)
			(void) hpc_slot_event_notify(hsp->hs_slot_handle,
					HPC_EVENT_ENABLE_ENUM, 0);
		else
			(void) hpc_slot_event_notify(hsp->hs_slot_handle,
					HPC_EVENT_DISABLE_ENUM, 0);
		hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
								HPC_LED_ON);
		if (hsc->hsp_last == hsp)
			hsc->hsp_last = NULL;
		break;
	case HPC_CTRL_DEV_UNCONFIGURED:
		hsp->hs_board_configured = B_FALSE;
		hsp->hs_board_unconfiguring = B_FALSE;
		hsp->hs_flags &= ~HSC_SLOT_BAD_STATE;
		if (hsp->hs_flags & HSC_ALARM_CARD_PRES)
			(void) scsb_hsc_ac_op(hsp->hs_hpchandle,
				hsp->hs_slot_number, SCSB_HSC_AC_UNCONFIGURED);
		hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
							HPC_LED_BLINK);
		if (((hsc->state & HSC_ENUM_ENABLED) &&
			scsb_hsc_fhs_slot_reset) ||
		(((hsc->state & HSC_ENUM_ENABLED) != HSC_ENUM_ENABLED) &&
				scsb_hsc_bhs_slot_reset) ||
				((hsp->hs_flags & HSC_AUTOCFG) !=
					HSC_AUTOCFG)) {
			if (scsb_reset_slot(hsp->hs_hpchandle,
				hsp->hs_slot_number, SCSB_RESET_SLOT) == 0) {

				hsp->hs_slot_state = HPC_SLOT_DISCONNECTED;
				hsp->hs_board_healthy = B_FALSE;
				hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
					HPC_FAULT_LED, HPC_LED_ON);
			}
		}
		break;
	case HPC_CTRL_DEV_CONFIG_FAILURE:
		hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
							HPC_LED_BLINK);
		hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
				HPC_FAULT_LED, HPC_LED_ON);
		break;
	case HPC_CTRL_DEV_UNCONFIG_FAILURE:
		hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
							HPC_LED_ON);
		break;
	case HPC_CTRL_DEV_CONFIG_START:
	case HPC_CTRL_DEV_UNCONFIG_START:
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_FAULT_LED,
					HPC_LED_OFF);
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
					HPC_LED_BLINK);
		break;
	default:
		return (HPC_ERR_INVALID);
	}

	if (cmd != HPC_CTRL_DEV_CONFIG_START &&
		cmd != HPC_CTRL_DEV_UNCONFIG_START &&
		hsc->regDone == B_FALSE &&
			scsb_hsc_numReg < hsc->n_registered_occupants) {
		scsb_hsc_numReg++;

		/*
		 * If the callback is invoked for all registered slots,
		 * enable ENUM.
		 */
		if (((hsc->state & HSC_ATTACHED) == HSC_ATTACHED) &&
			(scsb_hsc_numReg == hsc->n_registered_occupants)) {
			hsc->regDone = B_TRUE;
			if (hsc->hotswap_mode == HSC_HOTSWAP_MODE_FULL) {
#ifdef DEBUG
				cmn_err(CE_CONT, "%s%d: Enabling full hotswap"
					":%d non-empty slots\n",
					ddi_driver_name(hsc->dip),
					ddi_get_instance(hsc->dip),
					hsc->n_registered_occupants);
#endif
				if (scsb_enable_enum(hsc) != DDI_SUCCESS) {
					cmn_err(CE_WARN, "%s#%d: Cannot enable "
						"Full Hotswap",
						ddi_driver_name(hsc->dip),
						ddi_get_instance(hsc->dip));

					return (HPC_ERR_FAILED);
				}
			}
		}
	}

	return (HPC_SUCCESS);
}


/*ARGSUSED*/
static int
hsc_get_board_type(hsc_slot_t *hsp, hpc_board_type_t *hbtp)
{
	*hbtp = hsp->hs_board_type;
	return (HPC_SUCCESS);
}


/* ARGSUSED */
static int
hsc_autoconfig(hsc_slot_t *hsp, int cmd)
{
	int res = HPC_SUCCESS, enum_disable = B_TRUE, i;
	char slotautocfg_prop[18];
	hsc_state_t *hsc;

	DEBUG1("hsc_autoconfig: slot %d", hsp->hs_slot_number);
	(void) sprintf(slotautocfg_prop, "slot%d-autoconfig",
	    hsp->hs_slot_number);

	if (cmd == HPC_CTRL_ENABLE_AUTOCFG) {
		hsp->hs_flags |= HSC_AUTOCFG;
		(void) ddi_prop_update_string(DDI_DEV_T_NONE, hsp->hsc->dip,
				slotautocfg_prop, "enabled");
		if ((res = scsb_enable_enum(hsp->hsc)) == DDI_SUCCESS) {
			(void) hpc_slot_event_notify(hsp->hs_slot_handle,
					HPC_EVENT_ENABLE_ENUM, 0);
		}
	} else {
		(void) ddi_prop_update_string(DDI_DEV_T_NONE, hsp->hsc->dip,
		    slotautocfg_prop, "disabled");
		hsp->hs_flags &= ~HSC_AUTOCFG;
		hsc = hsp->hsc;
		if (hsc->state & HSC_ATTACHED) {
			(void) hpc_slot_event_notify(hsp->hs_slot_handle,
						HPC_EVENT_DISABLE_ENUM, 0);
			for (i = 0; i < hsc->slot_table_size; i++) {
				hsc_slot_t	*thsp;
				int slotnum;

				slotnum = hsc->slot_table_prop[i].pslotnum;
				thsp = hsc_find_slot(slotnum);
				if (thsp == NULL) {
					cmn_err(CE_WARN, "%s#%d: hsc_autocfg:"
						"No Slot Info for slot %d",
						ddi_driver_name(hsc->dip),
						ddi_get_instance(hsc->dip),
						slotnum);
					continue;
				}
				if (thsp->hs_flags & HSC_AUTOCFG) {
					enum_disable = B_FALSE;
					break;
				}
			}
			if (enum_disable == B_TRUE)
				(void) scsb_disable_enum(hsc,
				    SCSB_HSC_FORCE_REMOVE);
		}
	}
	return (res);
}


/*
 * This function is invoked to enable/disable a slot
 */
/* ARGSUSED */
#ifndef	lint
static int
hsc_slot_enable(hsc_slot_t *hsp, boolean_t enabled)
{
	scsb_uinfo_t	sunit;
	int		res;

	DEBUG1("hsc_slot_enable: slot %d", hsp->hs_slot_number);

	sunit.unit_type = SLOT;
	sunit.unit_number = hsp->hs_slot_number;
	if (enabled)
		sunit.unit_state = ON;
	else
		sunit.unit_state = OFF;

	res = scsb_reset_unit(hsp->hs_hpchandle, &sunit);
	if (res == 0)
		return (HPC_SUCCESS);
	else if (res == EINVAL)
		return (HPC_ERR_INVALID);
	else
		return (HPC_ERR_FAILED);
}
#endif


/*ARGSUSED*/
static int
hsc_control(caddr_t ops_arg, hpc_slot_t slot_hdl, int request, caddr_t arg)
{
	hsc_slot_t *hsp = (hsc_slot_t *)ops_arg;
	int rc = HPC_SUCCESS;

	DEBUG2("hsc_control: slot %d, op=%x\n", hsp->hs_slot_number, request);

	switch (request) {
	case HPC_CTRL_GET_LED_STATE:
		return (hsc_led_state(hsp,
			HPC_CTRL_GET_LED_STATE, (hpc_led_info_t *)arg));

	case HPC_CTRL_SET_LED_STATE:
		return (hsc_led_state(hsp,
			HPC_CTRL_SET_LED_STATE, (hpc_led_info_t *)arg));

	case HPC_CTRL_GET_SLOT_STATE:
		return (hsc_get_slot_state(hsp, (hpc_slot_state_t *)arg));

	case HPC_CTRL_DEV_CONFIGURED:
		return (hsc_set_config_state(hsp, HPC_CTRL_DEV_CONFIGURED));

	case HPC_CTRL_DEV_UNCONFIGURED:
		return (hsc_set_config_state(hsp, HPC_CTRL_DEV_UNCONFIGURED));

	case HPC_CTRL_DEV_CONFIG_FAILURE:
		return (hsc_set_config_state(hsp, HPC_CTRL_DEV_CONFIG_FAILURE));

	case HPC_CTRL_DEV_UNCONFIG_FAILURE:
		return (hsc_set_config_state(hsp,
				HPC_CTRL_DEV_UNCONFIG_FAILURE));

	case HPC_CTRL_DEV_CONFIG_START:
	case HPC_CTRL_DEV_UNCONFIG_START:
		return (hsc_set_config_state(hsp, request));

	case HPC_CTRL_GET_BOARD_TYPE:
		return (hsc_get_board_type(hsp, (hpc_board_type_t *)arg));

	case HPC_CTRL_DISABLE_AUTOCFG:
		return (hsc_autoconfig(hsp, HPC_CTRL_DISABLE_AUTOCFG));

	case HPC_CTRL_ENABLE_AUTOCFG:
		return (hsc_autoconfig(hsp, HPC_CTRL_ENABLE_AUTOCFG));

	case HPC_CTRL_DISABLE_SLOT:
		/*
		 * No hardware support for disabling the slot.
		 * Just imitate a disable_autoconfig operation for now
		 */
		if (hsp->hs_board_configured == B_TRUE)
			return (HPC_ERR_FAILED);
		if (scsb_hsc_disable_slot(hsp) != DDI_SUCCESS)
			rc = HPC_ERR_FAILED;
		return (rc);

	case HPC_CTRL_ENABLE_SLOT:
		if (scsb_hsc_enable_slot(hsp) != DDI_SUCCESS)
			rc = HPC_ERR_FAILED;
		return (rc);

	case HPC_CTRL_ENABLE_ENUM:
		return (scsb_enable_enum(hsp->hsc));

	case HPC_CTRL_DISABLE_ENUM:
		return (scsb_disable_enum(hsp->hsc, 0));

	default:
		return (HPC_ERR_INVALID);
	}
}

static int
scsb_hsc_disable_slot(hsc_slot_t *hsp)
{
	int rc;
	char slot_disable_prop[18];

	DEBUG1("hsc_disable_slot: slot %d", hsp->hs_slot_number);
	(void) sprintf(slot_disable_prop, "slot%d-status", hsp->hs_slot_number);

	rc = scsb_reset_slot(hsp->hs_hpchandle, hsp->hs_slot_number,
					SCSB_RESET_SLOT);
	if (rc == DDI_SUCCESS) {
		(void) hsc_autoconfig(hsp, HPC_CTRL_DISABLE_AUTOCFG);
		hsp->hs_flags &= ~HSC_SLOT_ENABLED;
		(void) ddi_prop_update_string(DDI_DEV_T_NONE, hsp->hsc->dip,
		    slot_disable_prop, "disabled");
	} else
		rc = DDI_FAILURE;
	return (rc);
}

static int
scsb_hsc_enable_slot(hsc_slot_t *hsp)
{
	int rc;
	char slot_disable_prop[18];

	DEBUG1("hsc_disable_slot: slot %d", hsp->hs_slot_number);
	(void) sprintf(slot_disable_prop, "slot%d-status", hsp->hs_slot_number);

	rc = scsb_reset_slot(hsp->hs_hpchandle, hsp->hs_slot_number,
					SCSB_UNRESET_SLOT);
	if (rc == DDI_SUCCESS) {
		(void) hsc_autoconfig(hsp, HPC_CTRL_ENABLE_AUTOCFG);
		hsp->hs_flags |= HSC_SLOT_ENABLED;
		(void) ddi_prop_remove(DDI_DEV_T_NONE, hsp->hsc->dip,
		    slot_disable_prop);
	} else
		rc = HPC_ERR_FAILED;
	return (rc);
}

#define	NEW(type)	(type *) kmem_zalloc(sizeof (type), KM_SLEEP)

static hsc_slot_t *
hsc_alloc_slot(
		uint16_t	device_number,
		int		slot_number,
		boolean_t	board_in_slot)
{
	hpc_slot_info_t	*hsip;
	hsc_slot_t	*hsp = NEW(hsc_slot_t);

	DEBUG2("hsc_alloc_slot: slot %d %s", slot_number,
		board_in_slot ? "occupied" : "empty");

	if (hsp == NULL) {
		cmn_err(CE_NOTE,
			"hsc_alloc_slot: allocation failed for slot %d",
			slot_number);
		return (NULL);
	}

	hsip = &hsp->hs_info;

	hsip->version			= HPC_SLOT_INFO_VERSION;
	hsip->slot_type			= HPC_SLOT_TYPE_CPCI;
	hsip->pci_dev_num		= device_number;
	hsip->pci_slot_capabilities	= 0;
	hsip->slot_flags		= HPC_SLOT_CREATE_DEVLINK;
	/*
	 * Note: the name *must* be 'pci' so that the correct cfgadm plug-in
	 *	 library is selected
	 */
	(void) sprintf(hsip->pci_slot_name, "cpci_slot%d", slot_number);

	/*
	 * We assume that the following LED settings reflect
	 * the hardware state.
	 * After we register the slot, we will be invoked by the nexus
	 * if the slot is occupied, and we will turn on the LED then.
	 */
	hsp->hs_active_led_state	= HPC_LED_OFF;
	hsp->hs_fault_led_state		= HPC_LED_OFF;

	hsp->hs_board_configured	= B_FALSE;
	hsp->hs_board_healthy		= B_FALSE;
	hsp->hs_board_type		= HPC_BOARD_UNKNOWN;

	hsp->hs_flags			= HSC_ENABLED | HSC_SLOT_ENABLED;
	hsp->hs_slot_number		= slot_number;

	/*
	 * we should just set this to connected,
	 * as MC slots are always connected.
	 */
	if (board_in_slot)
		hsp->hs_slot_state = HPC_SLOT_CONNECTED;
	else
		hsp->hs_slot_state = HPC_SLOT_EMPTY;

	return (hsp);
}


static void
hsc_free_slot(hsc_slot_t *hsp)
{
	DEBUG0("hsc_free_slot");

	kmem_free(hsp, sizeof (*hsp));
}


/*
 * This function is invoked to register a slot
 */
static int
hsc_slot_register(
	hsc_state_t	*hsc,
	char		*bus_path,	/* PCI nexus pathname */
	uint16_t	device_number,	/* PCI device number */
	uint_t		slot_number,	/* physical slot number */
	boolean_t	board_in_slot)	/* receptacle status */
{
	int		rc = HPC_SUCCESS;
	hsc_slot_t	*hsp;

	DEBUG2("hsc_slot_register: slot number %d, device number %d",
		slot_number, device_number);

	hsp = hsc_alloc_slot(device_number, slot_number,
			board_in_slot);

	if (hsp == NULL) {
#ifdef	DEBUG
		cmn_err(CE_NOTE, "hsc_slot_register: hsc_alloc_slot failed");
#endif
		return (HPC_ERR_FAILED);
	}

	hsp->hs_hpchandle = hsc->scsb_handle; /* handle for call backs */
	hsp->hsc = hsc;

	rc = scsb_hsc_init_slot_state(hsc, hsp);
	if (rc != DDI_SUCCESS)
		return (HPC_ERR_FAILED);

	/* slot autoconfiguration by default. */
	if (hsc->hotswap_mode == HSC_HOTSWAP_MODE_FULL)
		(void) hsc_autoconfig(hsp, HPC_CTRL_ENABLE_AUTOCFG);
	else
		(void) hsc_autoconfig(hsp, HPC_CTRL_DISABLE_AUTOCFG);

	/*
	 * Append to our list
	 */
	mutex_enter(&hsc_mutex);
	hsp->hs_next = hsc_slot_list;
	hsc_slot_list = hsp;
	mutex_exit(&hsc_mutex);

	rc = hpc_slot_register(hsc->dip,
			bus_path,
			&hsp->hs_info,
			&hsp->hs_slot_handle,	/* return value */
			hsc_slotops,
			(caddr_t)hsp,
			0);

	if (rc != HPC_SUCCESS) {
		cmn_err(CE_WARN, "%s#%d: failed to register slot %s:%d",
			ddi_driver_name(hsc->dip), ddi_get_instance(hsc->dip),
			bus_path, device_number);
		hsc_free_slot(hsp);
		return (rc);
	}

	DEBUG0("hsc_slot_register: hpc_slot_register successful");

	return (rc);
}


static int
hsc_slot_unregister(int slot_number)
{
	hsc_slot_t	*hsp, *prev;

	DEBUG1("hsc_slot_unregister: slot number %d", slot_number);

	mutex_enter(&hsc_mutex);
	hsp = prev = NULL;
	for (hsp = hsc_slot_list; hsp != NULL; hsp = hsp->hs_next) {
		if (hsp->hs_slot_number == slot_number) {
			if (prev == NULL) /* first entry */
				hsc_slot_list = hsc_slot_list->hs_next;
			else
				prev->hs_next = hsp->hs_next;
			hsp->hs_next = NULL;
			break;
		}
		prev = hsp;
	}
	mutex_exit(&hsc_mutex);

	if (hsp != NULL) {
		(void) hpc_slot_unregister(&hsp->hs_slot_handle);
		if ((hsp->hsc->state & HSC_ATTACHED) != HSC_ATTACHED &&
				hsp->hs_slot_state != HPC_SLOT_EMPTY) {
			hsp->hsc->n_registered_occupants--;
		}
		hsc_free_slot(hsp);
		return (0);
	}
	return (1);
}

static int
scsb_hsc_init_slot_state(hsc_state_t *hsc, hsc_slot_t *hsp)
{
	int rc, rstate;
	int slot_number = hsp->hs_slot_number;
	scsb_state_t	*scsb = (scsb_state_t *)hsc->scsb_handle;

	rc = scsb_get_slot_state(hsc->scsb_handle, slot_number, &rstate);
	if (rc != DDI_SUCCESS)
		return (DDI_FAILURE);

	/*
	 * Set the healthy status for this slot
	 */
	hsp->hs_board_healthy = scsb_read_slot_health(scsb, slot_number);
	hsp->hs_slot_state = rstate;
	switch (rstate) {
		case HPC_SLOT_EMPTY:
			/*
			 * this will clear any state differences between
			 * SCB Freeze operations.
			 */
			hsp->hs_slot_state = HPC_SLOT_EMPTY;
			/* slot empty. */
			(void) scsb_reset_slot(hsc->scsb_handle, slot_number,
			    SCSB_RESET_SLOT);
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
			    HPC_LED_OFF);
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_FAULT_LED,
			    HPC_LED_OFF);
			break;
		case HPC_SLOT_DISCONNECTED:
			/*
			 * this will clear any state differences between
			 * SCB Freeze operations.
			 */
			hsp->hs_slot_state = HPC_SLOT_DISCONNECTED;
			/* check recovery from SCB freeze */
			if (hsp->hs_board_configured != B_TRUE) {
				/*
				 * Force a disconnect just in case there are
				 * differences between healthy and reset states.
				 */
				(void) scsb_reset_slot(hsc->scsb_handle,
				    slot_number, SCSB_RESET_SLOT);
				/*
				 * Slot in reset. OBP has not probed this
				 * device. Hence it is ok to remove this board.
				 */
				hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
						HPC_ACTIVE_LED, HPC_LED_BLINK);
				hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
						HPC_FAULT_LED, HPC_LED_ON);
				break;
			}
			/*FALLTHROUGH*/
		case HPC_SLOT_CONNECTED:
			/*
			 * this will clear any state differences between
			 * SCB Freeze operations.
			 */
			hsp->hs_slot_state = HPC_SLOT_CONNECTED;
			/*
			 * OBP should have probed this device, unless
			 * it was plugged in during the boot operation
			 * before the driver was loaded. In any case,
			 * no assumption is made and hence we take
			 * the conservative approach by keeping fault
			 * led off so board removal is not allowed.
			 */
			if (hsp->hs_board_configured == B_TRUE)
				hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
					HPC_ACTIVE_LED, HPC_LED_ON);
			else
				hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
					HPC_ACTIVE_LED, HPC_LED_BLINK);
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_FAULT_LED,
							HPC_LED_OFF);
			/*
			 * Netra ct alarm card hotswap support
			 */
			if (slot_number == scsb->ac_slotnum &&
				scsb->scsb_hsc_state & SCSB_ALARM_CARD_PRES) {
				hsp->hs_flags |= HSC_ALARM_CARD_PRES;
				DEBUG0("Xscsb_hsc_init_slot_state: "
						"set HSC_ALARM_CARD_PRES");
			}
			break;
		default:
			break;
	}
	return (rc);
}

static hsc_slot_t *
hsc_get_slot_info(hsc_state_t *hsc, int pci_devno)
{
	int i;

	for (i = 0; i < hsc->slot_table_size; i++) {

		if (hsc->slot_table_prop[i].pci_devno == pci_devno)
			return ((hsc_slot_t *)hsc_find_slot(
				hsc->slot_table_prop[i].pslotnum));
	}
	return (NULL);
}

static hsc_slot_t *
hsc_find_slot(int slot_number)
{
	hsc_slot_t	*hsp;

	mutex_enter(&hsc_mutex);
	for (hsp = hsc_slot_list; hsp != NULL; hsp = hsp->hs_next) {
		if (hsp->hs_slot_number == slot_number)
			break;
	}
	mutex_exit(&hsc_mutex);
	return (hsp);
}


/*
 * This function is invoked by the SCSB when an interrupt
 * happens to indicate that a board has been inserted-in/removed-from
 * the specified slot.
 */
int
hsc_slot_occupancy(int slot_number, boolean_t occupied, int flags, int healthy)
{
	static const char	func[]	= "hsc_slot_occupancy";
	hsc_slot_t		*hsp;
	int			rc = DDI_SUCCESS;

	DEBUG4("hsc_slot_occupancy: slot %d %s, ac=%d, healthy=%d",
			slot_number, occupied ? "occupied" : "not occupied",
			(flags == ALARM_CARD_ON_SLOT) ? 1:0, healthy);

	hsp = hsc_find_slot(slot_number);

	if (hsp == NULL) {
		cmn_err(CE_NOTE,
			"%s: cannot map slot number %d to a hsc_slot_t",
			func, slot_number);
		return (DDI_FAILURE);
	}

	hsp->hs_board_healthy = healthy;
	if (occupied) {
		/*
		 * A board was just inserted. We are disconnected at this point.
		 */
		if (hsp->hs_slot_state == HPC_SLOT_EMPTY)
			hsp->hs_board_type = HPC_BOARD_CPCI_HS;
		hsp->hs_slot_state = HPC_SLOT_DISCONNECTED;
		if (flags == ALARM_CARD_ON_SLOT) {
			hsp->hs_flags |= HSC_ALARM_CARD_PRES;
			DEBUG0("Xhsc_slot_occupancy: set HSC_ALARM_CARD_PRES");
		}
		hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_FAULT_LED,
						HPC_LED_ON);
		/*
		 * if previous occupant stayed configured, do not allow another
		 * occupant to be connected.
		 * So as soon as the board is plugged in, we turn both LEDs On.
		 * This behaviour is an indication that the slot state
		 * is not clean.
		 */
		if (hsp->hs_flags & HSC_SLOT_BAD_STATE) {
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
								HPC_LED_ON);
			return (DDI_SUCCESS);
		}

		/* Do not allow connect if slot is disabled */
		if ((hsp->hs_flags & HSC_SLOT_ENABLED) != HSC_SLOT_ENABLED)
			return (DDI_SUCCESS);
		/* if no healthy, we stay disconnected. */
		if (healthy == B_FALSE) {
			return (DDI_SUCCESS);
		}
		rc = hsc_slot_autoconnect(hsp);
		hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
								HPC_LED_BLINK);
	} else {
		/*
		 * A board was just removed
		 */
		hsp->hs_slot_state = HPC_SLOT_EMPTY;
		hsp->hs_board_type = HPC_BOARD_UNKNOWN;
		hsp->hs_flags &= ~HSC_ENUM_FAILED;
		if (hsp->hs_flags & HSC_ALARM_CARD_PRES) {
			hsp->hs_flags &= ~HSC_ALARM_CARD_PRES;
			DEBUG0("Xhsc_slot_occupancy:clear HSC_ALARM_CARD_PRES");
		}
		if (hsp->hs_board_configured == B_TRUE) {
			(void) hpc_slot_event_notify(hsp->hs_slot_handle,
					HPC_EVENT_SLOT_NOT_HEALTHY, 0);
			cmn_err(CE_WARN, "%s#%d: ALERT! Surprise Removal "
				" on Slot %d, Occupant Online!!",
					ddi_driver_name(hsp->hsc->dip),
					ddi_get_instance(hsp->hsc->dip),
					slot_number);
			cmn_err(CE_WARN, "%s#%d: ALERT! System now in "
				" Inconsistent State! Slot disabled. Halt!",
					ddi_driver_name(hsp->hsc->dip),
					ddi_get_instance(hsp->hsc->dip));
			/* Slot in reset and disabled */
			(void) scsb_hsc_disable_slot(hsp);
			hsp->hs_flags |= HSC_SLOT_BAD_STATE;
			/* the following works for P1.0 only. */
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_FAULT_LED,
						HPC_LED_ON);
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
								HPC_LED_ON);
		} else {
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_FAULT_LED,
						HPC_LED_OFF);
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_ACTIVE_LED,
								HPC_LED_OFF);
		}
	}
	return (rc);
}


/*
 * This function is invoked by the SCSB when the health status of
 * a board changes.
 */
/*ARGSUSED*/
int
scsb_hsc_board_healthy(int slot_number, boolean_t healthy)
{
	hsc_slot_t		*hsp;
	hsc_state_t		*hsc;

	DEBUG2("hsc_board_healthy: slot %d = %d\n", slot_number, healthy);

	hsp = hsc_find_slot(slot_number);
	if (hsp == NULL) {
		cmn_err(CE_NOTE, "hsc_board_healthy: No Slot Info.");
		return (DDI_FAILURE);
	}

	hsc = hsp->hsc;
	if (hsp->hs_slot_state == HPC_SLOT_EMPTY) {
#ifdef	DEBUG
		cmn_err(CE_NOTE, "%s#%d: Healthy# %s on "
			"empty slot %d", ddi_driver_name(hsc->dip),
			ddi_get_instance(hsc->dip),
			healthy == B_TRUE ? "On" : "Off", slot_number);
#endif
		return (DDI_FAILURE);
	}
	if (hsp->hs_slot_state == HPC_SLOT_DISCONNECTED) {
		DEBUG2("healthy %s on disconnected slot %d\n",
			healthy == B_TRUE ? "On":"Off", slot_number);
		/*
		 * Connect the slot if board healthy and in autoconfig mode.
		 */
		hsp->hs_board_healthy = healthy;
		if (healthy == B_TRUE)
			return (hsc_slot_autoconnect(hsp));
	}

	/*
	 * the board is connected. The result could be seviour depending
	 * on the occupant state.
	 */
	if (healthy == B_TRUE) {
		if (hsp->hs_board_healthy != B_TRUE) {
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE, HPC_FAULT_LED,
					HPC_LED_OFF);
			/* Regained HEALTHY# at Run Time...!!! */
			cmn_err(CE_NOTE, "%s#%d: slot %d Occupant "
				"%s, Regained HEALTHY#!",
				ddi_driver_name(hsc->dip),
				ddi_get_instance(hsc->dip), slot_number,
				hsp->hs_board_configured == B_TRUE ?
						"configured" : "Unconfigured");
			(void) hpc_slot_event_notify(hsp->hs_slot_handle,
				HPC_EVENT_SLOT_HEALTHY_OK, 0);
		}
	} else {
		if (hsp->hs_board_configured == B_TRUE) {
			/* Lost HEALTHY# at Run Time...Serious Condition. */
			cmn_err(CE_WARN, "%s#%d: ALERT! Lost HEALTHY#"
				" on Slot %d, Occupant %s",
				ddi_driver_name(hsc->dip),
				ddi_get_instance(hsc->dip), slot_number,
					hsp->hs_board_configured == B_TRUE ?
						"Online!!!" : "Offline");
			(void) hpc_slot_event_notify(hsp->hs_slot_handle,
					HPC_EVENT_SLOT_NOT_HEALTHY, 0);
		}
		if ((hsp->hs_board_configured != B_TRUE) ||
						scsb_hsc_healthy_reset) {
			if (scsb_reset_slot(hsp->hs_hpchandle,
					slot_number, SCSB_RESET_SLOT) == 0) {
				/* signal Ok to remove board. */
				hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
					HPC_FAULT_LED, HPC_LED_ON);
				cmn_err(CE_WARN, "%s#%d: Slot %d "
					"successfully taken offline",
					ddi_driver_name(hsc->dip),
					ddi_get_instance(hsc->dip),
					slot_number);
			}
		}
	}
	hsp->hs_board_healthy = healthy;
	return (DDI_SUCCESS);
}

static int
hsc_slot_autoconnect(hsc_slot_t *hsp)
{
	hsc_state_t *hsc = hsp->hsc;
	int rc = DDI_SUCCESS;
	/*
	 * Keep slot in reset unless autoconfiguration is enabled
	 * Ie. for Basic Hotswap mode, we stay disconnected at
	 * insertion. For full hotswap mode, we automatically
	 * go into connected state at insertion, so that occupant
	 * autoconfiguration is possible.
	 */
	if (((hsc->state & HSC_ENUM_ENABLED) == HSC_ENUM_ENABLED) &&
			(hsp->hs_flags & HSC_AUTOCFG)) {
		/* this statement must be here before unreset. */
		hsc->hsp_last = hsp;
		if ((rc = scsb_reset_slot(hsp->hs_hpchandle,
			hsp->hs_slot_number, SCSB_UNRESET_SLOT)) == 0) {

			hsp->hs_slot_state = HPC_SLOT_CONNECTED;
			hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
					HPC_FAULT_LED, HPC_LED_OFF);
		} else {
			hsc->hsp_last = NULL;
			rc = DDI_FAILURE;
		}
	}
	return (rc);
}

/*
 * The SCSB code should invoke this function from its _init() function.
 */
int
hsc_init()
{
	int rc;

	rc = ddi_soft_state_init(&hsc_state, sizeof (hsc_state_t), 1);
	if (rc != 0)
		return (rc);

	hsc_slotops = hpc_alloc_slot_ops(KM_SLEEP);

	hsc_slotops->hpc_version	= HPC_SLOT_OPS_VERSION;
	hsc_slotops->hpc_op_connect	= hsc_connect;
	hsc_slotops->hpc_op_disconnect	= hsc_disconnect;
	hsc_slotops->hpc_op_insert	= hsc_insert;
	hsc_slotops->hpc_op_remove	= hsc_remove;
	hsc_slotops->hpc_op_control	= hsc_control;

	return (DDI_SUCCESS);
}


/*
 * The SCSB code should invoke this function from its _fini() function.
 */
int
hsc_fini()
{
	if (hsc_slotops != NULL) {
		hpc_free_slot_ops(hsc_slotops);
		hsc_slotops = NULL;
	}
	ddi_soft_state_fini(&hsc_state);
	return (DDI_SUCCESS);
}

static int
scsb_enable_enum(hsc_state_t *hsc)
{
	DEBUG0("hsc: Enable ENUM#\n");

	if ((hsc->state & HSC_ENUM_ENABLED) == HSC_ENUM_ENABLED)
		return (DDI_SUCCESS);
	if ((hsc->state & HSC_ATTACHED) != HSC_ATTACHED)
		return (DDI_FAILURE);

	if (ddi_add_intr(hsc->dip, 1, NULL, NULL,
			hsc_enum_intr, (caddr_t)hsc) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "%s#%d: failed ENUM# interrupt registration",
			ddi_driver_name(hsc->dip), ddi_get_instance(hsc->dip));
		return (DDI_FAILURE);
	}
	cmn_err(CE_CONT, "?%s%d: Successfully Upgraded to "
			"Full Hotswap Mode\n", ddi_driver_name(hsc->dip),
			ddi_get_instance(hsc->dip));
	hsc->state |= HSC_ENUM_ENABLED;
	(void) ddi_prop_update_string(DDI_DEV_T_NONE, hsc->dip,
	    HOTSWAP_MODE_PROP, "full");
	return (DDI_SUCCESS);

}

/*ARGSUSED*/
static int
scsb_disable_enum(hsc_state_t *hsc, int op)
{

	DEBUG0("hsc: Disable ENUM#\n");
	if (op == SCSB_HSC_FORCE_REMOVE) {
		/*
		 * Clear all pending interrupts before unregistering
		 * the interrupt. Otherwise the system will hang.
		 *
		 * Due to the hang problem, we'll not turn off or disable
		 * interrupts because if there's a non-friendly full hotswap
		 * device out there, the ENUM# will be kept asserted and
		 * hence hsc_clear_all_enum() can never deassert ENUM#.
		 * So the system will hang.
		 */
		if ((hsc->state & HSC_ENUM_ENABLED) == HSC_ENUM_ENABLED) {
			/* hsc_clear_all_enum(hsc); */
			ddi_remove_intr(hsc->dip, 1, NULL);
			hsc->state &= ~HSC_ENUM_ENABLED;
			cmn_err(CE_CONT, "?%s%d: Successfully Downgraded to "
				"Basic Hotswap Mode\n",
				ddi_driver_name(hsc->dip),
				ddi_get_instance(hsc->dip));
		}
		(void) ddi_prop_update_string(DDI_DEV_T_NONE, hsc->dip,
		    HOTSWAP_MODE_PROP, "basic");
		return (DDI_SUCCESS);
	} else
		/* No programming interface for disabling ENUM# on MC/Tonga */
		return (HPC_ERR_NOTSUPPORTED);
}

#ifndef	lint
static int
hsc_clear_all_enum(hsc_state_t *hsc)
{
	int i, rc;
	hsc_slot_t *hsp;

	for (i = 0; i < hsc->slot_table_size; i++) {

		hsp = hsc_find_slot(hsc->slot_table_prop[i].pslotnum);
		if (hsp == NULL)
			continue;
		rc = hpc_slot_event_notify(hsp->hs_slot_handle,
					HPC_EVENT_CLEAR_ENUM,
						HPC_EVENT_SYNCHRONOUS);
		if (rc == HPC_EVENT_UNCLAIMED)
			break;	/* no pending interrupts across the bus */
		DEBUG1("Pending Intr on slot %d\n",
			hsc->slot_table_prop[i].pslotnum);
	}
	return (0);
}
#endif

int
scsb_hsc_attach(dev_info_t *dip, void *scsb_handle, int instance)
{
	int i, n, prop_len;
	int prom_prop = 0;	/* default: OS property gives slot-table */
	int rc;
	char *hotswap_model;
	hsc_state_t	*hsc;
	scsb_state_t	*scsb = (scsb_state_t *)scsb_handle;
	caddr_t hpc_slot_table_data, s;
	int hpc_slot_table_size;
	hsc_prom_slot_table_t	*hpstp;
	int rstate;

	DEBUG0("hsc_attach: enter\n");
	/*
	 * To get the slot information,
	 * The OBP defines the 'slot-table' property. But the OS
	 * can override it with 'hsc-slot-map' property
	 * through the .conf file.
	 * Since the formats are different, 2 different property names
	 * are chosen.
	 * The OBP property format is
	 * <phandle>,<pci-devno>,<phys-slotno>,<ga-bits>
	 * The OS property format is (ga-bits is not used however)
	 * <busnexus-path>,<pci-devno>,<phys-slotno>,<ga-bits>
	 */
	rc = ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
		"hsc-slot-map", (caddr_t)&hpc_slot_table_data,
		&hpc_slot_table_size);
	if (rc != DDI_PROP_SUCCESS)  {
		prom_prop = 1;
		rc = ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
			"slot-table", (caddr_t)&hpc_slot_table_data,
			&hpc_slot_table_size);
		if (rc != DDI_PROP_SUCCESS) {
			cmn_err(CE_WARN, "%s#%d: 'slot-table' property "
				"missing!", ddi_driver_name(dip),
						ddi_get_instance(dip));
			return (DDI_FAILURE);
		}
	}
	rc = ddi_soft_state_zalloc(hsc_state, instance);
	if (rc != DDI_SUCCESS)
		return (DDI_FAILURE);

	hsc = (hsc_state_t *)ddi_get_soft_state(hsc_state, instance);
	hsc->scsb_handle = scsb_handle;
	hsc->dip = dip;
	hsc->instance = instance;
	hsc->n_registered_occupants = 0;
	hsc->regDone = B_FALSE;
	/* hsc->slot_info = hsc_slot_list; */

	/*
	 * Check whether the system should be in basic or full
	 * hotswap mode. The PROM property always says full, so
	 * look at the .conf file property whether this is "full"
	 */
	if (scsb_hsc_enable_fhs) {
		hsc->hotswap_mode = HSC_HOTSWAP_MODE_FULL;
	} else {
		hsc->hotswap_mode = HSC_HOTSWAP_MODE_BASIC;
	}

	rc = ddi_getlongprop(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
		"default-hotswap-mode", (caddr_t)&hotswap_model, &prop_len);

	if (rc == DDI_PROP_SUCCESS) {
		if (strcmp(hotswap_model, "full") == 0) {
			hsc->hotswap_mode = HSC_HOTSWAP_MODE_FULL;
		} else if (strcmp(hotswap_model, "basic") == 0) {
			hsc->hotswap_mode = HSC_HOTSWAP_MODE_BASIC;
		}

		kmem_free(hotswap_model, prop_len);
	}

	/*
	 * Determine the size of the slot table from the property and
	 * allocate the slot table arrary..Decoding is different for
	 * OS and PROM property.
	 */
	if (!prom_prop) {	/* OS .conf property */
		for (i = 0, n = 0; i < hpc_slot_table_size; i++) {
			if (hpc_slot_table_data[i] == 0) {
				n++;
			}
		}

		/* There should be four elements per entry */
		if (n % 4) {
			cmn_err(CE_WARN, "%s#%d: bad format for "
				"slot-table(%d)", ddi_driver_name(dip),
						ddi_get_instance(dip), n);
			kmem_free(hpc_slot_table_data, hpc_slot_table_size);
			ddi_soft_state_free(hsc_state, instance);
			return (DDI_FAILURE);
		}

		hsc->slot_table_size = n / 4;
	} else {
		hsc->slot_table_size = hpc_slot_table_size /
						sizeof (hsc_prom_slot_table_t);
		n = hpc_slot_table_size % sizeof (hsc_prom_slot_table_t);
		if (n) {
			cmn_err(CE_WARN, "%s#%d: bad format for "
				"slot-table(%d)", ddi_driver_name(dip),
				ddi_get_instance(dip), hpc_slot_table_size);
			kmem_free(hpc_slot_table_data, hpc_slot_table_size);
			ddi_soft_state_free(hsc_state, instance);
			return (DDI_FAILURE);
		}
	}

	/*
	 * Netract800 FTC (formerly known as CFTM) workaround.
	 * Leave Slot 2 out of the HS table if FTC is present in Slot 2
	 */
	if (scsb->scsb_hsc_state & SCSB_HSC_CTC_PRES) {
		hsc->slot_table_size -= 1;
	}
	DEBUG1("hsc_attach: %d hotplug slots on bus\n", hsc->slot_table_size);
	/*
	 * Create enough space for each slot table entry
	 * based on how many entries in the property
	 */
	hsc->slot_table_prop = (hsc_slot_table_t *)
		kmem_zalloc(hsc->slot_table_size *
			sizeof (hsc_slot_table_t), KM_SLEEP);

	if (!prom_prop) {
		s = hpc_slot_table_data;
		for (i = 0; i < hsc->slot_table_size; i++) {

			char *nexus, *pcidev, *phys_slotname, *ga;

			/* Pick off pointer to nexus path or PROM handle */
			nexus = s;
			while (*s != NULL)
				s++;
			s++;

			/* Pick off pointer to the pci device number */
			pcidev = s;
			while (*s != NULL)
				s++;
			s++;

			/* Pick off physical slot no */
			phys_slotname = s;
			while (*s != NULL)
				s++;
			s++;

			/* Pick off GA bits which we dont use for now. */
			ga = s;
			while (*s != NULL)
				s++;
			s++;

			if (scsb->scsb_hsc_state & SCSB_HSC_CTC_PRES &&
					atoi(phys_slotname) == SC_MC_CTC_SLOT) {
				--i;
				continue;
			}
			hsc->slot_table_prop[i].pslotnum = atoi(phys_slotname);
			hsc->slot_table_prop[i].ga = atoi(ga);
			hsc->slot_table_prop[i].pci_devno = atoi(pcidev);
			(void) strcpy(hsc->slot_table_prop[i].nexus, nexus);
		}
	} else {
		hpstp = (hsc_prom_slot_table_t *)hpc_slot_table_data;
		for (i = 0; i < hsc->slot_table_size; i++, hpstp++) {
			if (scsb->scsb_hsc_state & SCSB_HSC_CTC_PRES &&
					hpstp->pslotnum == SC_MC_CTC_SLOT) {
				--i;
				continue;
			}
			hsc->slot_table_prop[i].pslotnum = hpstp->pslotnum;
			hsc->slot_table_prop[i].ga = hpstp->ga;
			hsc->slot_table_prop[i].pci_devno = hpstp->pci_devno;

			if (prom_phandle_to_path((uint_t)hpstp->phandle,
				hsc->slot_table_prop[i].nexus,
				sizeof (hsc->slot_table_prop[i].nexus))
						== -1) {
				cmn_err(CE_WARN, "%s#%d: Cannot get phandle "
					"to nexus path", ddi_driver_name(dip),
					ddi_get_instance(dip));
				kmem_free(hsc->slot_table_prop,
					(hsc->slot_table_size *
						sizeof (hsc_slot_table_t)));
				kmem_free(hpc_slot_table_data,
						hpc_slot_table_size);
				ddi_soft_state_free(hsc_state, instance);
				return (DDI_FAILURE);
			}
		}
	}

	/* keep healthy register cache uptodate before reading slot state */
	if (scsb_read_bhealthy(scsb_handle) != 0) {
		cmn_err(CE_WARN, "%s#%d: hsc_attach: Cannot read "
			"Healthy Registers", ddi_driver_name(dip),
				ddi_get_instance(dip));
		kmem_free(hsc->slot_table_prop,
			(hsc->slot_table_size *
				sizeof (hsc_slot_table_t)));
		kmem_free(hpc_slot_table_data,
				hpc_slot_table_size);
		ddi_soft_state_free(hsc_state, instance);
		return (DDI_FAILURE);
	}

	/*
	 * Before we start registering the slots, calculate how many
	 * slots are occupied.
	 */

	for (i = 0; i < hsc->slot_table_size; i++) {
		if (scsb_get_slot_state(scsb_handle,
				hsc->slot_table_prop[i].pslotnum, &rstate) !=
				DDI_SUCCESS)
				return (rc);
		if (rstate != HPC_SLOT_EMPTY)
			hsc->n_registered_occupants++;
	}

	mutex_init(&hsc->hsc_mutex, NULL, MUTEX_DRIVER, NULL);
	for (i = 0; i < hsc->slot_table_size; i++) {

		DEBUG2("Registering on nexus [%s] cPCI device [%d]\n",
			hsc->slot_table_prop[i].nexus,
			hsc->slot_table_prop[i].pci_devno);

		if (hsc_slot_register(hsc, hsc->slot_table_prop[i].nexus,
			hsc->slot_table_prop[i].pci_devno,
			hsc->slot_table_prop[i].pslotnum, B_FALSE) !=
								HPC_SUCCESS) {

			cmn_err(CE_WARN, "%s#%d: Slot Registration Failure",
				ddi_driver_name(dip), ddi_get_instance(dip));
			while (i) {
				i--;
				n = hsc->slot_table_prop[i].pslotnum;
				if (hsc_slot_unregister(n) != 0) {
					cmn_err(CE_WARN,
						"%s#%d: failed to unregister"
						" slot %d",
						ddi_driver_name(dip),
						ddi_get_instance(dip), n);

				}
			}
			mutex_destroy(&hsc->hsc_mutex);
			kmem_free(hsc->slot_table_prop, (hsc->slot_table_size *
					sizeof (hsc_slot_table_t)));
			kmem_free(hpc_slot_table_data, hpc_slot_table_size);
			ddi_soft_state_free(hsc_state, instance);
			return (DDI_FAILURE);
		}
	}

	hsc->hsp_last = NULL;
	hsc->hsc_intr_counter = 0;
	kmem_free(hpc_slot_table_data, hpc_slot_table_size);
	(void) ddi_prop_update_string(DDI_DEV_T_NONE, hsc->dip,
	    HOTSWAP_MODE_PROP, "basic");
	hsc->state |= (HSC_ATTACHED|HSC_SCB_CONNECTED);

	/*
	 * We enable full hotswap right here if all the slots are empty.
	 */
	if ((hsc->regDone == B_FALSE && hsc->n_registered_occupants == 0) ||
			scsb_hsc_numReg == hsc->n_registered_occupants) {
		hsc->regDone = B_TRUE;
		if (hsc->hotswap_mode == HSC_HOTSWAP_MODE_FULL) {
			if (scsb_enable_enum(hsc) != DDI_SUCCESS) {
				cmn_err(CE_WARN, "%s#%d: Cannot enable "
					"Full Hotswap", ddi_driver_name(dip),
					ddi_get_instance(dip));
			}
		}
	}
	return (DDI_SUCCESS);
}

/*ARGSUSED*/
int
scsb_hsc_detach(dev_info_t *dip, void *scsb_handle, int instance)
{
	int i = 0;
	hsc_state_t	*hsc;
	char slotautocfg_prop[18];

	DEBUG0("hsc_detach: enter\n");
	hsc = (hsc_state_t *)ddi_get_soft_state(hsc_state, instance);
	if (hsc == NULL) {
		DEBUG2("%s#%d: hsc_detach: Soft state NULL",
				ddi_driver_name(dip), ddi_get_instance(dip));
		return (DDI_FAILURE);
	}

	if ((hsc->state & HSC_ATTACHED) != HSC_ATTACHED)
		return (DDI_FAILURE);
	/*
	 * let's unregister the hotpluggable slots with hotplug service.
	 */
	for (i = 0; i < hsc->slot_table_size; i++) {

		hsc_slot_t	*hsp;

		hsp = hsc_find_slot(hsc->slot_table_prop[i].pslotnum);
		if (hsp == NULL) {
			cmn_err(CE_WARN, "%s#%d: hsc_detach: No Slot Info",
				ddi_driver_name(dip), ddi_get_instance(dip));
		} else {
			hpc_led_info_t	aledinfo;	/* active led info. */
			hpc_led_info_t	fledinfo;	/* fault led info. */

			aledinfo.led = HPC_ACTIVE_LED;
			aledinfo.state = HPC_LED_BLINK;
			fledinfo.led = HPC_FAULT_LED;
			fledinfo.state = HPC_LED_OFF;
			(void) hsc_led_state(hsp, HPC_CTRL_SET_LED_STATE,
							&aledinfo);
			(void) hsc_led_state(hsp, HPC_CTRL_SET_LED_STATE,
							&fledinfo);
		}
		(void) sprintf(slotautocfg_prop, "slot%d-autoconfig",
		    hsp->hs_slot_number);
		(void) ddi_prop_remove(DDI_DEV_T_NONE, hsc->dip,
		    slotautocfg_prop);
		if (hsc_slot_unregister(hsc->slot_table_prop[i].pslotnum)
						!= 0) {
			cmn_err(CE_NOTE, "%s#%d: failed to unregister"
				" slot %d\n", ddi_driver_name(dip),
				ddi_get_instance(dip),
				hsc->slot_table_prop[i].pslotnum);
			return (DDI_FAILURE);
		}
	}
	kmem_free(hsc->slot_table_prop, (hsc->slot_table_size *
					sizeof (hsc_slot_table_t)));
	if ((hsc->state & HSC_ENUM_ENABLED) == HSC_ENUM_ENABLED) {
		ddi_remove_intr(hsc->dip, 1, hsc->enum_iblock);
		hsc->state &= ~HSC_ENUM_ENABLED;
	}
	mutex_destroy(&hsc->hsc_mutex);
	(void) ddi_prop_remove(DDI_DEV_T_NONE, hsc->dip, HOTSWAP_MODE_PROP);
	hsc->state &= ~(HSC_ATTACHED|HSC_SCB_CONNECTED);
	ddi_soft_state_free(hsc_state, instance);
	return (DDI_SUCCESS);
}

/*
 * The following function is called when the SCSB is hot extracted from
 * the system.
 */
int
scsb_hsc_freeze(dev_info_t *dip)
{
	hsc_state_t	*hsc;
	int instance = ddi_get_instance(dip);
	int i;
	hsc_slot_t	*hsp;

	hsc = (hsc_state_t *)ddi_get_soft_state(hsc_state, instance);
	if (hsc == NULL) {
		DEBUG2("%s#%d: Soft state NULL",
				ddi_driver_name(dip), ddi_get_instance(dip));
		return (DDI_SUCCESS);
	}
	if ((hsc->state & HSC_ATTACHED) != HSC_ATTACHED)
		return (DDI_SUCCESS);
	hsc->state &= ~HSC_SCB_CONNECTED;

	for (i = 0; i < hsc->slot_table_size; i++) {
		hsp = hsc_find_slot(hsc->slot_table_prop[i].pslotnum);

		if (hsp == NULL) {
			cmn_err(CE_NOTE, "hsc_freeze: "
				" Cannot map slot number %d to a hsc_slot_t",
					hsc->slot_table_prop[i].pslotnum);
			continue;
		}
		/*
		 * Since reset lines are pulled low, lets mark these
		 * slots and not allow a connect operation.
		 * Note that we still keep the slot as slot disconnected,
		 * although it is connected from the hardware standpoint.
		 * As soon as the SCB is plugged back in, we check these
		 * states and put the hardware state back to its original
		 * state.
		 */
		if (hsp->hs_slot_state == HPC_SLOT_DISCONNECTED) {
			cmn_err(CE_WARN, "%s#%d: Slot %d Now out of Reset!",
				ddi_driver_name(hsc->dip),
				ddi_get_instance(hsc->dip),
				hsp->hs_slot_number);
		}
		hsp->hs_flags |= HSC_SCB_HOTSWAPPED;
	}

	return (DDI_SUCCESS);
}

/*
 * The following function is called when the SCSB is hot inserted from
 * the system. We must update the LED status and set the RST# registers
 * again.
 */
int
scsb_hsc_restore(dev_info_t *dip)
{
	int i;
	hsc_state_t	*hsc;
	hsc_slot_t	*hsp;
	int instance = ddi_get_instance(dip);

	hsc = (hsc_state_t *)ddi_get_soft_state(hsc_state, instance);
	if (hsc == NULL) {
		DEBUG2("%s#%d: Soft state NULL",
				ddi_driver_name(dip), ddi_get_instance(dip));
		return (DDI_SUCCESS);
	}

	if ((hsc->state & HSC_ATTACHED) != HSC_ATTACHED)
		return (DDI_SUCCESS);
	hsc->state |= HSC_SCB_CONNECTED;
	for (i = 0; i < hsc->slot_table_size; i++) {
		hsp = hsc_find_slot(hsc->slot_table_prop[i].pslotnum);

		if (hsp == NULL) {
			cmn_err(CE_NOTE, "%s#%d: hsc_restore: "
				" Cannot map slot number %d to a hsc_slot_t",
					ddi_driver_name(hsc->dip),
					ddi_get_instance(hsc->dip),
					hsc->slot_table_prop[i].pslotnum);
			continue;
		}
		if ((hsp->hs_slot_state == HPC_SLOT_DISCONNECTED) &&
				(hsp->hs_board_configured == B_FALSE)) {
			if (scsb_reset_slot(hsp->hs_hpchandle,
					hsp->hs_slot_number,
					SCSB_RESET_SLOT) != 0) {
				cmn_err(CE_WARN, "%s#%d: hsc_restore: "
					" Cannot reset disconnected slot %d",
						ddi_driver_name(hsc->dip),
						ddi_get_instance(hsc->dip),
						hsp->hs_slot_number);
			}
		}

		if (scsb_hsc_init_slot_state(hsc, hsp) != DDI_SUCCESS) {

			cmn_err(CE_WARN, "%s#%d: hsc_freeze: Cannot init"
				" slot%d state",
				ddi_driver_name(hsc->dip),
				ddi_get_instance(hsc->dip),
				hsp->hs_slot_number);
		}
		hsp->hs_flags &= ~HSC_SCB_HOTSWAPPED;
	}
	return (DDI_SUCCESS);
}

#ifndef	lint
int
scsb_hsc_freeze_check(dev_info_t *dip)
{
	hsc_state_t	*hsc;
	int instance = ddi_get_instance(dip);

	hsc = (hsc_state_t *)ddi_get_soft_state(hsc_state, instance);
	if (hsc == NULL) {
		DEBUG2("%s#%d: Soft state NULL",
				ddi_driver_name(dip), ddi_get_instance(dip));
		return (DDI_SUCCESS);
	}
	if ((hsc->state & HSC_ATTACHED) != HSC_ATTACHED)
		return (DDI_SUCCESS);
	return (DDI_SUCCESS);
}
#endif

/*
 * update info about Alarm Card insert/remove mechanism.
 */
void
hsc_ac_op(int instance, int pslotnum, int op, void *arg)
{
	hsc_slot_t *hsp;
	hsc_state_t	*hsc;

	hsc = (hsc_state_t *)ddi_get_soft_state(hsc_state, instance);
	if (hsc == NULL) {
		cmn_err(CE_WARN, "%s#%d: hsc_ac_op: No Soft State Info",
			ddi_driver_name(hsc->dip), ddi_get_instance(hsc->dip));
		return;
	}

	hsp = hsc_find_slot(pslotnum);
	if (hsp == NULL) {
		cmn_err(CE_WARN, "%s#%d: hsc_ac_op: No Slot Info",
			ddi_driver_name(hsc->dip), ddi_get_instance(hsc->dip));
		return;
	}

	switch (op) {
		case SCSB_HSC_AC_UNCONFIGURE :
			/*
			 * If ENUM# is enabled, then action is pending on
			 * this slot, just send a event.
			 */
			if (hsc->state & HSC_ENUM_ENABLED)
				(void) hpc_slot_event_notify(
				    hsp->hs_slot_handle,
				    HPC_EVENT_PROCESS_ENUM, 0);
			break;
		case SCSB_HSC_AC_GET_SLOT_INFO :
			*(hsc_slot_t **)arg = hsp;
			break;
		default :
			break;
	}
}

static uint_t
hsc_enum_intr(caddr_t iarg)
{
	int rc;
	hsc_state_t *hsc = (hsc_state_t *)iarg;
	hsc_slot_t *hsp;

	DEBUG0("!E!");
	if ((hsc->state & HSC_ATTACHED) == 0)
		return (DDI_INTR_UNCLAIMED);

	hsp = hsc_find_slot(hsc->slot_table_prop[0].pslotnum);
	if (hsp == NULL)	/* No slots registered */
		return (DDI_INTR_UNCLAIMED);

	/*
	 * The following must be done to clear interrupt (synchronous event).
	 * To process the interrupt, we send an asynchronous event.
	 */
	rc = hpc_slot_event_notify(hsp->hs_slot_handle,
					HPC_EVENT_CLEAR_ENUM,
						HPC_EVENT_SYNCHRONOUS);
	if (rc == HPC_EVENT_UNCLAIMED) {
		/*
		 * possible support for handling insertion of non friendly
		 * full hotswap boards, otherwise the system hangs due
		 * to uncleared interrupt bursts.
		 */
		DEBUG2("!E>counter %d, last op@slot %lx\n",
				hsc->hsc_intr_counter, hsc->hsp_last);
		hsc->hsc_intr_counter ++;
		if (hsc->hsc_intr_counter == scsb_hsc_max_intr_count) {
			if (!hsc->hsp_last) {
				cmn_err(CE_WARN, "%s#%d: hsc_enum_intr: "
					" No Last Board Insertion Info.",
					ddi_driver_name(hsc->dip),
					ddi_get_instance(hsc->dip));
				hsc->hsc_intr_counter = 0;
				return (DDI_INTR_UNCLAIMED);
			}
			hsp = hsc->hsp_last;
			cmn_err(CE_WARN, "%s#%d: Bad (non friendly ?) Board "
				"in Slot %d ? Taking it Offline.",
				ddi_driver_name(hsc->dip),
				ddi_get_instance(hsc->dip),
				hsp->hs_slot_number);
			/*
			 * this should put just inserted board back in
			 * reset, thus deasserting the ENUM# and the
			 * system hang.
			 */
			if (scsb_reset_slot(hsp->hs_hpchandle,
					hsp->hs_slot_number,
					SCSB_RESET_SLOT) == 0) {
				/* Enumeration failed on this board */
				hsp->hs_flags |= HSC_ENUM_FAILED;
				if (hsp->hs_board_configured == B_TRUE)
					cmn_err(CE_WARN, "%s#%d: ALERT! System"
						" now in Inconsistent State."
						" Halt!",
					    ddi_driver_name(hsc->dip),
					    ddi_get_instance(hsc->dip));
				hsc_led_op(hsp, HPC_CTRL_SET_LED_STATE,
						HPC_FAULT_LED, HPC_LED_ON);
			}
			hsc->hsc_intr_counter = 0;
		}
		return (DDI_INTR_UNCLAIMED);
	}
	hsc->hsc_intr_counter = 0;
	/*
	 * if interrupt success, rc denotes the PCI device number which
	 * generated the ENUM# interrupt.
	 */
	hsp = hsc_get_slot_info(hsc, rc);
	if (hsp == NULL) {
		cmn_err(CE_WARN, "%s#%d: hsc_enum_intr: no slot info for "
			"dev %x", ddi_driver_name(hsc->dip),
			ddi_get_instance(hsc->dip), rc);
		return (DDI_INTR_CLAIMED);	/* interrupt already cleared */
	}
	/* if this is Alarm Card and if it is busy, dont process event */
	if (hsp->hs_flags & HSC_ALARM_CARD_PRES) {
		if (scsb_hsc_ac_op(hsp->hs_hpchandle, hsp->hs_slot_number,
						SCSB_HSC_AC_BUSY) == B_TRUE) {
			/*
			 * Busy means we need to inform (envmond)alarmcard.so
			 * that it should save the AC configuration, stop the
			 * heartbeat, and shutdown the RSC link.
			 */
			(void) scsb_hsc_ac_op(hsp->hs_hpchandle,
					hsp->hs_slot_number,
					SCSB_HSC_AC_REMOVAL_ALERT);
			return (DDI_INTR_CLAIMED);
		}
	}
	/*
	 * If SCB was swapped out, dont process ENUM#. We put this slot
	 * back in reset after SCB is inserted.
	 */
	if ((hsp->hs_flags & HSC_SCB_HOTSWAPPED) &&
			(hsp->hs_slot_state == HPC_SLOT_DISCONNECTED))
		return (DDI_INTR_CLAIMED);

	(void) hpc_slot_event_notify(hsp->hs_slot_handle,
	    HPC_EVENT_PROCESS_ENUM, 0);
	return (DDI_INTR_CLAIMED);
}
/*
 * A routine to convert a number (represented as a string) to
 * the integer value it represents.
 */

static int
isdigit(int ch)
{
	return (ch >= '0' && ch <= '9');
}

#define	isspace(c)	((c) == ' ' || (c) == '\t' || (c) == '\n')
#define	bad(val)	(val == NULL || !isdigit(*val))

static int
atoi(const char *p)
{
	int n;
	int c, neg = 0;

	if (!isdigit(c = *p)) {
		while (isspace(c))
			c = *++p;
		switch (c) {
			case '-':
				neg++;
				/* FALLTHROUGH */
			case '+':
			c = *++p;
		}
		if (!isdigit(c))
			return (0);
	}
	for (n = '0' - c; isdigit(c = *++p); ) {
		n *= 10; /* two steps to avoid unnecessary overflow */
		n += '0' - c; /* accum neg to avoid surprises at MAX */
	}
	return (neg ? n : -n);
}