/*
 * Copyright (c) 2005-2011 Atheros Communications Inc.
 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <string.h>

#include "core.h"
#include "debug.h"
#include "hif.h"

/********/
/* Send */
/********/

static void ath10k_htc_control_tx_complete(struct ath10k* ar, struct ath10k_msg_buf* msg_buf) {
    ath10k_msg_buf_free(msg_buf);
}

void ath10k_htc_notify_tx_completion(struct ath10k_htc_ep* ep, struct ath10k_msg_buf* msg_buf) {
    if (!ep->ep_ops.ep_tx_complete) {
        ath10k_warn("no tx handler for eid %d\n", ep->eid);
        ath10k_msg_buf_free(msg_buf);
        return;
    }

    ep->ep_ops.ep_tx_complete(ep->htc->ar, msg_buf);
}

static void ath10k_htc_prepare_tx_buf(struct ath10k_htc_ep* ep, struct ath10k_msg_buf* msg_buf) {
    struct ath10k_htc_hdr* hdr = ath10k_msg_buf_get_header(msg_buf, ATH10K_MSG_TYPE_HTC);
    hdr->eid = ep->eid;
    hdr->len = ath10k_msg_buf_get_payload_len(msg_buf, ATH10K_MSG_TYPE_HTC);
    hdr->flags = ATH10K_HTC_FLAG_NEED_CREDIT_UPDATE;

    mtx_lock(&ep->htc->tx_lock);
    hdr->seq_no = ep->seq_no++;
    mtx_unlock(&ep->htc->tx_lock);
}

zx_status_t ath10k_htc_send(struct ath10k_htc* htc, enum ath10k_htc_ep_id eid,
                            struct ath10k_msg_buf* msg_buf) {
    struct ath10k* ar = htc->ar;
    struct ath10k_htc_ep* ep = &htc->endpoint[eid];
    struct ath10k_hif_sg_item sg_item;
    int credits = 0;
    int ret;

    if (htc->ar->state == ATH10K_STATE_WEDGED) { return ZX_ERR_BAD_STATE; }

    if (eid >= ATH10K_HTC_EP_COUNT) {
        ath10k_warn("Invalid endpoint id: %d\n", eid);
        return ZX_ERR_OUT_OF_RANGE;
    }

    if (ep->tx_credit_flow_enabled) {
        credits = DIV_ROUNDUP(msg_buf->used, htc->target_credit_size);
        mtx_lock(&htc->tx_lock);
        if (ep->tx_credits < credits) {
            ath10k_dbg(ar, ATH10K_DBG_HTC,
                       "htc insufficient credits ep %d required %d available %d\n", eid, credits,
                       ep->tx_credits);
            mtx_unlock(&htc->tx_lock);
            ret = ZX_ERR_SHOULD_WAIT;
            goto err_done;
        }
        ep->tx_credits -= credits;
        ath10k_dbg(ar, ATH10K_DBG_HTC, "htc ep %d consumed %d credits (total %d)\n", eid, credits,
                   ep->tx_credits);
        mtx_unlock(&htc->tx_lock);
    }

    ath10k_htc_prepare_tx_buf(ep, msg_buf);

    sg_item.transfer_id = ep->eid;
    sg_item.transfer_context = msg_buf;
    sg_item.vaddr = msg_buf->vaddr;
    sg_item.paddr = msg_buf->paddr;
    sg_item.len = msg_buf->used;

    ret = ath10k_hif_tx_sg(htc->ar, ep->ul_pipe_id, &sg_item, 1);
    if (ret != ZX_OK) { goto err_credits; }

    return ZX_OK;

err_credits:
    if (ep->tx_credit_flow_enabled) {
        mtx_lock(&htc->tx_lock);
        ep->tx_credits += credits;
        ath10k_dbg(ar, ATH10K_DBG_HTC, "htc ep %d reverted %d credits back (total %d)\n", eid,
                   credits, ep->tx_credits);
        mtx_unlock(&htc->tx_lock);

        if (ep->ep_ops.ep_tx_credits) { ep->ep_ops.ep_tx_credits(htc->ar); }
    }
err_done:
    return ret;
}

void ath10k_htc_tx_completion_handler(struct ath10k* ar, struct ath10k_msg_buf* msg_buf) {
    struct ath10k_htc* htc = &ar->htc;
    struct ath10k_htc_ep* ep;

    struct ath10k_htc_hdr* htc_hdr = ath10k_msg_buf_get_header(msg_buf, ATH10K_MSG_TYPE_HTC);
    ep = &htc->endpoint[htc_hdr->eid];

    ath10k_htc_notify_tx_completion(ep, msg_buf);
    /* the msg_buf now belongs to the completion handler */
}

/***********/
/* Receive */
/***********/

static void ath10k_htc_process_credit_report(struct ath10k_htc* htc,
                                             const struct ath10k_htc_credit_report* report, int len,
                                             enum ath10k_htc_ep_id eid) {
    struct ath10k* ar = htc->ar;
    struct ath10k_htc_ep* ep;
    int i, n_reports;

    if (len % sizeof(*report)) { ath10k_warn("Uneven credit report len %d", len); }

    n_reports = len / sizeof(*report);

    mtx_lock(&htc->tx_lock);
    for (i = 0; i < n_reports; i++, report++) {
        if (report->eid >= ATH10K_HTC_EP_COUNT) { break; }

        ep = &htc->endpoint[report->eid];
        ep->tx_credits += report->credits;

        ath10k_dbg(ar, ATH10K_DBG_HTC, "htc ep %d got %d credits (total %d)\n", report->eid,
                   report->credits, ep->tx_credits);

        if (ep->ep_ops.ep_tx_credits) {
            mtx_unlock(&htc->tx_lock);
            ep->ep_ops.ep_tx_credits(htc->ar);
            mtx_lock(&htc->tx_lock);
        }
    }
    mtx_unlock(&htc->tx_lock);
}

static zx_status_t ath10k_htc_process_lookahead(struct ath10k_htc* htc,
                                                const struct ath10k_htc_lookahead_report* report,
                                                int len, enum ath10k_htc_ep_id eid,
                                                void* next_lookaheads, int* next_lookaheads_len) {
    struct ath10k* ar = htc->ar;

    /* Invalid lookahead flags are actually transmitted by
     * the target in the HTC control message.
     * Since this will happen at every boot we silently ignore
     * the lookahead in this case
     */
    if (report->pre_valid != ((~report->post_valid) & 0xFF)) { return ZX_OK; }

    if (next_lookaheads && next_lookaheads_len) {
        ath10k_dbg(ar, ATH10K_DBG_HTC, "htc rx lookahead found pre_valid 0x%x post_valid 0x%x\n",
                   report->pre_valid, report->post_valid);

        /* look ahead bytes are valid, copy them over */
        memcpy((uint8_t*)next_lookaheads, report->lookahead, 4);

        *next_lookaheads_len = 1;
    }

    return ZX_OK;
}

static zx_status_t ath10k_htc_process_lookahead_bundle(
    struct ath10k_htc* htc, const struct ath10k_htc_lookahead_bundle* report, int len,
    enum ath10k_htc_ep_id eid, void* next_lookaheads, int* next_lookaheads_len) {
    int bundle_cnt = len / sizeof(*report);

    if (!bundle_cnt || (bundle_cnt > HTC_HOST_MAX_MSG_PER_BUNDLE)) {
        ath10k_warn("Invalid lookahead bundle count: %d\n", bundle_cnt);
        return ZX_ERR_BUFFER_TOO_SMALL;
    }

    if (next_lookaheads && next_lookaheads_len) {
        int i;

        for (i = 0; i < bundle_cnt; i++) {
            memcpy(((uint8_t*)next_lookaheads) + 4 * i, report->lookahead, 4);
            report++;
        }

        *next_lookaheads_len = bundle_cnt;
    }

    return ZX_OK;
}

zx_status_t ath10k_htc_process_trailer(struct ath10k_htc* htc, uint8_t* buffer, int length,
                                       enum ath10k_htc_ep_id src_eid, void* next_lookaheads,
                                       int* next_lookaheads_len) {
    struct ath10k_htc_lookahead_bundle* bundle;
    struct ath10k* ar = htc->ar;
    int status = ZX_OK;
    struct ath10k_htc_record* record;
    uint8_t* orig_buffer;
    int orig_length;
    size_t len;

    orig_buffer = buffer;
    orig_length = length;

    while (length > 0) {
        record = (struct ath10k_htc_record*)buffer;

        if (length < (int)sizeof(record->hdr)) {
            status = ZX_ERR_BUFFER_TOO_SMALL;
            break;
        }

        if (record->hdr.len > length) {
            /* no room left in buffer for record */
            ath10k_warn("Invalid record length: %d\n", record->hdr.len);
            status = ZX_ERR_BUFFER_TOO_SMALL;
            break;
        }

        switch (record->hdr.id) {
        case ATH10K_HTC_RECORD_CREDITS:
            len = sizeof(struct ath10k_htc_credit_report);
            if (record->hdr.len < len) {
                ath10k_warn("Credit report too long\n");
                status = ZX_ERR_BUFFER_TOO_SMALL;
                break;
            }
            ath10k_htc_process_credit_report(htc, record->credit_report, record->hdr.len, src_eid);
            break;
        case ATH10K_HTC_RECORD_LOOKAHEAD:
            len = sizeof(struct ath10k_htc_lookahead_report);
            if (record->hdr.len < len) {
                ath10k_warn("Lookahead report too long\n");
                status = ZX_ERR_BUFFER_TOO_SMALL;
                break;
            }
            status = ath10k_htc_process_lookahead(htc, record->lookahead_report, record->hdr.len,
                                                  src_eid, next_lookaheads, next_lookaheads_len);
            break;
        case ATH10K_HTC_RECORD_LOOKAHEAD_BUNDLE:
            bundle = record->lookahead_bundle;
            status = ath10k_htc_process_lookahead_bundle(htc, bundle, record->hdr.len, src_eid,
                                                         next_lookaheads, next_lookaheads_len);
            break;
        default:
            ath10k_warn("Unhandled record: id:%d length:%d\n", record->hdr.id, record->hdr.len);
            break;
        }

        if (status != ZX_OK) { break; }

        /* multiple records may be present in a trailer */
        buffer += sizeof(record->hdr) + record->hdr.len;
        length -= sizeof(record->hdr) + record->hdr.len;
    }

    if (status != ZX_OK)
        ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc rx bad trailer", "", orig_buffer, orig_length);

    return status;
}

void ath10k_htc_rx_completion_handler(struct ath10k* ar, struct ath10k_msg_buf* msg_buf) {
    int status = ZX_OK;
    struct ath10k_htc* htc = &ar->htc;
    struct ath10k_htc_hdr* hdr;
    struct ath10k_htc_ep* ep;
    uint16_t payload_len;
    uint32_t trailer_len = 0;
    size_t min_len;
    uint8_t eid;
    bool trailer_present;

    hdr = ath10k_msg_buf_get_header(msg_buf, ATH10K_MSG_TYPE_HTC);

    msg_buf->used = sizeof(*hdr) + hdr->len;
    ZX_DEBUG_ASSERT(msg_buf->used <= msg_buf->capacity);

    eid = hdr->eid;

    if (eid >= ATH10K_HTC_EP_COUNT) {
        ath10k_warn("HTC Rx: invalid eid %d\n", eid);
        ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc bad header", "", hdr, sizeof(*hdr));
        goto out;
    }

    ep = &htc->endpoint[eid];

    payload_len = hdr->len;

    if (payload_len + sizeof(*hdr) > ATH10K_HTC_MAX_LEN) {
        ath10k_warn("HTC rx frame too long, len: %zu\n", payload_len + sizeof(*hdr));
        ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc bad rx pkt len", "", hdr, sizeof(*hdr));
        goto out;
    }

    size_t actual_payload_sz = ath10k_msg_buf_get_payload_len(msg_buf, ATH10K_MSG_TYPE_HTC);
    if (actual_payload_sz < payload_len) {
        ath10k_err("HTC Rx: insufficient length, got %zu, expected %d\n", actual_payload_sz,
                   payload_len);
        ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc bad rx pkt len", "", hdr, sizeof(*hdr));
        goto out;
    }

    /* get flags to check for trailer */
    trailer_present = hdr->flags & ATH10K_HTC_FLAG_TRAILER_PRESENT;
    if (trailer_present) {
        uint8_t* trailer;

        trailer_len = hdr->trailer_len;
        min_len = sizeof(struct ath10k_ath10k_htc_record_hdr);

        if ((trailer_len < min_len) || (trailer_len > payload_len)) {
            ath10k_warn("Invalid trailer length: %d\n", trailer_len);
            goto out;
        }

        trailer = (uint8_t*)hdr;
        trailer += sizeof(*hdr);
        trailer += payload_len;
        trailer -= trailer_len;
        status = ath10k_htc_process_trailer(htc, trailer, trailer_len, hdr->eid, NULL, NULL);
        if (status) { goto out; }

        msg_buf->used -= trailer_len;
    }

    if (((int)payload_len - (int)trailer_len) <= 0)
    /* zero length packet with trailer data, just drop these */
    {
        goto out;
    }

    ath10k_dbg(ar, ATH10K_DBG_HTC, "htc rx completion ep %d msg_buf %pK\n", eid, msg_buf);
    ep->ep_ops.ep_rx_complete(ar, msg_buf);

    /* msg_buf is now owned by the rx completion handler */
    return;

out:
    ath10k_msg_buf_free(msg_buf);
}

static void ath10k_htc_control_rx_complete(struct ath10k* ar, struct ath10k_msg_buf* msg_buf) {
    struct ath10k_htc* htc = &ar->htc;
    struct ath10k_htc_msg* msg = ath10k_msg_buf_get_header(msg_buf, ATH10K_MSG_TYPE_HTC_MSG);

    switch (msg->hdr.message_id) {
    case ATH10K_HTC_MSG_READY_ID:
    case ATH10K_HTC_MSG_CONNECT_SERVICE_RESP_ID:
        /* handle HTC control message */
        if (sync_completion_wait(&htc->ctl_resp, 0) == ZX_OK) {
            /* this is a fatal error, target should not be
             * sending unsolicited messages on the ep 0
             */
            ath10k_warn("HTC rx ctrl still processing\n");
            sync_completion_signal(&htc->ctl_resp);
            goto out;
        }

        size_t msg_len = ath10k_msg_buf_get_payload_len(msg_buf, ATH10K_MSG_TYPE_HTC_MSG);
        htc->control_resp_len = MIN_T(int, msg_len, ATH10K_HTC_MAX_CTRL_MSG_LEN);

        memcpy(htc->control_resp_buffer, msg, htc->control_resp_len);

        sync_completion_signal(&htc->ctl_resp);
        break;
    case ATH10K_HTC_MSG_SEND_SUSPEND_COMPLETE:
        htc->htc_ops.target_send_suspend_complete(ar);
        break;
    default:
        ath10k_warn("ignoring unsolicited htc ep0 event\n");
        break;
    }

out:
    ath10k_msg_buf_free(msg_buf);
}

/***************/
/* Init/Deinit */
/***************/

static const char* htc_service_name(enum ath10k_htc_svc_id id) {
    switch (id) {
    case ATH10K_HTC_SVC_ID_RESERVED:
        return "Reserved";
    case ATH10K_HTC_SVC_ID_RSVD_CTRL:
        return "Control";
    case ATH10K_HTC_SVC_ID_WMI_CONTROL:
        return "WMI";
    case ATH10K_HTC_SVC_ID_WMI_DATA_BE:
        return "DATA BE";
    case ATH10K_HTC_SVC_ID_WMI_DATA_BK:
        return "DATA BK";
    case ATH10K_HTC_SVC_ID_WMI_DATA_VI:
        return "DATA VI";
    case ATH10K_HTC_SVC_ID_WMI_DATA_VO:
        return "DATA VO";
    case ATH10K_HTC_SVC_ID_NMI_CONTROL:
        return "NMI Control";
    case ATH10K_HTC_SVC_ID_NMI_DATA:
        return "NMI Data";
    case ATH10K_HTC_SVC_ID_HTT_DATA_MSG:
        return "HTT Data";
    case ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS:
        return "RAW";
    }

    return "Unknown";
}

static void ath10k_htc_reset_endpoint_states(struct ath10k_htc* htc) {
    struct ath10k_htc_ep* ep;
    int i;

    for (i = ATH10K_HTC_EP_0; i < ATH10K_HTC_EP_COUNT; i++) {
        ep = &htc->endpoint[i];
        ep->service_id = ATH10K_HTC_SVC_ID_UNUSED;
        ep->max_ep_message_len = 0;
        ep->max_tx_queue_depth = 0;
        ep->eid = i;
        ep->htc = htc;
        ep->tx_credit_flow_enabled = true;
    }
}

static uint8_t ath10k_htc_get_credit_allocation(struct ath10k_htc* htc, uint16_t service_id) {
    uint8_t allocation = 0;

    /* The WMI control service is the only service with flow control.
     * Let it have all transmit credits.
     */
    if (service_id == ATH10K_HTC_SVC_ID_WMI_CONTROL) { allocation = htc->total_transmit_credits; }

    return allocation;
}

static zx_status_t ath10k_htc_wait_ctl_resp(struct ath10k_htc* htc) {
    struct ath10k* ar = htc->ar;
    int i;
    zx_status_t status = sync_completion_wait(&htc->ctl_resp, ATH10K_HTC_WAIT_TIMEOUT);
    if (status == ZX_ERR_TIMED_OUT) {
        /* Workaround: In some cases the PCI HIF doesn't
         * receive interrupt for the control response message
         * even if the buffer was completed. It is suspected
         * iomap writes unmasking PCI CE irqs aren't propagated
         * properly in KVM PCI-passthrough sometimes.
         * Some symptoms are described in NET-992.
         */
        ath10k_warn("failed to receive control response completion, polling..\n");

        for (i = 0; i < CE_COUNT; i++) {
            ath10k_hif_send_complete_check(ar, i, 1);
        }

        status = sync_completion_wait(&htc->ctl_resp, ATH10K_HTC_WAIT_TIMEOUT);
    }
    return status;
}

zx_status_t ath10k_htc_wait_target(struct ath10k_htc* htc) {
    struct ath10k* ar = htc->ar;
    zx_status_t status = ZX_OK;
    struct ath10k_htc_msg* msg;
    uint16_t message_id;

    status = ath10k_htc_wait_ctl_resp(htc);
    if (status != ZX_OK) {
        ath10k_err("ctl_resp never came in (%d)\n", status);
        return status;
    }

    if ((size_t)htc->control_resp_len < sizeof(msg->hdr) + sizeof(msg->ready)) {
        ath10k_err("Invalid HTC ready msg len:%d\n", htc->control_resp_len);
        return ZX_ERR_IO;
    }

    msg = (struct ath10k_htc_msg*)htc->control_resp_buffer;
    message_id = msg->hdr.message_id;

    if (message_id != ATH10K_HTC_MSG_READY_ID) {
        ath10k_err("Invalid HTC ready msg: 0x%x\n", message_id);
        return ZX_ERR_IO;
    }

    htc->total_transmit_credits = msg->ready.credit_count;
    htc->target_credit_size = msg->ready.credit_size;

    ath10k_dbg(ar, ATH10K_DBG_HTC, "Target ready! transmit resources: %d size:%d\n",
               htc->total_transmit_credits, htc->target_credit_size);

    if ((htc->total_transmit_credits == 0) || (htc->target_credit_size == 0)) {
        ath10k_err("Invalid credit size received\n");
        return ZX_ERR_IO;
    }

    /* The only way to determine if the ready message is an extended
     * message is from the size.
     */
    if ((size_t)htc->control_resp_len >= sizeof(msg->hdr) + sizeof(msg->ready_ext)) {
        htc->max_msgs_per_htc_bundle =
            MIN_T(uint8_t, msg->ready_ext.max_msgs_per_htc_bundle, HTC_HOST_MAX_MSG_PER_BUNDLE);
        ath10k_dbg(ar, ATH10K_DBG_HTC, "Extended ready message. RX bundle size: %d\n",
                   htc->max_msgs_per_htc_bundle);
    }

    return ZX_OK;
}

zx_status_t ath10k_htc_connect_service(struct ath10k_htc* htc,
                                       struct ath10k_htc_svc_conn_req* conn_req,
                                       struct ath10k_htc_svc_conn_resp* conn_resp) {
    struct ath10k* ar = htc->ar;
    struct ath10k_htc_msg* msg;
    struct ath10k_htc_conn_svc* req_msg;
    struct ath10k_htc_conn_svc_response resp_msg_dummy;
    struct ath10k_htc_conn_svc_response* resp_msg = &resp_msg_dummy;
    enum ath10k_htc_ep_id assigned_eid = ATH10K_HTC_EP_COUNT;
    struct ath10k_htc_ep* ep;
    struct ath10k_msg_buf* msg_buf;
    unsigned int max_msg_size = 0;
    int resp_length;
    zx_status_t status;
    bool disable_credit_flow_ctrl = false;
    uint16_t message_id, service_id, flags = 0;
    uint8_t tx_alloc = 0;

    /* special case for HTC pseudo control service */
    if (conn_req->service_id == ATH10K_HTC_SVC_ID_RSVD_CTRL) {
        disable_credit_flow_ctrl = true;
        assigned_eid = ATH10K_HTC_EP_0;
        max_msg_size = ATH10K_HTC_MAX_CTRL_MSG_LEN;
        memset(&resp_msg_dummy, 0, sizeof(resp_msg_dummy));
        goto setup;
    }

    tx_alloc = ath10k_htc_get_credit_allocation(htc, conn_req->service_id);
    if (!tx_alloc) {
        ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot htc service %s does not allocate target credits\n",
                   htc_service_name(conn_req->service_id));
    }

    status = ath10k_msg_buf_alloc(htc->ar, &msg_buf, ATH10K_MSG_TYPE_HTC_CONN_SVC, 0);
    if (status != ZX_OK) { return status; }

    msg = ath10k_msg_buf_get_header(msg_buf, ATH10K_MSG_TYPE_HTC_MSG);
    msg->hdr.message_id = ATH10K_HTC_MSG_CONNECT_SERVICE_ID;

    flags |= SM(tx_alloc, ATH10K_HTC_CONN_FLAGS_RECV_ALLOC);

    /* Only enable credit flow control for WMI ctrl service */
    if (conn_req->service_id != ATH10K_HTC_SVC_ID_WMI_CONTROL) {
        flags |= ATH10K_HTC_CONN_FLAGS_DISABLE_CREDIT_FLOW_CTRL;
        disable_credit_flow_ctrl = true;
    }

    req_msg = &msg->connect_service;
    req_msg->flags = flags;
    req_msg->service_id = conn_req->service_id;

    sync_completion_reset(&htc->ctl_resp);

    status = ath10k_htc_send(htc, ATH10K_HTC_EP_0, msg_buf);
    if (status != ZX_OK) {
        ath10k_err("Failed to send connection request: %s\n", zx_status_get_string(status));
        ath10k_msg_buf_free(msg_buf);
        return status;
    }

    /* wait for response */
    status = ath10k_htc_wait_ctl_resp(htc);
    if (status != ZX_OK) {
        ath10k_err("Service connect error: %s\n", zx_status_get_string(status));
        ath10k_msg_buf_free(msg_buf);
        return status;
    }

    /* we controlled the buffer creation, it's aligned */
    msg = (struct ath10k_htc_msg*)htc->control_resp_buffer;
    resp_msg = &msg->connect_service_response;
    message_id = msg->hdr.message_id;
    service_id = resp_msg->service_id;

    resp_length = sizeof(msg->hdr) + sizeof(msg->connect_service_response);
    if ((message_id != ATH10K_HTC_MSG_CONNECT_SERVICE_RESP_ID) ||
        (htc->control_resp_len < resp_length)) {
        ath10k_err("Invalid resp message ID 0x%x", message_id);
        return ZX_ERR_BAD_STATE;
    }

    ath10k_dbg(ar, ATH10K_DBG_HTC,
               "HTC Service %s connect response: status: 0x%x, assigned ep: 0x%x\n",
               htc_service_name(service_id), resp_msg->status, resp_msg->eid);

    conn_resp->connect_resp_code = resp_msg->status;

    /* check response status */
    if (resp_msg->status != ATH10K_HTC_CONN_SVC_STATUS_SUCCESS) {
        ath10k_err("HTC Service %s connect request failed: 0x%x)\n", htc_service_name(service_id),
                   resp_msg->status);
        return ZX_ERR_BAD_STATE;
    }

    assigned_eid = (enum ath10k_htc_ep_id)resp_msg->eid;
    max_msg_size = resp_msg->max_msg_size;

setup:

    if (assigned_eid >= ATH10K_HTC_EP_COUNT) { return ZX_ERR_OUT_OF_RANGE; }

    if (max_msg_size == 0) { return ZX_ERR_OUT_OF_RANGE; }

    ep = &htc->endpoint[assigned_eid];
    ep->eid = assigned_eid;

    if (ep->service_id != ATH10K_HTC_SVC_ID_UNUSED) { return ZX_ERR_OUT_OF_RANGE; }

    /* return assigned endpoint to caller */
    conn_resp->eid = assigned_eid;
    conn_resp->max_msg_len = resp_msg->max_msg_size;

    /* setup the endpoint */
    ep->service_id = conn_req->service_id;
    ep->max_tx_queue_depth = conn_req->max_send_queue_depth;
    ep->max_ep_message_len = resp_msg->max_msg_size;
    ep->tx_credits = tx_alloc;

    /* copy all the callbacks */
    ep->ep_ops = conn_req->ep_ops;

    status =
        ath10k_hif_map_service_to_pipe(htc->ar, ep->service_id, &ep->ul_pipe_id, &ep->dl_pipe_id);
    if (status != ZX_OK) { return status; }

    ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot htc service '%s' ul pipe %d dl pipe %d eid %d ready\n",
               htc_service_name(ep->service_id), ep->ul_pipe_id, ep->dl_pipe_id, ep->eid);

    if (disable_credit_flow_ctrl && ep->tx_credit_flow_enabled) {
        ep->tx_credit_flow_enabled = false;
        ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot htc service '%s' eid %d TX flow control disabled\n",
                   htc_service_name(ep->service_id), assigned_eid);
    }

    return status;
}

zx_status_t ath10k_htc_start(struct ath10k_htc* htc) {
    struct ath10k* ar = htc->ar;
    struct ath10k_msg_buf* msg_buf;
    zx_status_t status;
    struct ath10k_htc_msg* msg;

    status = ath10k_msg_buf_alloc(htc->ar, &msg_buf, ATH10K_MSG_TYPE_HTC_SETUP_COMPLETE_EXT, 0);
    if (status != ZX_OK) { return status; }

    msg = ath10k_msg_buf_get_header(msg_buf, ATH10K_MSG_TYPE_HTC_MSG);
    msg->hdr.message_id = ATH10K_HTC_MSG_SETUP_COMPLETE_EX_ID;

    if (ar->hif.bus == ATH10K_BUS_SDIO) {
        /* Extra setup params used by SDIO */
        msg->setup_complete_ext.flags = ATH10K_HTC_SETUP_COMPLETE_FLAGS_RX_BNDL_EN;
        msg->setup_complete_ext.max_msgs_per_bundled_recv = htc->max_msgs_per_htc_bundle;
    }
    ath10k_dbg(ar, ATH10K_DBG_HTC, "HTC is using TX credit flow control\n");

    status = ath10k_htc_send(htc, ATH10K_HTC_EP_0, msg_buf);
    if (status != ZX_OK) {
        ath10k_msg_buf_free(msg_buf);
        return status;
    }

    return ZX_OK;
}

/* registered target arrival callback from the HIF layer */
zx_status_t ath10k_htc_init(struct ath10k* ar) {
    zx_status_t status;
    struct ath10k_htc* htc = &ar->htc;
    struct ath10k_htc_svc_conn_req conn_req;
    struct ath10k_htc_svc_conn_resp conn_resp;

    mtx_init(&htc->tx_lock, mtx_plain);

    ath10k_htc_reset_endpoint_states(htc);

    htc->ar = ar;

    /* setup our pseudo HTC control endpoint connection */
    memset(&conn_req, 0, sizeof(conn_req));
    memset(&conn_resp, 0, sizeof(conn_resp));
    conn_req.ep_ops.ep_tx_complete = ath10k_htc_control_tx_complete;
    conn_req.ep_ops.ep_rx_complete = ath10k_htc_control_rx_complete;
    conn_req.max_send_queue_depth = ATH10K_NUM_CONTROL_TX_BUFFERS;
    conn_req.service_id = ATH10K_HTC_SVC_ID_RSVD_CTRL;

    /* connect fake service */
    status = ath10k_htc_connect_service(htc, &conn_req, &conn_resp);
    if (status != ZX_OK) {
        ath10k_err("could not connect to htc service (%d)\n", status);
        return status;
    }

    htc->ctl_resp = SYNC_COMPLETION_INIT;

    return ZX_OK;
}