hotplug/pcihp/pcihp.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

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

/*
 * **********************************************************************
 * Extension module for PCI nexus drivers to support PCI Hot Plug feature.
 *
 * DESCRIPTION:
 *    This module basically implements "devctl" and Attachment Point device
 *    nodes for hot plug operations. The cb_ops functions needed for access
 *    to these device nodes are also implemented. For hotplug operations
 *    on Attachment Points it interacts with the hotplug services (HPS)
 *    framework. A pci nexus driver would simply call pcihp_init() in its
 *    attach() function and pcihp_uninit() call in its detach() function.
 * **********************************************************************
 */

#include <sys/conf.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/modctl.h>
#include <sys/autoconf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/ddi_impldefs.h>
#include <sys/ndi_impldefs.h>
#include <sys/ddipropdefs.h>
#include <sys/open.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/pci.h>
#include <sys/pci_impl.h>
#include <sys/devctl.h>
#include <sys/hotplug/hpcsvc.h>
#include <sys/hotplug/pci/pcicfg.h>
#include <sys/hotplug/pci/pcihp.h>
#include <sys/sysevent.h>
#include <sys/sysevent/eventdefs.h>
#include <sys/sysevent/dr.h>
#include <sys/fs/dv_node.h>

/*
 * NOTE:
 * This module depends on PCI Configurator module (misc/pcicfg),
 * Hot Plug Services framework module (misc/hpcsvc) and Bus Resource
 * Allocator module (misc/busra).
 */

/*
 * ************************************************************************
 * *** Implementation specific data structures/definitions.		***
 * ************************************************************************
 */

/* soft state */
typedef enum { PCIHP_SOFT_STATE_CLOSED, PCIHP_SOFT_STATE_OPEN,
		PCIHP_SOFT_STATE_OPEN_EXCL } pcihp_soft_state_t;

#define	PCI_MAX_DEVS	32	/* max. number of devices on a pci bus */

/* the following correspond to sysevent defined subclasses */
#define	PCIHP_DR_AP_STATE_CHANGE	0
#define	PCIHP_DR_REQ			1

/*  pcihp_get_soft_state() command argument */
#define	PCIHP_DR_NOOP			0
#define	PCIHP_DR_BUS_CONFIGURE		1
#define	PCIHP_DR_BUS_UNCONFIGURE	2
#define	PCIHP_DR_SLOT_ENTER		4
#define	PCIHP_DR_SLOT_EXIT		8

/*  hot plug bus state */
enum { PCIHP_BUS_INITIALIZING, PCIHP_BUS_UNCONFIGURED,
		PCIHP_BUS_CONFIGURED };

/*
 * Soft state structure associated with each hot plug pci bus instance.
 */
typedef struct pcihp {
	struct pcihp		*nextp;

	/* devinfo pointer to the pci bus node */
	dev_info_t		*dip;

	/* soft state flags: PCIHP_SOFT_STATE_* */
	pcihp_soft_state_t	soft_state;

	/* global mutex to serialize exclusive access to the bus */
	kmutex_t		mutex;

	/* slot information structure */
	struct pcihp_slotinfo {
		hpc_slot_t	slot_hdl;	/* HPS slot handle */
		ap_rstate_t	rstate;		/* state of Receptacle */
		ap_ostate_t	ostate;		/* state of the Occupant */
		ap_condition_t	condition;	/* condition of the occupant */
		time32_t	last_change;	/* XXX needed? */
		uint32_t	event_mask;	/* last event mask registered */
		char		*name;		/* slot logical name */
		uint_t		slot_flags;
		uint16_t	slot_type;	/* slot type: pci or cpci */
		uint16_t	slot_capabilities; /* 64bit, etc. */
		int		hs_csr_location; /* Location of HS_CSR */
		kmutex_t	slot_mutex;	/* mutex to serialize hotplug */
						/* operations on the slot */
	} slotinfo[PCI_MAX_DEVS];

	/* misc. bus attributes */
	uint_t			bus_flags;
	uint_t			bus_state;
	uint_t			slots_active;
} pcihp_t;

/*
 * Bit definitions for slot_flags field:
 *
 *	PCIHP_SLOT_AUTO_CFG_EN	This flags is set if nexus can do auto
 *				configuration of hot plugged card on this slot
 *				if the hardware reports the hot plug events.
 *
 *	PCIHP_SLOT_DISABLED	Slot is disabled for hotplug operations.
 *
 *	PCIHP_SLOT_NOT_HEALTHY	HEALTHY# signal is not OK on this slot.
 */
#define	PCIHP_SLOT_AUTO_CFG_EN		0x1
#define	PCIHP_SLOT_DISABLED		0x2
#define	PCIHP_SLOT_NOT_HEALTHY		0x4
#define	PCIHP_SLOT_DEV_NON_HOTPLUG	0x8
#define	PCIHP_SLOT_ENUM_INS_PENDING	0x10
#define	PCIHP_SLOT_ENUM_EXT_PENDING	0x20

/*
 * Bit definitions for bus_flags field:
 *
 *	PCIHP_BUS_66MHZ	Bus is running at 66Mhz.
 */
#define	PCIHP_BUS_66MHZ		0x1
#define	PCIHP_BUS_ENUM_RADIAL	0x2

#define	PCIHP_DEVICES_STR		"/devices"

/*
 * control structure for tree walk during configure/unconfigure operation.
 */
struct pcihp_config_ctrl {
	int	pci_dev;	/* PCI device number for the slot */
	uint_t	flags;		/* control flags (see below) */
	int	op;		/* operation: PCIHP_ONLINE or PCIHP_OFFLINE */
	int	rv;		/* return error code */
	dev_info_t *dip;	/* dip at which the (first) error occurred */
	hpc_occupant_info_t *occupant;
};

/*
 * control flags for configure/unconfigure operations on the tree.
 *
 * PCIHP_CFG_CONTINUE	continue the operation ignoring errors
 */
#define	PCIHP_CFG_CONTINUE	0x1

#define	PCIHP_ONLINE	1
#define	PCIHP_OFFLINE	0


/* Leaf ops (hotplug controls for target devices) */
static int pcihp_open(dev_t *, int, int, cred_t *);
static int pcihp_close(dev_t, int, int, cred_t *);
static int pcihp_ioctl(dev_t, int, intptr_t, int, cred_t *, int *);

#ifdef DEBUG
static int pcihp_debug = 0;
#define	PCIHP_DEBUG(args)	if (pcihp_debug >= 1) cmn_err args
#define	PCIHP_DEBUG2(args)	if (pcihp_debug >= 2) cmn_err args
#else
#define	PCIHP_DEBUG(args)
#define	PCIHP_DEBUG2(args)
#endif

/*
 * We process ENUM# event one device at a time ie. as soon as we detect
 * that a device has the right ENUM# conditions, we return. If the following
 * variable is set to non-zero, we scan all the devices on the bus
 * for ENUM# conditions.
 */
static int pcihp_enum_scan_all = 0;
/*
 * If HSC driver cannot determine the board type (for example: it may not
 * be possible to differentiate between a Basic Hotswap, Non Hotswap or
 * Non-friendly Full hotswap board), the default board type is assigned
 * to be as defined by the following variable.
 */
static int pcihp_cpci_board_type = HPC_BOARD_CPCI_NON_HS;
static int pcihp_cpci_led_blink = 30;
/*
 * It was noted that the blue LED when written on/off would cause INS/EXT
 * bit to be set causing an extra interrupt. Although the cPCI specifications
 * does not imply this, this behavior is seen with some FHS silicons.
 * Also, handling the INS/EXT bit would control the LED being On/Off.
 * Until the behavior is confirmed, this flag could be used to enable or
 * disable handling the LED.
 * 0 means the silicons handles the LED behavior via the INS/EXT bit.
 * 1 means the software must explicitly do the LED behavior.
 */
static int pcihp_cpci_blue_led = 1;

/* static functions */
static pcihp_t *pcihp_create_soft_state(dev_info_t *dip);
static void pcihp_destroy_soft_state(dev_info_t *dip);
static pcihp_t *pcihp_get_soft_state(dev_info_t *dip, int cmd, int *rv);
static int pcihp_configure_ap(pcihp_t *pcihp_p, int pci_dev);
static int pcihp_unconfigure_ap(pcihp_t *pcihp_p, int pci_dev);
static int pcihp_new_slot_state(dev_info_t *, hpc_slot_t,
	hpc_slot_info_t *, int);
static int pcihp_configure(dev_info_t *, void *);
static int pcihp_event_handler(caddr_t, uint_t);
static dev_info_t *pcihp_devi_find(dev_info_t *dip, uint_t dev, uint_t func);
static int pcihp_match_dev(dev_info_t *dip, void *hdl);
static int pcihp_get_hs_csr(struct pcihp_slotinfo *, ddi_acc_handle_t,
	uint8_t *);
static void pcihp_set_hs_csr(struct pcihp_slotinfo *, ddi_acc_handle_t,
	uint8_t *);
static int pcihp_get_hs_csr_location(ddi_acc_handle_t);
static int pcihp_handle_enum(pcihp_t *, int, int, int);
static void pcihp_hs_csr_op(pcihp_t *, int, int);
static int pcihp_enum_slot(pcihp_t *, struct pcihp_slotinfo *, int, int, int);
static int pcihp_handle_enum_extraction(pcihp_t *, int, int, int);
static int pcihp_handle_enum_insertion(pcihp_t *, int, int, int);
static int pcihp_add_dummy_reg_property(dev_info_t *, uint_t, uint_t, uint_t);
static int pcihp_config_setup(dev_info_t **, ddi_acc_handle_t *,
			dev_info_t **, int, pcihp_t *);
static void pcihp_config_teardown(ddi_acc_handle_t *,
			dev_info_t **, int, pcihp_t *);
static int pcihp_get_board_type(struct pcihp_slotinfo *);
/* sysevent function */
static void pcihp_gen_sysevent(char *, int, int, dev_info_t *, int);

extern int pcicfg_configure(dev_info_t *, uint_t);
extern int pcicfg_unconfigure(dev_info_t *, uint_t);

static int pcihp_list_occupants(dev_info_t *, void *);
static int pcihp_indirect_map(dev_info_t *dip);

#if 0
static void pcihp_probe_slot_state(dev_info_t *, int, hpc_slot_state_t *);
#endif

int pcihp_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
    int flags, char *name, caddr_t valuep, int *lengthp);

struct cb_ops pcihp_cb_ops = {
	pcihp_open,			/* open */
	pcihp_close,			/* close */
	nodev,				/* strategy */
	nodev,				/* print */
	nodev,				/* dump */
	nodev,				/* read */
	nodev,				/* write */
	pcihp_ioctl,			/* ioctl */
	nodev,				/* devmap */
	nodev,				/* mmap */
	nodev,				/* segmap */
	nochpoll,			/* poll */
	pcihp_prop_op,			/* cb_prop_op */
	NULL,				/* streamtab */
	D_NEW | D_MP | D_HOTPLUG,	/* Driver compatibility flag */
	CB_REV,				/* rev */
	nodev,				/* int (*cb_aread)() */
	nodev				/* int (*cb_awrite)() */
};

/*
 * local data
 */

int pcihp_autocfg_enabled = 1; /* auto config is enabled by default */

static kmutex_t pcihp_mutex; /* mutex to protect the following data */
static pcihp_t *pcihp_head = NULL;

static kmutex_t pcihp_open_mutex; /* mutex to protect open/close/uninit */
static int	pci_devlink_flags = 0;

/*
 * Module linkage information for the kernel.
 */
extern struct mod_ops mod_miscops;
static struct modlmisc modlmisc = {
	&mod_miscops,
	"PCI nexus hotplug support v%I%",
};

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

int
_init(void)
{
	int error;

	mutex_init(&pcihp_mutex, NULL, MUTEX_DRIVER, NULL);
	mutex_init(&pcihp_open_mutex, NULL, MUTEX_DRIVER, NULL);
	if ((error = mod_install(&modlinkage)) != 0) {
		mutex_destroy(&pcihp_open_mutex);
		mutex_destroy(&pcihp_mutex);
	}

	return (error);
}

int
_fini(void)
{
	return (EBUSY);
}

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

static	pcihp_t *
pcihp_create_soft_state(
	dev_info_t *dip)
{
	pcihp_t	*pcihp_p;

	pcihp_p = kmem_zalloc(sizeof (struct pcihp), KM_SLEEP);

	pcihp_p->dip = dip;
	mutex_init(&pcihp_p->mutex, NULL, MUTEX_DRIVER, NULL);

	mutex_enter(&pcihp_mutex);
	pcihp_p->nextp = pcihp_head;
	pcihp_head = pcihp_p;
	pcihp_p->bus_state = PCIHP_BUS_INITIALIZING;
	pcihp_p->slots_active = 0;
	mutex_exit(&pcihp_mutex);

	return (pcihp_p);
}

static	void
pcihp_destroy_soft_state(
	dev_info_t *dip)
{
	pcihp_t	*p;
	pcihp_t	**pp;

	mutex_enter(&pcihp_mutex);
	pp = &pcihp_head;
	while ((p = *pp) != NULL) {
		if (p->dip == dip) {
			*pp = p->nextp;
			kmem_free(p, sizeof (struct pcihp));
			break;
		}
		pp = &(p->nextp);
	}
	mutex_exit(&pcihp_mutex);
}

/*
 * This function should be imported by client nexus drivers as their
 * devo_getinfo() entry point.
 */

/* ARGSUSED */
int
pcihp_info(
	dev_info_t	*dip,
	ddi_info_cmd_t	cmd,
	void		*arg,
	void		**result)
{
	pcihp_t		*pcihp_p;
	major_t		major;
	minor_t		minor;
	int		instance;

	major = getmajor((dev_t)arg);
	minor = getminor((dev_t)arg);
	instance = PCIHP_AP_MINOR_NUM_TO_INSTANCE(minor);

	switch (cmd) {
	default:
		return (DDI_FAILURE);

	case DDI_INFO_DEVT2INSTANCE:
		*result = (void *)(intptr_t)instance;
		return (DDI_SUCCESS);

	case DDI_INFO_DEVT2DEVINFO:
		mutex_enter(&pcihp_mutex);
		pcihp_p = pcihp_head;
		while (pcihp_p != NULL) {
			if (ddi_name_to_major(ddi_get_name(pcihp_p->dip)) ==
			    major && ddi_get_instance(pcihp_p->dip) ==
			    instance) {
				*result = (void *)pcihp_p->dip;
				mutex_exit(&pcihp_mutex);
				return (DDI_SUCCESS);
			}
			pcihp_p = pcihp_p->nextp;
		}
		mutex_exit(&pcihp_mutex);
		return (DDI_FAILURE);
	}
}

/*
 * This function retrieves the hot plug soft state and performs the
 * following primitive commands while the soft state is locked:
 * mark the bus unconfigured, increment slot activity, decrement
 * slot activity and noop.
 */

/* ARGSUSED */
static	pcihp_t *
pcihp_get_soft_state(
	dev_info_t	*dip, int cmd, int *rv)
{
	pcihp_t		*pcihp_p;

	*rv = PCIHP_SUCCESS;
	mutex_enter(&pcihp_mutex);
	pcihp_p = pcihp_head;
	while (pcihp_p != NULL) {
		if (pcihp_p->dip == dip) {
			switch (cmd) {
			case PCIHP_DR_BUS_UNCONFIGURE:
				if (pcihp_p->slots_active == 0)
					pcihp_p->bus_state =
					    PCIHP_BUS_UNCONFIGURED;
				else
					*rv = PCIHP_FAILURE;
				break;
			case PCIHP_DR_SLOT_ENTER:
				if (pcihp_p->bus_state ==
				    PCIHP_BUS_UNCONFIGURED)
					*rv = PCIHP_FAILURE;
				else
					pcihp_p->slots_active++;
				break;
			case PCIHP_DR_SLOT_EXIT:
				ASSERT(pcihp_p->slots_active > 0);
				if (pcihp_p->slots_active == 0)
					cmn_err(CE_PANIC,
					    "pcihp (%s%d): mismatched slot"
					    " activity",
					    ddi_driver_name(dip),
					    ddi_get_instance(dip));
				else
					pcihp_p->slots_active--;
				break;
			case PCIHP_DR_NOOP:
				break;
			default:
				*rv = PCIHP_FAILURE;
				break;
			}
			mutex_exit(&pcihp_mutex);
			return (pcihp_p);
		}
		pcihp_p = pcihp_p->nextp;
	}
	mutex_exit(&pcihp_mutex);

	return (NULL);
}

/* ARGSUSED3 */
static int
pcihp_open(dev_t *devp, int flags, int otyp, cred_t *credp)
{
	dev_info_t *self;
	pcihp_t *pcihp_p;
	minor_t	minor;
	int pci_dev;
	int rv;

	/*
	 * Make sure the open is for the right file type.
	 */
	if (otyp != OTYP_CHR)
		return (EINVAL);

	mutex_enter(&pcihp_open_mutex);
	/*
	 * Get the soft state structure.
	 */
	if (pcihp_info(NULL, DDI_INFO_DEVT2DEVINFO, (void *)*devp,
	    (void **)&self) != DDI_SUCCESS) {
		mutex_exit(&pcihp_open_mutex);
		return (ENXIO);
	}

	pcihp_p = pcihp_get_soft_state(self, PCIHP_DR_NOOP, &rv);
	ASSERT(pcihp_p != NULL);

	mutex_enter(&pcihp_p->mutex);

	/*
	 * If the pci_dev is valid then the minor device is an
	 * AP. Otherwise it is ":devctl" minor device.
	 */
	minor = getminor(*devp);
	pci_dev = PCIHP_AP_MINOR_NUM_TO_PCI_DEVNUM(minor);
	if (pci_dev < PCI_MAX_DEVS) {
		struct pcihp_slotinfo *slotinfop;

		slotinfop = &pcihp_p->slotinfo[pci_dev];
		if (slotinfop->slot_hdl == NULL) {
			mutex_exit(&pcihp_p->mutex);
			mutex_exit(&pcihp_open_mutex);
			return (ENXIO);
		}
	}

	/*
	 * Handle the open by tracking the device state.
	 *
	 * Note: Needs review w.r.t exclusive access to AP or the bus.
	 * Currently in the pci plug-in we don't use EXCL open at all
	 * so the code below implements EXCL access on the bus.
	 */

	/* enforce exclusive access to the bus */
	if ((pcihp_p->soft_state == PCIHP_SOFT_STATE_OPEN_EXCL) ||
	    ((flags & FEXCL) &&
	    (pcihp_p->soft_state != PCIHP_SOFT_STATE_CLOSED))) {
		mutex_exit(&pcihp_p->mutex);
		mutex_exit(&pcihp_open_mutex);
		return (EBUSY);
	}

	if (flags & FEXCL)
		pcihp_p->soft_state = PCIHP_SOFT_STATE_OPEN_EXCL;
	else
		pcihp_p->soft_state = PCIHP_SOFT_STATE_OPEN;

	mutex_exit(&pcihp_p->mutex);
	mutex_exit(&pcihp_open_mutex);

	return (0);
}

/* ARGSUSED */
static int
pcihp_close(dev_t dev, int flags, int otyp, cred_t *credp)
{
	dev_info_t *self;
	pcihp_t *pcihp_p;
	int rv;

	if (otyp != OTYP_CHR)
		return (EINVAL);

	mutex_enter(&pcihp_open_mutex);

	if (pcihp_info(NULL, DDI_INFO_DEVT2DEVINFO, (void *)dev,
	    (void **)&self) != DDI_SUCCESS) {
		mutex_exit(&pcihp_open_mutex);
		return (ENXIO);
	}

	pcihp_p = pcihp_get_soft_state(self, PCIHP_DR_NOOP, &rv);
	ASSERT(pcihp_p != NULL);

	mutex_enter(&pcihp_p->mutex);
	pcihp_p->soft_state = PCIHP_SOFT_STATE_CLOSED;
	mutex_exit(&pcihp_p->mutex);

	mutex_exit(&pcihp_open_mutex);

	return (0);
}

static int
pcihp_list_occupants(dev_info_t *dip, void *hdl)
{
	int pci_dev;
	struct pcihp_config_ctrl *ctrl = (struct pcihp_config_ctrl *)hdl;
	pci_regspec_t *pci_rp;
	int length;
	major_t major;

	/*
	 * Get the PCI device number information from the devinfo
	 * node. Since the node may not have the address field
	 * setup (this is done in the DDI_INITCHILD of the parent)
	 * we look up the 'reg' property to decode that information.
	 */
	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
	    DDI_PROP_DONTPASS, "reg", (int **)&pci_rp,
	    (uint_t *)&length) != DDI_PROP_SUCCESS) {
		ctrl->rv = DDI_FAILURE;
		ctrl->dip = dip;
		return (DDI_WALK_TERMINATE);
	}

	/* get the pci device id information */
	pci_dev = PCI_REG_DEV_G(pci_rp->pci_phys_hi);

	/*
	 * free the memory allocated by ddi_prop_lookup_int_array
	 */
	ddi_prop_free(pci_rp);

	/*
	 * Match the node for the device number of the slot.
	 */
	if (pci_dev == ctrl->pci_dev) { /* node is a match */

		major = ddi_driver_major(dip);

		/*
		 * If the node is not yet attached, then don't list it
		 * as an occupant. This is valid, since nothing can be
		 * consuming it until it is attached, and cfgadm will
		 * ask for the property explicitly which will cause it
		 * to be re-freshed right before checking with rcm.
		 */
		if ((major == -1) || !i_ddi_devi_attached(dip))
			return (DDI_WALK_PRUNECHILD);

		/*
		 * If we have used all our occupants then print mesage
		 * and terminate walk.
		 */
		if (ctrl->occupant->i >= HPC_MAX_OCCUPANTS) {
			cmn_err(CE_WARN,
			    "pcihp (%s%d): unable to list all occupants",
			    ddi_driver_name(ddi_get_parent(dip)),
			    ddi_get_instance(ddi_get_parent(dip)));
			return (DDI_WALK_TERMINATE);
		}

		/*
		 * No need to hold the dip as ddi_walk_devs
		 * has already arranged that for us.
		 */
		ctrl->occupant->id[ctrl->occupant->i] =
		    kmem_alloc(sizeof (char[MAXPATHLEN]), KM_SLEEP);
		(void) ddi_pathname(dip,
		    (char *)ctrl->occupant->id[ctrl->occupant->i]);
		ctrl->occupant->i++;
	}

	/*
	 * continue the walk to the next sibling to look for a match
	 * or to find other nodes if this card is a multi-function card.
	 */
	return (DDI_WALK_PRUNECHILD);
}

static void
pcihp_create_occupant_props_nolock(dev_info_t *self, dev_t dev, int pci_dev)
{
	struct pcihp_config_ctrl ctrl;
	hpc_occupant_info_t *occupant;
	int i;

	occupant = kmem_alloc(sizeof (hpc_occupant_info_t), KM_SLEEP);
	occupant->i = 0;

	ctrl.flags = 0;
	ctrl.dip = NULL;
	ctrl.rv = NDI_SUCCESS;
	ctrl.pci_dev = pci_dev;
	ctrl.op = 55; /* should define DRYRUN */
	ctrl.occupant = occupant;

	ddi_walk_devs(ddi_get_child(self), pcihp_list_occupants,
	    (void *)&ctrl);

	if (occupant->i == 0) {
		/* no occupants right now, need to create stub property */
		char *c[] = { "" };
		(void) ddi_prop_update_string_array(dev, self, "pci-occupant",
		    c, 1);
	} else {
		(void) ddi_prop_update_string_array(dev, self, "pci-occupant",
		    occupant->id, occupant->i);
	}
	for (i = 0; i < occupant->i; i++) {
		kmem_free(occupant->id[i], sizeof (char[MAXPATHLEN]));
	}

	kmem_free(occupant, sizeof (hpc_occupant_info_t));
}

static void
pcihp_create_occupant_props(dev_info_t *self, dev_t dev, int pci_dev)
{
	int circular;

	ndi_devi_enter(self, &circular);
	pcihp_create_occupant_props_nolock(self, dev, pci_dev);
	ndi_devi_exit(self, circular);
}

static void
pcihp_delete_occupant_props(dev_info_t *dip, dev_t dev)
{
	if (ddi_prop_remove(dev, dip, "pci-occupant")
	    != DDI_PROP_SUCCESS)
		return; /* add error handling */

}

/*
 * pcihp_ioctl: devctl hotplug controls
 */
/* ARGSUSED */
static int
pcihp_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
	int *rvalp)
{
	pcihp_t *pcihp_p;
	dev_info_t *self;
	struct devctl_iocdata *dcp;
	uint_t bus_state;
	int rv = 0;
	int pci_dev;
	struct pcihp_slotinfo *slotinfop;
	hpc_slot_state_t rstate;
	devctl_ap_state_t ap_state;
	struct hpc_control_data hpc_ctrldata;
	struct hpc_led_info led_info;
	time_t time;
	int state_locking;
	int state_unlocking;
	int rval;
	char *pathname = NULL;

	/*
	 * read devctl ioctl data before soft state retrieval
	 */
	if ((cmd != DEVCTL_AP_CONTROL) &&
	    ndi_dc_allochdl((void *)arg, &dcp) != NDI_SUCCESS)
		return (EFAULT);

	if (pcihp_info(NULL, DDI_INFO_DEVT2DEVINFO, (void *)dev,
	    (void **)&self) != DDI_SUCCESS) {
		if (cmd != DEVCTL_AP_CONTROL)
			ndi_dc_freehdl(dcp);
		return (ENXIO);
	}

	switch (cmd) {
	case DEVCTL_AP_INSERT:
	case DEVCTL_AP_REMOVE:
	case DEVCTL_AP_CONNECT:
	case DEVCTL_AP_DISCONNECT:
	case DEVCTL_AP_CONFIGURE:
	case DEVCTL_AP_UNCONFIGURE:
	case DEVCTL_AP_GETSTATE:
	case DEVCTL_AP_CONTROL:
		state_locking = PCIHP_DR_SLOT_ENTER;
		state_unlocking = PCIHP_DR_SLOT_EXIT;
		break;
	default:
		state_locking = PCIHP_DR_NOOP;
		state_unlocking = PCIHP_DR_NOOP;
		break;
	}

	pcihp_p = pcihp_get_soft_state(self, state_locking, &rval);
	ASSERT(pcihp_p != NULL);

	if (rval == PCIHP_FAILURE) {
		(void) ddi_pathname(pcihp_p->dip, pathname);
		PCIHP_DEBUG((CE_WARN, "Hot Plug bus %s instance is unconfigured"
		    " while slot activity is requested\n", pathname));
		if (cmd != DEVCTL_AP_CONTROL)
			ndi_dc_freehdl(dcp);
		return (EBUSY);
	}

	/*
	 * For attachment points the lower 8 bits of the minor number is the
	 * PCI device number.
	 */
	pci_dev = PCIHP_AP_MINOR_NUM_TO_PCI_DEVNUM(getminor(dev));

	/*
	 * We can use the generic implementation for these ioctls
	 */
	switch (cmd) {
	case DEVCTL_DEVICE_GETSTATE:
	case DEVCTL_DEVICE_ONLINE:
	case DEVCTL_DEVICE_OFFLINE:
	case DEVCTL_BUS_GETSTATE:
		rv = ndi_devctl_ioctl(self, cmd, arg, mode, 0);
		ndi_dc_freehdl(dcp);
		return (rv);
	default:
		break;
	}

	switch (cmd) {

	case DEVCTL_DEVICE_RESET:
		rv = ENOTSUP;
		break;

	case DEVCTL_BUS_QUIESCE:
		if (ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS)
			if (bus_state == BUS_QUIESCED)
				break;
		(void) ndi_set_bus_state(self, BUS_QUIESCED);
		break;

	case DEVCTL_BUS_UNQUIESCE:
		if (ndi_get_bus_state(self, &bus_state) == NDI_SUCCESS)
			if (bus_state == BUS_ACTIVE)
				break;
		(void) ndi_set_bus_state(self, BUS_ACTIVE);
		break;

	case DEVCTL_BUS_RESET:
		rv = ENOTSUP;
		break;

	case DEVCTL_BUS_RESETALL:
		rv = ENOTSUP;
		break;

	case DEVCTL_AP_CONNECT:
	case DEVCTL_AP_DISCONNECT:
		/*
		 * CONNECT(DISCONNECT) the hot plug slot to(from) the bus.
		 *
		 * For cPCI slots this operation is a nop so the HPC
		 * driver may return success if it is a valid operation.
		 */
	case DEVCTL_AP_INSERT:
	case DEVCTL_AP_REMOVE:
		/*
		 * Prepare the slot for INSERT/REMOVE operation.
		 */

		/*
		 * check for valid request:
		 *	1. It is a hotplug slot.
		 *	2. The slot has no occupant that is in
		 *	   the 'configured' state.
		 */
		if (pci_dev >= PCI_MAX_DEVS) {
			rv = ENXIO;
			break;
		}
		slotinfop = &pcihp_p->slotinfo[pci_dev];

		mutex_enter(&slotinfop->slot_mutex);

		if ((slotinfop->slot_hdl == NULL) ||
		    (slotinfop->slot_flags & PCIHP_SLOT_DISABLED)) {
			rv = ENXIO;
			mutex_exit(&slotinfop->slot_mutex);
			break;
		}

		/* the slot occupant must be in the UNCONFIGURED state */
		if (slotinfop->ostate != AP_OSTATE_UNCONFIGURED) {
			rv = EINVAL;
			mutex_exit(&slotinfop->slot_mutex);
			break;
		}
		/*
		 * Call the HPC driver to perform the operation on the slot.
		 */

		switch (cmd) {
		case DEVCTL_AP_INSERT:
			rv = hpc_nexus_insert(slotinfop->slot_hdl, NULL, 0);
			break;
		case DEVCTL_AP_REMOVE:
			rv = hpc_nexus_remove(slotinfop->slot_hdl, NULL, 0);
			break;
		case DEVCTL_AP_CONNECT:
			rv = hpc_nexus_connect(slotinfop->slot_hdl, NULL, 0);
			if (rv == HPC_SUCCESS) {
				slotinfop->rstate = AP_RSTATE_CONNECTED;

				if (drv_getparm(TIME, (void *)&time) !=
				    DDI_SUCCESS)
					slotinfop->last_change = (time_t)-1;
				else
					slotinfop->last_change = (time32_t)time;

				slotinfop = &pcihp_p->slotinfo[pci_dev];
				pcihp_gen_sysevent(slotinfop->name,
						PCIHP_DR_AP_STATE_CHANGE,
						SE_NO_HINT, pcihp_p->dip,
						KM_SLEEP);
			}
			break;
		case DEVCTL_AP_DISCONNECT:
			rv = hpc_nexus_disconnect(slotinfop->slot_hdl, NULL, 0);
			if (rv == HPC_SUCCESS) {
				slotinfop->rstate = AP_RSTATE_DISCONNECTED;

				if (drv_getparm(TIME, (void *)&time) !=
				    DDI_SUCCESS)
					slotinfop->last_change = (time_t)-1;
				else
					slotinfop->last_change = (time32_t)time;

				slotinfop = &pcihp_p->slotinfo[pci_dev];
				pcihp_gen_sysevent(slotinfop->name,
						PCIHP_DR_AP_STATE_CHANGE,
						SE_NO_HINT, pcihp_p->dip,
						KM_SLEEP);
			}
			break;
		}
		mutex_exit(&slotinfop->slot_mutex);

		switch (rv) {
		case HPC_ERR_INVALID:
			rv = ENXIO;
			break;
		case HPC_ERR_NOTSUPPORTED:
			rv = ENOTSUP;
			break;
		case HPC_ERR_FAILED:
			rv = EIO;
			break;
		}

		break;

	case DEVCTL_AP_CONFIGURE:
		/*
		 * **************************************
		 * CONFIGURE the occupant in the slot.
		 * **************************************
		 */
		slotinfop = &pcihp_p->slotinfo[pci_dev];

		mutex_enter(&slotinfop->slot_mutex);

		rv = pcihp_configure_ap(pcihp_p, pci_dev);
		if (rv == HPC_SUCCESS) {
			pcihp_gen_sysevent(slotinfop->name,
			    PCIHP_DR_AP_STATE_CHANGE,
			    SE_NO_HINT, pcihp_p->dip, KM_SLEEP);
			pcihp_create_occupant_props(self, dev, pci_dev);
		}
		mutex_exit(&slotinfop->slot_mutex);

		break;

	case DEVCTL_AP_UNCONFIGURE:
		/*
		 * **************************************
		 * UNCONFIGURE the occupant in the slot.
		 * **************************************
		 */
		slotinfop = &pcihp_p->slotinfo[pci_dev];

		mutex_enter(&slotinfop->slot_mutex);

		rv = pcihp_unconfigure_ap(pcihp_p, pci_dev);

		if (rv == HPC_SUCCESS) {
			pcihp_gen_sysevent(slotinfop->name,
			    PCIHP_DR_AP_STATE_CHANGE,
			    SE_NO_HINT, pcihp_p->dip, KM_SLEEP);
			pcihp_delete_occupant_props(pcihp_p->dip, dev);
		}
		mutex_exit(&slotinfop->slot_mutex);

		break;

	case DEVCTL_AP_GETSTATE:
	    {
		int mutex_held;

		/*
		 * return the state of Attachment Point.
		 *
		 * If the occupant is in UNCONFIGURED state then
		 * we should get the receptacle state from the
		 * HPC driver because the receptacle state
		 * maintained in the nexus may not be accurate.
		 */

		/*
		 * check for valid request:
		 *	1. It is a hotplug slot.
		 */
		slotinfop = &pcihp_p->slotinfo[pci_dev];

		/* try to acquire the slot mutex */
		mutex_held = mutex_tryenter(&slotinfop->slot_mutex);

		if (pci_dev >= PCI_MAX_DEVS || slotinfop->slot_hdl == NULL) {
			rv = ENXIO;
			if (mutex_held) {
				mutex_exit(&slotinfop->slot_mutex);
			}
			break;
		}

		if (slotinfop->ostate == AP_OSTATE_UNCONFIGURED) {
		    if (hpc_nexus_control(slotinfop->slot_hdl,
			HPC_CTRL_GET_SLOT_STATE, (caddr_t)&rstate) != 0) {
			rv = EIO;
			if (mutex_held)
			    mutex_exit(&slotinfop->slot_mutex);
			break;
		    }
		    slotinfop->rstate = (ap_rstate_t)rstate;
		}

		ap_state.ap_rstate = slotinfop->rstate;
		ap_state.ap_ostate = slotinfop->ostate;
		ap_state.ap_condition = slotinfop->condition;
		ap_state.ap_last_change = slotinfop->last_change;
		ap_state.ap_error_code = 0; /* XXX */
		if (mutex_held)
			ap_state.ap_in_transition = 0; /* AP is not busy */
		else
			ap_state.ap_in_transition = 1; /* AP is busy */

		if (mutex_held)
			mutex_exit(&slotinfop->slot_mutex);

		/* copy the return-AP-state information to the user space */
		if (ndi_dc_return_ap_state(&ap_state, dcp) != NDI_SUCCESS)
			rv = EFAULT;

		break;

	    }
	case DEVCTL_AP_CONTROL:
		/*
		 * HPC control functions:
		 *	HPC_CTRL_ENABLE_SLOT/HPC_CTRL_DISABLE_SLOT
		 *		Changes the state of the slot and preserves
		 *		the state across the reboot.
		 *	HPC_CTRL_ENABLE_AUTOCFG/HPC_CTRL_DISABLE_AUTOCFG
		 *		Enables or disables the auto configuration
		 *		of hot plugged occupant if the hardware
		 *		supports notification of the hot plug
		 *		events.
		 *	HPC_CTRL_GET_LED_STATE/HPC_CTRL_SET_LED_STATE
		 *		Controls the state of an LED.
		 *	HPC_CTRL_GET_SLOT_INFO
		 *		Get slot information data structure
		 *		(hpc_slot_info_t).
		 *	HPC_CTRL_GET_BOARD_TYPE
		 *		Get board type information (hpc_board_type_t).
		 *	HPC_CTRL_GET_CARD_INFO
		 *		Get card information (hpc_card_info_t).
		 *
		 * These control functions are used by the cfgadm plug-in
		 * to implement "-x" and "-v" options.
		 */

		/* copy user ioctl data first */
#ifdef _MULTI_DATAMODEL
		if (ddi_model_convert_from(mode & FMODELS) == DDI_MODEL_ILP32) {
			struct hpc_control32_data hpc_ctrldata32;

			if (copyin((void *)arg, (void *)&hpc_ctrldata32,
				sizeof (struct hpc_control32_data)) != 0) {
				rv = EFAULT;
				break;
			}
			hpc_ctrldata.cmd = hpc_ctrldata32.cmd;
			hpc_ctrldata.data =
				(void *)(intptr_t)hpc_ctrldata32.data;
		}
#else
		if (copyin((void *)arg, (void *)&hpc_ctrldata,
			sizeof (struct hpc_control_data)) != 0) {
			rv = EFAULT;
			break;
		}
#endif

		/*
		 * check for valid request:
		 *	1. It is a hotplug slot.
		 */
		slotinfop = &pcihp_p->slotinfo[pci_dev];

		mutex_enter(&slotinfop->slot_mutex);

		if (pci_dev >= PCI_MAX_DEVS || slotinfop->slot_hdl == NULL) {
			rv = ENXIO;
			mutex_exit(&slotinfop->slot_mutex);
			break;
		}

		switch (hpc_ctrldata.cmd) {

		case HPC_CTRL_GET_LED_STATE:
			/* copy the led info from the user space */
			if (copyin(hpc_ctrldata.data, (void *)&led_info,
					sizeof (hpc_led_info_t)) != 0) {
				rv = EFAULT;
				break;
			}

			/* get the state of LED information */
			if (hpc_nexus_control(slotinfop->slot_hdl,
				HPC_CTRL_GET_LED_STATE,
				(caddr_t)&led_info) != 0) {

				if (rv != ENOTSUP)
					rv = EIO;

				break;
			}

			/* copy the led info to the user space */
			if (copyout((void *)&led_info,
			    hpc_ctrldata.data,
			    sizeof (hpc_led_info_t)) != 0) {
			    rv = EFAULT;
			    break;
			}

			break;

		case HPC_CTRL_SET_LED_STATE:
			/* copy the led info from the user space */
			if (copyin(hpc_ctrldata.data, (void *)&led_info,
			    sizeof (hpc_led_info_t)) != 0) {
			    rv = EFAULT;
			    break;
			}

			/* set the state of an LED */
			rv = hpc_nexus_control(slotinfop->slot_hdl,
			    HPC_CTRL_SET_LED_STATE, (caddr_t)&led_info);

			/*
			 * If the Hotswap Controller does not support
			 * LED management (as you would find typically
			 * in the cPCI industry), then we handle the
			 * blue LED on/off/blink operations, just in
			 * case it helps slot identification.
			 */
			if ((rv == HPC_ERR_NOTSUPPORTED) &&
				(slotinfop->slot_type & HPC_SLOT_TYPE_CPCI)) {
				if (led_info.led != HPC_ATTN_LED)
					break;

				switch (led_info.state) {
					case HPC_LED_OFF:
						pcihp_hs_csr_op(pcihp_p,
						pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_OFF);
						rv = 0;
						break;
					case HPC_LED_ON:
						/*
						 * Please note that leaving
						 * LED ON could be dangerous
						 * as it means it is Ok to
						 * remove the board, which
						 * is not what we want to
						 * convey. So it is upto the
						 * user to take care of this
						 * situation and usage.
						 *
						 * Normally, a Blink command
						 * is more appropriate for
						 * identifying a board.
						 */
						pcihp_hs_csr_op(pcihp_p,
						pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_ON);
						rv = 0;
						break;
					case HPC_LED_BLINK:
					{
						int bl;

						for (bl = 0; bl < 2; bl++) {
						pcihp_hs_csr_op(pcihp_p,
						pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_ON);
						delay(pcihp_cpci_led_blink);
						pcihp_hs_csr_op(pcihp_p,
						pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_OFF);
						delay(pcihp_cpci_led_blink);
						}
						rv = 0;
						break;
					}
					default:
						break;
				}
			}

			if (rv == HPC_ERR_FAILED)
				rv = EIO;
			break;

		case HPC_CTRL_ENABLE_SLOT:

			/*
			 * If slot already enabled, do not send a duplicate
			 * control message to the HPC driver.
			 */
			if ((slotinfop->slot_flags & PCIHP_SLOT_DISABLED) == 0)
				break;

			/* tell the HPC driver also */
			if (hpc_nexus_control(slotinfop->slot_hdl,
					HPC_CTRL_ENABLE_SLOT, NULL)
							!= HPC_SUCCESS) {
				rv = EIO;
				break;
			}

			/*
			 * Enable the slot for hotplug operations.
			 */
			slotinfop->slot_flags &= ~PCIHP_SLOT_DISABLED;

			slotinfop->condition = AP_COND_UNKNOWN;

			/* XXX need to preserve this state across reboot? */

			break;

		case HPC_CTRL_DISABLE_SLOT:

			/* Do not disable if occupant configured */
			if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {
				rv = EAGAIN;
				break;
			}

			/* tell the HPC driver also */
			if (hpc_nexus_control(slotinfop->slot_hdl,
					HPC_CTRL_DISABLE_SLOT, NULL)
							!= HPC_SUCCESS) {
				rv = EIO;
				break;
			}

			/*
			 * Disable the slot for hotplug operations.
			 */
			slotinfop->slot_flags |= PCIHP_SLOT_DISABLED;

			slotinfop->condition = AP_COND_UNUSABLE;

			/* XXX need to preserve this state across reboot? */

			break;

		case HPC_CTRL_ENABLE_AUTOCFG:
			/*
			 * Enable auto configuration on this slot.
			 */
			slotinfop->slot_flags |= PCIHP_SLOT_AUTO_CFG_EN;

			/* tell the HPC driver also */
			(void) hpc_nexus_control(slotinfop->slot_hdl,
				HPC_CTRL_ENABLE_AUTOCFG, NULL);

			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI)
				pcihp_hs_csr_op(pcihp_p, pci_dev,
					HPC_EVENT_ENABLE_ENUM);
			break;

		case HPC_CTRL_DISABLE_AUTOCFG:
			/*
			 * Disable auto configuration on this slot.
			 */
			slotinfop->slot_flags &= ~PCIHP_SLOT_AUTO_CFG_EN;

			/* tell the HPC driver also */
			(void) hpc_nexus_control(slotinfop->slot_hdl,
			    HPC_CTRL_DISABLE_AUTOCFG, NULL);

			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI)
				pcihp_hs_csr_op(pcihp_p, pci_dev,
					HPC_EVENT_DISABLE_ENUM);
			break;

		case HPC_CTRL_GET_BOARD_TYPE:
		    {
			hpc_board_type_t board_type;

			/*
			 * Get board type data structure, hpc_board_type_t.
			 */
			board_type = pcihp_get_board_type(slotinfop);
			if (board_type == -1) {
			    rv = ENXIO;
			    break;
			}

			/* copy the board type info to the user space */
			if (copyout((void *)&board_type, hpc_ctrldata.data,
			    sizeof (hpc_board_type_t)) != 0) {
			    rv = ENXIO;
			    break;
			}

			break;
		    }

		case HPC_CTRL_GET_SLOT_INFO:
		    {
			hpc_slot_info_t slot_info;

			/*
			 * Get slot information structure, hpc_slot_info_t.
			 */
			slot_info.version = HPC_SLOT_INFO_VERSION;
			slot_info.slot_type = slotinfop->slot_type;
			slot_info.pci_slot_capabilities =
					slotinfop->slot_capabilities;
			slot_info.pci_dev_num = (uint16_t)pci_dev;
			(void) strcpy(slot_info.pci_slot_name, slotinfop->name);

			/* copy the slot info structure to the user space */
			if (copyout((void *)&slot_info, hpc_ctrldata.data,
			    sizeof (hpc_slot_info_t)) != 0) {
			    rv = EFAULT;
			    break;
			}

			break;
		    }

		case HPC_CTRL_GET_CARD_INFO:
		    {
			hpc_card_info_t card_info;
			ddi_acc_handle_t handle;
			dev_info_t *cdip;

			/*
			 * Get card information structure, hpc_card_info_t.
			 */

			/* verify that the card is configured */
			if ((slotinfop->ostate != AP_OSTATE_CONFIGURED) ||
			    ((cdip = pcihp_devi_find(self, pci_dev,
							0)) == NULL)) {
			    /* either the card is not present or */
			    /* it is not configured.		 */
			    rv = ENXIO;
			    break;
			}

			/*
			 * If declared failed, don't allow Config operations.
			 * Otherwise, if good or failing, it is assumed Ok
			 * to get config data.
			 */
			if (slotinfop->condition == AP_COND_FAILED) {
				rv = EIO;
				break;
			}

			/* get the information from the PCI config header */
			/* for the function 0.				  */
			if (pci_config_setup(cdip, &handle) != DDI_SUCCESS) {
				rv = EIO;
				break;
			}
			card_info.prog_class = pci_config_get8(handle,
						PCI_CONF_PROGCLASS);
			card_info.base_class = pci_config_get8(handle,
						PCI_CONF_BASCLASS);
			card_info.sub_class = pci_config_get8(handle,
						PCI_CONF_SUBCLASS);
			card_info.header_type = pci_config_get8(handle,
						PCI_CONF_HEADER);
			pci_config_teardown(&handle);

			/* copy the card info structure to the user space */
			if (copyout((void *)&card_info, hpc_ctrldata.data,
			    sizeof (hpc_card_info_t)) != 0) {
			    rv = EFAULT;
			    break;
			}

			break;
		    }

		default:
			rv = EINVAL;
			break;
		}

		mutex_exit(&slotinfop->slot_mutex);

		break;

	default:
		rv = ENOTTY;
	}

	if (cmd != DEVCTL_AP_CONTROL)
		ndi_dc_freehdl(dcp);

	(void) pcihp_get_soft_state(self, state_unlocking, &rval);

	return (rv);
}

/*
 * **************************************
 * CONFIGURE the occupant in the slot.
 * **************************************
 */
static int
pcihp_configure_ap(pcihp_t *pcihp_p, int pci_dev)
{
	dev_info_t *self = pcihp_p->dip;
	int rv = HPC_SUCCESS;
	struct pcihp_slotinfo *slotinfop;
	hpc_slot_state_t rstate;
	struct pcihp_config_ctrl ctrl;
	int circular_count;
	time_t time;

	/*
	 * check for valid request:
	 *	1. It is a hotplug slot.
	 *	2. The receptacle is in the CONNECTED state.
	 */
	slotinfop = &pcihp_p->slotinfo[pci_dev];


	if ((pci_dev >= PCI_MAX_DEVS) || (slotinfop->slot_hdl == NULL) ||
			(slotinfop->slot_flags & PCIHP_SLOT_DISABLED)) {

		return (ENXIO);
	}

	/*
	 * If the occupant is already in (partially?) configured
	 * state then call the ndi_devi_online() on the device
	 * subtree(s) for this attachment point.
	 */

	if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {
		ctrl.flags = PCIHP_CFG_CONTINUE;
		ctrl.rv = NDI_SUCCESS;
		ctrl.dip = NULL;
		ctrl.pci_dev = pci_dev;
		ctrl.op = PCIHP_ONLINE;

		ndi_devi_enter(self, &circular_count);
		ddi_walk_devs(ddi_get_child(self), pcihp_configure,
			(void *)&ctrl);
		ndi_devi_exit(self, circular_count);

		if (ctrl.rv != NDI_SUCCESS) {
			/*
			 * one or more of the devices are not
			 * onlined. How is this to be reported?
			 */
			cmn_err(CE_WARN,
				"pcihp (%s%d): failed to attach one or"
				" more drivers for the card in the slot %s",
				ddi_driver_name(self), ddi_get_instance(self),
				slotinfop->name);
			/* rv = EFAULT; */
		}
		/* tell HPC driver that the occupant is configured */
		(void) hpc_nexus_control(slotinfop->slot_hdl,
			HPC_CTRL_DEV_CONFIGURED, NULL);

		if (drv_getparm(TIME, (void *)&time) != DDI_SUCCESS)
			slotinfop->last_change = (time_t)-1;
		else
			slotinfop->last_change = (time32_t)time;


		return (rv);
	}

	/*
	 * Occupant is in the UNCONFIGURED state.
	 */

	/* Check if the receptacle is in the CONNECTED state. */
	if (hpc_nexus_control(slotinfop->slot_hdl,
			HPC_CTRL_GET_SLOT_STATE, (caddr_t)&rstate) != 0) {

		return (ENXIO);
	}

	if (rstate == HPC_SLOT_EMPTY) {
		/* error. slot is empty */

		return (ENXIO);
	}

	if (rstate != HPC_SLOT_CONNECTED) {
		/* error. either the slot is empty or connect failed */

		return (ENXIO);
	}

	slotinfop->rstate = AP_RSTATE_CONNECTED; /* record rstate */

	/* Turn INS and LED off, and start configuration. */
	if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
		pcihp_hs_csr_op(pcihp_p, pci_dev,
				HPC_EVENT_SLOT_CONFIGURE);
		if (pcihp_cpci_blue_led)
			pcihp_hs_csr_op(pcihp_p, pci_dev,
				HPC_EVENT_SLOT_BLUE_LED_OFF);
		slotinfop->slot_flags &= ~PCIHP_SLOT_ENUM_INS_PENDING;
	}

	(void) hpc_nexus_control(slotinfop->slot_hdl,
		HPC_CTRL_DEV_CONFIG_START, NULL);

	/*
	 * Call the configurator to configure the card.
	 */
	if (pcicfg_configure(self, pci_dev) != PCICFG_SUCCESS) {
		if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
			if (pcihp_cpci_blue_led)
				pcihp_hs_csr_op(pcihp_p, pci_dev,
					HPC_EVENT_SLOT_BLUE_LED_ON);
			pcihp_hs_csr_op(pcihp_p, pci_dev,
				HPC_EVENT_SLOT_UNCONFIGURE);
		}
		/* tell HPC driver occupant configure Error */
		(void) hpc_nexus_control(slotinfop->slot_hdl,
			HPC_CTRL_DEV_CONFIG_FAILURE, NULL);

		return (EIO);
	}

	/* record the occupant state as CONFIGURED */
	slotinfop->ostate = AP_OSTATE_CONFIGURED;
	slotinfop->condition = AP_COND_OK;

	/* now, online all the devices in the AP */
	ctrl.flags = PCIHP_CFG_CONTINUE;
	ctrl.rv = NDI_SUCCESS;
	ctrl.dip = NULL;
	ctrl.pci_dev = pci_dev;
	ctrl.op = PCIHP_ONLINE;

	ndi_devi_enter(self, &circular_count);
	ddi_walk_devs(ddi_get_child(self), pcihp_configure,
		(void *)&ctrl);
	ndi_devi_exit(self, circular_count);

	if (ctrl.rv != NDI_SUCCESS) {
		/*
		 * one or more of the devices are not
		 * ONLINE'd. How is this to be
		 * reported?
		 */
		cmn_err(CE_WARN,
			"pcihp (%s%d): failed to attach one or"
			" more drivers for the card in"
			" the slot %s",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip),
			slotinfop->name);
		/* rv = EFAULT; */
	}
	/* store HS_CSR location.  No events, jut a read operation. */
	if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI)
		pcihp_hs_csr_op(pcihp_p, pci_dev, -1);

	/* tell HPC driver that the occupant is configured */
	(void) hpc_nexus_control(slotinfop->slot_hdl,
		HPC_CTRL_DEV_CONFIGURED, NULL);


	return (rv);
}

/*
 * **************************************
 * UNCONFIGURE the occupant in the slot.
 * **************************************
 */
static int
pcihp_unconfigure_ap(pcihp_t *pcihp_p, int pci_dev)
{
	dev_info_t *self = pcihp_p->dip;
	int rv = HPC_SUCCESS;
	struct pcihp_slotinfo *slotinfop;
	struct pcihp_config_ctrl ctrl;
	int circular_count;
	time_t time;

	/*
	 * check for valid request:
	 *	1. It is a hotplug slot.
	 *	2. The occupant is in the CONFIGURED state.
	 */
	slotinfop = &pcihp_p->slotinfo[pci_dev];


	if ((pci_dev >= PCI_MAX_DEVS) || (slotinfop->slot_hdl == NULL) ||
			(slotinfop->slot_flags & PCIHP_SLOT_DISABLED)) {

		return (ENXIO);
	}
	/*
	 * The following may not need to be there, as we should
	 * support unconfiguring of boards and free resources
	 * even when the board is not hotswappable. But this is
	 * the only way, we may be able to tell the system
	 * administrator that it is not a hotswap board since
	 * disconnect operation is never called.
	 * This way we help the system administrator from not
	 * accidentally removing a non hotswap board and
	 * possibly destroying it. May be this behavior can
	 * be a default, and can be enabled or disabled via
	 * a global flag.
	 */
	if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
		if (slotinfop->slot_flags &
				PCIHP_SLOT_DEV_NON_HOTPLUG) {
			/* Operation unsupported if no HS board/slot */

			return (ENOTSUP);
		}
	}

	/*
	 * If the occupant is in the CONFIGURED state then
	 * call the configurator to unconfigure the slot.
	 */
	if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {

		/*
		 * since potential state change is imminent mask
		 * enum events to prevent the slot from being re-configured
		 */
		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_DISABLE_ENUM);

		/*
		 * Detach all the drivers for the devices in the
		 * slot. Call pcihp_configure() to do this.
		 */
		ctrl.flags = 0;
		ctrl.rv = NDI_SUCCESS;
		ctrl.dip = NULL;
		ctrl.pci_dev = pci_dev;
		ctrl.op = PCIHP_OFFLINE;

		(void) devfs_clean(self, NULL, DV_CLEAN_FORCE);
		ndi_devi_enter(self, &circular_count);
		ddi_walk_devs(ddi_get_child(self), pcihp_configure,
			(void *)&ctrl);
		ndi_devi_exit(self, circular_count);

		if (ctrl.rv != NDI_SUCCESS) {
			/*
			 * Failed to detach one or more drivers
			 * Restore the state of drivers which
			 * are offlined during this operation.
			 */
			ctrl.flags = 0;
			ctrl.rv = NDI_SUCCESS;
			ctrl.dip = NULL;
			ctrl.pci_dev = pci_dev;
			ctrl.op = PCIHP_ONLINE;

			ndi_devi_enter(self, &circular_count);
			ddi_walk_devs(ddi_get_child(self),
				pcihp_configure, (void *)&ctrl);
			ndi_devi_exit(self, circular_count);

			/* tell HPC driver that the occupant is Busy */
			(void) hpc_nexus_control(slotinfop->slot_hdl,
				HPC_CTRL_DEV_UNCONFIG_FAILURE, NULL);

			rv = EBUSY;
		} else {
			(void) hpc_nexus_control(slotinfop->slot_hdl,
				HPC_CTRL_DEV_UNCONFIG_START, NULL);

			if (pcicfg_unconfigure(self,
					pci_dev) == PCICFG_SUCCESS) {
			/*
			 * Now that resources are freed,
			 * clear EXT and Turn LED ON.
			 */
			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
				pcihp_hs_csr_op(pcihp_p, pci_dev,
					HPC_EVENT_SLOT_UNCONFIGURE);
				if (pcihp_cpci_blue_led)
					pcihp_hs_csr_op(pcihp_p, pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_ON);
				slotinfop->hs_csr_location = 0;
				slotinfop->slot_flags &=
					~(PCIHP_SLOT_DEV_NON_HOTPLUG|
						PCIHP_SLOT_ENUM_EXT_PENDING);
			}
				slotinfop->ostate =
						AP_OSTATE_UNCONFIGURED;
				slotinfop->condition = AP_COND_UNKNOWN;
				/*
				 * send the notification of state change
				 * to the HPC driver.
				 */
				(void) hpc_nexus_control(
					slotinfop->slot_hdl,
					HPC_CTRL_DEV_UNCONFIGURED,
					NULL);
			} else {
				/* tell HPC driver occupant unconfigure Error */
				(void) hpc_nexus_control(slotinfop->slot_hdl,
					HPC_CTRL_DEV_UNCONFIG_FAILURE, NULL);

				rv = EIO;
			}
		}
	}

	if (drv_getparm(TIME, (void *)&time) != DDI_SUCCESS)
		slotinfop->last_change = (time_t)-1;
	else
		slotinfop->last_change = (time32_t)time;


	/* unmask enum events again */
	if ((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) == 0) {
		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_ENABLE_ENUM);
	}

	return (rv);
}

/*
 * Accessor function to return pointer to the pci hotplug
 * cb_ops structure.
 */
struct cb_ops *
pcihp_get_cb_ops()
{
	return (&pcihp_cb_ops);
}

/*
 * Setup function to initialize hot plug feature. Returns DDI_SUCCESS
 * for successful initialization, otherwise it returns DDI_FAILURE.
 *
 * It is assumed that this this function is called from the attach()
 * entry point of the PCI nexus driver.
 */

int
pcihp_init(dev_info_t *dip)
{
	pcihp_t *pcihp_p;
	int i;
	caddr_t enum_data;
	int enum_size;
	int rv;

	mutex_enter(&pcihp_open_mutex);

	/*
	 * Make sure that it is not already initialized.
	 */
	if (pcihp_get_soft_state(dip, PCIHP_DR_NOOP, &rv) != NULL) {
		cmn_err(CE_WARN, "%s%d: pcihp instance already initialized!",
		    ddi_driver_name(dip), ddi_get_instance(dip));
		goto cleanup;
	}

	/*
	 * Initialize soft state structure for the bus instance.
	 */
	if ((pcihp_p = pcihp_create_soft_state(dip)) == NULL) {
		cmn_err(CE_WARN, "%s%d: can't allocate pcihp structure",
		    ddi_driver_name(dip), ddi_get_instance(dip));
		goto cleanup;
	}

	pcihp_p->soft_state = PCIHP_SOFT_STATE_CLOSED;
	/* XXX if bus is running at 66Mhz then set PCI_BUS_66MHZ bit */
	pcihp_p->bus_flags = 0;	/* XXX FIX IT */

	/*
	 * If a platform wishes to implement Radial ENUM# routing
	 * a property "enum-impl" must be presented to us with a
	 * string value "radial".
	 * This helps us not go for polling operation (default)
	 * during a ENUM# event.
	 */
	if (ddi_getlongprop(DDI_DEV_T_ANY, dip, 0, "enum-impl",
	    (caddr_t)&enum_data, &enum_size) == DDI_PROP_SUCCESS) {
		if (strcmp(enum_data, "radial") == 0) {
			pcihp_p->bus_flags |= PCIHP_BUS_ENUM_RADIAL;
		}
		kmem_free(enum_data, enum_size);
	}

	for (i = 0; i < PCI_MAX_DEVS; i++) {
		/* initialize slot mutex */
		mutex_init(&pcihp_p->slotinfo[i].slot_mutex, NULL,
						MUTEX_DRIVER, NULL);
	}

	/*
	 *  register the bus instance with the HPS framework.
	 */
	if (hpc_nexus_register_bus(dip, pcihp_new_slot_state, 0) != 0) {
		cmn_err(CE_WARN, "%s%d: failed to register the bus with HPS",
		    ddi_driver_name(dip), ddi_get_instance(dip));
		goto cleanup1;
	}

	/*
	 * Create the "devctl" minor for hot plug support. The minor
	 * number for "devctl" node is in the same format as the AP
	 * minor nodes.
	 */
	if (ddi_create_minor_node(dip, "devctl", S_IFCHR,
	    PCIHP_AP_MINOR_NUM(ddi_get_instance(dip), PCIHP_DEVCTL_MINOR),
	    DDI_NT_NEXUS, 0) != DDI_SUCCESS)
		goto cleanup2;

	/*
	 * Setup resource maps for this bus node. (Note: This can
	 * be done from the attach(9E) of the nexus itself.)
	 */
	(void) pci_resource_setup(dip);

	pcihp_p->bus_state = PCIHP_BUS_CONFIGURED;

	mutex_exit(&pcihp_open_mutex);

	return (DDI_SUCCESS);

cleanup2:
	(void) hpc_nexus_unregister_bus(dip);
cleanup1:
	for (i = 0; i < PCI_MAX_DEVS; i++)
		mutex_destroy(&pcihp_p->slotinfo[i].slot_mutex);
	pcihp_destroy_soft_state(dip);
cleanup:
	mutex_exit(&pcihp_open_mutex);
	return (DDI_FAILURE);
}

/*
 * pcihp_uninit()
 *
 * The bus instance is going away, cleanup any data associated with
 * the management of hot plug slots. It is assumed that this function
 * is called from detach() routine of the PCI nexus driver. Also,
 * it is assumed that no devices on the bus are in the configured state.
 */
int
pcihp_uninit(dev_info_t *dip)
{
	pcihp_t *pcihp_p;
	int i, j;
	int rv;

	mutex_enter(&pcihp_open_mutex);
	/* get a pointer to the soft state structure */
	pcihp_p = pcihp_get_soft_state(dip, PCIHP_DR_BUS_UNCONFIGURE, &rv);
	ASSERT(pcihp_p != NULL);

	/* slot mutexes should prevent any configure/unconfigure access */
	for (i = 0; i < PCI_MAX_DEVS; i++) {
		if (!mutex_tryenter(&pcihp_p->slotinfo[i].slot_mutex)) {
			for (j = 0; j < i; j++) {
				mutex_exit(&pcihp_p->slotinfo[j].slot_mutex);
			}
			mutex_exit(&pcihp_open_mutex);
			return (DDI_FAILURE);
		}
	}

	if ((pcihp_p->soft_state != PCIHP_SOFT_STATE_CLOSED) ||
	    (rv == PCIHP_FAILURE)) {
		cmn_err(CE_WARN, "%s%d: pcihp instance is busy",
		    ddi_driver_name(dip), ddi_get_instance(dip));
		for (i = 0; i < PCI_MAX_DEVS; i++) {
			mutex_exit(&pcihp_p->slotinfo[i].slot_mutex);
		}
		mutex_exit(&pcihp_open_mutex);
		return (DDI_FAILURE);
	}

	/*
	 * Unregister the bus with the HPS.
	 *
	 * (Note: It is assumed that the HPS framework uninstalls
	 *  event handlers for all the hot plug slots on this bus.)
	 */
	(void) hpc_nexus_unregister_bus(dip);

	/* Free up any kmem_alloc'd memory for slot info table. */
	for (i = 0; i < PCI_MAX_DEVS; i++) {
		/* free up slot name strings */
		if (pcihp_p->slotinfo[i].name != NULL)
			kmem_free(pcihp_p->slotinfo[i].name,
				strlen(pcihp_p->slotinfo[i].name) + 1);
	}

	/* destroy slot mutexes */
	for (i = 0; i < PCI_MAX_DEVS; i++)
		mutex_destroy(&pcihp_p->slotinfo[i].slot_mutex);

	ddi_remove_minor_node(dip, NULL);

	/* free up the soft state structure */
	pcihp_destroy_soft_state(dip);

	/*
	 * Destroy resource maps for this bus node. (Note: This can
	 * be done from the detach(9E) of the nexus itself.)
	 */
	(void) pci_resource_destroy(dip);

	mutex_exit(&pcihp_open_mutex);

	return (DDI_SUCCESS);
}

/*
 * pcihp_new_slot_state()
 *
 * This function is called by the HPS when it finds a hot plug
 * slot is added or being removed from the hot plug framework.
 * It returns 0 for success and HPC_ERR_FAILED for errors.
 */
static int
pcihp_new_slot_state(dev_info_t *dip, hpc_slot_t hdl,
	hpc_slot_info_t *slot_info, int slot_state)
{
	pcihp_t *pcihp_p;
	struct pcihp_slotinfo *slotinfop;
	int pci_dev;
	minor_t ap_minor;
	major_t ap_major;
	int rv = 0;
	time_t time;
	int auto_enable = 1;
	int rval;

	/* get a pointer to the soft state structure */
	pcihp_p = pcihp_get_soft_state(dip, PCIHP_DR_SLOT_ENTER, &rval);
	ASSERT(pcihp_p != NULL);

	if (rval == PCIHP_FAILURE) {
		PCIHP_DEBUG((CE_WARN, "pcihp instance is unconfigured"
		    " while slot activity is requested\n"));
		return (HPC_ERR_FAILED);
	}

	pci_dev = slot_info->pci_dev_num;
	slotinfop = &pcihp_p->slotinfo[pci_dev];

	mutex_enter(&slotinfop->slot_mutex);

	switch (slot_state) {

	case HPC_SLOT_ONLINE:

		/*
		 * Make sure the slot is not already ONLINE (paranoia?).
		 * (Note: Should this be simply an ASSERTION?)
		 */
		if (slotinfop->slot_hdl != NULL) {
		    PCIHP_DEBUG((CE_WARN,
			"pcihp (%s%d): pci slot (dev %x) already ONLINE!!",
			ddi_driver_name(dip), ddi_get_instance(dip), pci_dev));
			rv = HPC_ERR_FAILED;
			break;
		}

		/*
		 * Add the hot plug slot to the bus.
		 */

		/* create the AP minor node */
		ap_minor = PCIHP_AP_MINOR_NUM(ddi_get_instance(dip), pci_dev);
		if (ddi_create_minor_node(dip, slot_info->pci_slot_name,
			S_IFCHR, ap_minor,
			DDI_NT_PCI_ATTACHMENT_POINT, 0) == DDI_FAILURE) {
		    cmn_err(CE_WARN,
			"pcihp (%s%d): ddi_create_minor_node failed"
			" for pci dev %x", ddi_driver_name(dip),
			ddi_get_instance(dip), pci_dev);
		    rv = HPC_ERR_FAILED;
		    break;
		}

		/* save the slot handle */
		slotinfop->slot_hdl = hdl;

		/* setup event handler for all hardware events on the slot */
		ap_major = ddi_name_to_major(ddi_get_name(dip));
		if (hpc_install_event_handler(hdl, -1, pcihp_event_handler,
			(caddr_t)makedevice(ap_major, ap_minor)) != 0) {
		    cmn_err(CE_WARN,
			"pcihp (%s%d): install event handler failed"
			" for pci dev %x", ddi_driver_name(dip),
			ddi_get_instance(dip), pci_dev);
		    rv = HPC_ERR_FAILED;
		    break;
		}
		slotinfop->event_mask = (uint32_t)0xFFFFFFFF;

		pcihp_create_occupant_props(dip, makedevice(ap_major,
		    ap_minor), pci_dev);

		/* set default auto configuration enabled flag for this slot */
		slotinfop->slot_flags = pcihp_autocfg_enabled;

		/* copy the slot information */
		slotinfop->name =
		    kmem_alloc(strlen(slot_info->pci_slot_name) + 1, KM_SLEEP);
		(void) strcpy(slotinfop->name, slot_info->pci_slot_name);
		slotinfop->slot_type = slot_info->slot_type;
		slotinfop->hs_csr_location = 0;
		slotinfop->slot_capabilities = slot_info->pci_slot_capabilities;
		if (slot_info->slot_flags & HPC_SLOT_NO_AUTO_ENABLE)
			auto_enable = 0;

		if (slot_info->slot_flags & HPC_SLOT_CREATE_DEVLINK) {
			pci_devlink_flags |= (1 << pci_dev);
			(void) ddi_prop_update_int(DDI_DEV_T_NONE,
						dip,
						"ap-names",
						pci_devlink_flags);
		}

		PCIHP_DEBUG((CE_NOTE,
		    "pcihp (%s%d): pci slot (dev %x) ONLINE\n",
		    ddi_driver_name(dip), ddi_get_instance(dip), pci_dev));

		/*
		 * The slot may have an occupant that was configured
		 * at boot time. If we find a devinfo node in the tree
		 * for this slot (i.e pci device number) then we
		 * record the occupant state as CONFIGURED.
		 */
		if (pcihp_devi_find(dip, pci_dev, 0) != NULL) {
			/* we have a configured occupant */
			slotinfop->ostate = AP_OSTATE_CONFIGURED;
			slotinfop->rstate = AP_RSTATE_CONNECTED;
			slotinfop->condition = AP_COND_OK;

			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
				/* this will set slot flags too. */
				(void) pcihp_get_board_type(slotinfop);
				pcihp_hs_csr_op(pcihp_p, pci_dev,
					HPC_EVENT_SLOT_CONFIGURE);
				if (pcihp_cpci_blue_led)
					pcihp_hs_csr_op(pcihp_p, pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_OFF);
				/* ENUM# enabled by default for cPCI devices */
				slotinfop->slot_flags |= PCIHP_SLOT_AUTO_CFG_EN;
				slotinfop->slot_flags &=
					~PCIHP_SLOT_ENUM_INS_PENDING;
			}

			/* tell HPC driver that the occupant is configured */
			(void) hpc_nexus_control(slotinfop->slot_hdl,
				HPC_CTRL_DEV_CONFIGURED, NULL);
		} else {
			struct pcihp_config_ctrl ctrl;
			int circular_count;

			slotinfop->ostate = AP_OSTATE_UNCONFIGURED;
			slotinfop->rstate = AP_RSTATE_EMPTY;
			slotinfop->condition = AP_COND_UNKNOWN;

			if (!auto_enable) {	/* no further action */
				break;
			}

			/*
			 * We enable power to the slot and try to
			 * configure if there is any card present.
			 *
			 * Note: This case is possible if the BIOS or
			 * firmware doesn't enable the slots during
			 * soft reboot.
			 */
			if (hpc_nexus_connect(slotinfop->slot_hdl,
				NULL, 0) != HPC_SUCCESS)
				break;

			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
				pcihp_hs_csr_op(pcihp_p, pci_dev,
					HPC_EVENT_SLOT_CONFIGURE);
				if (pcihp_cpci_blue_led)
					pcihp_hs_csr_op(pcihp_p, pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_OFF);
				slotinfop->slot_flags |= PCIHP_SLOT_AUTO_CFG_EN;
				slotinfop->slot_flags &=
					~PCIHP_SLOT_ENUM_INS_PENDING;
			}

			(void) hpc_nexus_control(slotinfop->slot_hdl,
				HPC_CTRL_DEV_CONFIG_START, NULL);

			/*
			 * Call the configurator to configure the card.
			 */
			if (pcicfg_configure(dip, pci_dev) != PCICFG_SUCCESS) {
				if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
					if (pcihp_cpci_blue_led)
						pcihp_hs_csr_op(pcihp_p,
						pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_ON);
					pcihp_hs_csr_op(pcihp_p, pci_dev,
						HPC_EVENT_SLOT_UNCONFIGURE);
				}

				/* tell HPC driver occupant configure Error */
				(void) hpc_nexus_control(slotinfop->slot_hdl,
					HPC_CTRL_DEV_CONFIG_FAILURE, NULL);

				/*
				 * call HPC driver to turn off the power for
				 * the slot.
				 */
				(void) hpc_nexus_disconnect(slotinfop->slot_hdl,
							NULL, 0);
			} else {
			    /* record the occupant state as CONFIGURED */
			    slotinfop->ostate = AP_OSTATE_CONFIGURED;
			    slotinfop->rstate = AP_RSTATE_CONNECTED;
			    slotinfop->condition = AP_COND_OK;

			    /* now, online all the devices in the AP */
			    ctrl.flags = PCIHP_CFG_CONTINUE;
			    ctrl.rv = NDI_SUCCESS;
			    ctrl.dip = NULL;
			    ctrl.pci_dev = pci_dev;
			    ctrl.op = PCIHP_ONLINE;
				/*
				 * the following sets slot_flags and
				 * hs_csr_location too.
				 */
				(void) pcihp_get_board_type(slotinfop);

			    ndi_devi_enter(dip, &circular_count);
			    ddi_walk_devs(ddi_get_child(dip), pcihp_configure,
				(void *)&ctrl);
			    ndi_devi_exit(dip, circular_count);

			    if (ctrl.rv != NDI_SUCCESS) {
				/*
				 * one or more of the devices are not
				 * ONLINE'd. How is this to be
				 * reported?
				 */
				cmn_err(CE_WARN,
					"pcihp (%s%d): failed to attach one or"
					" more drivers for the card in"
					" the slot %s",
					ddi_driver_name(dip),
					ddi_get_instance(dip),
					slotinfop->name);
			    }

			    /* tell HPC driver about the configured occupant */
			    (void) hpc_nexus_control(slotinfop->slot_hdl,
				HPC_CTRL_DEV_CONFIGURED, NULL);
			}
		}

		break;

	case HPC_SLOT_OFFLINE:
		/*
		 * A hot plug slot is being removed from the bus.
		 * Make sure there is no occupant configured on the
		 * slot before removing the AP minor node.
		 */
		if (slotinfop->ostate != AP_OSTATE_UNCONFIGURED) {
		    cmn_err(CE_WARN, "pcihp (%s%d): Card is still in configured"
			" state for pci dev %x",
			ddi_driver_name(dip), ddi_get_instance(dip), pci_dev);
		    rv = HPC_ERR_FAILED;
		    break;
		}

		/*
		 * If the AP device is in open state then return
		 * error.
		 */
		if (pcihp_p->soft_state != PCIHP_SOFT_STATE_CLOSED) {
		    rv = HPC_ERR_FAILED;
		    break;
		}
		if (slot_info->slot_flags & HPC_SLOT_CREATE_DEVLINK) {
			pci_devlink_flags &= ~(1 << pci_dev);
			(void) ddi_prop_update_int(DDI_DEV_T_NONE,
					dip,
					"ap-names",
					pci_devlink_flags);
		}

		/* remove the minor node */
		ddi_remove_minor_node(dip, slotinfop->name);

		/* free up the memory for the name string */
		kmem_free(slotinfop->name, strlen(slotinfop->name) + 1);

		/* update the slot info data */
		slotinfop->name = NULL;
		slotinfop->slot_hdl = NULL;

		PCIHP_DEBUG((CE_NOTE,
		    "pcihp (%s%d): pci slot (dev %x) OFFLINE\n",
		    ddi_driver_name(dip), ddi_get_instance(dip),
		    slot_info->pci_dev_num));

		break;
	default:
		cmn_err(CE_WARN,
		    "pcihp_new_slot_state: unknown slot_state %d", slot_state);
		rv = HPC_ERR_FAILED;
	}

	if (rv == 0) {
		if (drv_getparm(TIME, (void *)&time) != DDI_SUCCESS)
			slotinfop->last_change = (time_t)-1;
		else
			slotinfop->last_change = (time32_t)time;
	}

	mutex_exit(&slotinfop->slot_mutex);

	(void) pcihp_get_soft_state(dip, PCIHP_DR_SLOT_EXIT, &rval);

	return (rv);
}

/*
 * Event handler. It is assumed that this function is called from
 * a kernel context only.
 *
 * Parameters:
 *	slot_arg	AP minor number.
 *	event_mask	Event that occurred.
 */

static int
pcihp_event_handler(caddr_t slot_arg, uint_t event_mask)
{
	dev_t ap_dev = (dev_t)slot_arg;
	dev_info_t *self;
	pcihp_t *pcihp_p;
	int pci_dev;
	int rv = HPC_EVENT_CLAIMED;
	struct pcihp_slotinfo *slotinfop;
	struct pcihp_config_ctrl ctrl;
	int circular_count;
	int rval;
	int hint;
	hpc_slot_state_t rstate;

	/*
	 * Get the soft state structure.
	 */
	if (pcihp_info(NULL, DDI_INFO_DEVT2DEVINFO, (void *)ap_dev,
	    (void **)&self) != DDI_SUCCESS)
		return (ENXIO);

	pcihp_p = pcihp_get_soft_state(self, PCIHP_DR_SLOT_ENTER, &rval);
	ASSERT(pcihp_p != NULL);

	if (rval == PCIHP_FAILURE) {
		PCIHP_DEBUG((CE_WARN, "pcihp instance is unconfigured"
		    " while slot activity is requested\n"));
		return (-1);
	}

	/* get the PCI device number for the slot */
	pci_dev = PCIHP_AP_MINOR_NUM_TO_PCI_DEVNUM(getminor(ap_dev));

	slotinfop = &pcihp_p->slotinfo[pci_dev];

	/*
	 * All the events that may be handled in interrupt context should be
	 * free of any mutex usage.
	 */
	switch (event_mask) {

	case HPC_EVENT_CLEAR_ENUM:
		/*
		 * Check and clear ENUM# interrupt status. This may be
		 * called by the Hotswap controller driver when it is
		 * operating in a full hotswap system where the
		 * platform may not have control on globally disabling ENUM#.
		 * In such cases, the intent is to clear interrupt and
		 * process the interrupt in non-interrupt context.
		 * This is the first part of the ENUM# event processing.
		 */
		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): ENUM# is generated"
		    " on the bus (for slot %s ?)",
		    ddi_driver_name(pcihp_p->dip),
		    ddi_get_instance(pcihp_p->dip), slotinfop->name));

		/* this is the only event coming through in interrupt context */
		rv = pcihp_handle_enum(pcihp_p, pci_dev, PCIHP_CLEAR_ENUM,
		    KM_NOSLEEP);

		(void) pcihp_get_soft_state(self, PCIHP_DR_SLOT_EXIT, &rval);

		return (rv);
	default:
		break;
	}

	mutex_enter(&slotinfop->slot_mutex);

	if (hpc_nexus_control(slotinfop->slot_hdl,
	    HPC_CTRL_GET_SLOT_STATE, (caddr_t)&rstate) != 0)
		rv = HPC_ERR_FAILED;

	slotinfop->rstate = (ap_rstate_t)rstate;

	switch (event_mask) {

	case HPC_EVENT_SLOT_INSERTION:
		/*
		 * A card is inserted in the slot. Just report this
		 * event and return.
		 */
		cmn_err(CE_NOTE, "pcihp (%s%d): card is inserted"
			" in the slot %s (pci dev %x)",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip),
			slotinfop->name, pci_dev);

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_SLOT_CONFIGURE:
		/*
		 * Configure the occupant that is just inserted in the slot.
		 * The receptacle may or may not be in the connected state. If
		 * the receptacle is not connected and the auto configuration
		 * is enabled on this slot then connect the slot. If auto
		 * configuration is enabled then configure the card.
		 */
		if ((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) == 0) {
			/*
			 * auto configuration is disabled. Tell someone
			 * like RCM about this hotplug event?
			 */
			cmn_err(CE_NOTE, "pcihp (%s%d): SLOT_CONFIGURE event"
				" occurred for pci dev %x (slot %s),"
				" Slot disabled for auto-configuration.",
				ddi_driver_name(pcihp_p->dip),
				ddi_get_instance(pcihp_p->dip), pci_dev,
				slotinfop->name);

			/* +++ HOOK for RCM to report this hotplug event? +++ */

			break;
		}

		if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {
			cmn_err(CE_WARN, "pcihp (%s%d): SLOT_CONFIGURE event"
				" re-occurred for pci dev %x (slot %s),",
				ddi_driver_name(pcihp_p->dip),
				ddi_get_instance(pcihp_p->dip), pci_dev,
				slotinfop->name);
			mutex_exit(&slotinfop->slot_mutex);

			(void) pcihp_get_soft_state(self, PCIHP_DR_SLOT_EXIT,
			    &rval);

			return (EAGAIN);
		}

		/*
		 * Auto configuration is enabled. First, make sure the
		 * receptacle is in the CONNECTED state.
		 */
		if ((rv = hpc_nexus_connect(slotinfop->slot_hdl,
		    NULL, 0)) == HPC_SUCCESS) {
		    slotinfop->rstate = AP_RSTATE_CONNECTED; /* record rstate */
		}

		/* Clear INS and Turn LED Off and start configuring. */
		if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
			pcihp_hs_csr_op(pcihp_p, pci_dev,
				HPC_EVENT_SLOT_CONFIGURE);
			if (pcihp_cpci_blue_led)
				pcihp_hs_csr_op(pcihp_p, pci_dev,
					HPC_EVENT_SLOT_BLUE_LED_OFF);
		}

		(void) hpc_nexus_control(slotinfop->slot_hdl,
			HPC_CTRL_DEV_CONFIG_START, NULL);

		/*
		 * Call the configurator to configure the card.
		 */
		if (pcicfg_configure(pcihp_p->dip, pci_dev) != PCICFG_SUCCESS) {
			if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
				if (pcihp_cpci_blue_led)
					pcihp_hs_csr_op(pcihp_p, pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_ON);
				pcihp_hs_csr_op(pcihp_p, pci_dev,
					HPC_EVENT_SLOT_UNCONFIGURE);
			}
			/* failed to configure the card */
			cmn_err(CE_WARN, "pcihp (%s%d): failed to configure"
				" the card in the slot %s",
				ddi_driver_name(pcihp_p->dip),
				ddi_get_instance(pcihp_p->dip),
				slotinfop->name);
			/* failed to configure; disconnect the slot */
			if (hpc_nexus_disconnect(slotinfop->slot_hdl,
			    NULL, 0) == HPC_SUCCESS) {
			    slotinfop->rstate = AP_RSTATE_DISCONNECTED;
			}

			/* tell HPC driver occupant configure Error */
			(void) hpc_nexus_control(slotinfop->slot_hdl,
				HPC_CTRL_DEV_CONFIG_FAILURE, NULL);
		} else {
			/* record the occupant state as CONFIGURED */
			slotinfop->ostate = AP_OSTATE_CONFIGURED;
			slotinfop->condition = AP_COND_OK;

			/* now, online all the devices in the AP */
			ctrl.flags = PCIHP_CFG_CONTINUE;
			ctrl.rv = NDI_SUCCESS;
			ctrl.dip = NULL;
			ctrl.pci_dev = pci_dev;
			ctrl.op = PCIHP_ONLINE;
				(void) pcihp_get_board_type(slotinfop);

			ndi_devi_enter(pcihp_p->dip, &circular_count);
			ddi_walk_devs(ddi_get_child(pcihp_p->dip),
				pcihp_configure, (void *)&ctrl);
			ndi_devi_exit(pcihp_p->dip, circular_count);

			if (ctrl.rv != NDI_SUCCESS) {
				/*
				 * one or more of the devices are not
				 * ONLINE'd. How is this to be
				 * reported?
				 */
				cmn_err(CE_WARN,
					"pcihp (%s%d): failed to attach one or"
					" more drivers for the card in"
					" the slot %s",
					ddi_driver_name(pcihp_p->dip),
					ddi_get_instance(pcihp_p->dip),
					slotinfop->name);
			}

			/* tell HPC driver that the occupant is configured */
			(void) hpc_nexus_control(slotinfop->slot_hdl,
				HPC_CTRL_DEV_CONFIGURED, NULL);

			cmn_err(CE_NOTE, "pcihp (%s%d): card is CONFIGURED"
				" in the slot %s (pci dev %x)",
				ddi_driver_name(pcihp_p->dip),
				ddi_get_instance(pcihp_p->dip),
				slotinfop->name, pci_dev);
		}

		break;

	case HPC_EVENT_SLOT_UNCONFIGURE:
		/*
		 * Unconfigure the occupant in this slot.
		 */
		if ((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) == 0) {
			/*
			 * auto configuration is disabled. Tell someone
			 * like RCM about this hotplug event?
			 */
			cmn_err(CE_NOTE, "pcihp (%s%d): SLOT_UNCONFIGURE event"
				" for pci dev %x (slot %s) ignored,"
				" Slot disabled for auto-configuration.",
				ddi_driver_name(pcihp_p->dip),
				ddi_get_instance(pcihp_p->dip), pci_dev,
				slotinfop->name);

			/* +++ HOOK for RCM to report this hotplug event? +++ */

			break;
		}

		if (slotinfop->ostate == AP_OSTATE_UNCONFIGURED) {
			cmn_err(CE_WARN, "pcihp (%s%d): SLOT_UNCONFIGURE "
				"event re-occurred for pci dev %x (slot %s),",
				ddi_driver_name(pcihp_p->dip),
				ddi_get_instance(pcihp_p->dip), pci_dev,
				slotinfop->name);
			mutex_exit(&slotinfop->slot_mutex);

			(void) pcihp_get_soft_state(self, PCIHP_DR_SLOT_EXIT,
			    &rval);

			return (EAGAIN);
		}
		/*
		 * If the occupant is in the CONFIGURED state then
		 * call the configurator to unconfigure the slot.
		 */
		if (slotinfop->ostate == AP_OSTATE_CONFIGURED) {
			/*
			 * Detach all the drivers for the devices in the
			 * slot. Call pcihp_configure() to offline the
			 * devices.
			 */
			ctrl.flags = 0;
			ctrl.rv = NDI_SUCCESS;
			ctrl.dip = NULL;
			ctrl.pci_dev = pci_dev;
			ctrl.op = PCIHP_OFFLINE;

			(void) devfs_clean(pcihp_p->dip, NULL, DV_CLEAN_FORCE);
			ndi_devi_enter(pcihp_p->dip, &circular_count);
			ddi_walk_devs(ddi_get_child(pcihp_p->dip),
				pcihp_configure, (void *)&ctrl);
			ndi_devi_exit(pcihp_p->dip, circular_count);

			if (ctrl.rv != NDI_SUCCESS) {
				/*
				 * Failed to detach one or more drivers.
				 * Restore the status for the drivers
				 * which are offlined during this step.
				 */
				ctrl.flags = PCIHP_CFG_CONTINUE;
				ctrl.rv = NDI_SUCCESS;
				ctrl.dip = NULL;
				ctrl.pci_dev = pci_dev;
				ctrl.op = PCIHP_ONLINE;

				ndi_devi_enter(pcihp_p->dip, &circular_count);
				ddi_walk_devs(ddi_get_child(pcihp_p->dip),
					pcihp_configure, (void *)&ctrl);
				ndi_devi_exit(pcihp_p->dip, circular_count);
				rv = HPC_ERR_FAILED;
			} else {
				(void) hpc_nexus_control(slotinfop->slot_hdl,
					HPC_CTRL_DEV_UNCONFIG_START, NULL);

				if (pcicfg_unconfigure(pcihp_p->dip,
						pci_dev) == PCICFG_SUCCESS) {

				/* Resources freed. Turn LED on. Clear EXT. */
				if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
					if (pcihp_cpci_blue_led)
						pcihp_hs_csr_op(pcihp_p,
						pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_ON);
					pcihp_hs_csr_op(pcihp_p, pci_dev,
						HPC_EVENT_SLOT_UNCONFIGURE);
					slotinfop->hs_csr_location = 0;
					slotinfop->slot_flags &=
						~PCIHP_SLOT_DEV_NON_HOTPLUG;
				}
					slotinfop->ostate =
						AP_OSTATE_UNCONFIGURED;
					slotinfop->condition = AP_COND_UNKNOWN;
					/*
					 * send the notification of state change
					 * to the HPC driver.
					 */
					(void) hpc_nexus_control(
						slotinfop->slot_hdl,
						HPC_CTRL_DEV_UNCONFIGURED,
						NULL);
					/* disconnect the slot */
					if (hpc_nexus_disconnect(
						slotinfop->slot_hdl,
						NULL, 0) == HPC_SUCCESS) {
							slotinfop->rstate =
							AP_RSTATE_DISCONNECTED;
					}

					cmn_err(CE_NOTE,
					"pcihp (%s%d): card is UNCONFIGURED"
						" in the slot %s (pci dev %x)",
						ddi_driver_name(pcihp_p->dip),
						ddi_get_instance(pcihp_p->dip),
						slotinfop->name, pci_dev);
				} else {
					/* tell HPC driver occupant is Busy */
					(void) hpc_nexus_control(
						slotinfop->slot_hdl,
						HPC_CTRL_DEV_UNCONFIG_FAILURE,
						NULL);

					rv = HPC_ERR_FAILED;
				}
			}
		}

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_SLOT_REMOVAL:
		/*
		 * Card is removed from the slot. The card must have been
		 * unconfigured before this event.
		 */
		if (slotinfop->ostate != AP_OSTATE_UNCONFIGURED) {
			slotinfop->condition = AP_COND_FAILED;
			cmn_err(CE_WARN, "pcihp (%s%d): card is removed"
			    " from the slot %s",
			    ddi_driver_name(pcihp_p->dip),
			    ddi_get_instance(pcihp_p->dip),
			    slotinfop->name);
		}
		else
			cmn_err(CE_NOTE, "pcihp (%s%d): card is removed"
			    " from the slot %s",
			    ddi_driver_name(pcihp_p->dip),
			    ddi_get_instance(pcihp_p->dip),
			    slotinfop->name);

		slotinfop->rstate = AP_RSTATE_EMPTY;

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_SLOT_POWER_ON:
		/*
		 * Slot is connected to the bus. i.e the card is powered
		 * on. Are there any error conditions to be checked?
		 */
		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): card is powered"
			" on in the slot %s",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip),
			slotinfop->name));

		slotinfop->rstate = AP_RSTATE_CONNECTED; /* record rstate */

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_SLOT_POWER_OFF:
		/*
		 * Slot is disconnected from the bus. i.e the card is powered
		 * off. Are there any error conditions to be checked?
		 */
		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): card is powered"
			" off in the slot %s",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip),
			slotinfop->name));

		slotinfop->rstate = AP_RSTATE_DISCONNECTED; /* record rstate */

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_SLOT_LATCH_SHUT:
		/*
		 * Latch on the slot is closed.
		 */
		cmn_err(CE_NOTE, "pcihp (%s%d): latch is shut"
			" for the slot %s",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip),
			slotinfop->name);

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_SLOT_LATCH_OPEN:
		/*
		 * Latch on the slot is open.
		 */
		cmn_err(CE_NOTE, "pcihp (%s%d): latch is open"
			" for the slot %s",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip),
			slotinfop->name);

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_PROCESS_ENUM:
		/*
		 * HSC knows the device number of the slot where the
		 * ENUM# was triggered.
		 * Now finish the necessary actions to be taken on that
		 * slot. Please note that the interrupt is already cleared.
		 * This is the second(last) part of the ENUM# event processing.
		 */
		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): processing ENUM#"
			" for slot %s",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip),
			slotinfop->name));

		mutex_exit(&slotinfop->slot_mutex);
		rv = pcihp_enum_slot(pcihp_p, slotinfop, pci_dev,
			PCIHP_HANDLE_ENUM, KM_SLEEP);
		mutex_enter(&slotinfop->slot_mutex);

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_BUS_ENUM:
		/*
		 * Same as HPC_EVENT_SLOT_ENUM as defined the PSARC doc.
		 * This term is used for better clarity of its usage.
		 *
		 * ENUM signal occurred on the bus. It may be from this
		 * slot or any other hotplug slot on the bus.
		 *
		 * It is NOT recommended that the hotswap controller uses
		 * event without queuing as NDI and other DDI calls may not
		 * necessarily be invokable in interrupt context.
		 * Hence the hotswap controller driver should use the
		 * CLEAR_ENUM event which returns the slot device number
		 * and then call HPC_EVENT_PROCESS_ENUM event with queuing.
		 *
		 * This can be used when the hotswap controller is
		 * implementing a polled event mechanism to do the
		 * necessary actions in a single call.
		 */
		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): ENUM# is generated"
		    " on the bus (for slot %s ?)",
		    ddi_driver_name(pcihp_p->dip),
		    ddi_get_instance(pcihp_p->dip),
		    slotinfop->name));

		mutex_exit(&slotinfop->slot_mutex);
		rv = pcihp_handle_enum(pcihp_p, pci_dev, PCIHP_HANDLE_ENUM,
			KM_SLEEP);
		mutex_enter(&slotinfop->slot_mutex);

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_SLOT_BLUE_LED_ON:

		/*
		 * Request to turn Hot Swap Blue LED on.
		 */
		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): Request To Turn On Blue "
		    "LED on the bus (for slot %s ?)",
		    ddi_driver_name(pcihp_p->dip),
		    ddi_get_instance(pcihp_p->dip),
		    slotinfop->name));

		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_SLOT_BLUE_LED_ON);
		break;

	case HPC_EVENT_DISABLE_ENUM:
		/*
		 * Disable ENUM# which disables auto configuration on this slot
		 */
		if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
			pcihp_hs_csr_op(pcihp_p, pci_dev,
				HPC_EVENT_DISABLE_ENUM);
			slotinfop->slot_flags &= ~PCIHP_SLOT_AUTO_CFG_EN;
		}
		break;

	case HPC_EVENT_ENABLE_ENUM:
		/*
		 * Enable ENUM# which enables auto configuration on this slot.
		 */
		if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
			pcihp_hs_csr_op(pcihp_p, pci_dev,
				HPC_EVENT_ENABLE_ENUM);
			slotinfop->slot_flags |= PCIHP_SLOT_AUTO_CFG_EN;
		}
		break;

	case HPC_EVENT_SLOT_BLUE_LED_OFF:

		/*
		 * Request to turn Hot Swap Blue LED off.
		 */
		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): Request To Turn Off Blue "
		    "LED on the bus (for slot %s ?)",
		    ddi_driver_name(pcihp_p->dip),
		    ddi_get_instance(pcihp_p->dip),
		    slotinfop->name));

		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_SLOT_BLUE_LED_OFF);

		break;

	case HPC_EVENT_SLOT_NOT_HEALTHY:
		/*
		 * HEALTHY# signal on this slot is not OK.
		 */
		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): HEALTHY# signal is not OK"
			" for this slot %s",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip),
			slotinfop->name));

		/* record the state in slot_flags field */
		slotinfop->slot_flags |= PCIHP_SLOT_NOT_HEALTHY;
		slotinfop->condition = AP_COND_FAILED;

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_SLOT_HEALTHY_OK:
		/*
		 * HEALTHY# signal on this slot is OK now.
		 */
		PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): HEALTHY# signal is OK now"
			" for this slot %s",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip),
			slotinfop->name));

		/* update the state in slot_flags field */
		slotinfop->slot_flags &= ~PCIHP_SLOT_NOT_HEALTHY;
		slotinfop->condition = AP_COND_OK;

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;

	case HPC_EVENT_SLOT_ATTN:
		/*
		 * Attention button is pressed.
		 */
		if (((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) == 0) ||
		    (slotinfop->slot_flags & PCIHP_SLOT_DISABLED)) {
			/*
			 * either auto-conifiguration or the slot is disabled,
			 * ignore this event.
			 */
			break;
		}

		if (slotinfop->ostate == AP_OSTATE_UNCONFIGURED)
			hint = SE_INCOMING_RES;
		else
			hint = SE_OUTGOING_RES;

		if (ddi_getprop(DDI_DEV_T_ANY, pcihp_p->dip, DDI_PROP_DONTPASS,
		    "inkernel-autoconfig", 0) == 0) {
			pcihp_gen_sysevent(slotinfop->name, PCIHP_DR_REQ, hint,
			    pcihp_p->dip, KM_SLEEP);
			break;
		}

		if ((slotinfop->ostate == AP_OSTATE_UNCONFIGURED) &&
		    (slotinfop->rstate != AP_RSTATE_EMPTY) &&
		    (slotinfop->condition != AP_COND_FAILED)) {
			if (slotinfop->rstate == AP_RSTATE_DISCONNECTED) {
				rv = hpc_nexus_connect(slotinfop->slot_hdl,
				    NULL, 0);
				if (rv == HPC_SUCCESS)
					slotinfop->rstate = AP_RSTATE_CONNECTED;
				else
					break;
			}

			rv = pcihp_configure_ap(pcihp_p, pci_dev);

		} else if ((slotinfop->ostate == AP_OSTATE_CONFIGURED) &&
		    (slotinfop->rstate == AP_RSTATE_CONNECTED) &&
		    (slotinfop->condition != AP_COND_FAILED)) {
			rv = pcihp_unconfigure_ap(pcihp_p, pci_dev);

			if (rv != HPC_SUCCESS)
				break;

			rv = hpc_nexus_disconnect(slotinfop->slot_hdl,
			    NULL, 0);
			if (rv == HPC_SUCCESS)
				slotinfop->rstate = AP_RSTATE_DISCONNECTED;
		}

		break;

	case HPC_EVENT_SLOT_POWER_FAULT:
		/*
		 * Power fault is detected.
		 */
		cmn_err(CE_NOTE, "pcihp (%s%d): power-fault"
		    " for this slot %s",
		    ddi_driver_name(pcihp_p->dip),
		    ddi_get_instance(pcihp_p->dip),
		    slotinfop->name);

		slotinfop->condition = AP_COND_FAILED;

		pcihp_gen_sysevent(slotinfop->name, PCIHP_DR_AP_STATE_CHANGE,
		    SE_NO_HINT, pcihp_p->dip, KM_SLEEP);

		break;

	default:
		cmn_err(CE_NOTE, "pcihp (%s%d): unknown event %x"
			" for this slot %s",
			ddi_driver_name(pcihp_p->dip),
			ddi_get_instance(pcihp_p->dip), event_mask,
			slotinfop->name);

		/* +++ HOOK for RCM to report this hotplug event? +++ */

		break;
	}

	mutex_exit(&slotinfop->slot_mutex);

	(void) pcihp_get_soft_state(self, PCIHP_DR_SLOT_EXIT, &rval);

	return (rv);
}

/*
 * This function is called to online or offline the devices for an
 * attachment point. If the PCI device number of the node matches
 * with the device number of the specified hot plug slot then
 * the operation is performed.
 */
static int
pcihp_configure(dev_info_t *dip, void *hdl)
{
	int pci_dev;
	struct pcihp_config_ctrl *ctrl = (struct pcihp_config_ctrl *)hdl;
	int rv;
	pci_regspec_t *pci_rp;
	int length;

	/*
	 * Get the PCI device number information from the devinfo
	 * node. Since the node may not have the address field
	 * setup (this is done in the DDI_INITCHILD of the parent)
	 * we look up the 'reg' property to decode that information.
	 */
	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
		DDI_PROP_DONTPASS, "reg", (int **)&pci_rp,
		(uint_t *)&length) != DDI_PROP_SUCCESS) {
		ctrl->rv = DDI_FAILURE;
		ctrl->dip = dip;
		return (DDI_WALK_TERMINATE);
	}

	/* get the pci device id information */
	pci_dev = PCI_REG_DEV_G(pci_rp->pci_phys_hi);

	/*
	 * free the memory allocated by ddi_prop_lookup_int_array
	 */
	ddi_prop_free(pci_rp);

	/*
	 * Match the node for the device number of the slot.
	 */
	if (pci_dev == ctrl->pci_dev) {	/* node is a match */
		if (ctrl->op == PCIHP_ONLINE) {
			/* it is CONFIGURE operation */
			rv = ndi_devi_online(dip, NDI_ONLINE_ATTACH|NDI_CONFIG);
		} else {
			/*
			 * it is UNCONFIGURE operation.
			 */
			rv = ndi_devi_offline(dip, NDI_UNCONFIG);
		}
		if (rv != NDI_SUCCESS) {
			/* failed to attach/detach the driver(s) */
			ctrl->rv = rv;
			ctrl->dip = dip;
			/* terminate the search if specified */
			if (!(ctrl->flags & PCIHP_CFG_CONTINUE))
				return (DDI_WALK_TERMINATE);
		}
	}

	/*
	 * continue the walk to the next sibling to look for a match
	 * or to find other nodes if this card is a multi-function card.
	 */
	return (DDI_WALK_PRUNECHILD);
}

/* control structure used to find a device in the devinfo tree */
struct pcihp_find_ctrl {
	uint_t		device;
	uint_t		function;
	dev_info_t	*dip;
};

static dev_info_t *
pcihp_devi_find(dev_info_t *dip, uint_t device, uint_t function)
{
	struct pcihp_find_ctrl ctrl;
	int circular_count;

	ctrl.device = device;
	ctrl.function = function;
	ctrl.dip = NULL;

	ndi_devi_enter(dip, &circular_count);
	ddi_walk_devs(ddi_get_child(dip), pcihp_match_dev, (void *)&ctrl);
	ndi_devi_exit(dip, circular_count);

	return (ctrl.dip);
}

static int
pcihp_match_dev(dev_info_t *dip, void *hdl)
{
	struct pcihp_find_ctrl *ctrl = (struct pcihp_find_ctrl *)hdl;
	pci_regspec_t *pci_rp;
	int length;
	int pci_dev;
	int pci_func;

	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
		DDI_PROP_DONTPASS, "reg", (int **)&pci_rp,
		(uint_t *)&length) != DDI_PROP_SUCCESS) {
		ctrl->dip = NULL;
		return (DDI_WALK_TERMINATE);
	}

	/* get the PCI device address info */
	pci_dev = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
	pci_func = PCI_REG_FUNC_G(pci_rp->pci_phys_hi);

	/*
	 * free the memory allocated by ddi_prop_lookup_int_array
	 */
	ddi_prop_free(pci_rp);


	if ((pci_dev == ctrl->device) && (pci_func == ctrl->function)) {
		/* found the match for the specified device address */
		ctrl->dip = dip;
		return (DDI_WALK_TERMINATE);
	}

	/*
	 * continue the walk to the next sibling to look for a match.
	 */
	return (DDI_WALK_PRUNECHILD);
}

#if 0
/*
 * Probe the configuration space of the slot to determine the receptacle
 * state. There may not be any devinfo tree created for this slot.
 */
static void
pcihp_probe_slot_state(dev_info_t *dip, int dev, hpc_slot_state_t *rstatep)
{
	/* XXX FIX IT */
}
#endif

/*
 * This routine is called when a ENUM# assertion is detected for a bus.
 * Since ENUM# may be bussed, the slot that asserted ENUM# may not be known.
 * The HPC Driver passes the handle of a slot that is its best guess.
 * If the best guess slot is the one that asserted ENUM#, the proper handling
 * will be done.  If its not, all possible slots will be locked at until
 * one that is asserting ENUM is found.
 * Also, indicate to the HSC to turn on ENUM# after it is serviced,
 * incase if it was disabled by the HSC due to the nature of asynchronous
 * delivery of interrupt by the framework.
 *
 * opcode has the following meanings.
 * PCIHP_CLEAR_ENUM = just clear interrupt and return the PCI device no. if
 *			success, else return -1.
 * PCIHP_HANDLE_ENUM = clear interrupt and handle interrupt also.
 *
 */
static int
pcihp_handle_enum(pcihp_t *pcihp_p, int favorite_pci_dev, int opcode,
	int kmflag)
{
	struct pcihp_slotinfo *slotinfop;
	int pci_dev, rc, event_serviced = 0;

	/*
	 * Handle ENUM# condition for the "favorite" slot first.
	 */
	slotinfop = &pcihp_p->slotinfo[favorite_pci_dev];
	if (slotinfop) {
		/*
		 * First try the "favorite" pci device.  This is the device
		 * associated with the handle passed by the HPC Driver.
		 */
		rc = pcihp_enum_slot(pcihp_p, slotinfop, favorite_pci_dev,
			opcode, kmflag);
		if (rc != HPC_EVENT_UNCLAIMED) {	/* indicates success */
			event_serviced = 1;
			/* This MUST be a non-DEBUG feature. */
			if (! pcihp_enum_scan_all) {
				return (rc);
			}
		}
	}

	/*
	 * If ENUM# is implemented as a radial signal, then there is no
	 * need to further poll the slots.
	 */
	if (pcihp_p->bus_flags & PCIHP_BUS_ENUM_RADIAL)
		goto enum_service_check;

	/*
	 * If the "favorite" pci device didn't assert ENUM#, then
	 * try the rest.  Once we find and handle a device that asserted
	 * ENUM#, then we will terminate the walk by returning unless
	 * scan-all flag is set.
	 */
	for (pci_dev = 0; pci_dev < PCI_MAX_DEVS; pci_dev++) {
		if (pci_dev != favorite_pci_dev) {
			slotinfop = &pcihp_p->slotinfo[pci_dev];
			if (slotinfop == NULL) {
				continue;
			}
			/* Only CPCI devices support ENUM# generation. */
			if (!(slotinfop->slot_type & HPC_SLOT_TYPE_CPCI))
				continue;
			rc = pcihp_enum_slot(pcihp_p, slotinfop, pci_dev,
				opcode, kmflag);
			if (rc != HPC_EVENT_UNCLAIMED) {
				event_serviced = 1;
				/* This MUST be a non-DEBUG feature. */
				if (! pcihp_enum_scan_all)
					break;
			}
		}
	}

enum_service_check:
	if (event_serviced) {
		return (rc);
	}

	/* No ENUM# event found, Return */
	return (HPC_EVENT_UNCLAIMED);
}

/*
 * This routine attempts to handle a possible ENUM# assertion case for a
 * specified slot.  This only works for adapters that implement Hot Swap
 * Friendly Silicon.  If the slot's HS_CSR is read and it specifies ENUM#
 * has been asserted, either the insertion or removal handlers will be
 * called.
 */
static int
pcihp_enum_slot(pcihp_t *pcihp_p, struct pcihp_slotinfo *slotinfop, int pci_dev,
		int opcode, int kmflag)
{
	ddi_acc_handle_t handle;
	dev_info_t *dip, *new_child = NULL;
	int result, rv = -1;
	uint8_t hs_csr;

	if (pcihp_config_setup(&dip, &handle, &new_child, pci_dev,
				pcihp_p) != DDI_SUCCESS) {
		return (HPC_EVENT_UNCLAIMED);
	}

	/*
	 * Read the device's HS_CSR.
	 */
	result = pcihp_get_hs_csr(slotinfop, handle, (uint8_t *)&hs_csr);
	PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): hs_csr = %x, flags = %x",
		ddi_driver_name(pcihp_p->dip), ddi_get_instance(pcihp_p->dip),
		hs_csr, slotinfop->slot_flags));
	/*
	 * we teardown our device map here, because in case of an
	 * extraction event, our nodes would be freed and a teardown
	 * will cause problems.
	 */
	pcihp_config_teardown(&handle, &new_child, pci_dev, pcihp_p);

	if (result == PCIHP_SUCCESS) {

		/* If ENUM# is masked, then it is not us. Some other device */
		if ((hs_csr & HS_CSR_EIM) && (opcode == PCIHP_CLEAR_ENUM))
			return (HPC_EVENT_UNCLAIMED);
		/*
		 * This device supports Full Hot Swap and implements
		 * the Hot Swap Control and Status Register.
		 */
		if ((hs_csr & HS_CSR_INS) ||
			(slotinfop->slot_flags & PCIHP_SLOT_ENUM_INS_PENDING)) {
			/* handle insertion ENUM */
			PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): "
			    "Handle Insertion ENUM (INS) "
			    "on the bus (for slot %s ?)",
			    ddi_driver_name(pcihp_p->dip),
			    ddi_get_instance(pcihp_p->dip),
			    slotinfop->name));

			/*
			 * generate sysevent
			 */

			if (opcode == PCIHP_CLEAR_ENUM)
				pcihp_gen_sysevent(slotinfop->name,
					PCIHP_DR_REQ,
					SE_INCOMING_RES, pcihp_p->dip,
					kmflag);

			rv = pcihp_handle_enum_insertion(pcihp_p, pci_dev,
				opcode, kmflag);

		} else if ((hs_csr & HS_CSR_EXT) || (slotinfop->slot_flags &
					PCIHP_SLOT_ENUM_EXT_PENDING)) {
			/* handle extraction ENUM */
			PCIHP_DEBUG((CE_NOTE, "pcihp (%s%d): "
			    "Handle Extraction ENUM (EXT) "
			    "on the bus (for slot %s ?)",
			    ddi_driver_name(pcihp_p->dip),
			    ddi_get_instance(pcihp_p->dip),
			    slotinfop->name));

			/*
			 * generate sysevent
			 */

			if (opcode == PCIHP_CLEAR_ENUM)
				pcihp_gen_sysevent(slotinfop->name,
					PCIHP_DR_REQ,
					SE_OUTGOING_RES,
					pcihp_p->dip,
					kmflag);

			rv = pcihp_handle_enum_extraction(pcihp_p, pci_dev,
				opcode, kmflag);
		}
		if (opcode == PCIHP_CLEAR_ENUM) {
			if (rv == PCIHP_SUCCESS)
				rv = pci_dev;
			else
				rv = HPC_EVENT_UNCLAIMED;
		}
	}

	return (rv);
}

/*
 * This routine is called when a ENUM# caused by lifting the lever
 * is detected.  If the occupant is configured, it will be unconfigured.
 * If the occupant is already unconfigured or is successfully unconfigured,
 * the blue LED on the adapter is illuminated which means its OK to remove.
 * Please note that the lock must be released before invoking the
 * generic AP unconfigure function.
 */
static int
pcihp_handle_enum_extraction(pcihp_t *pcihp_p, int pci_dev, int opcode,
	int kmflag)
{
	struct pcihp_slotinfo *slotinfop;
	int rv = PCIHP_FAILURE;

	slotinfop = &pcihp_p->slotinfo[pci_dev];

	/*
	 * It was observed that, clearing the EXT bit turned the LED ON.
	 * This is a BIG problem in case if the unconfigure operation
	 * failed because the board was busy.
	 * In order to avoid this confusing situation (LED ON but the board
	 * is not unconfigured), we instead decided not to clear EXT but
	 * disable further ENUM# from this slot. Disabling ENUM# clears
	 * the interrupt.
	 * Finally before returning we clear the interrupt and enable
	 * ENUM# back again from this slot.
	 */
	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_DISABLE_ENUM);
	if (opcode == PCIHP_CLEAR_ENUM) {
		slotinfop->slot_flags |= PCIHP_SLOT_ENUM_EXT_PENDING;
		return (PCIHP_SUCCESS);
	}

	mutex_enter(&slotinfop->slot_mutex);
	rv = pcihp_unconfigure_ap(pcihp_p, pci_dev);
	mutex_exit(&slotinfop->slot_mutex);
	if (rv != HPC_SUCCESS && rv != EBUSY) {
		cmn_err(CE_NOTE, "%s%d: PCI device %x Failed on Unconfigure",
		    ddi_driver_name(pcihp_p->dip),
		    ddi_get_instance(pcihp_p->dip), pci_dev);
	}
	if (rv == EBUSY)
		cmn_err(CE_NOTE, "%s%d: PCI device %x Busy",
		    ddi_driver_name(pcihp_p->dip),
		    ddi_get_instance(pcihp_p->dip), pci_dev);
	if (rv) {
		if (pcihp_cpci_blue_led)
			pcihp_hs_csr_op(pcihp_p, pci_dev,
					HPC_EVENT_SLOT_BLUE_LED_OFF);
	}
	/*
	 * we must clear interrupt in case the unconfigure didn't do it
	 * due to a duplicate interrupt. Extraction is success.
	 */
	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_SLOT_UNCONFIGURE);

	if (!rv) {
		/*
		 * Sys Event Notification.
		 */
		pcihp_gen_sysevent(slotinfop->name, PCIHP_DR_AP_STATE_CHANGE,
			SE_HINT_REMOVE, pcihp_p->dip, kmflag);
	}

	/*
	 * Enable interrupts back from this board.
	 * This could potentially be problematic in case if the user is
	 * quick enough to extract the board.
	 * But we must do it just in case if the switch is closed again.
	 */
	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_ENABLE_ENUM);
	slotinfop->slot_flags &= ~PCIHP_SLOT_ENUM_EXT_PENDING;
	return (rv);
}

/*
 * This routine is called when a ENUM# caused by when an adapter insertion
 * is detected.  If the occupant is successfully configured (i.e. PCI resources
 * successfully assigned, the blue LED is left off, otherwise if configuration
 * is not successful, the blue LED is illuminated.
 * Please note that the lock must be released before invoking the
 * generic AP configure function.
 */
static int
pcihp_handle_enum_insertion(pcihp_t *pcihp_p, int pci_dev, int opcode,
	int kmflag)
{
	struct pcihp_slotinfo *slotinfop;
	int rv = PCIHP_FAILURE;
	minor_t ap_minor;
	major_t ap_major;

	slotinfop = &pcihp_p->slotinfo[pci_dev];
	slotinfop->hs_csr_location = 0;
	/* we clear the interrupt here. This is a must here. */
	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_SLOT_CONFIGURE);
	/*
	 * disable further interrupt from this board till it is
	 * configured.
	 */
	pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_DISABLE_ENUM);
	if (opcode == PCIHP_CLEAR_ENUM) {
		slotinfop->slot_flags |= PCIHP_SLOT_ENUM_INS_PENDING;
		return (PCIHP_SUCCESS);
	}

	if ((slotinfop->slot_flags & PCIHP_SLOT_AUTO_CFG_EN) ==
					PCIHP_SLOT_AUTO_CFG_EN) {
		mutex_enter(&slotinfop->slot_mutex);
		rv = pcihp_configure_ap(pcihp_p, pci_dev);
		mutex_exit(&slotinfop->slot_mutex);
		if (rv != HPC_SUCCESS) {	/* configure failed */
			cmn_err(CE_NOTE, "%s%d: PCI device %x Failed on"
				" Configure", ddi_driver_name(pcihp_p->dip),
				ddi_get_instance(pcihp_p->dip), pci_dev);
			if (pcihp_cpci_blue_led)
				pcihp_hs_csr_op(pcihp_p, pci_dev,
						HPC_EVENT_SLOT_BLUE_LED_ON);
		}

		/* pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_CLEAR_ENUM); */
		pcihp_hs_csr_op(pcihp_p, pci_dev, HPC_EVENT_ENABLE_ENUM);

		if (!rv) {
			ap_major = ddi_driver_major(pcihp_p->dip);
			ap_minor = PCIHP_AP_MINOR_NUM(
			    ddi_get_instance(pcihp_p->dip), pci_dev);
			pcihp_create_occupant_props(pcihp_p->dip,
			    makedevice(ap_major, ap_minor), pci_dev);

			/*
			 * Sys Event Notification.
			 */
			pcihp_gen_sysevent(slotinfop->name,
				PCIHP_DR_AP_STATE_CHANGE,
				SE_HINT_INSERT, pcihp_p->dip, kmflag);
		}

	} else
		rv = PCIHP_SUCCESS;
	slotinfop->slot_flags &= ~PCIHP_SLOT_ENUM_INS_PENDING;
	return (rv);
}

/*
 * Read the Hot Swap Control and Status Register (HS_CSR) and
 * place the result in the location pointed to be hs_csr.
 */
static int
pcihp_get_hs_csr(struct pcihp_slotinfo *slotinfop,
    ddi_acc_handle_t config_handle, uint8_t *hs_csr)
{
	if (slotinfop->hs_csr_location == -1)
		return (PCIHP_FAILURE);

	if (slotinfop->hs_csr_location == 0) {
		slotinfop->hs_csr_location =
			pcihp_get_hs_csr_location(config_handle);

		if (slotinfop->hs_csr_location == -1)
			return (PCIHP_FAILURE);
	}
	*hs_csr = pci_config_get8(config_handle, slotinfop->hs_csr_location);
	return (PCIHP_SUCCESS);
}

/*
 * Write the Hot Swap Control and Status Register (HS_CSR) with
 * the value being pointed at by hs_csr.
 */
static void
pcihp_set_hs_csr(struct pcihp_slotinfo *slotinfop,
    ddi_acc_handle_t config_handle, uint8_t *hs_csr)
{
	if (slotinfop->hs_csr_location == -1)
		return;
	if (slotinfop->hs_csr_location == 0) {
		slotinfop->hs_csr_location =
			pcihp_get_hs_csr_location(config_handle);
		if (slotinfop->hs_csr_location == -1)
			return;
	}
	pci_config_put8(config_handle, slotinfop->hs_csr_location, *hs_csr);
	PCIHP_DEBUG((CE_NOTE, "hs_csr wrote %x, read %x", *hs_csr,
		pci_config_get8(config_handle, slotinfop->hs_csr_location)));
}

static int
pcihp_get_hs_csr_location(ddi_acc_handle_t config_handle)
{
	uint8_t	cap_id;
	uint_t	cap_id_loc;
	uint16_t	status;
	int location = -1;
#define	PCI_STAT_ECP_SUPP	0x10

	/*
	 * Need to check the Status register for ECP support first.
	 * Also please note that for type 1 devices, the
	 * offset could change. Should support type 1 next.
	 */
	status = pci_config_get16(config_handle, PCI_CONF_STAT);
	if (!(status & PCI_STAT_ECP_SUPP)) {
		PCIHP_DEBUG((CE_NOTE, "No Ext Capabilities for device\n"));
		return (-1);
	}
	cap_id_loc = pci_config_get8(config_handle, PCI_CONF_EXTCAP);

	/*
	 * Walk the list of capabilities, but don't walk past the end
	 * of the Configuration Space Header.
	 */
	while ((cap_id_loc) && (cap_id_loc < PCI_CONF_HDR_SIZE)) {

		cap_id = pci_config_get8(config_handle, cap_id_loc);

		if (cap_id == CPCI_HOTSWAP_CAPID) {
			location = cap_id_loc + PCI_ECP_HS_CSR;
			break;
		}
		cap_id_loc = pci_config_get8(config_handle,
		    cap_id_loc + 1);
	}
	return (location);
}

static int
pcihp_add_dummy_reg_property(dev_info_t *dip,
    uint_t bus, uint_t device, uint_t func)
{
	pci_regspec_t dummy_reg;

	bzero(&dummy_reg, sizeof (dummy_reg));

	dummy_reg.pci_phys_hi = PCIHP_MAKE_REG_HIGH(bus, device, func, 0);

	return (ndi_prop_update_int_array(DDI_DEV_T_NONE, dip,
	    "reg", (int *)&dummy_reg, sizeof (pci_regspec_t)/sizeof (int)));
}

static void
pcihp_hs_csr_op(pcihp_t *pcihp_p, int pci_dev, int event)
{
	struct pcihp_slotinfo *slotinfop;
	ddi_acc_handle_t config_handle;
	dev_info_t *dip, *new_child = NULL;
	uint8_t hs_csr;
	int result;

	slotinfop = &pcihp_p->slotinfo[pci_dev];

	if (pcihp_config_setup(&dip, &config_handle, &new_child, pci_dev,
				pcihp_p) != DDI_SUCCESS) {
		return;
	}

	result = pcihp_get_hs_csr(slotinfop, config_handle, (uint8_t *)&hs_csr);
	if ((result != PCIHP_SUCCESS) || (event == -1)) {
		pcihp_config_teardown(&config_handle, &new_child, pci_dev,
							pcihp_p);
		return;
	}

	hs_csr &= 0xf;
	switch (event) {
		case HPC_EVENT_SLOT_BLUE_LED_ON:
			hs_csr |= HS_CSR_LOO;
			break;
		case HPC_EVENT_SLOT_BLUE_LED_OFF:
			hs_csr &= ~HS_CSR_LOO;
			break;
		case HPC_EVENT_SLOT_CONFIGURE:
			hs_csr |= HS_CSR_INS;	/* clear INS */
			break;
		case HPC_EVENT_CLEAR_ENUM:
			hs_csr |= (HS_CSR_INS | HS_CSR_EXT);
			break;
		case HPC_EVENT_SLOT_UNCONFIGURE:
			hs_csr |= HS_CSR_EXT;	/* clear EXT */
			break;
		case HPC_EVENT_ENABLE_ENUM:
			hs_csr &= ~HS_CSR_EIM;
			break;
		case HPC_EVENT_DISABLE_ENUM:
			hs_csr |= HS_CSR_EIM;
			break;
		case HPC_EVENT_SLOT_NOT_HEALTHY:
		case HPC_EVENT_SLOT_HEALTHY_OK:
		default:
			break;
	}
	pcihp_set_hs_csr(slotinfop, config_handle, (uint8_t *)&hs_csr);
	pcihp_config_teardown(&config_handle, &new_child, pci_dev, pcihp_p);
}

static int
pcihp_config_setup(dev_info_t **dip, ddi_acc_handle_t *handle,
			dev_info_t **new_child, int pci_dev, pcihp_t *pcihp_p)
{
	dev_info_t *pdip = pcihp_p->dip;
	int bus, len, rc = DDI_SUCCESS;
	struct pcihp_slotinfo *slotinfop;
	hpc_slot_state_t rstate;
	ddi_acc_hdl_t *hp;
	struct bus_range {
		uint32_t lo;
		uint32_t hi;
	} pci_bus_range;

	slotinfop = &pcihp_p->slotinfo[pci_dev];

	/*
	 * If declared failed, don't allow Config operations.
	 * Otherwise, if good or failing, it is assumed Ok
	 * to get config data.
	 */
	if (slotinfop->condition == AP_COND_FAILED) {
		return (PCIHP_FAILURE);
	}
	/*
	 * check to see if there is a hardware present first.
	 * If no hardware present, no need to probe this slot.
	 * We can do this first probably as a first step towards
	 * safeguarding from accidental removal (we don't support it!).
	 */
	if (hpc_nexus_control(slotinfop->slot_hdl,
			HPC_CTRL_GET_SLOT_STATE, (caddr_t)&rstate) != 0) {
		return (DDI_FAILURE);
	}

	if (rstate != HPC_SLOT_CONNECTED) {
		/* error. slot must be connected */
		return (DDI_FAILURE);
	}
	*new_child = NULL;

	/*
	 * If there is no dip then we need to see if an
	 * adapter has just been hot plugged.
	 */
	len = sizeof (struct bus_range);
	if (ddi_getlongprop_buf(DDI_DEV_T_ANY, pdip,
	    0, "bus-range",
	    (caddr_t)&pci_bus_range, &len) != DDI_SUCCESS) {

		return (PCIHP_FAILURE);
	}

	/* primary bus number of this bus node */
	bus = pci_bus_range.lo;

	if (ndi_devi_alloc(pdip, DEVI_PSEUDO_NEXNAME,
	    (pnode_t)DEVI_SID_NODEID, dip) != NDI_SUCCESS) {

		PCIHP_DEBUG((CE_NOTE, "Failed to alloc probe node\n"));
		return (PCIHP_FAILURE);
	}

	if (pcihp_add_dummy_reg_property(*dip, bus,
	    pci_dev, 0) != DDI_SUCCESS) {

		(void) ndi_devi_free(*dip);
		return (PCIHP_FAILURE);
	}

	/*
	 * Probe for a device. Possibly a non (c)PCI board could be sitting
	 * here which would never respond to PCI config cycles - in which
	 * case we return. Eventually a configure operation would fail.
	 */
	if (pci_config_setup(*dip, handle) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "Cannot set config space map for"
		    " pci device number %d", pci_dev);
		(void) ndi_devi_free(*dip);
		return (PCIHP_FAILURE);
	}

	/*
	 * See if there is any PCI HW at this location
	 * by reading the Vendor ID.  If it returns with 0xffff
	 * then there is no hardware at this location.
	 */
	if (pcihp_indirect_map(*dip) == DDI_SUCCESS) {
		if (pci_config_get16(*handle, 0) == 0xffff) {
			pci_config_teardown(handle);
			(void) ndi_devi_free(*dip);
			return (PCIHP_FAILURE);
		}
	} else {
		/* Check if mapping is OK */
		hp = impl_acc_hdl_get(*handle);

		if (ddi_peek16(*dip, (int16_t *)(hp->ah_addr),
			(int16_t *)0) != DDI_SUCCESS) {
#ifdef DEBUG
			cmn_err(CE_WARN, "Cannot Map PCI config space for "
			    "device number %d", pci_dev);
#endif
			pci_config_teardown(handle);
			(void) ndi_devi_free(*dip);
			return (PCIHP_FAILURE);
		}
	}

	*new_child = *dip;
	return (rc);

}

static void
pcihp_config_teardown(ddi_acc_handle_t *handle,
			dev_info_t **new_child, int pci_dev, pcihp_t *pcihp_p)
{
	struct pcihp_slotinfo *slotinfop = &pcihp_p->slotinfo[pci_dev];

	pci_config_teardown(handle);
	if (*new_child) {
		(void) ndi_devi_free(*new_child);
		/*
		 * If occupant not configured, reset HS_CSR location
		 * so that we reprobe. This covers cases where
		 * the receptacle had a status change without a
		 * notification to the framework.
		 */
		if (slotinfop->ostate != AP_OSTATE_CONFIGURED)
			slotinfop->hs_csr_location = 0;
	}
}

static int
pcihp_get_board_type(struct pcihp_slotinfo *slotinfop)
{
	hpc_board_type_t board_type;

	/*
	 * Get board type data structure, hpc_board_type_t.
	 */
	if (hpc_nexus_control(slotinfop->slot_hdl, HPC_CTRL_GET_BOARD_TYPE,
				(caddr_t)&board_type) != 0) {

		cmn_err(CE_WARN, "Cannot Get Board Type..");
		return (-1);
	}

	/*
	 * We expect the Hotswap Controller to tell us if the board is
	 * a hotswap board or not, as it probably cannot differentiate
	 * between a basic hotswap board, a non hotswap board and a
	 * hotswap nonfriendly board.
	 * So here is the logic to differentiate between the various
	 * types of cPCI boards.
	 * In case if the HSC returns board type as unknown, we assign
	 * the default board type as defined by a configurable variable
	 * for a BHS, nonfriendly FHS and non HS board.
	 */
	if (slotinfop->slot_type & HPC_SLOT_TYPE_CPCI) {
		if (slotinfop->hs_csr_location > 0)
			board_type = HPC_BOARD_CPCI_FULL_HS;
		else {
			if (board_type == HPC_BOARD_CPCI_HS) {
				if (slotinfop->hs_csr_location
					== -1)
					board_type =
					HPC_BOARD_CPCI_BASIC_HS;
			}
			if (board_type == HPC_BOARD_UNKNOWN) {
				if (slotinfop->hs_csr_location
					== -1) {
					board_type =
					pcihp_cpci_board_type;
				} else if
				(slotinfop->hs_csr_location
					!= 0) {
					board_type =
					HPC_BOARD_CPCI_FULL_HS;
				}
			}
		}
		/*
		 * If board type is a non hotswap board, then we must
		 * deny a unconfigure operation. So set this flag.
		 * Strictly speaking, there is no reason not to disallow
		 * a unconfigure operation on nonhotswap boards. But this
		 * is the only way we can prevent a user from accidentally
		 * removing the board and damaging it.
		 */
		if (board_type == HPC_BOARD_CPCI_NON_HS)
			slotinfop->slot_flags |=
				PCIHP_SLOT_DEV_NON_HOTPLUG;
		else
			slotinfop->slot_flags &=
				~PCIHP_SLOT_DEV_NON_HOTPLUG;
	}
	return (board_type);
}


/*
 * Generate the System Event with a possible hint.
 */
static void
pcihp_gen_sysevent(char *slot_name, int event_sub_class, int hint,
				dev_info_t *self, int kmflag)
{

	int err;
	char *ev_subclass = NULL;
	sysevent_id_t eid;
	nvlist_t *ev_attr_list = NULL;
	char attach_pnt[MAXPATHLEN];

	/*
	 * Minor device name (AP) will be bus path
	 * concatenated with slot name
	 */

	(void) strcpy(attach_pnt, PCIHP_DEVICES_STR);
	(void) ddi_pathname(self, attach_pnt + strlen(PCIHP_DEVICES_STR));
	(void) strcat(attach_pnt, ":");
	(void) strcat(attach_pnt, slot_name);
	err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, kmflag);
	if (err != 0) {
		cmn_err(CE_WARN,
		    "%s%d: Failed to allocate memory "
		    "for event attributes%s", ddi_driver_name(self),
		    ddi_get_instance(self), ESC_DR_AP_STATE_CHANGE);
		return;
	}

	switch (event_sub_class) {

	/* event sub class: ESC_DR_AP_STATE_CHANGE */
	case PCIHP_DR_AP_STATE_CHANGE:

		ev_subclass = ESC_DR_AP_STATE_CHANGE;

		switch (hint) {

		case SE_NO_HINT:	/* fall through */
		case SE_HINT_INSERT:	/* fall through */
		case SE_HINT_REMOVE:


			err = nvlist_add_string(ev_attr_list, DR_HINT,
			    SE_HINT2STR(hint));

			if (err != 0) {
				cmn_err(CE_WARN, "%s%d: Failed to add attr [%s]"
					" for %s event", ddi_driver_name(self),
					ddi_get_instance(self),
					DR_HINT, ESC_DR_AP_STATE_CHANGE);
				nvlist_free(ev_attr_list);
				return;
			}
			break;

		default:
			cmn_err(CE_WARN, "%s%d: Unknown hint on sysevent",
				ddi_driver_name(self), ddi_get_instance(self));
			nvlist_free(ev_attr_list);
			return;
		}

		break;

	/* event sub class: ESC_DR_REQ */
	case PCIHP_DR_REQ:

		ev_subclass = ESC_DR_REQ;

		switch (hint) {

		case SE_INVESTIGATE_RES:	/* fall through */
		case SE_INCOMING_RES:	/* fall through */
		case SE_OUTGOING_RES:	/* fall through */

			err = nvlist_add_string(ev_attr_list, DR_REQ_TYPE,
				SE_REQ2STR(hint));

			if (err != 0) {
				cmn_err(CE_WARN,
					"%s%d: Failed to add attr [%s] "
					"for %s event", ddi_driver_name(self),
					ddi_get_instance(self),
					DR_REQ_TYPE, ESC_DR_REQ);
				nvlist_free(ev_attr_list);
				return;
			}
			break;

		default:
			cmn_err(CE_WARN,
				"%s%d:  Unknown hint on sysevent",
				ddi_driver_name(self), ddi_get_instance(self));
			nvlist_free(ev_attr_list);
			return;
		}

		break;

	default:
		cmn_err(CE_WARN,
			"%s%d:  Unknown Event subclass", ddi_driver_name(self),
			ddi_get_instance(self));
		nvlist_free(ev_attr_list);
		return;
	}

	/*
	 * Add attachment point as attribute (common attribute)
	 */

	err = nvlist_add_string(ev_attr_list, DR_AP_ID, attach_pnt);

	if (err != 0) {
		cmn_err(CE_WARN,
			"%s%d: Failed to add attr [%s] for %s event",
			ddi_driver_name(self), ddi_get_instance(self),
			DR_AP_ID, EC_DR);
		nvlist_free(ev_attr_list);
		return;
	}


	/*
	 * Log this event with sysevent framework.
	 */

	err = ddi_log_sysevent(self, DDI_VENDOR_SUNW, EC_DR,
	    ev_subclass, ev_attr_list, &eid,
	    ((kmflag == KM_SLEEP) ? DDI_SLEEP : DDI_NOSLEEP));
	if (err != 0) {
		cmn_err(CE_WARN, "%s%d: Failed to log %s event",
			ddi_driver_name(self), ddi_get_instance(self), EC_DR);
	}

	nvlist_free(ev_attr_list);
}

int
pcihp_prop_op(dev_t dev, dev_info_t *dip, ddi_prop_op_t prop_op,
    int flags, char *name, caddr_t valuep, int *lengthp)
{
	int pci_dev;

	if (dev == DDI_DEV_T_ANY)
		goto skip;

	if (strcmp(name, "pci-occupant") == 0) {
		pci_dev = PCIHP_AP_MINOR_NUM_TO_PCI_DEVNUM(getminor(dev));
		pcihp_create_occupant_props_nolock(dip, dev, pci_dev);
	}
	/* other cases... */
skip:
	return (ddi_prop_op(dev, dip, prop_op, flags, name, valuep, lengthp));
}

/*
 * this function is called only for SPARC platforms, where we may have
 * a mix n' match of direct vs indirectly mapped configuration space.
 * On x86, this function should always return success since the configuration
 * space is always indirect mapped.
 */
/*ARGSUSED*/
static int
pcihp_indirect_map(dev_info_t *dip)
{
#if defined(__sparc)
	int rc = DDI_FAILURE;

	if (ddi_prop_get_int(DDI_DEV_T_ANY, ddi_get_parent(dip), 0,
			PCI_DEV_CONF_MAP_PROP, DDI_FAILURE) != DDI_FAILURE)
		rc = DDI_SUCCESS;
	else
		if (ddi_prop_get_int(DDI_DEV_T_ANY, ddi_get_parent(dip),
				0, PCI_BUS_CONF_MAP_PROP,
				DDI_FAILURE) != DDI_FAILURE)
			rc = DDI_SUCCESS;
	return (rc);
#else
	return (DDI_SUCCESS);
#endif
}