/*

 * 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 2008 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/note.h>

#include <sys/t_lock.h>

#include <sys/cmn_err.h>

#include <sys/instance.h>

#include <sys/conf.h>

#include <sys/stat.h>

#include <sys/ddi.h>

#include <sys/hwconf.h>

#include <sys/sunddi.h>

#include <sys/sunndi.h>

#include <sys/ddi_impldefs.h>

#include <sys/ndi_impldefs.h>

#include <sys/modctl.h>

#include <sys/contract/device_impl.h>

#include <sys/dacf.h>

#include <sys/promif.h>

#include <sys/cpuvar.h>

#include <sys/pathname.h>

#include <sys/taskq.h>

#include <sys/sysevent.h>

#include <sys/sunmdi.h>

#include <sys/stream.h>

#include <sys/strsubr.h>

#include <sys/fs/snode.h>

#include <sys/fs/dv_node.h>

#include <sys/reboot.h>

#include <sys/sysmacros.h>

#include <sys/sunldi.h>

#include <sys/sunldi_impl.h>

#ifdef DEBUG

int ddidebug = DDI_AUDIT;

#else

int ddidebug = 0;

#endif

#define	MT_CONFIG_OP	0

#define	MT_UNCONFIG_OP	1

/* Multi-threaded configuration */

struct mt_config_handle {

	kmutex_t mtc_lock;

	kcondvar_t mtc_cv;

	int mtc_thr_count;

	dev_info_t *mtc_pdip;	/* parent dip for mt_config_children */

	dev_info_t **mtc_fdip;	/* "a" dip where unconfigure failed */

	major_t mtc_parmajor;	/* parent major for mt_config_driver */

	major_t mtc_major;

	int mtc_flags;

	int mtc_op;		/* config or unconfig */

	int mtc_error;		/* operation error */

	struct brevq_node **mtc_brevqp;	/* outstanding branch events queue */

#ifdef DEBUG

	int total_time;

	timestruc_t start_time;

#endif /* DEBUG */

};

struct devi_nodeid {

	pnode_t nodeid;

	dev_info_t *dip;

	struct devi_nodeid *next;

};

struct devi_nodeid_list {

	kmutex_t dno_lock;		/* Protects other fields */

	struct devi_nodeid *dno_head;	/* list of devi nodeid elements */

	struct devi_nodeid *dno_free;	/* Free list */

	uint_t dno_list_length;		/* number of dips in list */

};

/* used to keep track of branch remove events to be generated */

struct brevq_node {

	char *brn_deviname;

	struct brevq_node *brn_sibling;

	struct brevq_node *brn_child;

};

static struct devi_nodeid_list devi_nodeid_list;

static struct devi_nodeid_list *devimap = &devi_nodeid_list;

/*

 * Well known nodes which are attached first at boot time.

 */

dev_info_t *top_devinfo;		/* root of device tree */

dev_info_t *options_dip;

dev_info_t *pseudo_dip;

dev_info_t *clone_dip;

dev_info_t *scsi_vhci_dip;		/* MPXIO dip */

major_t clone_major;

/*

 * A non-global zone's /dev is derived from the device tree.

 * This generation number serves to indicate when a zone's

 * /dev may need to be updated.

 */

volatile ulong_t devtree_gen;		/* generation number */

/* block all future dev_info state changes */

static hrtime_t volatile devinfo_freeze = 0;

/* number of dev_info attaches/detaches currently in progress */

static ulong_t devinfo_attach_detach = 0;

extern kmutex_t global_vhci_lock;

/* bitset of DS_SYSAVAIL & DS_RECONFIG - no races, no lock */

static int devname_state = 0;

/*

 * The devinfo snapshot cache and related variables.

 * The only field in the di_cache structure that needs initialization

 * is the mutex (cache_lock). However, since this is an adaptive mutex

 * (MUTEX_DEFAULT) - it is automatically initialized by being allocated

 * in zeroed memory (static storage class). Therefore no explicit

 * initialization of the di_cache structure is needed.

 */

struct di_cache	di_cache = {1};

int		di_cache_debug = 0;

/* For ddvis, which needs pseudo children under PCI */

int pci_allow_pseudo_children = 0;

/* Allow path-oriented alias driver binding on driver.conf enumerated nodes */

int driver_conf_allow_path_alias = 1;

/*

 * The following switch is for service people, in case a

 * 3rd party driver depends on identify(9e) being called.

 */

int identify_9e = 0;

int mtc_off;					/* turn off mt config */

static kmem_cache_t *ddi_node_cache;		/* devinfo node cache */

static devinfo_log_header_t *devinfo_audit_log;	/* devinfo log */

static int devinfo_log_size;			/* size in pages */

static int lookup_compatible(dev_info_t *, uint_t);

static char *encode_composite_string(char **, uint_t, size_t *, uint_t);

static void link_to_driver_list(dev_info_t *);

static void unlink_from_driver_list(dev_info_t *);

static void add_to_dn_list(struct devnames *, dev_info_t *);

static void remove_from_dn_list(struct devnames *, dev_info_t *);

static dev_info_t *find_child_by_callback(dev_info_t *, char *, char *,

    int (*)(dev_info_t *, char *, int));

static dev_info_t *find_duplicate_child();

static void add_global_props(dev_info_t *);

static void remove_global_props(dev_info_t *);

static int uninit_node(dev_info_t *);

static void da_log_init(void);

static void da_log_enter(dev_info_t *);

static int walk_devs(dev_info_t *, int (*f)(dev_info_t *, void *), void *, int);

static int reset_nexus_flags(dev_info_t *, void *);

static void ddi_optimize_dtree(dev_info_t *);

static int is_leaf_node(dev_info_t *);

static struct mt_config_handle *mt_config_init(dev_info_t *, dev_info_t **,

    int, major_t, int, struct brevq_node **);

static void mt_config_children(struct mt_config_handle *);

static void mt_config_driver(struct mt_config_handle *);

static int mt_config_fini(struct mt_config_handle *);

static int devi_unconfig_common(dev_info_t *, dev_info_t **, int, major_t,

    struct brevq_node **);

static int

ndi_devi_config_obp_args(dev_info_t *parent, char *devnm,

    dev_info_t **childp, int flags);

static void i_link_vhci_node(dev_info_t *);

static void ndi_devi_exit_and_wait(dev_info_t *dip,

    int circular, clock_t end_time);

static int ndi_devi_unbind_driver(dev_info_t *dip);

static void i_ddi_check_retire(dev_info_t *dip);

/*

 * dev_info cache and node management

 */

/* initialize dev_info node cache */

void

i_ddi_node_cache_init()

{

	ASSERT(ddi_node_cache == NULL);

	ddi_node_cache = kmem_cache_create("dev_info_node_cache",

	    sizeof (struct dev_info), 0, NULL, NULL, NULL, NULL, NULL, 0);

	if (ddidebug & DDI_AUDIT)

		da_log_init();

}

/*

 * Allocating a dev_info node, callable from interrupt context with KM_NOSLEEP

 * The allocated node has a reference count of 0.

 */

dev_info_t *

i_ddi_alloc_node(dev_info_t *pdip, char *node_name, pnode_t nodeid,

    int instance, ddi_prop_t *sys_prop, int flag)

{

	struct dev_info *devi;

	struct devi_nodeid *elem;

	static char failed[] = "i_ddi_alloc_node: out of memory";

	ASSERT(node_name != NULL);

	if ((devi = kmem_cache_alloc(ddi_node_cache, flag)) == NULL) {

		cmn_err(CE_NOTE, failed);

		return (NULL);

	}

	bzero(devi, sizeof (struct dev_info));

	if (devinfo_audit_log) {

		devi->devi_audit = kmem_zalloc(sizeof (devinfo_audit_t), flag);

		if (devi->devi_audit == NULL)

			goto fail;

	}

	if ((devi->devi_node_name = i_ddi_strdup(node_name, flag)) == NULL)

		goto fail;

	/* default binding name is node name */

	devi->devi_binding_name = devi->devi_node_name;

	devi->devi_major = (major_t)-1;		/* unbound by default */

	/*

	 * Make a copy of system property

	 */

	if (sys_prop &&

	    (devi->devi_sys_prop_ptr = i_ddi_prop_list_dup(sys_prop, flag))

	    == NULL)

		goto fail;

	/*

	 * Assign devi_nodeid, devi_node_class, devi_node_attributes

	 * according to the following algorithm:

	 *

	 * nodeid arg			node class		node attributes

	 *

	 * DEVI_PSEUDO_NODEID		DDI_NC_PSEUDO		A

	 * DEVI_SID_NODEID		DDI_NC_PSEUDO		A,P

	 * other			DDI_NC_PROM		P

	 *

	 * Where A = DDI_AUTO_ASSIGNED_NODEID (auto-assign a nodeid)

	 * and	 P = DDI_PERSISTENT

	 *

	 * auto-assigned nodeids are also auto-freed.

	 */

	switch (nodeid) {

	case DEVI_SID_NODEID:

		devi->devi_node_attributes = DDI_PERSISTENT;

		if ((elem = kmem_zalloc(sizeof (*elem), flag)) == NULL)

			goto fail;

		/*FALLTHROUGH*/

	case DEVI_PSEUDO_NODEID:

		devi->devi_node_attributes |= DDI_AUTO_ASSIGNED_NODEID;

		devi->devi_node_class = DDI_NC_PSEUDO;

		if (impl_ddi_alloc_nodeid(&devi->devi_nodeid)) {

			panic("i_ddi_alloc_node: out of nodeids");

			/*NOTREACHED*/

		}

		break;

	default:

		if ((elem = kmem_zalloc(sizeof (*elem), flag)) == NULL)

			goto fail;

		/*

		 * the nodetype is 'prom', try to 'take' the nodeid now.

		 * This requires memory allocation, so check for failure.

		 */

		if (impl_ddi_take_nodeid(nodeid, flag) != 0) {

			kmem_free(elem, sizeof (*elem));

			goto fail;

		}

		devi->devi_nodeid = nodeid;

		devi->devi_node_class = DDI_NC_PROM;

		devi->devi_node_attributes = DDI_PERSISTENT;

	}

	if (ndi_dev_is_persistent_node((dev_info_t *)devi)) {

		mutex_enter(&devimap->dno_lock);

		elem->next = devimap->dno_free;

		devimap->dno_free = elem;

		mutex_exit(&devimap->dno_lock);

	}

	/*

	 * Instance is normally initialized to -1. In a few special

	 * cases, the caller may specify an instance (e.g. CPU nodes).

	 */

	devi->devi_instance = instance;

	/*

	 * set parent and bus_ctl parent

	 */

	devi->devi_parent = DEVI(pdip);

	devi->devi_bus_ctl = DEVI(pdip);

	NDI_CONFIG_DEBUG((CE_CONT,

	    "i_ddi_alloc_node: name=%s id=%d\n", node_name, devi->devi_nodeid));

	cv_init(&(devi->devi_cv), NULL, CV_DEFAULT, NULL);

	mutex_init(&(devi->devi_lock), NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&(devi->devi_pm_lock), NULL, MUTEX_DEFAULT, NULL);

	mutex_init(&(devi->devi_pm_busy_lock), NULL, MUTEX_DEFAULT, NULL);

	RIO_TRACE((CE_NOTE, "i_ddi_alloc_node: Initing contract fields: "

	    "dip=%p, name=%s", (void *)devi, node_name));

	mutex_init(&(devi->devi_ct_lock), NULL, MUTEX_DEFAULT, NULL);

	cv_init(&(devi->devi_ct_cv), NULL, CV_DEFAULT, NULL);

	devi->devi_ct_count = -1;	/* counter not in use if -1 */

	list_create(&(devi->devi_ct), sizeof (cont_device_t),

	    offsetof(cont_device_t, cond_next));

	i_ddi_set_node_state((dev_info_t *)devi, DS_PROTO);

	da_log_enter((dev_info_t *)devi);

	return ((dev_info_t *)devi);

fail:

	if (devi->devi_sys_prop_ptr)

		i_ddi_prop_list_delete(devi->devi_sys_prop_ptr);

	if (devi->devi_node_name)

		kmem_free(devi->devi_node_name, strlen(node_name) + 1);

	if (devi->devi_audit)

		kmem_free(devi->devi_audit, sizeof (devinfo_audit_t));

	kmem_cache_free(ddi_node_cache, devi);

	cmn_err(CE_NOTE, failed);

	return (NULL);

}

/*

 * free a dev_info structure.

 * NB. Not callable from interrupt since impl_ddi_free_nodeid may block.

 */

void

i_ddi_free_node(dev_info_t *dip)

{

	struct dev_info *devi = DEVI(dip);

	struct devi_nodeid *elem;

	ASSERT(devi->devi_ref == 0);

	ASSERT(devi->devi_addr == NULL);

	ASSERT(devi->devi_node_state == DS_PROTO);

	ASSERT(devi->devi_child == NULL);

	/* free devi_addr_buf allocated by ddi_set_name_addr() */

	if (devi->devi_addr_buf)

		kmem_free(devi->devi_addr_buf, 2 * MAXNAMELEN);

	if (i_ndi_dev_is_auto_assigned_node(dip))

		impl_ddi_free_nodeid(DEVI(dip)->devi_nodeid);

	if (ndi_dev_is_persistent_node(dip)) {

		mutex_enter(&devimap->dno_lock);

		ASSERT(devimap->dno_free);

		elem = devimap->dno_free;

		devimap->dno_free = elem->next;

		mutex_exit(&devimap->dno_lock);

		kmem_free(elem, sizeof (*elem));

	}

	if (DEVI(dip)->devi_compat_names)

		kmem_free(DEVI(dip)->devi_compat_names,

		    DEVI(dip)->devi_compat_length);

	if (DEVI(dip)->devi_rebinding_name)

		kmem_free(DEVI(dip)->devi_rebinding_name,

		    strlen(DEVI(dip)->devi_rebinding_name) + 1);

	ddi_prop_remove_all(dip);	/* remove driver properties */

	if (devi->devi_sys_prop_ptr)

		i_ddi_prop_list_delete(devi->devi_sys_prop_ptr);

	if (devi->devi_hw_prop_ptr)

		i_ddi_prop_list_delete(devi->devi_hw_prop_ptr);

	i_ddi_set_node_state(dip, DS_INVAL);

	da_log_enter(dip);

	if (devi->devi_audit) {

		kmem_free(devi->devi_audit, sizeof (devinfo_audit_t));

	}

	if (devi->devi_device_class)

		kmem_free(devi->devi_device_class,

		    strlen(devi->devi_device_class) + 1);

	cv_destroy(&(devi->devi_cv));

	mutex_destroy(&(devi->devi_lock));

	mutex_destroy(&(devi->devi_pm_lock));

	mutex_destroy(&(devi->devi_pm_busy_lock));

	RIO_TRACE((CE_NOTE, "i_ddi_free_node: destroying contract fields: "

	    "dip=%p", (void *)dip));

	contract_device_remove_dip(dip);

	ASSERT(devi->devi_ct_count == -1);

	ASSERT(list_is_empty(&(devi->devi_ct)));

	cv_destroy(&(devi->devi_ct_cv));

	list_destroy(&(devi->devi_ct));

	/* free this last since contract_device_remove_dip() uses it */

	mutex_destroy(&(devi->devi_ct_lock));

	RIO_TRACE((CE_NOTE, "i_ddi_free_node: destroyed all contract fields: "

	    "dip=%p, name=%s", (void *)dip, devi->devi_node_name));

	kmem_free(devi->devi_node_name, strlen(devi->devi_node_name) + 1);

	kmem_cache_free(ddi_node_cache, devi);

}

/*

 * Node state transitions

 */

/*

 * Change the node name

 */

int

ndi_devi_set_nodename(dev_info_t *dip, char *name, int flags)

{

	_NOTE(ARGUNUSED(flags))

	char *nname, *oname;

	ASSERT(dip && name);

	oname = DEVI(dip)->devi_node_name;

	if (strcmp(oname, name) == 0)

		return (DDI_SUCCESS);

	/*

	 * pcicfg_fix_ethernet requires a name change after node

	 * is linked into the tree. When pcicfg is fixed, we

	 * should only allow name change in DS_PROTO state.

	 */

	if (i_ddi_node_state(dip) >= DS_BOUND) {

		/*

		 * Don't allow name change once node is bound

		 */

		cmn_err(CE_NOTE,

		    "ndi_devi_set_nodename: node already bound dip = %p,"

		    " %s -> %s", (void *)dip, ddi_node_name(dip), name);

		return (NDI_FAILURE);

	}

	nname = i_ddi_strdup(name, KM_SLEEP);

	DEVI(dip)->devi_node_name = nname;

	i_ddi_set_binding_name(dip, nname);

	kmem_free(oname, strlen(oname) + 1);

	da_log_enter(dip);

	return (NDI_SUCCESS);

}

void

i_ddi_add_devimap(dev_info_t *dip)

{

	struct devi_nodeid *elem;

	ASSERT(dip);

	if (!ndi_dev_is_persistent_node(dip))

		return;

	ASSERT(ddi_get_parent(dip) == NULL || (DEVI_VHCI_NODE(dip)) ||

	    DEVI_BUSY_OWNED(ddi_get_parent(dip)));

	mutex_enter(&devimap->dno_lock);

	ASSERT(devimap->dno_free);

	elem = devimap->dno_free;

	devimap->dno_free = elem->next;

	elem->nodeid = ddi_get_nodeid(dip);

	elem->dip = dip;

	elem->next = devimap->dno_head;

	devimap->dno_head = elem;

	devimap->dno_list_length++;

	mutex_exit(&devimap->dno_lock);

}

static int

i_ddi_remove_devimap(dev_info_t *dip)

{

	struct devi_nodeid *prev, *elem;

	static const char *fcn = "i_ddi_remove_devimap";

	ASSERT(dip);

	if (!ndi_dev_is_persistent_node(dip))

		return (DDI_SUCCESS);

	mutex_enter(&devimap->dno_lock);

	/*