io/pciex/pci_props.c

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2024 Oxide Computer company
 */

/*
 * This file consolidates the basic devinfo properties that exist in the system
 * for PCI and PCI Express devices and attempts to ensure that there is only one
 * place to set these items. There are a bunch of different historical
 * considerations that are taken into account here.
 *
 * PCI Compatible Aliases
 * ----------------------
 *
 * The set of aliases that we put on devices is used in the 'compatible'
 * property to attach device drivers to nodes. These are ordered from more
 * specific aliases to less specific aliases. The original set of aliases that
 * was used was defined by Open Firmware for PCI and discussed in the PCI and
 * later the PCI Express bindings as part of IEEE 1275. Originally those
 * bindings consisted of aliases which we could describe as:
 *
 * pci<vendor id>,<device id>.<subsystem vendor>.<subsytem id>.<revision>
 * pci<vendor id>,<device id>.<subsystem vendor>.<subsytem id>
 * pci<subsystem vendor>,<subsytem id>
 * pci<vendor id>,<device id>.<revision>
 * pci<vendor id>,<device id>
 * pciclass,<class code><subclass><programming interface>
 * pciclass,<class code><subclass>
 *
 * When it came time to move to PCI Express, Sun had published a draft document
 * for how to adopt IEEE 1275 bindings to PCI Express. Most notably it dropped
 * the pci<subsystem vendor>.<subsytem id> entry and instead prefixed everything
 * with 'pciex' instead of 'pci'. The reason that this was dropped was because
 * of the fact that while the early days assumed that subsystem IDs were in a
 * shared namespace with device IDs, they ended up overlapping and therefore
 * have not proven to be unique. Because that ID syntax overlapped with
 * pci<vendor id>,<device id> this has led to problems where IDs are reused and
 * incorrect bindings occur. We already maintain a deny list where there are
 * known conflicts.
 *
 * To deal with the ambiguity here while trying to avoid the challenges of the
 * figuring out what IDs were meant to be subsystem IDs and which were primary
 * IDs (a non-obvious task given that some device drivers are almost exclusively
 * identified by standalone subsystem IDs -- see smrt(4D) and cpqary3(4D)), we
 * added two additional aliases for PCI (but not PCI Express) that allow drivers
 * to express what we call disambiguated IDs. These take the form:
 *
 * pci<subsystem vendor>,<subsystem id>,s
 * pci<vendor id>,<device id>,p
 *
 * Were that this was our only challenge. The next bit that we have to deal with
 * is another artifact of history. While Sun proposed the different PCIe
 * bindings in a draft, the original intent was just that the aliases would all
 * take the form of 'pciex' as above and that was it. However, the x86
 * implementation didn't actually roll with the plan. Instead, it placed the set
 * of PCI Express aliases and then followed it with the traditional PCI aliases.
 * As such, they have double the aliases. We still maintain this on x86, but do
 * not extend the double aliases to other platforms. Because these are specific
 * to the platform and not the instruction set architecture, whether this is
 * required or not is indicated by the PCI PRD compat flags interface
 * pci_prd_compat_flags().
 *
 * The last current wrinkle here is that of bridge IDs. Originally PCI bridges
 * didn't have any form of subsystem ID defined. In the PCI-PCI bridge
 * specification version 1.2, published in 2003, they eventually added an
 * optional capability to define a bridge's subsystem. This meant that for most
 * of PCI's existence this did not exist. In particular, until 2023 we did not
 * try to search for the capability and add it to a device's compatible
 * properties. Because of this lapse and having to deal with the above ID
 * disambiguation, we only add the disambiguated ,s subsystem ID for PCI. Both
 * PCI Express and PCI still have the fully qualified subsystem IDs added for
 * bridges.
 *
 * Our final set of aliases that we assign to all nodes is in the table below
 * called 'pci_alias_table'. This table has flags which control the behavior of
 * the ID generation. To summarize what a platform can control is:
 *
 *   o Whether or not both PCIe and PCI aliases are generated. This is
 *     controlled via PCI_PRD_COMPAT_PCI_NODE_NAME which also influences the
 *     node name below.
 *   o For PCI, whether or not we should generate the ambiguous subsystem ID
 *     alias. This is controlled by PCI_PRD_COMPAT_SUBSYS. We will always
 *     generate the disambiguated IDs for PCI to stick with IEEE 1275
 *     expectations across the system. PCI Express will not generate either of
 *     the standalone subsystem ID forms.
 *
 * Node Naming
 * -----------
 *
 * When we name devinfo names we generally do so in the form <type><subsystem
 * vendor id>,<subsystem id>. If there is no subsystem ID then we use
 * <type><vendor id>,<device id>. Type 1 headers do not have a subsystem ID.
 * They are instead found in an optional capability. Type 0 headers do have a
 * subsystem ID. If the subsystem vendor ID is zero, that indicates that the
 * subsystem ID is not present and we fall back to the vendor and device ID.
 *
 * x86 is again a land of exceptions. Because we never had subsystem IDs present
 * for bridges, they always use the vendor and device variant for compatibility
 * purposes. Similarly, x86 always sets the type to "pci" for compatibility.
 * Other platforms will set the type to "pciex" if it is a PCI Express device or
 * "pci" otherwise.
 *
 * Traditionally, node naming was originally driven by the PROM on SPARC which
 * used IEEE 1275 Open Firmware device class names instead of just the device
 * IDs that we have settled on. On our platforms there are two exceptions to
 * this. If we find an ISA compatible system and the PCI PRD indicates that the
 * platform supports ISA, then we will override that. In addition, a subset of
 * the display class codes have historically been used to name a device node
 * "display".
 *
 * Our order for naming device nodes is:
 *
 * 1. Check for display.
 * 2. Check for ISA.
 * 3. Attempt to use the subsystem.
 * 4. Fall back to the normal vendor and device.
 *
 * Platforms can influence this in the following ways:
 *
 *   o ISA is only considered if PCI_PRD_COMPAT_ISA is set.
 *   o Bridges will not use the subsystem IDs if PCI_PRD_COMPAT_SUBSYS is set.
 *   o The node name will always start with "pci" if
 *     PCI_PRD_COMPAT_PCI_NODE_NAME is set.
 *
 * Unit Address
 * ------------
 *
 * The unit address for a PCI device has historically been its device number.
 * For multi-function devices, everything past function zero is the device
 * number followed by the function number. ARI devices technically don't have a
 * device number. If we encounter such a device, we just set the device portion
 * of the unit address to 0.
 */

#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/cmn_err.h>
#include <sys/pci.h>
#include <sys/pcie.h>
#include <sys/pci_cfgspace.h>
#include <sys/pci_props.h>
#include <sys/sysmacros.h>
#include <sys/plat/pci_prd.h>
#include <pci_strings.h>

typedef struct {
	uint8_t ppc_class;
	uint8_t ppc_subclass;
	uint8_t ppc_pi;
} pci_prop_class_t;

static boolean_t
pci_prop_class_match(const pci_prop_data_t *prop, const pci_prop_class_t *class,
    const size_t nclass, boolean_t check_pi)
{
	for (size_t i = 0; i < nclass; i++) {
		if (prop->ppd_class == class[i].ppc_class &&
		    prop->ppd_subclass == class[i].ppc_subclass &&
		    (!check_pi || prop->ppd_pi == class[i].ppc_pi)) {
			return (B_TRUE);
		}
	}

	return (B_FALSE);
}

/*
 * This is used to determine if a given set of data indicates that we have
 * encountered a VGA class code which should be given the "display" name. The
 * following tuples of class, subclass, programming interface are VGA
 * compatible:
 *
 * 0x00, 0x01, 0x00: The pre-class code VGA device
 * 0x03, 0x00, 0x00: A VGA Compatible controller
 * 0x03, 0x00, 0x01: A 8514 compatible controller
 */
static const pci_prop_class_t pci_prop_vga_classes[] = {
	{ PCI_CLASS_NONE, PCI_NONE_VGA, 0x00 },
	{ PCI_CLASS_DISPLAY, PCI_DISPLAY_VGA, PCI_DISPLAY_IF_VGA },
	{ PCI_CLASS_DISPLAY, PCI_DISPLAY_VGA, PCI_DISPLAY_IF_8514 }
};

static const pci_prop_class_t pci_prop_ioapic_classes[] = {
	{ PCI_CLASS_PERIPH, PCI_PERIPH_PIC, PCI_PERIPH_PIC_IF_IO_APIC },
	{ PCI_CLASS_PERIPH, PCI_PERIPH_PIC, PCI_PERIPH_PIC_IF_IOX_APIC },
};

static const pci_prop_class_t pci_prop_isa_classes[] = {
	{ PCI_CLASS_BRIDGE, PCI_BRIDGE_ISA, 0 }
};

static const pci_prop_class_t pci_prop_pcibridge_classes[] = {
	{ PCI_CLASS_BRIDGE, PCI_BRIDGE_PCI, 0 }
};

boolean_t
pci_prop_class_is_vga(const pci_prop_data_t *prop)
{
	return (pci_prop_class_match(prop, pci_prop_vga_classes,
	    ARRAY_SIZE(pci_prop_vga_classes), B_TRUE));
}

boolean_t
pci_prop_class_is_ioapic(const pci_prop_data_t *prop)
{
	return (pci_prop_class_match(prop, pci_prop_ioapic_classes,
	    ARRAY_SIZE(pci_prop_ioapic_classes), B_TRUE));
}

/*
 * Determine if a class indicates that it is ISA. Technically this should be
 * checking the programming interface as only PI 0x00 is defined; however, this
 * is the check that has historically been done and the PCI-SIG is unlikely to
 * define additional programming interfaces for an ISA bridge.
 */
boolean_t
pci_prop_class_is_isa(const pci_prop_data_t *prop)
{
	return (pci_prop_class_match(prop, pci_prop_isa_classes,
	    ARRAY_SIZE(pci_prop_isa_classes), B_FALSE));
}

/*
 * We don't check the programming class here because callers don't care if this
 * is subtractive or not.
 */
boolean_t
pci_prop_class_is_pcibridge(const pci_prop_data_t *prop)
{
	return (pci_prop_class_match(prop, pci_prop_pcibridge_classes,
	    ARRAY_SIZE(pci_prop_pcibridge_classes), B_FALSE));
}

static const char *
pci_prop_nodename_prefix(const pci_prop_data_t *prop,
    pci_prd_compat_flags_t flags)
{
	if ((flags & PCI_PRD_COMPAT_PCI_NODE_NAME) != 0) {
		return ("pci");
	}

	if ((prop->ppd_flags & PCI_PROP_F_PCIE) != 0) {
		return ("pciex");
	} else {
		return ("pci");
	}
}

static boolean_t
pci_prop_use_subsystem(const pci_prop_data_t *prop,
    pci_prd_compat_flags_t flags)
{
	if ((flags & PCI_PRD_COMPAT_SUBSYS) != 0 &&
	    prop->ppd_header == PCI_HEADER_PPB) {
		return (B_FALSE);
	}

	return (prop->ppd_subvid != 0);
}

/*
 * Name a device node per the theory statement.
 */
pci_prop_failure_t
pci_prop_name_node(dev_info_t *dip, const pci_prop_data_t *prop)
{
	char buf[64];
	pci_prd_compat_flags_t flags = pci_prd_compat_flags();

	if (pci_prop_class_is_vga(prop)) {
		(void) snprintf(buf, sizeof (buf), "display");
	} else if (pci_prop_class_is_isa(prop) &&
	    (flags & PCI_PRD_COMPAT_ISA) != 0) {
		(void) snprintf(buf, sizeof (buf), "isa");
	} else {
		const char *prefix = pci_prop_nodename_prefix(prop, flags);

		if (pci_prop_use_subsystem(prop, flags)) {
			(void) snprintf(buf, sizeof (buf), "%s%x,%x", prefix,
			    prop->ppd_subvid, prop->ppd_subsys);
		} else {
			(void) snprintf(buf, sizeof (buf), "%s%x,%x", prefix,
			    prop->ppd_vendid, prop->ppd_devid);
		}
	}

	if (ndi_devi_set_nodename(dip, buf, 0) != NDI_SUCCESS) {
		return (PCI_PROP_E_NDI);
	}
	return (PCI_PROP_OK);
}

static uint8_t
pci_prop_get8(ddi_acc_handle_t acc, const pci_prop_data_t *prop, uint16_t off)
{
	if (acc == NULL) {
		return ((*pci_getb_func)(prop->ppd_bus, prop->ppd_dev,
		    prop->ppd_func, off));
	} else {
		return (pci_config_get8(acc, off));
	}
}

static uint16_t
pci_prop_get16(ddi_acc_handle_t acc, const pci_prop_data_t *prop, uint16_t off)
{
	if (acc == NULL) {
		return ((*pci_getw_func)(prop->ppd_bus, prop->ppd_dev,
		    prop->ppd_func, off));
	} else {
		return (pci_config_get16(acc, off));
	}
}

static uint32_t
pci_prop_get32(ddi_acc_handle_t acc, const pci_prop_data_t *prop, uint16_t off)
{
	if (acc == NULL) {
		return ((*pci_getl_func)(prop->ppd_bus, prop->ppd_dev,
		    prop->ppd_func, off));
	} else {
		return (pci_config_get32(acc, off));
	}
}

static pci_prop_failure_t
pci_prop_data_fill_pcie(ddi_acc_handle_t acc, pci_prop_data_t *prop,
    uint8_t cap_base)
{
	uint16_t pciecap;
	uint32_t slotcap;
	uint8_t vers;

	pciecap = pci_prop_get16(acc, prop, cap_base + PCIE_PCIECAP);
	vers = pciecap & PCIE_PCIECAP_VER_MASK;
	switch (vers) {
	case PCIE_PCIECAP_VER_1_0:
	case PCIE_PCIECAP_VER_2_0:
		break;
	default:
		cmn_err(CE_WARN, "found device at b/d/f 0x%x/0x%x/0x%x with "
		    "PCIe capability with unsupported capability version: 0x%x",
		    prop->ppd_bus, prop->ppd_dev, prop->ppd_func, vers);
		return (PCI_PROP_E_BAD_PCIE_CAP);
	}

	prop->ppd_flags |= PCI_PROP_F_PCIE;
	prop->ppd_pcie_type = pciecap & PCIE_PCIECAP_DEV_TYPE_MASK;

	if ((pciecap & PCIE_PCIECAP_SLOT_IMPL) == 0) {
		return (PCI_PROP_OK);
	}

	slotcap = pci_prop_get32(acc, prop, cap_base + PCIE_SLOTCAP);
	prop->ppd_slotno = PCIE_SLOTCAP_PHY_SLOT_NUM(slotcap);
	prop->ppd_flags |= PCI_PROP_F_SLOT_VALID;
	return (PCI_PROP_OK);
}

/*
 * Obtain basic information about a device and store it for future processing
 * and for other code's general usage. This may be called early in boot before
 * we feel like we should use the normal access routines or later in boot where
 * the system opts to use normal DDI accesses. We accept either and make do with
 * the rest.
 *
 * We err on the side of trying to be lenient with devices that are potentially
 * a bit odd. Not all devices in the wild actually follow the spec.
 */
pci_prop_failure_t
pci_prop_data_fill(ddi_acc_handle_t acc, uint8_t bus, uint8_t dev, uint8_t func,
    pci_prop_data_t *prop)
{
	uint8_t htype, cap_off, max_cap = PCI_CAP_MAX_PTR;
	uint16_t status;

	bzero(prop, sizeof (pci_prop_data_t));
	prop->ppd_bus = bus;
	prop->ppd_dev = dev;
	prop->ppd_func = func;

	/*
	 * To fill this out, begin with getting things that are always going to
	 * be the same between different header types. We check the validity of
	 * the vendor ID as a proxy for hardware being present.
	 */
	prop->ppd_vendid = pci_prop_get16(acc, prop, PCI_CONF_VENID);
	if (prop->ppd_vendid == PCI_EINVAL16) {
		return (PCI_PROP_E_BAD_READ);
	}
	prop->ppd_devid = pci_prop_get16(acc, prop, PCI_CONF_DEVID);
	prop->ppd_rev = pci_prop_get8(acc, prop, PCI_CONF_REVID);
	prop->ppd_class = pci_prop_get8(acc, prop, PCI_CONF_BASCLASS);
	prop->ppd_subclass = pci_prop_get8(acc, prop, PCI_CONF_SUBCLASS);
	prop->ppd_pi = pci_prop_get8(acc, prop, PCI_CONF_PROGCLASS);

	htype = pci_prop_get8(acc, prop, PCI_CONF_HEADER);
	prop->ppd_header = htype & PCI_HEADER_TYPE_M;
	if ((htype & PCI_HEADER_MULTI) != 0) {
		prop->ppd_flags |= PCI_PROP_F_MULT_FUNC;
	}


	/*
	 * Next, we get fields from the header that vary between device types or
	 * are specific to a given device type. Bridges do not have a subsystem
	 * ID at this point, instead we will fetch it out when we walk the basic
	 * capabilities.
	 */
	switch (prop->ppd_header) {
	case PCI_HEADER_ZERO:
		prop->ppd_subvid = pci_prop_get16(acc, prop,
		    PCI_CONF_SUBVENID);
		prop->ppd_subsys =  pci_prop_get16(acc, prop,
		    PCI_CONF_SUBSYSID);
		prop->ppd_mingrt = pci_prop_get8(acc, prop, PCI_CONF_MIN_G);
		prop->ppd_maxlat = pci_prop_get8(acc, prop, PCI_CONF_MAX_L);
		break;
	case PCI_HEADER_CARDBUS:
		prop->ppd_subvid = pci_prop_get16(acc, prop,
		    PCI_CBUS_SUBVENID);
		prop->ppd_subsys =  pci_prop_get16(acc, prop,
		    PCI_CBUS_SUBSYSID);
		break;
	case PCI_HEADER_PPB:
		break;
	default:
		return (PCI_PROP_E_UNKNOWN_HEADER);
	}

	/*
	 * Capture registers which are used to derive various devinfo
	 * properties and are shared between all device types.
	 */
	prop->ppd_ipin = pci_prop_get8(acc, prop, PCI_CONF_IPIN);
	prop->ppd_status = pci_prop_get16(acc, prop, PCI_CONF_STAT);

	/*
	 * If there are no capabilities, there is nothing else for us to do.
	 */
	status = pci_prop_get16(acc, prop, PCI_CONF_STAT);
	if ((status & PCI_STAT_CAP) == 0)
		return (PCI_PROP_OK);

	cap_off = pci_prop_get8(acc, prop, PCI_CONF_CAP_PTR);
	for (; max_cap > 0 && cap_off >= PCI_CAP_PTR_OFF; max_cap--) {
		uint8_t cap_addr = cap_off & PCI_CAP_PTR_MASK;
		uint8_t cap_id = pci_prop_get8(acc, prop, cap_addr);
		uint16_t subvid, subsys;
		pci_prop_failure_t ret;

		/*
		 * Look for an invalid read as a proxy for this being in illegal
		 * capability and that we're done. We don't treat this as fatal
		 * as some devices will place the caps at weird places.
		 */
		if (cap_id == PCI_EINVAL8) {
			return (PCI_PROP_OK);
		}

		switch (cap_id) {
		case PCI_CAP_ID_PCI_E:
			ret = pci_prop_data_fill_pcie(acc, prop, cap_addr);
			if (ret != PCI_PROP_OK) {
				return (ret);
			}
			break;
		case PCI_CAP_ID_P2P_SUBSYS:
			/*
			 * This is only legal in a type 1 header configuration
			 * space. In practice we've found some root complex
			 * event collectors in the wild that have both. Because
			 * this must come after the type 0 header, if this
			 * differs then we'll say something.
			 */
			subvid = pci_prop_get16(acc, prop, cap_addr +
			    PCI_SUBSYSCAP_SUBVID);
			subsys = pci_prop_get16(acc, prop, cap_addr +
			    PCI_SUBSYSCAP_SUBSYS);
			if (prop->ppd_header == PCI_HEADER_PPB) {
				prop->ppd_subvid = subvid;
				prop->ppd_subsys = subsys;
			} else if (subvid != prop->ppd_subvid ||
			    subsys != prop->ppd_subsys) {
				cmn_err(CE_WARN, "found device at b/d/f "
				    "0x%x/0x%x/0x%x with PCI subsystem "
				    "capability, but wrong header type 0x%x "
				    "and mismatched subsystems: header "
				    "0x%x/0x%x, cap: 0x%x/0x%x, using header "
				    "values", bus, dev, func, prop->ppd_header,
				    prop->ppd_subvid, prop->ppd_subsys, subvid,
				    subsys);
				break;
			}

			break;
		default:
			break;
		}

		/*
		 * Again, we check for invalid capability offsets to try to flag
		 * the case of an invalid read. If we have a zero representing
		 * the end of the list, then we'll break out up above.
		 */
		cap_off = pci_prop_get8(acc, prop, cap_addr + PCI_CAP_NEXT_PTR);
		if (cap_off == PCI_EINVAL8) {
			return (PCI_PROP_OK);
		}
	}

	return (PCI_PROP_OK);
}

/*
 * The IEEE 1275 slot-names property has a unique construction. It starts off
 * with a uint32_t which is a bitmask of names for each device. Then there is a
 * number of strings ordered based on the bitfield. The NDI doesn't have a great
 * way to represent this combination of types so we are bound by history which
 * says to use an int array. Yes, this is gross.
 *
 * For PCIe this is at least somewhat straightforward. We only ever have one
 * device so our bitfield value is always 0x1. The name we use is also always
 * "pcie<slot>".
 */
static void
pci_prop_set_pciex_slot_name(dev_info_t *dip, uint16_t slotno)
{
	uint32_t slot[32];
	size_t len;

	bzero(slot, sizeof (slot));
	slot[0] = 1;

	/*
	 * We need to calculate the number of uint32_t's that we used. We round
	 * up the number of bytes used for the name, convert that to a number of
	 * uint32_t's and then add one for the bitfield.
	 */
	len = snprintf((char *)&slot[1], sizeof (slot) - sizeof (slot[0]),
	    "pcie%u", slotno) + 1;
	len = P2ROUNDUP(len, sizeof (uint32_t));
	len /= sizeof (uint32_t);
	len += 1;
	(void) ndi_prop_update_int_array(DDI_DEV_T_NONE, dip, "slot-names",
	    (int *)slot, len);
}

pci_prop_failure_t
pci_prop_set_common_props(dev_info_t *dip, const pci_prop_data_t *prop)
{
	int class;
	char unitaddr[16];
	pci_prd_compat_flags_t flags = pci_prd_compat_flags();

	(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip, "vendor-id",
	    prop->ppd_vendid);
	(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip, "device-id",
	    prop->ppd_devid);
	(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip, "revision-id",
	    prop->ppd_rev);

	class = (prop->ppd_class << 16) | (prop->ppd_subclass << 8) |
	    prop->ppd_pi;
	(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip, "class-code", class);

	if (prop->ppd_subvid != 0) {
		(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip,
		    "subsystem-vendor-id", prop->ppd_subvid);
		(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip, "subsystem-id",
		    prop->ppd_subsys);
	}

	if (prop->ppd_func > 0) {
		(void) snprintf(unitaddr, sizeof (unitaddr), "%x,%x",
		    prop->ppd_dev, prop->ppd_func);
	} else {
		(void) snprintf(unitaddr, sizeof (unitaddr), "%x",
		    prop->ppd_dev);
	}
	(void) ndi_prop_update_string(DDI_DEV_T_NONE, dip, "unit-address",
	    unitaddr);

	/*
	 * Set properties specific to the device class (i.e. PCI or PCIe).
	 * While devsel-speed is meaningless for PCIe, this is still set
	 * anyways for it to match tradition.
	 */
	if ((prop->ppd_flags & PCI_PROP_F_PCIE) == 0) {
		if ((prop->ppd_status & PCI_STAT_FBBC) != 0) {
			(void) ndi_prop_create_boolean(DDI_DEV_T_NONE, dip,
			    "fast-back-to-back");
		}

		if ((prop->ppd_status & PCI_STAT_66MHZ) != 0) {
			(void) ndi_prop_create_boolean(DDI_DEV_T_NONE, dip,
			    "66mhz-capable");
		}

		if ((prop->ppd_status & PCI_STAT_UDF) != 0) {
			(void) ndi_prop_create_boolean(DDI_DEV_T_NONE, dip,
			    "udf-supported");
		}

		if (prop->ppd_header == PCI_HEADER_ZERO) {
			(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip,
			    "min-grant", prop->ppd_mingrt);

			(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip,
			    "max-latency", prop->ppd_maxlat);
		}
	} else {
		if ((prop->ppd_flags & PCI_PROP_F_SLOT_VALID) != 0) {
			(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip,
			    "physical-slot#", prop->ppd_slotno);
			if (prop->ppd_pcie_type !=
			    PCIE_PCIECAP_DEV_TYPE_PCIE2PCI) {
				pci_prop_set_pciex_slot_name(dip,
				    prop->ppd_slotno);
			}
		}
	}
	(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip, "devsel-speed",
	    (prop->ppd_status & PCI_STAT_DEVSELT) >> 9);

	/*
	 * The ipin indicates which INTx value a device should have. Zero
	 * indicates no INTx has been assigned.
	 */
	if (prop->ppd_ipin != 0) {
		(void) ndi_prop_update_int(DDI_DEV_T_NONE, dip, "interrupts",
		    prop->ppd_ipin);
	}

	/*
	 * VGA class devices have required specific device_type and related
	 * properties to be set. The same is true of ISA. Parent bridges and the
	 * synthetic nexus nodes that represent root complexes ala npe, pci,
	 * pcieb, etc. set the device type to either "pci" or "pciex", but that
	 * is not done universally at this time. We should consider that for the
	 * future.
	 */
	if (pci_prop_class_is_vga(prop)) {
		(void) ndi_prop_update_string(DDI_DEV_T_NONE, dip,
		    "device_type", "display");
	} else if (pci_prop_class_is_isa(prop) &&
	    (flags & PCI_PRD_COMPAT_ISA) != 0) {
		(void) ndi_prop_update_string(DDI_DEV_T_NONE, dip,
		    "device_type", "isa");
	}

	/*
	 * Go through and add the model property. This utilizes the common PCI
	 * class codes. Traditionally a PCIe->PCI bridge was treated specially
	 * and given a unique label because of the fact it was crossing between
	 * the protocols (though the opposite wasn't true for PCI->PCIe
	 * bridges).
	 *
	 * The other traditional gotcha here is that any device whose class and
	 * subclass indicated it was an IDE controller got that name.
	 */
	if ((prop->ppd_flags & PCI_PROP_F_PCIE) != 0 &&
	    prop->ppd_pcie_type == PCIE_PCIECAP_DEV_TYPE_PCIE2PCI) {
		(void) ndi_prop_update_string(DDI_DEV_T_NONE, dip, "model",
		    (char *)"PCIe-PCI bridge");
	} else if (prop->ppd_class == PCI_CLASS_MASS &&
	    prop->ppd_subclass == PCI_MASS_IDE) {
		(void) ndi_prop_update_string(DDI_DEV_T_NONE, dip, "model",
		    (char *)"IDE controller");
	} else {
		const char *desc = NULL;

		for (int i = 0; i < class_pci_items; i++) {
			if (prop->ppd_class == class_pci[i].base_class &&
			    prop->ppd_subclass == class_pci[i].sub_class &&
			    prop->ppd_pi == class_pci[i].prog_class) {
				desc = class_pci[i].actual_desc;
				break;
			}
		}

		if (desc == NULL) {
			/*
			 * Yes, we're not dealing with PNP strictly any more,
			 * but this is the string we've traditionally used.
			 */
			desc = "Unknown class of pci/pnpbios device";
		}

		(void) ndi_prop_update_string(DDI_DEV_T_NONE, dip, "model",
		    (char *)desc);
	}

	return (PCI_PROP_OK);
}


/*
 * This enumeration encodes the different possible forms of the alias
 * properties. In these definitions, the following groups of letters have
 * different means:
 *
 * "VD": Vendor ID,Device ID (1234,5678)
 * "SVSI": Subsystem Vendor ID, Subsystem ID
 * "R": Revision
 * "S": The string ,s to represent the disambiguated PCI subsystem alias
 * "P": The string ,p to represent the disambiguated PCI primary alias
 * "CSPI": Class, subclass, and Programming Interface
 * "CS": Class, subclass
 */
typedef enum {
	PCI_ALIAS_VD_SVSI_R,
	PCI_ALIAS_VD_SVSI,
	PCI_ALIAS_SVSI_S,
	PCI_ALIAS_SVSI,
	PCI_ALIAS_VD_R,
	PCI_ALIAS_VD_P,
	PCI_ALIAS_VD,
	PCI_ALIAS_CSPI,
	PCI_ALIAS_CS,
	PCI_ALIAS_MAX
} pci_alias_t;

/*
 * The upper bound on aliases is if everything is used once for PCIe and then
 * again for PCI. This is more than should be used.
 */
#define	PCI_MAX_ALIASES	(2 * PCI_ALIAS_MAX)

typedef enum {
	/*
	 * This flag indicates that a given alias should only be used for PCI
	 * devices.
	 */
	PCI_ALIAS_F_PCI_ONLY		= 1 << 0,
	/*
	 * This flag indicates that this value should not be used for any device
	 * with a type 1 header, aka PCI-PCI bridges.
	 */
	PCI_ALIAS_F_SKIP_BRIDGE		= 1 << 1,
	/*
	 * This flag indicates that we should create subsystem compatibility
	 * IDs. We only expect this to be done on x86 (and SPARC historically).
	 */
	PCI_ALIAS_F_COMPAT		= 1 << 2,
	/*
	 * This flag indicates that we need to check whether we've banned the
	 * subsystem ID due to duplication. This is still something we do even
	 * when we don't have PCI_ALIAS_F_COMPAT set for the disambiguated
	 * subsystem ID.
	 */
	PCI_ALIAS_F_CHECK_SUBSYS	= 1 << 3
} pci_alias_flags_t;

typedef struct {
	pci_alias_t pad_type;
	pci_alias_flags_t pad_flags;
} pci_alias_data_t;

static const pci_alias_data_t pci_alias_table[] = {
	{ PCI_ALIAS_VD_SVSI_R, 0 },
	{ PCI_ALIAS_VD_SVSI, 0 },
	{ PCI_ALIAS_SVSI_S, PCI_ALIAS_F_PCI_ONLY | PCI_ALIAS_F_CHECK_SUBSYS },
	{ PCI_ALIAS_SVSI, PCI_ALIAS_F_PCI_ONLY | PCI_ALIAS_F_SKIP_BRIDGE |
	    PCI_ALIAS_F_COMPAT | PCI_ALIAS_F_CHECK_SUBSYS },
	{ PCI_ALIAS_VD_R, 0 },
	{ PCI_ALIAS_VD_P, PCI_ALIAS_F_PCI_ONLY },
	{ PCI_ALIAS_VD, 0 },
	{ PCI_ALIAS_CSPI, 0 },
	{ PCI_ALIAS_CS, 0 },
};

/*
 * Our big theory statement talks about cases where we already know that PCI IDs
 * have had overlap with subsystems and them not being appropriate. The
 * following table describes how to match
 */
typedef enum {
	PCI_PROP_NSM_VID_CLASS,
	PCI_PROP_NSM_SUBSYS
} pci_prop_no_subsys_match_t;

typedef boolean_t (*pci_prop_no_subsys_class_f)(const pci_prop_data_t *);
typedef struct pci_prop_no_subsys {
	pci_prop_no_subsys_match_t	ppnsm_type;
	uint16_t			ppnsm_vid;
	uint16_t			ppnsm_did;
	uint16_t			ppnsm_subvid;
	uint16_t			ppnsm_subsys;
	pci_prop_no_subsys_class_f	ppnsm_class;
} pci_prop_no_subsys_t;

static const pci_prop_no_subsys_t pci_prop_no_subsys[] = {
	/*
	 * We've historically blocked nVidia subsystems because of subsystem
	 * reuse.
	 */
	{ .ppnsm_type = PCI_PROP_NSM_VID_CLASS, .ppnsm_vid = 0x10de,
	    .ppnsm_class = pci_prop_class_is_vga },
	/*
	 * 8086,166 is the Ivy Bridge built-in graphics controller on some
	 * models. Unfortunately 8086,2044 is the Skylake Server processor
	 * memory channel device. The Ivy Bridge device uses the Skylake
	 * ID as its sub-device ID. The GPU is not a memory controller DIMM
	 * channel.
	 */
	{ .ppnsm_type = PCI_PROP_NSM_SUBSYS, .ppnsm_vid = 0x8086,
	    .ppnsm_did = 0x166, .ppnsm_subvid = 0x8086, .ppnsm_subsys = 0x2044 }
};

static boolean_t
pci_prop_skip_subsys(const pci_prop_data_t *prop)
{
	for (size_t i = 0; i < ARRAY_SIZE(pci_prop_no_subsys); i++) {
		const pci_prop_no_subsys_t *p = &pci_prop_no_subsys[i];
		switch (p->ppnsm_type) {
		case PCI_PROP_NSM_VID_CLASS:
			if (prop->ppd_vendid == p->ppnsm_vid &&
			    p->ppnsm_class(prop)) {
				return (B_TRUE);
			}
			break;
		case PCI_PROP_NSM_SUBSYS:
			if (prop->ppd_vendid == p->ppnsm_vid &&
			    prop->ppd_devid == p->ppnsm_did &&
			    prop->ppd_subvid == p->ppnsm_subvid &&
			    prop->ppd_subsys == p->ppnsm_subsys) {
				return (B_TRUE);
			}
			break;
		}
	}
	return (B_FALSE);
}

static void
pci_prop_alias_pass(const pci_prop_data_t *prop, char **alias, uint_t *nalias,
    pci_prd_compat_flags_t compat, boolean_t force_pci)
{
	boolean_t is_pci = force_pci ||
	    (prop->ppd_flags & PCI_PROP_F_PCIE) == 0;
	const char *prefix = is_pci ? "pci" : "pciex";
	boolean_t subsys_valid = prop->ppd_subvid != 0;

	for (size_t i = 0; i < ARRAY_SIZE(pci_alias_table); i++) {
		const pci_alias_data_t *a = &pci_alias_table[i];

		if ((a->pad_flags & PCI_ALIAS_F_PCI_ONLY) != 0 && !is_pci) {
			continue;
		}

		if ((a->pad_flags & PCI_ALIAS_F_SKIP_BRIDGE) != 0 &&
		    prop->ppd_header == PCI_HEADER_PPB) {
			continue;
		}

		if ((a->pad_flags & PCI_ALIAS_F_COMPAT) != 0 &&
		    (compat & PCI_PRD_COMPAT_SUBSYS) == 0) {
			continue;
		}

		if ((a->pad_flags & PCI_ALIAS_F_CHECK_SUBSYS) != 0 &&
		    pci_prop_skip_subsys(prop)) {
			continue;
		}

		switch (a->pad_type) {
		case PCI_ALIAS_VD_SVSI_R:
			if (!subsys_valid)
				continue;
			alias[*nalias] = kmem_asprintf("%s%x,%x.%x.%x.%x",
			    prefix, prop->ppd_vendid, prop->ppd_devid,
			    prop->ppd_subvid, prop->ppd_subsys,
			    prop->ppd_rev);
			break;
		case PCI_ALIAS_VD_SVSI:
			if (!subsys_valid)
				continue;
			alias[*nalias] = kmem_asprintf("%s%x,%x.%x.%x", prefix,
			    prop->ppd_vendid, prop->ppd_devid,
			    prop->ppd_subvid, prop->ppd_subsys);
			break;
		case PCI_ALIAS_SVSI_S:
			if (!subsys_valid)
				continue;
			alias[*nalias] = kmem_asprintf("%s%x,%x,s", prefix,
			    prop->ppd_subvid, prop->ppd_subsys);
			break;
		case PCI_ALIAS_SVSI:
			if (!subsys_valid)
				continue;
			alias[*nalias] = kmem_asprintf("%s%x,%x", prefix,
			    prop->ppd_subvid, prop->ppd_subsys);
			break;
		case PCI_ALIAS_VD_R:
			alias[*nalias] = kmem_asprintf("%s%x,%x.%x", prefix,
			    prop->ppd_vendid, prop->ppd_devid, prop->ppd_rev);
			break;
		case PCI_ALIAS_VD_P:
			alias[*nalias] = kmem_asprintf("%s%x,%x,p", prefix,
			    prop->ppd_vendid, prop->ppd_devid);
			break;
		case PCI_ALIAS_VD:
			alias[*nalias] = kmem_asprintf("%s%x,%x", prefix,
			    prop->ppd_vendid, prop->ppd_devid);
			break;
		case PCI_ALIAS_CSPI:
			alias[*nalias] = kmem_asprintf("%sclass,%02x%02x%02x",
			    prefix, prop->ppd_class, prop->ppd_subclass,
			    prop->ppd_pi);
			break;
		case PCI_ALIAS_CS:
			alias[*nalias] = kmem_asprintf("%sclass,%02x%02x",
			    prefix, prop->ppd_class, prop->ppd_subclass);
			break;
		default:
			panic("encountered unknown alias type: 0x%x",
			    a->pad_type);
		}

		*nalias = *nalias + 1;
		ASSERT3U(*nalias, <=, PCI_MAX_ALIASES);
	}
}

/*
 * Go through the messy process of creating the compatible property. See the
 * theory statement for more info.
 */
pci_prop_failure_t
pci_prop_set_compatible(dev_info_t *dip, const pci_prop_data_t *prop)
{
	char *alias[PCI_MAX_ALIASES];
	uint_t nalias = 0;
	pci_prd_compat_flags_t compat = pci_prd_compat_flags();
	boolean_t two_sets = (compat & PCI_PRD_COMPAT_PCI_NODE_NAME) != 0;

	pci_prop_alias_pass(prop, alias, &nalias, compat, B_FALSE);
	if (two_sets && (prop->ppd_flags & PCI_PROP_F_PCIE) != 0) {
		pci_prop_alias_pass(prop, alias, &nalias, compat, B_TRUE);
	}

	(void) ndi_prop_update_string_array(DDI_DEV_T_NONE, dip, "compatible",
	    alias, nalias);
	for (uint_t i = 0; i < nalias; i++) {
		strfree(alias[i]);
	}
	return (PCI_PROP_OK);
}