pciex/hotplug/pcie_hp.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 *  Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 *  Use is subject to license terms.
 */

/*
 * This file contains the common hotplug code that is used by Standard
 * PCIe and PCI HotPlug Controller code.
 *
 * NOTE: This file is compiled and delivered through misc/pcie module.
 */

#include <sys/types.h>
#include <sys/conf.h>
#include <sys/kmem.h>
#include <sys/debug.h>
#include <sys/vtrace.h>
#include <sys/autoconf.h>
#include <sys/varargs.h>
#include <sys/ddi_impldefs.h>
#include <sys/time.h>
#include <sys/note.h>
#include <sys/callb.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/sysevent.h>
#include <sys/sysevent/eventdefs.h>
#include <sys/sysevent/dr.h>
#include <sys/pci_impl.h>
#include <sys/pci_cap.h>
#include <sys/hotplug/pci/pcicfg.h>
#include <sys/hotplug/pci/pcie_hp.h>
#include <sys/hotplug/pci/pciehpc.h>
#include <sys/hotplug/pci/pcishpc.h>
#include <io/pciex/pcieb.h>

/* Local functions prototype */
static int pcie_hp_list_occupants(dev_info_t *dip, void *arg);
static int pcie_hp_register_port(dev_info_t *dip, dev_info_t *pdip,
    char *cn_name);
static int pcie_hp_register_ports_for_dev(dev_info_t *dip, int device_num);
static int pcie_hp_unregister_ports_cb(ddi_hp_cn_info_t *info, void *arg);
static int pcie_hp_get_port_state(ddi_hp_cn_info_t *info, void *arg);
static int pcie_hp_match_dev_func(dev_info_t *dip, void *hdl);
static boolean_t pcie_hp_match_dev(dev_info_t *dip, int dev_num);
static int pcie_hp_get_df_from_port_name(char *cn_name, int *dev_num,
    int *func_num);
static int pcie_hp_create_port_name_num(dev_info_t *dip,
    ddi_hp_cn_info_t *cn_info);
static int pcie_hp_check_hardware_existence(dev_info_t *dip, int dev_num,
    int func_num);

/*
 * Global functions (called by other drivers/modules)
 */

/*
 * return description text for led state
 */
char *
pcie_led_state_text(pcie_hp_led_state_t state)
{
	switch (state) {
	case PCIE_HP_LED_ON:
		return (PCIEHPC_PROP_VALUE_ON);
	case PCIE_HP_LED_OFF:
		return (PCIEHPC_PROP_VALUE_OFF);
	case PCIE_HP_LED_BLINK:
	default:
		return (PCIEHPC_PROP_VALUE_BLINK);
	}
}

/*
 * return description text for slot condition
 */
char *
pcie_slot_condition_text(ap_condition_t condition)
{
	switch (condition) {
	case AP_COND_UNKNOWN:
		return (PCIEHPC_PROP_VALUE_UNKNOWN);
	case AP_COND_OK:
		return (PCIEHPC_PROP_VALUE_OK);
	case AP_COND_FAILING:
		return (PCIEHPC_PROP_VALUE_FAILING);
	case AP_COND_FAILED:
		return (PCIEHPC_PROP_VALUE_FAILED);
	case AP_COND_UNUSABLE:
		return (PCIEHPC_PROP_VALUE_UNUSABLE);
	default:
		return (PCIEHPC_PROP_VALUE_UNKNOWN);
	}
}

/*
 * routine to copy in a nvlist from userland
 */
int
pcie_copyin_nvlist(char *packed_buf, size_t packed_sz, nvlist_t **nvlp)
{
	int		ret = DDI_SUCCESS;
	char		*packed;
	nvlist_t	*dest = NULL;

	if (packed_buf == NULL || packed_sz == 0)
		return (DDI_EINVAL);

	/* copyin packed nvlist */
	if ((packed = kmem_alloc(packed_sz, KM_SLEEP)) == NULL)
		return (DDI_ENOMEM);

	if (copyin(packed_buf, packed, packed_sz) != 0) {
		cmn_err(CE_WARN, "pcie_copyin_nvlist: copyin failed.\n");
		ret = DDI_FAILURE;
		goto copyin_cleanup;
	}

	/* unpack packed nvlist */
	if ((ret = nvlist_unpack(packed, packed_sz, &dest, KM_SLEEP)) != 0) {
		cmn_err(CE_WARN, "pcie_copyin_nvlist: nvlist_unpack "
		    "failed with err %d\n", ret);
		switch (ret) {
		case EINVAL:
		case ENOTSUP:
			ret = DDI_EINVAL;
			goto copyin_cleanup;
		case ENOMEM:
			ret = DDI_ENOMEM;
			goto copyin_cleanup;
		default:
			ret = DDI_FAILURE;
			goto copyin_cleanup;
		}
	}
	*nvlp = dest;
copyin_cleanup:
	kmem_free(packed, packed_sz);
	return (ret);
}

/*
 * routine to copy out a nvlist to userland
 */
int
pcie_copyout_nvlist(nvlist_t *nvl, char *packed_buf, size_t *buf_sz)
{
	int	err = 0;
	char	*buf = NULL;
	size_t	packed_sz;

	if (nvl == NULL || packed_buf == NULL || buf_sz == NULL)
		return (DDI_EINVAL);

	/* pack nvlist, the library will allocate memory */
	if ((err = nvlist_pack(nvl, &buf, &packed_sz, NV_ENCODE_NATIVE, 0))
	    != 0) {
		cmn_err(CE_WARN, "pcie_copyout_nvlist: nvlist_pack "
		    "failed with err %d\n", err);
		switch (err) {
		case EINVAL:
		case ENOTSUP:
			return (DDI_EINVAL);
		case ENOMEM:
			return (DDI_ENOMEM);
		default:
			return (DDI_FAILURE);
		}
	}
	if (packed_sz > *buf_sz) {
		return (DDI_EINVAL);
	}

	/* copyout packed nvlist */
	if (copyout(buf, packed_buf, packed_sz) != 0) {
		cmn_err(CE_WARN, "pcie_copyout_nvlist: copyout " "failed.\n");
		kmem_free(buf, packed_sz);
		return (DDI_FAILURE);
	}

	*buf_sz = packed_sz;
	kmem_free(buf, packed_sz);
	return (DDI_SUCCESS);
}

/*
 * init bus_hp_op entry and init hotpluggable slots & virtual ports
 */
int
pcie_hp_init(dev_info_t *dip, caddr_t arg)
{
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);
	int		ret = DDI_SUCCESS, count;
	dev_info_t	*cdip;

	if (PCIE_IS_PCIE_HOTPLUG_CAPABLE(bus_p)) {
		/* Init hotplug controller */
		ret = pciehpc_init(dip, arg);
	} else if (PCIE_IS_PCI_HOTPLUG_CAPABLE(bus_p)) {
		ret = pcishpc_init(dip);
	}

	if (ret != DDI_SUCCESS) {
		PCIE_DBG("pcie_hp_init: initialize hotplug "
		    "controller failed with %d\n", ret);
		return (ret);
	}

	ndi_devi_enter(dip, &count);

	/* Create port for the first level children */
	cdip = ddi_get_child(dip);
	while (cdip != NULL) {
		if ((ret = pcie_hp_register_port(cdip, dip, NULL))
		    != DDI_SUCCESS) {
			/* stop and cleanup */
			break;
		}
		cdip = ddi_get_next_sibling(cdip);
	}
	ndi_devi_exit(dip, count);
	if (ret != DDI_SUCCESS) {
		cmn_err(CE_WARN, "pcie_hp_init: initialize virtual "
		    "hotplug port failed with %d\n", ret);
		(void) pcie_hp_uninit(dip);

		return (ret);
	}

	return (DDI_SUCCESS);
}

/*
 * uninit the hotpluggable slots and virtual ports
 */
int
pcie_hp_uninit(dev_info_t *dip)
{
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);
	pcie_hp_unreg_port_t arg;

	/*
	 * Must set arg.rv to NDI_SUCCESS so that if there's no port
	 * under this dip, we still return success thus the bridge
	 * driver can be successfully detached.
	 *
	 * Note that during the probe PCI configurator calls
	 * ndi_devi_offline() to detach driver for a new probed bridge,
	 * so that it can reprogram the resources for the bridge,
	 * ndi_devi_offline() calls into pcieb_detach() which in turn
	 * calls into this function. In this case there are no ports
	 * created under a new probe bridge dip, as ports are only
	 * created after the configurator finishing probing, thus the
	 * ndi_hp_walk_cn() will see no ports when this is called
	 * from the PCI configurtor.
	 */
	arg.nexus_dip = dip;
	arg.connector_num = DDI_HP_CN_NUM_NONE;
	arg.rv = NDI_SUCCESS;

	/* tear down all virtual hotplug handles */
	ndi_hp_walk_cn(dip, pcie_hp_unregister_ports_cb, &arg);

	if (arg.rv != NDI_SUCCESS)
		return (DDI_FAILURE);

	if (PCIE_IS_PCIE_HOTPLUG_ENABLED(bus_p))
		(void) pciehpc_uninit(dip);
	else if (PCIE_IS_PCI_HOTPLUG_ENABLED(bus_p))
		(void) pcishpc_uninit(dip);

	return (DDI_SUCCESS);
}

/*
 * interrupt handler
 */
int
pcie_hp_intr(dev_info_t *dip)
{
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);
	int		ret = DDI_INTR_UNCLAIMED;

	if (PCIE_IS_PCIE_HOTPLUG_ENABLED(bus_p))
		ret = pciehpc_intr(dip);
	else if (PCIE_IS_PCI_HOTPLUG_ENABLED(bus_p))
		ret = pcishpc_intr(dip);

	return (ret);
}

/*
 * Probe the given PCIe/PCI Hotplug Connection (CN).
 */
/*ARGSUSED*/
int
pcie_hp_probe(pcie_hp_slot_t *slot_p)
{
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	dev_info_t	*dip = ctrl_p->hc_dip;

	/*
	 * Call the configurator to probe a given PCI hotplug
	 * Hotplug Connection (CN).
	 */
	if (pcicfg_configure(dip, slot_p->hs_device_num, PCICFG_ALL_FUNC, 0)
	    != PCICFG_SUCCESS) {
		PCIE_DBG("pcie_hp_probe() failed\n");
		return (DDI_FAILURE);
	}
	slot_p->hs_condition = AP_COND_OK;
	pcie_hp_create_occupant_props(dip, makedevice(ddi_driver_major(dip),
	    slot_p->hs_minor), slot_p->hs_device_num);

	/*
	 * Create ports for the newly probed devices.
	 * Note, this is only for the first level children because the
	 * descendants' ports will be created during bridge driver attach.
	 */
	return (pcie_hp_register_ports_for_dev(dip, slot_p->hs_device_num));
}

/*
 * Unprobe the given PCIe/PCI Hotplug Connection (CN):
 *	1. remove all child device nodes
 *	2. unregister all dependent ports
 */
/*ARGSUSED*/
int
pcie_hp_unprobe(pcie_hp_slot_t *slot_p)
{
	pcie_hp_ctrl_t	*ctrl_p = slot_p->hs_ctrl;
	dev_info_t	*dip = ctrl_p->hc_dip;
	pcie_hp_unreg_port_t arg;

	/*
	 * Call the configurator to unprobe a given PCI hotplug
	 * Hotplug Connection (CN).
	 */
	if (pcicfg_unconfigure(dip, slot_p->hs_device_num, PCICFG_ALL_FUNC, 0)
	    != PCICFG_SUCCESS) {
		PCIE_DBG("pcie_hp_unprobe() failed\n");
		return (DDI_FAILURE);
	}
	slot_p->hs_condition = AP_COND_UNKNOWN;
	pcie_hp_delete_occupant_props(dip, makedevice(ddi_driver_major(dip),
	    slot_p->hs_minor));

	/*
	 * Remove ports for the unprobed devices.
	 * Note, this is only for the first level children because the
	 * descendants' ports were already removed during bridge driver dettach.
	 */
	arg.nexus_dip = dip;
	arg.connector_num = slot_p->hs_info.cn_num;
	arg.rv = NDI_SUCCESS;
	ndi_hp_walk_cn(dip, pcie_hp_unregister_ports_cb, &arg);

	return (arg.rv == NDI_SUCCESS) ? (DDI_SUCCESS) : (DDI_FAILURE);
}

/* Read-only probe: no hardware register programming. */
int
pcie_read_only_probe(dev_info_t *dip, char *cn_name, dev_info_t **pcdip)
{
	long dev, func;
	int ret;
	char *sp;
	dev_info_t *cdip;

	*pcdip = NULL;
	/*
	 * Parse the string of a pci Port name and get the device number
	 * and function number.
	 */
	if (ddi_strtol(cn_name + 4, &sp, 10, &dev) != 0)
		return (DDI_EINVAL);
	if (ddi_strtol(sp + 1, NULL, 10, &func) != 0)
		return (DDI_EINVAL);

	ret = pcicfg_configure(dip, (int)dev, (int)func,
	    PCICFG_FLAG_READ_ONLY);
	if (ret == PCICFG_SUCCESS) {
		cdip = pcie_hp_devi_find(dip, (int)dev, (int)func);
		*pcdip = cdip;
	}
	return (ret);
}

/* Read-only unprobe: no hardware register programming. */
int
pcie_read_only_unprobe(dev_info_t *dip, char *cn_name)
{
	long dev, func;
	int ret;
	char *sp;

	/*
	 * Parse the string of a pci Port name and get the device number
	 * and function number.
	 */
	if (ddi_strtol(cn_name + 4, &sp, 10, &dev) != 0)
		return (DDI_EINVAL);
	if (ddi_strtol(sp + 1, NULL, 10, &func) != 0)
		return (DDI_EINVAL);

	ret = pcicfg_unconfigure(dip, (int)dev, (int)func,
	    PCICFG_FLAG_READ_ONLY);

	return (ret);
}

/* Control structure used to find a device in the devinfo tree */
struct pcie_hp_find_ctrl {
	uint_t		device;
	uint_t		function;
	dev_info_t	*dip;
};

/*
 * find a devinfo node with specified device and function number
 * in the device tree under 'dip'
 */
dev_info_t *
pcie_hp_devi_find(dev_info_t *dip, uint_t device, uint_t function)
{
	struct pcie_hp_find_ctrl	ctrl;
	int				count;

	ctrl.device = device;
	ctrl.function = function;
	ctrl.dip = NULL;

	ndi_devi_enter(dip, &count);
	ddi_walk_devs(ddi_get_child(dip), pcie_hp_match_dev_func,
	    (void *)&ctrl);
	ndi_devi_exit(dip, count);

	return (ctrl.dip);
}

/*
 * routine to create 'pci-occupant' property for a hotplug slot
 */
void
pcie_hp_create_occupant_props(dev_info_t *dip, dev_t dev, int pci_dev)
{
	pcie_bus_t		*bus_p = PCIE_DIP2BUS(dip);
	pcie_hp_ctrl_t		*ctrl_p = (pcie_hp_ctrl_t *)bus_p->bus_hp_ctrl;
	pcie_hp_slot_t		*slotp;
	pcie_hp_cn_cfg_t	cn_cfg;
	pcie_hp_occupant_info_t	*occupant;
	int			circular, i;

	ndi_devi_enter(dip, &circular);

	if (PCIE_IS_PCIE_HOTPLUG_ENABLED(bus_p)) {
		slotp = (ctrl_p && (pci_dev == 0)) ?
		    ctrl_p->hc_slots[pci_dev] : NULL;
	} else if (PCIE_IS_PCI_HOTPLUG_ENABLED(bus_p)) {
		if (ctrl_p) {
			int	slot_num;

			slot_num = (ctrl_p->hc_device_increases) ?
			    (pci_dev - ctrl_p->hc_device_start) :
			    (pci_dev + ctrl_p->hc_device_start);

			slotp = ctrl_p->hc_slots[slot_num];
		} else {
			slotp = NULL;
		}
	}

	if (slotp == NULL)
		return;

	occupant = kmem_alloc(sizeof (pcie_hp_occupant_info_t), KM_SLEEP);
	occupant->i = 0;

	cn_cfg.flag = B_FALSE;
	cn_cfg.rv = NDI_SUCCESS;
	cn_cfg.dip = NULL;
	cn_cfg.slotp = (void *)slotp;
	cn_cfg.cn_private = (void *)occupant;

	ddi_walk_devs(ddi_get_child(dip), pcie_hp_list_occupants,
	    (void *)&cn_cfg);

	if (occupant->i == 0) {
		/* no occupants right now, need to create stub property */
		char *c[] = { "" };
		(void) ddi_prop_update_string_array(dev, dip, "pci-occupant",
		    c, 1);
	} else {
		(void) ddi_prop_update_string_array(dev, dip, "pci-occupant",
		    occupant->id, occupant->i);
	}

	for (i = 0; i < occupant->i; i++)
		kmem_free(occupant->id[i], sizeof (char[MAXPATHLEN]));

	kmem_free(occupant, sizeof (pcie_hp_occupant_info_t));

	ndi_devi_exit(dip, circular);
}

/*
 * routine to remove 'pci-occupant' property for a hotplug slot
 */
void
pcie_hp_delete_occupant_props(dev_info_t *dip, dev_t dev)
{
	(void) ddi_prop_remove(dev, dip, "pci-occupant");
}

/*
 * general code to create a minor node, called from hotplug controller
 * drivers.
 */
int
pcie_create_minor_node(pcie_hp_ctrl_t *ctrl_p, int slot)
{
	dev_info_t		*dip = ctrl_p->hc_dip;
	pcie_hp_slot_t		*slot_p = ctrl_p->hc_slots[slot];
	ddi_hp_cn_info_t	*info_p = &slot_p->hs_info;

	if (ddi_create_minor_node(dip, info_p->cn_name,
	    S_IFCHR, slot_p->hs_minor,
	    DDI_NT_PCI_ATTACHMENT_POINT, 0) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	(void) ddi_prop_update_int(DDI_DEV_T_NONE,
	    dip, "ap-names", 1 << slot_p->hs_device_num);

	return (DDI_SUCCESS);
}

/*
 * general code to remove a minor node, called from hotplug controller
 * drivers.
 */
void
pcie_remove_minor_node(pcie_hp_ctrl_t *ctrl_p, int slot)
{
	ddi_remove_minor_node(ctrl_p->hc_dip,
	    ctrl_p->hc_slots[slot]->hs_info.cn_name);
}

/*
 * Local functions (called within this file)
 */

/*
 * Register ports for all the children with device number device_num
 */
static int
pcie_hp_register_ports_for_dev(dev_info_t *dip, int device_num)
{
	dev_info_t	*cdip;
	int		rv;

	for (cdip = ddi_get_child(dip); cdip;
	    cdip = ddi_get_next_sibling(cdip)) {
		if (pcie_hp_match_dev(cdip, device_num)) {
			/*
			 * Found the newly probed device under the
			 * current slot. Register a port for it.
			 */
			if ((rv = pcie_hp_register_port(cdip, dip, NULL))
			    != DDI_SUCCESS)
				return (rv);
		} else {
			continue;
		}
	}

	return (DDI_SUCCESS);
}

/*
 * Unregister ports of a pci bridge dip, get called from ndi_hp_walk_cn()
 *
 * If connector_num is specified, then unregister the slot's dependent ports
 * only; Otherwise, unregister all ports of a pci bridge dip.
 */
static int
pcie_hp_unregister_ports_cb(ddi_hp_cn_info_t *info, void *arg)
{
	pcie_hp_unreg_port_t *unreg_arg = (pcie_hp_unreg_port_t *)arg;
	dev_info_t *dip = unreg_arg->nexus_dip;
	int rv = NDI_SUCCESS;

	if (info->cn_type != DDI_HP_CN_TYPE_VIRTUAL_PORT) {
		unreg_arg->rv = rv;
		return (DDI_WALK_CONTINUE);
	}

	if (unreg_arg->connector_num != DDI_HP_CN_NUM_NONE) {
		/* Unregister ports for all unprobed devices under a slot. */
		if (unreg_arg->connector_num == info->cn_num_dpd_on) {

			rv = ndi_hp_unregister(dip, info->cn_name);
		}
	} else {

		/* Unregister all ports of a pci bridge dip. */
		rv = ndi_hp_unregister(dip, info->cn_name);
	}

	unreg_arg->rv = rv;
	if (rv == NDI_SUCCESS)
		return (DDI_WALK_CONTINUE);
	else
		return (DDI_WALK_TERMINATE);
}

/*
 * Find a port according to cn_name and get the port's state.
 */
static int
pcie_hp_get_port_state(ddi_hp_cn_info_t *info, void *arg)
{
	pcie_hp_port_state_t *port = (pcie_hp_port_state_t *)arg;

	if (info->cn_type != DDI_HP_CN_TYPE_VIRTUAL_PORT)
		return (DDI_WALK_CONTINUE);

	if (strcmp(info->cn_name, port->cn_name) == 0) {
		/* Matched. */
		port->cn_state = info->cn_state;
		port->rv = DDI_SUCCESS;

		return (DDI_WALK_TERMINATE);
	}

	return (DDI_WALK_CONTINUE);
}

/*
 * Find the physical slot with the given device number;
 * return the slot if found.
 */
static pcie_hp_slot_t *
pcie_find_physical_slot(dev_info_t *dip, int dev_num)
{
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);
	pcie_hp_ctrl_t	*ctrl = PCIE_GET_HP_CTRL(dip);

	if (PCIE_IS_PCIE_HOTPLUG_CAPABLE(bus_p)) {
		/* PCIe has only one slot */
		return (dev_num == 0) ? (ctrl->hc_slots[0]) : (NULL);
	} else if (PCIE_IS_PCI_HOTPLUG_CAPABLE(bus_p)) {
		for (int slot = 0; slot < ctrl->hc_num_slots_impl; slot++) {
			if (ctrl->hc_slots[slot]->hs_device_num == dev_num) {
				/* found */
				return (ctrl->hc_slots[slot]);
			}
		}
	}

	return (NULL);
}

/*
 * setup slot name/slot-number info for the port which is being registered.
 */
static int
pcie_hp_create_port_name_num(dev_info_t *dip, ddi_hp_cn_info_t *cn_info)
{
	int		ret, dev_num, func_num, name_len;
	dev_info_t	*pdip = ddi_get_parent(dip);
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(pdip);
	pcie_hp_slot_t	*slot;
	pcie_req_id_t	bdf;
	char		tmp[PCIE_HP_DEV_FUNC_NUM_STRING_LEN];

	ret = pcie_get_bdf_from_dip(dip, &bdf);
	if (ret != DDI_SUCCESS) {
		return (ret);
	}
	if (PCIE_IS_RP(bus_p) || PCIE_IS_SWD(bus_p) ||
	    PCIE_IS_PCI2PCIE(bus_p)) {
		/*
		 * It is under a PCIe device, devcie number is always 0;
		 * function number might > 8 in ARI supported case.
		 */
		dev_num = 0;
		func_num = (bdf & ((~PCI_REG_BUS_M) >> 8));
	} else {
		dev_num = (bdf & (PCI_REG_DEV_M >> 8)) >> 3;
		func_num = bdf & (PCI_REG_FUNC_M >> 8);
	}
	/*
	 * The string length of dev_num and func_num must be no longer than 4
	 * including the string end mark. (With ARI case considered, e.g.,
	 * dev_num=0x0, func_num=0xff.)
	 */
	(void) snprintf(tmp, PCIE_HP_DEV_FUNC_NUM_STRING_LEN, "%x%x",
	    dev_num, func_num);
	/*
	 * Calculate the length of cn_name.
	 * The format of pci port name is: pci.d,f
	 * d stands for dev_num, f stands for func_num. So the length of the
	 * name string can be calculated as following.
	 */
	name_len = strlen(tmp) + PCIE_HP_PORT_NAME_STRING_LEN + 1;

	cn_info->cn_name = (char *)kmem_zalloc(name_len, KM_SLEEP);
	(void) snprintf(cn_info->cn_name, name_len, "pci.%x,%x",
	    dev_num, func_num);
	cn_info->cn_num = (dev_num << 8) | func_num;
	slot = pcie_find_physical_slot(pdip, dev_num);

	cn_info->cn_num_dpd_on = slot ?
	    slot->hs_info.cn_num : DDI_HP_CN_NUM_NONE;

	return (DDI_SUCCESS);
}

/*
 * Extract device and function number from port name, whose format is
 * something like 'pci.1,0'
 */
static int
pcie_hp_get_df_from_port_name(char *cn_name, int *dev_num, int *func_num)
{
	int name_len, ret;
	long d, f;
	char *sp;

	/* some checks for the input name */
	name_len = strlen(cn_name);
	if ((name_len <= PCIE_HP_PORT_NAME_STRING_LEN) ||
	    (name_len > (PCIE_HP_PORT_NAME_STRING_LEN +
	    PCIE_HP_DEV_FUNC_NUM_STRING_LEN - 1)) ||
	    (strncmp("pci.", cn_name, 4) != 0)) {
		return (DDI_EINVAL);
	}
	ret = ddi_strtol(cn_name + 4, &sp, 10, &d);
	if (ret != DDI_SUCCESS)
		return (ret);

	if (strncmp(",", sp, 1) != 0)
		return (DDI_EINVAL);

	ret = ddi_strtol(sp + 1, NULL, 10, &f);
	if (ret != DDI_SUCCESS)
		return (ret);
	*dev_num = (int)d;
	*func_num = (int)f;

	return (ret);
}

/*
 * Check/copy cn_name and set connection numbers.
 * If it is a valid name, then setup cn_info for the newly created port.
 */
static int
pcie_hp_setup_port_name_num(dev_info_t *pdip, char *cn_name,
    ddi_hp_cn_info_t *cn_info)
{
	int dev_num, func_num, ret;
	pcie_hp_slot_t *slot;

	if ((ret = pcie_hp_get_df_from_port_name(cn_name, &dev_num, &func_num))
	    != DDI_SUCCESS)
		return (ret);

	if (pcie_hp_check_hardware_existence(pdip, dev_num, func_num) ==
	    DDI_SUCCESS) {
		cn_info->cn_state = DDI_HP_CN_STATE_PRESENT;
	} else {
		cn_info->cn_state = DDI_HP_CN_STATE_EMPTY;
	}

	cn_info->cn_name = ddi_strdup(cn_name, KM_SLEEP);
	cn_info->cn_num = (dev_num << 8) | func_num;

	slot = pcie_find_physical_slot(pdip, dev_num);
	if (slot) {
		cn_info->cn_num_dpd_on = slot->hs_info.cn_num;
	} else {
		cn_info->cn_num_dpd_on = DDI_HP_CN_NUM_NONE;
	}
	return (DDI_SUCCESS);
}

static int
ndi2ddi(int n)
{
	int ret;

	switch (n) {
	case NDI_SUCCESS:
		ret = DDI_SUCCESS;
		break;
	case NDI_NOMEM:
		ret = DDI_ENOMEM;
		break;
	case NDI_BUSY:
		ret = DDI_EBUSY;
		break;
	case NDI_EINVAL:
		ret = DDI_EINVAL;
		break;
	case NDI_ENOTSUP:
		ret = DDI_ENOTSUP;
		break;
	case NDI_FAILURE:
	default:
		ret = DDI_FAILURE;
		break;
	}
	return (ret);
}

/*
 * Common routine to create and register a new port
 *
 * Create an empty port if dip is NULL, and cn_name needs to be specified in
 * this case. Otherwise, create a port mapping to the specified dip, and cn_name
 * is not needed in this case.
 */
static int
pcie_hp_register_port(dev_info_t *dip, dev_info_t *pdip, char *cn_name)
{
	ddi_hp_cn_info_t	*cn_info;
	int			ret;

	ASSERT((dip == NULL) != (cn_name == NULL));
	cn_info = kmem_zalloc(sizeof (ddi_hp_cn_info_t), KM_SLEEP);
	if (dip != NULL)
		ret = pcie_hp_create_port_name_num(dip, cn_info);
	else
		ret = pcie_hp_setup_port_name_num(pdip, cn_name, cn_info);

	if (ret != DDI_SUCCESS) {
		kmem_free(cn_info, sizeof (ddi_hp_cn_info_t));
		return (ret);
	}

	cn_info->cn_child = dip;
	cn_info->cn_type = DDI_HP_CN_TYPE_VIRTUAL_PORT;
	cn_info->cn_type_str = DDI_HP_CN_TYPE_STR_PORT;

	ret = ndi_hp_register(pdip, cn_info);

	kmem_free(cn_info->cn_name, strlen(cn_info->cn_name) + 1);
	kmem_free(cn_info, sizeof (ddi_hp_cn_info_t));

	return (ndi2ddi(ret));
}

/* Check if there is a piece of hardware exist corresponding to the cn_name */
static int
pcie_hp_check_hardware_existence(dev_info_t *dip, int dev_num, int func_num)
{

	/*
	 * VHPTODO:
	 * According to device and function number, check if there is a hardware
	 * device exists. Currently, this function can not be reached before
	 * we enable state transition to or from "Port-Empty" or "Port-Present"
	 * states. When the pci device type project is integrated, we are going
	 * to call the pci config space access interfaces introduced by it.
	 */
	_NOTE(ARGUNUSED(dip, dev_num, func_num));

	return (DDI_SUCCESS);
}

/*
 * Dispatch hotplug commands to different hotplug controller drivers, including
 * physical and virtual hotplug operations.
 */
/* ARGSUSED */
int
pcie_hp_common_ops(dev_info_t *dip, char *cn_name, ddi_hp_op_t op,
    void *arg, void *result)
{
	pcie_bus_t	*bus_p = PCIE_DIP2BUS(dip);
	int		ret = DDI_SUCCESS;

	PCIE_DBG("pcie_hp_common_ops: dip=%p cn_name=%s op=%x arg=%p\n",
	    dip, cn_name, op, arg);

	switch (op) {
	case DDI_HPOP_CN_CREATE_PORT:
	{
		/* create an empty port */
		return (pcie_hp_register_port(NULL, dip, cn_name));
	}
	case DDI_HPOP_CN_CHANGE_STATE:
	{
		ddi_hp_cn_state_t curr_state;
		ddi_hp_cn_state_t target_state = *(ddi_hp_cn_state_t *)arg;
		pcie_hp_port_state_t state_arg;

		if (target_state < DDI_HP_CN_STATE_PORT_EMPTY) {
			/* this is for physical slot state change */
			break;
		}
		PCIE_DBG("pcie_hp_common_ops: change port state"
		    " dip=%p cn_name=%s"
		    " op=%x arg=%p\n", (void *)dip, cn_name, op, arg);

		state_arg.rv = DDI_FAILURE;
		state_arg.cn_name = cn_name;
		ndi_hp_walk_cn(dip, pcie_hp_get_port_state, &state_arg);
		if (state_arg.rv != DDI_SUCCESS) {
			/* can not find the port */
			return (DDI_EINVAL);
		}
		curr_state = state_arg.cn_state;
		/*
		 * Check if this is for changing port's state: change to/from
		 * PORT_EMPTY/PRESENT states.
		 */
		if (curr_state < target_state) {
			/* Upgrade state */
			switch (curr_state) {
			case DDI_HP_CN_STATE_PORT_EMPTY:
				if (target_state ==
				    DDI_HP_CN_STATE_PORT_PRESENT) {
					int dev_num, func_num;

					ret = pcie_hp_get_df_from_port_name(
					    cn_name, &dev_num, &func_num);
					if (ret != DDI_SUCCESS)
						goto port_state_done;

					ret = pcie_hp_check_hardware_existence(
					    dip, dev_num, func_num);
				} else if (target_state ==
				    DDI_HP_CN_STATE_OFFLINE) {
					ret = pcie_read_only_probe(dip,
					    cn_name, (dev_info_t **)result);
				} else
					ret = DDI_EINVAL;

				goto port_state_done;
			case DDI_HP_CN_STATE_PORT_PRESENT:
				if (target_state ==
				    DDI_HP_CN_STATE_OFFLINE)
					ret = pcie_read_only_probe(dip,
					    cn_name, (dev_info_t **)result);
				else
					ret = DDI_EINVAL;

				goto port_state_done;
			default:
				ASSERT("unexpected state");
			}
		} else {
			/* Downgrade state */
			switch (curr_state) {
			case DDI_HP_CN_STATE_PORT_PRESENT:
			{
				int dev_num, func_num;

				ret = pcie_hp_get_df_from_port_name(cn_name,
				    &dev_num, &func_num);
				if (ret != DDI_SUCCESS)
					goto port_state_done;

				ret = pcie_hp_check_hardware_existence(dip,
				    dev_num, func_num);

				goto port_state_done;
			}
			case DDI_HP_CN_STATE_OFFLINE:
				ret = pcie_read_only_unprobe(dip, cn_name);

				goto port_state_done;
			default:
				ASSERT("unexpected state");
			}
		}
port_state_done:
		*(ddi_hp_cn_state_t *)result = curr_state;
		return (ret);
	}
	default:
		break;
	}

	if (PCIE_IS_PCIE_HOTPLUG_CAPABLE(bus_p)) {
		/* PCIe hotplug */
		ret = pciehpc_hp_ops(dip, cn_name, op, arg, result);
	} else if (PCIE_IS_PCI_HOTPLUG_CAPABLE(bus_p)) {
		/* PCI SHPC hotplug */
		ret = pcishpc_hp_ops(dip, cn_name, op, arg, result);
	} else {
		cmn_err(CE_WARN, "pcie_hp_common_ops: op is not supported."
		    " dip=%p cn_name=%s"
		    " op=%x arg=%p\n", (void *)dip, cn_name, op, arg);
		ret = DDI_ENOTSUP;
	}

#if defined(__i386) || defined(__amd64)
	/*
	 * like in attach, since hotplugging can change error registers,
	 * we need to ensure that the proper bits are set on this port
	 * after a configure operation
	 */
	if ((ret == DDI_SUCCESS) && (op == DDI_HPOP_CN_CHANGE_STATE) &&
	    (*(ddi_hp_cn_state_t *)arg == DDI_HP_CN_STATE_ENABLED))
		pcieb_intel_error_workaround(dip);
#endif

	return (ret);
}

/*
 * pcie_hp_match_dev_func:
 * Match dip's PCI device number and function number with input ones.
 */
static int
pcie_hp_match_dev_func(dev_info_t *dip, void *hdl)
{
	struct pcie_hp_find_ctrl	*ctrl = (struct pcie_hp_find_ctrl *)hdl;
	pci_regspec_t			*pci_rp;
	int				length;
	int				pci_dev, pci_func;

	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "reg", (int **)&pci_rp, (uint_t *)&length) != DDI_PROP_SUCCESS) {
		ctrl->dip = NULL;
		return (DDI_WALK_TERMINATE);
	}

	/* get the PCI device address info */
	pci_dev = PCI_REG_DEV_G(pci_rp->pci_phys_hi);
	pci_func = PCI_REG_FUNC_G(pci_rp->pci_phys_hi);

	/*
	 * free the memory allocated by ddi_prop_lookup_int_array
	 */
	ddi_prop_free(pci_rp);

	if ((pci_dev == ctrl->device) && (pci_func == ctrl->function)) {
		/* found the match for the specified device address */
		ctrl->dip = dip;
		return (DDI_WALK_TERMINATE);
	}

	/*
	 * continue the walk to the next sibling to look for a match.
	 */
	return (DDI_WALK_PRUNECHILD);
}

/*
 * pcie_hp_match_dev:
 * Match the dip's pci device number with the input dev_num
 */
static boolean_t
pcie_hp_match_dev(dev_info_t *dip, int dev_num)
{
	pci_regspec_t			*pci_rp;
	int				length;
	int				pci_dev;

	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip, DDI_PROP_DONTPASS,
	    "reg", (int **)&pci_rp, (uint_t *)&length) != DDI_PROP_SUCCESS) {
		return (B_FALSE);
	}

	/* get the PCI device address info */
	pci_dev = PCI_REG_DEV_G(pci_rp->pci_phys_hi);

	/*
	 * free the memory allocated by ddi_prop_lookup_int_array
	 */
	ddi_prop_free(pci_rp);

	if (pci_dev == dev_num) {
		/* found the match for the specified device address */
		return (B_TRUE);
	}

	return (B_FALSE);
}

/*
 * Callback function to match with device number in order to list
 * occupants under a specific slot
 */
static int
pcie_hp_list_occupants(dev_info_t *dip, void *arg)
{
	pcie_hp_cn_cfg_t	*cn_cfg_p = (pcie_hp_cn_cfg_t *)arg;
	pcie_hp_occupant_info_t	*occupant =
	    (pcie_hp_occupant_info_t *)cn_cfg_p->cn_private;
	pcie_hp_slot_t		*slot_p =
	    (pcie_hp_slot_t *)cn_cfg_p->slotp;
	int			pci_dev;
	pci_regspec_t		*pci_rp;
	int			length;
	major_t			major;

	/*
	 * Get the PCI device number information from the devinfo
	 * node. Since the node may not have the address field
	 * setup (this is done in the DDI_INITCHILD of the parent)
	 * we look up the 'reg' property to decode that information.
	 */
	if (ddi_prop_lookup_int_array(DDI_DEV_T_ANY, dip,
	    DDI_PROP_DONTPASS, "reg", (int **)&pci_rp,
	    (uint_t *)&length) != DDI_PROP_SUCCESS) {
		cn_cfg_p->rv = DDI_FAILURE;
		cn_cfg_p->dip = dip;
		return (DDI_WALK_TERMINATE);
	}

	/* get the pci device id information */
	pci_dev = PCI_REG_DEV_G(pci_rp->pci_phys_hi);

	/*
	 * free the memory allocated by ddi_prop_lookup_int_array
	 */
	ddi_prop_free(pci_rp);

	/*
	 * Match the node for the device number of the slot.
	 */
	if (pci_dev == slot_p->hs_device_num) {

		major = ddi_driver_major(dip);

		/*
		 * If the node is not yet attached, then don't list it
		 * as an occupant. This is valid, since nothing can be
		 * consuming it until it is attached, and cfgadm will
		 * ask for the property explicitly which will cause it
		 * to be re-freshed right before checking with rcm.
		 */
		if ((major == DDI_MAJOR_T_NONE) || !i_ddi_devi_attached(dip))
			return (DDI_WALK_PRUNECHILD);

		/*
		 * If we have used all our occupants then print mesage
		 * and terminate walk.
		 */
		if (occupant->i >= PCIE_HP_MAX_OCCUPANTS) {
			cmn_err(CE_WARN,
			    "pcie (%s%d): unable to list all occupants",
			    ddi_driver_name(ddi_get_parent(dip)),
			    ddi_get_instance(ddi_get_parent(dip)));
			return (DDI_WALK_TERMINATE);
		}

		/*
		 * No need to hold the dip as ddi_walk_devs
		 * has already arranged that for us.
		 */
		occupant->id[occupant->i] =
		    kmem_alloc(sizeof (char[MAXPATHLEN]), KM_SLEEP);
		(void) ddi_pathname(dip, (char *)occupant->id[occupant->i]);
		occupant->i++;
	}

	/*
	 * continue the walk to the next sibling to look for a match
	 * or to find other nodes if this card is a multi-function card.
	 */
	return (DDI_WALK_PRUNECHILD);
}

/*
 * Generate the System Event for ESC_DR_REQ.
 * One of the consumers is pcidr, it calls to libcfgadm to perform a
 * configure or unconfigure operation to the AP.
 */
void
pcie_hp_gen_sysevent_req(char *slot_name, int hint,
    dev_info_t *self, int kmflag)
{
	sysevent_id_t	eid;
	nvlist_t	*ev_attr_list = NULL;
	char		cn_path[MAXPATHLEN];
	char		*ap_id;
	int		err, ap_id_len;

	/*
	 * Minor device name (AP) will be bus path
	 * concatenated with slot name
	 */
	(void) strcpy(cn_path, "/devices");
	(void) ddi_pathname(self, cn_path + strlen("/devices"));

	ap_id_len = strlen(cn_path) + strlen(":") +
	    strlen(slot_name) + 1;
	ap_id = kmem_zalloc(ap_id_len, kmflag);
	if (ap_id == NULL) {
		cmn_err(CE_WARN,
		    "%s%d: Failed to allocate memory for AP ID: %s:%s",
		    ddi_driver_name(self), ddi_get_instance(self),
		    cn_path, slot_name);

		return;
	}

	(void) strcpy(ap_id, cn_path);
	(void) strcat(ap_id, ":");
	(void) strcat(ap_id, slot_name);

	err = nvlist_alloc(&ev_attr_list, NV_UNIQUE_NAME_TYPE, kmflag);
	if (err != 0) {
		cmn_err(CE_WARN,
		    "%s%d: Failed to allocate memory "
		    "for event attributes%s", ddi_driver_name(self),
		    ddi_get_instance(self), ESC_DR_REQ);

		kmem_free(ap_id, ap_id_len);
		return;
	}

	switch (hint) {

	case SE_INVESTIGATE_RES:	/* fall through */
	case SE_INCOMING_RES:		/* fall through */
	case SE_OUTGOING_RES:		/* fall through */

		err = nvlist_add_string(ev_attr_list, DR_REQ_TYPE,
		    SE_REQ2STR(hint));

		if (err != 0) {
			cmn_err(CE_WARN,
			    "%s%d: Failed to add attr [%s] "
			    "for %s event", ddi_driver_name(self),
			    ddi_get_instance(self),
			    DR_REQ_TYPE, ESC_DR_REQ);

			goto done;
		}
		break;

	default:
		cmn_err(CE_WARN, "%s%d:  Unknown hint on sysevent",
		    ddi_driver_name(self), ddi_get_instance(self));

		goto done;
	}

	/*
	 * Add attachment point as attribute (common attribute)
	 */

	err = nvlist_add_string(ev_attr_list, DR_AP_ID, ap_id);

	if (err != 0) {
		cmn_err(CE_WARN, "%s%d: Failed to add attr [%s] for %s event",
		    ddi_driver_name(self), ddi_get_instance(self),
		    DR_AP_ID, EC_DR);

		goto done;
	}


	/*
	 * Log this event with sysevent framework.
	 */

	err = ddi_log_sysevent(self, DDI_VENDOR_SUNW, EC_DR,
	    ESC_DR_REQ, ev_attr_list, &eid,
	    ((kmflag == KM_SLEEP) ? DDI_SLEEP : DDI_NOSLEEP));
	if (err != 0) {
		cmn_err(CE_WARN, "%s%d: Failed to log %s event",
		    ddi_driver_name(self), ddi_get_instance(self), EC_DR);
	}

done:
	nvlist_free(ev_attr_list);
	kmem_free(ap_id, ap_id_len);
}