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