/*
 * 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 (c) 1999-2000 by Sun Microsystems, Inc.
 * All rights reserved.
 */

/*
 * s1394_isoch.c
 *    1394 Services Layer Isochronous Communication Routines
 *    This file contains routines for managing isochronous bandwidth
 *    and channel needs for registered targets (through the target
 *    isoch interfaces).
 */

#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/sunddi.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>

/*
 * s1394_isoch_rsrc_realloc()
 *    is called during bus reset processing to reallocate any isochronous
 *    resources that were previously allocated.
 */
void
s1394_isoch_rsrc_realloc(s1394_hal_t *hal)
{
        s1394_isoch_cec_t *cec_curr;
        uint32_t          chnl_mask;
        uint32_t          old_chnl_mask;
        uint_t            bw_alloc_units;
        uint_t            generation;
        uint_t            chnl_num;
        int               err;
        int               ret;

        /*
         * Get the current generation number - don't need the
         * topology tree mutex here because it is read-only, and
         * there is a race condition with or without it.
         */
        generation = hal->generation_count;

        /* Lock the Isoch CEC list */
        mutex_enter(&hal->isoch_cec_list_mutex);

        cec_curr = hal->isoch_cec_list_head;
        while (cec_curr != NULL) {
                /* Lock the Isoch CEC member list */
                mutex_enter(&cec_curr->isoch_cec_mutex);

                /* Are we supposed to reallocate resources? */
                if (!(cec_curr->cec_options & T1394_NO_IRM_ALLOC) &&
                    (cec_curr->realloc_valid == B_TRUE) &&
                    (cec_curr->realloc_failed == B_FALSE)) {

                        /* Reallocate some bandwidth */
                        bw_alloc_units = s1394_compute_bw_alloc_units(hal,
                            cec_curr->bandwidth, cec_curr->realloc_speed);

                        /* Check that the generation has not changed */
                        if (generation != hal->generation_count) {
                                /* Try the next Isoch CEC */
                                goto next_isoch_cec;
                        }

                        /* Unlock the Isoch CEC member list */
                        mutex_exit(&cec_curr->isoch_cec_mutex);
                        /*
                         * We can unlock the Isoch CEC list here
                         * because we know this Isoch CEC can not
                         * go away (we are trying to realloc its
                         * resources so it can't be in a state that
                         * will allow a free).
                         */
                        mutex_exit(&hal->isoch_cec_list_mutex);

                        /* Try to reallocate bandwidth */
                        ret = s1394_bandwidth_alloc(hal, bw_alloc_units,
                            generation, &err);

                        /* Lock the Isoch CEC list */
                        mutex_enter(&hal->isoch_cec_list_mutex);
                        /* Lock the Isoch CEC member list */
                        mutex_enter(&cec_curr->isoch_cec_mutex);

                        /* If we failed because we couldn't get bandwidth */
                        if (ret == DDI_FAILURE) {
                                cec_curr->realloc_failed = B_TRUE;
                                cec_curr->realloc_fail_reason =
                                    T1394_RSRC_BANDWIDTH;
                        }
                }

                /* Are we supposed to reallocate resources? */
                if (!(cec_curr->cec_options & T1394_NO_IRM_ALLOC) &&
                    (cec_curr->realloc_valid == B_TRUE) &&
                    (cec_curr->realloc_failed == B_FALSE)) {

                        /* Reallocate the channel */
                        chnl_num  = cec_curr->realloc_chnl_num;
                        chnl_mask = (1 << ((63 - chnl_num) % 32));

                        /* Unlock the Isoch CEC member list */
                        mutex_exit(&cec_curr->isoch_cec_mutex);
                        /*
                         * We can unlock the Isoch CEC list here
                         * because we know this Isoch CEC can not
                         * go away (we are trying to realloc its
                         * resources so it can't be in a state that
                         * will allow a free).
                         */
                        mutex_exit(&hal->isoch_cec_list_mutex);

                        if (chnl_num < 32) {
                                ret = s1394_channel_alloc(hal, chnl_mask,
                                    generation, S1394_CHANNEL_ALLOC_HI,
                                    &old_chnl_mask, &err);
                        } else {
                                ret = s1394_channel_alloc(hal, chnl_mask,
                                    generation, S1394_CHANNEL_ALLOC_LO,
                                    &old_chnl_mask, &err);
                        }

                        /* Lock the Isoch CEC list */
                        mutex_enter(&hal->isoch_cec_list_mutex);
                        /* Lock the Isoch CEC member list */
                        mutex_enter(&cec_curr->isoch_cec_mutex);

                        if (ret == DDI_FAILURE) {
                                if (err != CMD1394_EBUSRESET) {
                                        /*
                                         * If we successfully reallocate
                                         * bandwidth, and then fail getting
                                         * the channel, we need to free up
                                         * the bandwidth
                                         */

                                        /* Try to free up the bandwidth */
                                        ret = s1394_bandwidth_free(hal,
                                            bw_alloc_units, generation, &err);
                                        /* Try the next Isoch CEC */
                                        goto next_isoch_cec;
                                }
                                cec_curr->realloc_failed = B_TRUE;
                                cec_curr->realloc_fail_reason =
                                    T1394_RSRC_CHANNEL;
                        }
                }
next_isoch_cec:
                /* Unlock the Isoch CEC member list */
                mutex_exit(&cec_curr->isoch_cec_mutex);
                cec_curr = cec_curr->cec_next;
        }

        /* Unlock the Isoch CEC list */
        mutex_exit(&hal->isoch_cec_list_mutex);
}

/*
 * s1394_isoch_rsrc_realloc_notify()
 *    is called during bus reset processing to notify all targets for
 *    which isochronous resources were not able to be reallocated.
 */
void
s1394_isoch_rsrc_realloc_notify(s1394_hal_t *hal)
{
        s1394_isoch_cec_t        *cec_curr;
        s1394_isoch_cec_member_t *member_curr;
        t1394_isoch_rsrc_error_t fail_arg;
        opaque_t                 evts_arg;
        s1394_isoch_cec_type_t   type;
        void (*rsrc_fail_callback)(t1394_isoch_cec_handle_t, opaque_t,
                                t1394_isoch_rsrc_error_t);

        /* Lock the Isoch CEC list */
        mutex_enter(&hal->isoch_cec_list_mutex);

        /* Notify all targets that failed realloc */
        cec_curr = hal->isoch_cec_list_head;
        while (cec_curr != NULL) {
                /* Lock the Isoch CEC member list */
                mutex_enter(&cec_curr->isoch_cec_mutex);

                /* Do we notify of realloc failure? */
                if (!(cec_curr->cec_options & T1394_NO_IRM_ALLOC) &&
                    (cec_curr->realloc_valid == B_TRUE) &&
                    (cec_curr->realloc_failed == B_TRUE)) {

                        /* Reason for realloc failure */
                        fail_arg = cec_curr->realloc_fail_reason;

                        /* Now we are going into the callbacks */
                        cec_curr->in_fail_callbacks = B_TRUE;

                        type = cec_curr->cec_type;

                        /* Unlock the Isoch CEC member list */
                        mutex_exit(&cec_curr->isoch_cec_mutex);
                        /*
                         * We can unlock the Isoch CEC list here
                         * because we have the in_fail_callbacks
                         * field set to B_TRUE.  And free will fail
                         * if we are in fail callbacks.
                         */
                        mutex_exit(&hal->isoch_cec_list_mutex);

                        /* Call all of the rsrc_fail_target() callbacks */
                        /* Start at the head (talker first) and */
                        /* go toward the tail (listeners last) */
                        member_curr = cec_curr->cec_member_list_head;
                        while (member_curr != NULL) {
                                rsrc_fail_callback = member_curr->
                                    isoch_cec_evts.rsrc_fail_target;
                                evts_arg = member_curr->isoch_cec_evts_arg;
                                if (rsrc_fail_callback != NULL) {

                                        if (type == S1394_PEER_TO_PEER) {
                                                rsrc_fail_callback(
                                                    (t1394_isoch_cec_handle_t)
                                                    cec_curr, evts_arg,
                                                    fail_arg);
                                        } else {
                                                rsrc_fail_callback(
                                                    (t1394_isoch_cec_handle_t)
                                                    cec_curr, evts_arg,
                                                    fail_arg);
                                        }
                                }
                                member_curr = member_curr->cec_mem_next;
                        }

                        /* Lock the Isoch CEC list */
                        mutex_enter(&hal->isoch_cec_list_mutex);
                        /* Lock the Isoch CEC member list */
                        mutex_enter(&cec_curr->isoch_cec_mutex);

                        /* We are finished with the callbacks */
                        cec_curr->in_fail_callbacks = B_FALSE;
                        if (cec_curr->cec_want_wakeup == B_TRUE) {
                                cec_curr->cec_want_wakeup = B_FALSE;
                                cv_broadcast(&cec_curr->in_callbacks_cv);
                        }

                        /* Set flags back to original state */
                        cec_curr->realloc_valid  = B_FALSE;
                        cec_curr->realloc_failed = B_FALSE;
                }
                /* Unlock the Isoch CEC member list */
                mutex_exit(&cec_curr->isoch_cec_mutex);
                cec_curr = cec_curr->cec_next;
        }

        /* Unlock the Isoch CEC list */
        mutex_exit(&hal->isoch_cec_list_mutex);
}

/*
 * s1394_channel_alloc()
 *    is used to allocate an isochronous channel.  A channel mask and
 *    generation are passed.  A request is sent to whichever node is the
 *    IRM for the appropriate channels.  If it fails because of a bus
 *    reset it can be retried.  If it fails for another reason the
 *    channel(s) may not be availble or there may be no IRM.
 */
int
s1394_channel_alloc(s1394_hal_t *hal, uint32_t channel_mask, uint_t generation,
    uint_t flags, uint32_t *old_channels, int *result)
{
        cmd1394_cmd_t   *cmd;
        uint64_t        IRM_ID_addr;
        uint32_t        compare;
        uint32_t        swap;
        uint32_t        old_value;
        uint_t          hal_node_num;
        uint_t          IRM_node;
        uint_t          offset;
        int             ret;
        int             i;
        int             num_retries = S1394_ISOCH_ALLOC_RETRIES;

        /* Lock the topology tree */
        mutex_enter(&hal->topology_tree_mutex);

        hal_node_num = IEEE1394_NODE_NUM(hal->node_id);
        IRM_node = hal->IRM_node;

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

        /* Make sure there is a valid IRM on the bus */
        if (IRM_node == -1) {
                *result = CMD1394_ERETRIES_EXCEEDED;
                return (DDI_FAILURE);
        }

        if (flags & S1394_CHANNEL_ALLOC_HI) {
                offset =
                    (IEEE1394_SCSR_CHANS_AVAIL_HI & IEEE1394_CSR_OFFSET_MASK);
        } else {
                offset =
                    (IEEE1394_SCSR_CHANS_AVAIL_LO & IEEE1394_CSR_OFFSET_MASK);
        }

        /* Send compare-swap to CHANNELS_AVAILABLE */
        /* register on the Isoch Rsrc Mgr */
        if (IRM_node == hal_node_num) {
                /* Local */
                i = num_retries;
                do {
                        (void) HAL_CALL(hal).csr_read(hal->halinfo.hal_private,
                            offset, &old_value);

                        /* Check that the generation has not changed */
                        if (generation != hal->generation_count) {
                                *result = CMD1394_EBUSRESET;
                                return (DDI_FAILURE);
                        }

                        compare = old_value;
                        swap    = old_value & (~channel_mask);

                        ret = HAL_CALL(hal).csr_cswap32(
                            hal->halinfo.hal_private, generation,
                            offset, compare, swap, &old_value);
                        if (ret != DDI_SUCCESS) {
                                *result = CMD1394_EBUSRESET;
                                return (DDI_FAILURE);
                        }

                        if ((~old_value & channel_mask) != 0) {
                                *result = CMD1394_ERETRIES_EXCEEDED;
                                return (DDI_FAILURE);
                        }

                        if (old_value == compare) {
                                *result = CMD1394_CMDSUCCESS;
                                *old_channels = old_value;

                                return (DDI_SUCCESS);
                        }
                } while (i--);

                *result = CMD1394_ERETRIES_EXCEEDED;
                return (DDI_FAILURE);

        } else {
                /* Remote */
                if (s1394_alloc_cmd(hal, 0, &cmd) != DDI_SUCCESS) {
                        *result = CMD1394_EUNKNOWN_ERROR;
                        return (DDI_FAILURE);
                }

                cmd->cmd_options = (CMD1394_CANCEL_ON_BUS_RESET |
                    CMD1394_OVERRIDE_ADDR | CMD1394_BLOCKING);
                cmd->cmd_type = CMD1394_ASYNCH_LOCK_32;

                if (flags & S1394_CHANNEL_ALLOC_HI) {
                        IRM_ID_addr = (IEEE1394_ADDR_BUS_ID_MASK |
                            IEEE1394_SCSR_CHANS_AVAIL_HI) |
                            (((uint64_t)IRM_node) <<
                            IEEE1394_ADDR_PHY_ID_SHIFT);
                } else {
                        IRM_ID_addr = (IEEE1394_ADDR_BUS_ID_MASK |
                            IEEE1394_SCSR_CHANS_AVAIL_LO) |
                            (((uint64_t)IRM_node) <<
                            IEEE1394_ADDR_PHY_ID_SHIFT);
                }

                cmd->cmd_addr              = IRM_ID_addr;
                cmd->bus_generation        = generation;
                cmd->cmd_u.l32.data_value  = T1394_DATA32(~channel_mask);
                cmd->cmd_u.l32.num_retries = num_retries;
                cmd->cmd_u.l32.lock_type   = CMD1394_LOCK_BIT_AND;

                ret = s1394_split_lock_req(hal, NULL, cmd);

                if (ret == DDI_SUCCESS) {
                        if (cmd->cmd_result == CMD1394_CMDSUCCESS) {
                                *old_channels = T1394_DATA32(
                                    cmd->cmd_u.l32.old_value);

                                if ((~(*old_channels) & channel_mask) != 0) {
                                        *result = CMD1394_ERETRIES_EXCEEDED;
                                        ret = DDI_FAILURE;
                                } else {
                                        *result = cmd->cmd_result;
                                }

                                /* Need to free the command */
                                (void) s1394_free_cmd(hal, &cmd);

                                return (ret);

                        } else {
                                *result = cmd->cmd_result;
                                /* Need to free the command */
                                (void) s1394_free_cmd(hal, &cmd);

                                return (DDI_FAILURE);
                        }
                } else {
                        *result = cmd->cmd_result;

                        /* Need to free the command */
                        (void) s1394_free_cmd(hal, &cmd);

                        return (DDI_FAILURE);
                }
        }
}

/*
 * s1394_channel_free()
 *    is used to free up an isochronous channel.  A channel mask and
 *    generation are passed.  A request is sent to whichever node is the
 *    IRM for the appropriate channels.  If it fails because of a bus
 *    reset it can be retried.  If it fails for another reason the
 *    channel(s) may already be free or there may be no IRM.
 */
int
s1394_channel_free(s1394_hal_t *hal, uint32_t channel_mask, uint_t generation,
    uint_t flags, uint32_t *old_channels, int *result)
{
        cmd1394_cmd_t   *cmd;
        uint64_t        IRM_ID_addr;
        uint32_t        compare;
        uint32_t        swap;
        uint32_t        old_value;
        uint_t          hal_node_num;
        uint_t          IRM_node;
        uint_t          offset;
        int             ret;
        int             i;
        int             num_retries = S1394_ISOCH_ALLOC_RETRIES;

        /* Lock the topology tree */
        mutex_enter(&hal->topology_tree_mutex);

        hal_node_num = IEEE1394_NODE_NUM(hal->node_id);
        IRM_node = hal->IRM_node;

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

        /* Make sure there is a valid IRM on the bus */
        if (IRM_node == -1) {
                *result = CMD1394_ERETRIES_EXCEEDED;
                return (DDI_FAILURE);
        }

        if (flags & S1394_CHANNEL_ALLOC_HI) {
                offset =
                    (IEEE1394_SCSR_CHANS_AVAIL_HI & IEEE1394_CSR_OFFSET_MASK);
        } else {
                offset =
                    (IEEE1394_SCSR_CHANS_AVAIL_LO & IEEE1394_CSR_OFFSET_MASK);
        }

        /* Send compare-swap to CHANNELS_AVAILABLE */
        /* register on the Isoch Rsrc Mgr */
        if (hal->IRM_node == hal_node_num) {
                /* Local */
                i = num_retries;
                do {
                        (void) HAL_CALL(hal).csr_read(hal->halinfo.hal_private,
                            offset, &old_value);

                        /* Check that the generation has not changed */
                        if (generation != hal->generation_count) {
                                *result = CMD1394_EBUSRESET;
                                return (DDI_FAILURE);
                        }

                        compare = old_value;
                        swap    = old_value | channel_mask;

                        ret = HAL_CALL(hal).csr_cswap32(
                            hal->halinfo.hal_private, hal->generation_count,
                            offset, compare, swap, &old_value);
                        if (ret != DDI_SUCCESS) {
                                *result = CMD1394_EBUSRESET;
                                return (DDI_FAILURE);
                        }

                        if (old_value == compare) {
                                *result = CMD1394_CMDSUCCESS;
                                *old_channels = old_value;
                                return (DDI_SUCCESS);
                        }
                } while (i--);

                *result = CMD1394_ERETRIES_EXCEEDED;
                return (DDI_FAILURE);

        } else {
                /* Remote */
                if (s1394_alloc_cmd(hal, 0, &cmd) != DDI_SUCCESS) {
                        *result = CMD1394_EUNKNOWN_ERROR;
                        return (DDI_FAILURE);
                }

                cmd->cmd_options = (CMD1394_CANCEL_ON_BUS_RESET |
                    CMD1394_OVERRIDE_ADDR | CMD1394_BLOCKING);
                cmd->cmd_type = CMD1394_ASYNCH_LOCK_32;

                if (flags & S1394_CHANNEL_ALLOC_HI) {
                        IRM_ID_addr = (IEEE1394_ADDR_BUS_ID_MASK |
                            IEEE1394_SCSR_CHANS_AVAIL_HI) |
                            (((uint64_t)IRM_node) <<
                            IEEE1394_ADDR_PHY_ID_SHIFT);
                } else {
                        IRM_ID_addr = (IEEE1394_ADDR_BUS_ID_MASK |
                            IEEE1394_SCSR_CHANS_AVAIL_LO) |
                            (((uint64_t)IRM_node) <<
                            IEEE1394_ADDR_PHY_ID_SHIFT);
                }

                cmd->cmd_addr              = IRM_ID_addr;
                cmd->bus_generation        = generation;
                cmd->cmd_u.l32.data_value  = T1394_DATA32(channel_mask);
                cmd->cmd_u.l32.num_retries = num_retries;
                cmd->cmd_u.l32.lock_type   = CMD1394_LOCK_BIT_OR;

                ret = s1394_split_lock_req(hal, NULL, cmd);

                if (ret == DDI_SUCCESS) {
                        if (cmd->cmd_result == CMD1394_CMDSUCCESS) {

                                *old_channels = T1394_DATA32(
                                    cmd->cmd_u.l32.old_value);
                                *result = cmd->cmd_result;

                                /* Need to free the command */
                                (void) s1394_free_cmd(hal, &cmd);

                                return (DDI_SUCCESS);

                        } else {
                                *result = cmd->cmd_result;

                                /* Need to free the command */
                                (void) s1394_free_cmd(hal, &cmd);

                                return (DDI_FAILURE);
                        }
                } else {
                        *result = cmd->cmd_result;
                        /* Need to free the command */
                        (void) s1394_free_cmd(hal, &cmd);

                        return (DDI_FAILURE);
                }
        }
}

/*
 * s1394_bandwidth_alloc()
 *    is used to allocate isochronous bandwidth.  A number of bandwidth
 *    allocation units and a generation are passed.  The request is sent
 *    to whichever node is the IRM for this amount of bandwidth.  If it
 *    fails because of a bus reset it can be retried.  If it fails for
 *    another reason the bandwidth may not be available or there may be
 *    no IRM.
 */
int
s1394_bandwidth_alloc(s1394_hal_t *hal, uint32_t bw_alloc_units,
    uint_t generation, int *result)
{
        cmd1394_cmd_t   *cmd;
        uint64_t        IRM_ID_addr;
        uint32_t        compare;
        uint32_t        swap;
        uint32_t        old_value;
        uint_t          hal_node_num;
        uint_t          IRM_node;
        int             temp_value;
        int             ret;
        int             i;
        int             num_retries = S1394_ISOCH_ALLOC_RETRIES;

        /* Lock the topology tree */
        mutex_enter(&hal->topology_tree_mutex);

        hal_node_num = IEEE1394_NODE_NUM(hal->node_id);
        IRM_node = hal->IRM_node;

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

        /* Make sure there is a valid IRM on the bus */
        if (IRM_node == -1) {
                *result = CMD1394_ERETRIES_EXCEEDED;
                return (DDI_FAILURE);
        }

        /* Send compare-swap to BANDWIDTH_AVAILABLE */
        /* register on the Isoch Rsrc Mgr */
        if (IRM_node == hal_node_num) {
                /* Local */
                i = num_retries;
                do {
                        (void) HAL_CALL(hal).csr_read(hal->halinfo.hal_private,
                            (IEEE1394_SCSR_BANDWIDTH_AVAIL &
                            IEEE1394_CSR_OFFSET_MASK), &old_value);
                        /*
                         * Check that the generation has not changed -
                         * don't need the lock (read-only)
                         */
                        if (generation != hal->generation_count) {
                                *result = CMD1394_EBUSRESET;
                                return (DDI_FAILURE);
                        }

                        temp_value = (old_value - bw_alloc_units);
                        if ((old_value >= bw_alloc_units) &&
                            (temp_value >= IEEE1394_BANDWIDTH_MIN)) {
                                compare = old_value;
                                swap    = (uint32_t)temp_value;
                        } else {
                                *result = CMD1394_ERETRIES_EXCEEDED;
                                return (DDI_FAILURE);
                        }

                        ret = HAL_CALL(hal).csr_cswap32(
                            hal->halinfo.hal_private, generation,
                            (IEEE1394_SCSR_BANDWIDTH_AVAIL &
                            IEEE1394_CSR_OFFSET_MASK), compare, swap,
                            &old_value);
                        if (ret != DDI_SUCCESS) {
                                *result = CMD1394_EBUSRESET;
                                return (DDI_FAILURE);
                        }

                        if (old_value == compare) {
                                *result = CMD1394_CMDSUCCESS;
                                return (DDI_SUCCESS);
                        }
                } while (i--);

                *result = CMD1394_ERETRIES_EXCEEDED;
                return (DDI_FAILURE);

        } else {
                /* Remote */
                if (s1394_alloc_cmd(hal, 0, &cmd) != DDI_SUCCESS) {
                        *result = CMD1394_EUNKNOWN_ERROR;
                        return (DDI_FAILURE);
                }

                cmd->cmd_options = (CMD1394_CANCEL_ON_BUS_RESET |
                    CMD1394_OVERRIDE_ADDR | CMD1394_BLOCKING);
                cmd->cmd_type = CMD1394_ASYNCH_LOCK_32;
                IRM_ID_addr = (IEEE1394_ADDR_BUS_ID_MASK |
                    IEEE1394_SCSR_BANDWIDTH_AVAIL) | (((uint64_t)IRM_node) <<
                    IEEE1394_ADDR_PHY_ID_SHIFT);
                cmd->cmd_addr              = IRM_ID_addr;
                cmd->bus_generation        = generation;
                cmd->cmd_u.l32.arg_value   = 0;
                cmd->cmd_u.l32.data_value  = bw_alloc_units;
                cmd->cmd_u.l32.num_retries = num_retries;
                cmd->cmd_u.l32.lock_type   = CMD1394_LOCK_THRESH_SUBTRACT;

                ret = s1394_split_lock_req(hal, NULL, cmd);

                if (ret == DDI_SUCCESS) {
                        if (cmd->cmd_result == CMD1394_CMDSUCCESS) {
                                *result = cmd->cmd_result;
                                /* Need to free the command */
                                (void) s1394_free_cmd(hal, &cmd);

                                return (DDI_SUCCESS);

                        } else {
                                *result = cmd->cmd_result;
                                /* Need to free the command */
                                (void) s1394_free_cmd(hal, &cmd);

                                return (DDI_FAILURE);
                        }
                } else {
                        *result = cmd->cmd_result;
                        /* Need to free the command */
                        (void) s1394_free_cmd(hal, &cmd);

                        return (DDI_FAILURE);
                }
        }
}

/*
 * s1394_compute_bw_alloc_units()
 *    is used to compute the number of "bandwidth allocation units" that
 *    are necessary for a given bit rate.  It calculates the overhead
 *    necessary for isoch packet headers, bus arbitration, etc.  (See
 *    IEEE 1394-1995 Section 8.3.2.3.7 for an explanation of what a
 *    "bandwidth allocation unit" is.
 */
uint_t
s1394_compute_bw_alloc_units(s1394_hal_t *hal, uint_t bandwidth, uint_t speed)
{
        uint_t  total_quads;
        uint_t  speed_factor;
        uint_t  bau;
        int     max_hops;

        /* Lock the topology tree */
        mutex_enter(&hal->topology_tree_mutex);

        /* Calculate the 1394 bus diameter */
        max_hops = s1394_topology_tree_calculate_diameter(hal);

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

        /* Calculate the total bandwidth (including overhead) */
        total_quads = (bandwidth >> 2) + IEEE1394_ISOCH_HDR_QUAD_SZ;
        switch (speed) {
        case IEEE1394_S400:
                speed_factor = ISOCH_SPEED_FACTOR_S400;
                break;
        case IEEE1394_S200:
                speed_factor = ISOCH_SPEED_FACTOR_S200;
                break;
        case IEEE1394_S100:
                speed_factor = ISOCH_SPEED_FACTOR_S100;
                break;
        }
        /* See IEC 61883-1 pp. 26-29 for this formula */
        bau = (32 * max_hops) + (total_quads * speed_factor);

        return (bau);
}

/*
 * s1394_bandwidth_free()
 *    is used to free up isochronous bandwidth.  A number of bandwidth
 *    allocation units and a generation are passed. The request is sent
 *    to whichever node is the IRM for this amount of bandwidth.  If it
 *    fails because of a bus reset it can be retried. If it fails for
 *    another reason the bandwidth may already be freed or there may
 *    be no IRM.
 */
int
s1394_bandwidth_free(s1394_hal_t *hal, uint32_t bw_alloc_units,
    uint_t generation, int *result)
{
        cmd1394_cmd_t   *cmd;
        uint64_t        IRM_ID_addr;
        uint32_t        compare;
        uint32_t        swap;
        uint32_t        old_value;
        uint32_t        temp_value;
        uint_t          hal_node_num;
        uint_t          IRM_node;
        int             ret;
        int             i;
        int             num_retries = S1394_ISOCH_ALLOC_RETRIES;

        /* Lock the topology tree */
        mutex_enter(&hal->topology_tree_mutex);

        hal_node_num = IEEE1394_NODE_NUM(hal->node_id);
        IRM_node = hal->IRM_node;

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

        /* Make sure there is a valid IRM on the bus */
        if (IRM_node == -1) {
                *result = CMD1394_ERETRIES_EXCEEDED;
                return (DDI_FAILURE);
        }

        /* Send compare-swap to BANDWIDTH_AVAILABLE */
        /* register on the Isoch Rsrc Mgr */
        if (IRM_node == hal_node_num) {
                i = num_retries;
                do {
                        (void) HAL_CALL(hal).csr_read(hal->halinfo.hal_private,
                            (IEEE1394_SCSR_BANDWIDTH_AVAIL &
                            IEEE1394_CSR_OFFSET_MASK), &old_value);

                        /* Check that the generation has not changed */
                        if (generation != hal->generation_count) {
                                *result = CMD1394_EBUSRESET;
                                return (DDI_FAILURE);
                        }

                        temp_value = (old_value + bw_alloc_units);
                        if ((temp_value >= old_value) &&
                            (temp_value <= IEEE1394_BANDWIDTH_MAX)) {
                                compare = old_value;
                                swap    = temp_value;
                        } else {
                                *result = CMD1394_ERETRIES_EXCEEDED;
                                return (DDI_FAILURE);
                        }

                        ret = HAL_CALL(hal).csr_cswap32(
                            hal->halinfo.hal_private, generation,
                            (IEEE1394_SCSR_BANDWIDTH_AVAIL &
                            IEEE1394_CSR_OFFSET_MASK), compare, swap,
                            &old_value);
                        if (ret != DDI_SUCCESS) {
                                *result = CMD1394_EBUSRESET;
                                return (DDI_FAILURE);
                        }

                        if (old_value == compare) {
                                *result = CMD1394_CMDSUCCESS;
                                return (DDI_SUCCESS);
                        }
                } while (i--);

                *result = CMD1394_ERETRIES_EXCEEDED;
                return (DDI_FAILURE);

        } else {
                /* Remote */
                if (s1394_alloc_cmd(hal, 0, &cmd) != DDI_SUCCESS) {
                        *result = CMD1394_EUNKNOWN_ERROR;
                        return (DDI_FAILURE);
                }

                cmd->cmd_options = (CMD1394_CANCEL_ON_BUS_RESET |
                    CMD1394_OVERRIDE_ADDR | CMD1394_BLOCKING);
                cmd->cmd_type = CMD1394_ASYNCH_LOCK_32;
                IRM_ID_addr = (IEEE1394_ADDR_BUS_ID_MASK |
                    IEEE1394_SCSR_BANDWIDTH_AVAIL) |
                    (((uint64_t)hal->IRM_node) << IEEE1394_ADDR_PHY_ID_SHIFT);
                cmd->cmd_addr              = IRM_ID_addr;
                cmd->bus_generation        = generation;
                cmd->cmd_u.l32.arg_value   = IEEE1394_BANDWIDTH_MAX;
                cmd->cmd_u.l32.data_value  = bw_alloc_units;
                cmd->cmd_u.l32.num_retries = num_retries;
                cmd->cmd_u.l32.lock_type   = CMD1394_LOCK_THRESH_ADD;

                ret = s1394_split_lock_req(hal, NULL, cmd);

                if (ret == DDI_SUCCESS) {
                        if (cmd->cmd_result == CMD1394_CMDSUCCESS) {
                                *result = cmd->cmd_result;

                                /* Need to free the command */
                                (void) s1394_free_cmd(hal, &cmd);

                                return (DDI_SUCCESS);

                        } else {
                                *result = cmd->cmd_result;
                                /* Need to free the command */
                                (void) s1394_free_cmd(hal, &cmd);

                                return (DDI_FAILURE);
                        }
                } else {
                        *result = cmd->cmd_result;
                        /* Need to free the command */
                        (void) s1394_free_cmd(hal, &cmd);

                        return (DDI_FAILURE);
                }
        }
}

/*
 * s1394_isoch_cec_list_insert()
 *    is used to insert an Isoch CEC into a given HAL's list of Isoch CECs.
 */
void
s1394_isoch_cec_list_insert(s1394_hal_t *hal, s1394_isoch_cec_t *cec)
{
        s1394_isoch_cec_t *cec_temp;

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

        /* Is the Isoch CEC list empty? */
        if ((hal->isoch_cec_list_head == NULL) &&
            (hal->isoch_cec_list_tail == NULL)) {

                hal->isoch_cec_list_head = cec;
                hal->isoch_cec_list_tail = cec;

                cec->cec_next = NULL;
                cec->cec_prev = NULL;

        } else {
                cec->cec_next = hal->isoch_cec_list_head;
                cec->cec_prev = NULL;
                cec_temp = hal->isoch_cec_list_head;
                cec_temp->cec_prev = cec;

                hal->isoch_cec_list_head = cec;
        }
}

/*
 * s1394_isoch_cec_list_remove()
 *    is used to remove an Isoch CEC from a given HAL's list of Isoch CECs.
 */
void
s1394_isoch_cec_list_remove(s1394_hal_t *hal, s1394_isoch_cec_t *cec)
{
        s1394_isoch_cec_t *prev_cec;
        s1394_isoch_cec_t *next_cec;

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

        prev_cec = cec->cec_prev;
        next_cec = cec->cec_next;
        cec->cec_prev = NULL;
        cec->cec_next = NULL;

        if (prev_cec != NULL) {
                prev_cec->cec_next = next_cec;

        } else {
                if (hal->isoch_cec_list_head == cec)
                        hal->isoch_cec_list_head = next_cec;
        }

        if (next_cec != NULL) {
                next_cec->cec_prev = prev_cec;

        } else {
                if (hal->isoch_cec_list_tail == cec)
                        hal->isoch_cec_list_tail = prev_cec;
        }
}

/*
 * s1394_isoch_cec_member_list_insert()
 *    is used to insert a new member (target) into the list of members for
 *    a given Isoch CEC.
 */
/* ARGSUSED */
void
s1394_isoch_cec_member_list_insert(s1394_hal_t *hal, s1394_isoch_cec_t *cec,
    s1394_isoch_cec_member_t *member)
{
        s1394_isoch_cec_member_t *member_temp;

        ASSERT(MUTEX_HELD(&cec->isoch_cec_mutex));

        /* Is the Isoch CEC member list empty? */
        if ((cec->cec_member_list_head == NULL) &&
            (cec->cec_member_list_tail == NULL)) {

                cec->cec_member_list_head = member;
                cec->cec_member_list_tail = member;
                member->cec_mem_next = NULL;
                member->cec_mem_prev = NULL;

        } else if (member->cec_mem_options & T1394_TALKER) {
                /* Put talker at the head of the list */
                member->cec_mem_next = cec->cec_member_list_head;
                member->cec_mem_prev = NULL;
                member_temp = cec->cec_member_list_head;
                member_temp->cec_mem_prev = member;
                cec->cec_member_list_head = member;

        } else {
                /* Put listeners at the tail of the list */
                member->cec_mem_prev = cec->cec_member_list_tail;
                member->cec_mem_next = NULL;
                member_temp = cec->cec_member_list_tail;
                member_temp->cec_mem_next = member;
                cec->cec_member_list_tail = member;
        }
}

/*
 * s1394_isoch_cec_member_list_remove()
 *    is used to remove a member (target) from the list of members for
 *    a given Isoch CEC.
 */
/* ARGSUSED */
void
s1394_isoch_cec_member_list_remove(s1394_hal_t *hal, s1394_isoch_cec_t *cec,
    s1394_isoch_cec_member_t *member)
{
        s1394_isoch_cec_member_t *prev_member;
        s1394_isoch_cec_member_t *next_member;

        ASSERT(MUTEX_HELD(&cec->isoch_cec_mutex));

        prev_member = member->cec_mem_prev;
        next_member = member->cec_mem_next;

        member->cec_mem_prev = NULL;
        member->cec_mem_next = NULL;

        if (prev_member != NULL) {
                prev_member->cec_mem_next = next_member;

        } else {
                if (cec->cec_member_list_head == member)
                        cec->cec_member_list_head = next_member;
        }

        if (next_member != NULL) {
                next_member->cec_mem_prev = prev_member;

        } else {
                if (cec->cec_member_list_tail == member)
                        cec->cec_member_list_tail = prev_member;
        }
}