xref: /illumos-gate/usr/src/uts/common/io/cardbus/cardbus_hp.c (revision 647709cb33adbc9ec046fb9ad41818ffc50b0bf3)

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

/*
 * Copyright (c)  * Copyright (c) 2001 Tadpole Technology plc
 * All rights reserved.
 * From "@(#)pcicfg.c   1.31    99/06/18 SMI"
 */

/*
 * Cardbus hotplug module
 */

#include <sys/open.h>
#include <sys/file.h>
#include <sys/stat.h>
#include <sys/ddi.h>
#include <sys/sunndi.h>

#include <sys/note.h>

#include <sys/pci.h>

#include <sys/hotplug/hpcsvc.h>
#include <sys/hotplug/pci/pcicfg.h>
#include <sys/pcic_reg.h>

#include "cardbus.h"
#include "cardbus_hp.h"
#include "cardbus_cfg.h"

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

#ifndef HPC_MAX_OCCUPANTS
#define	HPC_MAX_OCCUPANTS 8
typedef struct hpc_occupant_info {
	int	i;
	char	*id[HPC_MAX_OCCUPANTS];
} hpc_occupant_info_t;
#endif

#define	PCICFG_FLAGS_CONTINUE   0x1

#define	PCICFG_OP_ONLINE	0x1
#define	PCICFG_OP_OFFLINE	0x0

#define	CBHP_DEVCTL_MINOR	255

#define	AP_MINOR_NUM_TO_CB_INSTANCE(x)	((x) & 0xFF)
#define	AP_MINOR_NUM(x)		(((uint_t)(3) << 8) | ((x) & 0xFF))
#define	AP_IS_CB_MINOR(x)	(((x)>>8) == (3))

extern int cardbus_debug;
extern int number_of_cardbus_cards;

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

/* static functions */
static int cardbus_event_handler(caddr_t slot_arg, uint_t event_mask);
static int cardbus_pci_control(caddr_t ops_arg, hpc_slot_t slot_hdl,
				int request, caddr_t arg);
static int cardbus_new_slot_state(dev_info_t *dip, hpc_slot_t hdl,
				hpc_slot_info_t *slot_info, int slot_state);
static int cardbus_list_occupants(dev_info_t *dip, void *hdl);
static void create_occupant_props(dev_info_t *self, dev_t dev);
static void delete_occupant_props(dev_info_t *dip, dev_t dev);
static int cardbus_configure_ap(cbus_t *cbp);
static int cardbus_unconfigure_ap(cbus_t *cbp);
static int cbus_unconfigure(dev_info_t *devi, int prim_bus);
void cardbus_dump_pci_config(dev_info_t *dip);
void cardbus_dump_pci_node(dev_info_t *dip);

int
cardbus_init_hotplug(cbus_t *cbp)
{
	char tbuf[MAXNAMELEN];
	hpc_slot_info_t	slot_info;
	hpc_slot_ops_t	*slot_ops;
	hpc_slot_t	slhandle;	/* HPS slot handle */

	/*
	 *  register the bus instance with the HPS framework.
	 */
	if (hpc_nexus_register_bus(cbp->cb_dip,
	    cardbus_new_slot_state, 0) != 0) {
		cmn_err(CE_WARN, "%s%d: failed to register the bus with HPS\n",
		    ddi_driver_name(cbp->cb_dip), cbp->cb_instance);
		return (DDI_FAILURE);
	}

	(void) sprintf(cbp->ap_id, "slot%d", cbp->cb_instance);
	(void) ddi_pathname(cbp->cb_dip, tbuf);
	cbp->nexus_path = kmem_alloc(strlen(tbuf) + 1, KM_SLEEP);
	(void) strcpy(cbp->nexus_path, tbuf);
	cardbus_err(cbp->cb_dip, 8,
	    "cardbus_init_hotplug: nexus_path set to %s", cbp->nexus_path);

	slot_ops = hpc_alloc_slot_ops(KM_SLEEP);
	cbp->slot_ops = slot_ops;

	/*
	 * Fill in the slot information structure that
	 * describes the slot.
	 */
	slot_info.version = HPC_SLOT_INFO_VERSION;
	slot_info.slot_type = HPC_SLOT_TYPE_PCI;
	slot_info.slot.pci.device_number = 0;
	slot_info.slot.pci.slot_capabilities = 0;

	(void) strcpy(slot_info.slot.pci.slot_logical_name, cbp->ap_id);

	slot_ops->hpc_version = HPC_SLOT_OPS_VERSION;
	slot_ops->hpc_op_connect = NULL;
	slot_ops->hpc_op_disconnect = NULL;
	slot_ops->hpc_op_insert = NULL;
	slot_ops->hpc_op_remove = NULL;
	slot_ops->hpc_op_control = cardbus_pci_control;

	if (hpc_slot_register(cbp->cb_dip, cbp->nexus_path, &slot_info,
	    &slhandle, slot_ops, (caddr_t)cbp, 0) != 0) {
		/*
		 * If the slot can not be registered,
		 * then the slot_ops need to be freed.
		 */
		cmn_err(CE_WARN,
		    "cbp%d Unable to Register Slot %s", cbp->cb_instance,
		    slot_info.slot.pci.slot_logical_name);

		(void) hpc_nexus_unregister_bus(cbp->cb_dip);
		hpc_free_slot_ops(slot_ops);
		cbp->slot_ops = NULL;
		return (DDI_FAILURE);
	}

	ASSERT(slhandle == cbp->slot_handle);

	cardbus_err(cbp->cb_dip, 8,
	    "cardbus_init_hotplug: slot_handle 0x%p", cbp->slot_handle);
	return (DDI_SUCCESS);
}

static int
cardbus_event_handler(caddr_t slot_arg, uint_t event_mask)
{
	int ap_minor = (int)((uintptr_t)slot_arg);
	cbus_t *cbp;
	int cb_instance;
	int rv = HPC_EVENT_CLAIMED;

	cb_instance = AP_MINOR_NUM_TO_CB_INSTANCE(ap_minor);

	ASSERT(cb_instance >= 0);
	cbp = (cbus_t *)ddi_get_soft_state(cardbus_state, cb_instance);
	mutex_enter(&cbp->cb_mutex);

	switch (event_mask) {

	case HPC_EVENT_SLOT_INSERTION:
		/*
		 * A card is inserted in the slot. Just report this
		 * event and return.
		 */
		cardbus_err(cbp->cb_dip, 7,
		    "cardbus_event_handler(%s%d): card is inserted",
		    ddi_driver_name(cbp->cb_dip), cbp->cb_instance);

		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 (!(cbp->auto_config)) {
			/*
			 * auto configuration is disabled.
			 */
			cardbus_err(cbp->cb_dip, 7,
			    "cardbus_event_handler(%s%d): "
			    "SLOT_CONFIGURE event occured (slot %s)",
			    ddi_driver_name(cbp->cb_dip), cbp->cb_instance,
			    cbp->name);

			break;
		}

		cardbus_err(cbp->cb_dip, 7,
		    "cardbus_event_handler(%s%d): configure event",
		    ddi_driver_name(cbp->cb_dip), cbp->cb_instance);

		if (cbp->ostate != AP_OSTATE_UNCONFIGURED) {
			cmn_err(CE_WARN, "!slot%d already configured\n",
			    cbp->cb_instance);
			break;
		}

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

		if (cardbus_configure_ap(cbp) == HPC_SUCCESS)
			create_occupant_props(cbp->cb_dip, makedevice(
			    ddi_driver_major((cbp->cb_dip)), ap_minor));
		else
			rv = HPC_ERR_FAILED;

		break;

	case HPC_EVENT_SLOT_UNCONFIGURE:
		/*
		 * Unconfigure the occupant in this slot.
		 */
		if (!(cbp->auto_config)) {
			/*
			 * auto configuration is disabled.
			 */
			cardbus_err(cbp->cb_dip, 7,
			    "cardbus_event_handler(%s%d): "
			    "SLOT_UNCONFIGURE event"
			    " occured - auto-conf disabled (slot %s)",
			    ddi_driver_name(cbp->cb_dip), cbp->cb_instance,
			    cbp->name);

			break;
		}

		cardbus_err(cbp->cb_dip, 7,
		    "cardbus_event_handler(%s%d): SLOT_UNCONFIGURE event"
		    " occured (slot %s)",
		    ddi_driver_name(cbp->cb_dip), cbp->cb_instance,
		    cbp->name);

		if (cardbus_unconfigure_ap(cbp) != HPC_SUCCESS)
			rv = HPC_ERR_FAILED;

		DEVI(cbp->cb_dip)->devi_ops->devo_bus_ops = cbp->orig_bopsp;
		--number_of_cardbus_cards;
		break;

	case HPC_EVENT_SLOT_REMOVAL:
		/*
		 * Card is removed from the slot. The card must have been
		 * unconfigured before this event.
		 */
		if (cbp->ostate != AP_OSTATE_UNCONFIGURED) {
			cardbus_err(cbp->cb_dip, 1,
			    "cardbus_event_handler(%s%d): "
			    "card is removed from"
			    " the slot %s before doing unconfigure!!",
			    ddi_driver_name(cbp->cb_dip), cbp->cb_instance,
			    cbp->name);

			break;
		}

		cardbus_err(cbp->cb_dip, 7,
		    "cardbus_event_handler(%s%d): "
		    "card is removed from the slot %s",
		    ddi_driver_name(cbp->cb_dip), cbp->cb_instance,
		    cbp->name);

		break;

	case HPC_EVENT_SLOT_POWER_ON:
		/*
		 * Slot is connected to the bus. i.e the card is powered
		 * on.
		 */
		cardbus_err(cbp->cb_dip, 7,
		    "cardbus_event_handler(%s%d): "
		    "card is powered on in the slot %s",
		    ddi_driver_name(cbp->cb_dip), cbp->cb_instance,
		    cbp->name);

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

		break;

	case HPC_EVENT_SLOT_POWER_OFF:
		/*
		 * Slot is disconnected from the bus. i.e the card is powered
		 * off.
		 */
		cardbus_err(cbp->cb_dip, 7,
		    "cardbus_event_handler(%s%d): "
		    "card is powered off in the slot %s",
		    ddi_driver_name(cbp->cb_dip), cbp->cb_instance,
		    cbp->name);

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

		break;

	default:
		cardbus_err(cbp->cb_dip, 4,
		    "cardbus_event_handler(%s%d): "
		    "unknown event %x for this slot %s",
		    ddi_driver_name(cbp->cb_dip), cbp->cb_instance,
		    event_mask, cbp->name);

		break;
	}

	mutex_exit(&cbp->cb_mutex);

	return (rv);
}

static int
cardbus_pci_control(caddr_t ops_arg, hpc_slot_t slot_hdl, int request,
    caddr_t arg)
{
	cbus_t *cbp;
	int rval = HPC_SUCCESS;
	hpc_led_info_t *hpc_led_info;

	_NOTE(ARGUNUSED(slot_hdl))

	cbp = (cbus_t *)ops_arg;
	ASSERT(mutex_owned(&cbp->cb_mutex));

	switch (request) {

	case HPC_CTRL_GET_SLOT_STATE: {
		hpc_slot_state_t	*hpc_slot_state;

		hpc_slot_state = (hpc_slot_state_t *)arg;

		cardbus_err(cbp->cb_dip, 7,
		    "cardbus_pci_control() - "
		    "HPC_CTRL_GET_SLOT_STATE hpc_slot_state=0x%p",
		    (void *) hpc_slot_state);

		if (cbp->card_present)
			*hpc_slot_state = HPC_SLOT_CONNECTED;
		else
			*hpc_slot_state = HPC_SLOT_EMPTY;

		break;
	}

	case HPC_CTRL_GET_BOARD_TYPE: {
		hpc_board_type_t	*hpc_board_type;

		hpc_board_type = (hpc_board_type_t *)arg;

		cardbus_err(cbp->cb_dip, 7,
		    "cardbus_pci_control() - HPC_CTRL_GET_BOARD_TYPE");

		/*
		 * The HPC driver does not know what board type
		 * is plugged in.
		 */
		*hpc_board_type = HPC_BOARD_PCI_HOTPLUG;

		break;
	}

	case HPC_CTRL_DEV_CONFIGURED:
	case HPC_CTRL_DEV_UNCONFIGURED:
		cardbus_err(cbp->cb_dip, 5,
		    "cardbus_pci_control() - HPC_CTRL_DEV_%sCONFIGURED",
		    request == HPC_CTRL_DEV_UNCONFIGURED ? "UN" : "");
		break;

	case HPC_CTRL_GET_LED_STATE:
		hpc_led_info = (hpc_led_info_t *)arg;
		cardbus_err(cbp->cb_dip, 5,
		    "cardbus_pci_control() - HPC_CTRL_GET_LED_STATE "
		    "led %d is %d",
		    hpc_led_info->led, cbp->leds[hpc_led_info->led]);

		hpc_led_info->state = cbp->leds[hpc_led_info->led];
		break;

	case HPC_CTRL_SET_LED_STATE:
		hpc_led_info = (hpc_led_info_t *)arg;

		cardbus_err(cbp->cb_dip, 4,
		    "cardbus_pci_control() - HPC_CTRL_SET_LED_STATE "
		    "led %d to %d",
		    hpc_led_info->led, hpc_led_info->state);

		cbp->leds[hpc_led_info->led] = hpc_led_info->state;
		break;

	case HPC_CTRL_ENABLE_AUTOCFG:
		cardbus_err(cbp->cb_dip, 5,
		    "cardbus_pci_control() - HPC_CTRL_ENABLE_AUTOCFG");

		/*
		 * Cardbus ALWAYS does auto config, from the slots point of
		 * view this is turning on the card and making sure it's ok.
		 * This is all done by the bridge driver before we see any
		 * indication.
		 */
		break;

	case HPC_CTRL_DISABLE_AUTOCFG:
		cardbus_err(cbp->cb_dip, 5,
		    "cardbus_pci_control() - HPC_CTRL_DISABLE_AUTOCFG");
		break;

	case HPC_CTRL_DISABLE_ENUM:
	case HPC_CTRL_ENABLE_ENUM:
	default:
		rval = HPC_ERR_NOTSUPPORTED;
		break;
	}

	return (rval);
}

/*
 * cardbus_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
cardbus_new_slot_state(dev_info_t *dip, hpc_slot_t hdl,
    hpc_slot_info_t *slot_info, int slot_state)
{
	int cb_instance;
	cbus_t *cbp;
	int ap_minor;
	int rv = 0;

	cardbus_err(dip, 8,
	    "cardbus_new_slot_state: slot_handle 0x%p", hdl);

	/*
	 * get the soft state structure for the bus instance.
	 */
	cb_instance = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
	    DDI_PROP_DONTPASS, "cbus-instance", -1);
	ASSERT(cb_instance >= 0);
	cbp = (cbus_t *)ddi_get_soft_state(cardbus_state, cb_instance);

	mutex_enter(&cbp->cb_mutex);

	switch (slot_state) {

	case HPC_SLOT_ONLINE:
		/*
		 * Make sure the slot is not already ONLINE
		 */
		if (cbp->slot_handle != NULL) {
			cardbus_err(dip, 4,
			    "cardbus_new_slot_state: "
			    "cardbus already ONLINE!!");
			rv = HPC_ERR_FAILED;
			break;
		}

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

		/* create the AP minor node */
		ap_minor = AP_MINOR_NUM(cb_instance);
		if (ddi_create_minor_node(dip, slot_info->pci_slot_name,
		    S_IFCHR, ap_minor,
		    DDI_NT_PCI_ATTACHMENT_POINT,
		    0) == DDI_FAILURE) {
			cardbus_err(dip, 4,
			    "cardbus_new_slot_state: "
			    "ddi_create_minor_node failed");
			rv = HPC_ERR_FAILED;
			break;
		}

		/* save the slot handle */
		cbp->slot_handle = hdl;

		/* setup event handler for all hardware events on the slot */
		if (hpc_install_event_handler(hdl, -1, cardbus_event_handler,
		    (caddr_t)((long)ap_minor)) != 0) {
			cardbus_err(dip, 4,
			    "cardbus_new_slot_state: "
			    "install event handler failed");
			rv = HPC_ERR_FAILED;
			break;
		}
		cbp->event_mask = (uint32_t)0xFFFFFFFF;
		create_occupant_props(dip,
		    makedevice(ddi_name_to_major(ddi_get_name(dip)),
		    ap_minor));

		/* set default auto configuration enabled flag for this slot */
		cbp->auto_config = cardbus_autocfg_enabled;

		/* copy the slot information */
		cbp->name = (char *)kmem_alloc(strlen(slot_info->pci_slot_name)
		    + 1, KM_SLEEP);
		(void) strcpy(cbp->name, slot_info->pci_slot_name);
		cardbus_err(cbp->cb_dip, 10,
		    "cardbus_new_slot_state: cbp->name set to %s", cbp->name);

		cardbus_err(dip, 4,
		    "Cardbus slot \"%s\" ONLINE\n", slot_info->pci_slot_name);

		cbp->ostate = AP_OSTATE_UNCONFIGURED;
		cbp->rstate = AP_RSTATE_EMPTY;

		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 (cbp->ostate != AP_OSTATE_UNCONFIGURED) {
			cmn_err(CE_WARN,
			    "cardbus: Card is still in configured state");
			rv = HPC_ERR_FAILED;
			break;
		}

		/*
		 * If the AP device is in open state then return
		 * error.
		 */
		if (cbp->soft_state != PCIHP_SOFT_STATE_CLOSED) {
			rv = HPC_ERR_FAILED;
			break;
		}

		/* remove the minor node */
		ddi_remove_minor_node(dip, cbp->name);
		/* free up the memory for the name string */
		kmem_free(cbp->name, strlen(cbp->name) + 1);

		/* update the slot info data */
		cbp->name = NULL;
		cbp->slot_handle = NULL;

		cardbus_err(dip, 6,
		    "cardbus_new_slot_state: Cardbus slot OFFLINE");
		break;

	default:
		cmn_err(CE_WARN,
		    "cardbus_new_slot_state: unknown slot_state %d\n",
		    slot_state);
		rv = HPC_ERR_FAILED;
	}

	mutex_exit(&cbp->cb_mutex);

	return (rv);
}

static int
cardbus_list_occupants(dev_info_t *dip, void *hdl)
{
	hpc_occupant_info_t *occupant = (hpc_occupant_info_t *)hdl;
	char pn[MAXPATHLEN];

	/*
	 * Ignore the attachment point and pcs.
	 */
	if (strcmp(ddi_binding_name(dip), "pcs") == 0) {
		return (DDI_WALK_CONTINUE);
	}

	(void) ddi_pathname(dip, pn);

	occupant->id[occupant->i] = kmem_alloc(strlen(pn) + 1, KM_SLEEP);
	(void) strcpy(occupant->id[occupant->i], pn);

	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
create_occupant_props(dev_info_t *self, dev_t dev)
{
	hpc_occupant_info_t occupant;
	int i;
	int circular;

	occupant.i = 0;

	ndi_devi_enter(self, &circular);
	ddi_walk_devs(ddi_get_child(self), cardbus_list_occupants,
	    (void *)&occupant);
	ndi_devi_exit(self, circular);

	if (occupant.i == 0) {
		char *c[] = { "" };
		cardbus_err(self, 1, "create_occupant_props: no occupant\n");
		(void) ddi_prop_update_string_array(dev, self, "pci-occupant",
		    c, 1);
	} else {
		cardbus_err(self, 1,
		    "create_occupant_props: %d occupant\n", occupant.i);
		(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], strlen(occupant.id[i]) + 1);
	}
}

static void
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 */

}

/*
 * **************************************
 * CONFIGURE the occupant in the slot.
 * **************************************
 */
static int
cardbus_configure_ap(cbus_t *cbp)
{
	dev_info_t *self = cbp->cb_dip;
	int rv = HPC_SUCCESS;
	hpc_slot_state_t rstate;
	struct cardbus_config_ctrl ctrl;
	int circular_count;

	/*
	 * check for valid request:
	 *  1. It is a hotplug slot.
	 *  2. The receptacle is in the CONNECTED state.
	 */
	if (cbp->slot_handle == NULL || cbp->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 (cbp->ostate == AP_OSTATE_CONFIGURED) {
		ctrl.flags = PCICFG_FLAGS_CONTINUE;
		ctrl.busno = cardbus_primary_busno(self);
		ctrl.rv = NDI_SUCCESS;
		ctrl.dip = NULL;
		ctrl.op = PCICFG_OP_ONLINE;

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

		if (cardbus_debug) {
			cardbus_dump_pci_config(self);
			cardbus_dump_pci_node(self);
		}

		if (ctrl.rv != NDI_SUCCESS) {
			/*
			 * one or more of the devices are not
			 * onlined.
			 */
			cmn_err(CE_WARN, "cardbus(%s%d): failed to attach "
			    "one or more drivers for the card in the slot %s",
			    ddi_driver_name(self), cbp->cb_instance,
			    cbp->name);
		}

		/* tell HPC driver that the occupant is configured */
		(void) hpc_nexus_control(cbp->slot_handle,
		    HPC_CTRL_DEV_CONFIGURED, NULL);
		return (rv);
	}

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

	/* Check if the receptacle is in the CONNECTED state. */
	if (hpc_nexus_control(cbp->slot_handle,
	    HPC_CTRL_GET_SLOT_STATE, (caddr_t)&rstate) != 0) {
		return (ENXIO);
	}

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

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

	/*
	 * Call the configurator to configure the card.
	 */
	if (cardbus_configure(cbp) != PCICFG_SUCCESS) {
		return (EIO);
	}

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

	/* now, online all the devices in the AP */
	ctrl.flags = PCICFG_FLAGS_CONTINUE;
	ctrl.busno = cardbus_primary_busno(self);
	ctrl.rv = NDI_SUCCESS;
	ctrl.dip = NULL;
	ctrl.op = PCICFG_OP_ONLINE;

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

	if (cardbus_debug) {
		cardbus_dump_pci_config(self);
		cardbus_dump_pci_node(self);
	}
	if (ctrl.rv != NDI_SUCCESS) {
		/*
		 * one or more of the devices are not
		 * ONLINE'd.
		 */
		cmn_err(CE_WARN, "cbhp (%s%d): failed to attach one or"
		    " more drivers for the card in the slot %s",
		    ddi_driver_name(cbp->cb_dip),
		    cbp->cb_instance, cbp->name);
		/* rv = EFAULT; */
	}

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

	return (rv);
}

/*
 * **************************************
 * UNCONFIGURE the occupant in the slot.
 * **************************************
 */
static int
cardbus_unconfigure_ap(cbus_t *cbp)
{
	dev_info_t *self = cbp->cb_dip;
	int rv = HPC_SUCCESS, nrv;

	/*
	 * check for valid request:
	 *  1. It is a hotplug slot.
	 *  2. The occupant is in the CONFIGURED state.
	 */

	if (cbp->slot_handle == NULL || cbp->disabled) {
		return (ENXIO);
	}

	/*
	 * If the occupant is in the CONFIGURED state then
	 * call the configurator to unconfigure the slot.
	 */
	if (cbp->ostate == AP_OSTATE_CONFIGURED) {
		/*
		 * Detach all the drivers for the devices in the
		 * slot.
		 */
		nrv = cardbus_unconfigure_node(self,
		    cardbus_primary_busno(self),
		    B_TRUE);

		if (nrv != NDI_SUCCESS) {
			/*
			 * Failed to detach one or more drivers.
			 * Restore the status for the drivers
			 * which are offlined during this step.
			 */
			cmn_err(CE_WARN,
			    "cbhp (%s%d): Failed to offline all devices"
			    " (slot %s)", ddi_driver_name(cbp->cb_dip),
			    cbp->cb_instance, cbp->name);
			rv = EBUSY;
		} else {

			if (cardbus_unconfigure(cbp) == PCICFG_SUCCESS) {
				/*
				 * Now that resources are freed,
				 * clear EXT and Turn LED ON.
				 */
				cbp->ostate = AP_OSTATE_UNCONFIGURED;
				cbp->condition = AP_COND_UNKNOWN;
				/*
				 * send the notification of state change
				 * to the HPC driver.
				 */
				(void) hpc_nexus_control(cbp->slot_handle,
				    HPC_CTRL_DEV_UNCONFIGURED, NULL);
			} else {
				rv = EIO;
			}
		}
	}

	return (rv);
}

int
cbus_configure(dev_info_t *dip, void *hdl)
{
	pci_regspec_t *pci_rp;
	int length, rc;
	struct cardbus_config_ctrl *ctrl = (struct cardbus_config_ctrl *)hdl;
	uint8_t bus, device, function;

	/*
	 * Ignore the attachment point and pcs.
	 */
	if (strcmp(ddi_binding_name(dip), "hp_attachment") == 0 ||
	    strcmp(ddi_binding_name(dip), "pcs") == 0) {
		cardbus_err(dip, 8, "cbus_configure: Ignoring\n");
		return (DDI_WALK_CONTINUE);
	}

	cardbus_err(dip, 6, "cbus_configure\n");

	ASSERT(ctrl->op == PCICFG_OP_ONLINE);

	/*
	 * 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) {
		/* Porbably not a real device, like PCS for example */
		if (ddi_get_child(dip) == NULL)
			return (DDI_WALK_PRUNECHILD);

		cardbus_err(dip, 1, "cubs_configure: Don't configure device\n");
		ctrl->rv = DDI_FAILURE;
		ctrl->dip = dip;
		return (DDI_WALK_TERMINATE);
	}

	if (pci_rp->pci_phys_hi == 0)
		return (DDI_WALK_CONTINUE);

	/* get the pci device id information */
	bus = PCI_REG_BUS_G(pci_rp->pci_phys_hi);
	device = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
	function = 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 (bus <= ctrl->busno)
		return (DDI_WALK_CONTINUE);

	cardbus_err(dip, 8,
	    "cbus_configure on-line device at: "
	    "[0x%x][0x%x][0x%x]\n", bus, device, function);

	rc = ndi_devi_online(dip, NDI_ONLINE_ATTACH|NDI_CONFIG);

	cardbus_err(dip, 7,
	    "cbus_configure %s\n",
	    rc == NDI_SUCCESS ? "Success": "Failure");

	if (rc != NDI_SUCCESS)
		return (DDI_WALK_PRUNECHILD);

	return (DDI_WALK_CONTINUE);
}

int
cardbus_unconfigure_node(dev_info_t *dip, int prim_bus, boolean_t top_bridge)
{
	dev_info_t *child, *next;

	cardbus_err(dip, 6, "cardbus_unconfigure_node\n");

	/*
	 * Ignore pcs.
	 */
	if (strcmp(ddi_binding_name(dip), "pcs") == 0) {
		cardbus_err(dip, 8, "cardbus_unconfigure_node: Ignoring\n");
		return (NDI_SUCCESS);
	}

	/*
	 * bottom up off-line
	 */
	for (child = ddi_get_child(dip); child; child = next) {
		int rc;
		next = ddi_get_next_sibling(child);
		rc = cardbus_unconfigure_node(child, prim_bus, B_FALSE);
		if (rc != NDI_SUCCESS)
			return (rc);
	}

	/*
	 * Don't unconfigure the bridge itself.
	 */
	if (top_bridge)
		return (NDI_SUCCESS);

	if (cbus_unconfigure(dip, prim_bus) != NDI_SUCCESS) {
		cardbus_err(dip, 1,
		    "cardbus_unconfigure_node: cardbus_unconfigure failed\n");
		return (NDI_FAILURE);
	}
	return (NDI_SUCCESS);
}

/*
 * This will turn  resources allocated by cbus_configure()
 * and remove the device tree from the attachment point
 * and below.  The routine assumes the devices have their
 * drivers detached.
 */
static int
cbus_unconfigure(dev_info_t *devi, int prim_bus)
{
	pci_regspec_t *pci_rp;
	uint_t bus, device, func, length;
	int ndi_flags = NDI_UNCONFIG;

	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, devi,
	    DDI_PROP_DONTPASS, "reg", (int **)&pci_rp,
	    &length) != DDI_PROP_SUCCESS) {
		/*
		 * This cannot be one of our devices. If it's something like a
		 * SCSI device then the attempt to offline the HBA
		 * (which probably is one of our devices)
		 * will also do bottom up offlining. That
		 * will fail if this device is busy. So always
		 * return success here
		 * so that the walk will continue.
		 */
		return (NDI_SUCCESS);
	}

	if (pci_rp->pci_phys_hi == 0)
		return (NDI_FAILURE);

	bus = PCI_REG_BUS_G(pci_rp->pci_phys_hi);

	if (bus <= prim_bus)
		return (NDI_SUCCESS);

	device = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
	func = PCI_REG_FUNC_G(pci_rp->pci_phys_hi);
	ddi_prop_free(pci_rp);

	cardbus_err(devi, 8,
	    "cbus_unconfigure: "
	    "offline bus [0x%x] device [0x%x] function [%x]\n",
	    bus, device, func);
	if (ndi_devi_offline(devi, ndi_flags) != NDI_SUCCESS) {
		cardbus_err(devi, 1,
		    "Device [0x%x] function [%x] is busy\n", device, func);
		return (NDI_FAILURE);
	}

	cardbus_err(devi, 9,
	    "Tearing down device [0x%x] function [0x%x]\n", device, func);

	if (cardbus_teardown_device(devi) != PCICFG_SUCCESS) {
		cardbus_err(devi, 1,
		    "Failed to tear down "
		    "device [0x%x] function [0x%x]\n", device, func);
		return (NDI_FAILURE);
	}

	return (NDI_SUCCESS);
}

boolean_t
cardbus_is_cb_minor(dev_t dev)
{
	return (AP_IS_CB_MINOR(getminor(dev)) ? B_TRUE : B_FALSE);
}

int
cardbus_open(dev_t *devp, int flags, int otyp, cred_t *credp)
{
	cbus_t *cbp;
	int minor;

	_NOTE(ARGUNUSED(credp))

	minor = getminor(*devp);

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

	/*
	 * Get the soft state structure for the 'devctl' device.
	 */
	cbp = (cbus_t *)ddi_get_soft_state(cardbus_state,
	    AP_MINOR_NUM_TO_CB_INSTANCE(minor));
	if (cbp == NULL)
		return (ENXIO);

	mutex_enter(&cbp->cb_mutex);

	/*
	 * 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 ((cbp->soft_state == PCIHP_SOFT_STATE_OPEN_EXCL) ||
	    ((flags & FEXCL) &&
	    (cbp->soft_state != PCIHP_SOFT_STATE_CLOSED))) {
		mutex_exit(&cbp->cb_mutex);
		return (EBUSY);
	}

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

	mutex_exit(&cbp->cb_mutex);
	return (0);
}

/*ARGSUSED*/
int
cardbus_close(dev_t dev, int flags, int otyp, cred_t *credp)
{
	cbus_t *cbp;
	int minor;

	_NOTE(ARGUNUSED(credp))

	minor = getminor(dev);

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

	cbp = (cbus_t *)ddi_get_soft_state(cardbus_state,
	    AP_MINOR_NUM_TO_CB_INSTANCE(minor));
	if (cbp == NULL)
		return (ENXIO);

	mutex_enter(&cbp->cb_mutex);
	cbp->soft_state = PCIHP_SOFT_STATE_CLOSED;
	mutex_exit(&cbp->cb_mutex);
	return (0);
}

/*
 * cardbus_ioctl: devctl hotplug controls
 */
/*ARGSUSED*/
int
cardbus_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *credp,
    int *rvalp)
{
	cbus_t *cbp;
	dev_info_t *self;
	dev_info_t *child_dip = NULL;
	struct devctl_iocdata *dcp;
	uint_t bus_state;
	int rv = 0;
	int nrv = 0;
	int ap_minor;
	hpc_slot_state_t rstate;
	devctl_ap_state_t ap_state;
	struct hpc_control_data hpc_ctrldata;
	struct hpc_led_info led_info;

	_NOTE(ARGUNUSED(credp))

	ap_minor = getminor(dev);
	cbp = (cbus_t *)ddi_get_soft_state(cardbus_state,
	    AP_MINOR_NUM_TO_CB_INSTANCE(ap_minor));
	if (cbp == NULL)
		return (ENXIO);

	self = cbp->cb_dip;
	/*
	 * read devctl ioctl data
	 */
	if ((cmd != DEVCTL_AP_CONTROL) && ndi_dc_allochdl((void *)arg,
	    &dcp) != NDI_SUCCESS)
		return (EFAULT);

#ifdef CARDBUS_DEBUG
{
	char *cmd_name;

	switch (cmd) {
	case DEVCTL_DEVICE_GETSTATE: cmd_name = "DEVCTL_DEVICE_GETSTATE"; break;
	case DEVCTL_DEVICE_ONLINE: cmd_name = "DEVCTL_DEVICE_ONLINE"; break;
	case DEVCTL_DEVICE_OFFLINE: cmd_name = "DEVCTL_DEVICE_OFFLINE"; break;
	case DEVCTL_DEVICE_RESET: cmd_name = "DEVCTL_DEVICE_RESET"; break;
	case DEVCTL_BUS_QUIESCE: cmd_name = "DEVCTL_BUS_QUIESCE"; break;
	case DEVCTL_BUS_UNQUIESCE: cmd_name = "DEVCTL_BUS_UNQUIESCE"; break;
	case DEVCTL_BUS_RESET: cmd_name = "DEVCTL_BUS_RESET"; break;
	case DEVCTL_BUS_RESETALL: cmd_name = "DEVCTL_BUS_RESETALL"; break;
	case DEVCTL_BUS_GETSTATE: cmd_name = "DEVCTL_BUS_GETSTATE"; break;
	case DEVCTL_AP_CONNECT: cmd_name = "DEVCTL_AP_CONNECT"; break;
	case DEVCTL_AP_DISCONNECT: cmd_name = "DEVCTL_AP_DISCONNECT"; break;
	case DEVCTL_AP_INSERT: cmd_name = "DEVCTL_AP_INSERT"; break;
	case DEVCTL_AP_REMOVE: cmd_name = "DEVCTL_AP_REMOVE"; break;
	case DEVCTL_AP_CONFIGURE: cmd_name = "DEVCTL_AP_CONFIGURE"; break;
	case DEVCTL_AP_UNCONFIGURE: cmd_name = "DEVCTL_AP_UNCONFIGURE"; break;
	case DEVCTL_AP_GETSTATE: cmd_name = "DEVCTL_AP_GETSTATE"; break;
	case DEVCTL_AP_CONTROL: cmd_name = "DEVCTL_AP_CONTROL"; break;
	default: cmd_name = "Unknown"; break;
	}
	cardbus_err(cbp->cb_dip, 7,
	    "cardbus_ioctl: cmd = 0x%x, \"%s\"", cmd, cmd_name);
}
#endif

	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.
		 */
	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.
		 *
		 * The lower 8 bits of the minor number is the PCI
		 * device number for the slot.
		 */
		if ((cbp->slot_handle == NULL) || cbp->disabled) {
			rv = ENXIO;
			break;
		}

		/* the slot occupant must be in the UNCONFIGURED state */
		if (cbp->ostate != AP_OSTATE_UNCONFIGURED) {
			rv = EINVAL;
			break;
		}

		/*
		 * Call the HPC driver to perform the operation on the slot.
		 */
		mutex_enter(&cbp->cb_mutex);
		switch (cmd) {
		case DEVCTL_AP_INSERT:
			rv = hpc_nexus_insert(cbp->slot_handle, NULL, 0);
			break;
		case DEVCTL_AP_REMOVE:
			rv = hpc_nexus_remove(cbp->slot_handle, NULL, 0);
			break;
		case DEVCTL_AP_CONNECT:
			if ((rv = hpc_nexus_connect(cbp->slot_handle,
			    NULL, 0)) == 0)
				cbp->rstate = AP_RSTATE_CONNECTED;
			break;
		case DEVCTL_AP_DISCONNECT:
			if ((rv = hpc_nexus_disconnect(cbp->slot_handle,
			    NULL, 0)) == 0)
				cbp->rstate = AP_RSTATE_DISCONNECTED;
			break;
		}
		mutex_exit(&cbp->cb_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.
		 * **************************************
		 */

		mutex_enter(&cbp->cb_mutex);
		if ((nrv = cardbus_configure_ap(cbp)) == HPC_SUCCESS) {
			create_occupant_props(cbp->cb_dip, dev);
		} else
			rv = nrv;
		mutex_exit(&cbp->cb_mutex);
		break;

	case DEVCTL_AP_UNCONFIGURE:
		/*
		 * **************************************
		 * UNCONFIGURE the occupant in the slot.
		 * **************************************
		 */

		mutex_enter(&cbp->cb_mutex);
		if ((nrv = cardbus_unconfigure_ap(cbp)) == HPC_SUCCESS) {
			delete_occupant_props(cbp->cb_dip, dev);
		} else
			rv = nrv;
		mutex_exit(&cbp->cb_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.
		 */
		if (cbp->slot_handle == NULL) {
			rv = ENXIO;
			break;
		}

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

		if (cbp->ostate == AP_OSTATE_UNCONFIGURED) {
			if (hpc_nexus_control(cbp->slot_handle,
			    HPC_CTRL_GET_SLOT_STATE,
			    (caddr_t)&rstate) != 0) {
				rv = ENXIO;
				if (mutex_held)
					mutex_exit(&cbp->cb_mutex);
				break;
			}
			cbp->rstate = (ap_rstate_t)rstate;
		}

		ap_state.ap_rstate = cbp->rstate;
		ap_state.ap_ostate = cbp->ostate;
		ap_state.ap_condition = cbp->condition;
		ap_state.ap_last_change = 0;
		ap_state.ap_error_code = 0;
		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(&cbp->cb_mutex);

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

		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

#ifdef CARDBUS_DEBUG
{
		char *hpc_name;
		switch (hpc_ctrldata.cmd) {
		case HPC_CTRL_GET_LED_STATE:
			hpc_name = "HPC_CTRL_GET_LED_STATE";
			break;
		case HPC_CTRL_SET_LED_STATE:
			hpc_name = "HPC_CTRL_SET_LED_STATE";
			break;
		case HPC_CTRL_ENABLE_SLOT:
			hpc_name = "HPC_CTRL_ENABLE_SLOT";
			break;
		case HPC_CTRL_DISABLE_SLOT:
			hpc_name = "HPC_CTRL_DISABLE_SLOT";
			break;
		case HPC_CTRL_ENABLE_AUTOCFG:
			hpc_name = "HPC_CTRL_ENABLE_AUTOCFG";
			break;
		case HPC_CTRL_DISABLE_AUTOCFG:
			hpc_name = "HPC_CTRL_DISABLE_AUTOCFG";
			break;
		case HPC_CTRL_GET_BOARD_TYPE:
			hpc_name = "HPC_CTRL_GET_BOARD_TYPE";
			break;
		case HPC_CTRL_GET_SLOT_INFO:
			hpc_name = "HPC_CTRL_GET_SLOT_INFO";
			break;
		case HPC_CTRL_GET_CARD_INFO:
			hpc_name = "HPC_CTRL_GET_CARD_INFO";
			break;
		default: hpc_name = "Unknown"; break;
		}
		cardbus_err(cbp->cb_dip, 7,
		    "cardbus_ioctl: HP Control cmd 0x%x - \"%s\"",
		    hpc_ctrldata.cmd, hpc_name);
}
#endif
		/*
		 * check for valid request:
		 *	1. It is a hotplug slot.
		 */
		if (cbp->slot_handle == NULL) {
			rv = ENXIO;
			break;
		}

		mutex_enter(&cbp->cb_mutex);
		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 = ENXIO;
				break;
			}

			/* get the state of LED information */
			if (hpc_nexus_control(cbp->slot_handle,
			    HPC_CTRL_GET_LED_STATE,
			    (caddr_t)&led_info) != 0) {
				rv = ENXIO;
				break;
			}

			/* copy the led info to the user space */
			if (copyout((void *)&led_info, hpc_ctrldata.data,
			    sizeof (hpc_led_info_t)) != 0) {
				rv = ENXIO;
				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 = ENXIO;
				break;
			}

			/* set the state of an LED */
			if (hpc_nexus_control(cbp->slot_handle,
			    HPC_CTRL_SET_LED_STATE,
			    (caddr_t)&led_info) != 0) {
				rv = ENXIO;
				break;
			}

			break;

		case HPC_CTRL_ENABLE_SLOT:
			/*
			 * Enable the slot for hotplug operations.
			 */
			cbp->disabled = B_FALSE;

			/* tell the HPC driver also */
			(void) hpc_nexus_control(cbp->slot_handle,
				HPC_CTRL_ENABLE_SLOT, NULL);

			break;

		case HPC_CTRL_DISABLE_SLOT:
			/*
			 * Disable the slot for hotplug operations.
			 */
			cbp->disabled = B_TRUE;

			/* tell the HPC driver also */
			(void) hpc_nexus_control(cbp->slot_handle,
				HPC_CTRL_DISABLE_SLOT, NULL);

			break;

		case HPC_CTRL_ENABLE_AUTOCFG:
			/*
			 * Enable auto configuration on this slot.
			 */
			cbp->auto_config = B_TRUE;

			/* tell the HPC driver also */
			(void) hpc_nexus_control(cbp->slot_handle,
				HPC_CTRL_ENABLE_AUTOCFG, NULL);
			break;

		case HPC_CTRL_DISABLE_AUTOCFG:
			/*
			 * Disable auto configuration on this slot.
			 */
			cbp->auto_config = B_FALSE;

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

			break;

		case HPC_CTRL_GET_BOARD_TYPE:
		    {
			hpc_board_type_t board_type;

			/*
			 * Get board type data structure, hpc_board_type_t.
			 */
			if (hpc_nexus_control(cbp->slot_handle,
			    HPC_CTRL_GET_BOARD_TYPE,
			    (caddr_t)&board_type) != 0) {
				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 = 0;
			slot_info.pci_slot_capabilities = 0;
			slot_info.pci_dev_num =
				(uint16_t)AP_MINOR_NUM_TO_CB_INSTANCE(ap_minor);
			(void) strcpy(slot_info.pci_slot_name, cbp->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 = ENXIO;
				break;
			}

			break;
		    }

		case HPC_CTRL_GET_CARD_INFO:
		    {
			hpc_card_info_t card_info;
			ddi_acc_handle_t handle;

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

			if (cbp->card_present == B_FALSE) {
				rv = ENXIO;
				break;
			}
			/* verify that the card is configured */
			if (cbp->ostate != AP_OSTATE_CONFIGURED) {
				/* either the card is not present or */
				/* it is not configured. */
				rv = ENXIO;
				break;
			}

			/* get the information from the PCI config header */
			/* for the function 0. */
			for (child_dip = ddi_get_child(cbp->cb_dip); child_dip;
			    child_dip = ddi_get_next_sibling(child_dip))
				if (strcmp("pcs", ddi_get_name(child_dip)))
					break;

			if (!child_dip) {
				rv = ENXIO;
				break;
			}

			if (pci_config_setup(child_dip, &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 = ENXIO;
				break;
			}

			break;
		    }

		default:
			rv = EINVAL;
			break;
		}

		mutex_exit(&cbp->cb_mutex);
		break;

	default:
		rv = ENOTTY;
	}

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

	cardbus_err(cbp->cb_dip, 7,
	    "cardbus_ioctl: rv = 0x%x", rv);

	return (rv);
}

struct cardbus_pci_desc {
	char	*name;
	ushort_t	offset;
	int	(*cfg_get_func)();
	char	*fmt;
};

#define	CFG_GET(f)	((int(*)())(uintptr_t)f)

static struct cardbus_pci_desc generic_pci_cfg[] = {
	    { "VendorId    =", 0, CFG_GET(pci_config_get16), "%s 0x%04x" },
	    { "DeviceId    =", 2, CFG_GET(pci_config_get16), "%s 0x%04x" },
	    { "Command     =", 4, CFG_GET(pci_config_get16), "%s 0x%04x" },
	    { "Status      =", 6, CFG_GET(pci_config_get16), "%s 0x%04x" },
	    { "Latency     =", 0xd, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "BASE0       =", 0x10, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "BASE1       =", 0x14, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "BASE2       =", 0x18, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "BASE3       =", 0x1c, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "BASE4       =", 0x20, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "CIS Pointer =", 0x28, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "ILINE       =", 0x3c, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "IPIN        =", 0x3d, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { NULL, 0, NULL, NULL }
};

static struct cardbus_pci_desc cardbus_pci_cfg[] = {
	    { "VendorId    =", 0, CFG_GET(pci_config_get16), "%s 0x%04x" },
	    { "DeviceId    =", 2, CFG_GET(pci_config_get16), "%s 0x%04x" },
	    { "Command     =", 4, CFG_GET(pci_config_get16), "%s 0x%04x" },
	    { "Status      =", 6, CFG_GET(pci_config_get16), "%s 0x%04x" },
	    { "CacheLineSz =", 0xc, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "Latency     =", 0xd, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "MemBase Addr=", 0x10, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "Pri Bus     =", 0x18, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "Sec Bus     =", 0x19, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "Sub Bus     =", 0x1a, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "CBus Latency=", 0x1b, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "Mem0 Base   =", 0x1c, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "Mem0 Limit  =", 0x20, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "Mem1 Base   =", 0x24, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "Mem1 Limit  =", 0x28, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "I/O0 Base   =", 0x2c, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "I/O0 Limit  =", 0x30, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "I/O1 Base   =", 0x34, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "I/O1 Limit  =", 0x38, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { "ILINE       =", 0x3c, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "IPIN        =", 0x3d, CFG_GET(pci_config_get8), "%s 0x%02x" },
	    { "Bridge Ctrl =", 0x3e, CFG_GET(pci_config_get16), "%s 0x%04x" },
	    { "Legacy Addr =", 0x44, CFG_GET(pci_config_get32), "%s 0x%08x" },
	    { NULL, 0, NULL, NULL }
};

static void
cardbus_dump(struct cardbus_pci_desc *spcfg, ddi_acc_handle_t handle)
{
	int	i;
	for (i = 0; spcfg[i].name; i++) {

		cmn_err(CE_NOTE, spcfg[i].fmt, spcfg[i].name,
		    spcfg[i].cfg_get_func(handle, spcfg[i].offset));
	}

}

void
cardbus_dump_pci_node(dev_info_t *dip)
{
	dev_info_t *next;
	struct cardbus_pci_desc *spcfg;
	ddi_acc_handle_t config_handle;
	uint32_t VendorId;

	cmn_err(CE_NOTE, "\nPCI leaf node of dip 0x%p:\n", (void *)dip);
	for (next = ddi_get_child(dip); next;
	    next = ddi_get_next_sibling(next)) {

		VendorId = ddi_getprop(DDI_DEV_T_ANY, next,
		    DDI_PROP_CANSLEEP|DDI_PROP_DONTPASS,
		    "vendor-id", -1);
		if (VendorId == -1) {
			/* not a pci device */
			continue;
		}

		if (pci_config_setup(next, &config_handle) != DDI_SUCCESS) {
			cmn_err(CE_WARN, "!pcic child: non pci device\n");
			continue;
		}

		spcfg = generic_pci_cfg;
		cardbus_dump(spcfg, config_handle);
		pci_config_teardown(&config_handle);

	}

}

void
cardbus_dump_pci_config(dev_info_t *dip)
{
	struct cardbus_pci_desc *spcfg;
	ddi_acc_handle_t config_handle;

	if (pci_config_setup(dip, &config_handle) != DDI_SUCCESS) {
		cmn_err(CE_WARN,
		    "!pci_config_setup() failed on 0x%p", (void *)dip);
		return;
	}

	spcfg = cardbus_pci_cfg;
	cardbus_dump(spcfg, config_handle);

	pci_config_teardown(&config_handle);
}

void
cardbus_dump_socket(dev_info_t *dip)
{
	ddi_acc_handle_t	iohandle;
	caddr_t		ioaddr;
	ddi_device_acc_attr_t attr;
	attr.devacc_attr_version = DDI_DEVICE_ATTR_V0;
	attr.devacc_attr_endian_flags = DDI_STRUCTURE_LE_ACC;
	attr.devacc_attr_dataorder = DDI_STRICTORDER_ACC;
	if (ddi_regs_map_setup(dip, 1,
	    (caddr_t *)&ioaddr,
	    0,
	    4096,
	    &attr, &iohandle) != DDI_SUCCESS) {
		cmn_err(CE_WARN, "Failed to map address for 0x%p", (void *)dip);
		return;
	}

	cmn_err(CE_NOTE, "////////////////////////////////////////");
	cmn_err(CE_NOTE, "SOCKET_EVENT  = [0x%x]",
	    ddi_get32(iohandle, (uint32_t *)(ioaddr+CB_STATUS_EVENT)));
	cmn_err(CE_NOTE, "SOCKET_MASK   = [0x%x]",
	    ddi_get32(iohandle, (uint32_t *)(ioaddr+CB_STATUS_MASK)));
	cmn_err(CE_NOTE, "SOCKET_STATE  = [0x%x]",
	    ddi_get32(iohandle, (uint32_t *)(ioaddr+CB_PRESENT_STATE)));
	cmn_err(CE_NOTE, "////////////////////////////////////////");

	ddi_regs_map_free(&iohandle);

}