126947304SEvan Yan /*
226947304SEvan Yan  * CDDL HEADER START
326947304SEvan Yan  *
426947304SEvan Yan  * The contents of this file are subject to the terms of the
526947304SEvan Yan  * Common Development and Distribution License (the "License").
626947304SEvan Yan  * You may not use this file except in compliance with the License.
726947304SEvan Yan  *
826947304SEvan Yan  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
926947304SEvan Yan  * or http://www.opensolaris.org/os/licensing.
1026947304SEvan Yan  * See the License for the specific language governing permissions
1126947304SEvan Yan  * and limitations under the License.
1226947304SEvan Yan  *
1326947304SEvan Yan  * When distributing Covered Code, include this CDDL HEADER in each
1426947304SEvan Yan  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
1526947304SEvan Yan  * If applicable, add the following below this CDDL HEADER, with the
1626947304SEvan Yan  * fields enclosed by brackets "[]" replaced with your own identifying
1726947304SEvan Yan  * information: Portions Copyright [yyyy] [name of copyright owner]
1826947304SEvan Yan  *
1926947304SEvan Yan  * CDDL HEADER END
2026947304SEvan Yan  */
2126947304SEvan Yan 
2226947304SEvan Yan /*
2380dc702dSColin Zou - Sun Microsystems - Beijing China  * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
24b3d69c05SRobert Mustacchi  * Copyright 2019 Joyent, Inc.
2526947304SEvan Yan  */
2626947304SEvan Yan 
2726947304SEvan Yan /*
2826947304SEvan Yan  * This file contains Standard PCI Express HotPlug functionality that is
2926947304SEvan Yan  * compatible with the PCI Express ver 1.1 specification.
3026947304SEvan Yan  *
3126947304SEvan Yan  * NOTE: This file is compiled and delivered through misc/pcie module.
3226947304SEvan Yan  */
3326947304SEvan Yan 
3426947304SEvan Yan #include <sys/types.h>
3526947304SEvan Yan #include <sys/note.h>
3626947304SEvan Yan #include <sys/conf.h>
3726947304SEvan Yan #include <sys/kmem.h>
3826947304SEvan Yan #include <sys/debug.h>
3926947304SEvan Yan #include <sys/vtrace.h>
4026947304SEvan Yan #include <sys/autoconf.h>
4126947304SEvan Yan #include <sys/varargs.h>
4226947304SEvan Yan #include <sys/ddi_impldefs.h>
4326947304SEvan Yan #include <sys/time.h>
4426947304SEvan Yan #include <sys/callb.h>
4526947304SEvan Yan #include <sys/ddi.h>
4626947304SEvan Yan #include <sys/sunddi.h>
4726947304SEvan Yan #include <sys/sunndi.h>
4826947304SEvan Yan #include <sys/sysevent/dr.h>
4926947304SEvan Yan #include <sys/pci_impl.h>
5026947304SEvan Yan #include <sys/hotplug/pci/pcie_hp.h>
5126947304SEvan Yan #include <sys/hotplug/pci/pciehpc.h>
5226947304SEvan Yan 
5326947304SEvan Yan typedef struct pciehpc_prop {
5426947304SEvan Yan 	char	*prop_name;
5526947304SEvan Yan 	char	*prop_value;
5626947304SEvan Yan } pciehpc_prop_t;
5726947304SEvan Yan 
5826947304SEvan Yan static pciehpc_prop_t	pciehpc_props[] = {
5926947304SEvan Yan 	{ PCIEHPC_PROP_LED_FAULT,	PCIEHPC_PROP_VALUE_LED },
6026947304SEvan Yan 	{ PCIEHPC_PROP_LED_POWER,	PCIEHPC_PROP_VALUE_LED },
6126947304SEvan Yan 	{ PCIEHPC_PROP_LED_ATTN,	PCIEHPC_PROP_VALUE_LED },
6226947304SEvan Yan 	{ PCIEHPC_PROP_LED_ACTIVE,	PCIEHPC_PROP_VALUE_LED },
6326947304SEvan Yan 	{ PCIEHPC_PROP_CARD_TYPE,	PCIEHPC_PROP_VALUE_TYPE },
6426947304SEvan Yan 	{ PCIEHPC_PROP_BOARD_TYPE,	PCIEHPC_PROP_VALUE_TYPE },
6526947304SEvan Yan 	{ PCIEHPC_PROP_SLOT_CONDITION,	PCIEHPC_PROP_VALUE_TYPE }
6626947304SEvan Yan };
6726947304SEvan Yan 
6826947304SEvan Yan /* Local functions prototype */
6926947304SEvan Yan static int pciehpc_hpc_init(pcie_hp_ctrl_t *ctrl_p);
7026947304SEvan Yan static int pciehpc_hpc_uninit(pcie_hp_ctrl_t *ctrl_p);
7126947304SEvan Yan static int pciehpc_slotinfo_init(pcie_hp_ctrl_t *ctrl_p);
7226947304SEvan Yan static int pciehpc_slotinfo_uninit(pcie_hp_ctrl_t *ctrl_p);
7326947304SEvan Yan static int pciehpc_enable_intr(pcie_hp_ctrl_t *ctrl_p);
7426947304SEvan Yan static int pciehpc_disable_intr(pcie_hp_ctrl_t *ctrl_p);
7526947304SEvan Yan static pcie_hp_ctrl_t *pciehpc_create_controller(dev_info_t *dip);
7626947304SEvan Yan static void pciehpc_destroy_controller(dev_info_t *dip);
7726947304SEvan Yan static int pciehpc_register_slot(pcie_hp_ctrl_t *ctrl_p);
7826947304SEvan Yan static int pciehpc_unregister_slot(pcie_hp_ctrl_t *ctrl_p);
7926947304SEvan Yan static int pciehpc_slot_get_property(pcie_hp_slot_t *slot_p,
8026947304SEvan Yan     ddi_hp_property_t *arg, ddi_hp_property_t *rval);
8126947304SEvan Yan static int pciehpc_slot_set_property(pcie_hp_slot_t *slot_p,
8226947304SEvan Yan     ddi_hp_property_t *arg, ddi_hp_property_t *rval);
8326947304SEvan Yan static void pciehpc_issue_hpc_command(pcie_hp_ctrl_t *ctrl_p, uint16_t control);
8426947304SEvan Yan static void pciehpc_attn_btn_handler(pcie_hp_ctrl_t *ctrl_p);
8526947304SEvan Yan static pcie_hp_led_state_t pciehpc_led_state_to_hpc(uint16_t state);
8626947304SEvan Yan static pcie_hp_led_state_t pciehpc_get_led_state(pcie_hp_ctrl_t *ctrl_p,
8726947304SEvan Yan     pcie_hp_led_t led);
8826947304SEvan Yan static void pciehpc_set_led_state(pcie_hp_ctrl_t *ctrl_p, pcie_hp_led_t led,
8926947304SEvan Yan     pcie_hp_led_state_t state);
9026947304SEvan Yan 
9126947304SEvan Yan static int pciehpc_upgrade_slot_state(pcie_hp_slot_t *slot_p,
9226947304SEvan Yan     ddi_hp_cn_state_t target_state);
9326947304SEvan Yan static int pciehpc_downgrade_slot_state(pcie_hp_slot_t *slot_p,
9426947304SEvan Yan     ddi_hp_cn_state_t target_state);
9526947304SEvan Yan static int pciehpc_change_slot_state(pcie_hp_slot_t *slot_p,
9626947304SEvan Yan     ddi_hp_cn_state_t target_state);
9726947304SEvan Yan static int
9826947304SEvan Yan     pciehpc_slot_poweron(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t *result);
9926947304SEvan Yan static int
10026947304SEvan Yan     pciehpc_slot_poweroff(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t *result);
10126947304SEvan Yan static int pciehpc_slot_probe(pcie_hp_slot_t *slot_p);
10226947304SEvan Yan static int pciehpc_slot_unprobe(pcie_hp_slot_t *slot_p);
10380dc702dSColin Zou - Sun Microsystems - Beijing China static void pciehpc_handle_power_fault(dev_info_t *dip);
10480dc702dSColin Zou - Sun Microsystems - Beijing China static void pciehpc_power_fault_handler(void *arg);
10526947304SEvan Yan 
10626947304SEvan Yan #ifdef	DEBUG
10726947304SEvan Yan static void pciehpc_dump_hpregs(pcie_hp_ctrl_t *ctrl_p);
10826947304SEvan Yan #endif	/* DEBUG */
10926947304SEvan Yan 
11026947304SEvan Yan /*
11126947304SEvan Yan  * Global functions (called by other drivers/modules)
11226947304SEvan Yan  */
11326947304SEvan Yan 
11426947304SEvan Yan /*
11526947304SEvan Yan  * Initialize Hot Plug Controller if present. The arguments are:
11626947304SEvan Yan  *	dip	- Devinfo node pointer to the hot plug bus node
11726947304SEvan Yan  *	regops	- register ops to access HPC registers for non-standard
11826947304SEvan Yan  *		  HPC hw implementations (e.g: HPC in host PCI-E brdiges)
11926947304SEvan Yan  *		  This is NULL for standard HPC in PCIe bridges.
12026947304SEvan Yan  * Returns:
12126947304SEvan Yan  *	DDI_SUCCESS for successful HPC initialization
12226947304SEvan Yan  *	DDI_FAILURE for errors or if HPC hw not found
12326947304SEvan Yan  */
12426947304SEvan Yan int
12526947304SEvan Yan pciehpc_init(dev_info_t *dip, caddr_t arg)
12626947304SEvan Yan {
12726947304SEvan Yan 	pcie_hp_regops_t	*regops = (pcie_hp_regops_t *)(void *)arg;
12826947304SEvan Yan 	pcie_hp_ctrl_t		*ctrl_p;
12926947304SEvan Yan 
13026947304SEvan Yan 	PCIE_DBG("pciehpc_init() called (dip=%p)\n", (void *)dip);
13126947304SEvan Yan 
13226947304SEvan Yan 	/* Make sure that it is not already initialized */
13326947304SEvan Yan 	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) != NULL) {
13426947304SEvan Yan 		PCIE_DBG("%s%d: pciehpc instance already initialized!\n",
13526947304SEvan Yan 		    ddi_driver_name(dip), ddi_get_instance(dip));
13626947304SEvan Yan 		return (DDI_SUCCESS);
13726947304SEvan Yan 	}
13826947304SEvan Yan 
13926947304SEvan Yan 	/* Allocate a new hotplug controller and slot structures */
14026947304SEvan Yan 	ctrl_p = pciehpc_create_controller(dip);
14126947304SEvan Yan 
14226947304SEvan Yan 	/* setup access handle for HPC regs */
14326947304SEvan Yan 	if (regops != NULL) {
14426947304SEvan Yan 		/* HPC access is non-standard; use the supplied reg ops */
14526947304SEvan Yan 		ctrl_p->hc_regops = *regops;
14626947304SEvan Yan 	}
14726947304SEvan Yan 
14826947304SEvan Yan 	/*
14926947304SEvan Yan 	 * Setup resource maps for this bus node.
15026947304SEvan Yan 	 */
15126947304SEvan Yan 	(void) pci_resource_setup(dip);
15226947304SEvan Yan 
15326947304SEvan Yan 	PCIE_DISABLE_ERRORS(dip);
15426947304SEvan Yan 
15526947304SEvan Yan 	/*
15626947304SEvan Yan 	 * Set the platform specific hot plug mode.
15726947304SEvan Yan 	 */
15826947304SEvan Yan 	ctrl_p->hc_ops.init_hpc_hw = pciehpc_hpc_init;
15926947304SEvan Yan 	ctrl_p->hc_ops.uninit_hpc_hw = pciehpc_hpc_uninit;
16026947304SEvan Yan 	ctrl_p->hc_ops.init_hpc_slotinfo = pciehpc_slotinfo_init;
16126947304SEvan Yan 	ctrl_p->hc_ops.uninit_hpc_slotinfo = pciehpc_slotinfo_uninit;
16226947304SEvan Yan 	ctrl_p->hc_ops.poweron_hpc_slot = pciehpc_slot_poweron;
16326947304SEvan Yan 	ctrl_p->hc_ops.poweroff_hpc_slot = pciehpc_slot_poweroff;
16426947304SEvan Yan 
16526947304SEvan Yan 	ctrl_p->hc_ops.enable_hpc_intr = pciehpc_enable_intr;
16626947304SEvan Yan 	ctrl_p->hc_ops.disable_hpc_intr = pciehpc_disable_intr;
16726947304SEvan Yan 
16826947304SEvan Yan #if	defined(__i386) || defined(__amd64)
16926947304SEvan Yan 	pciehpc_update_ops(ctrl_p);
17026947304SEvan Yan #endif
17126947304SEvan Yan 
17226947304SEvan Yan 	/* initialize hot plug controller hw */
17326947304SEvan Yan 	if ((ctrl_p->hc_ops.init_hpc_hw)(ctrl_p) != DDI_SUCCESS)
17426947304SEvan Yan 		goto cleanup1;
17526947304SEvan Yan 
17626947304SEvan Yan 	/* initialize slot information soft state structure */
17726947304SEvan Yan 	if ((ctrl_p->hc_ops.init_hpc_slotinfo)(ctrl_p) != DDI_SUCCESS)
17826947304SEvan Yan 		goto cleanup2;
17926947304SEvan Yan 
18026947304SEvan Yan 	/* register the hot plug slot with DDI HP framework */
18126947304SEvan Yan 	if (pciehpc_register_slot(ctrl_p) != DDI_SUCCESS)
18226947304SEvan Yan 		goto cleanup3;
18326947304SEvan Yan 
18426947304SEvan Yan 	/* create minor node for this slot */
18526947304SEvan Yan 	if (pcie_create_minor_node(ctrl_p, 0) != DDI_SUCCESS)
18626947304SEvan Yan 		goto cleanup4;
18726947304SEvan Yan 
18826947304SEvan Yan 	/* HPC initialization is complete now */
18926947304SEvan Yan 	ctrl_p->hc_flags = PCIE_HP_INITIALIZED_FLAG;
19026947304SEvan Yan 
19126947304SEvan Yan #ifdef	DEBUG
19226947304SEvan Yan 	/* For debug, dump the HPC registers */
19326947304SEvan Yan 	pciehpc_dump_hpregs(ctrl_p);
19426947304SEvan Yan #endif	/* DEBUG */
19526947304SEvan Yan 
19626947304SEvan Yan 	return (DDI_SUCCESS);
19726947304SEvan Yan cleanup4:
19826947304SEvan Yan 	(void) pciehpc_unregister_slot(ctrl_p);
19926947304SEvan Yan cleanup3:
20026947304SEvan Yan 	(void) (ctrl_p->hc_ops.uninit_hpc_slotinfo)(ctrl_p);
20126947304SEvan Yan 
20226947304SEvan Yan cleanup2:
20326947304SEvan Yan 	(void) (ctrl_p->hc_ops.uninit_hpc_hw)(ctrl_p);
20426947304SEvan Yan 
20526947304SEvan Yan cleanup1:
20626947304SEvan Yan 	PCIE_ENABLE_ERRORS(dip);
20726947304SEvan Yan 	(void) pci_resource_destroy(dip);
20826947304SEvan Yan 
20926947304SEvan Yan 	pciehpc_destroy_controller(dip);
21026947304SEvan Yan 	return (DDI_FAILURE);
21126947304SEvan Yan }
21226947304SEvan Yan 
21326947304SEvan Yan /*
21426947304SEvan Yan  * Uninitialize HPC soft state structure and free up any resources
21526947304SEvan Yan  * used for the HPC instance.
21626947304SEvan Yan  */
21726947304SEvan Yan int
21826947304SEvan Yan pciehpc_uninit(dev_info_t *dip)
21926947304SEvan Yan {
22026947304SEvan Yan 	pcie_hp_ctrl_t *ctrl_p;
22126947304SEvan Yan 
22226947304SEvan Yan 	PCIE_DBG("pciehpc_uninit() called (dip=%p)\n", (void *)dip);
22326947304SEvan Yan 
22426947304SEvan Yan 	/* get the soft state structure for this dip */
22526947304SEvan Yan 	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL) {
22626947304SEvan Yan 		return (DDI_FAILURE);
22726947304SEvan Yan 	}
22826947304SEvan Yan 
22926947304SEvan Yan 	pcie_remove_minor_node(ctrl_p, 0);
23026947304SEvan Yan 
23126947304SEvan Yan 	/* unregister the slot */
23226947304SEvan Yan 	(void) pciehpc_unregister_slot(ctrl_p);
23326947304SEvan Yan 
23426947304SEvan Yan 	/* uninit any slot info data structures */
23526947304SEvan Yan 	(void) (ctrl_p->hc_ops.uninit_hpc_slotinfo)(ctrl_p);
23626947304SEvan Yan 
23726947304SEvan Yan 	/* uninitialize hpc, remove interrupt handler, etc. */
23826947304SEvan Yan 	(void) (ctrl_p->hc_ops.uninit_hpc_hw)(ctrl_p);
23926947304SEvan Yan 
24026947304SEvan Yan 	PCIE_ENABLE_ERRORS(dip);
24126947304SEvan Yan 
24226947304SEvan Yan 	/*
24326947304SEvan Yan 	 * Destroy resource maps for this bus node.
24426947304SEvan Yan 	 */
24526947304SEvan Yan 	(void) pci_resource_destroy(dip);
24626947304SEvan Yan 
24726947304SEvan Yan 	/* destroy the soft state structure */
24826947304SEvan Yan 	pciehpc_destroy_controller(dip);
24926947304SEvan Yan 
25026947304SEvan Yan 	return (DDI_SUCCESS);
25126947304SEvan Yan }
25226947304SEvan Yan 
25326947304SEvan Yan /*
25426947304SEvan Yan  * pciehpc_intr()
25526947304SEvan Yan  *
25626947304SEvan Yan  * Interrupt handler for PCI-E Hot plug controller interrupts.
25726947304SEvan Yan  *
25826947304SEvan Yan  * Note: This is only for native mode hot plug. This is called
25926947304SEvan Yan  * by the nexus driver at interrupt context. Interrupt Service Routine
26026947304SEvan Yan  * registration is done by the nexus driver for both hot plug and
26126947304SEvan Yan  * non-hot plug interrupts. This function is called from the ISR
26226947304SEvan Yan  * of the nexus driver to handle hot-plug interrupts.
26326947304SEvan Yan  */
26426947304SEvan Yan int
26526947304SEvan Yan pciehpc_intr(dev_info_t *dip)
26626947304SEvan Yan {
26726947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p;
26826947304SEvan Yan 	pcie_hp_slot_t	*slot_p;
26926947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);
27026947304SEvan Yan 	uint16_t	status, control;
27126947304SEvan Yan 
27226947304SEvan Yan 	/* get the soft state structure for this dip */
27326947304SEvan Yan 	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL)
27426947304SEvan Yan 		return (DDI_INTR_UNCLAIMED);
27526947304SEvan Yan 
27626947304SEvan Yan 	mutex_enter(&ctrl_p->hc_mutex);
27726947304SEvan Yan 
27826947304SEvan Yan 	/* make sure the controller soft state is initialized */
27926947304SEvan Yan 	if (!(ctrl_p->hc_flags & PCIE_HP_INITIALIZED_FLAG)) {
28026947304SEvan Yan 		mutex_exit(&ctrl_p->hc_mutex);
28126947304SEvan Yan 		return (DDI_INTR_UNCLAIMED);
28226947304SEvan Yan 	}
28326947304SEvan Yan 
28426947304SEvan Yan 	/* if it is not NATIVE hot plug mode then return */
28526947304SEvan Yan 	if (bus_p->bus_hp_curr_mode != PCIE_NATIVE_HP_MODE) {
28626947304SEvan Yan 		mutex_exit(&ctrl_p->hc_mutex);
28726947304SEvan Yan 		return (DDI_INTR_UNCLAIMED);
28826947304SEvan Yan 	}
28926947304SEvan Yan 
29026947304SEvan Yan 	slot_p = ctrl_p->hc_slots[0];
29126947304SEvan Yan 
29226947304SEvan Yan 	/* read the current slot status register */
29326947304SEvan Yan 	status = pciehpc_reg_get16(ctrl_p,
29426947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
29526947304SEvan Yan 
29626947304SEvan Yan 	/* check if there are any hot plug interrupts occurred */
29726947304SEvan Yan 	if (!(status & PCIE_SLOTSTS_STATUS_EVENTS)) {
29826947304SEvan Yan 		/* no hot plug events occurred */
29926947304SEvan Yan 		mutex_exit(&ctrl_p->hc_mutex);
30026947304SEvan Yan 		return (DDI_INTR_UNCLAIMED);
30126947304SEvan Yan 	}
30226947304SEvan Yan 
30326947304SEvan Yan 	/* clear the interrupt status bits */
30426947304SEvan Yan 	pciehpc_reg_put16(ctrl_p,
30526947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS, status);
30626947304SEvan Yan 
30726947304SEvan Yan 	/* check for CMD COMPLETE interrupt */
30826947304SEvan Yan 	if (status & PCIE_SLOTSTS_COMMAND_COMPLETED) {
30926947304SEvan Yan 		PCIE_DBG("pciehpc_intr(): CMD COMPLETED interrupt received\n");
31026947304SEvan Yan 		/* wake up any one waiting for Command Completion event */
31126947304SEvan Yan 		cv_signal(&ctrl_p->hc_cmd_comp_cv);
31226947304SEvan Yan 	}
31326947304SEvan Yan 
31426947304SEvan Yan 	/* check for ATTN button interrupt */
31526947304SEvan Yan 	if (status & PCIE_SLOTSTS_ATTN_BTN_PRESSED) {
31626947304SEvan Yan 		PCIE_DBG("pciehpc_intr(): ATTN BUTTON interrupt received\n");
31726947304SEvan Yan 
31826947304SEvan Yan 		/* if ATTN button event is still pending then cancel it */
31926947304SEvan Yan 		if (slot_p->hs_attn_btn_pending == B_TRUE)
32026947304SEvan Yan 			slot_p->hs_attn_btn_pending = B_FALSE;
32126947304SEvan Yan 		else
32226947304SEvan Yan 			slot_p->hs_attn_btn_pending = B_TRUE;
32326947304SEvan Yan 
32426947304SEvan Yan 		/* wake up the ATTN event handler */
32526947304SEvan Yan 		cv_signal(&slot_p->hs_attn_btn_cv);
32626947304SEvan Yan 	}
32726947304SEvan Yan 
32826947304SEvan Yan 	/* check for power fault interrupt */
32926947304SEvan Yan 	if (status & PCIE_SLOTSTS_PWR_FAULT_DETECTED) {
33026947304SEvan Yan 
33126947304SEvan Yan 		PCIE_DBG("pciehpc_intr(): POWER FAULT interrupt received"
33226947304SEvan Yan 		    " on slot %d\n", slot_p->hs_phy_slot_num);
33326947304SEvan Yan 		control =  pciehpc_reg_get16(ctrl_p,
33426947304SEvan Yan 		    bus_p->bus_pcie_off + PCIE_SLOTCTL);
33526947304SEvan Yan 
33626947304SEvan Yan 		if (control & PCIE_SLOTCTL_PWR_FAULT_EN) {
33726947304SEvan Yan 			slot_p->hs_condition = AP_COND_FAILED;
33826947304SEvan Yan 
33926947304SEvan Yan 			/* disable power fault detction interrupt */
34026947304SEvan Yan 			pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off +
34126947304SEvan Yan 			    PCIE_SLOTCTL, control & ~PCIE_SLOTCTL_PWR_FAULT_EN);
34226947304SEvan Yan 
34380dc702dSColin Zou - Sun Microsystems - Beijing China 			pciehpc_handle_power_fault(dip);
34426947304SEvan Yan 		}
34526947304SEvan Yan 	}
34626947304SEvan Yan 
34726947304SEvan Yan 	/* check for MRL SENSOR CHANGED interrupt */
34826947304SEvan Yan 	if (status & PCIE_SLOTSTS_MRL_SENSOR_CHANGED) {
34926947304SEvan Yan 		/* For now (phase-I), no action is taken on this event */
35026947304SEvan Yan 		PCIE_DBG("pciehpc_intr(): MRL SENSOR CHANGED interrupt received"
35126947304SEvan Yan 		    " on slot %d\n", slot_p->hs_phy_slot_num);
35226947304SEvan Yan 	}
35326947304SEvan Yan 
35426947304SEvan Yan 	/* check for PRESENCE CHANGED interrupt */
35526947304SEvan Yan 	if (status & PCIE_SLOTSTS_PRESENCE_CHANGED) {
35626947304SEvan Yan 
35726947304SEvan Yan 		PCIE_DBG("pciehpc_intr(): PRESENCE CHANGED interrupt received"
35826947304SEvan Yan 		    " on slot %d\n", slot_p->hs_phy_slot_num);
35926947304SEvan Yan 
36026947304SEvan Yan 		if (status & PCIE_SLOTSTS_PRESENCE_DETECTED) {
36126947304SEvan Yan 			/*
36226947304SEvan Yan 			 * card is inserted into the slot, ask DDI Hotplug
36326947304SEvan Yan 			 * framework to change state to Present.
36426947304SEvan Yan 			 */
36570f83219SEvan Yan 			cmn_err(CE_NOTE, "pciehpc (%s%d): card is inserted"
36670f83219SEvan Yan 			    " in the slot %s",
36770f83219SEvan Yan 			    ddi_driver_name(dip),
36870f83219SEvan Yan 			    ddi_get_instance(dip),
36970f83219SEvan Yan 			    slot_p->hs_info.cn_name);
37070f83219SEvan Yan 
37126947304SEvan Yan 			(void) ndi_hp_state_change_req(dip,
37226947304SEvan Yan 			    slot_p->hs_info.cn_name,
37326947304SEvan Yan 			    DDI_HP_CN_STATE_PRESENT,
37426947304SEvan Yan 			    DDI_HP_REQ_ASYNC);
37526947304SEvan Yan 		} else { /* card is removed from the slot */
37626947304SEvan Yan 			cmn_err(CE_NOTE, "pciehpc (%s%d): card is removed"
37726947304SEvan Yan 			    " from the slot %s",
37826947304SEvan Yan 			    ddi_driver_name(dip),
37926947304SEvan Yan 			    ddi_get_instance(dip),
38026947304SEvan Yan 			    slot_p->hs_info.cn_name);
38126947304SEvan Yan 
38226947304SEvan Yan 			if (slot_p->hs_info.cn_state ==
38326947304SEvan Yan 			    DDI_HP_CN_STATE_ENABLED) {
38426947304SEvan Yan 				/* Card is removed when slot is enabled */
38526947304SEvan Yan 				slot_p->hs_condition = AP_COND_FAILED;
38626947304SEvan Yan 			} else {
38726947304SEvan Yan 				slot_p->hs_condition = AP_COND_UNKNOWN;
38826947304SEvan Yan 			}
38926947304SEvan Yan 			/* make sure to disable power fault detction intr */
39026947304SEvan Yan 			control =  pciehpc_reg_get16(ctrl_p,
39126947304SEvan Yan 			    bus_p->bus_pcie_off + PCIE_SLOTCTL);
39226947304SEvan Yan 
39326947304SEvan Yan 			if (control & PCIE_SLOTCTL_PWR_FAULT_EN)
39426947304SEvan Yan 				pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off +
39526947304SEvan Yan 				    PCIE_SLOTCTL,
39626947304SEvan Yan 				    control & ~PCIE_SLOTCTL_PWR_FAULT_EN);
39726947304SEvan Yan 
398*ffb64830SJordan Paige Hendricks 			/*
399*ffb64830SJordan Paige Hendricks 			 * If supported, notify the child device driver that the
400*ffb64830SJordan Paige Hendricks 			 * device is being removed.
401*ffb64830SJordan Paige Hendricks 			 */
402*ffb64830SJordan Paige Hendricks 			dev_info_t *cdip = ddi_get_child(dip);
403*ffb64830SJordan Paige Hendricks 			if (cdip != NULL) {
404*ffb64830SJordan Paige Hendricks 				ddi_eventcookie_t rm_cookie;
405*ffb64830SJordan Paige Hendricks 				if (ddi_get_eventcookie(cdip,
406*ffb64830SJordan Paige Hendricks 				    DDI_DEVI_REMOVE_EVENT,
407*ffb64830SJordan Paige Hendricks 				    &rm_cookie) == DDI_SUCCESS) {
408*ffb64830SJordan Paige Hendricks 					ndi_post_event(dip, cdip, rm_cookie,
409*ffb64830SJordan Paige Hendricks 					    NULL);
410*ffb64830SJordan Paige Hendricks 				}
411*ffb64830SJordan Paige Hendricks 			}
412*ffb64830SJordan Paige Hendricks 
41326947304SEvan Yan 			/*
41426947304SEvan Yan 			 * Ask DDI Hotplug framework to change state to Empty
41526947304SEvan Yan 			 */
41626947304SEvan Yan 			(void) ndi_hp_state_change_req(dip,
41726947304SEvan Yan 			    slot_p->hs_info.cn_name,
41826947304SEvan Yan 			    DDI_HP_CN_STATE_EMPTY,
41926947304SEvan Yan 			    DDI_HP_REQ_ASYNC);
42026947304SEvan Yan 		}
42126947304SEvan Yan 	}
42226947304SEvan Yan 
42326947304SEvan Yan 	/* check for DLL state changed interrupt */
42426947304SEvan Yan 	if (ctrl_p->hc_dll_active_rep &&
42526947304SEvan Yan 	    (status & PCIE_SLOTSTS_DLL_STATE_CHANGED)) {
42626947304SEvan Yan 		PCIE_DBG("pciehpc_intr(): DLL STATE CHANGED interrupt received"
42726947304SEvan Yan 		    " on slot %d\n", slot_p->hs_phy_slot_num);
42826947304SEvan Yan 
42926947304SEvan Yan 		cv_signal(&slot_p->hs_dll_active_cv);
43026947304SEvan Yan 	}
43126947304SEvan Yan 
43226947304SEvan Yan 	mutex_exit(&ctrl_p->hc_mutex);
43326947304SEvan Yan 
43426947304SEvan Yan 	return (DDI_INTR_CLAIMED);
43526947304SEvan Yan }
43626947304SEvan Yan 
43726947304SEvan Yan /*
43826947304SEvan Yan  * Handle hotplug commands
43926947304SEvan Yan  *
44026947304SEvan Yan  * Note: This function is called by DDI HP framework at kernel context only
44126947304SEvan Yan  */
44226947304SEvan Yan /* ARGSUSED */
44326947304SEvan Yan int
44426947304SEvan Yan pciehpc_hp_ops(dev_info_t *dip, char *cn_name, ddi_hp_op_t op,
44526947304SEvan Yan     void *arg, void *result)
44626947304SEvan Yan {
44726947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p;
44826947304SEvan Yan 	pcie_hp_slot_t	*slot_p;
44926947304SEvan Yan 	int		ret = DDI_SUCCESS;
45026947304SEvan Yan 
45126947304SEvan Yan 	PCIE_DBG("pciehpc_hp_ops: dip=%p cn_name=%s op=%x arg=%p\n",
45226947304SEvan Yan 	    dip, cn_name, op, arg);
45326947304SEvan Yan 
45426947304SEvan Yan 	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL)
45526947304SEvan Yan 		return (DDI_FAILURE);
45626947304SEvan Yan 
45726947304SEvan Yan 	slot_p = ctrl_p->hc_slots[0];
45826947304SEvan Yan 
45926947304SEvan Yan 	if (strcmp(cn_name, slot_p->hs_info.cn_name) != 0)
46026947304SEvan Yan 		return (DDI_EINVAL);
46126947304SEvan Yan 
46226947304SEvan Yan 	switch (op) {
46326947304SEvan Yan 	case DDI_HPOP_CN_GET_STATE:
46426947304SEvan Yan 	{
46526947304SEvan Yan 		mutex_enter(&slot_p->hs_ctrl->hc_mutex);
46626947304SEvan Yan 
46726947304SEvan Yan 		/* get the current slot state */
46826947304SEvan Yan 		pciehpc_get_slot_state(slot_p);
46926947304SEvan Yan 
47026947304SEvan Yan 		*((ddi_hp_cn_state_t *)result) = slot_p->hs_info.cn_state;
47126947304SEvan Yan 
47226947304SEvan Yan 		mutex_exit(&slot_p->hs_ctrl->hc_mutex);
47326947304SEvan Yan 		break;
47426947304SEvan Yan 	}
47526947304SEvan Yan 	case DDI_HPOP_CN_CHANGE_STATE:
47626947304SEvan Yan 	{
47726947304SEvan Yan 		ddi_hp_cn_state_t target_state = *(ddi_hp_cn_state_t *)arg;
47826947304SEvan Yan 
47926947304SEvan Yan 		mutex_enter(&slot_p->hs_ctrl->hc_mutex);
48026947304SEvan Yan 
48126947304SEvan Yan 		ret = pciehpc_change_slot_state(slot_p, target_state);
48226947304SEvan Yan 		*(ddi_hp_cn_state_t *)result = slot_p->hs_info.cn_state;
48326947304SEvan Yan 
48426947304SEvan Yan 		mutex_exit(&slot_p->hs_ctrl->hc_mutex);
48526947304SEvan Yan 		break;
48626947304SEvan Yan 	}
48726947304SEvan Yan 	case DDI_HPOP_CN_PROBE:
48826947304SEvan Yan 
48926947304SEvan Yan 		ret = pciehpc_slot_probe(slot_p);
49026947304SEvan Yan 
49126947304SEvan Yan 		break;
49226947304SEvan Yan 	case DDI_HPOP_CN_UNPROBE:
49326947304SEvan Yan 		ret = pciehpc_slot_unprobe(slot_p);
49426947304SEvan Yan 
49526947304SEvan Yan 		break;
49626947304SEvan Yan 	case DDI_HPOP_CN_GET_PROPERTY:
49726947304SEvan Yan 		ret = pciehpc_slot_get_property(slot_p,
49826947304SEvan Yan 		    (ddi_hp_property_t *)arg, (ddi_hp_property_t *)result);
49926947304SEvan Yan 		break;
50026947304SEvan Yan 	case DDI_HPOP_CN_SET_PROPERTY:
50126947304SEvan Yan 		ret = pciehpc_slot_set_property(slot_p,
50226947304SEvan Yan 		    (ddi_hp_property_t *)arg, (ddi_hp_property_t *)result);
50326947304SEvan Yan 		break;
50426947304SEvan Yan 	default:
50526947304SEvan Yan 		ret = DDI_ENOTSUP;
50626947304SEvan Yan 		break;
50726947304SEvan Yan 	}
50826947304SEvan Yan 
50926947304SEvan Yan 	return (ret);
51026947304SEvan Yan }
51126947304SEvan Yan 
51226947304SEvan Yan /*
51326947304SEvan Yan  * Get the current state of the slot from the hw.
51426947304SEvan Yan  *
51526947304SEvan Yan  * The slot state should have been initialized before this function gets called.
51626947304SEvan Yan  */
51726947304SEvan Yan void
51826947304SEvan Yan pciehpc_get_slot_state(pcie_hp_slot_t *slot_p)
51926947304SEvan Yan {
52026947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
52126947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
52226947304SEvan Yan 	uint16_t	control, status;
52326947304SEvan Yan 	ddi_hp_cn_state_t curr_state = slot_p->hs_info.cn_state;
52426947304SEvan Yan 
52526947304SEvan Yan 	/* read the Slot Control Register */
52626947304SEvan Yan 	control = pciehpc_reg_get16(ctrl_p,
52726947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
52826947304SEvan Yan 
52926947304SEvan Yan 	slot_p->hs_fault_led_state = PCIE_HP_LED_OFF; /* no fault led */
53026947304SEvan Yan 	slot_p->hs_active_led_state = PCIE_HP_LED_OFF; /* no active led */
53126947304SEvan Yan 
53226947304SEvan Yan 	/* read the current Slot Status Register */
53326947304SEvan Yan 	status = pciehpc_reg_get16(ctrl_p,
53426947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
53526947304SEvan Yan 
53626947304SEvan Yan 	/* get POWER led state */
53726947304SEvan Yan 	slot_p->hs_power_led_state =
53826947304SEvan Yan 	    pciehpc_led_state_to_hpc(pcie_slotctl_pwr_indicator_get(control));
53926947304SEvan Yan 
54026947304SEvan Yan 	/* get ATTN led state */
54126947304SEvan Yan 	slot_p->hs_attn_led_state =
54226947304SEvan Yan 	    pciehpc_led_state_to_hpc(pcie_slotctl_attn_indicator_get(control));
54326947304SEvan Yan 
54426947304SEvan Yan 	if (!(status & PCIE_SLOTSTS_PRESENCE_DETECTED)) {
54526947304SEvan Yan 		/* no device present; slot is empty */
54626947304SEvan Yan 		slot_p->hs_info.cn_state = DDI_HP_CN_STATE_EMPTY;
54726947304SEvan Yan 
54826947304SEvan Yan 		return;
54926947304SEvan Yan 	}
55026947304SEvan Yan 
55126947304SEvan Yan 	/* device is present */
55226947304SEvan Yan 	slot_p->hs_info.cn_state = DDI_HP_CN_STATE_PRESENT;
55326947304SEvan Yan 
55426947304SEvan Yan 	if (!(control & PCIE_SLOTCTL_PWR_CONTROL)) {
55526947304SEvan Yan 		/*
55626947304SEvan Yan 		 * Device is powered on. Set to "ENABLED" state (skip
55726947304SEvan Yan 		 * POWERED state) because there is not a explicit "enable"
55826947304SEvan Yan 		 * action exists for PCIe.
55926947304SEvan Yan 		 * If it is already in "POWERED" state, then keep it until
56026947304SEvan Yan 		 * user explicitly change it to other states.
56126947304SEvan Yan 		 */
56226947304SEvan Yan 		if (curr_state == DDI_HP_CN_STATE_POWERED) {
56326947304SEvan Yan 			slot_p->hs_info.cn_state = curr_state;
56426947304SEvan Yan 		} else {
56526947304SEvan Yan 			slot_p->hs_info.cn_state = DDI_HP_CN_STATE_ENABLED;
56626947304SEvan Yan 		}
56726947304SEvan Yan 	}
56826947304SEvan Yan }
56926947304SEvan Yan 
57026947304SEvan Yan /*
57126947304SEvan Yan  * setup slot name/slot-number info.
57226947304SEvan Yan  */
57326947304SEvan Yan void
57426947304SEvan Yan pciehpc_set_slot_name(pcie_hp_ctrl_t *ctrl_p)
57526947304SEvan Yan {
57626947304SEvan Yan 	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
57726947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
57826947304SEvan Yan 	uchar_t		*slotname_data;
57926947304SEvan Yan 	int		*slotnum;
58026947304SEvan Yan 	uint_t		count;
58126947304SEvan Yan 	int		len;
58226947304SEvan Yan 	int		invalid_slotnum = 0;
58326947304SEvan Yan 	uint32_t	slot_capabilities;
58426947304SEvan Yan 
58526947304SEvan Yan 	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, ctrl_p->hc_dip,
58626947304SEvan Yan 	    DDI_PROP_DONTPASS, "physical-slot#", &slotnum, &count) ==
58726947304SEvan Yan 	    DDI_PROP_SUCCESS) {
58826947304SEvan Yan 		slot_p->hs_phy_slot_num = slotnum[0];
58926947304SEvan Yan 		ddi_prop_free(slotnum);
59026947304SEvan Yan 	} else {
59126947304SEvan Yan 		slot_capabilities = pciehpc_reg_get32(ctrl_p,
59226947304SEvan Yan 		    bus_p->bus_pcie_off + PCIE_SLOTCAP);
59326947304SEvan Yan 		slot_p->hs_phy_slot_num =
59426947304SEvan Yan 		    PCIE_SLOTCAP_PHY_SLOT_NUM(slot_capabilities);
59526947304SEvan Yan 	}
59626947304SEvan Yan 
59726947304SEvan Yan 	/* platform may not have initialized it */
59826947304SEvan Yan 	if (!slot_p->hs_phy_slot_num) {
59926947304SEvan Yan 		PCIE_DBG("%s#%d: Invalid slot number!\n",
60026947304SEvan Yan 		    ddi_driver_name(ctrl_p->hc_dip),
60126947304SEvan Yan 		    ddi_get_instance(ctrl_p->hc_dip));
60226947304SEvan Yan 		slot_p->hs_phy_slot_num = pciehpc_reg_get8(ctrl_p,
60326947304SEvan Yan 		    PCI_BCNF_SECBUS);
60426947304SEvan Yan 		invalid_slotnum = 1;
60526947304SEvan Yan 	}
60626947304SEvan Yan 	slot_p->hs_info.cn_num = slot_p->hs_phy_slot_num;
60726947304SEvan Yan 	slot_p->hs_info.cn_num_dpd_on = DDI_HP_CN_NUM_NONE;
60826947304SEvan Yan 
60926947304SEvan Yan 	/*
61026947304SEvan Yan 	 * construct the slot_name:
61126947304SEvan Yan 	 *	if "slot-names" property exists then use that name
61226947304SEvan Yan 	 *	else if valid slot number exists then it is "pcie<slot-num>".
61326947304SEvan Yan 	 *	else it will be "pcie<sec-bus-number>dev0"
61426947304SEvan Yan 	 */
61526947304SEvan Yan 	if (ddi_getlongprop(DDI_DEV_T_ANY, ctrl_p->hc_dip, DDI_PROP_DONTPASS,
61626947304SEvan Yan 	    "slot-names", (caddr_t)&slotname_data, &len) == DDI_PROP_SUCCESS) {
61726947304SEvan Yan 		char tmp_name[256];
61826947304SEvan Yan 
61926947304SEvan Yan 		/*
62026947304SEvan Yan 		 * Note: for PCI-E slots, the device number is always 0 so the
62126947304SEvan Yan 		 * first (and only) string is the slot name for this slot.
62226947304SEvan Yan 		 */
62326947304SEvan Yan 		(void) snprintf(tmp_name, sizeof (tmp_name),
62426947304SEvan Yan 		    (char *)slotname_data + 4);
62526947304SEvan Yan 		slot_p->hs_info.cn_name = ddi_strdup(tmp_name, KM_SLEEP);
62626947304SEvan Yan 		kmem_free(slotname_data, len);
62726947304SEvan Yan 	} else {
62826947304SEvan Yan 		if (invalid_slotnum) {
62926947304SEvan Yan 			/* use device number ie. 0 */
63026947304SEvan Yan 			slot_p->hs_info.cn_name = ddi_strdup("pcie0",
63126947304SEvan Yan 			    KM_SLEEP);
63226947304SEvan Yan 		} else {
63326947304SEvan Yan 			char tmp_name[256];
63426947304SEvan Yan 
63526947304SEvan Yan 			(void) snprintf(tmp_name, sizeof (tmp_name), "pcie%d",
63626947304SEvan Yan 			    slot_p->hs_phy_slot_num);
63726947304SEvan Yan 			slot_p->hs_info.cn_name = ddi_strdup(tmp_name,
63826947304SEvan Yan 			    KM_SLEEP);
63926947304SEvan Yan 		}
64026947304SEvan Yan 	}
64126947304SEvan Yan }
64226947304SEvan Yan 
64326947304SEvan Yan /*
64426947304SEvan Yan  * Read/Write access to HPC registers. If platform nexus has non-standard
64526947304SEvan Yan  * HPC access mechanism then regops functions are used to do reads/writes.
64626947304SEvan Yan  */
64726947304SEvan Yan uint8_t
64826947304SEvan Yan pciehpc_reg_get8(pcie_hp_ctrl_t *ctrl_p, uint_t off)
64926947304SEvan Yan {
65026947304SEvan Yan 	if (ctrl_p->hc_regops.get != NULL) {
65126947304SEvan Yan 		return ((uint8_t)ctrl_p->hc_regops.get(
65226947304SEvan Yan 		    ctrl_p->hc_regops.cookie, (off_t)off));
65326947304SEvan Yan 	} else {
65426947304SEvan Yan 		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
65526947304SEvan Yan 
65626947304SEvan Yan 		return (pci_config_get8(bus_p->bus_cfg_hdl, off));
65726947304SEvan Yan 	}
65826947304SEvan Yan }
65926947304SEvan Yan 
66026947304SEvan Yan uint16_t
66126947304SEvan Yan pciehpc_reg_get16(pcie_hp_ctrl_t *ctrl_p, uint_t off)
66226947304SEvan Yan {
66326947304SEvan Yan 	if (ctrl_p->hc_regops.get != NULL) {
66426947304SEvan Yan 		return ((uint16_t)ctrl_p->hc_regops.get(
66526947304SEvan Yan 		    ctrl_p->hc_regops.cookie, (off_t)off));
66626947304SEvan Yan 	} else {
66726947304SEvan Yan 		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
66826947304SEvan Yan 
66926947304SEvan Yan 		return (pci_config_get16(bus_p->bus_cfg_hdl, off));
67026947304SEvan Yan 	}
67126947304SEvan Yan }
67226947304SEvan Yan 
67326947304SEvan Yan uint32_t
67426947304SEvan Yan pciehpc_reg_get32(pcie_hp_ctrl_t *ctrl_p, uint_t off)
67526947304SEvan Yan {
67626947304SEvan Yan 	if (ctrl_p->hc_regops.get != NULL) {
67726947304SEvan Yan 		return ((uint32_t)ctrl_p->hc_regops.get(
67826947304SEvan Yan 		    ctrl_p->hc_regops.cookie, (off_t)off));
67926947304SEvan Yan 	} else {
68026947304SEvan Yan 		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
68126947304SEvan Yan 
68226947304SEvan Yan 		return (pci_config_get32(bus_p->bus_cfg_hdl, off));
68326947304SEvan Yan 	}
68426947304SEvan Yan }
68526947304SEvan Yan 
68626947304SEvan Yan void
68726947304SEvan Yan pciehpc_reg_put8(pcie_hp_ctrl_t *ctrl_p, uint_t off, uint8_t val)
68826947304SEvan Yan {
68926947304SEvan Yan 	if (ctrl_p->hc_regops.put != NULL) {
69026947304SEvan Yan 		ctrl_p->hc_regops.put(ctrl_p->hc_regops.cookie,
69126947304SEvan Yan 		    (off_t)off, (uint_t)val);
69226947304SEvan Yan 	} else {
69326947304SEvan Yan 		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
69426947304SEvan Yan 
69526947304SEvan Yan 		pci_config_put8(bus_p->bus_cfg_hdl, off, val);
69626947304SEvan Yan 	}
69726947304SEvan Yan }
69826947304SEvan Yan 
69926947304SEvan Yan void
70026947304SEvan Yan pciehpc_reg_put16(pcie_hp_ctrl_t *ctrl_p, uint_t off, uint16_t val)
70126947304SEvan Yan {
70226947304SEvan Yan 	if (ctrl_p->hc_regops.put != NULL) {
70326947304SEvan Yan 		ctrl_p->hc_regops.put(ctrl_p->hc_regops.cookie,
70426947304SEvan Yan 		    (off_t)off, (uint_t)val);
70526947304SEvan Yan 	} else {
70626947304SEvan Yan 		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
70726947304SEvan Yan 
70826947304SEvan Yan 		pci_config_put16(bus_p->bus_cfg_hdl, off, val);
70926947304SEvan Yan 	}
71026947304SEvan Yan }
71126947304SEvan Yan 
71226947304SEvan Yan void
71326947304SEvan Yan pciehpc_reg_put32(pcie_hp_ctrl_t *ctrl_p, uint_t off, uint32_t val)
71426947304SEvan Yan {
71526947304SEvan Yan 	if (ctrl_p->hc_regops.put != NULL) {
71626947304SEvan Yan 		ctrl_p->hc_regops.put(ctrl_p->hc_regops.cookie,
71726947304SEvan Yan 		    (off_t)off, (uint_t)val);
71826947304SEvan Yan 	} else {
71926947304SEvan Yan 		pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
72026947304SEvan Yan 
72126947304SEvan Yan 		pci_config_put32(bus_p->bus_cfg_hdl, off, val);
72226947304SEvan Yan 	}
72326947304SEvan Yan }
72426947304SEvan Yan 
72526947304SEvan Yan /*
72626947304SEvan Yan  * ************************************************************************
72726947304SEvan Yan  * ***	Local functions (called within this file)
72826947304SEvan Yan  * ***	PCIe Native Hotplug mode specific functions
72926947304SEvan Yan  * ************************************************************************
73026947304SEvan Yan  */
73126947304SEvan Yan 
73226947304SEvan Yan /*
73326947304SEvan Yan  * Initialize HPC hardware, install interrupt handler, etc. It doesn't
73426947304SEvan Yan  * enable hot plug interrupts.
73526947304SEvan Yan  *
73626947304SEvan Yan  * (Note: It is called only from pciehpc_init().)
73726947304SEvan Yan  */
73826947304SEvan Yan static int
73926947304SEvan Yan pciehpc_hpc_init(pcie_hp_ctrl_t *ctrl_p)
74026947304SEvan Yan {
74126947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
74226947304SEvan Yan 	uint16_t	reg;
74326947304SEvan Yan 
74426947304SEvan Yan 	/* read the Slot Control Register */
74526947304SEvan Yan 	reg = pciehpc_reg_get16(ctrl_p,
74626947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
74726947304SEvan Yan 
74826947304SEvan Yan 	/* disable all interrupts */
74926947304SEvan Yan 	reg &= ~(PCIE_SLOTCTL_INTR_MASK);
75026947304SEvan Yan 	pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off +
75126947304SEvan Yan 	    PCIE_SLOTCTL, reg);
75226947304SEvan Yan 
75326947304SEvan Yan 	/* clear any interrupt status bits */
75426947304SEvan Yan 	reg = pciehpc_reg_get16(ctrl_p,
75526947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
75626947304SEvan Yan 	pciehpc_reg_put16(ctrl_p,
75726947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS, reg);
75826947304SEvan Yan 
75926947304SEvan Yan 	return (DDI_SUCCESS);
76026947304SEvan Yan }
76126947304SEvan Yan 
76226947304SEvan Yan /*
76326947304SEvan Yan  * Uninitialize HPC hardware, uninstall interrupt handler, etc.
76426947304SEvan Yan  *
76526947304SEvan Yan  * (Note: It is called only from pciehpc_uninit().)
76626947304SEvan Yan  */
76726947304SEvan Yan static int
76826947304SEvan Yan pciehpc_hpc_uninit(pcie_hp_ctrl_t *ctrl_p)
76926947304SEvan Yan {
77026947304SEvan Yan 	/* disable interrupts */
77126947304SEvan Yan 	(void) pciehpc_disable_intr(ctrl_p);
77226947304SEvan Yan 
77326947304SEvan Yan 	return (DDI_SUCCESS);
77426947304SEvan Yan }
77526947304SEvan Yan 
77626947304SEvan Yan /*
77726947304SEvan Yan  * Setup slot information for use with DDI HP framework.
77826947304SEvan Yan  */
77926947304SEvan Yan static int
78026947304SEvan Yan pciehpc_slotinfo_init(pcie_hp_ctrl_t *ctrl_p)
78126947304SEvan Yan {
78226947304SEvan Yan 	uint32_t	slot_capabilities, link_capabilities;
78326947304SEvan Yan 	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
78426947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
78526947304SEvan Yan 
78626947304SEvan Yan 	mutex_enter(&ctrl_p->hc_mutex);
78726947304SEvan Yan 	/*
78826947304SEvan Yan 	 * setup DDI HP framework slot information structure
78926947304SEvan Yan 	 */
79026947304SEvan Yan 	slot_p->hs_device_num = 0;
79126947304SEvan Yan 
79226947304SEvan Yan 	slot_p->hs_info.cn_type = DDI_HP_CN_TYPE_PCIE;
79326947304SEvan Yan 	slot_p->hs_info.cn_type_str = (ctrl_p->hc_regops.get == NULL) ?
79426947304SEvan Yan 	    PCIE_NATIVE_HP_TYPE : PCIE_PROP_HP_TYPE;
79526947304SEvan Yan 	slot_p->hs_info.cn_child = NULL;
79626947304SEvan Yan 
79726947304SEvan Yan 	slot_p->hs_minor =
79826947304SEvan Yan 	    PCI_MINOR_NUM(ddi_get_instance(ctrl_p->hc_dip),
79926947304SEvan Yan 	    slot_p->hs_device_num);
80026947304SEvan Yan 	slot_p->hs_condition = AP_COND_UNKNOWN;
80126947304SEvan Yan 
80226947304SEvan Yan 	/* read Slot Capabilities Register */
80326947304SEvan Yan 	slot_capabilities = pciehpc_reg_get32(ctrl_p,
80426947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCAP);
80526947304SEvan Yan 
80626947304SEvan Yan 	/* set slot-name/slot-number info */
80726947304SEvan Yan 	pciehpc_set_slot_name(ctrl_p);
80826947304SEvan Yan 
80926947304SEvan Yan 	/* check if Attn Button present */
81026947304SEvan Yan 	ctrl_p->hc_has_attn = (slot_capabilities & PCIE_SLOTCAP_ATTN_BUTTON) ?
81126947304SEvan Yan 	    B_TRUE : B_FALSE;
81226947304SEvan Yan 
81326947304SEvan Yan 	/* check if Manual Retention Latch sensor present */
81426947304SEvan Yan 	ctrl_p->hc_has_mrl = (slot_capabilities & PCIE_SLOTCAP_MRL_SENSOR) ?
81526947304SEvan Yan 	    B_TRUE : B_FALSE;
81626947304SEvan Yan 
81726947304SEvan Yan 	/*
81826947304SEvan Yan 	 * PCI-E version 1.1 defines EMI Lock Present bit
81926947304SEvan Yan 	 * in Slot Capabilities register. Check for it.
82026947304SEvan Yan 	 */
82126947304SEvan Yan 	ctrl_p->hc_has_emi_lock = (slot_capabilities &
82226947304SEvan Yan 	    PCIE_SLOTCAP_EMI_LOCK_PRESENT) ? B_TRUE : B_FALSE;
82326947304SEvan Yan 
82426947304SEvan Yan 	link_capabilities = pciehpc_reg_get32(ctrl_p,
82526947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_LINKCAP);
82626947304SEvan Yan 	ctrl_p->hc_dll_active_rep = (link_capabilities &
82726947304SEvan Yan 	    PCIE_LINKCAP_DLL_ACTIVE_REP_CAPABLE) ? B_TRUE : B_FALSE;
82826947304SEvan Yan 	if (ctrl_p->hc_dll_active_rep)
82926947304SEvan Yan 		cv_init(&slot_p->hs_dll_active_cv, NULL, CV_DRIVER, NULL);
83026947304SEvan Yan 
83126947304SEvan Yan 	/* setup thread for handling ATTN button events */
83226947304SEvan Yan 	if (ctrl_p->hc_has_attn) {
83326947304SEvan Yan 		PCIE_DBG("pciehpc_slotinfo_init: setting up ATTN button event "
83426947304SEvan Yan 		    "handler thread for slot %d\n", slot_p->hs_phy_slot_num);
83526947304SEvan Yan 
83626947304SEvan Yan 		cv_init(&slot_p->hs_attn_btn_cv, NULL, CV_DRIVER, NULL);
83726947304SEvan Yan 		slot_p->hs_attn_btn_pending = B_FALSE;
83826947304SEvan Yan 		slot_p->hs_attn_btn_threadp = thread_create(NULL, 0,
83926947304SEvan Yan 		    pciehpc_attn_btn_handler,
84026947304SEvan Yan 		    (void *)ctrl_p, 0, &p0, TS_RUN, minclsyspri);
84126947304SEvan Yan 		slot_p->hs_attn_btn_thread_exit = B_FALSE;
84226947304SEvan Yan 	}
84326947304SEvan Yan 
84426947304SEvan Yan 	/* get current slot state from the hw */
84526947304SEvan Yan 	slot_p->hs_info.cn_state = DDI_HP_CN_STATE_EMPTY;
84626947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
84726947304SEvan Yan 	if (slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_ENABLED)
84826947304SEvan Yan 		slot_p->hs_condition = AP_COND_OK;
84926947304SEvan Yan 
85026947304SEvan Yan 	mutex_exit(&ctrl_p->hc_mutex);
85126947304SEvan Yan 
85226947304SEvan Yan 	return (DDI_SUCCESS);
85326947304SEvan Yan }
85426947304SEvan Yan 
85526947304SEvan Yan /*ARGSUSED*/
85626947304SEvan Yan static int
85726947304SEvan Yan pciehpc_slotinfo_uninit(pcie_hp_ctrl_t *ctrl_p)
85826947304SEvan Yan {
85926947304SEvan Yan 	pcie_hp_slot_t *slot_p = ctrl_p->hc_slots[0];
86026947304SEvan Yan 
86126947304SEvan Yan 	if (slot_p->hs_attn_btn_threadp != NULL) {
86226947304SEvan Yan 		mutex_enter(&ctrl_p->hc_mutex);
86326947304SEvan Yan 		slot_p->hs_attn_btn_thread_exit = B_TRUE;
86426947304SEvan Yan 		cv_signal(&slot_p->hs_attn_btn_cv);
86526947304SEvan Yan 		PCIE_DBG("pciehpc_slotinfo_uninit: "
86626947304SEvan Yan 		    "waiting for ATTN thread exit\n");
86726947304SEvan Yan 		cv_wait(&slot_p->hs_attn_btn_cv, &ctrl_p->hc_mutex);
86826947304SEvan Yan 		PCIE_DBG("pciehpc_slotinfo_uninit: ATTN thread exit\n");
86926947304SEvan Yan 		cv_destroy(&slot_p->hs_attn_btn_cv);
87026947304SEvan Yan 		slot_p->hs_attn_btn_threadp = NULL;
87126947304SEvan Yan 		mutex_exit(&ctrl_p->hc_mutex);
87226947304SEvan Yan 	}
87326947304SEvan Yan 
87426947304SEvan Yan 	if (ctrl_p->hc_dll_active_rep)
87526947304SEvan Yan 		cv_destroy(&slot_p->hs_dll_active_cv);
87626947304SEvan Yan 	if (slot_p->hs_info.cn_name)
87726947304SEvan Yan 		kmem_free(slot_p->hs_info.cn_name,
87826947304SEvan Yan 		    strlen(slot_p->hs_info.cn_name) + 1);
87926947304SEvan Yan 
88026947304SEvan Yan 	return (DDI_SUCCESS);
88126947304SEvan Yan }
88226947304SEvan Yan 
88326947304SEvan Yan /*
88426947304SEvan Yan  * Enable hot plug interrupts.
88526947304SEvan Yan  * Note: this is only for Native hot plug mode.
88626947304SEvan Yan  */
88726947304SEvan Yan static int
88826947304SEvan Yan pciehpc_enable_intr(pcie_hp_ctrl_t *ctrl_p)
88926947304SEvan Yan {
89026947304SEvan Yan 	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
89126947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
89226947304SEvan Yan 	uint16_t	reg;
89326947304SEvan Yan 
89426947304SEvan Yan 	/* clear any interrupt status bits */
89526947304SEvan Yan 	reg = pciehpc_reg_get16(ctrl_p,
89626947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
89726947304SEvan Yan 	pciehpc_reg_put16(ctrl_p,
89826947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS, reg);
89926947304SEvan Yan 
90026947304SEvan Yan 	/* read the Slot Control Register */
90126947304SEvan Yan 	reg = pciehpc_reg_get16(ctrl_p,
90226947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
90326947304SEvan Yan 
90426947304SEvan Yan 	/*
90526947304SEvan Yan 	 * enable interrupts: power fault detection interrupt is enabled
90626947304SEvan Yan 	 * only when the slot is powered ON
90726947304SEvan Yan 	 */
90826947304SEvan Yan 	if (slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_POWERED)
90926947304SEvan Yan 		pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off +
91026947304SEvan Yan 		    PCIE_SLOTCTL, reg | PCIE_SLOTCTL_INTR_MASK);
91126947304SEvan Yan 	else
91226947304SEvan Yan 		pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off +
91326947304SEvan Yan 		    PCIE_SLOTCTL, reg | (PCIE_SLOTCTL_INTR_MASK &
91426947304SEvan Yan 		    ~PCIE_SLOTCTL_PWR_FAULT_EN));
91526947304SEvan Yan 
91626947304SEvan Yan 	return (DDI_SUCCESS);
91726947304SEvan Yan }
91826947304SEvan Yan 
91926947304SEvan Yan /*
92026947304SEvan Yan  * Disable hot plug interrupts.
92126947304SEvan Yan  * Note: this is only for Native hot plug mode.
92226947304SEvan Yan  */
92326947304SEvan Yan static int
92426947304SEvan Yan pciehpc_disable_intr(pcie_hp_ctrl_t *ctrl_p)
92526947304SEvan Yan {
92626947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
92726947304SEvan Yan 	uint16_t	reg;
92826947304SEvan Yan 
92926947304SEvan Yan 	/* read the Slot Control Register */
93026947304SEvan Yan 	reg = pciehpc_reg_get16(ctrl_p,
93126947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
93226947304SEvan Yan 
93326947304SEvan Yan 	/* disable all interrupts */
93426947304SEvan Yan 	reg &= ~(PCIE_SLOTCTL_INTR_MASK);
93526947304SEvan Yan 	pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTCTL, reg);
93626947304SEvan Yan 
93726947304SEvan Yan 	/* clear any interrupt status bits */
93826947304SEvan Yan 	reg = pciehpc_reg_get16(ctrl_p,
93926947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
94026947304SEvan Yan 	pciehpc_reg_put16(ctrl_p,
94126947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS, reg);
94226947304SEvan Yan 
94326947304SEvan Yan 	return (DDI_SUCCESS);
94426947304SEvan Yan }
94526947304SEvan Yan 
94626947304SEvan Yan /*
94726947304SEvan Yan  * Allocate a new hotplug controller and slot structures for HPC
94826947304SEvan Yan  * associated with this dip.
94926947304SEvan Yan  */
95026947304SEvan Yan static pcie_hp_ctrl_t *
95126947304SEvan Yan pciehpc_create_controller(dev_info_t *dip)
95226947304SEvan Yan {
95326947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p;
95426947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);
95526947304SEvan Yan 
95626947304SEvan Yan 	ctrl_p = kmem_zalloc(sizeof (pcie_hp_ctrl_t), KM_SLEEP);
95726947304SEvan Yan 	ctrl_p->hc_dip = dip;
95826947304SEvan Yan 
95926947304SEvan Yan 	/* Allocate a new slot structure. */
96026947304SEvan Yan 	ctrl_p->hc_slots[0] = kmem_zalloc(sizeof (pcie_hp_slot_t), KM_SLEEP);
96126947304SEvan Yan 	ctrl_p->hc_slots[0]->hs_num = 0;
96226947304SEvan Yan 	ctrl_p->hc_slots[0]->hs_ctrl = ctrl_p;
96326947304SEvan Yan 
96426947304SEvan Yan 	/* Initialize the interrupt mutex */
96526947304SEvan Yan 	mutex_init(&ctrl_p->hc_mutex, NULL, MUTEX_DRIVER,
96626947304SEvan Yan 	    (void *)PCIE_INTR_PRI);
96726947304SEvan Yan 
96826947304SEvan Yan 	/* Initialize synchronization conditional variable */
96926947304SEvan Yan 	cv_init(&ctrl_p->hc_cmd_comp_cv, NULL, CV_DRIVER, NULL);
97026947304SEvan Yan 	ctrl_p->hc_cmd_pending = B_FALSE;
97126947304SEvan Yan 
97226947304SEvan Yan 	bus_p->bus_hp_curr_mode = PCIE_NATIVE_HP_MODE;
97326947304SEvan Yan 	PCIE_SET_HP_CTRL(dip, ctrl_p);
97426947304SEvan Yan 
97526947304SEvan Yan 	return (ctrl_p);
97626947304SEvan Yan }
97726947304SEvan Yan 
97826947304SEvan Yan /*
97926947304SEvan Yan  * Remove the HPC controller and slot structures
98026947304SEvan Yan  */
98126947304SEvan Yan static void
98226947304SEvan Yan pciehpc_destroy_controller(dev_info_t *dip)
98326947304SEvan Yan {
98426947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p;
98526947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);
98626947304SEvan Yan 
98726947304SEvan Yan 	/* get the soft state structure for this dip */
98826947304SEvan Yan 	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL)
98926947304SEvan Yan 		return;
99026947304SEvan Yan 
99126947304SEvan Yan 	PCIE_SET_HP_CTRL(dip, NULL);
99226947304SEvan Yan 	bus_p->bus_hp_curr_mode = PCIE_NONE_HP_MODE;
99326947304SEvan Yan 
99426947304SEvan Yan 	mutex_destroy(&ctrl_p->hc_mutex);
99526947304SEvan Yan 	cv_destroy(&ctrl_p->hc_cmd_comp_cv);
99626947304SEvan Yan 	kmem_free(ctrl_p->hc_slots[0], sizeof (pcie_hp_slot_t));
99726947304SEvan Yan 	kmem_free(ctrl_p, sizeof (pcie_hp_ctrl_t));
99826947304SEvan Yan }
99926947304SEvan Yan 
100026947304SEvan Yan /*
100126947304SEvan Yan  * Register the PCI-E hot plug slot with DDI HP framework.
100226947304SEvan Yan  */
100326947304SEvan Yan static int
100426947304SEvan Yan pciehpc_register_slot(pcie_hp_ctrl_t *ctrl_p)
100526947304SEvan Yan {
100626947304SEvan Yan 	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
100726947304SEvan Yan 	dev_info_t	*dip = ctrl_p->hc_dip;
100826947304SEvan Yan 
100926947304SEvan Yan 	/* register the slot with DDI HP framework */
101026947304SEvan Yan 	if (ndi_hp_register(dip, &slot_p->hs_info) != NDI_SUCCESS) {
101126947304SEvan Yan 		PCIE_DBG("pciehpc_register_slot() failed to register slot %d\n",
101226947304SEvan Yan 		    slot_p->hs_phy_slot_num);
101326947304SEvan Yan 		return (DDI_FAILURE);
101426947304SEvan Yan 	}
101526947304SEvan Yan 
101626947304SEvan Yan 	pcie_hp_create_occupant_props(dip, makedevice(ddi_driver_major(dip),
101726947304SEvan Yan 	    slot_p->hs_minor), slot_p->hs_device_num);
101826947304SEvan Yan 
101926947304SEvan Yan 	PCIE_DBG("pciehpc_register_slot(): registered slot %d\n",
102026947304SEvan Yan 	    slot_p->hs_phy_slot_num);
102126947304SEvan Yan 
102226947304SEvan Yan 	return (DDI_SUCCESS);
102326947304SEvan Yan }
102426947304SEvan Yan 
102526947304SEvan Yan /*
102626947304SEvan Yan  * Unregister the PCI-E hot plug slot from DDI HP framework.
102726947304SEvan Yan  */
102826947304SEvan Yan static int
102926947304SEvan Yan pciehpc_unregister_slot(pcie_hp_ctrl_t *ctrl_p)
103026947304SEvan Yan {
103126947304SEvan Yan 	pcie_hp_slot_t *slot_p = ctrl_p->hc_slots[0];
103226947304SEvan Yan 	dev_info_t	*dip = ctrl_p->hc_dip;
103326947304SEvan Yan 
103426947304SEvan Yan 	pcie_hp_delete_occupant_props(dip, makedevice(ddi_driver_major(dip),
103526947304SEvan Yan 	    slot_p->hs_minor));
103626947304SEvan Yan 
103726947304SEvan Yan 	/* unregister the slot with DDI HP framework */
103826947304SEvan Yan 	if (ndi_hp_unregister(dip, slot_p->hs_info.cn_name) != NDI_SUCCESS) {
103926947304SEvan Yan 		PCIE_DBG("pciehpc_unregister_slot() "
104026947304SEvan Yan 		    "failed to unregister slot %d\n", slot_p->hs_phy_slot_num);
104126947304SEvan Yan 		return (DDI_FAILURE);
104226947304SEvan Yan 	}
104326947304SEvan Yan 
104426947304SEvan Yan 	PCIE_DBG("pciehpc_unregister_slot(): unregistered slot %d\n",
104526947304SEvan Yan 	    slot_p->hs_phy_slot_num);
104626947304SEvan Yan 
104726947304SEvan Yan 	return (DDI_SUCCESS);
104826947304SEvan Yan }
104926947304SEvan Yan 
105026947304SEvan Yan /*
105126947304SEvan Yan  * pciehpc_slot_poweron()
105226947304SEvan Yan  *
105326947304SEvan Yan  * Poweron/Enable the slot.
105426947304SEvan Yan  *
105526947304SEvan Yan  * Note: This function is called by DDI HP framework at kernel context only
105626947304SEvan Yan  */
105726947304SEvan Yan /*ARGSUSED*/
105826947304SEvan Yan static int
105926947304SEvan Yan pciehpc_slot_poweron(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t *result)
106026947304SEvan Yan {
106126947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
106226947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
106326947304SEvan Yan 	uint16_t	status, control;
106426947304SEvan Yan 
106526947304SEvan Yan 	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));
106626947304SEvan Yan 
106726947304SEvan Yan 	/* get the current state of the slot */
106826947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
106926947304SEvan Yan 
107026947304SEvan Yan 	/* check if the slot is already in the 'enabled' state */
107126947304SEvan Yan 	if (slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_POWERED) {
107226947304SEvan Yan 		/* slot is already in the 'enabled' state */
107326947304SEvan Yan 		PCIE_DBG("pciehpc_slot_poweron() slot %d already enabled\n",
107426947304SEvan Yan 		    slot_p->hs_phy_slot_num);
107526947304SEvan Yan 
107626947304SEvan Yan 		*result = slot_p->hs_info.cn_state;
107726947304SEvan Yan 		return (DDI_SUCCESS);
107826947304SEvan Yan 	}
107926947304SEvan Yan 
108026947304SEvan Yan 	/* read the Slot Status Register */
108126947304SEvan Yan 	status =  pciehpc_reg_get16(ctrl_p,
108226947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
108326947304SEvan Yan 
108426947304SEvan Yan 	/* make sure the MRL switch is closed if present */
108526947304SEvan Yan 	if ((ctrl_p->hc_has_mrl) && (status & PCIE_SLOTSTS_MRL_SENSOR_OPEN)) {
108626947304SEvan Yan 		/* MRL switch is open */
108726947304SEvan Yan 		cmn_err(CE_WARN, "MRL switch is open on slot %d\n",
108826947304SEvan Yan 		    slot_p->hs_phy_slot_num);
108926947304SEvan Yan 		goto cleanup;
109026947304SEvan Yan 	}
109126947304SEvan Yan 
109226947304SEvan Yan 	/* make sure the slot has a device present */
109326947304SEvan Yan 	if (!(status & PCIE_SLOTSTS_PRESENCE_DETECTED)) {
109426947304SEvan Yan 		/* slot is empty */
109526947304SEvan Yan 		PCIE_DBG("slot %d is empty\n", slot_p->hs_phy_slot_num);
109626947304SEvan Yan 		goto cleanup;
109726947304SEvan Yan 	}
109826947304SEvan Yan 
109926947304SEvan Yan 	/* get the current state of Slot Control Register */
110026947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
110126947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
110226947304SEvan Yan 
110326947304SEvan Yan 	/*
110426947304SEvan Yan 	 * Enable power to the slot involves:
110526947304SEvan Yan 	 *	1. Set power LED to blink and ATTN led to OFF.
110626947304SEvan Yan 	 *	2. Set power control ON in Slot Control Reigster and
110726947304SEvan Yan 	 *	   wait for Command Completed Interrupt or 1 sec timeout.
110826947304SEvan Yan 	 *	3. If Data Link Layer State Changed events are supported
110926947304SEvan Yan 	 *	   then wait for the event to indicate Data Layer Link
111026947304SEvan Yan 	 *	   is active. The time out value for this event is 1 second.
111126947304SEvan Yan 	 *	   This is specified in PCI-E version 1.1.
111226947304SEvan Yan 	 *	4. Set power LED to be ON.
111326947304SEvan Yan 	 */
111426947304SEvan Yan 
111526947304SEvan Yan 	/* 1. set power LED to blink & ATTN led to OFF */
111626947304SEvan Yan 	pciehpc_set_led_state(ctrl_p, PCIE_HP_POWER_LED, PCIE_HP_LED_BLINK);
111726947304SEvan Yan 	pciehpc_set_led_state(ctrl_p, PCIE_HP_ATTN_LED, PCIE_HP_LED_OFF);
111826947304SEvan Yan 
111926947304SEvan Yan 	/* 2. set power control to ON */
112026947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
112126947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
112226947304SEvan Yan 	control &= ~PCIE_SLOTCTL_PWR_CONTROL;
112326947304SEvan Yan 	pciehpc_issue_hpc_command(ctrl_p, control);
112426947304SEvan Yan 
112526947304SEvan Yan 	/* 3. wait for DLL State Change event, if it's supported */
112626947304SEvan Yan 	if (ctrl_p->hc_dll_active_rep) {
112726947304SEvan Yan 		status =  pciehpc_reg_get16(ctrl_p,
112826947304SEvan Yan 		    bus_p->bus_pcie_off + PCIE_LINKSTS);
112926947304SEvan Yan 
113026947304SEvan Yan 		if (!(status & PCIE_LINKSTS_DLL_LINK_ACTIVE)) {
113126947304SEvan Yan 			/* wait 1 sec for the DLL State Changed event */
113226947304SEvan Yan 			(void) cv_timedwait(&slot_p->hs_dll_active_cv,
113326947304SEvan Yan 			    &ctrl_p->hc_mutex,
113426947304SEvan Yan 			    ddi_get_lbolt() +
113526947304SEvan Yan 			    SEC_TO_TICK(PCIE_HP_DLL_STATE_CHANGE_TIMEOUT));
113626947304SEvan Yan 
113726947304SEvan Yan 			/* check Link status */
113826947304SEvan Yan 			status =  pciehpc_reg_get16(ctrl_p,
113926947304SEvan Yan 			    bus_p->bus_pcie_off +
114026947304SEvan Yan 			    PCIE_LINKSTS);
114126947304SEvan Yan 			if (!(status & PCIE_LINKSTS_DLL_LINK_ACTIVE))
114226947304SEvan Yan 				goto cleanup2;
114326947304SEvan Yan 		}
114426947304SEvan Yan 	}
114526947304SEvan Yan 
114626947304SEvan Yan 	/* wait 1 sec for link to come up */
114726947304SEvan Yan 	delay(drv_usectohz(1000000));
114826947304SEvan Yan 
114926947304SEvan Yan 	/* check power is really turned ON */
115026947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
115126947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
115226947304SEvan Yan 
115326947304SEvan Yan 	if (control & PCIE_SLOTCTL_PWR_CONTROL) {
115426947304SEvan Yan 		PCIE_DBG("slot %d fails to turn on power on connect\n",
115526947304SEvan Yan 		    slot_p->hs_phy_slot_num);
115626947304SEvan Yan 
115726947304SEvan Yan 		goto cleanup1;
115826947304SEvan Yan 	}
115926947304SEvan Yan 
116026947304SEvan Yan 	/* clear power fault status */
116126947304SEvan Yan 	status =  pciehpc_reg_get16(ctrl_p,
116226947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
116326947304SEvan Yan 	status |= PCIE_SLOTSTS_PWR_FAULT_DETECTED;
116426947304SEvan Yan 	pciehpc_reg_put16(ctrl_p, bus_p->bus_pcie_off + PCIE_SLOTSTS,
116526947304SEvan Yan 	    status);
116626947304SEvan Yan 
116726947304SEvan Yan 	/* enable power fault detection interrupt */
116826947304SEvan Yan 	control |= PCIE_SLOTCTL_PWR_FAULT_EN;
116926947304SEvan Yan 	pciehpc_issue_hpc_command(ctrl_p, control);
117026947304SEvan Yan 
117126947304SEvan Yan 	/* 4. Set power LED to be ON */
117226947304SEvan Yan 	pciehpc_set_led_state(ctrl_p, PCIE_HP_POWER_LED, PCIE_HP_LED_ON);
117326947304SEvan Yan 
117426947304SEvan Yan 	/* if EMI is present, turn it ON */
117526947304SEvan Yan 	if (ctrl_p->hc_has_emi_lock) {
117626947304SEvan Yan 		status =  pciehpc_reg_get16(ctrl_p,
117726947304SEvan Yan 		    bus_p->bus_pcie_off + PCIE_SLOTSTS);
117826947304SEvan Yan 
117926947304SEvan Yan 		if (!(status & PCIE_SLOTSTS_EMI_LOCK_SET)) {
118026947304SEvan Yan 			control =  pciehpc_reg_get16(ctrl_p,
118126947304SEvan Yan 			    bus_p->bus_pcie_off + PCIE_SLOTCTL);
118226947304SEvan Yan 			control |= PCIE_SLOTCTL_EMI_LOCK_CONTROL;
118326947304SEvan Yan 			pciehpc_issue_hpc_command(ctrl_p, control);
118426947304SEvan Yan 
118526947304SEvan Yan 			/* wait 1 sec after toggling the state of EMI lock */
118626947304SEvan Yan 			delay(drv_usectohz(1000000));
118726947304SEvan Yan 		}
118826947304SEvan Yan 	}
118926947304SEvan Yan 
119026947304SEvan Yan 	*result = slot_p->hs_info.cn_state =
119126947304SEvan Yan 	    DDI_HP_CN_STATE_POWERED;
119226947304SEvan Yan 
119326947304SEvan Yan 	return (DDI_SUCCESS);
119426947304SEvan Yan 
119526947304SEvan Yan cleanup2:
119626947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
119726947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
119826947304SEvan Yan 
119926947304SEvan Yan 	/* if power is ON, set power control to OFF */
120026947304SEvan Yan 	if (!(control & PCIE_SLOTCTL_PWR_CONTROL)) {
120126947304SEvan Yan 		control |= PCIE_SLOTCTL_PWR_CONTROL;
120226947304SEvan Yan 		pciehpc_issue_hpc_command(ctrl_p, control);
120326947304SEvan Yan 	}
120426947304SEvan Yan 
120526947304SEvan Yan cleanup1:
120626947304SEvan Yan 	/* set power led to OFF */
120726947304SEvan Yan 	pciehpc_set_led_state(ctrl_p, PCIE_HP_POWER_LED, PCIE_HP_LED_OFF);
120826947304SEvan Yan 
120926947304SEvan Yan cleanup:
121026947304SEvan Yan 	return (DDI_FAILURE);
121126947304SEvan Yan }
121226947304SEvan Yan 
121326947304SEvan Yan /*ARGSUSED*/
121426947304SEvan Yan static int
121526947304SEvan Yan pciehpc_slot_poweroff(pcie_hp_slot_t *slot_p, ddi_hp_cn_state_t *result)
121626947304SEvan Yan {
121726947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
121826947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
121926947304SEvan Yan 	uint16_t	status, control;
122026947304SEvan Yan 
122126947304SEvan Yan 	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));
122226947304SEvan Yan 
122326947304SEvan Yan 	/* get the current state of the slot */
122426947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
122526947304SEvan Yan 
122626947304SEvan Yan 	/* check if the slot is not in the "enabled' state */
122726947304SEvan Yan 	if (slot_p->hs_info.cn_state < DDI_HP_CN_STATE_POWERED) {
122826947304SEvan Yan 		/* slot is in the 'disabled' state */
122926947304SEvan Yan 		PCIE_DBG("pciehpc_slot_poweroff(): "
123026947304SEvan Yan 		    "slot %d already disabled\n", slot_p->hs_phy_slot_num);
123126947304SEvan Yan 		ASSERT(slot_p->hs_power_led_state == PCIE_HP_LED_OFF);
123226947304SEvan Yan 
123326947304SEvan Yan 		*result = slot_p->hs_info.cn_state;
123426947304SEvan Yan 		return (DDI_SUCCESS);
123526947304SEvan Yan 	}
123626947304SEvan Yan 
123726947304SEvan Yan 	/* read the Slot Status Register */
123826947304SEvan Yan 	status =  pciehpc_reg_get16(ctrl_p,
123926947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTSTS);
124026947304SEvan Yan 
124126947304SEvan Yan 	/* make sure the slot has a device present */
124226947304SEvan Yan 	if (!(status & PCIE_SLOTSTS_PRESENCE_DETECTED)) {
124326947304SEvan Yan 		/* slot is empty */
124426947304SEvan Yan 		PCIE_DBG("pciehpc_slot_poweroff(): slot %d is empty\n",
124526947304SEvan Yan 		    slot_p->hs_phy_slot_num);
124626947304SEvan Yan 		goto cleanup;
124726947304SEvan Yan 	}
124826947304SEvan Yan 
124926947304SEvan Yan 	/*
125026947304SEvan Yan 	 * Disable power to the slot involves:
125126947304SEvan Yan 	 *	1. Set power LED to blink.
125226947304SEvan Yan 	 *	2. Set power control OFF in Slot Control Reigster and
125326947304SEvan Yan 	 *	   wait for Command Completed Interrupt or 1 sec timeout.
125426947304SEvan Yan 	 *	3. Set POWER led and ATTN led to be OFF.
125526947304SEvan Yan 	 */
125626947304SEvan Yan 
125726947304SEvan Yan 	/* 1. set power LED to blink */
125826947304SEvan Yan 	pciehpc_set_led_state(ctrl_p, PCIE_HP_POWER_LED, PCIE_HP_LED_BLINK);
125926947304SEvan Yan 
126026947304SEvan Yan 	/* disable power fault detection interrupt */
126126947304SEvan Yan 	control = pciehpc_reg_get16(ctrl_p,
126226947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
126326947304SEvan Yan 	control &= ~PCIE_SLOTCTL_PWR_FAULT_EN;
126426947304SEvan Yan 	pciehpc_issue_hpc_command(ctrl_p, control);
126526947304SEvan Yan 
126626947304SEvan Yan 	/* 2. set power control to OFF */
126726947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
126826947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
126926947304SEvan Yan 	control |= PCIE_SLOTCTL_PWR_CONTROL;
127026947304SEvan Yan 	pciehpc_issue_hpc_command(ctrl_p, control);
127126947304SEvan Yan 
127226947304SEvan Yan #ifdef DEBUG
127326947304SEvan Yan 	/* check for power control bit to be OFF */
127426947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
127526947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
127626947304SEvan Yan 	ASSERT(control & PCIE_SLOTCTL_PWR_CONTROL);
127726947304SEvan Yan #endif
127826947304SEvan Yan 
127926947304SEvan Yan 	/* 3. Set power LED to be OFF */
128026947304SEvan Yan 	pciehpc_set_led_state(ctrl_p, PCIE_HP_POWER_LED, PCIE_HP_LED_OFF);
128126947304SEvan Yan 	pciehpc_set_led_state(ctrl_p, PCIE_HP_ATTN_LED, PCIE_HP_LED_OFF);
128226947304SEvan Yan 
128326947304SEvan Yan 	/* if EMI is present, turn it OFF */
128426947304SEvan Yan 	if (ctrl_p->hc_has_emi_lock) {
128526947304SEvan Yan 		status =  pciehpc_reg_get16(ctrl_p,
128626947304SEvan Yan 		    bus_p->bus_pcie_off + PCIE_SLOTSTS);
128726947304SEvan Yan 
128826947304SEvan Yan 		if (status & PCIE_SLOTSTS_EMI_LOCK_SET) {
128926947304SEvan Yan 			control =  pciehpc_reg_get16(ctrl_p,
129026947304SEvan Yan 			    bus_p->bus_pcie_off + PCIE_SLOTCTL);
129126947304SEvan Yan 			control |= PCIE_SLOTCTL_EMI_LOCK_CONTROL;
129226947304SEvan Yan 			pciehpc_issue_hpc_command(ctrl_p, control);
129326947304SEvan Yan 
129426947304SEvan Yan 			/* wait 1 sec after toggling the state of EMI lock */
129526947304SEvan Yan 			delay(drv_usectohz(1000000));
129626947304SEvan Yan 		}
129726947304SEvan Yan 	}
129826947304SEvan Yan 
129926947304SEvan Yan 	/* get the current state of the slot */
130026947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
130126947304SEvan Yan 
130226947304SEvan Yan 	*result = slot_p->hs_info.cn_state;
130326947304SEvan Yan 
130426947304SEvan Yan 	return (DDI_SUCCESS);
130526947304SEvan Yan 
130626947304SEvan Yan cleanup:
130726947304SEvan Yan 	return (DDI_FAILURE);
130826947304SEvan Yan }
130926947304SEvan Yan 
131026947304SEvan Yan /*
131126947304SEvan Yan  * pciehpc_slot_probe()
131226947304SEvan Yan  *
131326947304SEvan Yan  * Probe the slot.
131426947304SEvan Yan  *
131526947304SEvan Yan  * Note: This function is called by DDI HP framework at kernel context only
131626947304SEvan Yan  */
131726947304SEvan Yan /*ARGSUSED*/
131826947304SEvan Yan static int
131926947304SEvan Yan pciehpc_slot_probe(pcie_hp_slot_t *slot_p)
132026947304SEvan Yan {
132126947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
132226947304SEvan Yan 	int		ret = DDI_SUCCESS;
132326947304SEvan Yan 
132426947304SEvan Yan 	mutex_enter(&ctrl_p->hc_mutex);
132526947304SEvan Yan 
132626947304SEvan Yan 	/* get the current state of the slot */
132726947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
132826947304SEvan Yan 
132926947304SEvan Yan 	/*
133026947304SEvan Yan 	 * Probe a given PCIe Hotplug Connection (CN).
133126947304SEvan Yan 	 */
133226947304SEvan Yan 	PCIE_DISABLE_ERRORS(ctrl_p->hc_dip);
133326947304SEvan Yan 	ret = pcie_hp_probe(slot_p);
133426947304SEvan Yan 
133526947304SEvan Yan 	if (ret != DDI_SUCCESS) {
133626947304SEvan Yan 		PCIE_DBG("pciehpc_slot_probe() failed\n");
133726947304SEvan Yan 
133826947304SEvan Yan 		/* turn the ATTN led ON for configure failure */
133926947304SEvan Yan 		pciehpc_set_led_state(ctrl_p, PCIE_HP_ATTN_LED, PCIE_HP_LED_ON);
134026947304SEvan Yan 
134126947304SEvan Yan 		/* if power to the slot is still on then set Power led to ON */
134226947304SEvan Yan 		if (slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_POWERED)
134326947304SEvan Yan 			pciehpc_set_led_state(ctrl_p, PCIE_HP_POWER_LED,
134426947304SEvan Yan 			    PCIE_HP_LED_ON);
134526947304SEvan Yan 
134626947304SEvan Yan 		mutex_exit(&ctrl_p->hc_mutex);
134726947304SEvan Yan 		return (DDI_FAILURE);
134826947304SEvan Yan 	}
134926947304SEvan Yan 
135026947304SEvan Yan 	PCIE_ENABLE_ERRORS(ctrl_p->hc_dip);
135126947304SEvan Yan 
135226947304SEvan Yan 	/* get the current state of the slot */
135326947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
135426947304SEvan Yan 
135526947304SEvan Yan 	mutex_exit(&ctrl_p->hc_mutex);
135626947304SEvan Yan 	return (DDI_SUCCESS);
135726947304SEvan Yan }
135826947304SEvan Yan 
135926947304SEvan Yan /*
136026947304SEvan Yan  * pciehpc_slot_unprobe()
136126947304SEvan Yan  *
136226947304SEvan Yan  * Unprobe the slot.
136326947304SEvan Yan  *
136426947304SEvan Yan  * Note: This function is called by DDI HP framework at kernel context only
136526947304SEvan Yan  */
136626947304SEvan Yan /*ARGSUSED*/
136726947304SEvan Yan static int
136826947304SEvan Yan pciehpc_slot_unprobe(pcie_hp_slot_t *slot_p)
136926947304SEvan Yan {
137026947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
137126947304SEvan Yan 	int		ret;
137226947304SEvan Yan 
137326947304SEvan Yan 	mutex_enter(&ctrl_p->hc_mutex);
137426947304SEvan Yan 
137526947304SEvan Yan 	/* get the current state of the slot */
137626947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
137726947304SEvan Yan 
137826947304SEvan Yan 	/*
137926947304SEvan Yan 	 * Unprobe a given PCIe Hotplug Connection (CN).
138026947304SEvan Yan 	 */
138126947304SEvan Yan 	PCIE_DISABLE_ERRORS(ctrl_p->hc_dip);
138226947304SEvan Yan 	ret = pcie_hp_unprobe(slot_p);
138326947304SEvan Yan 
138426947304SEvan Yan 	if (ret != DDI_SUCCESS) {
138526947304SEvan Yan 		PCIE_DBG("pciehpc_slot_unprobe() failed\n");
138626947304SEvan Yan 
138726947304SEvan Yan 		/* if power to the slot is still on then set Power led to ON */
138826947304SEvan Yan 		if (slot_p->hs_info.cn_state >= DDI_HP_CN_STATE_POWERED)
138926947304SEvan Yan 			pciehpc_set_led_state(ctrl_p, PCIE_HP_POWER_LED,
139026947304SEvan Yan 			    PCIE_HP_LED_ON);
139126947304SEvan Yan 
139226947304SEvan Yan 		PCIE_ENABLE_ERRORS(ctrl_p->hc_dip);
139326947304SEvan Yan 
139426947304SEvan Yan 		mutex_exit(&ctrl_p->hc_mutex);
139526947304SEvan Yan 		return (DDI_FAILURE);
139626947304SEvan Yan 	}
139726947304SEvan Yan 
139826947304SEvan Yan 	/* get the current state of the slot */
139926947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
140026947304SEvan Yan 
140126947304SEvan Yan 	mutex_exit(&ctrl_p->hc_mutex);
140226947304SEvan Yan 	return (DDI_SUCCESS);
140326947304SEvan Yan }
140426947304SEvan Yan 
140526947304SEvan Yan static int
140626947304SEvan Yan pciehpc_upgrade_slot_state(pcie_hp_slot_t *slot_p,
140726947304SEvan Yan     ddi_hp_cn_state_t target_state)
140826947304SEvan Yan {
140926947304SEvan Yan 	ddi_hp_cn_state_t curr_state;
141026947304SEvan Yan 	int rv = DDI_SUCCESS;
141126947304SEvan Yan 
141226947304SEvan Yan 	if (target_state > DDI_HP_CN_STATE_ENABLED) {
141326947304SEvan Yan 		return (DDI_EINVAL);
141426947304SEvan Yan 	}
141526947304SEvan Yan 
141626947304SEvan Yan 	curr_state = slot_p->hs_info.cn_state;
141726947304SEvan Yan 	while ((curr_state < target_state) && (rv == DDI_SUCCESS)) {
141826947304SEvan Yan 
141926947304SEvan Yan 		switch (curr_state) {
142026947304SEvan Yan 		case DDI_HP_CN_STATE_EMPTY:
142126947304SEvan Yan 			/*
142226947304SEvan Yan 			 * From EMPTY to PRESENT, just check the hardware
142326947304SEvan Yan 			 * slot state.
142426947304SEvan Yan 			 */
142526947304SEvan Yan 			pciehpc_get_slot_state(slot_p);
142626947304SEvan Yan 			curr_state = slot_p->hs_info.cn_state;
142726947304SEvan Yan 			if (curr_state < DDI_HP_CN_STATE_PRESENT)
142826947304SEvan Yan 				rv = DDI_FAILURE;
142926947304SEvan Yan 			break;
143026947304SEvan Yan 		case DDI_HP_CN_STATE_PRESENT:
143126947304SEvan Yan 			rv = (slot_p->hs_ctrl->hc_ops.poweron_hpc_slot)(slot_p,
143226947304SEvan Yan 			    &curr_state);
143326947304SEvan Yan 
143426947304SEvan Yan 			break;
143526947304SEvan Yan 		case DDI_HP_CN_STATE_POWERED:
143626947304SEvan Yan 			curr_state = slot_p->hs_info.cn_state =
143726947304SEvan Yan 			    DDI_HP_CN_STATE_ENABLED;
143826947304SEvan Yan 			break;
143926947304SEvan Yan 		default:
144026947304SEvan Yan 			/* should never reach here */
144126947304SEvan Yan 			ASSERT("unknown devinfo state");
144226947304SEvan Yan 		}
144326947304SEvan Yan 	}
144426947304SEvan Yan 
144526947304SEvan Yan 	return (rv);
144626947304SEvan Yan }
144726947304SEvan Yan 
144826947304SEvan Yan static int
144926947304SEvan Yan pciehpc_downgrade_slot_state(pcie_hp_slot_t *slot_p,
145026947304SEvan Yan     ddi_hp_cn_state_t target_state)
145126947304SEvan Yan {
145226947304SEvan Yan 	ddi_hp_cn_state_t curr_state;
145326947304SEvan Yan 	int rv = DDI_SUCCESS;
145426947304SEvan Yan 
145526947304SEvan Yan 
145626947304SEvan Yan 	curr_state = slot_p->hs_info.cn_state;
145726947304SEvan Yan 	while ((curr_state > target_state) && (rv == DDI_SUCCESS)) {
145826947304SEvan Yan 
145926947304SEvan Yan 		switch (curr_state) {
146026947304SEvan Yan 		case DDI_HP_CN_STATE_PRESENT:
146126947304SEvan Yan 			/*
146226947304SEvan Yan 			 * From PRESENT to EMPTY, just check hardware slot
146326947304SEvan Yan 			 * state.
146426947304SEvan Yan 			 */
146526947304SEvan Yan 			pciehpc_get_slot_state(slot_p);
146626947304SEvan Yan 			curr_state = slot_p->hs_info.cn_state;
146726947304SEvan Yan 			if (curr_state >= DDI_HP_CN_STATE_PRESENT)
146826947304SEvan Yan 				rv = DDI_FAILURE;
146926947304SEvan Yan 			break;
147026947304SEvan Yan 		case DDI_HP_CN_STATE_POWERED:
147126947304SEvan Yan 			rv = (slot_p->hs_ctrl->hc_ops.poweroff_hpc_slot)(
147226947304SEvan Yan 			    slot_p, &curr_state);
147326947304SEvan Yan 
147426947304SEvan Yan 			break;
147526947304SEvan Yan 		case DDI_HP_CN_STATE_ENABLED:
147626947304SEvan Yan 			curr_state = slot_p->hs_info.cn_state =
147726947304SEvan Yan 			    DDI_HP_CN_STATE_POWERED;
147826947304SEvan Yan 
147926947304SEvan Yan 			break;
148026947304SEvan Yan 		default:
148126947304SEvan Yan 			/* should never reach here */
148226947304SEvan Yan 			ASSERT("unknown devinfo state");
148326947304SEvan Yan 		}
148426947304SEvan Yan 	}
148526947304SEvan Yan 
148626947304SEvan Yan 	return (rv);
148726947304SEvan Yan }
148826947304SEvan Yan 
148926947304SEvan Yan /* Change slot state to a target state */
149026947304SEvan Yan static int
149126947304SEvan Yan pciehpc_change_slot_state(pcie_hp_slot_t *slot_p,
149226947304SEvan Yan     ddi_hp_cn_state_t target_state)
149326947304SEvan Yan {
149426947304SEvan Yan 	ddi_hp_cn_state_t curr_state;
149526947304SEvan Yan 	int rv;
149626947304SEvan Yan 
149726947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
149826947304SEvan Yan 	curr_state = slot_p->hs_info.cn_state;
149926947304SEvan Yan 
150026947304SEvan Yan 	if (curr_state == target_state) {
150126947304SEvan Yan 		return (DDI_SUCCESS);
150226947304SEvan Yan 	}
150326947304SEvan Yan 	if (curr_state < target_state) {
150426947304SEvan Yan 
150526947304SEvan Yan 		rv = pciehpc_upgrade_slot_state(slot_p, target_state);
150626947304SEvan Yan 	} else {
150726947304SEvan Yan 		rv = pciehpc_downgrade_slot_state(slot_p, target_state);
150826947304SEvan Yan 	}
150926947304SEvan Yan 
151026947304SEvan Yan 	return (rv);
151126947304SEvan Yan }
151226947304SEvan Yan 
151326947304SEvan Yan int
151426947304SEvan Yan pciehpc_slot_get_property(pcie_hp_slot_t *slot_p, ddi_hp_property_t *arg,
151526947304SEvan Yan     ddi_hp_property_t *rval)
151626947304SEvan Yan {
151726947304SEvan Yan 	ddi_hp_property_t request, result;
151826947304SEvan Yan #ifdef _SYSCALL32_IMPL
151926947304SEvan Yan 	ddi_hp_property32_t request32, result32;
152026947304SEvan Yan #endif
152126947304SEvan Yan 	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
152226947304SEvan Yan 	nvlist_t	*prop_list;
152326947304SEvan Yan 	nvlist_t	*prop_rlist; /* nvlist for return values */
152426947304SEvan Yan 	nvpair_t	*prop_pair;
152526947304SEvan Yan 	char		*name, *value;
152626947304SEvan Yan 	int		ret = DDI_SUCCESS;
152726947304SEvan Yan 	int		i, n;
152826947304SEvan Yan 	boolean_t	get_all_prop = B_FALSE;
152926947304SEvan Yan 
153026947304SEvan Yan 	if (get_udatamodel() == DATAMODEL_NATIVE) {
153126947304SEvan Yan 		if (copyin(arg, &request, sizeof (ddi_hp_property_t)) ||
153226947304SEvan Yan 		    copyin(rval, &result, sizeof (ddi_hp_property_t)))
153326947304SEvan Yan 			return (DDI_FAILURE);
153426947304SEvan Yan 	}
153526947304SEvan Yan #ifdef _SYSCALL32_IMPL
153626947304SEvan Yan 	else {
153726947304SEvan Yan 		bzero(&request, sizeof (request));
153826947304SEvan Yan 		bzero(&result, sizeof (result));
153926947304SEvan Yan 		if (copyin(arg, &request32, sizeof (ddi_hp_property32_t)) ||
154026947304SEvan Yan 		    copyin(rval, &result32, sizeof (ddi_hp_property32_t)))
154126947304SEvan Yan 			return (DDI_FAILURE);
154226947304SEvan Yan 		request.nvlist_buf = (char *)(uintptr_t)request32.nvlist_buf;
154326947304SEvan Yan 		request.buf_size = request32.buf_size;
154426947304SEvan Yan 		result.nvlist_buf = (char *)(uintptr_t)result32.nvlist_buf;
154526947304SEvan Yan 		result.buf_size = result32.buf_size;
154626947304SEvan Yan 	}
154726947304SEvan Yan #endif
154826947304SEvan Yan 
154926947304SEvan Yan 	if ((ret = pcie_copyin_nvlist(request.nvlist_buf, request.buf_size,
155026947304SEvan Yan 	    &prop_list)) != DDI_SUCCESS)
155126947304SEvan Yan 		return (ret);
155226947304SEvan Yan 
155326947304SEvan Yan 	if (nvlist_alloc(&prop_rlist, NV_UNIQUE_NAME, 0)) {
155426947304SEvan Yan 		ret = DDI_ENOMEM;
155526947304SEvan Yan 		goto get_prop_cleanup;
155626947304SEvan Yan 	}
155726947304SEvan Yan 
155826947304SEvan Yan 	/* check whether the requested property is "all" or "help" */
155926947304SEvan Yan 	prop_pair = nvlist_next_nvpair(prop_list, NULL);
156026947304SEvan Yan 	if (prop_pair && !nvlist_next_nvpair(prop_list, prop_pair)) {
156126947304SEvan Yan 		name = nvpair_name(prop_pair);
156226947304SEvan Yan 		n = sizeof (pciehpc_props) / sizeof (pciehpc_prop_t);
156326947304SEvan Yan 
156426947304SEvan Yan 		if (strcmp(name, PCIEHPC_PROP_ALL) == 0) {
156526947304SEvan Yan 			(void) nvlist_remove_all(prop_list, PCIEHPC_PROP_ALL);
156626947304SEvan Yan 
156726947304SEvan Yan 			/*
156826947304SEvan Yan 			 * Add all properties into the request list, so that we
156926947304SEvan Yan 			 * will get the values in the following for loop.
157026947304SEvan Yan 			 */
157126947304SEvan Yan 			for (i = 0; i < n; i++) {
157226947304SEvan Yan 				if (nvlist_add_string(prop_list,
157326947304SEvan Yan 				    pciehpc_props[i].prop_name, "") != 0) {
157426947304SEvan Yan 					ret = DDI_FAILURE;
157526947304SEvan Yan 					goto get_prop_cleanup1;
157626947304SEvan Yan 				}
157726947304SEvan Yan 			}
157826947304SEvan Yan 			get_all_prop = B_TRUE;
157926947304SEvan Yan 		} else if (strcmp(name, PCIEHPC_PROP_HELP) == 0) {
158026947304SEvan Yan 			/*
158126947304SEvan Yan 			 * Empty the request list, and add help strings into the
158226947304SEvan Yan 			 * return list. We will pass the following for loop.
158326947304SEvan Yan 			 */
158426947304SEvan Yan 			(void) nvlist_remove_all(prop_list, PCIEHPC_PROP_HELP);
158526947304SEvan Yan 
158626947304SEvan Yan 			for (i = 0; i < n; i++) {
158726947304SEvan Yan 				if (nvlist_add_string(prop_rlist,
158826947304SEvan Yan 				    pciehpc_props[i].prop_name,
158926947304SEvan Yan 				    pciehpc_props[i].prop_value) != 0) {
159026947304SEvan Yan 					ret = DDI_FAILURE;
159126947304SEvan Yan 					goto get_prop_cleanup1;
159226947304SEvan Yan 				}
159326947304SEvan Yan 			}
159426947304SEvan Yan 		}
159526947304SEvan Yan 	}
159626947304SEvan Yan 
159726947304SEvan Yan 	mutex_enter(&ctrl_p->hc_mutex);
159826947304SEvan Yan 
159926947304SEvan Yan 	/* get the current slot state */
160026947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
160126947304SEvan Yan 
160226947304SEvan Yan 	/* for each requested property, get the value and add it to nvlist */
160326947304SEvan Yan 	prop_pair = NULL;
1604b3d69c05SRobert Mustacchi 	while ((prop_pair = nvlist_next_nvpair(prop_list, prop_pair)) != NULL) {
160526947304SEvan Yan 		name = nvpair_name(prop_pair);
1606b3d69c05SRobert Mustacchi 		value = NULL;
160726947304SEvan Yan 
160826947304SEvan Yan 		if (strcmp(name, PCIEHPC_PROP_LED_FAULT) == 0) {
160926947304SEvan Yan 			value = pcie_led_state_text(
161026947304SEvan Yan 			    slot_p->hs_fault_led_state);
161126947304SEvan Yan 		} else if (strcmp(name, PCIEHPC_PROP_LED_POWER) == 0) {
161226947304SEvan Yan 			value = pcie_led_state_text(
161326947304SEvan Yan 			    slot_p->hs_power_led_state);
161426947304SEvan Yan 		} else if (strcmp(name, PCIEHPC_PROP_LED_ATTN) == 0) {
161526947304SEvan Yan 			value = pcie_led_state_text(
161626947304SEvan Yan 			    slot_p->hs_attn_led_state);
161726947304SEvan Yan 		} else if (strcmp(name, PCIEHPC_PROP_LED_ACTIVE) == 0) {
161826947304SEvan Yan 			value = pcie_led_state_text(
161926947304SEvan Yan 			    slot_p->hs_active_led_state);
162026947304SEvan Yan 		} else if (strcmp(name, PCIEHPC_PROP_CARD_TYPE) == 0) {
162126947304SEvan Yan 			ddi_acc_handle_t handle;
162226947304SEvan Yan 			dev_info_t	*cdip;
162326947304SEvan Yan 			uint8_t		prog_class, base_class, sub_class;
162426947304SEvan Yan 			int		i;
162526947304SEvan Yan 
162626947304SEvan Yan 			mutex_exit(&ctrl_p->hc_mutex);
162726947304SEvan Yan 			cdip = pcie_hp_devi_find(
162826947304SEvan Yan 			    ctrl_p->hc_dip, slot_p->hs_device_num, 0);
162926947304SEvan Yan 			mutex_enter(&ctrl_p->hc_mutex);
163026947304SEvan Yan 
163126947304SEvan Yan 			if ((slot_p->hs_info.cn_state
163226947304SEvan Yan 			    != DDI_HP_CN_STATE_ENABLED) || (cdip == NULL)) {
163326947304SEvan Yan 				/*
163426947304SEvan Yan 				 * When getting all properties, just ignore the
163526947304SEvan Yan 				 * one that's not available under certain state.
163626947304SEvan Yan 				 */
163726947304SEvan Yan 				if (get_all_prop)
163826947304SEvan Yan 					continue;
163926947304SEvan Yan 
164026947304SEvan Yan 				ret = DDI_ENOTSUP;
164126947304SEvan Yan 				goto get_prop_cleanup2;
164226947304SEvan Yan 			}
164326947304SEvan Yan 
164426947304SEvan Yan 			if (pci_config_setup(cdip, &handle) != DDI_SUCCESS) {
164526947304SEvan Yan 				ret = DDI_FAILURE;
164626947304SEvan Yan 				goto get_prop_cleanup2;
164726947304SEvan Yan 			}
164826947304SEvan Yan 
164926947304SEvan Yan 			prog_class = pci_config_get8(handle,
165026947304SEvan Yan 			    PCI_CONF_PROGCLASS);
165126947304SEvan Yan 			base_class = pci_config_get8(handle, PCI_CONF_BASCLASS);
165226947304SEvan Yan 			sub_class = pci_config_get8(handle, PCI_CONF_SUBCLASS);
165326947304SEvan Yan 			pci_config_teardown(&handle);
165426947304SEvan Yan 
165526947304SEvan Yan 			for (i = 0; i < class_pci_items; i++) {
165626947304SEvan Yan 				if ((base_class == class_pci[i].base_class) &&
165726947304SEvan Yan 				    (sub_class == class_pci[i].sub_class) &&
165826947304SEvan Yan 				    (prog_class == class_pci[i].prog_class)) {
165926947304SEvan Yan 					value = class_pci[i].short_desc;
166026947304SEvan Yan 					break;
166126947304SEvan Yan 				}
166226947304SEvan Yan 			}
166326947304SEvan Yan 			if (i == class_pci_items)
166426947304SEvan Yan 				value = PCIEHPC_PROP_VALUE_UNKNOWN;
166526947304SEvan Yan 		} else if (strcmp(name, PCIEHPC_PROP_BOARD_TYPE) == 0) {
166626947304SEvan Yan 			if (slot_p->hs_info.cn_state <= DDI_HP_CN_STATE_EMPTY)
166726947304SEvan Yan 				value = PCIEHPC_PROP_VALUE_UNKNOWN;
166826947304SEvan Yan 			else
166926947304SEvan Yan 				value = PCIEHPC_PROP_VALUE_PCIHOTPLUG;
167026947304SEvan Yan 		} else if (strcmp(name, PCIEHPC_PROP_SLOT_CONDITION) == 0) {
167126947304SEvan Yan 			value = pcie_slot_condition_text(slot_p->hs_condition);
167226947304SEvan Yan 		} else {
167326947304SEvan Yan 			/* unsupported property */
167424fd5dc4SEvan Yan 			PCIE_DBG("Unsupported property: %s\n", name);
167526947304SEvan Yan 
167626947304SEvan Yan 			ret = DDI_ENOTSUP;
167726947304SEvan Yan 			goto get_prop_cleanup2;
167826947304SEvan Yan 		}
167926947304SEvan Yan 		if (nvlist_add_string(prop_rlist, name, value) != 0) {
168026947304SEvan Yan 			ret = DDI_FAILURE;
168126947304SEvan Yan 			goto get_prop_cleanup2;
168226947304SEvan Yan 		}
168326947304SEvan Yan 	}
168426947304SEvan Yan 
168526947304SEvan Yan 	/* pack nvlist and copyout */
168626947304SEvan Yan 	if ((ret = pcie_copyout_nvlist(prop_rlist, result.nvlist_buf,
168726947304SEvan Yan 	    &result.buf_size)) != DDI_SUCCESS) {
168826947304SEvan Yan 		goto get_prop_cleanup2;
168926947304SEvan Yan 	}
169026947304SEvan Yan 	if (get_udatamodel() == DATAMODEL_NATIVE) {
169126947304SEvan Yan 		if (copyout(&result, rval, sizeof (ddi_hp_property_t)))
169226947304SEvan Yan 			ret = DDI_FAILURE;
169326947304SEvan Yan 	}
169426947304SEvan Yan #ifdef _SYSCALL32_IMPL
169526947304SEvan Yan 	else {
169626947304SEvan Yan 		if (result.buf_size > UINT32_MAX) {
169726947304SEvan Yan 			ret = DDI_FAILURE;
169826947304SEvan Yan 		} else {
169926947304SEvan Yan 			result32.buf_size = (uint32_t)result.buf_size;
170026947304SEvan Yan 			if (copyout(&result32, rval,
170126947304SEvan Yan 			    sizeof (ddi_hp_property32_t)))
170226947304SEvan Yan 				ret = DDI_FAILURE;
170326947304SEvan Yan 		}
170426947304SEvan Yan 	}
170526947304SEvan Yan #endif
170626947304SEvan Yan 
170726947304SEvan Yan get_prop_cleanup2:
170826947304SEvan Yan 	mutex_exit(&ctrl_p->hc_mutex);
170926947304SEvan Yan get_prop_cleanup1:
171026947304SEvan Yan 	nvlist_free(prop_rlist);
171126947304SEvan Yan get_prop_cleanup:
171226947304SEvan Yan 	nvlist_free(prop_list);
171326947304SEvan Yan 	return (ret);
171426947304SEvan Yan }
171526947304SEvan Yan 
171626947304SEvan Yan int
171726947304SEvan Yan pciehpc_slot_set_property(pcie_hp_slot_t *slot_p, ddi_hp_property_t *arg,
171826947304SEvan Yan     ddi_hp_property_t *rval)
171926947304SEvan Yan {
172026947304SEvan Yan 	ddi_hp_property_t	request, result;
172126947304SEvan Yan #ifdef _SYSCALL32_IMPL
172226947304SEvan Yan 	ddi_hp_property32_t	request32, result32;
172326947304SEvan Yan #endif
172426947304SEvan Yan 	pcie_hp_ctrl_t		*ctrl_p = slot_p->hs_ctrl;
172526947304SEvan Yan 	nvlist_t		*prop_list;
172626947304SEvan Yan 	nvlist_t		*prop_rlist;
172726947304SEvan Yan 	nvpair_t		*prop_pair;
172826947304SEvan Yan 	char			*name, *value;
172926947304SEvan Yan 	pcie_hp_led_state_t	led_state;
173026947304SEvan Yan 	int			ret = DDI_SUCCESS;
173126947304SEvan Yan 
173226947304SEvan Yan 	if (get_udatamodel() == DATAMODEL_NATIVE) {
173326947304SEvan Yan 		if (copyin(arg, &request, sizeof (ddi_hp_property_t)))
173426947304SEvan Yan 			return (DDI_FAILURE);
173526947304SEvan Yan 		if (rval &&
173626947304SEvan Yan 		    copyin(rval, &result, sizeof (ddi_hp_property_t)))
173726947304SEvan Yan 			return (DDI_FAILURE);
173826947304SEvan Yan 	}
173926947304SEvan Yan #ifdef _SYSCALL32_IMPL
174026947304SEvan Yan 	else {
174126947304SEvan Yan 		bzero(&request, sizeof (request));
174226947304SEvan Yan 		bzero(&result, sizeof (result));
174326947304SEvan Yan 		if (copyin(arg, &request32, sizeof (ddi_hp_property32_t)))
174426947304SEvan Yan 			return (DDI_FAILURE);
174526947304SEvan Yan 		if (rval &&
174626947304SEvan Yan 		    copyin(rval, &result32, sizeof (ddi_hp_property32_t)))
174726947304SEvan Yan 			return (DDI_FAILURE);
174826947304SEvan Yan 		request.nvlist_buf = (char *)(uintptr_t)request32.nvlist_buf;
174926947304SEvan Yan 		request.buf_size = request32.buf_size;
175026947304SEvan Yan 		if (rval) {
175126947304SEvan Yan 			result.nvlist_buf =
175226947304SEvan Yan 			    (char *)(uintptr_t)result32.nvlist_buf;
175326947304SEvan Yan 			result.buf_size = result32.buf_size;
175426947304SEvan Yan 		}
175526947304SEvan Yan 	}
175626947304SEvan Yan #endif
175726947304SEvan Yan 
175826947304SEvan Yan 	if ((ret = pcie_copyin_nvlist(request.nvlist_buf, request.buf_size,
175926947304SEvan Yan 	    &prop_list)) != DDI_SUCCESS)
176026947304SEvan Yan 		return (ret);
176126947304SEvan Yan 
176226947304SEvan Yan 	/* check whether the requested property is "help" */
176326947304SEvan Yan 	prop_pair = nvlist_next_nvpair(prop_list, NULL);
176426947304SEvan Yan 	if (prop_pair && !nvlist_next_nvpair(prop_list, prop_pair) &&
176526947304SEvan Yan 	    (strcmp(nvpair_name(prop_pair), PCIEHPC_PROP_HELP) == 0)) {
176626947304SEvan Yan 		if (!rval) {
176726947304SEvan Yan 			ret = DDI_ENOTSUP;
176826947304SEvan Yan 			goto set_prop_cleanup;
176926947304SEvan Yan 		}
177026947304SEvan Yan 
177126947304SEvan Yan 		if (nvlist_alloc(&prop_rlist, NV_UNIQUE_NAME, 0)) {
177226947304SEvan Yan 			ret = DDI_ENOMEM;
177326947304SEvan Yan 			goto set_prop_cleanup;
177426947304SEvan Yan 		}
177526947304SEvan Yan 		if (nvlist_add_string(prop_rlist, PCIEHPC_PROP_LED_ATTN,
177626947304SEvan Yan 		    PCIEHPC_PROP_VALUE_LED) != 0) {
177726947304SEvan Yan 			ret = DDI_FAILURE;
177826947304SEvan Yan 			goto set_prop_cleanup1;
177926947304SEvan Yan 		}
178026947304SEvan Yan 
178126947304SEvan Yan 		if ((ret = pcie_copyout_nvlist(prop_rlist, result.nvlist_buf,
178226947304SEvan Yan 		    &result.buf_size)) != DDI_SUCCESS) {
178326947304SEvan Yan 			goto set_prop_cleanup1;
178426947304SEvan Yan 		}
178526947304SEvan Yan 		if (get_udatamodel() == DATAMODEL_NATIVE) {
178626947304SEvan Yan 			if (copyout(&result, rval,
178726947304SEvan Yan 			    sizeof (ddi_hp_property_t))) {
178826947304SEvan Yan 				ret =  DDI_FAILURE;
178926947304SEvan Yan 				goto set_prop_cleanup1;
179026947304SEvan Yan 			}
179126947304SEvan Yan 		}
179226947304SEvan Yan #ifdef _SYSCALL32_IMPL
179326947304SEvan Yan 		else {
179426947304SEvan Yan 			if (result.buf_size > UINT32_MAX) {
179526947304SEvan Yan 				ret =  DDI_FAILURE;
179626947304SEvan Yan 				goto set_prop_cleanup1;
179726947304SEvan Yan 			} else {
179826947304SEvan Yan 				result32.buf_size = (uint32_t)result.buf_size;
179926947304SEvan Yan 				if (copyout(&result32, rval,
180026947304SEvan Yan 				    sizeof (ddi_hp_property32_t))) {
180126947304SEvan Yan 					ret =  DDI_FAILURE;
180226947304SEvan Yan 					goto set_prop_cleanup1;
180326947304SEvan Yan 				}
180426947304SEvan Yan 			}
180526947304SEvan Yan 		}
180626947304SEvan Yan #endif
180726947304SEvan Yan set_prop_cleanup1:
180826947304SEvan Yan 		nvlist_free(prop_rlist);
180926947304SEvan Yan 		nvlist_free(prop_list);
181026947304SEvan Yan 		return (ret);
181126947304SEvan Yan 	}
181226947304SEvan Yan 
181326947304SEvan Yan 	/* Validate the request */
181426947304SEvan Yan 	prop_pair = NULL;
1815b3d69c05SRobert Mustacchi 	while ((prop_pair = nvlist_next_nvpair(prop_list, prop_pair)) != NULL) {
181626947304SEvan Yan 		name = nvpair_name(prop_pair);
181726947304SEvan Yan 		if (nvpair_type(prop_pair) != DATA_TYPE_STRING) {
181824fd5dc4SEvan Yan 			PCIE_DBG("Unexpected data type of setting "
181926947304SEvan Yan 			    "property %s.\n", name);
182026947304SEvan Yan 			ret = DDI_EINVAL;
182126947304SEvan Yan 			goto set_prop_cleanup;
182226947304SEvan Yan 		}
182326947304SEvan Yan 		if (nvpair_value_string(prop_pair, &value)) {
182424fd5dc4SEvan Yan 			PCIE_DBG("Get string value failed for property %s.\n",
182524fd5dc4SEvan Yan 			    name);
182626947304SEvan Yan 			ret = DDI_FAILURE;
182726947304SEvan Yan 			goto set_prop_cleanup;
182826947304SEvan Yan 		}
182926947304SEvan Yan 
183026947304SEvan Yan 		if (strcmp(name, PCIEHPC_PROP_LED_ATTN) == 0) {
183126947304SEvan Yan 			if ((strcmp(value, PCIEHPC_PROP_VALUE_ON) != 0) &&
183226947304SEvan Yan 			    (strcmp(value, PCIEHPC_PROP_VALUE_OFF) != 0) &&
183326947304SEvan Yan 			    (strcmp(value, PCIEHPC_PROP_VALUE_BLINK) != 0)) {
183424fd5dc4SEvan Yan 				PCIE_DBG("Unsupported value of setting "
183526947304SEvan Yan 				    "property %s\n", name);
183626947304SEvan Yan 				ret = DDI_ENOTSUP;
183726947304SEvan Yan 				goto set_prop_cleanup;
183826947304SEvan Yan 			}
183926947304SEvan Yan 		} else {
184024fd5dc4SEvan Yan 			PCIE_DBG("Unsupported property: %s\n", name);
184126947304SEvan Yan 			ret = DDI_ENOTSUP;
184226947304SEvan Yan 			goto set_prop_cleanup;
184326947304SEvan Yan 		}
184426947304SEvan Yan 	}
184526947304SEvan Yan 	mutex_enter(&ctrl_p->hc_mutex);
184626947304SEvan Yan 
184726947304SEvan Yan 	/* get the current slot state */
184826947304SEvan Yan 	pciehpc_get_slot_state(slot_p);
184926947304SEvan Yan 
185026947304SEvan Yan 	/* set each property */
185126947304SEvan Yan 	prop_pair = NULL;
1852b3d69c05SRobert Mustacchi 	while ((prop_pair = nvlist_next_nvpair(prop_list, prop_pair)) != NULL) {
185326947304SEvan Yan 		name = nvpair_name(prop_pair);
185426947304SEvan Yan 
1855b3d69c05SRobert Mustacchi 		/*
1856b3d69c05SRobert Mustacchi 		 * The validity of the property was checked above.
1857b3d69c05SRobert Mustacchi 		 */
185826947304SEvan Yan 		if (strcmp(name, PCIEHPC_PROP_LED_ATTN) == 0) {
185926947304SEvan Yan 			if (strcmp(value, PCIEHPC_PROP_VALUE_ON) == 0)
186026947304SEvan Yan 				led_state = PCIE_HP_LED_ON;
186126947304SEvan Yan 			else if (strcmp(value, PCIEHPC_PROP_VALUE_OFF) == 0)
186226947304SEvan Yan 				led_state = PCIE_HP_LED_OFF;
186326947304SEvan Yan 			else if (strcmp(value, PCIEHPC_PROP_VALUE_BLINK) == 0)
186426947304SEvan Yan 				led_state = PCIE_HP_LED_BLINK;
1865b3d69c05SRobert Mustacchi 			else
1866b3d69c05SRobert Mustacchi 				continue;
186726947304SEvan Yan 
186826947304SEvan Yan 			pciehpc_set_led_state(ctrl_p, PCIE_HP_ATTN_LED,
186926947304SEvan Yan 			    led_state);
187026947304SEvan Yan 		}
187126947304SEvan Yan 	}
187224fd5dc4SEvan Yan 	if (rval) {
187324fd5dc4SEvan Yan 		if (get_udatamodel() == DATAMODEL_NATIVE) {
187424fd5dc4SEvan Yan 			result.buf_size = 0;
187524fd5dc4SEvan Yan 			if (copyout(&result, rval, sizeof (ddi_hp_property_t)))
187624fd5dc4SEvan Yan 				ret =  DDI_FAILURE;
187724fd5dc4SEvan Yan 		}
187824fd5dc4SEvan Yan #ifdef _SYSCALL32_IMPL
187924fd5dc4SEvan Yan 		else {
188024fd5dc4SEvan Yan 			result32.buf_size = 0;
188124fd5dc4SEvan Yan 			if (copyout(&result32, rval,
188224fd5dc4SEvan Yan 			    sizeof (ddi_hp_property32_t)))
188324fd5dc4SEvan Yan 				ret =  DDI_FAILURE;
188424fd5dc4SEvan Yan 		}
188524fd5dc4SEvan Yan #endif
188624fd5dc4SEvan Yan 	}
188726947304SEvan Yan 
188826947304SEvan Yan 	mutex_exit(&ctrl_p->hc_mutex);
188926947304SEvan Yan set_prop_cleanup:
189026947304SEvan Yan 	nvlist_free(prop_list);
189126947304SEvan Yan 	return (ret);
189226947304SEvan Yan }
189326947304SEvan Yan 
189426947304SEvan Yan /*
189526947304SEvan Yan  * Send a command to the PCI-E Hot Plug Controller.
189626947304SEvan Yan  *
189726947304SEvan Yan  * NOTES: The PCI-E spec defines the following semantics for issuing hot plug
189826947304SEvan Yan  * commands.
189926947304SEvan Yan  * 1) If Command Complete events/interrupts are supported then software
190026947304SEvan Yan  *    waits for Command Complete event after issuing a command (i.e writing
190126947304SEvan Yan  *    to the Slot Control register). The command completion could take as
190226947304SEvan Yan  *    long as 1 second so software should be prepared to wait for 1 second
190326947304SEvan Yan  *    before issuing another command.
190426947304SEvan Yan  *
190526947304SEvan Yan  * 2) If Command Complete events/interrupts are not supported then
190626947304SEvan Yan  *    software could issue multiple Slot Control writes without any delay
190726947304SEvan Yan  *    between writes.
190826947304SEvan Yan  */
190926947304SEvan Yan static void
191026947304SEvan Yan pciehpc_issue_hpc_command(pcie_hp_ctrl_t *ctrl_p, uint16_t control)
191126947304SEvan Yan {
191226947304SEvan Yan 	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
191326947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
191426947304SEvan Yan 	uint16_t	status;
191526947304SEvan Yan 	uint32_t	slot_cap;
191626947304SEvan Yan 
191726947304SEvan Yan 	/*
191826947304SEvan Yan 	 * PCI-E version 1.1 spec defines No Command Completed
191926947304SEvan Yan 	 * Support bit (bit#18) in Slot Capabilities register. If this
192026947304SEvan Yan 	 * bit is set then slot doesn't support notification of command
192126947304SEvan Yan 	 * completion events.
192226947304SEvan Yan 	 */
192326947304SEvan Yan 	slot_cap =  pciehpc_reg_get32(ctrl_p,
192426947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCAP);
192526947304SEvan Yan 
192626947304SEvan Yan 	/*
192726947304SEvan Yan 	 * If no Command Completion event is supported or it is ACPI
192826947304SEvan Yan 	 * hot plug mode then just issue the command and return.
192926947304SEvan Yan 	 */
193026947304SEvan Yan 	if ((slot_cap & PCIE_SLOTCAP_NO_CMD_COMP_SUPP) ||
193126947304SEvan Yan 	    (bus_p->bus_hp_curr_mode == PCIE_ACPI_HP_MODE)) {
193226947304SEvan Yan 		pciehpc_reg_put16(ctrl_p,
193326947304SEvan Yan 		    bus_p->bus_pcie_off + PCIE_SLOTCTL, control);
193426947304SEvan Yan 		return;
193526947304SEvan Yan 	}
193626947304SEvan Yan 
193726947304SEvan Yan 	/*
193826947304SEvan Yan 	 * **************************************
193926947304SEvan Yan 	 * Command Complete events are supported.
194026947304SEvan Yan 	 * **************************************
194126947304SEvan Yan 	 */
194226947304SEvan Yan 
194326947304SEvan Yan 	/*
194426947304SEvan Yan 	 * If HPC is not yet initialized then just poll for the Command
194526947304SEvan Yan 	 * Completion interrupt.
194626947304SEvan Yan 	 */
194726947304SEvan Yan 	if (!(ctrl_p->hc_flags & PCIE_HP_INITIALIZED_FLAG)) {
194826947304SEvan Yan 		int retry = PCIE_HP_CMD_WAIT_RETRY;
194926947304SEvan Yan 
195026947304SEvan Yan 		/* write the command to the HPC */
195126947304SEvan Yan 		pciehpc_reg_put16(ctrl_p,
195226947304SEvan Yan 		    bus_p->bus_pcie_off + PCIE_SLOTCTL, control);
195326947304SEvan Yan 
195426947304SEvan Yan 		/* poll for status completion */
195526947304SEvan Yan 		while (retry--) {
195626947304SEvan Yan 			/* wait for 10 msec before checking the status */
195726947304SEvan Yan 			delay(drv_usectohz(PCIE_HP_CMD_WAIT_TIME));
195826947304SEvan Yan 
195926947304SEvan Yan 			status = pciehpc_reg_get16(ctrl_p,
196026947304SEvan Yan 			    bus_p->bus_pcie_off + PCIE_SLOTSTS);
196126947304SEvan Yan 
196226947304SEvan Yan 			if (status & PCIE_SLOTSTS_COMMAND_COMPLETED) {
196326947304SEvan Yan 				/* clear the status bits */
196426947304SEvan Yan 				pciehpc_reg_put16(ctrl_p,
196526947304SEvan Yan 				    bus_p->bus_pcie_off + PCIE_SLOTSTS, status);
196626947304SEvan Yan 				break;
196726947304SEvan Yan 			}
196826947304SEvan Yan 		}
196926947304SEvan Yan 		return;
197026947304SEvan Yan 	}
197126947304SEvan Yan 
197226947304SEvan Yan 	/* HPC is already initialized */
197326947304SEvan Yan 
197426947304SEvan Yan 	ASSERT(MUTEX_HELD(&ctrl_p->hc_mutex));
197526947304SEvan Yan 
197626947304SEvan Yan 	/*
197726947304SEvan Yan 	 * If previous command is still pending then wait for its
197826947304SEvan Yan 	 * completion. i.e cv_wait()
197926947304SEvan Yan 	 */
198026947304SEvan Yan 
198126947304SEvan Yan 	while (ctrl_p->hc_cmd_pending == B_TRUE)
198226947304SEvan Yan 		cv_wait(&ctrl_p->hc_cmd_comp_cv, &ctrl_p->hc_mutex);
198326947304SEvan Yan 
198426947304SEvan Yan 	/*
198526947304SEvan Yan 	 * Issue the command and wait for Command Completion or
198626947304SEvan Yan 	 * the 1 sec timeout.
198726947304SEvan Yan 	 */
198826947304SEvan Yan 	pciehpc_reg_put16(ctrl_p,
198926947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL, control);
199026947304SEvan Yan 
199126947304SEvan Yan 	ctrl_p->hc_cmd_pending = B_TRUE;
199226947304SEvan Yan 
199326947304SEvan Yan 	if (cv_timedwait(&ctrl_p->hc_cmd_comp_cv, &ctrl_p->hc_mutex,
199426947304SEvan Yan 	    ddi_get_lbolt() + SEC_TO_TICK(1)) == -1) {
199526947304SEvan Yan 
199626947304SEvan Yan 		/* it is a timeout */
199726947304SEvan Yan 		PCIE_DBG("pciehpc_issue_hpc_command: Command Complete"
199826947304SEvan Yan 		    " interrupt is not received for slot %d\n",
199926947304SEvan Yan 		    slot_p->hs_phy_slot_num);
200026947304SEvan Yan 
200126947304SEvan Yan 		/* clear the status info in case interrupts are disabled? */
200226947304SEvan Yan 		status = pciehpc_reg_get16(ctrl_p,
200326947304SEvan Yan 		    bus_p->bus_pcie_off + PCIE_SLOTSTS);
200426947304SEvan Yan 
200526947304SEvan Yan 		if (status & PCIE_SLOTSTS_COMMAND_COMPLETED) {
200626947304SEvan Yan 			/* clear the status bits */
200726947304SEvan Yan 			pciehpc_reg_put16(ctrl_p,
200826947304SEvan Yan 			    bus_p->bus_pcie_off + PCIE_SLOTSTS, status);
200926947304SEvan Yan 		}
201026947304SEvan Yan 	}
201126947304SEvan Yan 
201226947304SEvan Yan 	ctrl_p->hc_cmd_pending = B_FALSE;
201326947304SEvan Yan 
201426947304SEvan Yan 	/* wake up any one waiting for issuing another command to HPC */
201526947304SEvan Yan 	cv_signal(&ctrl_p->hc_cmd_comp_cv);
201626947304SEvan Yan }
201726947304SEvan Yan 
201826947304SEvan Yan /*
201926947304SEvan Yan  * pciehcp_attn_btn_handler()
202026947304SEvan Yan  *
202126947304SEvan Yan  * This handles ATTN button pressed event as per the PCI-E 1.1 spec.
202226947304SEvan Yan  */
202326947304SEvan Yan static void
202426947304SEvan Yan pciehpc_attn_btn_handler(pcie_hp_ctrl_t *ctrl_p)
202526947304SEvan Yan {
202626947304SEvan Yan 	pcie_hp_slot_t		*slot_p = ctrl_p->hc_slots[0];
202726947304SEvan Yan 	pcie_hp_led_state_t	power_led_state;
202826947304SEvan Yan 	callb_cpr_t		cprinfo;
202926947304SEvan Yan 
203026947304SEvan Yan 	PCIE_DBG("pciehpc_attn_btn_handler: thread started\n");
203126947304SEvan Yan 
203226947304SEvan Yan 	CALLB_CPR_INIT(&cprinfo, &ctrl_p->hc_mutex, callb_generic_cpr,
203326947304SEvan Yan 	    "pciehpc_attn_btn_handler");
203426947304SEvan Yan 
203526947304SEvan Yan 	mutex_enter(&ctrl_p->hc_mutex);
203626947304SEvan Yan 
203726947304SEvan Yan 	/* wait for ATTN button event */
203826947304SEvan Yan 	cv_wait(&slot_p->hs_attn_btn_cv, &ctrl_p->hc_mutex);
203926947304SEvan Yan 
204026947304SEvan Yan 	while (slot_p->hs_attn_btn_thread_exit == B_FALSE) {
204126947304SEvan Yan 		if (slot_p->hs_attn_btn_pending == B_TRUE) {
204226947304SEvan Yan 			/* get the current state of power LED */
204326947304SEvan Yan 			power_led_state = pciehpc_get_led_state(ctrl_p,
204426947304SEvan Yan 			    PCIE_HP_POWER_LED);
204526947304SEvan Yan 
204626947304SEvan Yan 			/* Blink the Power LED while we wait for 5 seconds */
204726947304SEvan Yan 			pciehpc_set_led_state(ctrl_p, PCIE_HP_POWER_LED,
204826947304SEvan Yan 			    PCIE_HP_LED_BLINK);
204926947304SEvan Yan 
205026947304SEvan Yan 			/* wait for 5 seconds before taking any action */
205126947304SEvan Yan 			if (cv_timedwait(&slot_p->hs_attn_btn_cv,
205226947304SEvan Yan 			    &ctrl_p->hc_mutex,
205326947304SEvan Yan 			    ddi_get_lbolt() + SEC_TO_TICK(5)) == -1) {
205426947304SEvan Yan 				/*
205526947304SEvan Yan 				 * It is a time out; make sure the ATTN pending
205626947304SEvan Yan 				 * flag is still ON before sending the event to
205726947304SEvan Yan 				 * DDI HP framework.
205826947304SEvan Yan 				 */
205926947304SEvan Yan 				if (slot_p->hs_attn_btn_pending == B_TRUE) {
206026947304SEvan Yan 					int hint;
206126947304SEvan Yan 
206226947304SEvan Yan 					slot_p->hs_attn_btn_pending = B_FALSE;
206326947304SEvan Yan 					pciehpc_get_slot_state(slot_p);
206426947304SEvan Yan 
206526947304SEvan Yan 					if (slot_p->hs_info.cn_state <=
206626947304SEvan Yan 					    DDI_HP_CN_STATE_PRESENT) {
206726947304SEvan Yan 						/*
206826947304SEvan Yan 						 * Insertion.
206926947304SEvan Yan 						 */
207026947304SEvan Yan 						hint = SE_INCOMING_RES;
207126947304SEvan Yan 					} else {
207226947304SEvan Yan 						/*
207326947304SEvan Yan 						 * Want to remove;
207426947304SEvan Yan 						 */
207526947304SEvan Yan 						hint = SE_OUTGOING_RES;
207626947304SEvan Yan 					}
207726947304SEvan Yan 
207826947304SEvan Yan 					/*
207926947304SEvan Yan 					 * We can't call ddihp_cn_gen_sysevent
208026947304SEvan Yan 					 * here since it's not a DDI interface.
208126947304SEvan Yan 					 */
208226947304SEvan Yan 					pcie_hp_gen_sysevent_req(
208326947304SEvan Yan 					    slot_p->hs_info.cn_name,
208426947304SEvan Yan 					    hint,
208526947304SEvan Yan 					    ctrl_p->hc_dip,
208626947304SEvan Yan 					    KM_SLEEP);
208726947304SEvan Yan 				}
208826947304SEvan Yan 			}
208926947304SEvan Yan 
209026947304SEvan Yan 			/* restore the power LED state */
209126947304SEvan Yan 			pciehpc_set_led_state(ctrl_p, PCIE_HP_POWER_LED,
209226947304SEvan Yan 			    power_led_state);
209326947304SEvan Yan 			continue;
209426947304SEvan Yan 		}
209526947304SEvan Yan 
209626947304SEvan Yan 		/* wait for another ATTN button event */
209726947304SEvan Yan 		cv_wait(&slot_p->hs_attn_btn_cv, &ctrl_p->hc_mutex);
209826947304SEvan Yan 	}
209926947304SEvan Yan 
210026947304SEvan Yan 	PCIE_DBG("pciehpc_attn_btn_handler: thread exit\n");
210126947304SEvan Yan 	cv_signal(&slot_p->hs_attn_btn_cv);
210226947304SEvan Yan 	CALLB_CPR_EXIT(&cprinfo);
210326947304SEvan Yan 	thread_exit();
210426947304SEvan Yan }
210526947304SEvan Yan 
210626947304SEvan Yan /*
210726947304SEvan Yan  * convert LED state from PCIE HPC definition to pcie_hp_led_state_t
210826947304SEvan Yan  * definition.
210926947304SEvan Yan  */
211026947304SEvan Yan static pcie_hp_led_state_t
211126947304SEvan Yan pciehpc_led_state_to_hpc(uint16_t state)
211226947304SEvan Yan {
211326947304SEvan Yan 	switch (state) {
211426947304SEvan Yan 	case PCIE_SLOTCTL_INDICATOR_STATE_ON:
211526947304SEvan Yan 		return (PCIE_HP_LED_ON);
211626947304SEvan Yan 	case PCIE_SLOTCTL_INDICATOR_STATE_BLINK:
211726947304SEvan Yan 		return (PCIE_HP_LED_BLINK);
211826947304SEvan Yan 	case PCIE_SLOTCTL_INDICATOR_STATE_OFF:
211926947304SEvan Yan 	default:
212026947304SEvan Yan 		return (PCIE_HP_LED_OFF);
212126947304SEvan Yan 	}
212226947304SEvan Yan }
212326947304SEvan Yan 
212426947304SEvan Yan /*
212526947304SEvan Yan  * Get the state of an LED.
212626947304SEvan Yan  */
212726947304SEvan Yan static pcie_hp_led_state_t
212826947304SEvan Yan pciehpc_get_led_state(pcie_hp_ctrl_t *ctrl_p, pcie_hp_led_t led)
212926947304SEvan Yan {
213026947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
213126947304SEvan Yan 	uint16_t	control, state;
213226947304SEvan Yan 
213326947304SEvan Yan 	/* get the current state of Slot Control register */
213426947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
213526947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
213626947304SEvan Yan 
213726947304SEvan Yan 	switch (led) {
213826947304SEvan Yan 	case PCIE_HP_POWER_LED:
213926947304SEvan Yan 		state = pcie_slotctl_pwr_indicator_get(control);
214026947304SEvan Yan 		break;
214126947304SEvan Yan 	case PCIE_HP_ATTN_LED:
214226947304SEvan Yan 		state = pcie_slotctl_attn_indicator_get(control);
214326947304SEvan Yan 		break;
214426947304SEvan Yan 	default:
214526947304SEvan Yan 		PCIE_DBG("pciehpc_get_led_state() invalid LED %d\n", led);
214626947304SEvan Yan 		return (PCIE_HP_LED_OFF);
214726947304SEvan Yan 	}
214826947304SEvan Yan 
214926947304SEvan Yan 	switch (state) {
215026947304SEvan Yan 	case PCIE_SLOTCTL_INDICATOR_STATE_ON:
215126947304SEvan Yan 		return (PCIE_HP_LED_ON);
215226947304SEvan Yan 
215326947304SEvan Yan 	case PCIE_SLOTCTL_INDICATOR_STATE_BLINK:
215426947304SEvan Yan 		return (PCIE_HP_LED_BLINK);
215526947304SEvan Yan 
215626947304SEvan Yan 	case PCIE_SLOTCTL_INDICATOR_STATE_OFF:
215726947304SEvan Yan 	default:
215826947304SEvan Yan 		return (PCIE_HP_LED_OFF);
215926947304SEvan Yan 	}
216026947304SEvan Yan }
216126947304SEvan Yan 
216226947304SEvan Yan /*
216326947304SEvan Yan  * Set the state of an LED. It updates both hw and sw state.
216426947304SEvan Yan  */
216526947304SEvan Yan static void
216626947304SEvan Yan pciehpc_set_led_state(pcie_hp_ctrl_t *ctrl_p, pcie_hp_led_t led,
216726947304SEvan Yan     pcie_hp_led_state_t state)
216826947304SEvan Yan {
216926947304SEvan Yan 	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
217026947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
217126947304SEvan Yan 	uint16_t	control;
217226947304SEvan Yan 
217326947304SEvan Yan 	/* get the current state of Slot Control register */
217426947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
217526947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
217626947304SEvan Yan 
217726947304SEvan Yan 	switch (led) {
217826947304SEvan Yan 	case PCIE_HP_POWER_LED:
217926947304SEvan Yan 		/* clear led mask */
218026947304SEvan Yan 		control &= ~PCIE_SLOTCTL_PWR_INDICATOR_MASK;
218126947304SEvan Yan 		slot_p->hs_power_led_state = state;
218226947304SEvan Yan 		break;
218326947304SEvan Yan 	case PCIE_HP_ATTN_LED:
218426947304SEvan Yan 		/* clear led mask */
218526947304SEvan Yan 		control &= ~PCIE_SLOTCTL_ATTN_INDICATOR_MASK;
218626947304SEvan Yan 		slot_p->hs_attn_led_state = state;
218726947304SEvan Yan 		break;
218826947304SEvan Yan 	default:
218926947304SEvan Yan 		PCIE_DBG("pciehpc_set_led_state() invalid LED %d\n", led);
219026947304SEvan Yan 		return;
219126947304SEvan Yan 	}
219226947304SEvan Yan 
219326947304SEvan Yan 	switch (state) {
219426947304SEvan Yan 	case PCIE_HP_LED_ON:
219526947304SEvan Yan 		if (led == PCIE_HP_POWER_LED)
219626947304SEvan Yan 			control = pcie_slotctl_pwr_indicator_set(control,
219726947304SEvan Yan 			    PCIE_SLOTCTL_INDICATOR_STATE_ON);
219826947304SEvan Yan 		else if (led == PCIE_HP_ATTN_LED)
219926947304SEvan Yan 			control = pcie_slotctl_attn_indicator_set(control,
220026947304SEvan Yan 			    PCIE_SLOTCTL_INDICATOR_STATE_ON);
220126947304SEvan Yan 		break;
220226947304SEvan Yan 	case PCIE_HP_LED_OFF:
220326947304SEvan Yan 		if (led == PCIE_HP_POWER_LED)
220426947304SEvan Yan 			control = pcie_slotctl_pwr_indicator_set(control,
220526947304SEvan Yan 			    PCIE_SLOTCTL_INDICATOR_STATE_OFF);
220626947304SEvan Yan 		else if (led == PCIE_HP_ATTN_LED)
220726947304SEvan Yan 			control = pcie_slotctl_attn_indicator_set(control,
220826947304SEvan Yan 			    PCIE_SLOTCTL_INDICATOR_STATE_OFF);
220926947304SEvan Yan 		break;
221026947304SEvan Yan 	case PCIE_HP_LED_BLINK:
221126947304SEvan Yan 		if (led == PCIE_HP_POWER_LED)
221226947304SEvan Yan 			control = pcie_slotctl_pwr_indicator_set(control,
221326947304SEvan Yan 			    PCIE_SLOTCTL_INDICATOR_STATE_BLINK);
221426947304SEvan Yan 		else if (led == PCIE_HP_ATTN_LED)
221526947304SEvan Yan 			control = pcie_slotctl_attn_indicator_set(control,
221626947304SEvan Yan 			    PCIE_SLOTCTL_INDICATOR_STATE_BLINK);
221726947304SEvan Yan 		break;
221826947304SEvan Yan 
221926947304SEvan Yan 	default:
222026947304SEvan Yan 		PCIE_DBG("pciehpc_set_led_state() invalid LED state %d\n",
222126947304SEvan Yan 		    state);
222226947304SEvan Yan 		return;
222326947304SEvan Yan 	}
222426947304SEvan Yan 
222526947304SEvan Yan 	/* update the Slot Control Register */
222626947304SEvan Yan 	pciehpc_issue_hpc_command(ctrl_p, control);
222726947304SEvan Yan 
222826947304SEvan Yan #ifdef DEBUG
222926947304SEvan Yan 	/* get the current state of Slot Control register */
223026947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
223126947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
223226947304SEvan Yan 
223326947304SEvan Yan 	PCIE_DBG("pciehpc_set_led_state: slot %d power-led %s attn-led %s\n",
223426947304SEvan Yan 	    slot_p->hs_phy_slot_num, pcie_led_state_text(
223526947304SEvan Yan 	    pciehpc_led_state_to_hpc(pcie_slotctl_pwr_indicator_get(control))),
223626947304SEvan Yan 	    pcie_led_state_text(pciehpc_led_state_to_hpc(
223726947304SEvan Yan 	    pcie_slotctl_attn_indicator_get(control))));
223826947304SEvan Yan #endif
223926947304SEvan Yan }
224026947304SEvan Yan 
224180dc702dSColin Zou - Sun Microsystems - Beijing China static void
224280dc702dSColin Zou - Sun Microsystems - Beijing China pciehpc_handle_power_fault(dev_info_t *dip)
224380dc702dSColin Zou - Sun Microsystems - Beijing China {
224480dc702dSColin Zou - Sun Microsystems - Beijing China 	/*
224580dc702dSColin Zou - Sun Microsystems - Beijing China 	 * Hold the parent's ref so that it won't disappear when the taskq is
224680dc702dSColin Zou - Sun Microsystems - Beijing China 	 * scheduled to run.
224780dc702dSColin Zou - Sun Microsystems - Beijing China 	 */
224880dc702dSColin Zou - Sun Microsystems - Beijing China 	ndi_hold_devi(dip);
224980dc702dSColin Zou - Sun Microsystems - Beijing China 
2250fc8ae2ecSToomas Soome 	if (taskq_dispatch(system_taskq, pciehpc_power_fault_handler, dip,
2251fc8ae2ecSToomas Soome 	    TQ_NOSLEEP) == TASKQID_INVALID) {
225280dc702dSColin Zou - Sun Microsystems - Beijing China 		ndi_rele_devi(dip);
225380dc702dSColin Zou - Sun Microsystems - Beijing China 		PCIE_DBG("pciehpc_intr(): "
225480dc702dSColin Zou - Sun Microsystems - Beijing China 		    "Failed to dispatch power fault handler, dip %p\n", dip);
225580dc702dSColin Zou - Sun Microsystems - Beijing China 	}
225680dc702dSColin Zou - Sun Microsystems - Beijing China }
225780dc702dSColin Zou - Sun Microsystems - Beijing China 
225880dc702dSColin Zou - Sun Microsystems - Beijing China static void
225980dc702dSColin Zou - Sun Microsystems - Beijing China pciehpc_power_fault_handler(void *arg)
226080dc702dSColin Zou - Sun Microsystems - Beijing China {
226180dc702dSColin Zou - Sun Microsystems - Beijing China 	dev_info_t *dip = (dev_info_t *)arg;
226280dc702dSColin Zou - Sun Microsystems - Beijing China 	pcie_hp_ctrl_t  *ctrl_p;
226380dc702dSColin Zou - Sun Microsystems - Beijing China 	pcie_hp_slot_t  *slot_p;
226480dc702dSColin Zou - Sun Microsystems - Beijing China 
226580dc702dSColin Zou - Sun Microsystems - Beijing China 	/* get the soft state structure for this dip */
226680dc702dSColin Zou - Sun Microsystems - Beijing China 	if ((ctrl_p = PCIE_GET_HP_CTRL(dip)) == NULL) {
226780dc702dSColin Zou - Sun Microsystems - Beijing China 		ndi_rele_devi(dip);
226880dc702dSColin Zou - Sun Microsystems - Beijing China 		return;
226980dc702dSColin Zou - Sun Microsystems - Beijing China 	}
227080dc702dSColin Zou - Sun Microsystems - Beijing China 	slot_p = ctrl_p->hc_slots[0];
227180dc702dSColin Zou - Sun Microsystems - Beijing China 
227280dc702dSColin Zou - Sun Microsystems - Beijing China 	/*
227380dc702dSColin Zou - Sun Microsystems - Beijing China 	 * Send the event to DDI Hotplug framework, power off
227480dc702dSColin Zou - Sun Microsystems - Beijing China 	 * the slot
227580dc702dSColin Zou - Sun Microsystems - Beijing China 	 */
227680dc702dSColin Zou - Sun Microsystems - Beijing China 	(void) ndi_hp_state_change_req(dip,
227780dc702dSColin Zou - Sun Microsystems - Beijing China 	    slot_p->hs_info.cn_name,
227880dc702dSColin Zou - Sun Microsystems - Beijing China 	    DDI_HP_CN_STATE_EMPTY, DDI_HP_REQ_SYNC);
227980dc702dSColin Zou - Sun Microsystems - Beijing China 
228080dc702dSColin Zou - Sun Microsystems - Beijing China 	mutex_enter(&ctrl_p->hc_mutex);
228180dc702dSColin Zou - Sun Microsystems - Beijing China 	pciehpc_set_led_state(ctrl_p, PCIE_HP_ATTN_LED,
228280dc702dSColin Zou - Sun Microsystems - Beijing China 	    PCIE_HP_LED_ON);
228380dc702dSColin Zou - Sun Microsystems - Beijing China 	mutex_exit(&ctrl_p->hc_mutex);
228480dc702dSColin Zou - Sun Microsystems - Beijing China 	ndi_rele_devi(dip);
228580dc702dSColin Zou - Sun Microsystems - Beijing China }
228680dc702dSColin Zou - Sun Microsystems - Beijing China 
228726947304SEvan Yan #ifdef DEBUG
228826947304SEvan Yan /*
228926947304SEvan Yan  * Dump PCI-E Hot Plug registers.
229026947304SEvan Yan  */
229126947304SEvan Yan static void
229226947304SEvan Yan pciehpc_dump_hpregs(pcie_hp_ctrl_t *ctrl_p)
229326947304SEvan Yan {
229426947304SEvan Yan 	pcie_hp_slot_t	*slot_p = ctrl_p->hc_slots[0];
229526947304SEvan Yan 	pcie_bus_t	*bus_p = PCIE_DIP2BUS(ctrl_p->hc_dip);
229626947304SEvan Yan 	uint16_t	control;
229726947304SEvan Yan 	uint32_t	capabilities;
229826947304SEvan Yan 
229926947304SEvan Yan 	if (!pcie_debug_flags)
230026947304SEvan Yan 		return;
230126947304SEvan Yan 
230226947304SEvan Yan 	capabilities = pciehpc_reg_get32(ctrl_p,
230326947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCAP);
230426947304SEvan Yan 
230526947304SEvan Yan 	control =  pciehpc_reg_get16(ctrl_p,
230626947304SEvan Yan 	    bus_p->bus_pcie_off + PCIE_SLOTCTL);
230726947304SEvan Yan 
230826947304SEvan Yan 	PCIE_DBG("pciehpc_dump_hpregs: Found PCI-E hot plug slot %d\n",
230926947304SEvan Yan 	    slot_p->hs_phy_slot_num);
231026947304SEvan Yan 
231126947304SEvan Yan 	PCIE_DBG("Attention Button Present = %s\n",
231226947304SEvan Yan 	    capabilities & PCIE_SLOTCAP_ATTN_BUTTON ? "Yes":"No");
231326947304SEvan Yan 
231426947304SEvan Yan 	PCIE_DBG("Power controller Present = %s\n",
231526947304SEvan Yan 	    capabilities & PCIE_SLOTCAP_POWER_CONTROLLER ? "Yes":"No");
231626947304SEvan Yan 
231726947304SEvan Yan 	PCIE_DBG("MRL Sensor Present	   = %s\n",
231826947304SEvan Yan 	    capabilities & PCIE_SLOTCAP_MRL_SENSOR ? "Yes":"No");
231926947304SEvan Yan 
232026947304SEvan Yan 	PCIE_DBG("Attn Indicator Present   = %s\n",
232126947304SEvan Yan 	    capabilities & PCIE_SLOTCAP_ATTN_INDICATOR ? "Yes":"No");
232226947304SEvan Yan 
232326947304SEvan Yan 	PCIE_DBG("Power Indicator Present  = %s\n",
232426947304SEvan Yan 	    capabilities & PCIE_SLOTCAP_PWR_INDICATOR ? "Yes":"No");
232526947304SEvan Yan 
232626947304SEvan Yan 	PCIE_DBG("HotPlug Surprise	   = %s\n",
232726947304SEvan Yan 	    capabilities & PCIE_SLOTCAP_HP_SURPRISE ? "Yes":"No");
232826947304SEvan Yan 
232926947304SEvan Yan 	PCIE_DBG("HotPlug Capable	   = %s\n",
233026947304SEvan Yan 	    capabilities & PCIE_SLOTCAP_HP_CAPABLE ? "Yes":"No");
233126947304SEvan Yan 
233226947304SEvan Yan 	PCIE_DBG("Physical Slot Number	   = %d\n",
233326947304SEvan Yan 	    PCIE_SLOTCAP_PHY_SLOT_NUM(capabilities));
233426947304SEvan Yan 
233526947304SEvan Yan 	PCIE_DBG("Attn Button interrupt Enabled  = %s\n",
233626947304SEvan Yan 	    control & PCIE_SLOTCTL_ATTN_BTN_EN ? "Yes":"No");
233726947304SEvan Yan 
233826947304SEvan Yan 	PCIE_DBG("Power Fault interrupt Enabled  = %s\n",
233926947304SEvan Yan 	    control & PCIE_SLOTCTL_PWR_FAULT_EN ? "Yes":"No");
234026947304SEvan Yan 
234126947304SEvan Yan 	PCIE_DBG("MRL Sensor INTR Enabled   = %s\n",
234226947304SEvan Yan 	    control & PCIE_SLOTCTL_MRL_SENSOR_EN ? "Yes":"No");
234326947304SEvan Yan 
234426947304SEvan Yan 	PCIE_DBG("Presence interrupt Enabled	 = %s\n",
234526947304SEvan Yan 	    control & PCIE_SLOTCTL_PRESENCE_CHANGE_EN ? "Yes":"No");
234626947304SEvan Yan 
234726947304SEvan Yan 	PCIE_DBG("Cmd Complete interrupt Enabled = %s\n",
234826947304SEvan Yan 	    control & PCIE_SLOTCTL_CMD_INTR_EN ? "Yes":"No");
234926947304SEvan Yan 
235026947304SEvan Yan 	PCIE_DBG("HotPlug interrupt Enabled	 = %s\n",
235126947304SEvan Yan 	    control & PCIE_SLOTCTL_HP_INTR_EN ? "Yes":"No");
235226947304SEvan Yan 
235326947304SEvan Yan 	PCIE_DBG("Power Indicator LED = %s", pcie_led_state_text(
235426947304SEvan Yan 	    pciehpc_led_state_to_hpc(pcie_slotctl_pwr_indicator_get(control))));
235526947304SEvan Yan 
235626947304SEvan Yan 	PCIE_DBG("Attn Indicator LED = %s\n",
235726947304SEvan Yan 	    pcie_led_state_text(pciehpc_led_state_to_hpc(
235826947304SEvan Yan 	    pcie_slotctl_attn_indicator_get(control))));
235926947304SEvan Yan }
236026947304SEvan Yan #endif	/* DEBUG */
2361