xref: /illumos-gate/usr/src/uts/common/io/pciex/hotplug/pciehpc.c (revision ead3c390933666e6c332491643357cede94c341e)

/*
 * 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 (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
 * Copyright 2019 Joyent, Inc.
 * Copyright 2024 Oxide Computer Company
 */

/*
 * This file contains Standard PCI Express HotPlug functionality that is
 * compatible with the PCI Express ver 1.1 specification.
 *
 * NOTE: This file is compiled and delivered through misc/pcie module.
 *
 * The main purpose of this is to take the PCIe slot logic, which is found on a
 * PCIe bridge that indicates it is hotplug capable, and map the DDI hotplug
 * controller states to this. This is an imperfect mapping as the definition of
 * the pciehpc_slot_power_t shows. This file assumes that a device can be
 * removed at any time without notice. This is what the spec calls 'surprise
 * removal'.
 *
 * Not all PCIe slots are the same. In particular this can handle the following
 * features which may or may not exist on the slot:
 *
 *  o Power Controllers: With the rise of NVMe based hotplug and the Enterprise
 *    SSD specification, you can have hotplug, but not specific power control
 *    over the device.
 *  o MRL sensor: Manually-operated Retention latches are an optional item and
 *    less common with U.2, E.1, and E.3 based form factors, but there is the
 *    ability to see their state.
 *  o EMI: Electromechanical Interlock. This is used to lock the device in place
 *    and is often paired with an MRL. This similarly isn't as common.
 *  o Attention Button: A button which can be pressed to say please do
 *    something. This is more of a holdover from the world of coordinated
 *    removal from the PCI Standard Hot-Plug Controller (SHPC).
 *  o Power Fault: The ability to tell whether or not a power fault has
 *    occurred.
 *  o Power and Attention Indicators: These are LEDs that are supposed to be
 *    enabled in response to specific actions in the spec, but some of that is
 *    ultimately policy. It's worth noting that not all controllers support both
 *    LEDs and so platforms may want to munge the logical states here a bit
 *    more.
 *
 * There are four primary states that a slot is considered to exist in that
 * roughly have the following state transition diagram:
 *
 *      +-------+
 *      | Empty |<---------------<------------+
 *      +-------+                             |
 *          |                                 |
 * Device   |                                 |
 * Inserted .                                 ^
 *          |                                 |
 *          |                                 |
 *          v                                 |
 *     +---------+                            . . . Device
 *     | Present |<------+                    |     Removed
 *     +---------+       |                    |
 *          |            |                    |
 * Slot     |            |                    |
 * Power  . .            . . Slot Power       |
 * Enabled  |            |   Disabled,        |
 *          |            |   Power Fault,     |
 *          v            |   or specific      |
 *     +---------+       |   request          |
 *     | Powered |-->----+                    |
 *     +---------+       |                    |
 *          |            |                    |
 *          |            |                    |
 * Request  |            ^                    ^
 * or auto- |            |                    |
 * online . *            |                    |
 *          |            |                    |
 *          v            |                    |
 *     +---------+       |                    |
 *     | Enabled |-->----+--------->----------+
 *     +---------+
 *
 * These four states are all related to the DDI_HP_CN_STATE_* values. For
 * example, the empty state above is DDI_HP_CN_STATE_EMPTY and enabled is
 * DDI_HP_CN_STATE_ENABLED. These changes can happen initially because of
 * outside action that is taken or because an explicit state change has been
 * requested via cfgadm/libhotplug. Note that one cannot enter or leave empty
 * without removing or inserting a device.
 *
 * A device node is created in the devinfo tree as a side effect of
 * transitioning to the enabled state and removed when transitioning away from
 * enabled. This is initiated by the DDI hotplug framework making a probe
 * (DDI_HPOP_CN_PROBE) and unprobe (DDI_HPOP_CN_UNPROBE) request which will
 * ultimately get us to pcicfg_configure() which dynamically sets up child
 * nodes.
 *
 * State Initialization
 * --------------------
 *
 * Initializing the state of the world is a bit tricky here. In particular,
 * there are a few things that we need to understand and deal with:
 *
 * 1. A PCIe slot may or may not have been powered prior to us initializing this
 * module. In particular, the PCIe firmware specification generally expects
 * occupied slots to have both their MRL and power indicator match the slot
 * occupancy state (3.5 Device State at Firmware/Operating System Handoff). Of
 * course, we must not assume that firmware has done this or not.
 *
 * This is further complicated by the fact that while the PCIe default is that
 * power is enabled at reset, some controllers require an explicit first write
 * to enact the reset behavior. You cannot do things like enable or disable
 * interrupts without doing a write to the PCIe Slot Control register and
 * turning power on. Those are just the breaks from the spec. The spec also
 * doesn't have a way to tell us if power is actually on or not, we just have to
 * hope. All we can see is if we've commanded power on and if a power fault was
 * detected at some point.
 *
 * 2. Because of (1), the normal platform-specific startup logic for PCIe may or
 * may not have found any devices and initialized them depending on at what
 * state in the initialization point it was at.
 *
 * 3. To actually enumerate a hotplug device, our DDI_HPOP_CN_PROBE entry point
 * needs to be called, which is pciehpc_slot_probe(). This will ultimately call
 * pcicfg_configure(). There is a wrinkle here. If we have done (2), we don't
 * want to call the probe entry point. However, if we haven't, then at start up,
 * the broader hotplug unfortunately, won't assume that there is anything to do
 * here to make this happen. The kernel framework won't call this unless it sees
 * a transition from a lesser state to DDI_HP_CN_STATE_ENABLED.
 *
 * The cases described above are not our only problem. In particular, there are
 * some other complications that happen here. In particular, it's worth
 * understanding how we actually keep all of our state in sync. The core idea is
 * that changes are coming from one of two places: either a user has explicitly
 * requested a state change or we have had external activity that has injected a
 * hotplug interrupt. This is due to something such as a surprise insertion,
 * removal, power fault, or similar activity.
 *
 * The general construction and assumption is that we know the valid state at
 * the moment before an interrupt occurs, so then the slot status register will
 * indicate to us what has changed. Once we know what we should transition to,
 * then we will go ahead and ask the system to make a state change request to
 * change our state to a given target. While this is similar in spirit to what a
 * user could request, they could not imitate a state transition to EMPTY. The
 * transition to EMPTY or to ENABLED is what kicks off the probe and unprobe
 * operations.
 *
 * This system is all well and good, but it is dependent on the fact that we
 * have an interrupt enabled for changes and that the various interrupt cause
 * bits in the slot status register have been cleared as they are generally RW1C
 * (read, write 1 to clear). This means that in addition to the issues with case
 * (1) and what firmware has or hasn't done, it is also possible that additional
 * changes may occur without us recording them or noticing them in an interrupt.
 *
 * This steady state is a great place to be, but because of the races we
 * discussed above, we need to do a bit of additional work here to ensure that
 * we can reliably enter it. As such, we're going to address the three
 * complications above in reverse order. If we start with (3), while in the
 * steady state, we basically treat the DDI states as the main states we can
 * transition to and from (again see the pciehpc_slot_power_t comment for the
 * fact that this is somewhat factious). This means that if we are ENABLED, a
 * probe must have happened (or the semi-equivalent in (2)).
 *
 * Normally, we assume that if we got all the way up and have a powered device
 * that the state we should return to the system is ENABLED. However, that only
 * works if we can ensure that the state transition from less than ENABLED to
 * ENABLED occurs so a probe can occur.
 *
 * This window is made larger because of (1) and (2). However, this is not
 * unique to the ENABLED state and these cases can happen by having a device
 * that was probed at initial time be removed prior to the interrupt being
 * enabled. While this is honestly a very tight window and something that may
 * not happen in practice, it highlights many of the things that can occur and
 * that we need to handle.
 *
 * To deal with this we are a little more careful with our startup state. When
 * we reach our module's main initialization entry point for a given controller,
 * pciehpc_init(), we know that at that point (2) has completed. We also know
 * that the interrupt shouldn't be initiated at that point, but that isn't
 * guaranteed until we finish calling the pciehpc_hpc_init() entry point. We
 * subsequently will enable the interrupt via the enable_phc_intr() function
 * pointer, which is called from pcie_hpintr_enable(). This gap is to allow the
 * overall driver (say pcieb) to ensure that it has allocated and attached
 * interrupts prior to us enabling it.
 *
 * At the point that we are initialized, we can look and see if we have any
 * children. If we do, then we know that (2) performed initialization and it's
 * safe for us to set our initial state to ENABLED and allow that to be the
 * first thing the kernel hotplug framework sees, assuming our state would
 * otherwise suggest we'd be here. If we do not see a child device and we have
 * enabled power, then we basically need to mimic the normal act of having
 * transitioned to an ENABLED state. This needs to happen ahead of us first
 * communicating our state to the DDI.
 *
 * The next set of things we need to do happen when we go to enable interrupts.
 * It's worth keeping in mind that at this point the rest of the system is fully
 * operational. One of three events can be injected at this point, a removal,
 * insertion, or a power fault. We also need to consider that a removal or
 * insertion happened in an intervening point. To make this all happen, let's
 * discuss the different pieces that are involved in tracking what's going on:
 *
 * 1) During pciehpc_slotinfo_init() we check to see if we have a child devinfo
 * node or not. We only mark a node as ENABLED if we have a child and it is
 * already POWERED. This ensures that we aren't ahead of ourselves. The normal
 * state determination logic will not put us at enabled prior to being there.
 *
 * 2) We have added a pair of flags to the pcie_hp_ctrl_t called
 * PCIE_HP_SYNC_PENDING and PCIE_HP_SYNC_RUNNING. The former indicates that we
 * have identified that we need to perform a state correction and have
 * dispatched a task to the system taskq to deal with it. The
 * PCIE_HP_SYNC_RUNNING flag is used to indicate that a state transition request
 * is actually being made due to this right now. This is used to tweak a bit of
 * the slot upgrade path, discussed below.
 *
 * 3) Immediately after enabling interrupts, while still holding the hotplug
 * controller mutex, we investigate what our current state is and what we have
 * previously set it to. Depending on the transition that needs to occur and if
 * it has a side effect of needing to probe or unprobe a connection, then we'll
 * end up scheduling a task in the system taskq to perform that transition.
 * Otherwise, we will simply fix up the LED state as we have no reason to
 * believe that it is currently correct for our state.
 *
 * Using the taskq has a major benefit for us in that it allows us to leverage
 * the existing code paths for state transitions. This means that if things are
 * already powered on and the data link layer is active, there won't be any
 * extra delay and if not, it will honor the same 1s timeout, take advantage of
 * the datalink layer active bit if supported, and on failure it will turn off
 * the controller.
 *
 * 4) We are reliant on an important property of pciehpc_get_slot_state(): if it
 * finds itself in the POWERED state, it will not change from that. This is half
 * of the reason that we opt to go to the POWERED state when this occurs. The
 * other half is that it is factually accurate and doing otherwise would get in
 * the way of our logic which attempts to correct the state in
 * pciehpc_change_slot_state() which corrects for the state being incorrect.
 * While it is tempting to use the PRESENT state and try to avoid a special case
 * in pciehpc_upgrade_slot_state(), that ends up breaking more invariants than
 * the logic described below.
 *
 * 5) Finally, when the PCIE_HP_SYNC_RUNNING bit is set, that tells us when
 * we're doing a power on exercise that we need to do so again regardless of
 * what we think we've done. Because of our attempts to try to have things be
 * idempotent, this ends up being a relatively safe operation to perform again
 * and being able to reuse this helps a lot.
 *
 * It is our hope that after this point everything will be in line such that we
 * can enter the steady state. If devices have come or gone, the use of the
 * normal state machine transitions should allow us to get them to be attached
 * or not.
 *
 * LED Management
 * --------------
 *
 * The PCIe specifications define two LEDs that may optionally exist on a slot:
 * a power LED and an attention LED. In the earliest version of the PCIe
 * specification, these were maintained as device capabilities, but by PCIe 1.1
 * they are solely on the slot. The PCIe specification provides very specific
 * meanings for what these LEDs indicate. However, different systems implement a
 * subset of these LEDs and may not want to use them for the same purposes. The
 * PCIe Native HotPlug defined in S6.7 describes the following roles for each
 * LED (and also defines the colors):
 *
 * POWER	Off:	Device not powered
 *		On:	Device powered
 *		Blink:	Power transition occurring
 *
 * ATTENTION	Off:	Everything's fine, how are you?
 *		On:	There's a problem here.
 *		Blink:	Attention
 *
 * While this is the standard, it's not always the case that everything actually
 * has implemented these, that all platforms want to use the same definitions,
 * or even have both LEDs. The above definitions are strictly meant for hotplug,
 * but one could have LEDs without hotplug (though it's rare). In addition,
 * there are cases that the operating system adds additional semantics as to
 * what the LEDs should mean. For example, while holding the attention button,
 * the power LED blinks, or if probe fails, then we assume that attention should
 * be asserted. Finally, there is the unfortunate reality that many systems
 * which implement a more limited form of Enterprise SSD take away LED
 * management from the OS entirely and it is left entirely up to firmware's
 * druthers (possibly allowing for interaction via IPMI or something similar).
 *
 * The next consideration for LED management is that there is an ability for
 * this to be overridden by userland. For example, there is no first class blink
 * or locate ioctl and instead that is something that is created by an operator
 * using libhotplug or say an FMA topology. This means that the state that we
 * have displayed can be overridden at any time. As such, while libhotplug and
 * other consumers may chance the LED state, we instead think of this as an
 * override. When they are done, they can restore the default behavior and we
 * will figure out what that means.
 *
 * For the most part our LED state can be determined based upon the slot's
 * state. However, there are a few specific transitions that can occur that need
 * to be captured like while we are powering, attention button activity, or
 * probe failures. A particular part of this is what are the lifetimes of these
 * and when should they be cleared out. There is a bunch of complexity here that
 * suggests this subsystem should perhaps be driven more by userland (where it's
 * a bit easier to inject what someone wants). For now, here is how we scope
 * those special cases:
 *
 * POWER FAULT		When a power fault occurs, this normally automatically
 *			causes us to power off the device (if there is a power
 *			controller). As such the only things that clear out a
 *			power fault is another attempt to power on the device
 *			(because we have no way of knowing whether or not it's
 *			still faulted, thanks specs) or until the device is
 *			removed.
 *
 * ATTENTION BUTTON	Pushing the attention button is supposed to cause a five
 *			second timer to begin. This state persists across its
 *			entire lifetime. Once that is done, then it will be
 *			turned off. Unlike other things it is not bound to a
 *			power transition.
 *
 * PROBE FAILURE	This is not a PCIe concept, but something that we do.
 *			This is meant to last until a subsequent attempt to
 *			probe the device occurs, the device is powered off, or
 *			the device is removed. This is different from a power
 *			fault in so far as we honor power off as a transition
 *			point here. This was chosen because powering off
 *			represents an active action to try to and change the
 *			state away from probing, so it no longer serves to blink
 *			the LED because of a probe failure.
 *
 * To deal with this, we have a series of logical LED states that can be enabled
 * which are then evaluated in a preferential ordering that describe what to do
 * for each logical item we want to do. These include things like power
 * transitions, the device being powered, or things like the power fault or
 * probe failing. This is tracked in the slot's hs_led_plat_en[] data structure.
 * Higher states are preferential which is why we work through the states
 * backwards. Each state can opt to take an explicit state or punt to the next.
 *
 * We map the logical state to LED actions through a platform-specific set of
 * definitions. Pretty much everything will use the standard PCIe LED behavior
 * (pciehpc_pcie_std_leds[]), but this can be overridden for particular
 * platforms.
 *
 * Because of our startup races, we defer actually setting the external LED
 * state until we first get through pciehpc_enable_state_sync() or a
 * corresponding state transition that it forces to happen.
 */

#include <sys/types.h>
#include <sys/note.h>
#include <sys/conf.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/vtrace.h>
#include <sys/autoconf.h>
#include <sys/varargs.h>
#include <sys/ddi_impldefs.h>
#include <sys/time.h>
#include <sys/callb.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/sysmacros.h>
#include <sys/sysevent/dr.h>
#include <sys/pci_impl.h>
#include <sys/kstat.h>
#include <sys/zone.h>
#include <sys/hotplug/pci/pcie_hp.h>
#include <sys/hotplug/pci/pciehpc.h>

/* XXX /etc/system is NOT a policy interface */
int pcie_auto_online = 1;

/*
 * Ideally, it would be possible to represent the state of a slot with a single
 * ddi_hp_cn_state_t; after all, that's the purpose of that data type.
 * Unfortunately it wasn't designed very well and cannot even represent the
 * range of possible power states of a PCIe slot.  It is possible for a slot to
 * be powered on or off with or without a device present, and it is possible for
 * a slot not to have a power controller at all.  Finally, it's possible for a
 * power fault to be detected regardless of whether power is on or off or a
 * device is present or not.  This state attempts to represent all possible
 * power states that a slot can have, which is important for implementing our
 * state machine that has to expose only the very limited DDI states.
 *
 * These are bits that may be ORed together.  Not all combinations comply with
 * the standards, but these definitions were chosen to make it harder to
 * construct invalid combinations.  In particular, if there is no controller,
 * there is also no possibility of the slot being turned off, nor is it possible
 * for there to be a fault.
 */
typedef enum pciehpc_slot_power {
	PSP_NO_CONTROLLER = 0,
	PSP_HAS_CONTROLLER = (1U << 0),
	PSP_OFF = (1U << 1),
	PSP_FAULT = (1U << 2)
} pciehpc_slot_power_t;

typedef struct {
	pcie_hp_ctrl_t *pst_ctrl;
	ddi_hp_cn_state_t pst_targ;
	ddi_hp_cn_state_t pst_cur;
} pciehpc_sync_task_t;

static const pciehpc_led_plat_state_t pciehpc_std_leds[PCIEHPC_LED_NSTATES] = {
	[PCIE_LL_BASE] = { PCIE_HLA_OFF, PCIE_HLA_OFF },
	[PCIE_LL_POWER_TRANSITION] = { PCIE_HLA_BLINK, PCIE_HLA_PASS },
	[PCIE_LL_POWERED] = { PCIE_HLA_ON, PCIE_HLA_OFF },
	[PCIE_LL_PROBE_FAILED] = { PCIE_HLA_PASS, PCIE_HLA_ON },
	[PCIE_LL_POWER_FAULT] = { PCIE_HLA_BLINK, PCIE_HLA_PASS },
	[PCIE_LL_ATTENTION_BUTTON] = { PCIE_HLA_BLINK, PCIE_HLA_PASS }
};

/*
 * The Gimlet hardware platform only has a single attention LED that is used for
 * multiple purposes.
 */
static const pciehpc_led_plat_state_t pciehpc_gimlet_leds[PCIEHPC_LED_NSTATES] =
{
	[PCIE_LL_BASE] = { PCIE_HLA_OFF, PCIE_HLA_OFF },
	[PCIE_LL_POWER_TRANSITION] = { PCIE_HLA_PASS, PCIE_HLA_PASS },
	[PCIE_LL_POWERED] = { PCIE_HLA_PASS, PCIE_HLA_ON },
	[PCIE_LL_PROBE_FAILED] = { PCIE_HLA_PASS, PCIE_HLA_BLINK },
	[PCIE_LL_POWER_FAULT] = { PCIE_HLA_PASS, PCIE_HLA_BLINK },
	[PCIE_LL_ATTENTION_BUTTON] = { PCIE_HLA_PASS, PCIE_HLA_PASS }
};

typedef struct pciehpc_led_plat_map {
	uint16_t plpm_vid;
	uint16_t plpm_did;
	uint16_t plpm_svid;
	uint16_t plpm_ssys;
	const pciehpc_led_plat_state_t *plpm_map;
} pciehpc_led_plat_map_t;

/*
 * This table represents platforms that have different values than the default
 * PCIe LED usage that should be applied.
 */
static const pciehpc_led_plat_map_t pciehpc_led_plat_map[] = {
	{ .plpm_vid = 0x1022, .plpm_did = 0x1483, .plpm_svid = 0x1de,
	    .plpm_ssys = 0xfff9, .plpm_map = pciehpc_gimlet_leds }
};

/* Local functions prototype */
static int pciehpc_hpc_init(pcie_hp_ctrl_t *ctrl_p);
static int pciehpc_hpc_uninit(pcie_hp_ctrl_t *ctrl_p);
static int pciehpc_slotinfo_init(pcie_hp_ctrl_t *ctrl_p);
static int pciehpc_slotinfo_uninit(pcie_hp_ctrl_t *ctrl_p);
static int pciehpc_enable_intr(pcie_hp_ctrl_t *ctrl_p);
static int pciehpc_disable_intr(pcie_hp_ctrl_t *ctrl_p);
static pcie_hp_ctrl_t *pciehpc_create_controller(dev_info_t *dip);
static void pciehpc_destroy_controller(dev_info_t *dip);
static int pciehpc_register_slot(pcie_hp_ctrl_t *ctrl_p);
static int pciehpc_unregister_slot(pcie_hp_ctrl_t *ctrl_p);
static int pciehpc_slot_get_property(pcie_hp_slot_t *slot_p,
    uintptr_t arg, uintptr_t rval);
static int pciehpc_slot_set_property(pcie_hp_slot_t *slot_p,
    uintptr_t arg, uintptr_t rval);
static void pciehpc_issue_hpc_command(pcie_hp_ctrl_t *ctrl_p, uint16_t control);
static void pciehpc_attn_btn_handler(pcie_hp_ctrl_t *ctrl_p);
static pcie_hp_led_state_t pciehpc_led_state_to_hpc(uint16_t state);

static int pciehpc_upgrade_slot_state(pcie_hp_slot_t *slot_p,
    ddi_hp_cn_state_t target_state);
static int pciehpc_downgrade_slot_state(pcie_hp_slot_t *slot_p,
    ddi_hp_cn_state_t target_state);
static int pciehpc_change_slot_state(pcie_hp_slot_t *slot_p,
    ddi_hp_cn_state_t target_state);
static int
    pciehpc_slot_poweron(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t *result);
static int
    pciehpc_slot_poweroff(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t *result);
static int pciehpc_slot_probe(pcie_hp_slot_t *slot_p);
static int pciehpc_slot_unprobe(pcie_hp_slot_t *slot_p);
static void pciehpc_handle_power_fault(dev_info_t *dip);
static void pciehpc_power_fault_handler(void *arg);

#ifdef	DEBUG
static void pciehpc_dump_hpregs(pcie_hp_ctrl_t *ctrl_p);
#endif	/* DEBUG */

typedef struct pciehpc_stat_data {
	kstat_named_t psd_attnsw_count;
	kstat_named_t psd_attnsw_ts;
	kstat_named_t psd_pwrflt_count;
	kstat_named_t psd_pwrflt_ts;
	kstat_named_t psd_mrl_chg_count;
	kstat_named_t psd_mrl_chg_ts;
	kstat_named_t psd_pres_chg_count;
	kstat_named_t psd_pres_chg_ts;
	kstat_named_t psd_cmd_cpl_count;
	kstat_named_t psd_cmd_cpl_ts;
	kstat_named_t psd_dll_chg_count;
	kstat_named_t psd_dll_chg_ts;
	kstat_named_t psd_intr_count;
	kstat_named_t psd_intr_ts;
} pciehpc_stat_data_t;

static inline void
pciehpc_kstat_event(kstat_named_t *countp, kstat_named_t *tsp, hrtime_t now)
{
	atomic_inc_64(&countp->value.ui64);
	tsp->value.ui64 = now;
}

#define	KSTAT_EVENT(_slotp, _evname, _now)	\
    pciehpc_kstat_event((&(_slotp)->hs_stat_data->psd_ ## _evname ## _count), \
	(&(_slotp)->hs_stat_data->psd_ ## _evname ## _ts), (_now))

/*
 * Global functions (called by other drivers/modules)
 */

/*
 * Initialize Hot Plug Controller if present. The arguments are:
 *	dip	- devinfo node pointer to the hot plug bus node
 *	regops	- register ops to access HPC registers for non-standard
 *		  HPC hw implementations (e.g: HPC in host PCI-E bridges)
 *		  This is NULL for standard HPC in PCIe bridges.
 * Returns:
 *	DDI_SUCCESS for successful HPC initialization
 *	DDI_FAILURE for errors or if HPC hw not found
 */
int
pciehpc_init(dev_info_t *dip, caddr_t arg)
{
	pcie_hp_regops_t	*regops = (pcie_hp_regops_t *)(void *)arg;
	pcie_hp_ctrl_t		*ctrl_p;

	PCIE_DBG("pciehpc_init() called (dip=%p)\n", (void *)dip);

	/* Make sure that it is not already initialized */
	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) != NULL) {
		PCIE_DBG("%s%d: pciehpc instance already initialized!\n",
		    ddi_driver_name(dip), ddi_get_instance(dip));
		return (DDI_SUCCESS);
	}

	/* Allocate a new hotplug controller and slot structures */
	ctrl_p = pciehpc_create_controller(dip);

	/* setup access handle for HPC regs */
	if (regops != NULL) {
		/* HPC access is non-standard; use the supplied reg ops */
		ctrl_p->hc_regops = *regops;
	}

	/*
	 * Setup resource maps for this bus node.
	 */
	(void) pci_resource_setup(dip);

	PCIE_DISABLE_ERRORS(dip);

	/*
	 * Set the platform specific hot plug mode.
	 */
	ctrl_p->hc_ops.init_hpc_hw = pciehpc_hpc_init;
	ctrl_p->hc_ops.uninit_hpc_hw = pciehpc_hpc_uninit;
	ctrl_p->hc_ops.init_hpc_slotinfo = pciehpc_slotinfo_init;
	ctrl_p->hc_ops.uninit_hpc_slotinfo = pciehpc_slotinfo_uninit;
	ctrl_p->hc_ops.poweron_hpc_slot = pciehpc_slot_poweron;
	ctrl_p->hc_ops.poweroff_hpc_slot = pciehpc_slot_poweroff;

	ctrl_p->hc_ops.enable_hpc_intr = pciehpc_enable_intr;
	ctrl_p->hc_ops.disable_hpc_intr = pciehpc_disable_intr;

#if	defined(__x86)
	pciehpc_update_ops(ctrl_p);
#endif

	/* initialize hot plug controller hw */
	if ((ctrl_p->hc_ops.init_hpc_hw)(ctrl_p) != DDI_SUCCESS)
		goto cleanup1;

	/* initialize slot information soft state structure */
	if ((ctrl_p->hc_ops.init_hpc_slotinfo)(ctrl_p) != DDI_SUCCESS)
		goto cleanup2;

	/* register the hot plug slot with DDI HP framework */
	if (pciehpc_register_slot(ctrl_p) != DDI_SUCCESS)
		goto cleanup3;

	/* create minor node for this slot */
	if (pcie_create_minor_node(ctrl_p, 0) != DDI_SUCCESS)
		goto cleanup4;

	/*
	 * While we disabled errors upon entry, if we were initialized and
	 * entered the ENABLED state that indicates we have children and
	 * therefore we should go back and enable errors.
	 */
	if (ctrl_p->hc_slots[0]->hs_info.cn_state == DDI_HP_CN_STATE_ENABLED) {
		PCIE_ENABLE_ERRORS(dip);
	}

	/* HPC initialization is complete now */
	ctrl_p->hc_flags |= PCIE_HP_INITIALIZED_FLAG;

#ifdef	DEBUG
	/* For debug, dump the HPC registers */
	pciehpc_dump_hpregs(ctrl_p);
#endif	/* DEBUG */

	return (DDI_SUCCESS);
cleanup4:
	(void) pciehpc_unregister_slot(ctrl_p);
cleanup3:
	(void) (ctrl_p->hc_ops.uninit_hpc_slotinfo)(ctrl_p);

cleanup2:
	(void) (ctrl_p->hc_ops.uninit_hpc_hw)(ctrl_p);

cleanup1:
	PCIE_ENABLE_ERRORS(dip);
	(void) pci_resource_destroy(dip);

	pciehpc_destroy_controller(dip);
	return (DDI_FAILURE);
}

/*
 * Uninitialize HPC soft state structure and free up any resources
 * used for the HPC instance.
 */
int
pciehpc_uninit(dev_info_t *dip)
{
	pcie_hp_ctrl_t *ctrl_p;
	taskqid_t id;

	PCIE_DBG("pciehpc_uninit() called (dip=%p)\n", (void *)dip);

	/* get the soft state structure for this dip */
	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL) {
		return (DDI_FAILURE);
	}

	/*
	 * Prior to taking any action, we want to remove the initialized flag.
	 * Any interrupts should have already been quiesced prior to this. There
	 * may be an outstanding startup synchronization timeout(9F) call.
	 */
	mutex_enter(&ctrl_p->hc_mutex);
	ctrl_p->hc_flags &= ~PCIE_HP_INITIALIZED_FLAG;
	id = ctrl_p->hc_startup_sync;
	ctrl_p->hc_startup_sync = TASKQID_INVALID;
	mutex_exit(&ctrl_p->hc_mutex);

	if (id != TASKQID_INVALID)
		taskq_wait_id(system_taskq, id);

	pcie_remove_minor_node(ctrl_p, 0);

	/* unregister the slot */
	(void) pciehpc_unregister_slot(ctrl_p);

	/* uninit any slot info data structures */
	(void) (ctrl_p->hc_ops.uninit_hpc_slotinfo)(ctrl_p);

	/* uninitialize hpc, remove interrupt handler, etc. */
	(void) (ctrl_p->hc_ops.uninit_hpc_hw)(ctrl_p);

	PCIE_ENABLE_ERRORS(dip);

	/*
	 * Destroy resource maps for this bus node.
	 */
	(void) pci_resource_destroy(dip);

	/* destroy the soft state structure */
	pciehpc_destroy_controller(dip);

	return (DDI_SUCCESS);
}

/*
 * pciehpc_intr()
 *
 * Interrupt handler for PCI-E Hot plug controller interrupts.
 *
 * Note: This is only for native mode hot plug. This is called
 * by the nexus driver at interrupt context. Interrupt Service Routine
 * registration is done by the nexus driver for both hot plug and
 * non-hot plug interrupts. This function is called from the ISR
 * of the nexus driver to handle hot-plug interrupts.
 *
 * We must check whether or not we have a pending synchronization event and if
 * so, cancel it. In particular, there are several cases that may cause us to
 * request an asynchronous state transition (e.g. a drive was removed or
 * inserted). When that occurs, we effectively cancel the pending
 * synchronization taskq activity. It will still execute, but do nothing. If it
 * has already started executing, then its state change request will already
 * have been dispatched and we let things shake out with the additional logic we
 * have present in pciehpc_change_slot_state().
 */
int
pciehpc_intr(dev_info_t *dip)
{
	pcie_hp_ctrl_t	*ctrl_p;
	pcie_hp_slot_t	*slot_p;
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);
	uint16_t	status, control;
	boolean_t	clear_pend = B_FALSE;
	hrtime_t	now;

	/* get the soft state structure for this dip */
	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL)
		return (DDI_INTR_UNCLAIMED);

	now = gethrtime();

	mutex_enter(&ctrl_p->hc_mutex);

	/* make sure the controller soft state is initialized */
	if (!(ctrl_p->hc_flags & PCIE_HP_INITIALIZED_FLAG)) {
		mutex_exit(&ctrl_p->hc_mutex);
		return (DDI_INTR_UNCLAIMED);
	}

	/* if it is not NATIVE hot plug mode then return */
	if (bus_p->bus_hp_curr_mode != PCIE_NATIVE_HP_MODE) {
		mutex_exit(&ctrl_p->hc_mutex);
		return (DDI_INTR_UNCLAIMED);
	}

	slot_p = ctrl_p->hc_slots[0];

	/* read the current slot status register */
	status = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS);

	/* check if there are any hot plug interrupts occurred */
	if (!(status & PCIE_SLOTSTS_STATUS_EVENTS)) {
		/* no hot plug events occurred */
		mutex_exit(&ctrl_p->hc_mutex);
		return (DDI_INTR_UNCLAIMED);
	}

	/* We are now committed to claiming the interrupt; record it. */
	KSTAT_EVENT(slot_p, intr, now);

	/* clear the interrupt status bits */
	pciehpc_reg_put16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS, status);

	/* check for CMD COMPLETE interrupt */
	if (status & PCIE_SLOTSTS_COMMAND_COMPLETED) {
		KSTAT_EVENT(slot_p, cmd_cpl, now);
		PCIE_DBG("pciehpc_intr(): CMD COMPLETED interrupt received\n");
		/* wake up any one waiting for Command Completion event */
		cv_signal(&ctrl_p->hc_cmd_comp_cv);
	}

	/* check for ATTN button interrupt */
	if (status & PCIE_SLOTSTS_ATTN_BTN_PRESSED) {
		KSTAT_EVENT(slot_p, attnsw, now);
		PCIE_DBG("pciehpc_intr(): ATTN BUTTON interrupt received\n");

		/* if ATTN button event is still pending then cancel it */
		if (slot_p->hs_attn_btn_pending == B_TRUE)
			slot_p->hs_attn_btn_pending = B_FALSE;
		else
			slot_p->hs_attn_btn_pending = B_TRUE;

		/* wake up the ATTN event handler */
		cv_signal(&slot_p->hs_attn_btn_cv);
	}

	/* check for power fault interrupt */
	if (status & PCIE_SLOTSTS_PWR_FAULT_DETECTED) {
		KSTAT_EVENT(slot_p, pwrflt, now);
		PCIE_DBG("pciehpc_intr(): POWER FAULT interrupt received"
		    " on slot %d\n", slot_p->hs_phy_slot_num);
		control =  pciehpc_reg_get16(ctrl_p,
		    bus_p->bus_pcie_off + PCIE_SLOTCTL);

		if (control & PCIE_SLOTCTL_PWR_FAULT_EN) {
			slot_p->hs_condition = AP_COND_FAILED;

			/* disable power fault detection interrupt */
			pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off +
			    PCIE_SLOTCTL, control & ~PCIE_SLOTCTL_PWR_FAULT_EN);

			pciehpc_handle_power_fault(dip);
			clear_pend = B_TRUE;
		}
	}

	/* check for MRL SENSOR CHANGED interrupt */
	if (status & PCIE_SLOTSTS_MRL_SENSOR_CHANGED) {
		KSTAT_EVENT(slot_p, mrl_chg, now);
		/* For now (phase-I), no action is taken on this event */
		PCIE_DBG("pciehpc_intr(): MRL SENSOR CHANGED interrupt received"
		    " on slot %d\n", slot_p->hs_phy_slot_num);
	}

	/* check for PRESENCE CHANGED interrupt */
	if (status & PCIE_SLOTSTS_PRESENCE_CHANGED) {
		KSTAT_EVENT(slot_p, pres_chg, now);
		PCIE_DBG("pciehpc_intr(): PRESENCE CHANGED interrupt received"
		    " on slot %d\n", slot_p->hs_phy_slot_num);

		if (status & PCIE_SLOTSTS_PRESENCE_DETECTED) {
			ddi_hp_cn_state_t tgt_state = (pcie_auto_online != 0) ?
			    DDI_HP_CN_STATE_ENABLED : DDI_HP_CN_STATE_PRESENT;
			/*
			 * card is inserted into the slot, ask DDI Hotplug
			 * framework to change state to Present.
			 */
			cmn_err(CE_NOTE, "pciehpc (%s%d): card is inserted"
			    " in the slot %s",
			    ddi_driver_name(dip),
			    ddi_get_instance(dip),
			    slot_p->hs_info.cn_name);

			(void) ndi_hp_state_change_req(dip,
			    slot_p->hs_info.cn_name,
			    tgt_state, DDI_HP_REQ_ASYNC);
		} else { /* card is removed from the slot */
			cmn_err(CE_NOTE, "pciehpc (%s%d): card is removed"
			    " from the slot %s",
			    ddi_driver_name(dip),
			    ddi_get_instance(dip),
			    slot_p->hs_info.cn_name);

			if (slot_p->hs_info.cn_state ==
			    DDI_HP_CN_STATE_ENABLED) {
				/* Card is removed when slot is enabled */
				slot_p->hs_condition = AP_COND_FAILED;
			} else {
				slot_p->hs_condition = AP_COND_UNKNOWN;
			}
			/* make sure to disable power fault detction intr */
			control =  pciehpc_reg_get16(ctrl_p,
			    bus_p->bus_pcie_off + PCIE_SLOTCTL);

			if (control & PCIE_SLOTCTL_PWR_FAULT_EN)
				pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off +
				    PCIE_SLOTCTL,
				    control & ~PCIE_SLOTCTL_PWR_FAULT_EN);

			/*
			 * If supported, notify the child device driver that the
			 * device is being removed.
			 */
			dev_info_t *cdip = ddi_get_child(dip);
			if (cdip != NULL) {
				ddi_eventcookie_t rm_cookie;
				if (ddi_get_eventcookie(cdip,
				    DDI_DEVI_REMOVE_EVENT,
				    &rm_cookie) == DDI_SUCCESS) {
					ndi_post_event(dip, cdip, rm_cookie,
					    NULL);
				}
			}

			/*
			 * Ask DDI Hotplug framework to change state to Empty
			 */
			(void) ndi_hp_state_change_req(dip,
			    slot_p->hs_info.cn_name,
			    DDI_HP_CN_STATE_EMPTY,
			    DDI_HP_REQ_ASYNC);
		}

		clear_pend = B_TRUE;
	}

	/* check for DLL state changed interrupt */
	if (ctrl_p->hc_dll_active_rep &&
	    (status & PCIE_SLOTSTS_DLL_STATE_CHANGED)) {
		KSTAT_EVENT(slot_p, dll_chg, now);
		PCIE_DBG("pciehpc_intr(): DLL STATE CHANGED interrupt received"
		    " on slot %d\n", slot_p->hs_phy_slot_num);

		cv_signal(&slot_p->hs_dll_active_cv);
	}

	if (clear_pend) {
		ctrl_p->hc_flags &= ~PCIE_HP_SYNC_PENDING;
	}
	mutex_exit(&ctrl_p->hc_mutex);

	return (DDI_INTR_CLAIMED);
}

/*
 * Handle hotplug commands
 *
 * Note: This function is called by DDI HP framework at kernel context only
 */
int
pciehpc_hp_ops(dev_info_t *dip, char *cn_name, ddi_hp_op_t op,
    void *arg, void *result)
{
	pcie_hp_ctrl_t	*ctrl_p;
	pcie_hp_slot_t	*slot_p;
	int		ret = DDI_SUCCESS;

	PCIE_DBG("pciehpc_hp_ops: dip=%p cn_name=%s op=%x arg=%p\n",
	    dip, cn_name, op, arg);

	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL)
		return (DDI_FAILURE);

	slot_p = ctrl_p->hc_slots[0];

	if (strcmp(cn_name, slot_p->hs_info.cn_name) != 0)
		return (DDI_EINVAL);

	switch (op) {
	case DDI_HPOP_CN_GET_STATE:
	{
		mutex_enter(&slot_p->hs_ctrl->hc_mutex);

		/* get the current slot state */
		pciehpc_get_slot_state(slot_p);

		*((ddi_hp_cn_state_t *)result) = slot_p->hs_info.cn_state;

		mutex_exit(&slot_p->hs_ctrl->hc_mutex);
		break;
	}
	case DDI_HPOP_CN_CHANGE_STATE:
	{
		ddi_hp_cn_state_t target_state = *(ddi_hp_cn_state_t *)arg;

		mutex_enter(&slot_p->hs_ctrl->hc_mutex);

		ret = pciehpc_change_slot_state(slot_p, target_state);
		*(ddi_hp_cn_state_t *)result = slot_p->hs_info.cn_state;

		mutex_exit(&slot_p->hs_ctrl->hc_mutex);
		break;
	}
	case DDI_HPOP_CN_PROBE:

		ret = pciehpc_slot_probe(slot_p);

		break;
	case DDI_HPOP_CN_UNPROBE:
		ret = pciehpc_slot_unprobe(slot_p);

		break;
	case DDI_HPOP_CN_GET_PROPERTY:
		ret = pciehpc_slot_get_property(slot_p, (uintptr_t)arg,
		    (uintptr_t)result);
		break;
	case DDI_HPOP_CN_SET_PROPERTY:
		ret = pciehpc_slot_set_property(slot_p, (uintptr_t)arg,
		    (uintptr_t)result);
		break;
	default:
		ret = DDI_ENOTSUP;
		break;
	}

	return (ret);
}

/*
 * Get the current state of the slot from the hw.
 *
 * The slot state should have been initialized before this function gets called.
 */
void
pciehpc_get_slot_state(pcie_hp_slot_t *slot_p)
{
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uint16_t	control, status;
	ddi_hp_cn_state_t curr_state = slot_p->hs_info.cn_state;

	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));

	/* read the Slot Control Register */
	control = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);

	/*
	 * These LEDs are always set to off because they don't exist. They are
	 * only here because the data structure is shared with the PCI SHPC
	 * logic. We do not pretend to implement it.
	 */
	slot_p->hs_fault_led_state = PCIE_HP_LED_OFF;
	slot_p->hs_active_led_state = PCIE_HP_LED_OFF;

	/* read the current Slot Status Register */
	status = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS);

	/* get POWER led state */
	slot_p->hs_power_led_state =
	    pciehpc_led_state_to_hpc(pcie_slotctl_pwr_indicator_get(control));

	/* get ATTN led state */
	slot_p->hs_attn_led_state =
	    pciehpc_led_state_to_hpc(pcie_slotctl_attn_indicator_get(control));

	if (!(status & PCIE_SLOTSTS_PRESENCE_DETECTED)) {
		/* no device present; slot is empty */
		slot_p->hs_info.cn_state = DDI_HP_CN_STATE_EMPTY;
		return;
	}

	/* device is present */
	slot_p->hs_info.cn_state = DDI_HP_CN_STATE_PRESENT;

	/*
	 * If we have power control and power control is disabled, then we are
	 * merely present. We cannot be POWERED or ENABLED without this being
	 * active.
	 */
	if (ctrl_p->hc_has_pwr && (control & PCIE_SLOTCTL_PWR_CONTROL) != 0) {
		return;
	}

	/*
	 * To be in the ENABLED state that means that we have verified that the
	 * device is ready to be used. This happens at different points in time
	 * right now depending on whether or not we have a power controller and
	 * should be consolidated in the future. Our main constraint is that the
	 * kernel expects that when something is in the ENABLED state that probe
	 * should succeed.
	 *
	 * For devices with a power controller, this is guaranteed as part of
	 * the PRESENT->POWERED transition. For devices without a power
	 * controller, we must assume that power is always applied (the slot
	 * control register bit for power status is undefined). This means that
	 * the POWERED->ENABLED transition point is where this occurs.
	 *
	 * This is all a long way of justifying the logic below. If our current
	 * state is enabled then we will stay in enabled; however, if it is
	 * anything else we will go to powered and allow the normal state
	 * transition to take effect.
	 */
	if (curr_state == DDI_HP_CN_STATE_ENABLED) {
		slot_p->hs_info.cn_state = curr_state;
	} else {
		slot_p->hs_info.cn_state = DDI_HP_CN_STATE_POWERED;
	}
}

/*
 * setup slot name/slot-number info.
 */
void
pciehpc_set_slot_name(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uchar_t		*slotname_data;
	int		*slotnum;
	uint_t		count;
	int		len;
	int		invalid_slotnum = 0;
	uint32_t	slot_capabilities;

	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, ctrl_p->hc_dip,
	    DDI_PROP_DONTPASS, "physical-slot#", &slotnum, &count) ==
	    DDI_PROP_SUCCESS) {
		slot_p->hs_phy_slot_num = slotnum[0];
		ddi_prop_free(slotnum);
	} else {
		slot_capabilities = pciehpc_reg_get32(ctrl_p,
		    bus_p->bus_pcie_off + PCIE_SLOTCAP);
		slot_p->hs_phy_slot_num =
		    PCIE_SLOTCAP_PHY_SLOT_NUM(slot_capabilities);
	}

	/* platform may not have initialized it */
	if (!slot_p->hs_phy_slot_num) {
		PCIE_DBG("%s#%d: Invalid slot number!\n",
		    ddi_driver_name(ctrl_p->hc_dip),
		    ddi_get_instance(ctrl_p->hc_dip));
		slot_p->hs_phy_slot_num = pciehpc_reg_get8(ctrl_p,
		    PCI_BCNF_SECBUS);
		invalid_slotnum = 1;
	}
	slot_p->hs_info.cn_num = slot_p->hs_phy_slot_num;
	slot_p->hs_info.cn_num_dpd_on = DDI_HP_CN_NUM_NONE;

	/*
	 * construct the slot_name:
	 *	if "slot-names" property exists then use that name
	 *	else if valid slot number exists then it is "pcie<slot-num>".
	 *	else it will be "pcie<sec-bus-number>dev0"
	 */
	if (ddi_getlongprop(DDI_DEV_T_ANY, ctrl_p->hc_dip, DDI_PROP_DONTPASS,
	    "slot-names", (caddr_t)&slotname_data, &len) == DDI_PROP_SUCCESS) {
		char tmp_name[256];

		/*
		 * Note: for PCI-E slots, the device number is always 0 so the
		 * first (and only) string is the slot name for this slot.
		 */
		(void) snprintf(tmp_name, sizeof (tmp_name),
		    (char *)slotname_data + 4);
		slot_p->hs_info.cn_name = ddi_strdup(tmp_name, KM_SLEEP);
		kmem_free(slotname_data, len);
	} else {
		if (invalid_slotnum) {
			/* use device number ie. 0 */
			slot_p->hs_info.cn_name = ddi_strdup("pcie0",
			    KM_SLEEP);
		} else {
			char tmp_name[256];

			(void) snprintf(tmp_name, sizeof (tmp_name), "pcie%d",
			    slot_p->hs_phy_slot_num);
			slot_p->hs_info.cn_name = ddi_strdup(tmp_name,
			    KM_SLEEP);
		}
	}
}

/*
 * Read/Write access to HPC registers. If platform nexus has non-standard
 * HPC access mechanism then regops functions are used to do reads/writes.
 */
uint8_t
pciehpc_reg_get8(pcie_hp_ctrl_t *ctrl_p, uint_t off)
{
	if (ctrl_p->hc_regops.get != NULL) {
		return ((uint8_t)ctrl_p->hc_regops.get(
		    ctrl_p->hc_regops.cookie, (off_t)off));
	} else {
		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);

		return (pci_config_get8(bus_p->bus_cfg_hdl, off));
	}
}

uint16_t
pciehpc_reg_get16(pcie_hp_ctrl_t *ctrl_p, uint_t off)
{
	if (ctrl_p->hc_regops.get != NULL) {
		return ((uint16_t)ctrl_p->hc_regops.get(
		    ctrl_p->hc_regops.cookie, (off_t)off));
	} else {
		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);

		return (pci_config_get16(bus_p->bus_cfg_hdl, off));
	}
}

uint32_t
pciehpc_reg_get32(pcie_hp_ctrl_t *ctrl_p, uint_t off)
{
	if (ctrl_p->hc_regops.get != NULL) {
		return ((uint32_t)ctrl_p->hc_regops.get(
		    ctrl_p->hc_regops.cookie, (off_t)off));
	} else {
		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);

		return (pci_config_get32(bus_p->bus_cfg_hdl, off));
	}
}

void
pciehpc_reg_put8(pcie_hp_ctrl_t *ctrl_p, uint_t off, uint8_t val)
{
	if (ctrl_p->hc_regops.put != NULL) {
		ctrl_p->hc_regops.put(ctrl_p->hc_regops.cookie,
		    (off_t)off, (uint_t)val);
	} else {
		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);

		pci_config_put8(bus_p->bus_cfg_hdl, off, val);
	}
}

void
pciehpc_reg_put16(pcie_hp_ctrl_t *ctrl_p, uint_t off, uint16_t val)
{
	if (ctrl_p->hc_regops.put != NULL) {
		ctrl_p->hc_regops.put(ctrl_p->hc_regops.cookie,
		    (off_t)off, (uint_t)val);
	} else {
		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);

		pci_config_put16(bus_p->bus_cfg_hdl, off, val);
	}
}

void
pciehpc_reg_put32(pcie_hp_ctrl_t *ctrl_p, uint_t off, uint32_t val)
{
	if (ctrl_p->hc_regops.put != NULL) {
		ctrl_p->hc_regops.put(ctrl_p->hc_regops.cookie,
		    (off_t)off, (uint_t)val);
	} else {
		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);

		pci_config_put32(bus_p->bus_cfg_hdl, off, val);
	}
}

/*
 * ************************************************************************
 * ***	Local functions (called within this file)
 * ***	PCIe Native Hotplug mode specific functions
 * ************************************************************************
 */

static uint8_t
pciehpc_led_state_to_pcie(pcie_hp_led_state_t state)
{
	switch (state) {
	case PCIE_HP_LED_ON:
		return (PCIE_SLOTCTL_INDICATOR_STATE_ON);
	case PCIE_HP_LED_BLINK:
		return (PCIE_SLOTCTL_INDICATOR_STATE_BLINK);
	case PCIE_HP_LED_OFF:
	default:
		return (PCIE_SLOTCTL_INDICATOR_STATE_OFF);
	}
}

/*
 * This iterates over the logical led states that we have (in descending order)
 * and computes the resulting state that a given LED should have. User overrides
 * are applied elsewhere.
 */
static pcie_hp_led_state_t
pciehpc_calc_logical_led(pcie_hp_slot_t *slot_p, pciehpc_led_plat_id_t led)
{
	pcie_hp_led_state_t ret = PCIE_HP_LED_OFF;

	for (uint_t i = PCIEHPC_LED_NSTATES; i > 0; i--) {
		const uint_t idx = i - 1;
		if (!slot_p->hs_led_plat_en[idx])
			continue;

		switch (slot_p->hs_led_plat_conf[idx].plps_acts[led]) {
		case PCIE_HLA_PASS:
			continue;
		case PCIE_HLA_OFF:
			return (PCIE_HP_LED_OFF);
		case PCIE_HLA_ON:
			return (PCIE_HP_LED_ON);
		case PCIE_HLA_BLINK:
			return (PCIE_HP_LED_BLINK);
		}
	}

	return (ret);
}

static void
pciehpc_sync_leds_to_hw(pcie_hp_slot_t *slot_p)
{
	pcie_hp_led_state_t	power, attn;
	uint16_t		orig_ctrl, ctrl;
	pcie_hp_ctrl_t		*ctrl_p = slot_p->hs_ctrl;
	pcie_bus_t		*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);

	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));


	if (slot_p->hs_power_usr_ovr) {
		power = slot_p->hs_power_usr_ovr_state;
	} else {
		power = pciehpc_calc_logical_led(slot_p, PCIEHPC_PLAT_ID_POWER);
	}

	if (slot_p->hs_attn_usr_ovr) {
		attn = slot_p->hs_attn_usr_ovr_state;
	} else {
		attn = pciehpc_calc_logical_led(slot_p, PCIEHPC_PLAT_ID_ATTN);
	}

	slot_p->hs_power_led_state = power;
	slot_p->hs_attn_led_state = attn;
	orig_ctrl = ctrl = pciehpc_reg_get16(ctrl_p, bus_p->bus_pcie_off +
	    PCIE_SLOTCTL);

	ctrl = pcie_slotctl_attn_indicator_set(ctrl,
	    pciehpc_led_state_to_pcie(attn));
	ctrl = pcie_slotctl_pwr_indicator_set(ctrl,
	    pciehpc_led_state_to_pcie(power));
	if (orig_ctrl != ctrl) {
		pciehpc_issue_hpc_command(ctrl_p, ctrl);
	}
}

/*
 * Initialize HPC hardware, install interrupt handler, etc. It doesn't
 * enable hot plug interrupts.
 *
 * (Note: It is called only from pciehpc_init().)
 */
static int
pciehpc_hpc_init(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uint16_t	reg;

	/* read the Slot Control Register */
	reg = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);

	/* disable all interrupts */
	reg &= ~(PCIE_SLOTCTL_INTR_MASK);
	pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off +
	    PCIE_SLOTCTL, reg);

	/* clear any interrupt status bits */
	reg = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
	pciehpc_reg_put16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS, reg);

	return (DDI_SUCCESS);
}

/*
 * Uninitialize HPC hardware, uninstall interrupt handler, etc.
 *
 * (Note: It is called only from pciehpc_uninit().)
 */
static int
pciehpc_hpc_uninit(pcie_hp_ctrl_t *ctrl_p)
{
	/* disable interrupts */
	(void) pciehpc_disable_intr(ctrl_p);

	return (DDI_SUCCESS);
}

/*
 * Initialize the PCIe LED tracking and policy.
 */
void
pciehpc_led_init(pcie_hp_slot_t *slot_p)
{
	int vid, did, subvid, subsys;
	pcie_hp_ctrl_t *ctrl_p = slot_p->hs_ctrl;

	slot_p->hs_power_usr_ovr = false;
	slot_p->hs_attn_usr_ovr = false;
	slot_p->hs_power_usr_ovr_state = PCIE_HP_LED_OFF;
	slot_p->hs_attn_usr_ovr_state = PCIE_HP_LED_OFF;
	bzero(slot_p->hs_led_plat_en, sizeof (slot_p->hs_led_plat_en));

	slot_p->hs_led_plat_conf = pciehpc_std_leds;

	vid = ddi_prop_get_int(DDI_DEV_T_ANY, ctrl_p->hc_dip, DDI_PROP_DONTPASS,
	    "vendor-id", PCI_EINVAL16);
	did = ddi_prop_get_int(DDI_DEV_T_ANY, ctrl_p->hc_dip, DDI_PROP_DONTPASS,
	    "device-id", PCI_EINVAL16);
	subvid = ddi_prop_get_int(DDI_DEV_T_ANY, ctrl_p->hc_dip,
	    DDI_PROP_DONTPASS, "subsystem-vendor-id", PCI_EINVAL16);
	subsys = ddi_prop_get_int(DDI_DEV_T_ANY, ctrl_p->hc_dip,
	    DDI_PROP_DONTPASS, "subsystem-id", PCI_EINVAL16);
	for (size_t i = 0; i < ARRAY_SIZE(pciehpc_led_plat_map); i++) {
		if (vid == pciehpc_led_plat_map[i].plpm_vid &&
		    did == pciehpc_led_plat_map[i].plpm_did &&
		    subvid == pciehpc_led_plat_map[i].plpm_svid &&
		    subsys == pciehpc_led_plat_map[i].plpm_ssys) {
			slot_p->hs_led_plat_conf =
			    pciehpc_led_plat_map[i].plpm_map;
			break;
		}
	}

	/*
	 * Finally, enable the base state for the slot which is meant to always
	 * be true. We'll catch up the rest of the states when we get the slot
	 * state there.
	 */
	slot_p->hs_led_plat_en[PCIE_LL_BASE] = true;
}

bool
pciehpc_slot_kstat_init(pcie_hp_slot_t *slot_p)
{
	/*
	 * Many if not most PCs have firmware bugs that cause multiple slots to
	 * end up with the same physical slot number in the slot cap register.
	 * This is a clear and direct violation of PCIe4 7.5.3.9, but that
	 * doesn't seem to matter to the people who write firmware.  This is
	 * going to end up confusing the hotplug subsystem and the time to deal
	 * with it is probably before we arrive here, but in order to avoid
	 * additional warning messages during boot on such machines, we will use
	 * the hotplug-capable bridge's instance number when creating event
	 * counter kstats instead of hs_phy_slot_num (or hs_info.cn_num, which
	 * is usually the same).  In the unlikely event that the broken firmware
	 * has given us unique names (even if not slot numbers) for a slot,
	 * we'll still have a unique name for each kstat, just as we will for
	 * each AP.  Otherwise the kstat names will at least match the still
	 * possibly duplicated AP names.
	 */
	int inst = ddi_get_instance(slot_p->hs_ctrl->hc_dip);

	/*
	 * Although the interrupts we are counting are generated by the hotplug
	 * controller, they are conceptually associated with the slot so we
	 * store them with it.  The PCIe hotplug controller as currently defined
	 * supports only a single slot (0), but in principle a future controller
	 * might support multiple slots and we would have some way of
	 * determining the set of events that have been detected for each slot
	 * even the state changes for all slots share a single interrupt.
	 *
	 * The statistics are persistent because we want to keep counting them
	 * over the entire lifetime of this kernel; if the slot's occupant is
	 * removed and that leads to pciehpc_uninit() being called, we don't
	 * want to lose the previous statistics.  Indeed, observing what led up
	 * to such an event is a key purpose of this infrastructure.
	 */
	slot_p->hs_kstat = kstat_create_zone("pcie", inst,
	    slot_p->hs_info.cn_name, "controller", KSTAT_TYPE_NAMED,
	    sizeof (pciehpc_stat_data_t) / sizeof (kstat_named_t),
	    KSTAT_FLAG_PERSISTENT, GLOBAL_ZONEID);

	if (slot_p->hs_kstat == NULL) {
		PCIE_DBG("pciehpc_slot_kstat_init: %d:%s kstat_create failed",
		    inst, slot_p->hs_info.cn_name);
		return (false);
	}

	slot_p->hs_stat_data = (pciehpc_stat_data_t *)slot_p->hs_kstat->ks_data;

	/*
	 * We would like to report only the set of kstats that correspond to the
	 * events for which the controller advertises support.  However, it is
	 * possible for a buggy controller to set status bits that correspond to
	 * bits that aren't set in the capabilities register.  If this were to
	 * occur, we'll still increment the counters and the kstat framework
	 * doesn't really guarantee that we're allowed to do so.  Therefore we
	 * will initialise all the counters, even those that should not or
	 * cannot have meaningful values for this slot.
	 */
	kstat_named_init(&slot_p->hs_stat_data->psd_attnsw_count,
	    "attention_switch_count", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_attnsw_ts,
	    "attention_switch_ts", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_pwrflt_count,
	    "power_fault_count", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_pwrflt_ts,
	    "power_fault_ts", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_mrl_chg_count,
	    "mrl_change_count", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_mrl_chg_ts,
	    "mrl_change_ts", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_pres_chg_count,
	    "presence_change_count", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_pres_chg_ts,
	    "presence_change_ts", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_cmd_cpl_count,
	    "command_completion_count", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_cmd_cpl_ts,
	    "command_completion_ts", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_dll_chg_count,
	    "dll_active_change_count", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_dll_chg_ts,
	    "dll_active_change_ts", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_intr_count,
	    "interrupt_count", KSTAT_DATA_UINT64);
	kstat_named_init(&slot_p->hs_stat_data->psd_intr_ts,
	    "interrupt_ts", KSTAT_DATA_UINT64);

	kstat_install(slot_p->hs_kstat);

	return (true);
}

/*
 * Setup slot information for use with DDI HP framework. Per the theory
 * statement, this is where we need to go through and look at whether or not we
 * have a child and whether or not we want the 1s later timeout to get things
 * into a reasonable state.
 */
static int
pciehpc_slotinfo_init(pcie_hp_ctrl_t *ctrl_p)
{
	uint32_t	slot_capabilities, link_capabilities;
	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	boolean_t	have_child;

	/*
	 * First we look to see if we have any children at all. If we do, then
	 * we assume that things were initialized prior to our existence as
	 * discussed by state initialization (2).
	 */
	ndi_devi_enter(ctrl_p->hc_dip);
	have_child = ddi_get_child(ctrl_p->hc_dip) != NULL;
	ndi_devi_exit(ctrl_p->hc_dip);

	/*
	 * There's no expectation for two threads to be here at the same time:
	 * we arrive here through the attach path and the DDI guarantees
	 * exclusion.  We take the mutex because some of the functions we call
	 * assert that we have it.
	 */
	mutex_enter(&ctrl_p->hc_mutex);
	/*
	 * setup DDI HP framework slot information structure
	 */
	slot_p->hs_device_num = 0;

	slot_p->hs_info.cn_type = DDI_HP_CN_TYPE_PCIE;
	slot_p->hs_info.cn_type_str = (ctrl_p->hc_regops.get == NULL) ?
	    PCIE_NATIVE_HP_TYPE : PCIE_PROP_HP_TYPE;
	slot_p->hs_info.cn_child = NULL;

	slot_p->hs_minor =
	    PCI_MINOR_NUM(ddi_get_instance(ctrl_p->hc_dip),
	    slot_p->hs_device_num);
	slot_p->hs_condition = AP_COND_UNKNOWN;

	/* read Slot Capabilities Register */
	slot_capabilities = pciehpc_reg_get32(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCAP);

	/* set slot-name/slot-number info */
	pciehpc_set_slot_name(ctrl_p);

	/* check if Attn Button present */
	ctrl_p->hc_has_attn = (slot_capabilities & PCIE_SLOTCAP_ATTN_BUTTON) ?
	    B_TRUE : B_FALSE;

	/* check if Manual Retention Latch sensor present */
	ctrl_p->hc_has_mrl = (slot_capabilities & PCIE_SLOTCAP_MRL_SENSOR) ?
	    B_TRUE : B_FALSE;

	/*
	 * Contrary to what one might expect, not all systems actually have
	 * power control despite having hot-swap capabilities. This is most
	 * commonly due to the Enterprise SSD specification which doesn't call
	 * for power-control in the PCIe native hotplug implementation.
	 */
	ctrl_p->hc_has_pwr = (slot_capabilities &
	    PCIE_SLOTCAP_POWER_CONTROLLER) ? B_TRUE: B_FALSE;

	/*
	 * PCI-E version 1.1 defines EMI Lock Present bit
	 * in Slot Capabilities register. Check for it.
	 */
	ctrl_p->hc_has_emi_lock = (slot_capabilities &
	    PCIE_SLOTCAP_EMI_LOCK_PRESENT) ? B_TRUE : B_FALSE;

	link_capabilities = pciehpc_reg_get32(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_LINKCAP);
	ctrl_p->hc_dll_active_rep = (link_capabilities &
	    PCIE_LINKCAP_DLL_ACTIVE_REP_CAPABLE) ? B_TRUE : B_FALSE;
	if (ctrl_p->hc_dll_active_rep)
		cv_init(&slot_p->hs_dll_active_cv, NULL, CV_DRIVER, NULL);

	/* setup thread for handling ATTN button events */
	if (ctrl_p->hc_has_attn) {
		PCIE_DBG("pciehpc_slotinfo_init: setting up ATTN button event "
		    "handler thread for slot %d\n", slot_p->hs_phy_slot_num);

		cv_init(&slot_p->hs_attn_btn_cv, NULL, CV_DRIVER, NULL);
		slot_p->hs_attn_btn_pending = B_FALSE;
		slot_p->hs_attn_btn_threadp = thread_create(NULL, 0,
		    pciehpc_attn_btn_handler,
		    (void *)ctrl_p, 0, &p0, TS_RUN, minclsyspri);
		slot_p->hs_attn_btn_thread_exit = B_FALSE;
	}

	/*
	 * Initialize our LED state tracking.
	 */
	pciehpc_led_init(slot_p);

	/* get current slot state from the hw */
	slot_p->hs_info.cn_state = DDI_HP_CN_STATE_EMPTY;
	pciehpc_get_slot_state(slot_p);

	/*
	 * If the kernel has enumerated a device, note that we have performed
	 * the enabled transition.
	 */
	if (slot_p->hs_info.cn_state == DDI_HP_CN_STATE_POWERED &&
	    have_child) {
		slot_p->hs_info.cn_state = DDI_HP_CN_STATE_ENABLED;
	}

	if (slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_POWERED)
		slot_p->hs_led_plat_en[PCIE_LL_POWERED] = true;

	if (slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_ENABLED)
		slot_p->hs_condition = AP_COND_OK;
	mutex_exit(&ctrl_p->hc_mutex);

	if (!pciehpc_slot_kstat_init(slot_p)) {
		(void) pciehpc_slotinfo_uninit(ctrl_p);
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

void
pciehpc_slot_kstat_fini(pcie_hp_slot_t *slot_p)
{
	if (slot_p->hs_kstat != NULL) {
		kstat_delete(slot_p->hs_kstat);
		slot_p->hs_kstat = NULL;
		slot_p->hs_stat_data = NULL;
	}
}

static int
pciehpc_slotinfo_uninit(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_hp_slot_t *slot_p = ctrl_p->hc_slots[0];

	if (slot_p->hs_attn_btn_threadp != NULL) {
		mutex_enter(&ctrl_p->hc_mutex);
		slot_p->hs_attn_btn_thread_exit = B_TRUE;
		cv_signal(&slot_p->hs_attn_btn_cv);
		PCIE_DBG("pciehpc_slotinfo_uninit: "
		    "waiting for ATTN thread exit\n");
		cv_wait(&slot_p->hs_attn_btn_cv, &ctrl_p->hc_mutex);
		PCIE_DBG("pciehpc_slotinfo_uninit: ATTN thread exit\n");
		cv_destroy(&slot_p->hs_attn_btn_cv);
		slot_p->hs_attn_btn_threadp = NULL;
		mutex_exit(&ctrl_p->hc_mutex);
	}

	if (ctrl_p->hc_dll_active_rep)
		cv_destroy(&slot_p->hs_dll_active_cv);
	if (slot_p->hs_info.cn_name)
		kmem_free(slot_p->hs_info.cn_name,
		    strlen(slot_p->hs_info.cn_name) + 1);

	pciehpc_slot_kstat_fini(slot_p);

	return (DDI_SUCCESS);
}

/*
 * This is the synchronization function that is discussed in the 'State
 * Initialization' portion of the theory statement in this file. It is
 * responsible for trying to make sure that devices are in a usable state during
 * a potentially turbulent start up sequence.
 */
static void
pciehpc_state_sync(void *arg)
{
	pciehpc_sync_task_t *sync = arg;
	pcie_hp_ctrl_t *ctrl_p = sync->pst_ctrl;
	dev_info_t *dip = ctrl_p->hc_dip;
	pcie_hp_slot_t *slot_p = ctrl_p->hc_slots[0];

	mutex_enter(&ctrl_p->hc_mutex);
	if (ctrl_p->hc_startup_sync == TASKQID_INVALID) {
		mutex_exit(&ctrl_p->hc_mutex);
		kmem_free(sync, sizeof (pciehpc_sync_task_t));
		return;
	}

	if ((ctrl_p->hc_flags & PCIE_HP_SYNC_PENDING) == 0) {
		goto done;
	}

	cmn_err(CE_NOTE, "pciehpc (%s%d): synchronizing state in slot %s to "
	    "0x%x", ddi_driver_name(dip), ddi_get_instance(dip),
	    slot_p->hs_info.cn_name, sync->pst_targ);

	ASSERT3U(slot_p->hs_info.cn_state, ==, sync->pst_cur);

	ctrl_p->hc_flags &= ~PCIE_HP_SYNC_PENDING;
	ctrl_p->hc_flags |= PCIE_HP_SYNC_RUNNING;
	mutex_exit(&ctrl_p->hc_mutex);

	(void) ndi_hp_state_change_req(dip, slot_p->hs_info.cn_name,
	    sync->pst_targ, DDI_HP_REQ_SYNC);

	/*
	 * Now that we're done with operating this way, go ahead and clear
	 * things up.
	 */
	mutex_enter(&ctrl_p->hc_mutex);
done:
	ctrl_p->hc_flags &= ~PCIE_HP_SYNC_RUNNING;
	ctrl_p->hc_startup_sync = TASKQID_INVALID;
	mutex_exit(&ctrl_p->hc_mutex);
	kmem_free(sync, sizeof (pciehpc_sync_task_t));
}

static void
pciehpc_dispatch_state_sync(pcie_hp_ctrl_t *ctrl_p, ddi_hp_cn_state_t targ)
{
	pciehpc_sync_task_t *sync;
	pcie_hp_slot_t *slot_p = ctrl_p->hc_slots[0];

	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));
	sync = kmem_alloc(sizeof (pciehpc_sync_task_t), KM_SLEEP);
	sync->pst_ctrl = ctrl_p;
	sync->pst_targ = targ;
	sync->pst_cur = slot_p->hs_info.cn_state;

	ctrl_p->hc_flags |= PCIE_HP_SYNC_PENDING;
	ctrl_p->hc_startup_sync = taskq_dispatch(system_taskq,
	    pciehpc_state_sync, sync, TQ_SLEEP);
}

/*
 * The point of this is to forcibly set the logical LED states to the
 * corresponding ones that make sense for the corresponding hotplug state.
 */
static void
pciehpc_enable_state_sync_leds(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_hp_slot_t *slot_p = ctrl_p->hc_slots[0];
	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));

	bzero(slot_p->hs_led_plat_en, sizeof (slot_p->hs_led_plat_en));

	switch (slot_p->hs_info.cn_state) {
	case DDI_HP_CN_STATE_ENABLED:
	case DDI_HP_CN_STATE_POWERED:
		slot_p->hs_led_plat_en[PCIE_LL_POWERED] = true;
		slot_p->hs_led_plat_en[PCIE_LL_BASE] = true;
		break;
	case DDI_HP_CN_STATE_PRESENT:
	case DDI_HP_CN_STATE_EMPTY:
		slot_p->hs_led_plat_en[PCIE_LL_BASE] = true;
		break;
	default:
		dev_err(ctrl_p->hc_dip, CE_PANIC, "encountered invalid "
		    "connector state: 0x%x", slot_p->hs_info.cn_state);
		break;
	}

	pciehpc_sync_leds_to_hw(slot_p);
}

/*
 * We have just enabled interrupts and cleared any changes that may or may not
 * have been valid from the hardware perspective. There are a few key
 * assumptions that we're making right now as discussed in the theory statement:
 *
 *  o If we are currently enabled, then we know that we have children and
 *    nothing has changed from our init.
 *  o Because we have just enabled interrupts, but have not relinquished our
 *    exclusion on the controller hardware, nothing else could have come in and
 *    started reacting to an actual change.
 *  o Even though someone could come and call DDI_HPOP_CN_GET_STATE, that could
 *    not transition us to enabled yet.
 *  o Because interrupt enable is still called in attach context, we cannot have
 *    a user accessing the node and requesting a state change.
 *
 * Finally there are a few things that we need to be mindful of. We must set any
 * updates to the state prior to calling into any request to update the LED
 * state as that may rely on getting an async callback.
 */
static void
pciehpc_enable_state_sync(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_bus_t *bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	pcie_hp_slot_t *slot_p = ctrl_p->hc_slots[0];
	uint16_t control, status;
	ddi_hp_cn_state_t curr_state, online_targ;

	online_targ = (pcie_auto_online != 0) ?  DDI_HP_CN_STATE_ENABLED :
	    DDI_HP_CN_STATE_PRESENT;
	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));

	/*
	 * We manually compute the status from a single read of things rather
	 * than go through and use pciehpc_get_slot_state(). This is important
	 * to make sure that we can get hardware in sync with the kernel.
	 */
	curr_state = slot_p->hs_info.cn_state;
	control = pciehpc_reg_get16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTCTL);
	status = pciehpc_reg_get16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTSTS);

	if (!(status & PCIE_SLOTSTS_PRESENCE_DETECTED)) {
		switch (curr_state) {
		case DDI_HP_CN_STATE_ENABLED:
			pciehpc_dispatch_state_sync(ctrl_p,
			    DDI_HP_CN_STATE_EMPTY);
			break;
		case DDI_HP_CN_STATE_EMPTY:
		case DDI_HP_CN_STATE_PRESENT:
		case DDI_HP_CN_STATE_POWERED:
			if (ctrl_p->hc_has_pwr &&
			    (control & PCIE_SLOTCTL_PWR_CONTROL) == 0) {
				slot_p->hs_info.cn_state =
				    DDI_HP_CN_STATE_POWERED;
				pciehpc_dispatch_state_sync(ctrl_p,
				    DDI_HP_CN_STATE_EMPTY);
			} else {
				slot_p->hs_info.cn_state =
				    DDI_HP_CN_STATE_EMPTY;
				pciehpc_enable_state_sync_leds(ctrl_p);
			}
			break;
		default:
			dev_err(ctrl_p->hc_dip, CE_PANIC, "encountered invalid "
			    "connector state: 0x%x", curr_state);
			break;
		}

		return;
	}

	/*
	 * If we don't have a power controller, don't bother looking at this.
	 * There's nothing we can really do and we'll let the main case attempt
	 * to online this.
	 */
	if (ctrl_p->hc_has_pwr && (control & PCIE_SLOTCTL_PWR_CONTROL) != 0) {
		switch (curr_state) {
		case DDI_HP_CN_STATE_EMPTY:
			pciehpc_dispatch_state_sync(ctrl_p, online_targ);
			break;
		case DDI_HP_CN_STATE_PRESENT:
			if (curr_state == online_targ) {
				pciehpc_enable_state_sync_leds(ctrl_p);
				break;
			}
			pciehpc_dispatch_state_sync(ctrl_p, online_targ);
			break;
		case DDI_HP_CN_STATE_POWERED:
			dev_err(ctrl_p->hc_dip, CE_WARN, "device powered off "
			    "somehow from prior powered state, attempting "
			    "recovery");
			slot_p->hs_info.cn_state = DDI_HP_CN_STATE_PRESENT;
			if (online_targ > DDI_HP_CN_STATE_PRESENT) {
				pciehpc_dispatch_state_sync(ctrl_p,
				    online_targ);
			} else {
				pciehpc_enable_state_sync_leds(ctrl_p);
			}
			break;
		case DDI_HP_CN_STATE_ENABLED:
			/*
			 * This case seems very strange. We had a device that we
			 * enumerated and was online and something that wasn't
			 * us powerd off the slot. This is possibly a
			 * recoverable state, but it seems hard to understand
			 * what the proper path to go here is. While we could
			 * try to unprobe it, it's a real mystery how that
			 * happened and even that path might not be safe. If
			 * this kind of state is actually encountered in the
			 * wild and during this startup window of the device,
			 * then we'll need to figure out how to handle it there.
			 * Odds are it's either a software bug in this driver or
			 * something is going very wrong with hardware and as
			 * such, it's hard to predict what the solution is.
			 */
			dev_err(ctrl_p->hc_dip, CE_PANIC, "device powered off "
			    "somehow from prior enabled state unable to "
			    "recover");
			break;
		default:
			dev_err(ctrl_p->hc_dip, CE_PANIC, "encountered invalid "
			    "connector state: 0x%x", curr_state);
		}
		return;
	}

	/*
	 * While we should consider checking for a power fault here, if it was
	 * injected just after we cleared everythign as part of interrupt
	 * enable, then we'll get that injected normally and allow that to
	 * happen naturally.
	 */

	switch (curr_state) {
	case DDI_HP_CN_STATE_ENABLED:
		pciehpc_enable_state_sync_leds(ctrl_p);
		break;
	case DDI_HP_CN_STATE_POWERED:
	case DDI_HP_CN_STATE_EMPTY:
	case DDI_HP_CN_STATE_PRESENT:
		if (curr_state == online_targ) {
			pciehpc_enable_state_sync_leds(ctrl_p);
		} else {
			pciehpc_dispatch_state_sync(ctrl_p, online_targ);
		}
		break;
	default:
		dev_err(ctrl_p->hc_dip, CE_PANIC, "encountered invalid "
		    "connector state: 0x%x", curr_state);
	}
}

/*
 * Enable hot plug interrupts.
 * Note: this is only for Native hot plug mode.
 */
static int
pciehpc_enable_intr(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uint16_t	reg;
	uint16_t	intr_mask = PCIE_SLOTCTL_INTR_MASK;

	mutex_enter(&ctrl_p->hc_mutex);

	/*
	 * power fault detection interrupt is enabled only
	 * when the slot is powered ON
	 */
	if (slot_p->hs_info.cn_state < DDI_HP_CN_STATE_POWERED)
		intr_mask &= ~PCIE_SLOTCTL_PWR_FAULT_EN;

	/*
	 * enable interrupt sources but leave the top-level
	 * interrupt disabled. some sources may generate a
	 * spurrious event when they are first enabled.
	 * by leaving the top-level interrupt disabled, those
	 * can be cleared first.
	 */
	reg = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
	pciehpc_reg_put16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL,
	    reg | (intr_mask & ~PCIE_SLOTCTL_HP_INTR_EN));

	/* clear any interrupt status bits */
	reg = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
	pciehpc_reg_put16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS, reg);

	/* enable top-level interrupt */
	reg = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
	pciehpc_reg_put16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL,
	    reg | intr_mask);

	/*
	 * Now, and only now that interrupts are enabled can we go back and
	 * perform state synchronization that is required of the system. This
	 * happens in a few steps. We have previously checked to see if we
	 * should be in the ENABLED or POWERED state. However, it is quite
	 * possible that hardware was left at its PCIe default of power being
	 * enabled, even if no device is present. Because we have interrupts
	 * enabled, if there is a change after this point, then it will be
	 * caught. See the theory statement for more information.
	 */
	pciehpc_enable_state_sync(ctrl_p);
	mutex_exit(&ctrl_p->hc_mutex);

	return (DDI_SUCCESS);
}

/*
 * Disable hot plug interrupts.
 * Note: this is only for Native hot plug mode.
 */
static int
pciehpc_disable_intr(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uint16_t	reg;

	/* read the Slot Control Register */
	reg = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);

	/* disable all interrupts */
	reg &= ~(PCIE_SLOTCTL_INTR_MASK);
	pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTCTL, reg);

	/* clear any interrupt status bits */
	reg = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
	pciehpc_reg_put16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS, reg);

	return (DDI_SUCCESS);
}

/*
 * Allocate a new hotplug controller and slot structures for HPC
 * associated with this dip.
 */
static pcie_hp_ctrl_t *
pciehpc_create_controller(dev_info_t *dip)
{
	pcie_hp_ctrl_t	*ctrl_p;
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);

	ctrl_p = kmem_zalloc(sizeof (pcie_hp_ctrl_t), KM_SLEEP);
	ctrl_p->hc_dip = dip;

	/* Allocate a new slot structure. */
	ctrl_p->hc_slots[0] = kmem_zalloc(sizeof (pcie_hp_slot_t), KM_SLEEP);
	ctrl_p->hc_slots[0]->hs_num = 0;
	ctrl_p->hc_slots[0]->hs_ctrl = ctrl_p;

	/* Initialize the interrupt mutex */
	mutex_init(&ctrl_p->hc_mutex, NULL, MUTEX_DRIVER,
	    (void *)PCIE_INTR_PRI);

	/* Initialize synchronization conditional variable */
	cv_init(&ctrl_p->hc_cmd_comp_cv, NULL, CV_DRIVER, NULL);
	ctrl_p->hc_cmd_pending = B_FALSE;

	bus_p->bus_hp_curr_mode = PCIE_NATIVE_HP_MODE;
	PCIE_SET_HP_CTRL(dip, ctrl_p);

	return (ctrl_p);
}

/*
 * Remove the HPC controller and slot structures
 */
static void
pciehpc_destroy_controller(dev_info_t *dip)
{
	pcie_hp_ctrl_t	*ctrl_p;
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);

	/* get the soft state structure for this dip */
	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL)
		return;

	PCIE_SET_HP_CTRL(dip, NULL);
	bus_p->bus_hp_curr_mode = PCIE_NONE_HP_MODE;

	mutex_destroy(&ctrl_p->hc_mutex);
	cv_destroy(&ctrl_p->hc_cmd_comp_cv);
	kmem_free(ctrl_p->hc_slots[0], sizeof (pcie_hp_slot_t));
	kmem_free(ctrl_p, sizeof (pcie_hp_ctrl_t));
}

/*
 * Register the PCI-E hot plug slot with DDI HP framework.
 */
static int
pciehpc_register_slot(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
	dev_info_t	*dip = ctrl_p->hc_dip;

	/* register the slot with DDI HP framework */
	if (ndi_hp_register(dip, &slot_p->hs_info) != NDI_SUCCESS) {
		PCIE_DBG("pciehpc_register_slot() failed to register slot %d\n",
		    slot_p->hs_phy_slot_num);
		return (DDI_FAILURE);
	}

	pcie_hp_create_occupant_props(dip, makedevice(ddi_driver_major(dip),
	    slot_p->hs_minor), slot_p->hs_device_num);

	PCIE_DBG("pciehpc_register_slot(): registered slot %d\n",
	    slot_p->hs_phy_slot_num);

	return (DDI_SUCCESS);
}

/*
 * Unregister the PCI-E hot plug slot from DDI HP framework.
 */
static int
pciehpc_unregister_slot(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_hp_slot_t *slot_p = ctrl_p->hc_slots[0];
	dev_info_t	*dip = ctrl_p->hc_dip;

	pcie_hp_delete_occupant_props(dip, makedevice(ddi_driver_major(dip),
	    slot_p->hs_minor));

	/* unregister the slot with DDI HP framework */
	if (ndi_hp_unregister(dip, slot_p->hs_info.cn_name) != NDI_SUCCESS) {
		PCIE_DBG("pciehpc_unregister_slot() "
		    "failed to unregister slot %d\n", slot_p->hs_phy_slot_num);
		return (DDI_FAILURE);
	}

	PCIE_DBG("pciehpc_unregister_slot(): unregistered slot %d\n",
	    slot_p->hs_phy_slot_num);

	return (DDI_SUCCESS);
}

static pciehpc_slot_power_t
pciehpc_slot_power_state(pcie_hp_slot_t *slot_p)
{
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uint16_t control, status;
	pciehpc_slot_power_t state = 0;

	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));

	if (!ctrl_p->hc_has_pwr) {
		return (PSP_NO_CONTROLLER);
	} else {
		state |= PSP_HAS_CONTROLLER;
	}

	control = pciehpc_reg_get16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTCTL);
	status = pciehpc_reg_get16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTSTS);

	if ((control & PCIE_SLOTCTL_PWR_CONTROL) != 0)
		state |= PSP_OFF;

	if ((status & PCIE_SLOTSTS_PWR_FAULT_DETECTED) != 0)
		state |= PSP_FAULT;

	return (state);
}

/*
 * Wait for a PCIe slot to be considered active per the PCIe hotplug rules. If
 * there is no DLL active reporting capability then we wait up to 1 second and
 * just assume it was successful. Regardless of whether or not we have explicit
 * power control, the device is still powering on and may not be ready to work.
 */
static boolean_t
pciehpc_slot_wait_for_active(pcie_hp_slot_t *slot_p)
{
	pcie_hp_ctrl_t *ctrl_p = slot_p->hs_ctrl;
	pcie_bus_t *bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);

	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));

	if (ctrl_p->hc_dll_active_rep) {
		clock_t deadline;
		uint16_t status;

		/* wait 1 sec for the DLL State Changed event */
		status = pciehpc_reg_get16(ctrl_p,
		    bus_p->bus_pcie_off + PCIE_LINKSTS);

		deadline = ddi_get_lbolt() +
		    SEC_TO_TICK(PCIE_HP_DLL_STATE_CHANGE_TIMEOUT);

		while ((status & PCIE_LINKSTS_DLL_LINK_ACTIVE) == 0 &&
		    ddi_get_lbolt() < deadline) {
			(void) cv_timedwait(&slot_p->hs_dll_active_cv,
			    &ctrl_p->hc_mutex, deadline);

			/* check Link status */
			status =  pciehpc_reg_get16(ctrl_p,
			    bus_p->bus_pcie_off +
			    PCIE_LINKSTS);
		}

		if ((status & PCIE_LINKSTS_DLL_LINK_ACTIVE) == 0) {
			return (B_FALSE);
		}
	} else {
		/* wait 1 sec for link to come up */
		delay(drv_usectohz(1000000));
	}

	return (B_TRUE);
}

/*
 * This takes care of all the logic for trying to verify a slot's state that
 * does not have an explicit power controller. If this is a surprise insertion,
 * we still need to wait for the data link layer to become active even if we
 * don't explicitly control power. We do this in three steps:
 *
 * 1) Verify the slot is powered at least.
 * 2) Wait for the slot to be active.
 * 3) Verify the slot is still powered after that.
 */
static int
pciehpc_slot_noctrl_active(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t *result)
{
	pcie_hp_ctrl_t *ctrl_p = slot_p->hs_ctrl;

	VERIFY3U(ctrl_p->hc_has_pwr, ==, B_FALSE);
	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));

	pciehpc_get_slot_state(slot_p);
	if (slot_p->hs_info.cn_state < DDI_HP_CN_STATE_POWERED) {
		return (DDI_FAILURE);
	}

	/*
	 * Regardless of whether this worked or failed we must check the slot
	 * state again.
	 */
	if (!pciehpc_slot_wait_for_active(slot_p)) {
		cmn_err(CE_WARN, "pciehpc_slot_poweron_noctrl (slot %d): "
		    "device failed to become active", slot_p->hs_phy_slot_num);
		return (DDI_FAILURE);
	}
	pciehpc_get_slot_state(slot_p);
	*result = slot_p->hs_info.cn_state;
	if (slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_POWERED) {
		slot_p->hs_led_plat_en[PCIE_LL_POWERED] = true;
		slot_p->hs_led_plat_en[PCIE_LL_POWER_FAULT] = false;
		slot_p->hs_led_plat_en[PCIE_LL_PROBE_FAILED] = false;
		pciehpc_sync_leds_to_hw(slot_p);
		return (DDI_SUCCESS);
	} else {
		return (DDI_FAILURE);
	}
}

/*
 * Poweron/Enable the slot.
 *
 * Note: This function is called by DDI HP framework at kernel context only
 *
 * We intend for this function to be idempotent.  That is, when we return, if
 * the slot we've been asked to turn on has a device present, and has a power
 * controller, then a successful return guarantees all of the following,
 * regardless of the hardware or software state that existed when called:
 *
 * 1. The power controller enable bit is clear (asserted).
 * 2. If DLL State Change is supported by the bridge, we waited until DLL Active
 *    was asserted; otherwise we waited at least one second after the first
 *    moment we knew for certain that the power controller was enabled.
 * 3. Any power fault that was previously asserted in the status register has
 *    been acknowledged and cleared, allowing detection of subsequent faults if
 *    supported by hardware.
 * 4. The power indicator is on (if it exists).
 * 5. The MRL, if it exists, is latched.
 *
 * If we fail, either this slot has no power control capability or the following
 * guarantees are made:
 *
 * 1. We have attempted to disable the power controller for this slot.
 * 2. We have attempted to disable the power indicator for this slot.
 *
 * In the failure case, *result has undefined contents.  This function does not
 * change the contents of slot_p->hs_info.cn_state.  This allows callers to act
 * upon the previous software state (preserved by this function), the new
 * software state (in *result if successful), and the current hardware state
 * which can be obtained via pciehpc_get_slot_state().
 */
static int
pciehpc_slot_poweron(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t *result)
{
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uint16_t	status, control;

	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));

	/*
	 * If the hardware doesn't have support for a power controller, then
	 * that generally means that power is already on or at the least there
	 * isn't very much else we can do and the PCIe spec says it's the
	 * responsibility of the controller to have turned it on if a device is
	 * present.  We don't care whether a device is present in this case,
	 * though, because we've been asked to turn on power and we know that we
	 * cannot.  Either a device is present and power is already on, in which
	 * case calling code can figure that out, or no device is present and
	 * we'd fail even if we had a controller.  Either way, we still indicate
	 * that is a failure since we can't change it and instead rely on code
	 * executing the actual state machine to figure out how to handle this.
	 */
	if (!ctrl_p->hc_has_pwr) {
		PCIE_DBG("pciehpc_slot_poweron (slot %d): no power control "
		    "capability, but was asked to power on\n",
		    slot_p->hs_phy_slot_num);
		return (DDI_FAILURE);
	}

	/*
	 * We need the current state of the slot control register to figure out
	 * whether the power controller is enabled already.  Note that this is
	 * not a status bit: it can't tell us whether power is actually on or
	 * off, only what the last control input was.  We also grab the status
	 * register here as we need several bits from it.
	 */
	control = pciehpc_reg_get16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTCTL);
	status = pciehpc_reg_get16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTSTS);

	/*
	 * If there's no device present, we need to fail.
	 */
	if (!(status & PCIE_SLOTSTS_PRESENCE_DETECTED)) {
		/* slot is empty */
		PCIE_DBG("pciehpc_slot_poweron (slot %d): slot is empty\n",
		    slot_p->hs_phy_slot_num);
		goto cleanup;
	}

	/*
	 * If there's an MRL and it's open, we need to fail.
	 */
	if ((ctrl_p->hc_has_mrl) && (status & PCIE_SLOTSTS_MRL_SENSOR_OPEN)) {
		cmn_err(CE_WARN, "pciehpc_slot_poweron (slot %d): MRL switch "
		    "is open", slot_p->hs_phy_slot_num);
		goto cleanup;
	}

	/*
	 * The power controller is already on, but we're in a state below
	 * POWERED.  This shouldn't happen, but there are any number of ways
	 * that it can; we simply note this if debugging and move on.
	 */
	if ((control & PCIE_SLOTCTL_PWR_CONTROL) == 0 &&
	    slot_p->hs_info.cn_state < DDI_HP_CN_STATE_POWERED) {
		PCIE_DBG("pciehpc_slot_poweron (slot %d): controller is "
		    "already enabled in SW state %d; continuing\n",
		    slot_p->hs_phy_slot_num, slot_p->hs_info.cn_state);
		goto alreadyon;
	}

	/*
	 * The power controller has been turned off (which doesn't mean it *is*
	 * off), but software thinks it's on.  This is pretty bad, and we
	 * probably need to consider doing something here to reset the state
	 * machine because upper layers are likely to be confused.  We will
	 * nevertheless turn on the controller and hope the right things happen
	 * above us.
	 */
	if ((control & PCIE_SLOTCTL_PWR_CONTROL) != 0 &&
	    slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_POWERED) {
		cmn_err(CE_WARN, "pciehpc_slot_poweron (slot %d): SW state is "
		    "already %d but power controller is disabled; continuing",
		    slot_p->hs_phy_slot_num, slot_p->hs_info.cn_state);
	}

	/*
	 * Enabling power to the slot involves:
	 *	1. Updating our LED state to indicate the transition is
	 *	   beginning and clearing out other aspects.
	 *	2. Set power control ON in Slot Control Reigster and
	 *	   wait for Command Completed Interrupt or 1 sec timeout.
	 *	3. If Data Link Layer State Changed events are supported
	 *	   then wait for the event to indicate Data Layer Link
	 *	   is active. The time out value for this event is 1 second.
	 *	   This is specified in PCI-E version 1.1.
	 *	4. Set power LED to be ON.
	 */

	/*
	 * If power is already on, we skip indicating a power transition is
	 * going on. However, we always try to clear out the error state LEDs at
	 * this point.
	 */
	slot_p->hs_led_plat_en[PCIE_LL_POWER_TRANSITION] = true;
alreadyon:
	slot_p->hs_led_plat_en[PCIE_LL_PROBE_FAILED] = false;
	slot_p->hs_led_plat_en[PCIE_LL_POWER_FAULT] = false;
	pciehpc_sync_leds_to_hw(slot_p);

	/* 2. set power control to ON */
	control =  pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
	control &= ~PCIE_SLOTCTL_PWR_CONTROL;
	pciehpc_issue_hpc_command(ctrl_p, control);

	/* 3. wait for DLL State Change event, if it's supported */
	if (!pciehpc_slot_wait_for_active(slot_p))
		goto cleanup;

	/* check power is really turned ON */
	control = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);

	if (control & PCIE_SLOTCTL_PWR_CONTROL) {
		PCIE_DBG("pciehpc_slot_poweron (slot %d): power controller "
		    "enable was disabled autonomously after SW enable",
		    slot_p->hs_phy_slot_num);

		goto cleanup;
	}

	/* clear power fault status */
	status = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
	status |= PCIE_SLOTSTS_PWR_FAULT_DETECTED;
	pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTSTS,
	    status);

	/* enable power fault detection interrupt */
	control |= PCIE_SLOTCTL_PWR_FAULT_EN;
	pciehpc_issue_hpc_command(ctrl_p, control);

	/* 4. Set power LED to be ON */
	slot_p->hs_led_plat_en[PCIE_LL_POWER_TRANSITION] = false;
	slot_p->hs_led_plat_en[PCIE_LL_POWERED] = true;
	pciehpc_sync_leds_to_hw(slot_p);

	/* if EMI is present, turn it ON */
	if (ctrl_p->hc_has_emi_lock) {
		status = pciehpc_reg_get16(ctrl_p,
		    bus_p->bus_pcie_off + PCIE_SLOTSTS);

		if (!(status & PCIE_SLOTSTS_EMI_LOCK_SET)) {
			control = pciehpc_reg_get16(ctrl_p,
			    bus_p->bus_pcie_off + PCIE_SLOTCTL);
			control |= PCIE_SLOTCTL_EMI_LOCK_CONTROL;
			pciehpc_issue_hpc_command(ctrl_p, control);

			/* wait 1 sec after toggling the state of EMI lock */
			delay(drv_usectohz(1000000));
		}
	}

	*result = slot_p->hs_info.cn_state = DDI_HP_CN_STATE_POWERED;

	return (DDI_SUCCESS);

cleanup:
	control = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);

	/* if power is ON, set power control to OFF */
	if ((control & PCIE_SLOTCTL_PWR_CONTROL) == 0) {
		control |= PCIE_SLOTCTL_PWR_CONTROL;
		pciehpc_issue_hpc_command(ctrl_p, control);
	}

	/* set power led to OFF XXX what if HW/FW refused to turn off? */
	slot_p->hs_led_plat_en[PCIE_LL_POWER_TRANSITION] = false;
	slot_p->hs_led_plat_en[PCIE_LL_POWERED] = false;
	pciehpc_sync_leds_to_hw(slot_p);

	return (DDI_FAILURE);
}

/*
 * All the same considerations apply to poweroff; see notes above.
 */
static int
pciehpc_slot_poweroff(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t *result)
{
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uint16_t	status, control;

	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));

	/*
	 * Some devices do not have a power controller. In such cases we need to
	 * fail any request to power it off. If a device is being pulled, the
	 * state will generally have automatically been updated; however, if
	 * someone is asking for us to do something via an explicit request,
	 * then this will fail.
	 */
	if (!ctrl_p->hc_has_pwr) {
		PCIE_DBG("pciehpc_slot_poweroff (slot %d): no power control "
		    "capability, but was asked to power off\n",
		    slot_p->hs_phy_slot_num);
		return (DDI_ENOTSUP);
	}

	/*
	 * SW thinks the slot is already powered off.  Note this unexpected
	 * condition and continue.
	 */
	if (slot_p->hs_info.cn_state < DDI_HP_CN_STATE_POWERED) {
		PCIE_DBG("pciehpc_slot_poweroff (slot %d): SW state is "
		    "already %d; continuing\n",
		    slot_p->hs_phy_slot_num, slot_p->hs_info.cn_state);
	}

	control = pciehpc_reg_get16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTCTL);
	status = pciehpc_reg_get16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTSTS);

	/*
	 * The power controller has been turned off (which doesn't mean it *is*
	 * off), but software thinks it's on.  Note this unexpected condition
	 * for debugging and continue; we'll do what we can to get the state
	 * machines back in sync.
	 */
	if ((control & PCIE_SLOTCTL_PWR_CONTROL) != 0 &&
	    slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_POWERED) {
		cmn_err(CE_WARN, "pciehpc_slot_poweroff (slot %d): SW state is "
		    "%d but power controller is already disabled; continuing",
		    slot_p->hs_phy_slot_num, slot_p->hs_info.cn_state);
		goto alreadyoff;
	}

	if (!(status & PCIE_SLOTSTS_PRESENCE_DETECTED)) {
		PCIE_DBG("pciehpc_slot_poweroff (slot %d): powering off "
		    "empty slot\n", slot_p->hs_phy_slot_num);
	}

	/*
	 * Disable power to the slot involves:
	 *	1. Set power LED to blink.
	 *	2. Set power control OFF in Slot Control Reigster and
	 *	   wait for Command Completed Interrupt or 1 sec timeout.
	 *	3. Set POWER led and ATTN led to be OFF.
	 */

	/*
	 * We don't bother indicating a power transition if the device is
	 * already off. The act of turning it off does clear out a probe
	 * failure, but it doesn't clear out a power fault. That is only
	 * reserved for a removal.
	 */
	slot_p->hs_led_plat_en[PCIE_LL_POWER_TRANSITION] = true;
alreadyoff:
	slot_p->hs_led_plat_en[PCIE_LL_PROBE_FAILED] = false;
	pciehpc_sync_leds_to_hw(slot_p);

	/* disable power fault detection interrupt */
	control = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
	control &= ~PCIE_SLOTCTL_PWR_FAULT_EN;
	pciehpc_issue_hpc_command(ctrl_p, control);

	/* 2. set power control to OFF */
	control = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
	control |= PCIE_SLOTCTL_PWR_CONTROL;
	pciehpc_issue_hpc_command(ctrl_p, control);

	/*
	 * Make sure our control input has been acknowledged.  Some
	 * implementations may clear the control bit if the power controller
	 * couldn't be disabled for some reasons, or if firmware decided to
	 * disallow our command.
	 */
	control = pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
	if ((control & PCIE_SLOTCTL_PWR_CONTROL) == 0) {
		/*
		 * Well, this is unfortunate: we couldn't turn power off.
		 * XXX Should we turn on the ATTN indicator?  For now we just
		 * log a warning and fail.
		 */
		cmn_err(CE_WARN, "pciehpc_slot_poweroff (slot %d): power "
		    "controller completed our disable command but is still "
		    "enabled", slot_p->hs_phy_slot_num);
		slot_p->hs_led_plat_en[PCIE_LL_POWER_TRANSITION] = false;
		slot_p->hs_led_plat_en[PCIE_LL_POWERED] = true;
		pciehpc_sync_leds_to_hw(slot_p);

		return (DDI_FAILURE);
	}

	/* 3. Set power LED to be OFF */
	slot_p->hs_led_plat_en[PCIE_LL_POWER_TRANSITION] = false;
	slot_p->hs_led_plat_en[PCIE_LL_POWERED] = false;
	pciehpc_sync_leds_to_hw(slot_p);

	/* if EMI is present, turn it OFF */
	if (ctrl_p->hc_has_emi_lock) {
		status =  pciehpc_reg_get16(ctrl_p,
		    bus_p->bus_pcie_off + PCIE_SLOTSTS);

		if (status & PCIE_SLOTSTS_EMI_LOCK_SET) {
			control =  pciehpc_reg_get16(ctrl_p,
			    bus_p->bus_pcie_off + PCIE_SLOTCTL);
			control |= PCIE_SLOTCTL_EMI_LOCK_CONTROL;
			pciehpc_issue_hpc_command(ctrl_p, control);

			/* wait 1 sec after toggling the state of EMI lock */
			delay(drv_usectohz(1000000));
		}
	}

	/* get the current state of the slot */
	pciehpc_get_slot_state(slot_p);

	*result = slot_p->hs_info.cn_state;

	return (DDI_SUCCESS);
}

/*
 * pciehpc_slot_probe()
 *
 * Probe the slot.
 *
 * Note: This function is called by DDI HP framework at kernel context only
 */
static int
pciehpc_slot_probe(pcie_hp_slot_t *slot_p)
{
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	int		ret = DDI_SUCCESS;

	mutex_enter(&ctrl_p->hc_mutex);

	/*
	 * Because we've been asked to probe again, make sure we aren't actively
	 * suggesting probe failed from an LED perspective.
	 */
	slot_p->hs_led_plat_en[PCIE_LL_PROBE_FAILED] = false;
	pciehpc_sync_leds_to_hw(slot_p);

	/* get the current state of the slot */
	pciehpc_get_slot_state(slot_p);

	/*
	 * Probe a given PCIe Hotplug Connection (CN).
	 */
	PCIE_DISABLE_ERRORS(ctrl_p->hc_dip);
	ret = pcie_hp_probe(slot_p);

	if (ret != DDI_SUCCESS) {
		PCIE_DBG("pciehpc_slot_probe() failed\n");

		/* turn the ATTN led ON for configure failure */
		slot_p->hs_led_plat_en[PCIE_LL_PROBE_FAILED] = true;
		pciehpc_sync_leds_to_hw(slot_p);
		mutex_exit(&ctrl_p->hc_mutex);
		return (DDI_FAILURE);
	}

	PCIE_ENABLE_ERRORS(ctrl_p->hc_dip);

	/* get the current state of the slot */
	pciehpc_get_slot_state(slot_p);

	mutex_exit(&ctrl_p->hc_mutex);
	return (DDI_SUCCESS);
}

/*
 * pciehpc_slot_unprobe()
 *
 * Unprobe the slot.
 *
 * Note: This function is called by DDI HP framework at kernel context only
 */
static int
pciehpc_slot_unprobe(pcie_hp_slot_t *slot_p)
{
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	int		ret;

	mutex_enter(&ctrl_p->hc_mutex);

	/* get the current state of the slot */
	pciehpc_get_slot_state(slot_p);

	/*
	 * Unprobe a given PCIe Hotplug Connection (CN).
	 */
	PCIE_DISABLE_ERRORS(ctrl_p->hc_dip);
	ret = pcie_hp_unprobe(slot_p);

	if (ret != DDI_SUCCESS) {
		PCIE_DBG("pciehpc_slot_unprobe() failed\n");
		PCIE_ENABLE_ERRORS(ctrl_p->hc_dip);
		mutex_exit(&ctrl_p->hc_mutex);
		return (DDI_FAILURE);
	}

	/* get the current state of the slot */
	pciehpc_get_slot_state(slot_p);

	mutex_exit(&ctrl_p->hc_mutex);
	return (DDI_SUCCESS);
}

static int
pciehpc_upgrade_slot_state(pcie_hp_slot_t *slot_p,
    ddi_hp_cn_state_t target_state)
{
	ddi_hp_cn_state_t curr_state;
	int rv = DDI_SUCCESS;
	pcie_hp_ctrl_t *ctrl_p = slot_p->hs_ctrl;

	if (target_state > DDI_HP_CN_STATE_ENABLED) {
		return (DDI_EINVAL);
	}

	curr_state = slot_p->hs_info.cn_state;
	while ((curr_state < target_state) && (rv == DDI_SUCCESS)) {

		switch (curr_state) {
		case DDI_HP_CN_STATE_EMPTY:
			/*
			 * From EMPTY to PRESENT, just check the hardware
			 * slot state.
			 */
			pciehpc_get_slot_state(slot_p);
			curr_state = slot_p->hs_info.cn_state;
			if (curr_state < DDI_HP_CN_STATE_PRESENT)
				rv = DDI_FAILURE;
			break;
		case DDI_HP_CN_STATE_PRESENT:
			if (!ctrl_p->hc_has_pwr) {
				pciehpc_get_slot_state(slot_p);
				curr_state = slot_p->hs_info.cn_state;
				if (curr_state < DDI_HP_CN_STATE_POWERED)
					rv = DDI_FAILURE;
				break;
			}

			rv = (ctrl_p->hc_ops.poweron_hpc_slot)(slot_p,
			    &curr_state);

			break;
		case DDI_HP_CN_STATE_POWERED:
			/*
			 * If we're performing a synchronization, then the
			 * POWERED state isn't quite accurate. Power is enabled,
			 * but we haven't really done all the actual steps that
			 * are expected. As such, we will do another call to
			 * power on and if successful, then do the change to
			 * ENABLED. If the call to power on did not work, then
			 * we must transition back to PRESENT. If there is no
			 * power controller, then this is a no-op.
			 */
			if ((ctrl_p->hc_flags & PCIE_HP_SYNC_RUNNING) != 0 &&
			    ctrl_p->hc_has_pwr) {
				rv = (ctrl_p->hc_ops.poweron_hpc_slot)(slot_p,
				    &curr_state);
				if (rv != DDI_SUCCESS) {
					slot_p->hs_info.cn_state =
					    DDI_HP_CN_STATE_PRESENT;
					break;
				}
			} else if (!ctrl_p->hc_has_pwr) {
				rv = pciehpc_slot_noctrl_active(slot_p,
				    &curr_state);
				if (rv != DDI_SUCCESS)
					break;
			}

			curr_state = slot_p->hs_info.cn_state =
			    DDI_HP_CN_STATE_ENABLED;
			break;
		default:
			/* should never reach here */
			ASSERT("unknown devinfo state");
		}
	}

	return (rv);
}

/*
 * Remove and clear out LEDs given a slot state downgrade. In particular, we
 * have three states that we need to worry about: whether the device is powered,
 * a power fault, and a probe failure.
 *
 * Removing power removes the powered state and a probe failure, but retains a
 * power fault. Removing a device ensures that all three are off.
 */
static void
pciehpc_downgrade_slot_leds(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t state)
{
	switch (state) {
	case DDI_HP_CN_STATE_EMPTY:
		slot_p->hs_led_plat_en[PCIE_LL_POWERED] = false;
		slot_p->hs_led_plat_en[PCIE_LL_PROBE_FAILED] = false;
		slot_p->hs_led_plat_en[PCIE_LL_POWER_FAULT] = false;
		break;
	case DDI_HP_CN_STATE_PRESENT:
		slot_p->hs_led_plat_en[PCIE_LL_POWERED] = false;
		slot_p->hs_led_plat_en[PCIE_LL_PROBE_FAILED] = false;
		break;
	default:
		break;
	}

	pciehpc_sync_leds_to_hw(slot_p);
}

static int
pciehpc_downgrade_slot_state(pcie_hp_slot_t *slot_p,
    ddi_hp_cn_state_t target_state)
{
	ddi_hp_cn_state_t curr_state;
	int rv = DDI_SUCCESS;


	curr_state = slot_p->hs_info.cn_state;
	while ((curr_state > target_state) && (rv == DDI_SUCCESS)) {

		switch (curr_state) {
		case DDI_HP_CN_STATE_PRESENT:
			/*
			 * From PRESENT to EMPTY, just check hardware slot
			 * state. Removal of a device means we should make sure
			 * that the LEDs are cleaned up.
			 */
			pciehpc_get_slot_state(slot_p);
			curr_state = slot_p->hs_info.cn_state;
			if (curr_state >= DDI_HP_CN_STATE_PRESENT) {
				rv = DDI_FAILURE;
			} else {
				pciehpc_downgrade_slot_leds(slot_p, curr_state);
			}
			break;
		case DDI_HP_CN_STATE_POWERED:
			/*
			 * If the device doesn't have power control then we
			 * cannot ask it to power off the slot. However, a
			 * device may have been removed and therefore we need to
			 * manually check if the device was removed by getting
			 * the state. Otherwise we let power control do
			 * everything.
			 */
			if (!slot_p->hs_ctrl->hc_has_pwr) {
				pciehpc_get_slot_state(slot_p);
				curr_state = slot_p->hs_info.cn_state;
				if (curr_state >= DDI_HP_CN_STATE_POWERED) {
					rv = DDI_FAILURE;
				} else {
					pciehpc_downgrade_slot_leds(slot_p,
					    curr_state);
				}
				break;
			}

			rv = (slot_p->hs_ctrl->hc_ops.poweroff_hpc_slot)(
			    slot_p, &curr_state);

			break;
		case DDI_HP_CN_STATE_ENABLED:
			curr_state = slot_p->hs_info.cn_state =
			    DDI_HP_CN_STATE_POWERED;

			break;
		default:
			/* should never reach here */
			ASSERT("unknown devinfo state");
		}
	}

	return (rv);
}

/* Change slot state to a target state */
static int
pciehpc_change_slot_state(pcie_hp_slot_t *slot_p,
    ddi_hp_cn_state_t target_state)
{
	ddi_hp_cn_state_t curr_state;
	pciehpc_slot_power_t pwr_state;
	boolean_t sync = B_FALSE;
	int rv = 0;

	ASSERT(MUTEX_HELD(&slot_p->hs_ctrl->hc_mutex));

	pciehpc_get_slot_state(slot_p);
	curr_state = slot_p->hs_info.cn_state;
	pwr_state = pciehpc_slot_power_state(slot_p);

	/*
	 * We've been asked to change the slot state. If we still had an
	 * outstanding synchronization task, then we should remove that because
	 * we've had an explicit state change. In essence we take over that sync
	 * and note that it's running.
	 */
	if ((slot_p->hs_ctrl->hc_flags & PCIE_HP_SYNC_PENDING) != 0 &&
	    slot_p->hs_info.cn_state == DDI_HP_CN_STATE_POWERED) {
		sync = B_TRUE;
		slot_p->hs_ctrl->hc_flags |= PCIE_HP_SYNC_RUNNING;
	}
	slot_p->hs_ctrl->hc_flags &= ~PCIE_HP_SYNC_PENDING;

	/*
	 * We need to see whether the power controller state (if there is one)
	 * matches the DDI slot state.  If not, it may be necessary to perform
	 * the upgrade or downgrade procedure even if the DDI slot state matches
	 * the target already.  We'll make sure that curr_state reflects the
	 * state of the power controller with respect to our desired target
	 * state, even if the slot is empty.
	 */
	if (pwr_state == PSP_NO_CONTROLLER)
		goto skip_sync;

	switch (target_state) {
	case DDI_HP_CN_STATE_EMPTY:
	case DDI_HP_CN_STATE_PRESENT:
		/*
		 * Power controller is on but software doesn't know that, and
		 * wants to enter a state in which power should be off.
		 */
		if ((pwr_state & PSP_OFF) == 0 &&
		    curr_state < DDI_HP_CN_STATE_POWERED) {
			curr_state = DDI_HP_CN_STATE_POWERED;
		}
		break;
	case DDI_HP_CN_STATE_POWERED:
	case DDI_HP_CN_STATE_ENABLED:
		/*
		 * Power controller is off but software doesn't know that, and
		 * wants to enter a state in which power should be on.
		 */
		if ((pwr_state & PSP_OFF) != 0 &&
		    curr_state >= DDI_HP_CN_STATE_POWERED) {
			curr_state = DDI_HP_CN_STATE_PRESENT;
		}
		break;
	default:
		break;
	}

	slot_p->hs_info.cn_state = curr_state;

skip_sync:
	if (curr_state == target_state) {
		return (DDI_SUCCESS);
	}

	if (curr_state < target_state) {
		rv = pciehpc_upgrade_slot_state(slot_p, target_state);
	} else {
		rv = pciehpc_downgrade_slot_state(slot_p, target_state);
	}

	if (sync) {
		slot_p->hs_ctrl->hc_flags &= ~PCIE_HP_SYNC_RUNNING;
	}

	return (rv);
}

typedef struct pciehpc_prop {
	const char *prop_name;
	const char *prop_value;
	bool (*prop_valid)(const char *);
	int (*prop_get)(pcie_hp_slot_t *, const char **);
	void (*prop_set)(pcie_hp_slot_t *, const char *);
} pciehpc_prop_t;

static bool
pciehpc_prop_led_valid(const char *value)
{
	return (strcmp(value, PCIEHPC_PROP_VALUE_ON) == 0 ||
	    strcmp(value, PCIEHPC_PROP_VALUE_OFF) == 0 ||
	    strcmp(value, PCIEHPC_PROP_VALUE_BLINK) == 0 ||
	    strcmp(value, PCIEHPC_PROP_VALUE_DEFAULT) == 0);
}

static int
pciehpc_prop_card_get(pcie_hp_slot_t *slot_p, const char **value_p)
{
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	ddi_acc_handle_t handle;
	dev_info_t	*cdip;
	uint8_t		prog_class, base_class, sub_class;

	mutex_exit(&ctrl_p->hc_mutex);
	cdip = pcie_hp_devi_find(ctrl_p->hc_dip, slot_p->hs_device_num, 0);
	mutex_enter(&ctrl_p->hc_mutex);

	if ((slot_p->hs_info.cn_state != DDI_HP_CN_STATE_ENABLED) ||
	    cdip == NULL) {
		/*
		 * When getting all properties, just ignore the
		 * one that's not available under certain state.
		 */
		return (DDI_ENOTSUP);
	}

	if (pci_config_setup(cdip, &handle) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	prog_class = pci_config_get8(handle, PCI_CONF_PROGCLASS);
	base_class = pci_config_get8(handle, PCI_CONF_BASCLASS);
	sub_class = pci_config_get8(handle, PCI_CONF_SUBCLASS);
	pci_config_teardown(&handle);

	*value_p = PCIEHPC_PROP_VALUE_UNKNOWN;
	for (size_t i = 0; i < class_pci_items; i++) {
		if ((base_class == class_pci[i].base_class) &&
		    (sub_class == class_pci[i].sub_class) &&
		    (prog_class == class_pci[i].prog_class)) {
			*value_p = class_pci[i].short_desc;
			break;
		}
	}

	return (DDI_SUCCESS);
}

static int
pciehpc_prop_board_get(pcie_hp_slot_t *slot_p, const char **value_p)
{
	if (slot_p->hs_info.cn_state <= DDI_HP_CN_STATE_EMPTY) {
		*value_p = PCIEHPC_PROP_VALUE_UNKNOWN;
	} else {
		*value_p = PCIEHPC_PROP_VALUE_PCIHOTPLUG;
	}

	return (DDI_SUCCESS);
}

static int
pciehpc_prop_slot_get(pcie_hp_slot_t *slot_p, const char **value_p)
{
	*value_p = pcie_slot_condition_text(slot_p->hs_condition);
	return (DDI_SUCCESS);
}

static int
pciehpc_prop_led_get_power(pcie_hp_slot_t *slot_p, const char **value_p)
{
	if (slot_p->hs_power_usr_ovr) {
		*value_p = pcie_led_state_text(slot_p->hs_power_usr_ovr_state);
	} else {
		*value_p = PCIEHPC_PROP_VALUE_DEFAULT;
	}
	return (DDI_SUCCESS);
}

static int
pciehpc_prop_led_get_attn(pcie_hp_slot_t *slot_p, const char **value_p)
{
	if (slot_p->hs_attn_usr_ovr) {
		*value_p = pcie_led_state_text(slot_p->hs_attn_usr_ovr_state);
	} else {
		*value_p = PCIEHPC_PROP_VALUE_DEFAULT;
	}
	return (DDI_SUCCESS);
}

static void
pciehpc_prop_led_set_common(bool *ovr, pcie_hp_led_state_t *state,
    const char *val)
{
	if (strcmp(val, PCIEHPC_PROP_VALUE_DEFAULT) == 0) {
		*ovr = false;
		return;
	}

	*ovr = true;
	if (strcmp(val, PCIEHPC_PROP_VALUE_ON) == 0) {
		*state = PCIE_HP_LED_ON;
	} else if (strcmp(val, PCIEHPC_PROP_VALUE_OFF) == 0) {
		*state = PCIE_HP_LED_OFF;
	} else if (strcmp(val, PCIEHPC_PROP_VALUE_BLINK) == 0) {
		*state = PCIE_HP_LED_BLINK;
	}
}

static void
pciehpc_prop_led_set_attn(pcie_hp_slot_t *slot_p, const char *value)
{
	pciehpc_prop_led_set_common(&slot_p->hs_attn_usr_ovr,
	    &slot_p->hs_attn_usr_ovr_state, value);
}

static void
pciehpc_prop_led_set_power(pcie_hp_slot_t *slot_p, const char *value)
{
	pciehpc_prop_led_set_common(&slot_p->hs_power_usr_ovr,
	    &slot_p->hs_power_usr_ovr_state, value);
}

static pciehpc_prop_t pciehpc_props[] = {
	{ PCIEHPC_PROP_LED_POWER, PCIEHPC_PROP_VALUE_LED_DEF,
	    pciehpc_prop_led_valid, pciehpc_prop_led_get_power,
	    pciehpc_prop_led_set_power },
	{ PCIEHPC_PROP_LED_ATTN, PCIEHPC_PROP_VALUE_LED_DEF,
	    pciehpc_prop_led_valid, pciehpc_prop_led_get_attn,
	    pciehpc_prop_led_set_attn },
	{ PCIEHPC_PROP_CARD_TYPE, PCIEHPC_PROP_VALUE_TYPE, NULL,
	    pciehpc_prop_card_get, NULL },
	{ PCIEHPC_PROP_BOARD_TYPE, PCIEHPC_PROP_VALUE_TYPE, NULL,
	    pciehpc_prop_board_get, NULL },
	{ PCIEHPC_PROP_SLOT_CONDITION, PCIEHPC_PROP_VALUE_TYPE, NULL,
	    pciehpc_prop_slot_get, NULL },
};

static bool
pciehpc_slot_prop_copyin(uintptr_t arg, ddi_hp_property_t *prop)
{
	switch (ddi_model_convert_from(get_udatamodel())) {
#ifdef	_MULTI_DATAMODEL
	case DDI_MODEL_ILP32: {
		ddi_hp_property32_t prop32;
		if (ddi_copyin((void *)arg, &prop32, sizeof (prop32), 0) != 0) {
			return (false);
		}
		bzero(prop, sizeof (prop));
		prop->nvlist_buf = (void *)(uintptr_t)prop32.nvlist_buf;
		prop->buf_size = prop32.buf_size;
		break;
	}
#endif
	case DDI_MODEL_NONE:
		if (ddi_copyin((void *)arg, prop, sizeof (*prop), 0) != 0) {
			return (false);
		}
		break;
	default:
		return (false);
	}

	return (true);
}

static bool
pciehpc_slot_prop_copyout(uintptr_t dest, const ddi_hp_property_t *prop)
{
	switch (ddi_model_convert_from(get_udatamodel())) {
#ifdef	_MULTI_DATAMODEL
	case DDI_MODEL_ILP32: {
		ddi_hp_property32_t prop32;

		if ((uintptr_t)prop->nvlist_buf > UINT32_MAX ||
		    prop->buf_size > UINT32_MAX) {
			return (false);
		}
		bzero(&prop32, sizeof (prop32));
		prop32.nvlist_buf = (caddr32_t)(uintptr_t)prop->nvlist_buf;
		prop32.buf_size = (uint32_t)prop->buf_size;
		if (ddi_copyout(&prop32, (void *)dest, sizeof (prop32), 0) !=
		    0) {
			return (false);
		}
		break;
	}
#endif
	case DDI_MODEL_NONE:
		if (ddi_copyout(prop, (void *)dest, sizeof (ddi_hp_property_t),
		    0) != 0) {
			return (false);
		}
		break;
	default:
		return (false);
	}

	return (true);
}

int
pciehpc_slot_get_property(pcie_hp_slot_t *slot_p, uintptr_t arg, uintptr_t rval)
{
	ddi_hp_property_t request, result;
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	nvlist_t	*prop_list;
	nvlist_t	*prop_rlist; /* nvlist for return values */
	nvpair_t	*prop_pair;
	int		ret = DDI_SUCCESS;
	boolean_t	get_all_prop = B_FALSE;

	if (!pciehpc_slot_prop_copyin(arg, &request) ||
	    !pciehpc_slot_prop_copyin(rval, &result))
		return (false);

	if ((ret = pcie_copyin_nvlist(request.nvlist_buf, request.buf_size,
	    &prop_list)) != DDI_SUCCESS)
		return (ret);

	if (nvlist_alloc(&prop_rlist, NV_UNIQUE_NAME, 0)) {
		ret = DDI_ENOMEM;
		goto get_prop_cleanup;
	}

	/* check whether the requested property is "all" or "help" */
	prop_pair = nvlist_next_nvpair(prop_list, NULL);
	if (prop_pair && !nvlist_next_nvpair(prop_list, prop_pair)) {
		const char *name = nvpair_name(prop_pair);

		if (strcmp(name, PCIEHPC_PROP_ALL) == 0) {
			(void) nvlist_remove_all(prop_list, PCIEHPC_PROP_ALL);

			/*
			 * Add all properties into the request list, so that we
			 * will get the values in the following for loop.
			 */
			for (size_t i = 0; i < ARRAY_SIZE(pciehpc_props); i++) {
				if (nvlist_add_string(prop_list,
				    pciehpc_props[i].prop_name, "") != 0) {
					ret = DDI_FAILURE;
					goto get_prop_cleanup1;
				}
			}
			get_all_prop = B_TRUE;
		} else if (strcmp(name, PCIEHPC_PROP_HELP) == 0) {
			/*
			 * Empty the request list, and add help strings into the
			 * return list. We will pass the following for loop.
			 */
			(void) nvlist_remove_all(prop_list, PCIEHPC_PROP_HELP);

			for (size_t i = 0; i < ARRAY_SIZE(pciehpc_props); i++) {
				if (nvlist_add_string(prop_rlist,
				    pciehpc_props[i].prop_name,
				    pciehpc_props[i].prop_value) != 0) {
					ret = DDI_FAILURE;
					goto get_prop_cleanup1;
				}
			}
		}
	}

	mutex_enter(&ctrl_p->hc_mutex);

	/* get the current slot state */
	pciehpc_get_slot_state(slot_p);

	/* for each requested property, get the value and add it to nvlist */
	prop_pair = NULL;
	while ((prop_pair = nvlist_next_nvpair(prop_list, prop_pair)) != NULL) {
		const char *name = nvpair_name(prop_pair);
		const pciehpc_prop_t *prop = NULL;
		const char *value = NULL;

		for (size_t i = 0; i < ARRAY_SIZE(pciehpc_props); i++) {
			if (strcmp(pciehpc_props[i].prop_name, name) == 0) {
				prop = &pciehpc_props[i];
				break;
			}
		}

		if (prop == NULL) {
			PCIE_DBG("Unsupported property: %s\n", name);
			ret = DDI_EINVAL;
			goto get_prop_cleanup2;
		}

		/*
		 * Get the property. Some things may fail with ENOTSUP and we
		 * allow that if we are being asked to get everything.
		 */
		ret = prop->prop_get(slot_p, &value);
		if (ret != DDI_SUCCESS &&
		    (get_all_prop && ret != DDI_ENOTSUP)) {
			goto get_prop_cleanup2;
		}

		if (nvlist_add_string(prop_rlist, name, value) != 0) {
			ret = DDI_FAILURE;
			goto get_prop_cleanup2;
		}
	}

	/* pack nvlist and copyout */
	if ((ret = pcie_copyout_nvlist(prop_rlist, result.nvlist_buf,
	    &result.buf_size)) != DDI_SUCCESS) {
		goto get_prop_cleanup2;
	}

	if (!pciehpc_slot_prop_copyout(rval, &result)) {
		ret = DDI_FAILURE;
	}

get_prop_cleanup2:
	mutex_exit(&ctrl_p->hc_mutex);
get_prop_cleanup1:
	nvlist_free(prop_rlist);
get_prop_cleanup:
	nvlist_free(prop_list);
	return (ret);
}


int
pciehpc_slot_set_property(pcie_hp_slot_t *slot_p, uintptr_t arg,
    uintptr_t rval)
{
	ddi_hp_property_t	request, result;
	pcie_hp_ctrl_t		*ctrl_p = slot_p->hs_ctrl;
	nvlist_t		*prop_list;
	nvlist_t		*prop_rlist;
	nvpair_t		*prop_pair;
	int			ret = DDI_SUCCESS;

	if (!pciehpc_slot_prop_copyin(arg, &request) ||
	    !pciehpc_slot_prop_copyin(rval, &result))
		return (false);

	if ((ret = pcie_copyin_nvlist(request.nvlist_buf, request.buf_size,
	    &prop_list)) != DDI_SUCCESS)
		return (ret);

	/* check whether the requested property is "help" */
	prop_pair = nvlist_next_nvpair(prop_list, NULL);
	if (prop_pair && !nvlist_next_nvpair(prop_list, prop_pair) &&
	    (strcmp(nvpair_name(prop_pair), PCIEHPC_PROP_HELP) == 0)) {
		if (!rval) {
			ret = DDI_ENOTSUP;
			goto set_prop_cleanup;
		}

		if (nvlist_alloc(&prop_rlist, NV_UNIQUE_NAME, 0)) {
			ret = DDI_ENOMEM;
			goto set_prop_cleanup;
		}

		for (size_t i = 0; i < ARRAY_SIZE(pciehpc_props); i++) {
			if (pciehpc_props[i].prop_valid == NULL)
				continue;

			if (nvlist_add_string(prop_rlist,
			    pciehpc_props[i].prop_name,
			    pciehpc_props[i].prop_value) != 0) {
				ret = DDI_FAILURE;
				goto set_prop_cleanup1;
			}
		}

		if ((ret = pcie_copyout_nvlist(prop_rlist, result.nvlist_buf,
		    &result.buf_size)) != DDI_SUCCESS) {
			goto set_prop_cleanup1;
		}

		if (!pciehpc_slot_prop_copyout(rval, &result)) {
			ret = DDI_FAILURE;
		}

set_prop_cleanup1:
		nvlist_free(prop_rlist);
		nvlist_free(prop_list);
		return (ret);
	}

	/* Validate the request */
	prop_pair = NULL;
	while ((prop_pair = nvlist_next_nvpair(prop_list, prop_pair)) != NULL) {
		const pciehpc_prop_t *prop;
		char *value;
		const char *name = nvpair_name(prop_pair);

		if (nvpair_type(prop_pair) != DATA_TYPE_STRING) {
			PCIE_DBG("Unexpected data type of setting "
			    "property %s.\n", name);
			ret = DDI_EINVAL;
			goto set_prop_cleanup;
		}

		if (nvpair_value_string(prop_pair, &value)) {
			PCIE_DBG("Get string value failed for property %s.\n",
			    name);
			ret = DDI_FAILURE;
			goto set_prop_cleanup;
		}

		prop = NULL;
		for (size_t i = 0; i < ARRAY_SIZE(pciehpc_props); i++) {
			if (strcmp(pciehpc_props[i].prop_name, name) == 0) {
				prop = &pciehpc_props[i];
				break;
			}
		}

		if (prop == NULL) {
			PCIE_DBG("Unsupported property: %s\n", name);
			ret = DDI_EINVAL;
			goto set_prop_cleanup;
		}

		if (prop->prop_valid == NULL) {
			PCIE_DBG("Read only property: %s\n", name);
			ret = DDI_ENOTSUP;
			goto set_prop_cleanup;
		} else if (!prop->prop_valid(value)) {
			PCIE_DBG("Unsupported value ('%s') for property: %s\n",
			    value, name);
			ret = DDI_EINVAL;
			goto set_prop_cleanup;
		}
	}
	mutex_enter(&ctrl_p->hc_mutex);

	/* get the current slot state */
	pciehpc_get_slot_state(slot_p);

	/* set each property */
	prop_pair = NULL;
	while ((prop_pair = nvlist_next_nvpair(prop_list, prop_pair)) != NULL) {
		const char *name = nvpair_name(prop_pair);
		const pciehpc_prop_t *prop = NULL;
		char *value;

		(void) nvpair_value_string(prop_pair, &value);
		for (size_t i = 0; i < ARRAY_SIZE(pciehpc_props); i++) {
			if (strcmp(pciehpc_props[i].prop_name, name) == 0) {
				prop = &pciehpc_props[i];
				break;
			}
		}

		ASSERT3P(prop, !=, NULL);
		prop->prop_set(slot_p, value);
	}

	/*
	 * Because the only properties we can set are LED related, always
	 * resync.
	 */
	pciehpc_sync_leds_to_hw(slot_p);

	if (rval != 0) {
		result.buf_size = 0;
		if (!pciehpc_slot_prop_copyout(rval, &result)) {
			ret = DDI_FAILURE;
		}
	}

	mutex_exit(&ctrl_p->hc_mutex);
set_prop_cleanup:
	nvlist_free(prop_list);
	return (ret);
}

/*
 * Send a command to the PCI-E Hot Plug Controller.
 *
 * NOTES: The PCI-E spec defines the following semantics for issuing hot plug
 * commands.
 * 1) If Command Complete events/interrupts are supported then software
 *    waits for Command Complete event after issuing a command (i.e writing
 *    to the Slot Control register). The command completion could take as
 *    long as 1 second so software should be prepared to wait for 1 second
 *    before issuing another command.
 *
 * 2) If Command Complete events/interrupts are not supported then
 *    software could issue multiple Slot Control writes without any delay
 *    between writes.
 */
static void
pciehpc_issue_hpc_command(pcie_hp_ctrl_t *ctrl_p, uint16_t control)
{
	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uint16_t	status;
	uint32_t	slot_cap;

	/*
	 * PCI-E version 1.1 spec defines No Command Completed
	 * Support bit (bit#18) in Slot Capabilities register. If this
	 * bit is set then slot doesn't support notification of command
	 * completion events.
	 */
	slot_cap =  pciehpc_reg_get32(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCAP);

	/*
	 * If no Command Completion event is supported or it is ACPI
	 * hot plug mode then just issue the command and return.
	 */
	if ((slot_cap & PCIE_SLOTCAP_NO_CMD_COMP_SUPP) ||
	    (bus_p->bus_hp_curr_mode == PCIE_ACPI_HP_MODE)) {
		pciehpc_reg_put16(ctrl_p,
		    bus_p->bus_pcie_off + PCIE_SLOTCTL, control);
		return;
	}

	/*
	 * **************************************
	 * Command Complete events are supported.
	 * **************************************
	 */

	/*
	 * If HPC is not yet initialized then just poll for the Command
	 * Completion interrupt.
	 */
	if (!(ctrl_p->hc_flags & PCIE_HP_INITIALIZED_FLAG)) {
		int retry = PCIE_HP_CMD_WAIT_RETRY;

		/* write the command to the HPC */
		pciehpc_reg_put16(ctrl_p,
		    bus_p->bus_pcie_off + PCIE_SLOTCTL, control);

		/* poll for status completion */
		while (retry--) {
			/* wait for 10 msec before checking the status */
			delay(drv_usectohz(PCIE_HP_CMD_WAIT_TIME));

			status = pciehpc_reg_get16(ctrl_p,
			    bus_p->bus_pcie_off + PCIE_SLOTSTS);

			if (status & PCIE_SLOTSTS_COMMAND_COMPLETED) {
				/* clear the status bits */
				pciehpc_reg_put16(ctrl_p,
				    bus_p->bus_pcie_off + PCIE_SLOTSTS, status);
				break;
			}
		}
		return;
	}

	/* HPC is already initialized */

	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));

	/*
	 * If previous command is still pending then wait for its
	 * completion. i.e cv_wait()
	 */

	while (ctrl_p->hc_cmd_pending == B_TRUE)
		cv_wait(&ctrl_p->hc_cmd_comp_cv, &ctrl_p->hc_mutex);

	/*
	 * Issue the command and wait for Command Completion or
	 * the 1 sec timeout.
	 */
	pciehpc_reg_put16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL, control);

	ctrl_p->hc_cmd_pending = B_TRUE;

	if (cv_timedwait(&ctrl_p->hc_cmd_comp_cv, &ctrl_p->hc_mutex,
	    ddi_get_lbolt() + SEC_TO_TICK(1)) == -1) {

		/* it is a timeout */
		PCIE_DBG("pciehpc_issue_hpc_command: Command Complete"
		    " interrupt is not received for slot %d\n",
		    slot_p->hs_phy_slot_num);

		/* clear the status info in case interrupts are disabled? */
		status = pciehpc_reg_get16(ctrl_p,
		    bus_p->bus_pcie_off + PCIE_SLOTSTS);

		if (status & PCIE_SLOTSTS_COMMAND_COMPLETED) {
			/* clear the status bits */
			pciehpc_reg_put16(ctrl_p,
			    bus_p->bus_pcie_off + PCIE_SLOTSTS, status);
		}
	}

	ctrl_p->hc_cmd_pending = B_FALSE;

	/* wake up any one waiting for issuing another command to HPC */
	cv_signal(&ctrl_p->hc_cmd_comp_cv);
}

/*
 * pciehcp_attn_btn_handler()
 *
 * This handles ATTN button pressed event as per the PCI-E 1.1 spec.
 */
static void
pciehpc_attn_btn_handler(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_hp_slot_t		*slot_p = ctrl_p->hc_slots[0];
	callb_cpr_t		cprinfo;

	PCIE_DBG("pciehpc_attn_btn_handler: thread started\n");

	CALLB_CPR_INIT(&cprinfo, &ctrl_p->hc_mutex, callb_generic_cpr,
	    "pciehpc_attn_btn_handler");

	mutex_enter(&ctrl_p->hc_mutex);

	/* wait for ATTN button event */
	cv_wait(&slot_p->hs_attn_btn_cv, &ctrl_p->hc_mutex);

	while (slot_p->hs_attn_btn_thread_exit == B_FALSE) {
		if (slot_p->hs_attn_btn_pending == B_TRUE) {
			/*
			 * Allow the platform to toggle an appropriate LED while
			 * we're waiting for this to take effect (generally
			 * blinking the power LED).
			 */
			slot_p->hs_led_plat_en[PCIE_LL_ATTENTION_BUTTON] = true;
			pciehpc_sync_leds_to_hw(slot_p);

			/* wait for 5 seconds before taking any action */
			if (cv_timedwait(&slot_p->hs_attn_btn_cv,
			    &ctrl_p->hc_mutex,
			    ddi_get_lbolt() + SEC_TO_TICK(5)) == -1) {
				/*
				 * It is a time out; make sure the ATTN pending
				 * flag is still ON before sending the event to
				 * DDI HP framework.
				 */
				if (slot_p->hs_attn_btn_pending == B_TRUE) {
					int hint;

					slot_p->hs_attn_btn_pending = B_FALSE;
					pciehpc_get_slot_state(slot_p);

					if (slot_p->hs_info.cn_state <=
					    DDI_HP_CN_STATE_PRESENT) {
						/*
						 * Insertion.
						 */
						hint = SE_INCOMING_RES;
					} else {
						/*
						 * Want to remove;
						 */
						hint = SE_OUTGOING_RES;
					}

					/*
					 * We can't call ddihp_cn_gen_sysevent
					 * here since it's not a DDI interface.
					 */
					pcie_hp_gen_sysevent_req(
					    slot_p->hs_info.cn_name,
					    hint,
					    ctrl_p->hc_dip,
					    KM_SLEEP);
				}
			}

			/* restore the power LED state */
			slot_p->hs_led_plat_en[PCIE_LL_ATTENTION_BUTTON] =
			    false;
			pciehpc_sync_leds_to_hw(slot_p);
			continue;
		}

		/* wait for another ATTN button event */
		cv_wait(&slot_p->hs_attn_btn_cv, &ctrl_p->hc_mutex);
	}

	PCIE_DBG("pciehpc_attn_btn_handler: thread exit\n");
	cv_signal(&slot_p->hs_attn_btn_cv);
	CALLB_CPR_EXIT(&cprinfo);
	thread_exit();
}

/*
 * convert LED state from PCIE HPC definition to pcie_hp_led_state_t
 * definition.
 */
static pcie_hp_led_state_t
pciehpc_led_state_to_hpc(uint16_t state)
{
	switch (state) {
	case PCIE_SLOTCTL_INDICATOR_STATE_ON:
		return (PCIE_HP_LED_ON);
	case PCIE_SLOTCTL_INDICATOR_STATE_BLINK:
		return (PCIE_HP_LED_BLINK);
	case PCIE_SLOTCTL_INDICATOR_STATE_OFF:
	default:
		return (PCIE_HP_LED_OFF);
	}
}

static void
pciehpc_handle_power_fault(dev_info_t *dip)
{
	/*
	 * Hold the parent's ref so that it won't disappear when the taskq is
	 * scheduled to run.
	 */
	ndi_hold_devi(dip);

	if (taskq_dispatch(system_taskq, pciehpc_power_fault_handler, dip,
	    TQ_NOSLEEP) == TASKQID_INVALID) {
		ndi_rele_devi(dip);
		PCIE_DBG("pciehpc_intr(): "
		    "Failed to dispatch power fault handler, dip %p\n", dip);
	}
}

static void
pciehpc_power_fault_handler(void *arg)
{
	dev_info_t *dip = (dev_info_t *)arg;
	pcie_hp_ctrl_t  *ctrl_p;
	pcie_hp_slot_t  *slot_p;

	/* get the soft state structure for this dip */
	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL) {
		ndi_rele_devi(dip);
		return;
	}
	slot_p = ctrl_p->hc_slots[0];

	/*
	 * Send the event to DDI Hotplug framework, power off
	 * the slot
	 */
	(void) ndi_hp_state_change_req(dip,
	    slot_p->hs_info.cn_name,
	    DDI_HP_CN_STATE_PRESENT, DDI_HP_REQ_SYNC);

	mutex_enter(&ctrl_p->hc_mutex);
	slot_p->hs_led_plat_en[PCIE_LL_POWER_FAULT] = true;
	pciehpc_sync_leds_to_hw(slot_p);
	mutex_exit(&ctrl_p->hc_mutex);
	ndi_rele_devi(dip);
}

#ifdef DEBUG
/*
 * Dump PCI-E Hot Plug registers.
 */
static void
pciehpc_dump_hpregs(pcie_hp_ctrl_t *ctrl_p)
{
	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
	uint16_t	control;
	uint32_t	capabilities;

	if (!pcie_debug_flags)
		return;

	capabilities = pciehpc_reg_get32(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCAP);

	control =  pciehpc_reg_get16(ctrl_p,
	    bus_p->bus_pcie_off + PCIE_SLOTCTL);

	PCIE_DBG("pciehpc_dump_hpregs: Found PCI-E hot plug slot %d\n",
	    slot_p->hs_phy_slot_num);

	PCIE_DBG("Attention Button Present = %s\n",
	    capabilities & PCIE_SLOTCAP_ATTN_BUTTON ? "Yes":"No");

	PCIE_DBG("Power controller Present = %s\n",
	    capabilities & PCIE_SLOTCAP_POWER_CONTROLLER ? "Yes":"No");

	PCIE_DBG("MRL Sensor Present	   = %s\n",
	    capabilities & PCIE_SLOTCAP_MRL_SENSOR ? "Yes":"No");

	PCIE_DBG("Attn Indicator Present   = %s\n",
	    capabilities & PCIE_SLOTCAP_ATTN_INDICATOR ? "Yes":"No");

	PCIE_DBG("Power Indicator Present  = %s\n",
	    capabilities & PCIE_SLOTCAP_PWR_INDICATOR ? "Yes":"No");

	PCIE_DBG("HotPlug Surprise	   = %s\n",
	    capabilities & PCIE_SLOTCAP_HP_SURPRISE ? "Yes":"No");

	PCIE_DBG("HotPlug Capable	   = %s\n",
	    capabilities & PCIE_SLOTCAP_HP_CAPABLE ? "Yes":"No");

	PCIE_DBG("Physical Slot Number	   = %d\n",
	    PCIE_SLOTCAP_PHY_SLOT_NUM(capabilities));

	PCIE_DBG("Attn Button interrupt Enabled  = %s\n",
	    control & PCIE_SLOTCTL_ATTN_BTN_EN ? "Yes":"No");

	PCIE_DBG("Power Fault interrupt Enabled  = %s\n",
	    control & PCIE_SLOTCTL_PWR_FAULT_EN ? "Yes":"No");

	PCIE_DBG("MRL Sensor INTR Enabled   = %s\n",
	    control & PCIE_SLOTCTL_MRL_SENSOR_EN ? "Yes":"No");

	PCIE_DBG("Presence interrupt Enabled	 = %s\n",
	    control & PCIE_SLOTCTL_PRESENCE_CHANGE_EN ? "Yes":"No");

	PCIE_DBG("Cmd Complete interrupt Enabled = %s\n",
	    control & PCIE_SLOTCTL_CMD_INTR_EN ? "Yes":"No");

	PCIE_DBG("HotPlug interrupt Enabled	 = %s\n",
	    control & PCIE_SLOTCTL_HP_INTR_EN ? "Yes":"No");

	PCIE_DBG("Power Indicator LED = %s", pcie_led_state_text(
	    pciehpc_led_state_to_hpc(pcie_slotctl_pwr_indicator_get(control))));

	PCIE_DBG("Attn Indicator LED = %s\n",
	    pcie_led_state_text(pciehpc_led_state_to_hpc(
	    pcie_slotctl_attn_indicator_get(control))));
}
#endif	/* DEBUG */