io/heci/heci_intr.c

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

/*
 * Part of Intel(R) Manageability Engine Interface Linux driver
 *
 * Copyright (c) 2003 - 2008 Intel Corp.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions, and the following disclaimer,
 *    without modification.
 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
 *    substantially similar to the "NO WARRANTY" disclaimer below
 *    ("Disclaimer") and any redistribution must be conditioned upon
 *    including a substantially similar Disclaimer requirement for further
 *    binary redistribution.
 * 3. Neither the names of the above-listed copyright holders nor the names
 *    of any contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * Alternatively, this software may be distributed under the terms of the
 * GNU General Public License ("GPL") version 2 as published by the Free
 * Software Foundation.
 *
 * NO WARRANTY
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGES.
 *
 */

#include <sys/types.h>
#include <sys/cmn_err.h>
#include <sys/conf.h>
#include <sys/ddi.h>
#include <sys/ddi_impldefs.h>
#include <sys/devops.h>
#include <sys/instance.h>
#include <sys/modctl.h>
#include <sys/open.h>
#include <sys/stat.h>
#include <sys/sunddi.h>
#include <sys/sunndi.h>
#include <sys/systm.h>
#include <sys/mkdev.h>
#include <sys/list.h>
#include <sys/note.h>
#include "heci_data_structures.h"

#include "heci.h"
#include "heci_interface.h"

/*
 *  interrupt function prototypes
 */
static void heci_bh_handler(void *data);
static int heci_bh_read_handler(struct io_heci_list *complete_list,
        struct iamt_heci_device *dev,
        int32_t *slots);
static int heci_bh_write_handler(struct io_heci_list *complete_list,
        struct iamt_heci_device *dev,
        int32_t *slots);
static void heci_bh_read_bus_message(struct iamt_heci_device *dev,
        struct heci_msg_hdr *heci_hdr);
static int heci_bh_read_pthi_message(struct io_heci_list *complete_list,
        struct iamt_heci_device *dev,
        struct heci_msg_hdr *heci_hdr);
static int heci_bh_read_client_message(struct io_heci_list *complete_list,
        struct iamt_heci_device *dev,
        struct heci_msg_hdr *heci_hdr);
static void heci_client_connect_response(struct iamt_heci_device *dev,
        struct hbm_client_connect_response *connect_res);
static void heci_client_disconnect_response(struct iamt_heci_device *dev,
        struct hbm_client_connect_response *disconnect_res);
static void heci_client_flow_control_response(struct iamt_heci_device *dev,
        struct hbm_flow_control *flow_control);
static void heci_client_disconnect_request(struct iamt_heci_device *dev,
        struct hbm_client_disconnect_request *disconnect_req);

static int heci_bh_process_device(struct iamt_heci_device *dev);

/*
 * heci_isr_interrupt - The ISR of the HECI device
 *
 * @irq: The irq number
 * @dev_id: pointer to the device structure
 *
 * @return irqreturn_t
 */
uint_t
heci_isr_interrupt(caddr_t arg1)
{
    struct iamt_heci_device *device =
        (struct iamt_heci_device *)(void *)arg1;

    mutex_enter(&device->device_lock);

    if (device->heci_state == HECI_POWER_DOWN) {
        mutex_exit(&device->device_lock);
        return (DDI_INTR_UNCLAIMED);
    }
    device->host_hw_state = read_heci_register(device, H_CSR);

    if ((device->host_hw_state & H_IS) != H_IS) {
        mutex_exit(&device->device_lock);
        return (DDI_INTR_UNCLAIMED);
    }

    /* disable interrupts */
    heci_csr_disable_interrupts(device);

    mutex_exit(&device->device_lock);

    /*
     * Our device interrupted, schedule work the heci_bh_handler
     * to handle the interrupt processing. This needs to be a
     * taskq
     */
    DBG("schedule work the heci_bh_handler.\n");
    if (ddi_taskq_dispatch(device->work, heci_bh_handler,
        (void*)arg1, DDI_NOSLEEP) == DDI_FAILURE)
        cmn_err(CE_WARN, "taskq_dispatch failed for heci_bh_handler");

    return (DDI_INTR_CLAIMED);
}

/*
 * _heci_cmpl: process completed operation.
 *
 * @file_ext: private data of the file object.
 * @priv_cb_pos: callback block.
 */
static void _heci_cmpl(struct heci_file_private *file_ext,
                struct heci_cb_private *priv_cb_pos)
{
    if (priv_cb_pos->major_file_operations == HECI_WRITE) {
        heci_free_cb_private(priv_cb_pos);
        DBG("completing write call back.\n");
        file_ext->writing_state = HECI_WRITE_COMPLETE;
        pollwakeup(&file_ext->tx_pollwait, POLL_IN|POLLRDNORM);

    } else if (priv_cb_pos->major_file_operations == HECI_READ &&
        HECI_READING == file_ext->reading_state) {
        DBG("completing read call back information= %lu\n",
            priv_cb_pos->information);
        file_ext->reading_state = HECI_READ_COMPLETE;
        cv_broadcast(&file_ext->rx_wait);

    }
}

/*
 * _heci_cmpl_iamthif: process completed iamthif operation.
 *
 * @dev: Device object for our driver.
 * @priv_cb_pos: callback block.
 */
static void _heci_cmpl_iamthif(struct iamt_heci_device *dev,
                struct heci_cb_private *priv_cb_pos)
{
    if (dev->iamthif_canceled != 1) {
        dev->iamthif_state = HECI_IAMTHIF_READ_COMPLETE;
        dev->iamthif_stall_timer = 0;
        (void) memcpy(priv_cb_pos->response_buffer.data,
            dev->iamthif_msg_buf,
            dev->iamthif_msg_buf_index);
        list_add_tail(&priv_cb_pos->cb_list,
            &dev->pthi_read_complete_list.heci_cb.cb_list);
        DBG("pthi read completed.\n");
    } else {
        run_next_iamthif_cmd(dev);
    }
    if (&dev->iamthif_file_ext.pollwait) {
        DBG("completing pthi call back.\n");
        pollwakeup(&dev->iamthif_file_ext.pollwait, POLL_IN|POLLRDNORM);
    }
}
/*
 * heci_bh_handler - function called after ISR to handle the interrupt
 * processing.
 *
 * @work: pointer to the work structure
 *
 * NOTE: This function is called by schedule work
 */
static void
heci_bh_handler(void *data)
{
    struct iamt_heci_device *dev = (struct iamt_heci_device *)data;

#ifdef SUNOS
    while (heci_bh_process_device(dev))
        ;
#elif defined(LINUX)
    if (heci_bh_process_device(dev)) {
        PEPARE_WORK(&dev->work, heci_bh_handler);
        DBG("schedule work the heci_bh_handler.\n");
        rets = schedule_work(&dev->work);
        if (!rets) {
            printk(KERN_ERR "heci: schedule the heci_bh_handler"
            " failed error=%x\n", rets);
        }
    }
#else

#error "Unknown platform!"

#endif
}

static int
heci_bh_process_device(struct iamt_heci_device *dev)
{
    struct io_heci_list complete_list;
    int32_t slots;
    int rets, isr_pending = 0;
    struct heci_cb_private *cb_pos = NULL, *cb_next = NULL;
    struct heci_file_private *file_ext;
    int bus_message_received = 0;

    DBG("function called after ISR to handle the interrupt processing.\n");
    /* initialize our complete list */
    mutex_enter(&dev->device_lock);
    heci_initialize_list(&complete_list, dev);
    dev->host_hw_state = read_heci_register(dev, H_CSR);
    dev->me_hw_state = read_heci_register(dev, ME_CSR_HA);

    /* check if ME wants a reset */
    if (((dev->me_hw_state & ME_RDY_HRA) == 0) &&
        (dev->heci_state != HECI_RESETING) &&
        (dev->heci_state != HECI_INITIALIZING)) {
        DBG("FW not ready.\n");
        heci_reset(dev, 1);
        mutex_exit(&dev->device_lock);
        return (0);
    }

    /*  check if we need to start the dev */
    if ((dev->host_hw_state & H_RDY) == 0) {
        if ((dev->me_hw_state & ME_RDY_HRA) == ME_RDY_HRA) {
            DBG("we need to start the dev.\n");
            dev->host_hw_state |= (H_IE | H_IG | H_RDY);
            heci_set_csr_register(dev);
            if (dev->heci_state == HECI_INITIALIZING) {
                dev->recvd_msg = 1;
                cv_broadcast(&dev->wait_recvd_msg);
                mutex_exit(&dev->device_lock);

                return (0);

            } else {
                mutex_exit(&dev->device_lock);
                if (dev->reinit_tsk &&
                    ddi_taskq_dispatch(dev->reinit_tsk,
                    heci_task_initialize_clients,
                    dev, DDI_SLEEP) == DDI_FAILURE) {

                    cmn_err(CE_WARN, "taskq_dispatch "
                        "failed for reinit_tsk");
                }
                return (0);
            }
        } else {
            DBG("enable interrupt FW not ready.\n");
            heci_csr_enable_interrupts(dev);
            mutex_exit(&dev->device_lock);
            return (0);
        }
    }
    /* check slots avalable for reading */
    slots = count_full_read_slots(dev);
    DBG("slots =%08x  extra_write_index =%08x.\n",
        slots, dev->extra_write_index);
    while ((slots > 0) && (!dev->extra_write_index)) {
        DBG("slots =%08x  extra_write_index =%08x.\n", slots,
            dev->extra_write_index);
        DBG("call heci_bh_read_handler.\n");
        rets = heci_bh_read_handler(&complete_list, dev, &slots);
        if (rets != 0)
            goto end;
    }
    rets = heci_bh_write_handler(&complete_list, dev, &slots);
end:
    DBG("end of bottom half function.\n");
    dev->host_hw_state = read_heci_register(dev, H_CSR);
    dev->host_buffer_is_empty = host_buffer_is_empty(dev);

    if ((dev->host_hw_state & H_IS) == H_IS) {
        /* acknowledge interrupt and disable interrupts */
        heci_csr_disable_interrupts(dev);

        DBG("schedule work the heci_bh_handler.\n");
        isr_pending = 1;


    } else {
        heci_csr_enable_interrupts(dev);
    }

    if (dev->recvd_msg) {
        DBG("received waiting bus message\n");
        bus_message_received = 1;
    }

    if (bus_message_received) {
        DBG("wake up dev->wait_recvd_msg\n");
        cv_broadcast(&dev->wait_recvd_msg);
        bus_message_received = 0;
    }
    if ((complete_list.status != 0) ||
        list_empty(&complete_list.heci_cb.cb_list)) {
        mutex_exit(&dev->device_lock);
        return (isr_pending);
    }

    mutex_exit(&dev->device_lock);

    list_for_each_entry_safe(cb_pos, cb_next,
        &complete_list.heci_cb.cb_list, cb_list, struct heci_cb_private) {
        file_ext = (struct heci_file_private *)cb_pos->file_private;
        list_del(&cb_pos->cb_list);
        if (file_ext != NULL) {
            if (file_ext != &dev->iamthif_file_ext) {
                DBG("completing call back.\n");
                _heci_cmpl(file_ext, cb_pos);
                cb_pos = NULL;
            } else if (file_ext == &dev->iamthif_file_ext) {
                _heci_cmpl_iamthif(dev, cb_pos);
            }
        }
    }
    return (isr_pending);
}


/*
 * heci_bh_read_handler - bottom half read routine after ISR to
 * handle the read processing.
 *
 * @cmpl_list: An instance of our list structure
 * @dev: Device object for our driver
 * @slots: slots to read.
 *
 * @return 0 on success, <0 on failure.
 */
static int
heci_bh_read_handler(struct io_heci_list *cmpl_list,
        struct iamt_heci_device *dev,
        int32_t *slots)
{
    struct heci_msg_hdr *heci_hdr;
    int ret = 0;
    struct heci_file_private *file_pos = NULL;
    struct heci_file_private *file_next = NULL;

    if (!dev->rd_msg_hdr) {
        dev->rd_msg_hdr = read_heci_register(dev, ME_CB_RW);
        DBG("slots=%08x.\n", *slots);
        (*slots)--;
        DBG("slots=%08x.\n", *slots);
    }
    heci_hdr = (struct heci_msg_hdr *)&dev->rd_msg_hdr;
    DBG("heci_hdr->length =%d\n", heci_hdr->length);

    if ((heci_hdr->reserved) || !(dev->rd_msg_hdr)) {
        DBG("corrupted message header.\n");
        ret = -ECORRUPTED_MESSAGE_HEADER;
        goto end;
    }

    if ((heci_hdr->host_addr) || (heci_hdr->me_addr)) {
        list_for_each_entry_safe(file_pos, file_next,
        &dev->file_list, link, struct heci_file_private) {
            DBG("list_for_each_entry_safe read host"
                    " client = %d, ME client = %d\n",
                    file_pos->host_client_id,
                    file_pos->me_client_id);
            if ((file_pos->host_client_id == heci_hdr->host_addr) &&
                (file_pos->me_client_id == heci_hdr->me_addr))
                break;
        }

        if (&file_pos->link == &dev->file_list) {
            DBG("corrupted message header\n");
            ret = -ECORRUPTED_MESSAGE_HEADER;
            goto end;
        }
    }
    if (((*slots) * sizeof (uint32_t)) < heci_hdr->length) {
        DBG("we can't read the message slots=%08x.\n", *slots);
        /* we can't read the message */
        ret = -ERANGE;
        goto end;
    }

    /* decide where to read the message too */
    if (!heci_hdr->host_addr) {
        DBG("call heci_bh_read_bus_message.\n");
        heci_bh_read_bus_message(dev, heci_hdr);
        DBG("end heci_bh_read_bus_message.\n");
    } else if ((heci_hdr->host_addr ==
        dev->iamthif_file_ext.host_client_id) &&
        (HECI_FILE_CONNECTED == dev->iamthif_file_ext.state) &&
        (dev->iamthif_state == HECI_IAMTHIF_READING)) {

        DBG("call heci_bh_read_iamthif_message.\n");
        DBG("heci_hdr->length =%d\n", heci_hdr->length);
        ret = heci_bh_read_pthi_message(cmpl_list, dev, heci_hdr);
        if (ret != 0)
            goto end;

    } else {
        DBG("call heci_bh_read_client_message.\n");
        ret = heci_bh_read_client_message(cmpl_list, dev, heci_hdr);
        if (ret != 0)
            goto end;

    }

    /* reset the number of slots and header */
    *slots = count_full_read_slots(dev);
    dev->rd_msg_hdr = 0;

    if (*slots == -ESLOTS_OVERFLOW) {
        /* overflow - reset */
        DBG("reseting due to slots overflow.\n");
        /* set the event since message has been read */
        ret = -ERANGE;
        goto end;
    }
end:
    return (ret);
}


/*
 * heci_bh_read_bus_message - bottom half read routine after ISR to
 * handle the read bus message cmd  processing.
 *
 * @dev: Device object for our driver
 * @heci_hdr: header of bus message
 */
static void heci_bh_read_bus_message(struct iamt_heci_device *dev,
        struct heci_msg_hdr *heci_hdr)
{
    struct heci_bus_message *heci_msg;
    struct hbm_host_version_response *version_res;
    struct hbm_client_connect_response *connect_res;
    struct hbm_client_connect_response *disconnect_res;
    struct hbm_flow_control *flow_control;
    struct hbm_props_response *props_res;
    struct hbm_host_enum_response *enum_res;
    struct hbm_client_disconnect_request *disconnect_req;
    struct hbm_host_stop_request *h_stop_req;
    int i;
    unsigned char *buffer;

    /*  read the message to our buffer */
    buffer = (unsigned char *)dev->rd_msg_buf;
    ASSERT(heci_hdr->length < sizeof (dev->rd_msg_buf));
    heci_read_slots(dev, buffer, heci_hdr->length);
    heci_msg = (struct heci_bus_message *)buffer;

    switch (*(uint8_t *)heci_msg) {
    case HOST_START_RES_CMD:
        version_res = (struct hbm_host_version_response *)heci_msg;
        if (version_res->host_version_supported) {
            dev->version.major_version = HBM_MAJOR_VERSION;
            dev->version.minor_version = HBM_MINOR_VERSION;
        } else {
            dev->version = version_res->me_max_version;
        }
        dev->recvd_msg = 1;
        DBG("host start response message received.\n");
        break;

    case CLIENT_CONNECT_RES_CMD:
        connect_res =
            (struct hbm_client_connect_response *)heci_msg;
        heci_client_connect_response(dev, connect_res);
        DBG("client connect response message received.\n");
        cv_broadcast(&dev->wait_recvd_msg);
        break;

    case CLIENT_DISCONNECT_RES_CMD:
        disconnect_res =
            (struct hbm_client_connect_response *)heci_msg;
        heci_client_disconnect_response(dev,     disconnect_res);
        DBG("client disconnect response message received.\n");
        cv_broadcast(&dev->wait_recvd_msg);
        break;

    case HECI_FLOW_CONTROL_CMD:
        flow_control = (struct hbm_flow_control *)heci_msg;
        heci_client_flow_control_response(dev, flow_control);
        DBG("client flow control response message received.\n");
        break;

    case HOST_CLIENT_PROPERTEIS_RES_CMD:
        props_res = (struct hbm_props_response *)heci_msg;
        if (props_res->status != 0) {
            ASSERT(0);
            break;
        }
        for (i = 0; i < dev->num_heci_me_clients; i++) {
            if (dev->me_clients[i].client_id ==
                props_res->address) {
                dev->me_clients[i].props =
                    props_res->client_properties;
                break;
            }

        }
        dev->recvd_msg = 1;
        break;

    case HOST_ENUM_RES_CMD:
        enum_res = (struct hbm_host_enum_response *)heci_msg;
        (void) memcpy(dev->heci_me_clients,
            enum_res->valid_addresses, 32);
        dev->recvd_msg = 1;
        break;

    case HOST_STOP_RES_CMD:
        dev->heci_state = HECI_DISABLED;
        DBG("reseting because of FW stop response.\n");
        heci_reset(dev, 1);
        break;

    case CLIENT_DISCONNECT_REQ_CMD:
        /* search for client */
        disconnect_req =
            (struct hbm_client_disconnect_request *)heci_msg;
        heci_client_disconnect_request(dev, disconnect_req);
        break;

    case ME_STOP_REQ_CMD:
        /* prepare stop request */
        heci_hdr = (struct heci_msg_hdr *)&dev->ext_msg_buf[0];
        heci_hdr->host_addr = 0;
        heci_hdr->me_addr = 0;
        heci_hdr->length = sizeof (struct hbm_host_stop_request);
        heci_hdr->msg_complete = 1;
        heci_hdr->reserved = 0;
        h_stop_req =
            (struct hbm_host_stop_request *)&dev->ext_msg_buf[1];
        (void) memset(h_stop_req, 0,
            sizeof (struct hbm_host_stop_request));
        h_stop_req->cmd.cmd = HOST_STOP_REQ_CMD;
        h_stop_req->reason = DRIVER_STOP_REQUEST;
        h_stop_req->reserved[0] = 0;
        h_stop_req->reserved[1] = 0;
        dev->extra_write_index = 2;
        break;

    default:
        ASSERT(0);
        break;

    }
}

/*
 * heci_bh_read_pthi_message - bottom half read routine after ISR to
 * handle the read pthi message data processing.
 *
 * @complete_list: An instance of our list structure
 * @dev: Device object for our driver
 * @heci_hdr: header of pthi message
 *
 * @return 0 on success, <0 on failure.
 */
static int
heci_bh_read_pthi_message(struct io_heci_list *complete_list,
        struct iamt_heci_device *dev,
        struct heci_msg_hdr *heci_hdr)
{
    struct heci_file_private *file_ext;
    struct heci_cb_private *priv_cb;
    unsigned char *buffer;

    ASSERT(heci_hdr->me_addr == dev->iamthif_file_ext.me_client_id);
    ASSERT(dev->iamthif_state == HECI_IAMTHIF_READING);

    buffer = (unsigned char *)(dev->iamthif_msg_buf +
        dev->iamthif_msg_buf_index);
    ASSERT(sizeof (dev->iamthif_msg_buf) >=
        (dev->iamthif_msg_buf_index + heci_hdr->length));

    heci_read_slots(dev, buffer, heci_hdr->length);

    dev->iamthif_msg_buf_index += heci_hdr->length;

    if (!(heci_hdr->msg_complete))
        return (0);

    DBG("pthi_message_buffer_index=%d\n", heci_hdr->length);
    DBG("completed pthi read.\n ");
    if (!dev->iamthif_current_cb)
        return (-ENODEV);

    priv_cb = dev->iamthif_current_cb;
    dev->iamthif_current_cb = NULL;

    file_ext = (struct heci_file_private *)priv_cb->file_private;
    if (!file_ext)
        return (-ENODEV);

    dev->iamthif_stall_timer = 0;
    priv_cb->information =  dev->iamthif_msg_buf_index;
    priv_cb->read_time = ddi_get_time();
    if ((dev->iamthif_ioctl) && (file_ext == &dev->iamthif_file_ext)) {
        /* found the iamthif cb */
        DBG("complete the pthi read cb.\n ");
        if (&dev->iamthif_file_ext) {
            DBG("add the pthi read cb to complete.\n ");
            list_add_tail(&priv_cb->cb_list,
                &complete_list->heci_cb.cb_list);
        }
    }
    return (0);
}

/*
 * _heci_bh_state_ok - check if heci header matches file private data
 *
 * @file_ext: private data of the file object
 * @heci_hdr: header of heci client message
 *
 * @return  !=0 if matches, 0 if no match.
 */
static int
_heci_bh_state_ok(struct heci_file_private *file_ext,
                    struct heci_msg_hdr *heci_hdr)
{
    return ((file_ext->host_client_id == heci_hdr->host_addr) &&
        (file_ext->me_client_id == heci_hdr->me_addr) &&
        (file_ext->state == HECI_FILE_CONNECTED) &&
        (HECI_READ_COMPLETE != file_ext->reading_state));
}

/*
 * heci_bh_read_client_message - bottom half read routine after ISR to
 * handle the read heci client message data  processing.
 *
 * @complete_list: An instance of our list structure
 * @dev: Device object for our driver
 * @heci_hdr: header of heci client message
 *
 * @return  0 on success, <0 on failure.
 */
static int
heci_bh_read_client_message(struct io_heci_list *complete_list,
    struct iamt_heci_device *dev,
    struct heci_msg_hdr *heci_hdr)
{
    struct heci_file_private *file_ext;
    struct heci_cb_private *priv_cb_pos = NULL, *priv_cb_next = NULL;
    unsigned char *buffer = NULL;

    DBG("start client msg\n");
    if (!((dev->read_list.status == 0) &&
        !list_empty(&dev->read_list.heci_cb.cb_list)))
        goto quit;

    list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
        &dev->read_list.heci_cb.cb_list, cb_list, struct heci_cb_private) {
        file_ext = (struct heci_file_private *)
                priv_cb_pos->file_private;
        if ((file_ext != NULL) &&
            (_heci_bh_state_ok(file_ext, heci_hdr))) {
            mutex_enter(&file_ext->read_io_lock);
            file_ext->reading_state = HECI_READING;
            buffer = (unsigned char *)
                (priv_cb_pos->response_buffer.data +
                priv_cb_pos->information);
            ASSERT(priv_cb_pos->response_buffer.size >=
                    heci_hdr->length +
                    priv_cb_pos->information);

            if (priv_cb_pos->response_buffer.size <
                    heci_hdr->length +
                    priv_cb_pos->information) {
                DBG("message overflow.\n");
                list_del(&priv_cb_pos->cb_list);
                mutex_exit(&file_ext->read_io_lock);
                return (-ENOMEM);
            }
            if (buffer) {
                heci_read_slots(dev, buffer,
                        heci_hdr->length);
            }
            priv_cb_pos->information += heci_hdr->length;
            if (heci_hdr->msg_complete) {
                file_ext->status = 0;
                list_del(&priv_cb_pos->cb_list);
                mutex_exit(&file_ext->read_io_lock);
                DBG("completed read host client = %d,"
                    "ME client = %d, "
                    "data length = %lu\n",
                    file_ext->host_client_id,
                    file_ext->me_client_id,
                    priv_cb_pos->information);

                DBG("priv_cb_pos->res_buffer - %s\n",
                    priv_cb_pos->response_buffer.data);
                list_add_tail(&priv_cb_pos->cb_list,
                    &complete_list->heci_cb.cb_list);
            } else {
                mutex_exit(&file_ext->read_io_lock);
            }

            break;
        }

    }

quit:
    DBG("message read\n");
    if (!buffer) {
        heci_read_slots(dev, (unsigned char *)dev->rd_msg_buf,
            heci_hdr->length);
        DBG("discarding message, header=%08x.\n",
            *(uint32_t *)dev->rd_msg_buf);
    }

    return (0);
}

/*
 * _heci_bh_iamthif_read: prepare to read iamthif data.
 *
 * @dev: Device object for our driver.
 * @slots: free slots.
 *
 * @return  0, OK; otherwise, error.
 */
static int
_heci_bh_iamthif_read(struct iamt_heci_device *dev, int32_t *slots)
{

    if (((*slots) * sizeof (uint32_t)) >= (sizeof (struct heci_msg_hdr)
            + sizeof (struct hbm_flow_control))) {
        *slots -= (sizeof (struct heci_msg_hdr) +
                sizeof (struct hbm_flow_control) + 3) / 4;
        if (!heci_send_flow_control(dev, &dev->iamthif_file_ext)) {
            DBG("iamthif flow control failed\n");
        } else {
            DBG("iamthif flow control success\n");
            dev->iamthif_state = HECI_IAMTHIF_READING;
            dev->iamthif_flow_control_pending = 0;
            dev->iamthif_msg_buf_index = 0;
            dev->iamthif_msg_buf_size = 0;
            dev->iamthif_stall_timer = IAMTHIF_STALL_TIMER;
            dev->host_buffer_is_empty = host_buffer_is_empty(dev);
        }
        return (0);
    } else {
        return (-ECOMPLETE_MESSAGE);
    }
}

/*
 * _heci_bh_close: process close related operation.
 *
 * @dev: Device object for our driver.
 * @slots: free slots.
 * @priv_cb_pos: callback block.
 * @file_ext: private data of the file object.
 * @cmpl_list: complete list.
 *
 * @return  0, OK; otherwise, error.
 */
static int
_heci_bh_close(struct iamt_heci_device *dev, int32_t *slots,
    struct heci_cb_private *priv_cb_pos,
    struct heci_file_private *file_ext,
    struct io_heci_list *cmpl_list)
{
    if ((*slots * sizeof (uint32_t)) >= (sizeof (struct heci_msg_hdr) +
        sizeof (struct hbm_client_disconnect_request))) {
        *slots -= (sizeof (struct heci_msg_hdr) +
            sizeof (struct hbm_client_disconnect_request) + 3) / 4;

        if (!heci_disconnect(dev, file_ext)) {
            file_ext->status = 0;
            priv_cb_pos->information = 0;
            list_relink_node(&priv_cb_pos->cb_list,
                    &cmpl_list->heci_cb.cb_list);
            return (-ECOMPLETE_MESSAGE);
        } else {
            file_ext->state = HECI_FILE_DISCONNECTING;
            file_ext->status = 0;
            priv_cb_pos->information = 0;
            list_relink_node(&priv_cb_pos->cb_list,
                    &dev->ctrl_rd_list.heci_cb.cb_list);
            file_ext->timer_count = HECI_CONNECT_TIMEOUT;
        }
    } else {
        /* return the cancel routine */
        return (-ECORRUPTED_MESSAGE_HEADER);
    }

    return (0);
}

/*
 * _heci_hb_close: process read related operation.
 *
 * @dev: Device object for our driver.
 * @slots: free slots.
 * @priv_cb_pos: callback block.
 * @file_ext: private data of the file object.
 * @cmpl_list: complete list.
 *
 * @return 0, OK; otherwise, error.
 */
static int
_heci_bh_read(struct iamt_heci_device *dev, int32_t *slots,
    struct heci_cb_private *priv_cb_pos,
    struct heci_file_private *file_ext,
    struct io_heci_list *cmpl_list)
{
    if ((*slots * sizeof (uint32_t)) >= (sizeof (struct heci_msg_hdr) +
        sizeof (struct hbm_flow_control))) {
        *slots -= (sizeof (struct heci_msg_hdr) +
            sizeof (struct hbm_flow_control) + 3) / 4;
        if (!heci_send_flow_control(dev, file_ext)) {
            file_ext->status = -ENODEV;
            priv_cb_pos->information = 0;
            list_relink_node(&priv_cb_pos->cb_list,
                    &cmpl_list->heci_cb.cb_list);
            return (-ENODEV);
        } else {
            list_relink_node(&priv_cb_pos->cb_list,
                    &dev->read_list.heci_cb.cb_list);
        }
    } else {
        /* return the cancel routine */
        list_del(&priv_cb_pos->cb_list);
        return (-ECORRUPTED_MESSAGE_HEADER);
    }

    return (0);
}


/*
 * _heci_bh_ioctl: process ioctl related operation.
 *
 * @dev: Device object for our driver.
 * @slots: free slots.
 * @priv_cb_pos: callback block.
 * @file_ext: private data of the file object.
 * @cmpl_list: complete list.
 *
 * @return  0, OK; otherwise, error.
 */
static int
_heci_bh_ioctl(struct iamt_heci_device *dev,    int32_t *slots,
    struct heci_cb_private *priv_cb_pos,
    struct heci_file_private *file_ext,
    struct io_heci_list *cmpl_list)
{
    _NOTE(ARGUNUSED(cmpl_list));

    if ((*slots * sizeof (uint32_t)) >= (sizeof (struct heci_msg_hdr) +
        sizeof (struct hbm_client_connect_request))) {
        file_ext->state = HECI_FILE_CONNECTING;
        *slots -= (sizeof (struct heci_msg_hdr) +
            sizeof (struct hbm_client_connect_request) + 3) / 4;
        if (!heci_connect(dev, file_ext)) {
            file_ext->status = -ENODEV;
            priv_cb_pos->information = 0;
            list_del(&priv_cb_pos->cb_list);
            return (-ENODEV);
        } else {
            list_relink_node(&priv_cb_pos->cb_list,
                &dev->ctrl_rd_list.heci_cb.cb_list);
            file_ext->timer_count = HECI_CONNECT_TIMEOUT;
        }
    } else {
        /* return the cancel routine */
        list_del(&priv_cb_pos->cb_list);
        return (-ECORRUPTED_MESSAGE_HEADER);
    }

    return (0);
}

/*
 * _heci_bh_cmpl: process completed and no-iamthif operation.
 *
 * @dev: Device object for our driver.
 * @slots: free slots.
 * @priv_cb_pos: callback block.
 * @file_ext: private data of the file object.
 * @cmpl_list: complete list.
 *
 * @return  0, OK; otherwise, error.
 */
static int
_heci_bh_cmpl(struct iamt_heci_device *dev, int32_t *slots,
            struct heci_cb_private *priv_cb_pos,
            struct heci_file_private *file_ext,
            struct io_heci_list *cmpl_list)
{
    struct heci_msg_hdr *heci_hdr;

    if ((*slots * sizeof (uint32_t)) >= (sizeof (struct heci_msg_hdr) +
        (priv_cb_pos->request_buffer.size -
        priv_cb_pos->information))) {
        heci_hdr = (struct heci_msg_hdr *)&dev->wr_msg_buf[0];
        heci_hdr->host_addr = file_ext->host_client_id;
        heci_hdr->me_addr = file_ext->me_client_id;
        heci_hdr->length = ((priv_cb_pos->request_buffer.size) -
            (priv_cb_pos->information));
        heci_hdr->msg_complete = 1;
        heci_hdr->reserved = 0;
        DBG("priv_cb_pos->request_buffer.size =%d"
            "heci_hdr->msg_complete= %d\n",
            priv_cb_pos->request_buffer.size,
            heci_hdr->msg_complete);
        DBG("priv_cb_pos->information  =%lu\n",
            priv_cb_pos->information);
        DBG("heci_hdr->length  =%d\n",
            heci_hdr->length);
        *slots -= (sizeof (struct heci_msg_hdr) +
            heci_hdr->length + 3) / 4;
        if (!heci_write_message(dev, heci_hdr,
            (unsigned char *)(priv_cb_pos->request_buffer.data +
            priv_cb_pos->information),
            heci_hdr->length)) {
            file_ext->status = -ENODEV;
            list_relink_node(&priv_cb_pos->cb_list,
                &cmpl_list->heci_cb.cb_list);
            return (-ENODEV);
        } else {
            flow_ctrl_reduce(dev, file_ext);
            file_ext->status = 0;
            priv_cb_pos->information += heci_hdr->length;
            list_relink_node(&priv_cb_pos->cb_list,
                &dev->write_waiting_list.heci_cb.cb_list);
        }
    } else if (*slots == ((dev->host_hw_state & H_CBD) >> 24)) {
        /* buffer is still empty */
        heci_hdr = (struct heci_msg_hdr *)&dev->wr_msg_buf[0];
        heci_hdr->host_addr = file_ext->host_client_id;
        heci_hdr->me_addr = file_ext->me_client_id;
        heci_hdr->length =
            (*slots * sizeof (uint32_t)) - sizeof (struct heci_msg_hdr);
        heci_hdr->msg_complete = 0;
        heci_hdr->reserved = 0;

        (*slots) -= (sizeof (struct heci_msg_hdr) +
            heci_hdr->length + 3) / 4;
        if (!heci_write_message(dev, heci_hdr,
            (unsigned char *)
            (priv_cb_pos->request_buffer.data +
            priv_cb_pos->information),
            heci_hdr->length)) {
            file_ext->status = -ENODEV;
            list_relink_node(&priv_cb_pos->cb_list,
                &cmpl_list->heci_cb.cb_list);
            return (-ENODEV);
        } else {
            priv_cb_pos->information += heci_hdr->length;
            DBG("priv_cb_pos->request_buffer.size =%d"
                " heci_hdr->msg_complete= %d\n",
                priv_cb_pos->request_buffer.size,
                heci_hdr->msg_complete);
            DBG("priv_cb_pos->information  =%lu\n",
                priv_cb_pos->information);
            DBG("heci_hdr->length  =%d\n", heci_hdr->length);
        }
        return (-ECOMPLETE_MESSAGE);
    } else {
        return (-ECORRUPTED_MESSAGE_HEADER);
    }

    return (0);
}

/*
 * _heci_bh_cmpl_iamthif: process completed iamthif operation.
 *
 * @dev: Device object for our driver.
 * @slots: free slots.
 * @priv_cb_pos: callback block.
 * @file_ext: private data of the file object.
 * @cmpl_list: complete list.
 *
 * @return  0, OK; otherwise, error.
 */
static int
_heci_bh_cmpl_iamthif(struct iamt_heci_device *dev, int32_t *slots,
    struct heci_cb_private *priv_cb_pos,
    struct heci_file_private *file_ext,
    struct io_heci_list *cmpl_list)
{
    struct heci_msg_hdr *heci_hdr;

    _NOTE(ARGUNUSED(cmpl_list));

    if ((*slots * sizeof (uint32_t)) >= (sizeof (struct heci_msg_hdr) +
        dev->iamthif_msg_buf_size -
        dev->iamthif_msg_buf_index)) {
        heci_hdr = (struct heci_msg_hdr *)&dev->wr_msg_buf[0];
        heci_hdr->host_addr = file_ext->host_client_id;
        heci_hdr->me_addr = file_ext->me_client_id;
        heci_hdr->length = dev->iamthif_msg_buf_size -
            dev->iamthif_msg_buf_index;
        heci_hdr->msg_complete = 1;
        heci_hdr->reserved = 0;

        *slots -= (sizeof (struct heci_msg_hdr) +
            heci_hdr->length + 3) / 4;

        if (!heci_write_message(dev, heci_hdr,
            (dev->iamthif_msg_buf +
            dev->iamthif_msg_buf_index),
            heci_hdr->length)) {
            dev->iamthif_state = HECI_IAMTHIF_IDLE;
            file_ext->status = -ENODEV;
            list_del(&priv_cb_pos->cb_list);
            return (-ENODEV);
        } else {
            flow_ctrl_reduce(dev, file_ext);
            dev->iamthif_msg_buf_index += heci_hdr->length;
            priv_cb_pos->information = dev->iamthif_msg_buf_index;
            file_ext->status = 0;
            dev->iamthif_state = HECI_IAMTHIF_FLOW_CONTROL;
            dev->iamthif_flow_control_pending = 1;
            /* save iamthif cb sent to pthi client */
            dev->iamthif_current_cb = priv_cb_pos;
            list_relink_node(&priv_cb_pos->cb_list,
                &dev->write_waiting_list.heci_cb.cb_list);

        }
    } else if (*slots == ((dev->host_hw_state & H_CBD) >> 24)) {
            /* buffer is still empty */
        heci_hdr = (struct heci_msg_hdr *)&dev->wr_msg_buf[0];
        heci_hdr->host_addr = file_ext->host_client_id;
        heci_hdr->me_addr = file_ext->me_client_id;
        heci_hdr->length =
            (*slots * sizeof (uint32_t)) - sizeof (struct heci_msg_hdr);
        heci_hdr->msg_complete = 0;
        heci_hdr->reserved = 0;

        *slots -= (sizeof (struct heci_msg_hdr) +
            heci_hdr->length + 3) / 4;

        if (!heci_write_message(dev, heci_hdr,
            (dev->iamthif_msg_buf +
            dev->iamthif_msg_buf_index),
            heci_hdr->length)) {
            file_ext->status = -ENODEV;
            list_del(&priv_cb_pos->cb_list);
        } else {
            dev->iamthif_msg_buf_index += heci_hdr->length;
        }
        return (-ECOMPLETE_MESSAGE);
    } else {
        return (-ECORRUPTED_MESSAGE_HEADER);
    }

    return (0);
}

/*
 * heci_bh_write_handler - bottom half write routine after
 * ISR to handle the write processing.
 *
 * @cmpl_list: An instance of our list structure
 * @dev: Device object for our driver
 * @slots: slots to write.
 *
 * @return 0 on success, <0 on failure.
 */
static int
heci_bh_write_handler(struct io_heci_list *cmpl_list,
    struct iamt_heci_device *dev,
    int32_t *slots)
{

    struct heci_file_private *file_ext;
    struct heci_cb_private *priv_cb_pos = NULL, *priv_cb_next = NULL;
    struct io_heci_list *list;
    int ret;

    if (!host_buffer_is_empty(dev)) {
        DBG("host buffer is not empty.\n");
        return (0);
    }
    dev->write_hang = (uint8_t)-1;
    *slots = count_empty_write_slots(dev);
    /* complete all waiting for write CB */
    DBG("complete all waiting for write cb.\n");

    list = &dev->write_waiting_list;
    if ((list->status == 0) &&
        !list_empty(&list->heci_cb.cb_list)) {
        list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
            &list->heci_cb.cb_list, cb_list, struct heci_cb_private) {
            file_ext = (struct heci_file_private *)
                    priv_cb_pos->file_private;
            if (file_ext != NULL) {
                file_ext->status = 0;
                list_del(&priv_cb_pos->cb_list);
                if ((HECI_WRITING == file_ext->writing_state) &&
                    (priv_cb_pos->major_file_operations ==
                        HECI_WRITE) &&
                    (file_ext != &dev->iamthif_file_ext)) {
                    DBG("HECI WRITE COMPLETE\n");
                    file_ext->writing_state =
                        HECI_WRITE_COMPLETE;
                    list_add_tail(&priv_cb_pos->cb_list,
                        &cmpl_list->heci_cb.cb_list);
                }
                if (file_ext == &dev->iamthif_file_ext) {
                    DBG("check iamthif flow control.\n");
                    if (dev->iamthif_flow_control_pending) {
                        ret = _heci_bh_iamthif_read(dev,
                                    slots);
                        if (ret != 0)
                            return (ret);
                    }
                }
            }

        }
    }

    if ((dev->stop) && (!dev->wd_pending)) {
        dev->wd_stoped = 1;
        cv_broadcast(&dev->wait_stop_wd);
        return (0);
    }

    if (dev->extra_write_index != 0) {
        DBG("extra_write_index =%d.\n", dev->extra_write_index);
        if (!heci_write_message(dev,
            (struct heci_msg_hdr *)&dev->ext_msg_buf[0],
            (unsigned char *)&dev->ext_msg_buf[1],
            (dev->extra_write_index - 1) * sizeof (uint32_t))) {
            DBG("heci_bh_handler: writing msg failed\n");
        }
        *slots -= dev->extra_write_index;
        dev->extra_write_index = 0;
    }
    if (dev->heci_state == HECI_ENABLED) {
        if (dev->wd_pending &&
            flow_ctrl_creds(dev, &dev->wd_file_ext)) {
            if (!heci_send_wd(dev)) {
                DBG("wd send failed.\n");
            } else
                flow_ctrl_reduce(dev, &dev->wd_file_ext);

            dev->wd_pending = 0;

            if (dev->wd_timeout != 0) {
                *slots -= (sizeof (struct heci_msg_hdr) +
                    HECI_START_WD_DATA_SIZE + 3) / 4;
                dev->wd_due_counter = 2;
            } else {
                *slots -= (sizeof (struct heci_msg_hdr) +
                    HECI_WD_PARAMS_SIZE + 3) / 4;
                dev->wd_due_counter = 0;
            }

        }
    }
    if (dev->stop)
        return (~ENODEV);

    /* complete control write list CB */
    if (dev->ctrl_wr_list.status == 0) {
        /* complete control write list CB */
        DBG("complete control write list cb.\n");
        list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
            &dev->ctrl_wr_list.heci_cb.cb_list,
            cb_list, struct heci_cb_private) {
            file_ext = (struct heci_file_private *)
                priv_cb_pos->file_private;
            if (file_ext == NULL) {
                list_del(&priv_cb_pos->cb_list);
                return (-ENODEV);
            }
            switch (priv_cb_pos->major_file_operations) {
            case HECI_CLOSE:
                /* send disconnect message */
                ret = _heci_bh_close(dev, slots,
                    priv_cb_pos,
                    file_ext, cmpl_list);
                if (ret != 0)
                    return (ret);

                break;
            case HECI_READ:
                /* send flow control message */
                ret = _heci_bh_read(dev, slots,
                    priv_cb_pos,
                    file_ext, cmpl_list);
                if (ret != 0)
                    return (ret);

                break;
            case HECI_IOCTL:
                /* connect message */
                if (!other_client_is_connecting(dev, file_ext))
                    continue;
                ret = _heci_bh_ioctl(dev, slots,
                    priv_cb_pos,
                    file_ext, cmpl_list);
                if (ret != 0)
                    return (ret);

                break;

            default:
                ASSERT(0);
            }

        }
    }
    /* complete  write list CB */
    if ((dev->write_list.status == 0) &&
        !list_empty(&dev->write_list.heci_cb.cb_list)) {

        DBG("complete write list cb.\n");
        list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
            &dev->write_list.heci_cb.cb_list,
            cb_list, struct heci_cb_private) {

            file_ext = (struct heci_file_private *)
                priv_cb_pos->file_private;
            if (file_ext != NULL) {
                if (file_ext != &dev->iamthif_file_ext) {
                    if (!flow_ctrl_creds(dev, file_ext)) {
                        DBG("No flow control"
                            " credentials for client"
                            " %d, not sending.\n",
                            file_ext->host_client_id);
                        continue;
                    }
                    ret = _heci_bh_cmpl(dev, slots,
                        priv_cb_pos, file_ext, cmpl_list);
                    if (ret != 0)
                        return (ret);

                } else if (file_ext == &dev->iamthif_file_ext) {
                    /* IAMTHIF IOCTL */
                    DBG("complete pthi write cb.\n");
                    if (!flow_ctrl_creds(dev, file_ext)) {
                        DBG("No flow control"
                            " credentials for pthi"
                            " client %d.\n",
                            file_ext->host_client_id);
                        continue;
                    }
                    ret = _heci_bh_cmpl_iamthif(dev, slots,
                        priv_cb_pos, file_ext, cmpl_list);
                    if (ret != 0)
                        return (ret);

                }
            }

        }
    }
    return (0);
}


/*
 * is_treat_specially_client  - check if the message belong
 * to the file private data.
 *
 * @file_ext: private data of the file object
 * @rs: connect response bus message
 * @dev: Device object for our driver
 *
 * @return 0 on success, <0 on failure.
 */
static int
is_treat_specially_client(struct heci_file_private *file_ext,
    struct hbm_client_connect_response *rs)
{
    int ret = 0;

    if ((file_ext->host_client_id == rs->host_addr) &&
        (file_ext->me_client_id == rs->me_addr)) {
        if (rs->status == 0) {
            DBG("client connect status = 0x%08x.\n", rs->status);
            file_ext->state = HECI_FILE_CONNECTED;
            file_ext->status = 0;
        } else {
            DBG("client connect status = 0x%08x.\n", rs->status);
            file_ext->state = HECI_FILE_DISCONNECTED;
            file_ext->status = -ENODEV;
        }
        ret = 1;
    }
    DBG("client state = %d.\n", file_ext->state);
    return (ret);
}

/*
 * heci_client_connect_response  - connect response bh routine
 *
 * @dev: Device object for our driver
 * @rs: connect response bus message
 */
static void
heci_client_connect_response(struct iamt_heci_device *dev,
    struct hbm_client_connect_response *rs)
{

    struct heci_file_private *file_ext;
    struct heci_cb_private *priv_cb_pos = NULL, *priv_cb_next = NULL;

    /* if WD or iamthif client treat specially */

    if ((is_treat_specially_client(&(dev->wd_file_ext), rs)) ||
        (is_treat_specially_client(&(dev->iamthif_file_ext), rs)))
        return;

    if (dev->ctrl_rd_list.status == 0 &&
        !list_empty(&dev->ctrl_rd_list.heci_cb.cb_list)) {

        list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
            &dev->ctrl_rd_list.heci_cb.cb_list,
            cb_list, struct heci_cb_private) {

            file_ext = (struct heci_file_private *)
                priv_cb_pos->file_private;
            if (file_ext == NULL) {
                list_del(&priv_cb_pos->cb_list);
                return;
            }
            if (HECI_IOCTL == priv_cb_pos->major_file_operations) {
                if (is_treat_specially_client(file_ext, rs)) {
                    list_del(&priv_cb_pos->cb_list);
                    file_ext->status = 0;
                    file_ext->timer_count = 0;
                    break;
                }
            }
        }
    }
}

/*
 * heci_client_disconnect_response  - disconnect response bh routine
 *
 * @dev: Device object for our driver
 * @rs: disconnect response bus message
 */
static void heci_client_disconnect_response(struct iamt_heci_device *dev,
                    struct hbm_client_connect_response *rs)
{
    struct heci_file_private *file_ext;
    struct heci_cb_private *priv_cb_pos = NULL, *priv_cb_next = NULL;

    if (dev->ctrl_rd_list.status == 0 &&
        !list_empty(&dev->ctrl_rd_list.heci_cb.cb_list)) {

        list_for_each_entry_safe(priv_cb_pos, priv_cb_next,
            &dev->ctrl_rd_list.heci_cb.cb_list,
            cb_list, struct heci_cb_private) {

            file_ext = (struct heci_file_private *)
                priv_cb_pos->file_private;

            if (file_ext == NULL) {
                list_del(&priv_cb_pos->cb_list);
                return;
            }

            DBG("list_for_each_entry_safe in ctrl_rd_list.\n");
            if ((file_ext->host_client_id == rs->host_addr) &&
                (file_ext->me_client_id == rs->me_addr)) {

                list_del(&priv_cb_pos->cb_list);
                if (rs->status == 0) {
                    file_ext->state =
                        HECI_FILE_DISCONNECTED;
                }

                file_ext->status = 0;
                file_ext->timer_count = 0;
                break;
            }
        }
    }
}

/*
 * same_flow_addr - tell they have same address.
 *
 * @file: private data of the file object.
 * @flow: flow control.
 *
 * @return  !=0, same; 0,not.
 */
static int
same_flow_addr(struct heci_file_private *file,
    struct hbm_flow_control *flow)
{
    return ((file->host_client_id == flow->host_addr) &&
        (file->me_client_id == flow->me_addr));
}

/*
 * add_single_flow_creds - add single buffer credentials.
 *
 * @file: private data ot the file object.
 * @flow: flow control.
 */
static void
add_single_flow_creds(struct iamt_heci_device *dev,
    struct hbm_flow_control *flow)
{
    struct heci_me_client *client;
    int i;

    for (i = 0; i < dev->num_heci_me_clients; i++) {
        client = &dev->me_clients[i];
        if ((client != NULL) &&
            (flow->me_addr == client->client_id)) {
            if (client->props.single_recv_buf != 0) {
                client->flow_ctrl_creds++;
                DBG("recv flow ctrl msg ME %d (single).\n",
                    flow->me_addr);
                DBG("flow control credentials=%d.\n",
                    client->flow_ctrl_creds);
            } else {
                ASSERT(0);  /* error in flow control */
            }
        }
    }
}
/*
 * heci_client_flow_control_response  - flow control response bh routine
 *
 * @dev: Device object for our driver
 * @flow_control: flow control response bus message
 */
static void
heci_client_flow_control_response(struct iamt_heci_device *dev,
    struct hbm_flow_control *flow_control)
{
    struct heci_file_private *file_pos = NULL;
    struct heci_file_private *file_next = NULL;

    if (flow_control->host_addr == 0) {
        /* single receive buffer */
        add_single_flow_creds(dev, flow_control);
    } else {
        /* normal connection */
        list_for_each_entry_safe(file_pos, file_next,
            &dev->file_list, link, struct heci_file_private) {
            DBG("list_for_each_entry_safe in file_list\n");

            DBG("file_ext of host client %d ME client %d.\n",
                file_pos->host_client_id,
                file_pos->me_client_id);
            DBG("flow ctrl msg for host %d ME %d.\n",
                flow_control->host_addr,
                flow_control->me_addr);
            if (same_flow_addr(file_pos, flow_control)) {
                DBG("recv ctrl msg for host  %d ME %d.\n",
                    flow_control->host_addr,
                    flow_control->me_addr);
                file_pos->flow_ctrl_creds++;
                DBG("flow control credentials=%d.\n",
                    file_pos->flow_ctrl_creds);
                break;
            }
        }
    }
}

/*
 * same_disconn_addr - tell they have same address
 *
 * @file: private data of the file object.
 * @disconn: disconnection request.
 *
 * @return !=0, same; 0,not.
 */
static int
same_disconn_addr(struct heci_file_private *file,
    struct hbm_client_disconnect_request *disconn)
{
    return ((file->host_client_id == disconn->host_addr) &&
        (file->me_client_id == disconn->me_addr));
}

/*
 * heci_client_disconnect_request  - disconnect request bh routine
 *
 * @dev: Device object for our driver.
 * @disconnect_req: disconnect request bus message.
 */
static void
heci_client_disconnect_request(struct iamt_heci_device *dev,
        struct hbm_client_disconnect_request *disconnect_req)
{
    struct heci_msg_hdr *heci_hdr;
    struct hbm_client_connect_response *disconnect_res;
    struct heci_file_private *file_pos = NULL;
    struct heci_file_private *file_next = NULL;

    list_for_each_entry_safe(file_pos, file_next, &dev->file_list,
        link, struct heci_file_private) {

        if (same_disconn_addr(file_pos, disconnect_req)) {
            DBG("disconnect request host client %d ME client %d.\n",
                disconnect_req->host_addr,
                disconnect_req->me_addr);
            file_pos->state = HECI_FILE_DISCONNECTED;
            file_pos->timer_count = 0;
            if (file_pos == &dev->wd_file_ext) {
                dev->wd_due_counter = 0;
                dev->wd_pending = 0;
            } else if (file_pos == &dev->iamthif_file_ext)
                dev->iamthif_timer = 0;

            /* prepare disconnect response */
            heci_hdr =
                (struct heci_msg_hdr *)&dev->ext_msg_buf[0];
            heci_hdr->host_addr = 0;
            heci_hdr->me_addr = 0;
            heci_hdr->length =
                sizeof (struct hbm_client_connect_response);
            heci_hdr->msg_complete = 1;
            heci_hdr->reserved = 0;

            disconnect_res =
                (struct hbm_client_connect_response *)
                &dev->ext_msg_buf[1];
            disconnect_res->host_addr = file_pos->host_client_id;
            disconnect_res->me_addr = file_pos->me_client_id;
            *(uint8_t *)(&disconnect_res->cmd) =
                CLIENT_DISCONNECT_RES_CMD;
            disconnect_res->status = 0;
            dev->extra_write_index = 2;
            break;
        }
    }
}

/*
 * heci_timer - timer function.
 *
 * @data: pointer to the device structure
 *
 * NOTE: This function is called by timer interrupt work
 */
void
heci_wd_timer(void *data)
{
    struct iamt_heci_device *dev = (struct iamt_heci_device *)data;

    DBG("send watchdog.\n");
    mutex_enter(&dev->device_lock);
    if (dev->heci_state != HECI_ENABLED) {
        dev->wd_timer = timeout(heci_wd_timer, data, 2 * HZ);
        mutex_exit(&dev->device_lock);
        return;
    }
    if (dev->wd_file_ext.state != HECI_FILE_CONNECTED) {
        dev->wd_timer = timeout(heci_wd_timer, data, 2 * HZ);
        mutex_exit(&dev->device_lock);
        return;
    }
    /* Watchdog */
    if ((dev->wd_due_counter != 0) && (dev->wd_bypass == 0)) {
        if (--dev->wd_due_counter == 0) {
            if (dev->host_buffer_is_empty &&
                flow_ctrl_creds(dev, &dev->wd_file_ext)) {
                dev->host_buffer_is_empty = 0;
                if (!heci_send_wd(dev)) {
                    DBG("wd send failed.\n");
                } else {
                    flow_ctrl_reduce(dev,
                        &dev->wd_file_ext);
                }

                if (dev->wd_timeout != 0)
                    dev->wd_due_counter = 2;
                else
                    dev->wd_due_counter = 0;

            } else
                dev->wd_pending = 1;

        }
    }
    if (dev->iamthif_stall_timer != 0) {
        if (--dev->iamthif_stall_timer == 0) {
            DBG("reseting because of hang to PTHI.\n");
            heci_reset(dev, 1);
            dev->iamthif_msg_buf_size = 0;
            dev->iamthif_msg_buf_index = 0;
            dev->iamthif_canceled = 0;
            dev->iamthif_ioctl = 1;
            dev->iamthif_state = HECI_IAMTHIF_IDLE;
            dev->iamthif_timer = 0;
            mutex_exit(&dev->device_lock);

            if (dev->iamthif_current_cb)
                heci_free_cb_private(dev->iamthif_current_cb);

            mutex_enter(&dev->device_lock);
            dev->iamthif_file_object = NULL;
            dev->iamthif_current_cb = NULL;
            run_next_iamthif_cmd(dev);
        }
    }
    dev->wd_timer = timeout(heci_wd_timer, data, 2 * HZ);
    mutex_exit(&dev->device_lock);
}