/*
* Initialize our FMA resources
*/
static void
acpinex_fm_init(acpinex_softstate_t *softsp)
{
softsp->ans_fm_cap = DDI_FM_EREPORT_CAPABLE | DDI_FM_ERRCB_CAPABLE |
DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE;
/*
* Request our capability level and get our parent's capability and ibc.
*/
ddi_fm_init(softsp->ans_dip, &softsp->ans_fm_cap, &softsp->ans_fm_ibc);
if (softsp->ans_fm_cap & DDI_FM_ERRCB_CAPABLE) {
/*
* Register error callback with our parent if supported.
*/
ddi_fm_handler_register(softsp->ans_dip, acpinex_err_callback,
softsp);
}
}
/*
* Initialize our FMA resources
*/
static void
ppb_fm_init(ppb_devstate_t *ppb_p)
{
ppb_p->fm_cap = DDI_FM_EREPORT_CAPABLE | DDI_FM_ERRCB_CAPABLE |
DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE;
/*
* Request our capability level and get our parents capability
* and ibc.
*/
ddi_fm_init(ppb_p->dip, &ppb_p->fm_cap, &ppb_p->fm_ibc);
ASSERT((ppb_p->fm_cap & DDI_FM_EREPORT_CAPABLE) &&
(ppb_p->fm_cap & DDI_FM_ERRCB_CAPABLE));
pci_ereport_setup(ppb_p->dip);
/*
* Register error callback with our parent.
*/
ddi_fm_handler_register(ppb_p->dip, ppb_err_callback, NULL);
}
void
pci_fm_create(pci_t *pci_p)
{
pci_common_t *cmn_p = pci_p->pci_common_p;
/*
* PCI detected ECC errorq, to schedule async handling
* of ECC errors and logging.
* The errorq is created here but destroyed when _fini is called
* for the pci module.
*/
if (pci_ecc_queue == NULL) {
pci_ecc_queue = errorq_create("pci_ecc_queue",
(errorq_func_t)ecc_err_drain,
(void *)pci_p->pci_ecc_p,
ECC_MAX_ERRS, sizeof (ecc_errstate_t),
PIL_2, ERRORQ_VITAL);
if (pci_ecc_queue == NULL)
panic("failed to create required system error queue");
}
/*
* Initialize pci_target_queue for FMA handling of pci errors.
*/
pci_targetq_init();
/*
* Initialize FMA support
* The axq workaround prevents fault management of access errors
*/
if (pci_p->pci_pbm_p->pbm_pio_limit == 0)
pci_p->pci_fm_cap = DDI_FM_EREPORT_CAPABLE |
DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE |
DDI_FM_ERRCB_CAPABLE;
else
pci_p->pci_fm_cap = DDI_FM_EREPORT_CAPABLE |
DDI_FM_DMACHK_CAPABLE | DDI_FM_ERRCB_CAPABLE;
/*
* Call parent to get it's capablity
*/
ddi_fm_init(pci_p->pci_dip, &pci_p->pci_fm_cap,
&pci_p->pci_fm_ibc);
/*
* Need to be ereport and error handler cabable
*/
ASSERT((pci_p->pci_fm_cap & DDI_FM_ERRCB_CAPABLE) &&
(pci_p->pci_fm_cap & DDI_FM_EREPORT_CAPABLE));
/*
* Initialize error handling mutex.
*/
if (cmn_p->pci_common_refcnt == 0) {
mutex_init(&cmn_p->pci_fm_mutex, NULL, MUTEX_DRIVER,
(void *)pci_p->pci_fm_ibc);
}
/*
* Register error callback with our parent.
*/
ddi_fm_handler_register(pci_p->pci_dip, pci_err_callback,
pci_p);
}
/*ARGSUSED*/
static int
ppb_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
dev_info_t *root = ddi_root_node();
int instance;
ppb_devstate_t *ppb;
dev_info_t *pdip;
ddi_acc_handle_t config_handle;
char *bus;
int ret;
switch (cmd) {
case DDI_ATTACH:
/*
* Make sure the "device_type" property exists.
*/
(void) ddi_prop_update_string(DDI_DEV_T_NONE, devi,
"device_type", "pci");
/*
* Allocate and get soft state structure.
*/
instance = ddi_get_instance(devi);
if (ddi_soft_state_zalloc(ppb_state, instance) != DDI_SUCCESS)
return (DDI_FAILURE);
ppb = ddi_get_soft_state(ppb_state, instance);
ppb->dip = devi;
/*
* don't enable ereports if immediate child of npe
*/
if (strcmp(ddi_driver_name(ddi_get_parent(devi)), "npe") == 0)
ppb->ppb_fmcap = DDI_FM_ERRCB_CAPABLE |
DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE;
else
ppb->ppb_fmcap = DDI_FM_EREPORT_CAPABLE |
DDI_FM_ERRCB_CAPABLE | DDI_FM_ACCCHK_CAPABLE |
DDI_FM_DMACHK_CAPABLE;
ddi_fm_init(devi, &ppb->ppb_fmcap, &ppb->ppb_fm_ibc);
mutex_init(&ppb->ppb_mutex, NULL, MUTEX_DRIVER, NULL);
mutex_init(&ppb->ppb_err_mutex, NULL, MUTEX_DRIVER,
(void *)ppb->ppb_fm_ibc);
mutex_init(&ppb->ppb_peek_poke_mutex, NULL, MUTEX_DRIVER,
(void *)ppb->ppb_fm_ibc);
if (ppb->ppb_fmcap & (DDI_FM_ERRCB_CAPABLE |
DDI_FM_EREPORT_CAPABLE))
pci_ereport_setup(devi);
if (ppb->ppb_fmcap & DDI_FM_ERRCB_CAPABLE)
ddi_fm_handler_register(devi, ppb_fm_callback, NULL);
if (pci_config_setup(devi, &config_handle) != DDI_SUCCESS) {
if (ppb->ppb_fmcap & DDI_FM_ERRCB_CAPABLE)
ddi_fm_handler_unregister(devi);
if (ppb->ppb_fmcap & (DDI_FM_ERRCB_CAPABLE |
DDI_FM_EREPORT_CAPABLE))
pci_ereport_teardown(devi);
ddi_fm_fini(devi);
ddi_soft_state_free(ppb_state, instance);
return (DDI_FAILURE);
}
ppb->parent_bus = PCIE_PCIECAP_DEV_TYPE_PCI_PSEUDO;
for (pdip = ddi_get_parent(devi); pdip && (pdip != root) &&
(ppb->parent_bus != PCIE_PCIECAP_DEV_TYPE_PCIE_DEV);
pdip = ddi_get_parent(pdip)) {
if (ddi_prop_lookup_string(DDI_DEV_T_ANY, pdip,
DDI_PROP_DONTPASS, "device_type", &bus) !=
DDI_PROP_SUCCESS)
break;
if (strcmp(bus, "pciex") == 0)
ppb->parent_bus =
PCIE_PCIECAP_DEV_TYPE_PCIE_DEV;
ddi_prop_free(bus);
}
if (ppb_support_ht_msimap == 1)
(void) ppb_ht_msimap_set(config_handle,
HT_MSIMAP_ENABLE);
else if (ppb_support_ht_msimap == -1)
(void) ppb_ht_msimap_set(config_handle,
HT_MSIMAP_DISABLE);
pci_config_teardown(&config_handle);
/*
* Initialize hotplug support on this bus.
*/
if (ppb->parent_bus == PCIE_PCIECAP_DEV_TYPE_PCIE_DEV)
ret = pcie_init(devi, NULL);
else
ret = pcihp_init(devi);
if (ret != DDI_SUCCESS) {
cmn_err(CE_WARN,
"pci: Failed to setup hotplug framework");
(void) ppb_detach(devi, DDI_DETACH);
return (ret);
}
ddi_report_dev(devi);
return (DDI_SUCCESS);
case DDI_RESUME:
/*
* Get the soft state structure for the bridge.
*/
ppb = ddi_get_soft_state(ppb_state, ddi_get_instance(devi));
ppb_restore_config_regs(ppb);
return (DDI_SUCCESS);
default:
break;
}
return (DDI_FAILURE);
}
/*ARGSUSED*/
static int
pci_attach(dev_info_t *devi, ddi_attach_cmd_t cmd)
{
/*
* Use the minor number as constructed by pcihp, as the index value to
* ddi_soft_state_zalloc.
*/
int instance = ddi_get_instance(devi);
pci_state_t *pcip = NULL;
switch (cmd) {
case DDI_ATTACH:
break;
case DDI_RESUME:
return (DDI_SUCCESS);
default:
return (DDI_FAILURE);
}
if (ddi_prop_update_string(DDI_DEV_T_NONE, devi, "device_type", "pci")
!= DDI_PROP_SUCCESS) {
cmn_err(CE_WARN, "pci: 'device_type' prop create failed");
}
if (ddi_soft_state_zalloc(pci_statep, instance) == DDI_SUCCESS) {
pcip = ddi_get_soft_state(pci_statep, instance);
}
if (pcip == NULL) {
goto bad_soft_state;
}
pcip->pci_dip = devi;
pcip->pci_soft_state = PCI_SOFT_STATE_CLOSED;
/*
* Initialize hotplug support on this bus. At minimum
* (for non hotplug bus) this would create ":devctl" minor
* node to support DEVCTL_DEVICE_* and DEVCTL_BUS_* ioctls
* to this bus.
*/
if (pcihp_init(devi) != DDI_SUCCESS) {
cmn_err(CE_WARN, "pci: Failed to setup hotplug framework");
goto bad_pcihp_init;
}
/* Second arg: initialize for pci, not pci_express */
if (pcitool_init(devi, B_FALSE) != DDI_SUCCESS) {
goto bad_pcitool_init;
}
pcip->pci_fmcap = DDI_FM_ERRCB_CAPABLE |
DDI_FM_ACCCHK_CAPABLE | DDI_FM_DMACHK_CAPABLE;
ddi_fm_init(devi, &pcip->pci_fmcap, &pcip->pci_fm_ibc);
mutex_init(&pcip->pci_mutex, NULL, MUTEX_DRIVER, NULL);
mutex_init(&pcip->pci_err_mutex, NULL, MUTEX_DRIVER,
(void *)pcip->pci_fm_ibc);
mutex_init(&pcip->pci_peek_poke_mutex, NULL, MUTEX_DRIVER,
(void *)pcip->pci_fm_ibc);
if (pcip->pci_fmcap & DDI_FM_ERRCB_CAPABLE) {
pci_ereport_setup(devi);
ddi_fm_handler_register(devi, pci_fm_callback, NULL);
}
ddi_report_dev(devi);
return (DDI_SUCCESS);
bad_pcitool_init:
(void) pcihp_uninit(devi);
bad_pcihp_init:
ddi_soft_state_free(pci_statep, instance);
bad_soft_state:
return (DDI_FAILURE);
}
