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