static void
ppb_removechild(dev_info_t *dip)
{
ppb_devstate_t *ppb;
ppb = (ppb_devstate_t *)ddi_get_soft_state(ppb_state,
ddi_get_instance(ddi_get_parent(dip)));
if (PM_CAPABLE(ppb->ppb_pwr_p)) {
DEBUG2(DBG_PWR, ddi_get_parent(dip),
"UNINITCHILD: removing pwr_info for %s@%s\n",
ddi_node_name(dip), ddi_get_name_addr(dip));
pci_pwr_rm_info(ppb->ppb_pwr_p, dip);
}
ddi_set_name_addr(dip, NULL);
/*
* Strip the node to properly convert it back to prototype form
*/
ddi_remove_minor_node(dip, NULL);
impl_rem_dev_props(dip);
}
static dev_info_t *
get_my_childs_dip(dev_info_t *dip, dev_info_t *rdip)
{
dev_info_t *cdip = rdip;
for (; ddi_get_parent(cdip) != dip; cdip = ddi_get_parent(cdip))
;
return (cdip);
}
int
is_pseudo_device(dev_info_t *dip)
{
dev_info_t *pdip;
for (pdip = ddi_get_parent(dip); pdip && pdip != ddi_root_node();
pdip = ddi_get_parent(pdip)) {
if (strcmp(ddi_get_name(pdip), DEVI_PSEUDO_NEXNAME) == 0)
return (1);
}
return (0);
}
static int
fco_parent(dev_info_t *ap, fco_handle_t rp, fc_ci_t *cp)
{
fc_phandle_t h;
dev_info_t *dip;
if (fc_cell2int(cp->nargs) != 1)
return (fc_syntax_error(cp, "nargs must be 1"));
if (fc_cell2int(cp->nresults) < 1)
return (fc_syntax_error(cp, "nresults must be > 0"));
/*
* Make sure this is a handle we gave out ...
*/
h = fc_cell2phandle(fc_arg(cp, 0));
if ((dip = fc_phandle_to_dip(fc_handle_to_phandle_head(rp), h)) == NULL)
return (fc_priv_error(cp, "unknown handle"));
/*
* Find the parent and if there is one, return it ...
*/
dip = ddi_get_parent(dip);
h = 0;
if (dip != NULL)
h = fc_dip_to_phandle(fc_handle_to_phandle_head(rp), dip);
cp->nresults = fc_int2cell(1);
fc_result(cp, 0) = fc_phandle2cell(h);
return (fc_success_op(ap, rp, cp));
}
static int vboxUSBMonSolarisResetDevice(char *pszDevicePath, bool fReattach)
{
int rc = VERR_GENERAL_FAILURE;
LogFunc((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: pszDevicePath=%s fReattach=%d\n", pszDevicePath, fReattach));
/*
* Try grabbing the dev_info_t.
*/
dev_info_t *pDeviceInfo = e_ddi_hold_devi_by_path(pszDevicePath, 0);
if (pDeviceInfo)
{
ddi_release_devi(pDeviceInfo);
/*
* Grab the root device node from the parent hub for resetting.
*/
dev_info_t *pTmpDeviceInfo = NULL;
for (;;)
{
pTmpDeviceInfo = ddi_get_parent(pDeviceInfo);
if (!pTmpDeviceInfo)
{
LogRel((DEVICE_NAME ":vboxUSBMonSolarisResetDevice: Failed to get parent device info for %s\n", pszDevicePath));
return VERR_GENERAL_FAILURE;
}
if (ddi_prop_exists(DDI_DEV_T_ANY, pTmpDeviceInfo, DDI_PROP_DONTPASS, "usb-port-count")) /* parent hub */
break;
pDeviceInfo = pTmpDeviceInfo;
}
/*
* Try re-enumerating the device.
*/
rc = usb_reset_device(pDeviceInfo, fReattach ? USB_RESET_LVL_REATTACH : USB_RESET_LVL_DEFAULT);
Log((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: usb_reset_device for %s level=%s rc=%d\n", pszDevicePath,
fReattach ? "ReAttach" : "Default", rc));
switch (rc)
{
case USB_SUCCESS: rc = VINF_SUCCESS; break;
case USB_INVALID_PERM: rc = VERR_PERMISSION_DENIED; break;
case USB_INVALID_ARGS: rc = VERR_INVALID_PARAMETER; break;
case USB_BUSY: rc = VERR_RESOURCE_BUSY; break;
case USB_INVALID_CONTEXT: rc = VERR_INVALID_CONTEXT; break;
case USB_FAILURE: rc = VERR_GENERAL_FAILURE; break;
default: rc = VERR_UNRESOLVED_ERROR; break;
}
}
else
{
rc = VERR_INVALID_HANDLE;
LogRel((DEVICE_NAME ": vboxUSBMonSolarisResetDevice: Cannot obtain device info for %s\n", pszDevicePath));
}
return rc;
}
static void
ppb_removechild(dev_info_t *dip)
{
struct ddi_parent_private_data *pdptr;
ppb_devstate_t *ppb;
ppb = (ppb_devstate_t *)ddi_get_soft_state(ppb_state,
ddi_get_instance(ddi_get_parent(dip)));
if (ppb->parent_bus == PCIE_PCIECAP_DEV_TYPE_PCIE_DEV) {
pcie_fini_dom(dip);
pcie_fini_cfghdl(dip);
} else if ((pdptr = ddi_get_parent_data(dip)) != NULL) {
kmem_free(pdptr, (sizeof (*pdptr) + sizeof (struct intrspec)));
ddi_set_parent_data(dip, NULL);
}
ddi_set_name_addr(dip, NULL);
/*
* Strip the node to properly convert it back to prototype form
*/
ddi_remove_minor_node(dip, NULL);
impl_rem_dev_props(dip);
}
/*
* nx1394_dma_allochdl()
* Merges the ddi_dma_attr_t passed in by the target (using
* ddi_dma_alloc_handle() call) with that of the hal and passes the alloc
* handle request up the device by calling ddi_dma_allochdl().
*/
static int
nx1394_dma_allochdl(dev_info_t *dip, dev_info_t *rdip, ddi_dma_attr_t *attr,
int (*waitfnp)(caddr_t), caddr_t arg, ddi_dma_handle_t *handlep)
{
s1394_hal_t *hal;
ddi_dma_attr_t *hal_attr;
int status;
_NOTE(SCHEME_PROTECTS_DATA("unique (per thread)", ddi_dma_attr_t))
TNF_PROBE_0_DEBUG(nx1394_dma_allochdl_enter, S1394_TNF_SL_NEXUS_STACK,
"");
/*
* If hal calls ddi_dma_alloc_handle, dip == rdip == hal dip.
* Unfortunately, we cannot verify this (by way of looking up for hal
* dip) here because h1394_attach() may happen much later.
*/
if (dip != rdip) {
hal = s1394_dip_to_hal(ddi_get_parent(rdip));
ASSERT(hal);
hal_attr = &hal->halinfo.dma_attr;
ASSERT(hal_attr);
ddi_dma_attr_merge(attr, hal_attr);
}
status = ddi_dma_allochdl(dip, rdip, attr, waitfnp, arg, handlep);
TNF_PROBE_1_DEBUG(nx1394_dma_allochdl_exit, S1394_TNF_SL_NEXUS_STACK,
"", tnf_int, status, status);
return (status);
}
/*
* For a given instance, load that driver and its parents
*/
static int
load_parent_drivers(dev_info_t *dip, char *path)
{
int rval = 0;
major_t major = (major_t)-1;
char *drv;
char *p;
while (dip) {
/* check for path-oriented alias */
if (path)
major = ddi_name_to_major(path);
else
major = (major_t)-1;
if (major != (major_t)-1)
drv = ddi_major_to_name(major);
else
drv = ddi_binding_name(dip);
if (load_boot_driver(drv) != 0)
rval = -1;
dip = ddi_get_parent(dip);
if (path) {
p = strrchr(path, '/');
if (p)
*p = 0;
}
}
return (rval);
}
/*
* Create a pci_pwr_chld_t structure for a given devinfo node.
*/
void
pci_pwr_create_info(pci_pwr_t *pwr_p, dev_info_t *dip)
{
pci_pwr_chld_t *p;
ASSERT(PM_CAPABLE(pwr_p));
DEBUG2(DBG_PWR, ddi_get_parent(dip), "ADDING NEW PWR_INFO %s@%s\n",
ddi_node_name(dip), ddi_get_name_addr(dip));
p = kmem_zalloc(sizeof (struct pci_pwr_chld), KM_SLEEP);
p->dip = dip;
mutex_enter(&pwr_p->pwr_mutex);
/*
* Until components are created for this device, bus
* should be at full power since power of child device
* is unknown. Increment # children requiring "full power"
*/
p->flags |= PWR_FP_HOLD;
pwr_p->pwr_fp++;
p->next = pwr_p->pwr_info;
pwr_p->pwr_info = p;
pci_pwr_change(pwr_p, pwr_p->current_lvl, pci_pwr_new_lvl(pwr_p));
mutex_exit(&pwr_p->pwr_mutex);
}
static int
sbbc_find_dip(dev_info_t *dip, void *arg)
{
char *node_name;
sbbc_find_dip_t *dip_struct = (sbbc_find_dip_t *)arg;
char status[OBP_MAXPROPNAME];
/*
* Need to find a node named "bootbus-controller" that is neither
* disabled nor failed. If a node is not ok, there will be an
* OBP status property. Therefore, we will look for a node
* without the status property.
*/
node_name = ddi_node_name(dip);
if (strcmp(node_name, "bootbus-controller") == 0 && DDI_CF2(dip) &&
(prom_getprop(ddi_get_nodeid(dip),
"status", (caddr_t)status) == -1) &&
(prom_getprop(ddi_get_nodeid(ddi_get_parent(dip)),
"status", (caddr_t)status) == -1)) {
if (dip != dip_struct->cur_dip) {
dip_struct->new_dip = (void *)dip;
return (DDI_WALK_TERMINATE);
}
}
return (DDI_WALK_CONTINUE);
}
/*
* vdds_find_node -- A common function to find a NIU nexus or NIU node.
*/
static dev_info_t *
vdds_find_node(uint64_t cookie, dev_info_t *sdip,
int (*match_func)(dev_info_t *dip, void *arg))
{
vdds_cb_arg_t arg;
dev_info_t *pdip;
int circ;
DBG1(NULL, "Called cookie=%lx\n", cookie);
arg.dip = NULL;
arg.cookie = cookie;
if (pdip = ddi_get_parent(sdip)) {
ndi_devi_enter(pdip, &circ);
}
ddi_walk_devs(sdip, match_func, (void *)&arg);
if (pdip != NULL) {
ndi_devi_exit(pdip, circ);
}
DBG1(NULL, "Returning dip=0x%p", arg.dip);
return (arg.dip);
}
/*
* Recursive ascent
*
* This now only does half the job. It finds the node, then the caller
* has to search the node for the binding name
*/
static in_node_t *
in_devwalk(dev_info_t *dip, in_node_t **ap, char *addr)
{
in_node_t *np;
char *name;
ASSERT(dip);
ASSERT(e_ddi_inst_state.ins_busy);
if (dip == ddi_root_node()) {
*ap = NULL;
return (e_ddi_inst_state.ins_root);
}
/*
* call up to find parent, then look through the list of kids
* for a match
*/
np = in_devwalk(ddi_get_parent(dip), ap, NULL);
if (np == NULL)
return (np);
*ap = np;
np = np->in_child;
name = ddi_node_name(dip);
if (addr == NULL)
addr = ddi_get_name_addr(dip);
while (np) {
if (in_eqstr(np->in_node_name, name) &&
in_eqstr(np->in_unit_addr, addr)) {
return (np);
}
np = np->in_sibling;
}
return (np);
}
/*
* pcmu_init_child
*
* This function is called from our control ops routine on a
* DDI_CTLOPS_INITCHILD request. It builds and sets the device's
* parent private data area.
*
* used by: pcmu_ctlops()
*
* return value: none
*/
int
pcmu_init_child(pcmu_t *pcmu_p, dev_info_t *child)
{
char name[10];
ddi_acc_handle_t config_handle;
uint8_t bcr;
uint8_t header_type;
if (name_child(child, name, 10) != DDI_SUCCESS)
return (DDI_FAILURE);
ddi_set_name_addr(child, name);
PCMU_DBG2(PCMU_DBG_PWR, ddi_get_parent(child),
"INITCHILD: config regs setup for %s@%s\n",
ddi_node_name(child), ddi_get_name_addr(child));
/*
* Map the child configuration space to for initialization.
* We assume the obp will do the following in the devices
* config space:
*
* Set the latency-timer register to values appropriate
* for the devices on the bus (based on other devices
* MIN_GNT and MAX_LAT registers.
*
* Set the fast back-to-back enable bit in the command
* register if it's supported and all devices on the bus
* have the capability.
*
*/
if (pci_config_setup(child, &config_handle) != DDI_SUCCESS) {
ddi_set_name_addr(child, NULL);
return (DDI_FAILURE);
}
/*
* Determine the configuration header type.
*/
header_type = pci_config_get8(config_handle, PCI_CONF_HEADER);
PCMU_DBG2(PCMU_DBG_INIT_CLD, pcmu_p->pcmu_dip, "%s: header_type=%x\n",
ddi_driver_name(child), header_type);
/*
* If the device has a bus control register then program it
* based on the settings in the command register.
*/
if ((header_type & PCI_HEADER_TYPE_M) == PCI_HEADER_ONE) {
bcr = pci_config_get8(config_handle, PCI_BCNF_BCNTRL);
if (pcmu_command_default & PCI_COMM_PARITY_DETECT)
bcr |= PCI_BCNF_BCNTRL_PARITY_ENABLE;
if (pcmu_command_default & PCI_COMM_SERR_ENABLE)
bcr |= PCI_BCNF_BCNTRL_SERR_ENABLE;
bcr |= PCI_BCNF_BCNTRL_MAST_AB_MODE;
pci_config_put8(config_handle, PCI_BCNF_BCNTRL, bcr);
}
pci_config_teardown(&config_handle);
return (DDI_SUCCESS);
}
int
get_portid_ddi(dev_info_t *dip, dev_info_t **cmpp)
{
int portid;
int i;
char dev_type[OBP_MAXPROPNAME];
int len = OBP_MAXPROPNAME;
dev_info_t *cpu_parent;
if (cmpp != NULL)
*cmpp = NULL;
if ((portid = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
DDI_PROP_DONTPASS, "portid", -1)) != -1)
return (portid);
if ((portid = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
DDI_PROP_DONTPASS, "upa-portid", -1)) != -1)
return (portid);
if (ddi_prop_op(DDI_DEV_T_ANY, dip, PROP_LEN_AND_VAL_BUF,
DDI_PROP_DONTPASS, "device_type", (caddr_t)dev_type,
&len) != 0)
return (-1);
/*
* For a virtual cpu node that is a CMP core, the "portid"
* is in the parent node.
* For a virtual cpu node that is a CMT strand, the "portid" is
* in its grandparent node.
* So we iterate up as far as 2 levels to get the "portid".
*/
if (strcmp(dev_type, "cpu") == 0) {
cpu_parent = dip = ddi_get_parent(dip);
for (i = 0; dip != NULL && i < 2; i++) {
if ((portid = ddi_prop_get_int(DDI_DEV_T_ANY, dip,
DDI_PROP_DONTPASS, "portid", -1)) != -1) {
if (cmpp != NULL)
*cmpp = cpu_parent;
return (portid);
}
dip = ddi_get_parent(dip);
}
}
return (-1);
}
/* Search the uwb handle with a hwarc/hwahc dip */
uwb_dev_handle_t
uwba_dev_search(dev_info_t *dip)
{
mutex_enter(&uwba_mutex);
uwba_dev_t *uwba_dev = list_head(&uwba_dev_list);
while (uwba_dev != NULL) {
if (ddi_get_parent(uwba_dev->dip) == ddi_get_parent(dip)) {
goto done;
}
uwba_dev = list_next(&uwba_dev_list, uwba_dev);
}
done:
mutex_exit(&uwba_mutex);
return (uwb_dev_handle_t)(uwba_dev);
}
/* ARGSUSED */
void
i_ddi_remove_intrspec(dev_info_t *dip, dev_info_t *rdip,
ddi_intrspec_t intrspec, ddi_iblock_cookie_t iblock_cookie)
{
dev_info_t *pdip = ddi_get_parent(dip);
cmn_err(CE_WARN, "Failed to process interrupt "
"for %s%d due to down-rev nexus driver %s%d",
ddi_driver_name(rdip), ddi_get_instance(rdip),
ddi_driver_name(pdip), ddi_get_instance(pdip));
}
/*
* Get the parent dip.
*/
static dev_info_t *
get_parent(dev_info_t *dip, struct parinfo *info)
{
dev_info_t *pdip;
pdip = ddi_get_parent(dip);
ndi_hold_devi(pdip);
info->dip = dip;
info->pdip = pdip;
return (pdip);
}
/* ARGSUSED */
ddi_intrspec_t
i_ddi_get_intrspec(dev_info_t *dip, dev_info_t *rdip, uint_t inumber)
{
dev_info_t *pdip = ddi_get_parent(dip);
cmn_err(CE_WARN, "Failed to process interrupt "
"for %s%d due to down-rev nexus driver %s%d",
ddi_driver_name(rdip), ddi_get_instance(rdip),
ddi_driver_name(pdip), ddi_get_instance(pdip));
return (NULL);
}
/* ARGSUSED */
int
i_ddi_intr_ctlops(dev_info_t *dip, dev_info_t *rdip, ddi_intr_ctlop_t op,
void *arg, void *val)
{
dev_info_t *pdip = ddi_get_parent(dip);
cmn_err(CE_WARN, "Failed to process interrupt "
"for %s%d due to down-rev nexus driver %s%d",
ddi_driver_name(rdip), ddi_get_instance(rdip),
ddi_driver_name(pdip), ddi_get_instance(pdip));
return (DDI_ENOTSUP);
}
int
pcmu_uninit_child(pcmu_t *pcmu_p, dev_info_t *child)
{
PCMU_DBG2(PCMU_DBG_CTLOPS, pcmu_p->pcmu_dip,
"DDI_CTLOPS_UNINITCHILD: arg=%s%d\n",
ddi_driver_name(child), ddi_get_instance(child));
ddi_set_name_addr(child, NULL);
ddi_remove_minor_node(child, NULL);
impl_rem_dev_props(child);
PCMU_DBG0(PCMU_DBG_PWR, ddi_get_parent(child), "\n\n");
return (DDI_SUCCESS);
}
static void
i_detach_ctlop(dev_info_t *devi, ddi_detach_cmd_t cmd, ddi_pre_post_t w,
int ret)
{
int error;
struct detachspec ds;
dev_info_t *pdip = ddi_get_parent(devi);
ds.cmd = cmd;
ds.when = w;
ds.pdip = pdip;
ds.result = ret;
(void) ddi_ctlops(devi, devi, DDI_CTLOPS_DETACH, &ds, &error);
}
static void
i_attach_ctlop(dev_info_t *devi, ddi_attach_cmd_t cmd, ddi_pre_post_t w,
int ret)
{
int error;
struct attachspec as;
dev_info_t *pdip = ddi_get_parent(devi);
as.cmd = cmd;
as.when = w;
as.pdip = pdip;
as.result = ret;
(void) ddi_ctlops(devi, devi, DDI_CTLOPS_ATTACH, &as, &error);
}
/* ARGSUSED */
int
i_ddi_add_intrspec(dev_info_t *dip, dev_info_t *rdip, ddi_intrspec_t intrspec,
ddi_iblock_cookie_t *iblock_cookiep,
ddi_idevice_cookie_t *idevice_cookiep,
uint_t (*int_handler)(caddr_t int_handler_arg),
caddr_t int_handler_arg, int kind)
{
dev_info_t *pdip = ddi_get_parent(dip);
cmn_err(CE_WARN, "Failed to process interrupt "
"for %s%d due to down-rev nexus driver %s%d",
ddi_driver_name(rdip), ddi_get_instance(rdip),
ddi_driver_name(pdip), ddi_get_instance(pdip));
return (DDI_ENOTSUP);
}
static struct ra_dip_type *
find_dip_map_resources(dev_info_t *dip, char *type,
struct ra_dip_type ***backdip, struct ra_type_map ***backtype,
uint32_t flag)
{
struct ra_type_map **prevmap;
struct ra_dip_type *dipmap, **prevdip;
ASSERT(mutex_owned(&ra_lock));
prevdip = NULL;
dipmap = NULL;
prevmap = &ra_map_list_head;
while (*prevmap) {
if (strcmp((*prevmap)->type, type) == 0)
break;
prevmap = &(*prevmap)->ra_next;
}
if (*prevmap) {
for (; dip != NULL; dip = ddi_get_parent(dip)) {
prevdip = &(*prevmap)->ra_dip_list;
dipmap = *prevdip;
while (dipmap) {
if (dipmap->ra_dip == dip)
break;
prevdip = &dipmap->ra_next;
dipmap = dipmap->ra_next;
}
if (dipmap != NULL) {
/* found it */
break;
}
if (!(flag & NDI_RA_PASS)) {
break;
}
}
}
*backtype = (*prevmap == NULL) ? NULL: prevmap;
*backdip = (dipmap == NULL) ? NULL: prevdip;
return (dipmap);
}
/*
* cpunex_bus_ctl()
* This routine implements nexus bus ctl operations. Of importance are
* DDI_CTLOPS_REPORTDEV, DDI_CTLOPS_INITCHILD, DDI_CTLOPS_UNINITCHILD
* and DDI_CTLOPS_POWER. For DDI_CTLOPS_INITCHILD, it tries to lookup
* reg property on the child node and builds and sets the name.
*/
static int
cpunex_bus_ctl(dev_info_t *dip, dev_info_t *rdip, ddi_ctl_enum_t op, void *arg,
void *result)
{
switch (op) {
case DDI_CTLOPS_REPORTDEV: {
dev_info_t *pdip = ddi_get_parent(rdip);
cmn_err(CE_CONT, "?%s%d at %s%d",
ddi_node_name(rdip), ddi_get_instance(rdip),
ddi_node_name(pdip), ddi_get_instance(pdip));
return (DDI_SUCCESS);
}
case DDI_CTLOPS_INITCHILD: {
dev_info_t *cdip = (dev_info_t *)arg;
int i;
char caddr[MAXNAMELEN];
i = ddi_prop_get_int(DDI_DEV_T_ANY, cdip,
DDI_PROP_DONTPASS, "reg", -1);
if (i == -1) {
cmn_err(CE_NOTE, "!%s(%d): \"reg\" property "
"not found", ddi_node_name(cdip),
ddi_get_instance(cdip));
return (DDI_NOT_WELL_FORMED);
}
(void) sprintf(caddr, "%d", i);
ddi_set_name_addr(cdip, caddr);
return (DDI_SUCCESS);
}
case DDI_CTLOPS_UNINITCHILD: {
ddi_prop_remove_all((dev_info_t *)arg);
ddi_set_name_addr((dev_info_t *)arg, NULL);
return (DDI_SUCCESS);
}
default: {
return (ddi_ctlops(dip, rdip, op, arg, result));
}
}
}
/*
* Look first for an ACPI PCI bus node matching busid, then for a _PRT on the
* parent node; then drop into the bridge-chasing code (which will also
* look for _PRTs on the way up the tree of bridges)
*
* Stores polarity and sensitivity in the structure pointed to by
* intr_flagp, and irqno in the value pointed to by pci_irqp. *
* Returns:
* ACPI_PSM_SUCCESS on success.
* ACPI_PSM_PARTIAL to indicate need to configure the interrupt
* link device.
* ACPI_PSM_FAILURE if an error prevented the system from
* obtaining irq information for dip.
*/
int
acpi_translate_pci_irq(dev_info_t *dip, int ipin, int *pci_irqp,
iflag_t *intr_flagp, acpi_psm_lnk_t *acpipsmlnkp)
{
ACPI_HANDLE pciobj;
int status = AE_ERROR;
dev_info_t *curdip, *parentdip;
int curpin, curbus, curdev;
curpin = ipin;
curdip = dip;
while (curdip != ddi_root_node()) {
parentdip = ddi_get_parent(curdip);
ASSERT(parentdip != NULL);
if (get_bdf(curdip, &curbus, &curdev, NULL) != 0)
break;
status = acpica_get_handle(parentdip, &pciobj);
if ((status == AE_OK) && psm_node_has_prt(pciobj)) {
return (acpi_get_gsiv(curdip, pciobj, curdev, curpin,
pci_irqp, intr_flagp, acpipsmlnkp));
}
/* if we got here, we need to traverse a bridge upwards */
if (!psm_is_pci_bridge(parentdip))
break;
/*
* This is the rotating scheme that Compaq is using
* and documented in the PCI-PCI spec. Also, if the
* PCI-PCI bridge is behind another PCI-PCI bridge,
* then it needs to keep ascending until an interrupt
* entry is found or the top is reached
*/
curpin = (curdev + curpin) % PCI_INTD;
curdip = parentdip;
}
/*
* We should never, ever get here; didn't find a _PRT
*/
return (ACPI_PSM_FAILURE);
}
static void
ppb_uninitchild(dev_info_t *child)
{
ppb_devstate_t *ppb;
ppb = (ppb_devstate_t *)ddi_get_soft_state(ppb_state,
ddi_get_instance(ddi_get_parent(child)));
/*
* SG OPL FMA specific
*/
if (ppb->parent_bus == PCIE_PCIECAP_DEV_TYPE_PCIE_DEV) {
pcie_fini_dom(child);
pcie_fini_cfghdl(child);
}
ppb_removechild(child);
}
/*
* Allocate space for component state information in pci_pwr_chld_t
*/
void
pci_pwr_add_components(pci_pwr_t *pwr_p, dev_info_t *cdip, pci_pwr_chld_t *p)
{
int num_comps = PM_NUMCMPTS(cdip);
int i;
ASSERT(MUTEX_HELD(&pwr_p->pwr_mutex));
/*
* Assume the power level of a component is UNKNOWN until
* notified otherwise.
*/
if (num_comps > 0) {
p->comp_pwr =
kmem_alloc(sizeof (int) * num_comps, KM_SLEEP);
p->num_comps = num_comps;
DEBUG3(DBG_PWR, ddi_get_parent(cdip),
"ADDING %d COMPONENTS FOR %s@%s\n", num_comps,
ddi_node_name(cdip), ddi_get_name_addr(cdip));
} else {
cmn_err(CE_WARN, "%s%d device has %d components",
ddi_driver_name(cdip), ddi_get_instance(cdip),
num_comps);
return;
}
/*
* Release the fp hold that was made when the device
* was created.
*/
ASSERT((p->flags & PWR_FP_HOLD) == PWR_FP_HOLD);
p->flags &= ~PWR_FP_HOLD;
pwr_p->pwr_fp--;
for (i = 0; i < num_comps; i++) {
/*
* Initialize the component lvl so that the
* state reference counts will be updated correctly.
*/
p->comp_pwr[i] = PM_LEVEL_NOLEVEL;
pci_pwr_update_comp(pwr_p, p, i, PM_LEVEL_UNKNOWN);
}
}
/*
* nx1394_post_event()
* Called when a child node calls ddi_post_event. If the event is one of
* the events supported by us (bus reset/insert/remove, for now), builds
* a t1394_localinfo_t structure and calls ndi_event_run_callbacks(). This
* will result in all registered callbacks being invoked with
* t1394_localinfo_t as the impl_data. (see ddi_add_eventcall for callback
* arguments.) If the event is not defined by us, the request is
* propagated up the device tree by calling ndi_post_event().
*/
static int
nx1394_post_event(dev_info_t *dip, dev_info_t *rdip, ddi_eventcookie_t cookie,
void *impl_data)
{
int ret;
char *name;
s1394_hal_t *hal;
t1394_localinfo_t localinfo;
hal = s1394_dip_to_hal(dip);
ASSERT(hal);
TNF_PROBE_0_DEBUG(nx1394_post_event_enter, S1394_TNF_SL_NEXUS_STACK,
"");
name = ndi_event_cookie_to_name(hal->hal_ndi_event_hdl, cookie);
/* name is NULL if we don't generate the event */
if (name != NULL) {
mutex_enter(&hal->topology_tree_mutex);
localinfo.bus_generation = hal->generation_count;
localinfo.local_nodeID = hal->node_id;
mutex_exit(&hal->topology_tree_mutex);
impl_data = &localinfo;
ret = ndi_event_run_callbacks(hal->hal_ndi_event_hdl,
rdip, cookie, impl_data);
TNF_PROBE_4_DEBUG(nx1394_post_event_exit,
S1394_TNF_SL_NEXUS_STACK, "", tnf_opaque, parent_dip,
(void *)dip, tnf_opaque, requestor_dip, (void *)rdip,
tnf_string, event_name, name, tnf_int, request_status, ret);
return (ret);
} else {
ret = ndi_post_event(ddi_get_parent(dip), rdip, cookie,
impl_data);
TNF_PROBE_2_DEBUG(nx1394_post_event_exit,
S1394_TNF_SL_NEXUS_STACK, "", tnf_string, msg,
"Not our event", tnf_int, ret, ret);
return (ret);
}
}
/*ARGSUSED*/
static int
ppb_bus_map(dev_info_t *dip, dev_info_t *rdip, ddi_map_req_t *mp,
off_t offset, off_t len, caddr_t *vaddrp)
{
dev_info_t *pdip;
ppb_devstate_t *ppb = ddi_get_soft_state(ppb_state,
ddi_get_instance(dip));
if (strcmp(ddi_driver_name(ddi_get_parent(dip)), "npe") == 0 &&
mp->map_handlep != NULL) {
ddi_acc_impl_t *hdlp =
(ddi_acc_impl_t *)(mp->map_handlep)->ah_platform_private;
hdlp->ahi_err_mutexp = &ppb->ppb_err_mutex;
hdlp->ahi_peekpoke_mutexp = &ppb->ppb_peek_poke_mutex;
hdlp->ahi_scan_dip = dip;
hdlp->ahi_scan = ppb_peekpoke_cb;
}
pdip = (dev_info_t *)DEVI(dip)->devi_parent;
return ((DEVI(pdip)->devi_ops->devo_bus_ops->bus_map)(pdip,
rdip, mp, offset, len, vaddrp));
}
