io/1394/s1394_hotplug.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * s1394_hotplug.c
 *    1394 Services Layer Hotplug Routines
 *    This file contains routines that walk the old and topology
 *    trees, at bus reset time, creating devinfo's for new nodes and offlining
 *    nodes that are removed.
 */

#include <sys/conf.h>
#include <sys/sysmacros.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/modctl.h>
#include <sys/sunddi.h>
#include <sys/ddi_impldefs.h>
#include <sys/types.h>
#include <sys/1394/t1394.h>
#include <sys/1394/s1394.h>
#include <sys/1394/h1394.h>
#include <sys/1394/ieee1394.h>

static void s1394_send_remove_event(s1394_hal_t *hal, dev_info_t *dip,
    t1394_localinfo_t *localinfo);
static void s1394_send_insert_event(s1394_hal_t *hal, dev_info_t *dip,
    t1394_localinfo_t *localinfo);
static dev_info_t *s1394_create_devinfo(s1394_hal_t *hal, s1394_node_t *node,
    uint32_t *unit_dir, int nunit);
static void s1394_update_unit_dir_location(s1394_hal_t *hal, dev_info_t *tdip,
    uint_t offset);

/*
 * s1394_send_remove_event()
 *    Invokes any "remove event" callback registered for dip. Passes
 *    t1394_localinfo_t as impl_data for the callback.
 */
static void
s1394_send_remove_event(s1394_hal_t *hal, dev_info_t *dip,
    t1394_localinfo_t *localinfo)
{
	char name[128];
	ddi_eventcookie_t cookie;

	(void) sprintf(name, "%s%d", ddi_driver_name(dip),
	    ddi_get_instance(dip));

	if (ndi_event_retrieve_cookie(hal->hal_ndi_event_hdl, dip,
	    DDI_DEVI_REMOVE_EVENT, &cookie, NDI_EVENT_NOPASS)
	    == NDI_SUCCESS) {
		(void) ndi_event_run_callbacks(hal->hal_ndi_event_hdl, dip,
		    cookie, localinfo);
	}
}

/*
 * s1394_send_insert_event()
 *    Invokes any "insert event" callback registered for dip. Passes
 *    t1394_localinfo_t as impl_data for the callback.
 */
static void
s1394_send_insert_event(s1394_hal_t *hal, dev_info_t *dip,
    t1394_localinfo_t *localinfo)
{
	char name[128];
	ddi_eventcookie_t cookie;

	(void) sprintf(name, "%s%d", ddi_driver_name(dip),
	    ddi_get_instance(dip));

	if (ndi_event_retrieve_cookie(hal->hal_ndi_event_hdl, dip,
	    DDI_DEVI_INSERT_EVENT, &cookie, NDI_EVENT_NOPASS) ==
	    NDI_SUCCESS)
		(void) ndi_event_run_callbacks(hal->hal_ndi_event_hdl, dip,
		    cookie, localinfo);
}

/*
 * s1394_create_devinfo()
 *    This routine creates a devinfo corresponding to the unit_dir passed in.
 *    It adds "hp-node", "reg", "compatible" properties to the devinfo
 *    (formats for "reg" and "compatible" properties are specified by 1275
 *    binding for IEEE1394). If unable to create the devinfo and/or add the
 *    the properties, returns NULL, otherwise, returns the devinfo created.
 *
 *    NOTE: All ndi_* routines are interrupt callable (and thus won't sleep).
 *    So, we don't drop topology_mutex across ndi calls.
 */
static dev_info_t *
s1394_create_devinfo(s1394_hal_t *hal, s1394_node_t *node, uint32_t *unit_dir,
    int nunit)
{
	dev_info_t *hal_dip;
	uint32_t *root_dir;
	dev_info_t *target_dip;

	int root_dir_len;
	int result, i, j, spec_id, sw_version;
	int mod_ven, mod_hw, mod_spec, mod_sw;
	int node_ven, node_hw, node_spec, node_sw;

	/*LINTED type is unused*/
	uint32_t type __unused, key, value;
	uint32_t unit_spec_id, unit_sw_version;
	uint32_t node_spec_id, node_sw_version;
	uint32_t node_vendor_id, node_hw_version;
	uint32_t module_spec_id, module_sw_version;
	uint32_t module_vendor_id, module_hw_version;

	char *fmt = "firewire%06x,%06x";

	char *buf[5], data[5][24];
	uint32_t reg[6];

	ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));

	hal_dip = hal->halinfo.dip;

	/* Allocate and init a new device node instance. */
	result = ndi_devi_alloc(hal_dip, "unit", (pnode_t)DEVI_SID_NODEID,
	    &target_dip);

	if (result != NDI_SUCCESS) {
		cmn_err(CE_NOTE, "!Unable to create devinfo"
		    " (node's GUID %08x%08x)", node->node_guid_hi,
		    node->node_guid_lo);
		return (NULL);
	}

	/* Add "hp-node" property */
	result = ndi_prop_update_int(DDI_DEV_T_NONE, target_dip, "hp-node", 0);
	if (result != NDI_SUCCESS) {
		cmn_err(CE_NOTE, "!Unable to add \"hp-node\" property"
		    " (node's GUID %08x%08x)", node->node_guid_hi,
		    node->node_guid_lo);
#if defined(DEBUG)
		cmn_err(CE_CONT, "!Error code %d", result);
#endif
		ndi_prop_remove_all(target_dip);
		(void) ndi_devi_free(target_dip);
		return (NULL);
	}

	spec_id = sw_version = mod_ven = mod_hw = mod_spec = mod_sw =
	    node_ven = node_hw = node_spec = node_sw = 0;
	unit_sw_version = node_sw_version = node_hw_version =
	    module_sw_version = module_hw_version = 0;


	root_dir = CFGROM_ROOT_DIR(node->cfgrom);
	root_dir_len = CFGROM_DIR_LEN(root_dir);

	for (i = 0; i < root_dir_len; i++) {

		CFGROM_TYPE_KEY_VALUE(root_dir[i + 1], type, key, value);
		switch (key) {

		case IEEE1212_MODULE_VENDOR_ID:
			module_vendor_id = value;
			mod_ven++;
			break;
		case IEEE1212_MODULE_HW_VERSION:
			module_hw_version = value;
			mod_hw++;
			break;
		case IEEE1212_MODULE_SPEC_ID:
			module_spec_id = value;
			mod_spec++;
			break;
		case IEEE1212_MODULE_SW_VERSION:
			module_sw_version = value;
			mod_sw++;
			break;
		case IEEE1212_NODE_VENDOR_ID:
			node_vendor_id = value;
			node_ven++;
			break;
		case IEEE1212_NODE_UNIQUE_ID: {
				uint32_t *node_unique_leaf =
				    &root_dir[i + 1] + value;
				node_vendor_id = (node_unique_leaf[1] >> 8);
				node_ven++;
			}
			break;
		case IEEE1212_NODE_HW_VERSION:
			node_hw_version = value;
			node_hw++;
			break;
		case IEEE1212_NODE_SPEC_ID:
			node_spec_id = value;
			node_spec++;
			break;
		case IEEE1212_NODE_SW_VERSION:
			node_sw_version = value;
			node_sw++;
			break;
		}

		if (mod_ven && mod_hw && mod_spec && mod_sw && node_ven &&
		    node_hw && node_spec && node_sw) {
			break;
		}
	}

	/*
	 * Search for unit spec and version
	 */
	for (i = 0; i < CFGROM_DIR_LEN(unit_dir); i++) {

		CFGROM_TYPE_KEY_VALUE(unit_dir[i + 1], type, key, value);
		if (key == IEEE1212_UNIT_SPEC_ID) {

			unit_spec_id = value;
			spec_id++;
		} else if (key == IEEE1212_UNIT_SW_VERSION) {

			unit_sw_version = value;
			sw_version++;
		}
		if (spec_id && sw_version)
			break;
	}

	/*
	 * Refer to IEEE1212 (pages 90-92) for information regarding various
	 * id's. Module_Vendor_Id is required. Node_Vendor_Id is optional and
	 * if not implemented, its assumed value is Module_Vendor_Id.
	 * Module_Spec_Id is optional and if not implemented, its assumed value
	 * is Module_Vendor_Id. Node_Spec_Id is optional, and if not
	 * implemented, its assumed value is Node_Vendor_Id. Unit_Spec_Id is
	 * optional, and if not implemented, its assumed value is
	 * Node_Vendor_Id.
	 */
	if (node_ven == 0) {
		node_vendor_id = module_vendor_id;
		node_ven++;
	}

	if (node_spec == 0) {
		node_spec_id = node_vendor_id;
		node_spec++;
	}

	if (mod_spec == 0) {
		module_spec_id = module_vendor_id;
		mod_spec++;
	}

	if (spec_id == 0) {
		unit_spec_id = node_vendor_id;
		spec_id++;
	}

	i = 0;
	if (sw_version != 0) {
		buf[i] = data[i];
		(void) sprintf(data[i++], fmt, unit_spec_id, unit_sw_version);
	}
	if (node_sw != 0) {
		buf[i] = data[i];
		(void) sprintf(data[i++], fmt, node_spec_id, node_sw_version);
	}
	if (node_hw != 0) {
		buf[i] = data[i];
		(void) sprintf(data[i++], fmt, node_vendor_id, node_hw_version);
	}
	if (mod_sw != 0) {
		buf[i] = data[i];
		(void) sprintf(data[i++], fmt, module_spec_id,
		    module_sw_version);
	}
	if (mod_hw != 0) {
		buf[i] = data[i];
		(void) sprintf(data[i++], fmt, module_vendor_id,
		    module_hw_version);
	}

	result = ndi_prop_update_string_array(DDI_DEV_T_NONE, target_dip,
	    "compatible", (char **)&buf, i);
	if (result != NDI_SUCCESS) {
		cmn_err(CE_NOTE, "!Unable to add \"compatible\" property"
		    " (node's GUID %08x%08x)", node->node_guid_hi,
		    node->node_guid_lo);
#if defined(DEBUG)
		cmn_err(CE_CONT, "!Error code %d; nelements %d", result, i);
		for (j = 0; j < i; j++) {
			cmn_err(CE_CONT, "!buf[%d]: %s", j, buf[j]);
		}
#endif
		ndi_prop_remove_all(target_dip);
		(void) ndi_devi_free(target_dip);
		return (NULL);
	}

	/* GUID,ADDR */
	reg[0] = node->node_guid_hi;
	reg[1] = node->node_guid_lo;
	s1394_cfgrom_parse_unit_dir(unit_dir, &reg[2], &reg[3], &reg[4],
	    &reg[5]);

	reg[3] = nunit;

	result = ndi_prop_update_int_array(DDI_DEV_T_NONE, target_dip, "reg",
	    (int *)reg, 6);
	if (result != NDI_SUCCESS) {
		cmn_err(CE_NOTE, "!Unable to add \"reg\" property");
#if defined(DEBUG)
		cmn_err(CE_CONT, "!Error code %d", result);
		for (j = 0; j < 6; j++) {
			cmn_err(CE_CONT, "!reg[%d]: 0x%08x", j, reg[j]);
		}
#endif
		ndi_prop_remove_all(target_dip);
		(void) ndi_devi_free(target_dip);
		return (NULL);
	}

	return (target_dip);
}

/*
 * s1394_devi_find()
 *    Searches all children of pdip for a match of name@caddr. Builds the
 *    name and address of each child node by looking up the reg property on
 *    the node and compares the built name@addr with the name@addr passed in.
 *    Returns the child dip if a match is found, otherwise, returns NULL.
 *    NOTE:
 *    This routine is decidedly non-ddi. We had to use this one since
 *    ndi_devi_find() can find only nodes that have valid addr field
 *    set and that won't happen unless the node goes through INITCHILD
 *    (at which time nx1394.c calls ddi_set_name_addr()). If, in future,
 *    the ndi_devi_find() provides a way of looking up nodes using criteria
 *    other than addr, we can get rid of this routine.
 */
/*ARGSUSED*/
dev_info_t *
s1394_devi_find(dev_info_t *pdip, char *name, char *caddr)
{
	int i, reglen;
	char addr[32];
	uint32_t *regptr;
	dev_info_t *cdip = NULL;

	ASSERT((name != NULL) && (caddr != NULL));

	/*
	 * for each child of this parent, find name and addr and match with
	 * name and caddr passed in.
	 */
	for (cdip = (dev_info_t *)DEVI(pdip)->devi_child; cdip != NULL;
	    cdip = (dev_info_t *)DEVI(cdip)->devi_sibling) {

		i = ddi_prop_lookup_int_array(DDI_DEV_T_ANY, cdip,
		    DDI_PROP_DONTPASS, "reg", (int **)&regptr,
		    (uint_t *)&reglen);

		if (i != DDI_PROP_SUCCESS)
			continue;

		/*
		 * Construct addr from the reg property (addr is of the format
		 * GGGGGGGGGGGGGGGG[,AAAAAAAAAAAA], where GGGGGGGGGGGGGGGG is
		 * the address and AAAAAAAAAAAA is the optional unit address)
		 */
		if (regptr[2] != 0 || regptr[3] != 0) {
			(void) sprintf(addr, "%08x%08x,%04x%08x", regptr[0],
			    regptr[1], regptr[2], regptr[3]);
		} else {
			(void) sprintf(addr, "%08x%08x", regptr[0], regptr[1]);
		}
		ddi_prop_free(regptr);

		if (strcmp(caddr, addr) == 0) {
			ASSERT(strcmp(ddi_node_name(cdip), name) == 0);
			break;
		}
	}

	return (cdip);
}

/*
 * s1394_update_devinfo_tree()
 *    Parses the config rom for the passed in node and creates/updates devinfo's
 *    for each unit directory found. If the devinfo corresponding to a unit
 *    already exists, any insert event callbacks registered for that devinfo
 *    are called (topology tree is unlocked and relocked around these
 *    callbacks). Returns DDI_SUCCESS if everything went fine and DDI_FAILURE
 *    if unable to reacquire the lock after callbacks (relock fails because of
 *    an intervening bus reset or if the services layer kills the bus reset
 *    thread). The node is marked as parsed before returning.
 */
int
s1394_update_devinfo_tree(s1394_hal_t *hal, s1394_node_t *node)
{
	dev_info_t *tdip;
	int j, units, d, lockfail = 0;
	s1394_target_t *target, *t;
	uint32_t hi, lo, size_hi, size_lo, type, key, value;
	uint32_t *ptr, *root_dir, dir_len;
	t1394_localinfo_t linfo;

	uint32_t *unit_dir_ptrs[32];
	dev_info_t *devinfo_ptrs[32];
	uint32_t new_devinfo = 0;	/* to keep track of new allocations */

	char caddr[32];

	ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));

	ASSERT(CFGROM_PARSED(node) == B_FALSE);
	ASSERT(node->cfgrom != NULL);

	/* scan through config rom looking for unit dirs */
	root_dir = CFGROM_ROOT_DIR(node->cfgrom);

	if (node->cfgrom_valid_size < CFGROM_DIR_LEN(root_dir))
		dir_len = node->cfgrom_valid_size;
	else
		dir_len = CFGROM_DIR_LEN(root_dir);

	CFGROM_TYPE_KEY_VALUE(root_dir[0], type, key, value);
	if (s1394_valid_dir(hal, node, key, root_dir) == B_FALSE) {
		cmn_err(CE_NOTE,
		    "!Bad root directory in config rom (node's GUID %08x%08x)",
		    node->node_guid_hi, node->node_guid_lo);

		SET_CFGROM_PARSED(node);
		CLEAR_CFGROM_GEN_CHANGED(node);	/* if set */
		CLEAR_CFGROM_NEW_ALLOC(node);

		return (DDI_SUCCESS);
	}

	for (units = 0, j = 1; j <= dir_len; j++) {
		CFGROM_TYPE_KEY_VALUE(root_dir[j], type, key, value);
		if (key == IEEE1212_UNIT_DIRECTORY && type ==
		    IEEE1212_DIRECTORY_TYPE) {
			ptr = &root_dir[j] + value;
			if (s1394_valid_dir(hal, node, key, ptr) == B_TRUE) {
				unit_dir_ptrs[units++] = ptr;
			} else {
				cmn_err(CE_NOTE, "!Bad unit directory in config"
				    " rom (node's GUID %08x%08x)",
				    node->node_guid_hi, node->node_guid_lo);
			}
		}
	}

	for (d = 0, j = 0; j < units; j++) {

		s1394_cfgrom_parse_unit_dir(unit_dir_ptrs[j],
		    &hi, &lo, &size_hi, &size_lo);

		lo = j;

		if (hi || lo) {
			(void) sprintf(caddr, "%08x%08x,%04x%08x",
			    node->node_guid_hi, node->node_guid_lo, hi, lo);
		} else {
			(void) sprintf(caddr, "%08x%08x",
			    node->node_guid_hi, node->node_guid_lo);
		}

		tdip = s1394_devi_find(hal->halinfo.dip, "unit", caddr);
		if (tdip != NULL) {

			rw_enter(&hal->target_list_rwlock, RW_WRITER);
			target = s1394_target_from_dip_locked(hal, tdip);
			if (target != NULL) {
				target->target_sibling = NULL;
				target->on_node = node;
				target->target_state &= ~S1394_TARG_GONE;
				target->unit_dir = unit_dir_ptrs[j] - root_dir;

				if ((t = node->target_list) != NULL) {
					ASSERT(t != target);
					while (t->target_sibling != NULL) {
						t = t->target_sibling;
						ASSERT(t != target);
					}
					t->target_sibling = target;
				} else {
					node->target_list = target;
				}

				target->target_list = node->target_list;
			}
			rw_exit(&hal->target_list_rwlock);

			s1394_update_unit_dir_location(hal, tdip,
			    unit_dir_ptrs[j] - root_dir);

		} else {
			/* create devinfo for unit@caddr */
			tdip = s1394_create_devinfo(hal, node,
			    unit_dir_ptrs[j], j);
			if (tdip != NULL) {
				new_devinfo |= (1 << d);
				s1394_update_unit_dir_location(hal, tdip,
				    unit_dir_ptrs[j] - root_dir);
			}
		}
		if (tdip != NULL)
			devinfo_ptrs[d++] = tdip;
	}

	ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
	/* Online all valid units */
	for (j = 0; j < d; j++) {
		if ((new_devinfo & (1 << j)) == 0) {
			linfo.bus_generation = hal->generation_count;
			linfo.local_nodeID = hal->node_id;
		}
		/* don't need to drop topology_tree_mutex across ndi calls */
		(void) ndi_devi_online_async(devinfo_ptrs[j], 0);
		if ((new_devinfo & (1 << j)) == 0) {
			/*
			 * send an insert event if this an existing devinfo.
			 * drop and reacquire topology_tree_mutex across
			 * the event calls
			 */
			s1394_unlock_tree(hal);
			s1394_send_insert_event(hal, devinfo_ptrs[j], &linfo);
			if (s1394_lock_tree(hal) != DDI_SUCCESS) {
				lockfail = 1;
				break;
			}
		}
	}

	if (lockfail) {
		return (DDI_FAILURE);
	}

	SET_CFGROM_PARSED(node);
	CLEAR_CFGROM_GEN_CHANGED(node);	/* if set */
	CLEAR_CFGROM_NEW_ALLOC(node);

	return (DDI_SUCCESS);
}

/*
 * s1394_offline_node()
 *    Offlines a node. This involves marking all targets attached to the
 *    node as gone, invoking any remove event callbacks and calling
 *    ndi_devi_offline to mark the devinfo as OFFLINE (for each unit
 *    directory on the node). The tree is unlocked and relocked around
 *    the callbacks. If unable to relock the tree, DDI_FAILURE, else
 *    returns DDI_SUCCESS.
 */
int
s1394_offline_node(s1394_hal_t *hal, s1394_node_t *node)
{
	s1394_target_t *t;
	dev_info_t *tdip;
	int j, d, units;
	uint32_t *unit_dir_ptrs[32];
	dev_info_t *devinfo_ptrs[32];
	t1394_localinfo_t linfo;
	uint32_t *ptr, *root_dir, dir_len;
	uint32_t hi, lo, size_hi, size_lo, type, key, value;
	char caddr[32];

	ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));

	d = 0;
	rw_enter(&hal->target_list_rwlock, RW_WRITER);
	t = node->target_list;
	while (t != NULL) {
		t->target_state |= S1394_TARG_GONE;
		t->on_node = NULL;
		t = t->target_sibling;
	}
	rw_exit(&hal->target_list_rwlock);

	/* scan through config rom looking for unit dirs */
	root_dir = CFGROM_ROOT_DIR(node->cfgrom);

	if (node->cfgrom_valid_size < CFGROM_DIR_LEN(root_dir))
		dir_len = node->cfgrom_valid_size;
	else
		dir_len = CFGROM_DIR_LEN(root_dir);

	CFGROM_TYPE_KEY_VALUE(root_dir[0], type, key, value);

	for (units = 0, j = 1; j <= dir_len; j++) {
		CFGROM_TYPE_KEY_VALUE(root_dir[j], type, key, value);
		if (key == IEEE1212_UNIT_DIRECTORY && type ==
				IEEE1212_DIRECTORY_TYPE) {
			ptr = &root_dir[j] + value;
			if (s1394_valid_dir(hal, node, key, ptr) == B_TRUE) {
				unit_dir_ptrs[units++] = ptr;
			}
		}
	}

	for (d = 0, j = 0; j < units; j++) {

		s1394_cfgrom_parse_unit_dir(unit_dir_ptrs[j],
				&hi, &lo, &size_hi, &size_lo);

		lo = j;

		if (hi || lo) {
			(void) sprintf(caddr, "%08x%08x,%04x%08x",
					node->node_guid_hi, node->node_guid_lo, hi, lo);
		} else {
			(void) sprintf(caddr, "%08x%08x",
					node->node_guid_hi, node->node_guid_lo);
		}

		if ((tdip = s1394_devi_find(hal->halinfo.dip, "unit", caddr)) !=
				NULL)
			devinfo_ptrs[d++] = tdip;
	}

	node->old_node = NULL;

	linfo.bus_generation = hal->generation_count;
	linfo.local_nodeID = hal->node_id;

	for (j = 0; j < d; j++) {
		s1394_unlock_tree(hal);

		s1394_send_remove_event(hal, devinfo_ptrs[j], &linfo);
		(void) ndi_devi_offline(devinfo_ptrs[j], NDI_DEVI_REMOVE);
		if (s1394_lock_tree(hal) != DDI_SUCCESS) {
			return (DDI_FAILURE);
		}
	}

	ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
	return (DDI_SUCCESS);
}

/*
 * s1394_process_topology_tree()
 *    Walks the topology tree, processing each node. If node that has
 *    already been parsed, updates the generation property on all devinfos
 *    for the node. Also, if the node exists in both old & new trees, ASSERTS
 *    that both point to the same config rom. If the node has valid config
 *    rom but hasn't been parsed yet, calls s1394_update_devinfo_tree()
 *    to parse and create devinfos for the node. Kicks off further config
 *    rom reading if only the bus info block for the node is read.
 *    Returns DDI_SUCCESS if everything went fine, else returns DDI_FAILURE
 *    (for eg. unable to reacquire the tree lock etc). wait_for_cbs argument
 *    tells the caller if some completions can be expected. wait_gen tells
 *    the generation the commands were issued at.
 */
int
s1394_process_topology_tree(s1394_hal_t *hal, int *wait_for_cbs,
    uint_t *wait_gen)
{
	int i;
	uint_t hal_node_num, number_of_nodes;
	s1394_node_t *node, *onode;
	s1394_status_t status;

	ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));

	if (s1394_lock_tree(hal) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	hal_node_num = IEEE1394_NODE_NUM(hal->node_id);
	hal->cfgroms_being_read = 0;
	number_of_nodes = hal->number_of_nodes;
	s1394_unlock_tree(hal);

	for (i = 0; i < number_of_nodes; i++) {

		if (i == hal_node_num)
			continue;
		if (s1394_lock_tree(hal) != DDI_SUCCESS) {
			return (DDI_FAILURE);
		}
		node = &hal->topology_tree[i];

		if (LINK_ACTIVE(node) == B_FALSE) {
			s1394_unlock_tree(hal);
			continue;
		}
		if (node->cfgrom == NULL) {
			s1394_unlock_tree(hal);
			continue;
		}

		onode = node->old_node;

		if (onode != NULL && onode->cfgrom != NULL && node->cfgrom !=
		    NULL) {
			/*
			 * onode->cfgrom != node->cfgrom should have been
			 * handled by s1394_match_GUID()!!!
			 */
			ASSERT(onode->cfgrom == node->cfgrom);
		}

		if (CFGROM_PARSED(node) == B_FALSE && CFGROM_ALL_READ(node) ==
		    B_TRUE) {
			ASSERT((node->cfgrom_size <
			    IEEE1394_CONFIG_ROM_QUAD_SZ) ||
			    NODE_MATCHED(node) == B_TRUE);
			rw_enter(&hal->target_list_rwlock, RW_READER);
			ASSERT(node->target_list == NULL);
			rw_exit(&hal->target_list_rwlock);
			if (s1394_update_devinfo_tree(hal, node) ==
			    DDI_FAILURE) {
				ASSERT(MUTEX_NOT_HELD(
				    &hal->topology_tree_mutex));
				return (DDI_FAILURE);
			}
		} else if (CFGROM_PARSED(node) == B_FALSE && CFGROM_BIB_READ(
		    node) == B_TRUE) {
			if (s1394_read_rest_of_cfgrom(hal, node, &status) !=
			    DDI_SUCCESS) {
				if ((status & S1394_LOCK_FAILED) == 0) {
					ASSERT(MUTEX_HELD(&hal->
					    topology_tree_mutex));
					*wait_for_cbs = 0;
					s1394_unlock_tree(hal);
				}
				return (DDI_FAILURE);
			} else {
				*wait_for_cbs = 1;
				*wait_gen = hal->br_cfgrom_read_gen;
			}
		}

		s1394_unlock_tree(hal);
	}

	/*
	 * flag the tree as processed; if a single bus reset happens after
	 * this, we will use tree matching.
	 */
	if (s1394_lock_tree(hal) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}
	hal->topology_tree_processed = B_TRUE;
	s1394_unlock_tree(hal);

	return (DDI_SUCCESS);
}

/*
 * s1394_process_old_tree()
 *    Walks through the old tree and offlines nodes that are removed. Nodes
 *    with an active link in the old tree but link powered off in the current
 *    generation are also offlined, as well as nodes with invalid config
 *    rom in current generation.
 *    The topology tree is locked/unlocked while walking through all the nodes;
 *    if the locking fails at any stage, stops further walking and returns
 *    DDI_FAILURE. Returns DDI_SUCCESS if everything went fine.
 */
int
s1394_process_old_tree(s1394_hal_t *hal)
{
	int i;
	uint_t hal_node_num_old, old_number_of_nodes;
	s1394_node_t *onode;

	/*
	 * NODE_MATCHED(onode) == 0 indicates this node doesn't exist
	 * any more.
	 */
	ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));

	if (s1394_lock_tree(hal) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}
	hal_node_num_old = IEEE1394_NODE_NUM(hal->old_node_id);
	old_number_of_nodes = hal->old_number_of_nodes;
	s1394_unlock_tree(hal);

	for (i = 0; i < old_number_of_nodes; i++) {

		if (i == hal_node_num_old)
			continue;
		if (s1394_lock_tree(hal) != DDI_SUCCESS) {
			return (DDI_FAILURE);
		}

		onode = &hal->old_tree[i];

		if (onode->cfgrom == NULL) {
			CLEAR_CFGROM_STATE(onode);
			s1394_unlock_tree(hal);
			continue;
		}

		/*
		 * onode->cur_node == NULL iff we couldn't read cfgrom in the
		 * current generation in non-tree matching case (and thus
		 * match_GUIDs couldn't set cur_node).
		 */
		if (NODE_MATCHED(onode) == B_FALSE || (onode->cur_node ==
		    NULL || ((CFGROM_VALID(onode) == B_TRUE &&
		    CFGROM_VALID(onode->cur_node) == B_FALSE) ||
		    (LINK_ACTIVE(onode) == B_TRUE && LINK_ACTIVE(onode->
		    cur_node) == B_FALSE)))) {

			if (s1394_offline_node(hal, onode) != DDI_SUCCESS) {
				return (DDI_FAILURE);
			}
			s1394_free_cfgrom(hal, onode, S1394_FREE_CFGROM_OLD);
		}

		s1394_unlock_tree(hal);
	}

	ASSERT(MUTEX_NOT_HELD(&hal->topology_tree_mutex));

	return (DDI_SUCCESS);
}

/*
 * s1394_update_unit_dir_location()
 *    Updates the unit-dir-offset property on the devinfo.
 *    NOTE: ndi_prop_update_int() is interrupt callable (and thus won't block);
 *    so, the caller doesn't drop topology_tree_mutex when calling this routine.
 */
/*ARGSUSED*/
static void
s1394_update_unit_dir_location(s1394_hal_t *hal, dev_info_t *tdip,
    uint_t offset)
{
	ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));
	ASSERT(tdip != NULL);

	(void) ndi_prop_update_int(DDI_DEV_T_NONE, tdip, "unit-dir-offset",
	    offset);
}

/*
 * s1394_add_target_to_node()
 *    adds target to the list of targets hanging off the node. Figures out
 *    the node by searching the topology tree for the GUID corresponding
 *    to the target. Points on_node field of target structure at the node.
 */
void
s1394_add_target_to_node(s1394_target_t *target)
{
	s1394_target_t *t;
	s1394_hal_t *hal;
	uint32_t guid_hi;
	uint32_t guid_lo;
	int i;
	char name[MAXNAMELEN];
	char *ptr;

	hal = target->on_hal;
	ASSERT(hal != NULL);

	/* Topology tree must be locked when it gets here! */
	ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));

	/* target_list_rwlock should be held in write mode */
	ASSERT(rw_read_locked(&target->on_hal->target_list_rwlock) == 0);

	if ((ptr = ddi_get_name_addr(target->target_dip)) == NULL) {
		return;
	}

	(void) sprintf(name, ptr);
	/* Drop the ,<ADDR> part, if present */
	if ((ptr = strchr(name, ',')) != NULL)
		*ptr = '\0';

	ptr = name;
	guid_hi = s1394_stoi(ptr, 8, 16);
	guid_lo = s1394_stoi(ptr + 8, 8, 16);

	/* Search the HAL's node list for this GUID */
	for (i = 0; i < hal->number_of_nodes; i++) {
		if (CFGROM_VALID(&hal->topology_tree[i]) == B_TRUE) {
			ASSERT(hal->topology_tree[i].cfgrom != NULL);

			if ((hal->topology_tree[i].node_guid_hi == guid_hi) &&
			    (hal->topology_tree[i].node_guid_lo == guid_lo)) {
				target->on_node = &hal->topology_tree[i];
				if ((t = hal->topology_tree[i].target_list) !=
				    NULL) {
					ASSERT(t != target);
					while (t->target_sibling != NULL) {
						t = t->target_sibling;
						ASSERT(t != target);
					}
					t->target_sibling = target;
				} else {
					hal->topology_tree[i].target_list =
					    target;
				}

				/*
				 * update target_list in all targets on the
				 * node
				 */
				t = hal->topology_tree[i].target_list;
				while (t != NULL) {
					t->target_list =
					    hal->topology_tree[i].target_list;
					t = t->target_sibling;
				}
				break;
			}
		}
	}
}

/*
 * s1394_remove_target_from_node()
 *    Removes target from the corresponding node's target_list.
 */
void
s1394_remove_target_from_node(s1394_target_t *target)
{
	s1394_target_t *t, *t1;
	s1394_hal_t *hal;

	hal = target->on_hal;
	ASSERT(hal != NULL);

	/* Topology tree must be locked when it gets here! */
	ASSERT(MUTEX_HELD(&hal->topology_tree_mutex));

	/* target_list_rwlock should be held in write mode */
	ASSERT(rw_read_locked(&target->on_hal->target_list_rwlock) == 0);

	t = target->target_list;
	t1 = NULL;
	while (t != NULL) {
		if (t == target) {
			if (t1 == NULL) {
				target->target_list = t->target_sibling;
			} else {
				t1->target_sibling = t->target_sibling;
			}
			break;
		}
		t1 = t;
		t = t->target_sibling;
	}
	/* Update the target_list pointer in all the targets */
	if (target->on_node != NULL)
		target->on_node->target_list = target->target_list;

	t = t1 = target->target_list;
	while (t != NULL) {
		t->target_list = t1;
		t = t->target_sibling;
	}

	target->on_node = NULL;
	target->target_sibling = NULL;
}