xref: /illumos-gate/usr/src/uts/common/io/1394/h1394.c (revision 2570281c)

/*
 * 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 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * h1394.c
 *    1394 Services Layer HAL Interface
 *    Contains all of the routines that define the HAL to Services Layer
 *    interface
 */

#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.h>
#include <sys/modctl.h>
#include <sys/sunndi.h>
#include <sys/cmn_err.h>
#include <sys/types.h>
#include <sys/kmem.h>
#include <sys/thread.h>
#include <sys/proc.h>
#include <sys/disp.h>
#include <sys/time.h>
#include <sys/devctl.h>
#include <sys/1394/t1394.h>
#include <sys/1394/s1394.h>
#include <sys/1394/h1394.h>
#include <sys/1394/ieee1394.h>


extern struct bus_ops nx1394_busops;
extern int nx1394_define_events(s1394_hal_t *hal);
extern void nx1394_undefine_events(s1394_hal_t *hal);
extern int s1394_ignore_invalid_gap_cnt;

/*
 * Function:    h1394_init()
 * Input(s):    modlp			The structure containing all of the
 *					    HAL's relevant information
 *
 * Output(s):
 *
 * Description:	h1394_init() is called by the HAL's _init function and is
 *		used to set up the nexus bus ops.
 */
int
h1394_init(struct modlinkage *modlp)
{
	struct dev_ops	*devops;

	devops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
	devops->devo_bus_ops = &nx1394_busops;

	return (0);
}

/*
 * Function:    h1394_fini()
 * Input(s):    modlp			The structure containing all of the
 *					    HAL's relevant information
 *
 * Output(s):
 *
 * Description:	h1394_fini() is called by the HAL's _fini function and is
 *		used to NULL out the nexus bus ops.
 */
void
h1394_fini(struct modlinkage *modlp)
{
	struct dev_ops	*devops;

	devops = ((struct modldrv *)(modlp->ml_linkage[0]))->drv_dev_ops;
	devops->devo_bus_ops = NULL;
}

/*
 * Function:    h1394_attach()
 * Input(s):    halinfo			The structure containing all of the
 *					    HAL's relevant information
 *		cmd			The ddi_attach_cmd_t that tells us
 *					    if this is a RESUME or a regular
 *					    attach() call
 *
 * Output(s):	sl_private		The HAL "handle" to be used for
 *					    all subsequent calls into the
 *					    1394 Software Framework
 *
 * Description:	h1394_attach() registers the HAL with the 1394 Software
 *		Framework.  It returns a HAL "handle" to be used for
 *		all subsequent calls into the 1394 Software Framework.
 */
int
h1394_attach(h1394_halinfo_t *halinfo, ddi_attach_cmd_t cmd, void **sl_private)
{
	s1394_hal_t	*hal;
	int		ret;
	char		buf[32];
	uint_t		cmd_size;

	ASSERT(sl_private != NULL);

	/* If this is a DDI_RESUME, return success */
	if (cmd == DDI_RESUME) {
		hal = (s1394_hal_t *)(*sl_private);
		/* If we have a 1394A PHY, then reset the "contender bit" */
		if (hal->halinfo.phy == H1394_PHY_1394A)
			(void) HAL_CALL(hal).set_contender_bit(
			    hal->halinfo.hal_private);
		return (DDI_SUCCESS);
	} else if (cmd != DDI_ATTACH) {
		return (DDI_FAILURE);
	}

	/* Allocate space for s1394_hal_t */
	hal = kmem_zalloc(sizeof (s1394_hal_t), KM_SLEEP);

	/* Setup HAL state */
	hal->hal_state = S1394_HAL_INIT;

	/* Copy in the halinfo struct */
	hal->halinfo = *halinfo;

	/* Create the topology tree mutex */
	mutex_init(&hal->topology_tree_mutex, NULL, MUTEX_DRIVER,
	    hal->halinfo.hw_interrupt);

	/* Create the Cycle Mater timer mutex */
	mutex_init(&hal->cm_timer_mutex, NULL, MUTEX_DRIVER,
	    hal->halinfo.hw_interrupt);

	/* Initialize the Isoch CEC list */
	hal->isoch_cec_list_head = NULL;
	hal->isoch_cec_list_tail = NULL;
	mutex_init(&hal->isoch_cec_list_mutex, NULL, MUTEX_DRIVER,
	    hal->halinfo.hw_interrupt);

	/* Initialize the Bus Manager node ID mutex and cv */
	mutex_init(&hal->bus_mgr_node_mutex, NULL, MUTEX_DRIVER,
	    hal->halinfo.hw_interrupt);
	cv_init(&hal->bus_mgr_node_cv, NULL, CV_DRIVER,
	    hal->halinfo.hw_interrupt);

	/* Initialize the Bus Manager node ID - "-1" means undetermined */
	hal->bus_mgr_node	= -1;
	hal->incumbent_bus_mgr	= B_FALSE;

	/* Initialize the Target list */
	hal->target_head = NULL;
	hal->target_tail = NULL;
	rw_init(&hal->target_list_rwlock, NULL, RW_DRIVER,
	    hal->halinfo.hw_interrupt);

	/* Setup Request Q's */
	hal->outstanding_q_head	= NULL;
	hal->outstanding_q_tail	= NULL;
	mutex_init(&hal->outstanding_q_mutex, NULL, MUTEX_DRIVER,
	    hal->halinfo.hw_interrupt);
	hal->pending_q_head	= NULL;
	hal->pending_q_tail	= NULL;
	mutex_init(&hal->pending_q_mutex, NULL, MUTEX_DRIVER,
	    hal->halinfo.hw_interrupt);

	/* Create the kmem_cache for command allocations */
	(void) sprintf(buf, "hal%d_cache", ddi_get_instance(hal->halinfo.dip));
	cmd_size = sizeof (cmd1394_cmd_t) + sizeof (s1394_cmd_priv_t) +
	    hal->halinfo.hal_overhead;

	hal->hal_kmem_cachep = kmem_cache_create(buf, cmd_size, 8, NULL, NULL,
	    NULL, NULL, NULL, 0);

	/* Setup the event stuff */
	ret = nx1394_define_events(hal);
	if (ret != DDI_SUCCESS) {
		/* Clean up before leaving */
		s1394_cleanup_for_detach(hal, H1394_CLEANUP_LEVEL0);

		return (DDI_FAILURE);
	}

	/* Initialize the mutexes and cv's used by the bus reset thread */
	mutex_init(&hal->br_thread_mutex, NULL, MUTEX_DRIVER,
	    hal->halinfo.hw_interrupt);
	cv_init(&hal->br_thread_cv, NULL, CV_DRIVER, hal->halinfo.hw_interrupt);
	mutex_init(&hal->br_cmplq_mutex, NULL, MUTEX_DRIVER,
	    hal->halinfo.hw_interrupt);
	cv_init(&hal->br_cmplq_cv, NULL, CV_DRIVER, hal->halinfo.hw_interrupt);

	/*
	 * Create a bus reset thread to handle the device discovery.
	 *    It should take the default stack sizes, it should run
	 *    the s1394_br_thread() routine at the start, passing the
	 *    HAL pointer as its argument.  The thread should be put
	 *    on processor p0, its state should be set to runnable,
	 *    but not yet on a processor, and its scheduling priority
	 *    should be the minimum level of any system class.
	 */
	hal->br_thread = thread_create((caddr_t)NULL, 0, s1394_br_thread,
	    hal, 0, &p0, TS_RUN, minclsyspri);

	/* Until we see a bus reset this HAL has no nodes */
	hal->number_of_nodes = 0;
	hal->num_bus_reset_till_fail = NUM_BR_FAIL;

	/* Initialize the SelfID Info */
	hal->current_buffer = 0;
	hal->selfid_buf0 = kmem_zalloc(S1394_SELFID_BUF_SIZE, KM_SLEEP);
	hal->selfid_buf1 = kmem_zalloc(S1394_SELFID_BUF_SIZE, KM_SLEEP);

	/* Initialize kstat structures */
	ret = s1394_kstat_init(hal);
	if (ret != DDI_SUCCESS) {
		/* Clean up before leaving */
		s1394_cleanup_for_detach(hal, H1394_CLEANUP_LEVEL3);

		return (DDI_FAILURE);
	}
	hal->hal_kstats->guid = hal->halinfo.guid;

	/* Setup the node tree pointers */
	hal->old_tree	   = &hal->last_valid_tree[0];
	hal->topology_tree = &hal->current_tree[0];

	/* Initialize the local Config ROM entry */
	ret = s1394_init_local_config_rom(hal);
	if (ret != DDI_SUCCESS) {
		/* Clean up before leaving */
		s1394_cleanup_for_detach(hal, H1394_CLEANUP_LEVEL4);

		return (DDI_FAILURE);
	}

	/* Initialize 1394 Address Space */
	ret = s1394_init_addr_space(hal);
	if (ret != DDI_SUCCESS) {
		/* Clean up before leaving */
		s1394_cleanup_for_detach(hal, H1394_CLEANUP_LEVEL5);

		return (DDI_FAILURE);
	}

	/* Initialize FCP subsystem */
	ret = s1394_fcp_hal_init(hal);
	if (ret != DDI_SUCCESS) {
		/* Clean up before leaving */
		s1394_cleanup_for_detach(hal, H1394_CLEANUP_LEVEL6);

		return (DDI_FAILURE);
	}

	/* Initialize the IRM node ID - "-1" means invalid, undetermined */
	hal->IRM_node = -1;

	/* If we have a 1394A PHY, then set the "contender bit" */
	if (hal->halinfo.phy == H1394_PHY_1394A)
		(void) HAL_CALL(hal).set_contender_bit(
		    hal->halinfo.hal_private);

	/* Add into linked list */
	mutex_enter(&s1394_statep->hal_list_mutex);
	if ((s1394_statep->hal_head == NULL) &&
	    (s1394_statep->hal_tail == NULL)) {
		s1394_statep->hal_head = hal;
		s1394_statep->hal_tail = hal;
	} else {
		s1394_statep->hal_tail->hal_next = hal;
		hal->hal_prev = s1394_statep->hal_tail;
		s1394_statep->hal_tail = hal;
	}
	mutex_exit(&s1394_statep->hal_list_mutex);

	/* Fill in services layer private info */
	*sl_private = (void *)hal;

	return (DDI_SUCCESS);
}

/*
 * Function:    h1394_detach()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		cmd			The ddi_detach_cmd_t that tells us
 *					    if this is a SUSPEND or a regular
 *					    detach() call
 *
 * Output(s):	DDI_SUCCESS		HAL successfully detached
 *		DDI_FAILURE		HAL failed to detach
 *
 * Description:	h1394_detach() unregisters the HAL from the 1394 Software
 *		Framework.  It can be called during a SUSPEND operation or
 *		for a real detach() event.
 */
int
h1394_detach(void **sl_private, ddi_detach_cmd_t cmd)
{
	s1394_hal_t	*hal;

	hal = (s1394_hal_t *)(*sl_private);

	switch (cmd) {
	case DDI_DETACH:
		/* Clean up before leaving */
		s1394_cleanup_for_detach(hal, H1394_CLEANUP_LEVEL7);
		/* NULL out the HAL "handle" */
		*sl_private = NULL;
		break;

	case DDI_SUSPEND:
		/* Turn off any timers that might be set */
		s1394_destroy_timers(hal);
		/* Set the hal_was_suspended bit */
		hal->hal_was_suspended = B_TRUE;
		break;

	default:
		return (DDI_FAILURE);
	}

	return (DDI_SUCCESS);
}

/*
 * Function:    h1394_alloc_cmd()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		flags			The flags parameter is described below
 *
 * Output(s):	cmdp			Pointer to the newly allocated command
 *		hal_priv_ptr		Offset into the command, points to
 *					    the HAL's private area
 *
 * Description:	h1394_alloc_cmd() allocates a command for use with the
 *		h1394_read_request(), h1394_write_request(), or
 *		h1394_lock_request() interfaces of the 1394 Software Framework.
 *		By default, h1394_alloc_cmd() may sleep while allocating
 *		memory for the command structure.  If this is undesirable,
 *		the HAL may set the H1394_ALLOC_CMD_NOSLEEP bit in the flags
 *		parameter.
 */
int
h1394_alloc_cmd(void *sl_private, uint_t flags, cmd1394_cmd_t **cmdp,
    h1394_cmd_priv_t **hal_priv_ptr)
{
	s1394_hal_t	 *hal;
	s1394_cmd_priv_t *s_priv;

	hal = (s1394_hal_t *)sl_private;

	if (s1394_alloc_cmd(hal, flags, cmdp) != DDI_SUCCESS) {
		return (DDI_FAILURE);
	}

	/* Get the Services Layer private area */
	s_priv = S1394_GET_CMD_PRIV(*cmdp);

	*hal_priv_ptr = &s_priv->hal_cmd_private;

	return (DDI_SUCCESS);
}

/*
 * Function:    h1394_free_cmd()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		cmdp			Pointer to the command to be freed
 *
 * Output(s):	DDI_SUCCESS		HAL successfully freed command
 *		DDI_FAILURE		HAL failed to free command
 *
 * Description:	h1394_free_cmd() attempts to free a command that has previously
 *		been allocated by the HAL.  It is possible for h1394_free_cmd()
 *		to fail because the command is currently in-use by the 1394
 *		Software Framework.
 */
int
h1394_free_cmd(void *sl_private, cmd1394_cmd_t **cmdp)
{
	s1394_hal_t	 *hal;
	s1394_cmd_priv_t *s_priv;

	hal = (s1394_hal_t *)sl_private;

	/* Get the Services Layer private area */
	s_priv = S1394_GET_CMD_PRIV(*cmdp);

	/* Check that command isn't in use */
	if (s_priv->cmd_in_use == B_TRUE) {
		ASSERT(s_priv->cmd_in_use == B_FALSE);
		return (DDI_FAILURE);
	}

	kmem_cache_free(hal->hal_kmem_cachep, *cmdp);

	/* Command pointer is set to NULL before returning */
	*cmdp = NULL;

	/* kstats - number of cmds freed */
	hal->hal_kstats->cmd_free++;

	return (DDI_SUCCESS);
}

/*
 * Function:    h1394_cmd_is_complete()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		command_id		Pointer to the command that has
 *					    just completed
 *		cmd_type		AT_RESP => AT response or ATREQ =
 *					    AT request
 *		status			Command's completion status
 *
 * Output(s):	None
 *
 * Description:	h1394_cmd_is_complete() is called by the HAL whenever an
 *		outstanding command has completed (successfully or otherwise).
 *		After determining whether it was an AT request or and AT
 *		response that we are handling, the command is dispatched to
 *		the appropriate handler in the 1394 Software Framework.
 */
void
h1394_cmd_is_complete(void *sl_private, cmd1394_cmd_t *command_id,
    uint32_t cmd_type, int status)
{
	s1394_hal_t	*hal;
	dev_info_t	*dip;

	hal = (s1394_hal_t *)sl_private;

	/* Is it AT_RESP or AT_REQ? */
	switch (cmd_type) {
	case H1394_AT_REQ:
		s1394_atreq_cmd_complete(hal, command_id, status);
		break;

	case H1394_AT_RESP:
		s1394_atresp_cmd_complete(hal, command_id, status);
		break;

	default:
		dip = hal->halinfo.dip;

		/* An unexpected error in the HAL */
		cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
		    ddi_node_name(dip), ddi_get_instance(dip));

		/* Disable the HAL */
		s1394_hal_shutdown(hal, B_TRUE);

		break;
	}
}

/*
 * Function:    h1394_bus_reset()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *
 * Output(s):	selfid_buf_addr		The pointer to a buffer into which
 *					    any Self ID packets should be put
 *
 * Description:	h1394_bus_reset() is called whenever a 1394 bus reset event
 *		is detected by the HAL.  This routine simply prepares for
 *		the subsequent Self ID packets.
 */
void
h1394_bus_reset(void *sl_private, void **selfid_buf_addr)
{
	s1394_hal_t	*hal;

	hal = (s1394_hal_t *)sl_private;

	mutex_enter(&hal->topology_tree_mutex);

	/* Update the HAL's state */
	if (hal->hal_state != S1394_HAL_SHUTDOWN) {
		hal->hal_state = S1394_HAL_RESET;
	} else {
		mutex_exit(&hal->topology_tree_mutex);
		return;
	}

	if (hal->initiated_bus_reset == B_TRUE) {
		hal->initiated_bus_reset = B_FALSE;
		if (hal->num_bus_reset_till_fail > 0) {
			hal->num_bus_reset_till_fail--;
		}
	} else {
		hal->num_bus_reset_till_fail = NUM_BR_FAIL;
	}

	/* Reset the IRM node ID */
	hal->IRM_node = -1;

	/* Slowest node defaults to IEEE1394_S400 */
	hal->slowest_node_speed = IEEE1394_S400;

	/* Pick a SelfID buffer to give */
	if (hal->current_buffer == 0) {
		*selfid_buf_addr = (void *)hal->selfid_buf1;
		hal->current_buffer = 1;
	} else {
		*selfid_buf_addr = (void *)hal->selfid_buf0;
		hal->current_buffer = 0;
	}

	/* Disable the CSR topology_map (temporarily) */
	s1394_CSR_topology_map_disable(hal);

	mutex_exit(&hal->topology_tree_mutex);

	/* Reset the Bus Manager node ID */
	mutex_enter(&hal->bus_mgr_node_mutex);
	hal->bus_mgr_node = -1;
	mutex_exit(&hal->bus_mgr_node_mutex);
}

/*
 * Function:    h1394_self_ids()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		selfid_buf_addr		Pointer to the Self ID buffer
 *		selfid_size		The size of the filled part of the
 *					    Self ID buffer
 *		node_id			The local (host) node ID for the
 *					    current generation
 *		generation_count	The current generation number
 *
 * Output(s):	None
 *
 * Description:	h1394_self_ids() does alot of the work at bus reset.  It
 *		takes the Self ID packets and parses them, builds a topology
 *		tree representation of them, calculates gap count, IRM, speed
 *		map, does any node matching that's possible, and then wakes
 *		up the br_thread.
 */
void
h1394_self_ids(void *sl_private, void *selfid_buf_addr, uint32_t selfid_size,
    uint32_t node_id, uint32_t generation_count)
{
	s1394_hal_t	*hal;
	int		diameter;
	uint_t		gen_diff, gen_rollover;
	boolean_t	tree_copied = B_FALSE;
	ushort_t	saved_number_of_nodes;

	/*
	 * NOTE: current topology tree is referred to as topology_tree
	 * and the old topology tree is referred to as old_tree.
	 * tree_valid indicates selfID buffer checked out OK and we were
	 * able to build the topology tree.
	 * tree_processed indicates we read the config ROMs as needed.
	 */
	hal = (s1394_hal_t *)sl_private;

	/* Lock the topology tree */
	mutex_enter(&hal->topology_tree_mutex);
	if (hal->hal_state == S1394_HAL_SHUTDOWN) {
		mutex_exit(&hal->topology_tree_mutex);
		return;
	}

	/* kstats - number of selfid completes */
	hal->hal_kstats->selfid_complete++;

	if (generation_count > hal->generation_count) {
		gen_diff = generation_count - hal->generation_count;
		hal->hal_kstats->bus_reset += gen_diff;
	} else {
		gen_diff = hal->generation_count - generation_count;
		/* Use max_generation to determine how many bus resets */
		hal->hal_kstats->bus_reset +=
		    (hal->halinfo.max_generation - gen_diff);
	}

	/*
	 * If the current tree has a valid topology tree (selfids
	 * checked out OK etc) and config roms read as needed,
	 * then make it the old tree before building a new one.
	 */
	if ((hal->topology_tree_valid == B_TRUE) &&
	    (hal->topology_tree_processed == B_TRUE)) {
		/* Trees are switched after the copy completes */
		s1394_copy_old_tree(hal);
		tree_copied = B_TRUE;
	}

	/* Set the new generation and node id */
	hal->node_id = node_id;
	hal->generation_count = generation_count;

	/* Invalidate the current topology tree */
	hal->topology_tree_valid = B_FALSE;
	hal->topology_tree_processed = B_FALSE;
	hal->cfgroms_being_read = 0;

	/*
	 * Save the number of nodes prior to parsing the self id buffer.
	 * We need this saved value while initializing the topology tree
	 * (for non-copy case).
	 */
	saved_number_of_nodes = hal->number_of_nodes;

	/* Parse the SelfID buffer */
	if (s1394_parse_selfid_buffer(hal, selfid_buf_addr, selfid_size) !=
	    DDI_SUCCESS) {
		/* Unlock the topology tree */
		mutex_exit(&hal->topology_tree_mutex);

		/* kstats - SelfID buffer error */
		hal->hal_kstats->selfid_buffer_error++;
		return;		/* Error parsing SelfIDs */
	}

	/* Sort the SelfID packets by node number (if it's a 1995 PHY) */
	if (hal->halinfo.phy == H1394_PHY_1995) {
		s1394_sort_selfids(hal);
	}

	/*
	 * Update the cycle master timer - if the timer is set and
	 * we were the root but we are not anymore, then disable it.
	 */
	mutex_enter(&hal->cm_timer_mutex);
	if ((hal->cm_timer_set == B_TRUE) &&
	    ((hal->old_number_of_nodes - 1) ==
		IEEE1394_NODE_NUM(hal->old_node_id)) &&
	    ((hal->number_of_nodes - 1) !=
		IEEE1394_NODE_NUM(hal->node_id))) {
		mutex_exit(&hal->cm_timer_mutex);
		(void) untimeout(hal->cm_timer);
	} else {
		mutex_exit(&hal->cm_timer_mutex);
	}

	s1394_init_topology_tree(hal, tree_copied, saved_number_of_nodes);

	/* Determine the 1394 bus gap count */
	hal->gap_count = s1394_get_current_gap_count(hal);
	/* If gap counts are inconsistent, reset */
	if (hal->gap_count == -1) {
		/* Unlock the topology tree */
		mutex_exit(&hal->topology_tree_mutex);

		/* kstats - SelfID buffer error (invalid gap counts) */
		hal->hal_kstats->selfid_buffer_error++;

		if (s1394_ignore_invalid_gap_cnt == 1) {
			/* Lock the topology tree again */
			mutex_enter(&hal->topology_tree_mutex);
			hal->gap_count = 0x3F;
		} else {
			return;	/* Invalid gap counts in SelfID buffer */
		}
	}

	/* Determine the Isoch Resource Manager */
	hal->IRM_node = s1394_get_isoch_rsrc_mgr(hal);

	/* Build the topology tree */
	if (s1394_topology_tree_build(hal) != DDI_SUCCESS) {
		/* Unlock the topology tree */
		mutex_exit(&hal->topology_tree_mutex);

		/* kstats - SelfID buffer error (Invalid topology tree) */
		hal->hal_kstats->selfid_buffer_error++;
		return;		/* Error building topology tree from SelfIDs */
	}

	/* Update the CSR topology_map */
	s1394_CSR_topology_map_update(hal);

	/* Calculate the diameter */
	diameter = s1394_topology_tree_calculate_diameter(hal);

	/* Determine the optimum gap count */
	hal->optimum_gap_count = s1394_gap_count_optimize(diameter);

	/* Fill in the speed map */
	s1394_speed_map_fill(hal);

	/* Initialize the two trees (for tree walking) */
	s1394_topology_tree_mark_all_unvisited(hal);
	s1394_old_tree_mark_all_unvisited(hal);
	s1394_old_tree_mark_all_unmatched(hal);

	/* Are both trees (old and new) valid? */
	if ((hal->old_tree_valid == B_TRUE) &&
	    (hal->topology_tree_valid == B_TRUE)) {
		/* If HAL was in a suspended state, then do no matching */
		if (hal->hal_was_suspended == B_TRUE) {
		    hal->hal_was_suspended = B_FALSE;
		} else {
			gen_rollover = hal->halinfo.max_generation + 1;
			/* If only one bus reset occurred, match the trees */
			if (((hal->old_generation_count + 1) % gen_rollover) ==
			    generation_count) {
				s1394_match_tree_nodes(hal);
			}
		}
	}

	/* Unlock the topology tree */
	mutex_exit(&hal->topology_tree_mutex);

	/* Wake up the bus reset processing thread */
	s1394_tickle_bus_reset_thread(hal);
}

/*
 * Function:    h1394_read_request()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		req			The incoming AR request
 *
 * Output(s):	None
 *
 * Description:	h1394_read_request() receives incoming AR requests.  These
 *		asynchronous read requests are dispatched to the appropriate
 *		target (if one has registered) or are handled by the 1394
 *		Software Framework, which will send out an appropriate
 *		response.
 */
void
h1394_read_request(void *sl_private, cmd1394_cmd_t *req)
{
	s1394_hal_t		*hal;
	s1394_cmd_priv_t	*s_priv;
	s1394_addr_space_blk_t  *addr_blk;
	dev_info_t		*dip;
	uint64_t		end_of_request;
	uint32_t		offset;
	size_t			cmd_length;
	uchar_t			*bufp_addr;
	uchar_t			*begin_ptr;
	uchar_t			*end_ptr;
	uchar_t			*tmp_ptr;
	void (*recv_read_req)(cmd1394_cmd_t *);

	hal = (s1394_hal_t *)sl_private;

	/* Get the Services Layer private area */
	s_priv = S1394_GET_CMD_PRIV(req);

	s_priv->cmd_priv_xfer_type = S1394_CMD_READ;

	switch (req->cmd_type) {
	case CMD1394_ASYNCH_RD_QUAD:
		cmd_length = IEEE1394_QUADLET;
		hal->hal_kstats->arreq_quad_rd++;
		break;

	case CMD1394_ASYNCH_RD_BLOCK:
		cmd_length = req->cmd_u.b.blk_length;
		hal->hal_kstats->arreq_blk_rd++;
		break;

	default:
		dip = hal->halinfo.dip;

		/* An unexpected error in the HAL */
		cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
		    ddi_node_name(dip), ddi_get_instance(dip));

		/* Disable the HAL */
		s1394_hal_shutdown(hal, B_TRUE);

		return;
	}

	/* Lock the "used" tree */
	mutex_enter(&hal->addr_space_used_mutex);

	/* Has the 1394 address been allocated? */
	addr_blk = s1394_used_tree_search(hal, req->cmd_addr);

	/* If it wasn't found, it isn't owned... */
	if (addr_blk == NULL) {
		/* Unlock the "used" tree */
		mutex_exit(&hal->addr_space_used_mutex);
		req->cmd_result = IEEE1394_RESP_ADDRESS_ERROR;
		(void) s1394_send_response(hal, req);
		return;
	}

	/* Does the WHOLE request fit in the allocated block? */
	end_of_request = (req->cmd_addr + cmd_length) - 1;
	if (end_of_request > addr_blk->addr_hi) {
		/* Unlock the "used" tree */
		mutex_exit(&hal->addr_space_used_mutex);
		req->cmd_result = IEEE1394_RESP_ADDRESS_ERROR;
		(void) s1394_send_response(hal, req);
		return;
	}

	/* Is a read request valid for this address space? */
	if (!(addr_blk->addr_enable & T1394_ADDR_RDENBL)) {
		/* Unlock the "used" tree */
		mutex_exit(&hal->addr_space_used_mutex);
		req->cmd_result = IEEE1394_RESP_TYPE_ERROR;
		(void) s1394_send_response(hal, req);
		return;
	}

	/* Make sure quadlet requests are quadlet-aligned */
	offset = req->cmd_addr - addr_blk->addr_lo;
	if ((req->cmd_type == CMD1394_ASYNCH_RD_QUAD) &&
	    ((offset & 0x3) != 0)) {
		/* Unlock the "used" tree */
		mutex_exit(&hal->addr_space_used_mutex);
		req->cmd_result = IEEE1394_RESP_TYPE_ERROR;
		(void) s1394_send_response(hal, req);
		return;
	}

	/* Fill in the backing store if necessary */
	if (addr_blk->kmem_bufp != NULL) {
		offset = req->cmd_addr - addr_blk->addr_lo;
		bufp_addr = (uchar_t *)addr_blk->kmem_bufp + offset;

		switch (req->cmd_type) {
		case CMD1394_ASYNCH_RD_QUAD:
			bcopy((void *)bufp_addr,
			    (void *)&(req->cmd_u.q.quadlet_data), cmd_length);
			break;

		case CMD1394_ASYNCH_RD_BLOCK:
			begin_ptr = req->cmd_u.b.data_block->b_wptr;
			end_ptr	  = begin_ptr + cmd_length;
			tmp_ptr	  = req->cmd_u.b.data_block->b_datap->db_lim;
			if (end_ptr <= tmp_ptr) {
				bcopy((void *)bufp_addr, (void *)begin_ptr,
				    cmd_length);
				/* Update b_wptr to refelect the new data */
				req->cmd_u.b.data_block->b_wptr = end_ptr;
			} else {
				dip = hal->halinfo.dip;

				/* An unexpected error in the HAL */
				cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
				    ddi_node_name(dip), ddi_get_instance(dip));

				/* Unlock the "used" tree */
				mutex_exit(&hal->addr_space_used_mutex);

				/* Disable the HAL */
				s1394_hal_shutdown(hal, B_TRUE);

				return;
			}
			break;

		default:
			dip = hal->halinfo.dip;

			/* An unexpected error in the HAL */
			cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
			    ddi_node_name(dip), ddi_get_instance(dip));

			/* Unlock the "used" tree */
			mutex_exit(&hal->addr_space_used_mutex);

			/* Disable the HAL */
			s1394_hal_shutdown(hal, B_TRUE);

			return;
		}
	}

	/* Fill in the rest of the info in the request */
	s_priv->arreq_valid_addr = B_TRUE;
	req->cmd_callback_arg	 = addr_blk->addr_arg;
	recv_read_req		 = addr_blk->addr_events.recv_read_request;

	/* Unlock the "used" tree */
	mutex_exit(&hal->addr_space_used_mutex);

	/*
	 * Add no code that modifies the command after the target
	 * callback is called or after the response is sent to the
	 * HAL.
	 */
	if (recv_read_req != NULL) {
		recv_read_req(req);
	} else {
		req->cmd_result = IEEE1394_RESP_COMPLETE;
		(void) s1394_send_response(hal, req);
		return;
	}
}

/*
 * Function:    h1394_write_request()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		req			The incoming AR request
 *
 * Output(s):	None
 *
 * Description:	h1394_write_request() receives incoming AR requests.  These
 *		asynchronous write requests are dispatched to the appropriate
 *		target (if one has registered) or are handled by the 1394
 *		Software Framework, which will send out an appropriate
 *		response.
 */
void
h1394_write_request(void *sl_private, cmd1394_cmd_t *req)
{
	s1394_hal_t		*hal;
	s1394_cmd_priv_t	*s_priv;
	h1394_cmd_priv_t	*h_priv;
	s1394_addr_space_blk_t	*addr_blk;
	dev_info_t		*dip;
	uint32_t		offset;
	size_t			cmd_length;
	uchar_t			*bufp_addr;
	uchar_t			*begin_ptr;
	uchar_t			*end_ptr;
	uchar_t			*tmp_ptr;
	uint64_t		end_of_request;
	boolean_t		posted_write = B_FALSE;
	boolean_t		write_error = B_FALSE;
	void (*recv_write_req)(cmd1394_cmd_t *);

	hal = (s1394_hal_t *)sl_private;

	/* Get the Services Layer private area */
	s_priv = S1394_GET_CMD_PRIV(req);

	s_priv->cmd_priv_xfer_type = S1394_CMD_WRITE;

	switch (req->cmd_type) {
	case CMD1394_ASYNCH_WR_QUAD:
		cmd_length = IEEE1394_QUADLET;
		hal->hal_kstats->arreq_quad_wr++;
		break;

	case CMD1394_ASYNCH_WR_BLOCK:
		cmd_length = req->cmd_u.b.blk_length;
		hal->hal_kstats->arreq_blk_wr++;
		hal->hal_kstats->arreq_blk_wr_size += cmd_length;
		break;

	default:
		dip = hal->halinfo.dip;

		/* An unexpected error in the HAL */
		cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
		    ddi_node_name(dip), ddi_get_instance(dip));

		/* Disable the HAL */
		s1394_hal_shutdown(hal, B_TRUE);

		return;
	}

	/* Lock the "used" tree */
	mutex_enter(&hal->addr_space_used_mutex);

	/* Has the 1394 address been allocated? */
	addr_blk = s1394_used_tree_search(hal, req->cmd_addr);

	/* Is this a posted write request? */
	posted_write = s1394_is_posted_write(hal, req->cmd_addr);

	/* If it wasn't found, it isn't owned... */
	if (addr_blk == NULL) {
		req->cmd_result = IEEE1394_RESP_ADDRESS_ERROR;
		write_error	= B_TRUE;
		goto write_error_check;
	}

	/* Does the WHOLE request fit in the allocated block? */
	end_of_request = (req->cmd_addr + cmd_length) - 1;
	if (end_of_request > addr_blk->addr_hi) {
		req->cmd_result = IEEE1394_RESP_ADDRESS_ERROR;
		write_error	= B_TRUE;
		goto write_error_check;
	}

	/* Is a write request valid for this address space? */
	if (!(addr_blk->addr_enable & T1394_ADDR_WRENBL)) {
		req->cmd_result = IEEE1394_RESP_TYPE_ERROR;
		write_error	= B_TRUE;
		goto write_error_check;
	}

	/* Make sure quadlet request is quadlet aligned */
	offset = req->cmd_addr - addr_blk->addr_lo;
	if ((req->cmd_type == CMD1394_ASYNCH_WR_QUAD) &&
	    ((offset & 0x3) != 0)) {
		req->cmd_result = IEEE1394_RESP_TYPE_ERROR;
		write_error	= B_TRUE;
		goto write_error_check;
	}

write_error_check:
	/* Check if posted-write when sending error responses */
	if (write_error == B_TRUE) {
		/* Unlock the "used" tree */
		mutex_exit(&hal->addr_space_used_mutex);

		if (posted_write == B_TRUE) {
			/* Get a pointer to the HAL private struct */
			h_priv = (h1394_cmd_priv_t *)&s_priv->hal_cmd_private;
			hal->hal_kstats->arreq_posted_write_error++;
			/* Free the command - Pass it back to the HAL */
			HAL_CALL(hal).response_complete(
			    hal->halinfo.hal_private, req, h_priv);
			return;
		} else {
			(void) s1394_send_response(hal, req);
			return;
		}
	}

	/* Fill in the backing store if necessary */
	if (addr_blk->kmem_bufp != NULL) {
		offset = req->cmd_addr - addr_blk->addr_lo;
		bufp_addr = (uchar_t *)addr_blk->kmem_bufp + offset;
		switch (req->cmd_type) {
		case CMD1394_ASYNCH_WR_QUAD:
			bcopy((void *)&(req->cmd_u.q.quadlet_data),
			    (void *)bufp_addr, cmd_length);
			break;

		case CMD1394_ASYNCH_WR_BLOCK:
			begin_ptr = req->cmd_u.b.data_block->b_rptr;
			end_ptr = begin_ptr + cmd_length;
			tmp_ptr = req->cmd_u.b.data_block->b_wptr;
			if (end_ptr <= tmp_ptr) {
				bcopy((void *)begin_ptr, (void *)bufp_addr,
				    cmd_length);
			} else {
				dip = hal->halinfo.dip;

				/* An unexpected error in the HAL */
				cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
				    ddi_node_name(dip), ddi_get_instance(dip));

				/* Unlock the "used" tree */
				mutex_exit(&hal->addr_space_used_mutex);

				/* Disable the HAL */
				s1394_hal_shutdown(hal, B_TRUE);

				return;
			}
			break;

		default:
			dip = hal->halinfo.dip;

			/* An unexpected error in the HAL */
			cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
			    ddi_node_name(dip), ddi_get_instance(dip));

			/* Unlock the "used" tree */
			mutex_exit(&hal->addr_space_used_mutex);

			/* Disable the HAL */
			s1394_hal_shutdown(hal, B_TRUE);

			return;
		}
	}

	/* Fill in the rest of the info in the request */
	if (addr_blk->addr_type == T1394_ADDR_POSTED_WRITE)
		s_priv->posted_write = B_TRUE;

	s_priv->arreq_valid_addr = B_TRUE;
	req->cmd_callback_arg	 = addr_blk->addr_arg;
	recv_write_req		 = addr_blk->addr_events.recv_write_request;

	/* Unlock the "used" tree */
	mutex_exit(&hal->addr_space_used_mutex);

	/*
	 * Add no code that modifies the command after the target
	 * callback is called or after the response is sent to the
	 * HAL.
	 */
	if (recv_write_req != NULL) {
		recv_write_req(req);
	} else {
		req->cmd_result = IEEE1394_RESP_COMPLETE;
		(void) s1394_send_response(hal, req);
		return;
	}
}

/*
 * Function:    h1394_lock_request()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		req			The incoming AR request
 *
 * Output(s):	None
 *
 * Description:	h1394_lock_request() receives incoming AR requests.  These
 *		asynchronous lock requests are dispatched to the appropriate
 *		target (if one has registered) or are handled by the 1394
 *		Software Framework, which will send out an appropriate
 *		response.
 */
void
h1394_lock_request(void *sl_private, cmd1394_cmd_t *req)
{
	s1394_hal_t		*hal;
	s1394_cmd_priv_t	*s_priv;
	s1394_addr_space_blk_t	*addr_blk;
	dev_info_t		*dip;
	uint64_t		end_of_request;
	uint32_t		offset;
	uchar_t			*bufp_addr;
	cmd1394_lock_type_t	lock_type;
	void (*recv_lock_req)(cmd1394_cmd_t *);

	hal = (s1394_hal_t *)sl_private;

	/* Get the Services Layer private area */
	s_priv = S1394_GET_CMD_PRIV(req);

	s_priv->cmd_priv_xfer_type = S1394_CMD_LOCK;

	/* Lock the "used" tree */
	mutex_enter(&hal->addr_space_used_mutex);

	/* Has the 1394 address been allocated? */
	addr_blk = s1394_used_tree_search(hal, req->cmd_addr);

	/* If it wasn't found, it isn't owned... */
	if (addr_blk == NULL) {
		/* Unlock the "used" tree */
		mutex_exit(&hal->addr_space_used_mutex);
		req->cmd_result = IEEE1394_RESP_ADDRESS_ERROR;
		(void) s1394_send_response(hal, req);
		return;
	}

	/* Does the WHOLE request fit in the allocated block? */
	switch (req->cmd_type) {
	case CMD1394_ASYNCH_LOCK_32:
		end_of_request = (req->cmd_addr + IEEE1394_QUADLET) - 1;
		/* kstats - 32-bit lock request */
		hal->hal_kstats->arreq_lock32++;
		break;

	case CMD1394_ASYNCH_LOCK_64:
		end_of_request = (req->cmd_addr + IEEE1394_OCTLET) - 1;
		/* kstats - 64-bit lock request */
		hal->hal_kstats->arreq_lock64++;
		break;

	default:
		/* Unlock the "used" tree */
		mutex_exit(&hal->addr_space_used_mutex);

		dip = hal->halinfo.dip;

		/* An unexpected error in the HAL */
		cmn_err(CE_WARN, HALT_ERROR_MESSAGE,
		    ddi_node_name(dip), ddi_get_instance(dip));

		/* Disable the HAL */
		s1394_hal_shutdown(hal, B_TRUE);

		return;
	}

	if (end_of_request > addr_blk->addr_hi) {
		/* Unlock the "used" tree */
		mutex_exit(&hal->addr_space_used_mutex);
		req->cmd_result = IEEE1394_RESP_ADDRESS_ERROR;
		(void) s1394_send_response(hal, req);
		return;
	}

	/* Is a lock request valid for this address space? */
	if (!(addr_blk->addr_enable & T1394_ADDR_LKENBL)) {
		/* Unlock the "used" tree */
		mutex_exit(&hal->addr_space_used_mutex);
		req->cmd_result = IEEE1394_RESP_TYPE_ERROR;
		(void) s1394_send_response(hal, req);
		return;
	}

	/* Fill in the backing store if necessary */
	if (addr_blk->kmem_bufp != NULL) {
		offset = req->cmd_addr - addr_blk->addr_lo;
		bufp_addr = (uchar_t *)addr_blk->kmem_bufp + offset;

		if (req->cmd_type == CMD1394_ASYNCH_LOCK_32) {
			uint32_t	old_value;
			uint32_t	arg_value;
			uint32_t	data_value;
			uint32_t	new_value;

			arg_value	= req->cmd_u.l32.arg_value;
			data_value	= req->cmd_u.l32.data_value;
			lock_type	= req->cmd_u.l32.lock_type;
			bcopy((void *)bufp_addr, (void *)&old_value,
			    IEEE1394_QUADLET);

			switch (lock_type) {
			case CMD1394_LOCK_MASK_SWAP:
				/* Mask-Swap (see P1394A - Table 1.7) */
				new_value = (data_value & arg_value) |
				    (old_value & ~arg_value);
				/* Copy new_value into backing store */
				bcopy((void *)&new_value, (void *)bufp_addr,
				    IEEE1394_QUADLET);
				req->cmd_u.l32.old_value = old_value;
				break;

			case CMD1394_LOCK_COMPARE_SWAP:
				/* Compare-Swap */
				if (old_value == arg_value) {
					new_value = data_value;
					/* Copy new_value into backing store */
					bcopy((void *)&new_value,
					    (void *)bufp_addr,
					    IEEE1394_QUADLET);
				}
				req->cmd_u.l32.old_value = old_value;
				break;

			case CMD1394_LOCK_FETCH_ADD:
				/* Fetch-Add (see P1394A - Table 1.7) */
				old_value = T1394_DATA32(old_value);
				new_value = old_value + data_value;
				new_value = T1394_DATA32(new_value);
				/* Copy new_value into backing store */
				bcopy((void *)&new_value, (void *)bufp_addr,
				    IEEE1394_QUADLET);
				req->cmd_u.l32.old_value = old_value;
				break;

			case CMD1394_LOCK_LITTLE_ADD:
				/* Little-Add (see P1394A - Table 1.7) */
				old_value = T1394_DATA32(old_value);
				new_value = old_value + data_value;
				new_value = T1394_DATA32(new_value);
				/* Copy new_value into backing store */
				bcopy((void *)&new_value, (void *)bufp_addr,
				    IEEE1394_QUADLET);
				req->cmd_u.l32.old_value = old_value;
				break;

			case CMD1394_LOCK_BOUNDED_ADD:
				/* Bounded-Add (see P1394A - Table 1.7) */
				old_value = T1394_DATA32(old_value);
				if (old_value != arg_value) {
					new_value = old_value + data_value;
					new_value = T1394_DATA32(new_value);
					/* Copy new_value into backing store */
					bcopy((void *)&new_value,
					    (void *)bufp_addr,
					    IEEE1394_QUADLET);
				}
				req->cmd_u.l32.old_value = old_value;
				break;

			case CMD1394_LOCK_WRAP_ADD:
				/* Wrap-Add (see P1394A - Table 1.7) */
				old_value = T1394_DATA32(old_value);
				if (old_value != arg_value) {
					new_value = old_value + data_value;
				} else {
					new_value = data_value;
				}
				new_value = T1394_DATA32(new_value);
				/* Copy new_value into backing store */
				bcopy((void *)&new_value, (void *)bufp_addr,
				    IEEE1394_QUADLET);
				req->cmd_u.l32.old_value = old_value;
				break;

			default:
				/* Unlock the "used" tree */
				mutex_exit(&hal->addr_space_used_mutex);
				req->cmd_result = IEEE1394_RESP_TYPE_ERROR;
				(void) s1394_send_response(hal, req);
				return;
			}
		} else {
			/* Handling for the 8-byte (64-bit) lock requests */
			uint64_t	old_value;
			uint64_t	arg_value;
			uint64_t	data_value;
			uint64_t	new_value;

			arg_value	= req->cmd_u.l64.arg_value;
			data_value	= req->cmd_u.l64.data_value;
			lock_type	= req->cmd_u.l64.lock_type;
			bcopy((void *)bufp_addr, (void *)&old_value,
			    IEEE1394_OCTLET);

			switch (lock_type) {
			case CMD1394_LOCK_MASK_SWAP:
				/* Mask-Swap (see P1394A - Table 1.7) */
				new_value = (data_value & arg_value) |
				    (old_value & ~arg_value);
				/* Copy new_value into backing store */
				bcopy((void *)&new_value, (void *)bufp_addr,
				    IEEE1394_OCTLET);
				req->cmd_u.l64.old_value = old_value;
				break;

			case CMD1394_LOCK_COMPARE_SWAP:
				/* Compare-Swap */
				if (old_value == arg_value) {
					new_value = data_value;
					/* Copy new_value into backing store */
					bcopy((void *)&new_value,
					    (void *)bufp_addr,
					    IEEE1394_OCTLET);
				}
				req->cmd_u.l64.old_value = old_value;
				break;

			case CMD1394_LOCK_FETCH_ADD:
				/* Fetch-Add (see P1394A - Table 1.7) */
				old_value = T1394_DATA64(old_value);
				new_value = old_value + data_value;
				new_value = T1394_DATA64(new_value);
				/* Copy new_value into backing store */
				bcopy((void *)&new_value, (void *)bufp_addr,
				    IEEE1394_OCTLET);
				req->cmd_u.l64.old_value = old_value;
				break;

			case CMD1394_LOCK_LITTLE_ADD:
				/* Little-Add (see P1394A - Table 1.7) */
				old_value = T1394_DATA64(old_value);
				new_value = old_value + data_value;
				new_value = T1394_DATA64(new_value);
				/* Copy new_value into backing store */
				bcopy((void *)&new_value, (void *)bufp_addr,
				    IEEE1394_OCTLET);
				req->cmd_u.l64.old_value = old_value;
				break;

			case CMD1394_LOCK_BOUNDED_ADD:
				/* Bounded-Add (see P1394A - Table 1.7) */
				old_value = T1394_DATA64(old_value);
				if (old_value != arg_value) {
					new_value = old_value + data_value;
					new_value = T1394_DATA64(new_value);
					/* Copy new_value into backing store */
					bcopy((void *)&new_value,
					    (void *)bufp_addr,
					    IEEE1394_OCTLET);
				}
				req->cmd_u.l64.old_value = old_value;
				break;

			case CMD1394_LOCK_WRAP_ADD:
				/* Wrap-Add (see P1394A - Table 1.7) */
				old_value = T1394_DATA64(old_value);
				if (old_value != arg_value) {
					new_value = old_value + data_value;
				} else {
					new_value = data_value;
				}
				new_value = T1394_DATA64(new_value);
				/* Copy new_value into backing store */
				bcopy((void *)&new_value, (void *)bufp_addr,
				    IEEE1394_OCTLET);
				req->cmd_u.l64.old_value = old_value;
				break;

			default:
				/* Unlock the "used" tree */
				mutex_exit(&hal->addr_space_used_mutex);
				req->cmd_result = IEEE1394_RESP_TYPE_ERROR;
				(void) s1394_send_response(hal, req);
				return;
			}
		}
	}

	/* Fill in the rest of the info in the request */
	s_priv->arreq_valid_addr = B_TRUE;
	req->cmd_callback_arg	 = addr_blk->addr_arg;
	recv_lock_req		 = addr_blk->addr_events.recv_lock_request;

	/* Unlock the "used" tree */
	mutex_exit(&hal->addr_space_used_mutex);

	/*
	 * Add no code that modifies the command after the target
	 * callback is called or after the response is sent to the
	 * HAL.
	 */
	if (recv_lock_req != NULL) {
		recv_lock_req(req);
	} else {
		req->cmd_result = IEEE1394_RESP_COMPLETE;
		(void) s1394_send_response(hal, req);
		return;
	}
}

/*
 * Function:    h1394_ioctl()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		cmd			ioctl cmd
 *		arg			argument for the ioctl cmd
 *		mode			mode bits (see ioctl(9e))
 *		cred_p			cred structure pointer
 *		rval_p			pointer to return value (see ioctl(9e))
 *
 * Output(s):	EINVAL if not a DEVCTL ioctl, else return value from s1394_ioctl
 *
 * Description:	h1394_ioctl() implements non-HAL specific ioctls. Currently,
 *		DEVCTL ioctls are the only generic ioctls supported.
 */
int
h1394_ioctl(void *sl_private, int cmd, intptr_t arg, int mode, cred_t *cred_p,
    int *rval_p)
{
	int	status;

	if ((cmd & DEVCTL_IOC) != DEVCTL_IOC)
		return (EINVAL);

	status = s1394_ioctl((s1394_hal_t *)sl_private, cmd, arg, mode,
	    cred_p, rval_p);

	return (status);
}

/*
 * Function:    h1394_phy_packet()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		packet_data		Pointer to a buffer of packet data
 *		quadlet_count		Length of the buffer
 *		timestamp		Timestamp indicating time of arrival
 *
 * Output(s):	None
 *
 * Description:	h1394_phy_packet() is not implemented currently, but would
 *		be used to process the responses to PHY ping packets in P1394A
 *		When one is sent out, a timestamp is given indicating its time
 *		of departure. Comparing that old timestamp with this new
 *		timestamp, we can determine the time of flight and can use
 *		those times to optimize the gap count.
 */
/* ARGSUSED */
void
h1394_phy_packet(void *sl_private, uint32_t *packet_data, uint_t quadlet_count,
	uint_t timestamp)
{
	/* This interface is not yet implemented */
}

/*
 * Function:    h1394_error_detected()
 * Input(s):    sl_private		The HAL "handle" returned by
 *					    h1394_attach()
 *		type			The type of error the HAL detected
 *		arg			Pointer to any extra information
 *
 * Output(s):	None
 *
 * Description:	h1394_error_detected() is used by the HAL to report errors
 *		to the 1394 Software Framework.
 */
void
h1394_error_detected(void *sl_private, h1394_error_t type, void *arg)
{
	s1394_hal_t	*hal;
	uint_t		hal_node_num;
	uint_t		IRM_node_num;

	hal = (s1394_hal_t *)sl_private;

	switch (type) {
	case H1394_LOCK_RESP_ERR:
		/* If we are the IRM, then initiate a bus reset */
		mutex_enter(&hal->topology_tree_mutex);
		hal_node_num = IEEE1394_NODE_NUM(hal->node_id);
		IRM_node_num = hal->IRM_node;
		mutex_exit(&hal->topology_tree_mutex);
		if (IRM_node_num == hal_node_num)
			s1394_initiate_hal_reset(hal, NON_CRITICAL);
		break;

	case H1394_POSTED_WR_ERR:
		break;

	case H1394_SELF_INITIATED_SHUTDOWN:
		s1394_hal_shutdown(hal, B_FALSE);
		break;

	case H1394_CYCLE_TOO_LONG:
		/* Set a timer to become cycle master after 1 second */
		mutex_enter(&hal->cm_timer_mutex);
		hal->cm_timer_set = B_TRUE;
		mutex_exit(&hal->cm_timer_mutex);
		hal->cm_timer = timeout(s1394_cycle_too_long_callback, hal,
		    drv_usectohz(CYCLE_MASTER_TIMER * 1000));

		break;

	default:
		break;
	}
}