/*
 * Copyright (c) 2007-2011 Atheros Communications 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 "core.h"
#include "debug.h"
#include "hif-ops.h"

#define HTC_PACKET_CONTAINER_ALLOCATION 32
#define HTC_CONTROL_BUFFER_SIZE (HTC_MAX_CTRL_MSG_LEN + HTC_HDR_LENGTH)

static int ath6kl_htc_pipe_tx(struct htc_target *handle,
                              struct htc_packet *packet);
static void ath6kl_htc_pipe_cleanup(struct htc_target *handle);

/* htc pipe tx path */
static inline void restore_tx_packet(struct htc_packet *packet)
{
        if (packet->info.tx.flags & HTC_FLAGS_TX_FIXUP_NETBUF) {
                skb_pull(packet->skb, sizeof(struct htc_frame_hdr));
                packet->info.tx.flags &= ~HTC_FLAGS_TX_FIXUP_NETBUF;
        }
}

static void do_send_completion(struct htc_endpoint *ep,
                               struct list_head *queue_to_indicate)
{
        struct htc_packet *packet;

        if (list_empty(queue_to_indicate)) {
                /* nothing to indicate */
                return;
        }

        if (ep->ep_cb.tx_comp_multi != NULL) {
                ath6kl_dbg(ATH6KL_DBG_HTC,
                           "%s: calling ep %d, send complete multiple callback (%d pkts)\n",
                           __func__, ep->eid,
                           get_queue_depth(queue_to_indicate));
                /*
                 * a multiple send complete handler is being used,
                 * pass the queue to the handler
                 */
                ep->ep_cb.tx_comp_multi(ep->target, queue_to_indicate);
                /*
                 * all packets are now owned by the callback,
                 * reset queue to be safe
                 */
                INIT_LIST_HEAD(queue_to_indicate);
        } else {
                /* using legacy EpTxComplete */
                do {
                        packet = list_first_entry(queue_to_indicate,
                                                  struct htc_packet, list);

                        list_del(&packet->list);
                        ath6kl_dbg(ATH6KL_DBG_HTC,
                                   "%s: calling ep %d send complete callback on packet 0x%p\n",
                                   __func__, ep->eid, packet);
                        ep->ep_cb.tx_complete(ep->target, packet);
                } while (!list_empty(queue_to_indicate));
        }
}

static void send_packet_completion(struct htc_target *target,
                                   struct htc_packet *packet)
{
        struct htc_endpoint *ep = &target->endpoint[packet->endpoint];
        struct list_head container;

        restore_tx_packet(packet);
        INIT_LIST_HEAD(&container);
        list_add_tail(&packet->list, &container);

        /* do completion */
        do_send_completion(ep, &container);
}

static void get_htc_packet_credit_based(struct htc_target *target,
                                        struct htc_endpoint *ep,
                                        struct list_head *queue)
{
        int credits_required;
        int remainder;
        u8 send_flags;
        struct htc_packet *packet;
        unsigned int transfer_len;

        /* NOTE : the TX lock is held when this function is called */

        /* loop until we can grab as many packets out of the queue as we can */
        while (true) {
                send_flags = 0;
                if (list_empty(&ep->txq))
                        break;

                /* get packet at head, but don't remove it */
                packet = list_first_entry(&ep->txq, struct htc_packet, list);

                ath6kl_dbg(ATH6KL_DBG_HTC,
                           "%s: got head packet:0x%p , queue depth: %d\n",
                           __func__, packet, get_queue_depth(&ep->txq));

                transfer_len = packet->act_len + HTC_HDR_LENGTH;

                if (transfer_len <= target->tgt_cred_sz) {
                        credits_required = 1;
                } else {
                        /* figure out how many credits this message requires */
                        credits_required = transfer_len / target->tgt_cred_sz;
                        remainder = transfer_len % target->tgt_cred_sz;

                        if (remainder)
                                credits_required++;
                }

                ath6kl_dbg(ATH6KL_DBG_HTC, "%s: creds required:%d got:%d\n",
                           __func__, credits_required, ep->cred_dist.credits);

                if (ep->eid == ENDPOINT_0) {
                        /*
                         * endpoint 0 is special, it always has a credit and
                         * does not require credit based flow control
                         */
                        credits_required = 0;

                } else {
                        if (ep->cred_dist.credits < credits_required)
                                break;

                        ep->cred_dist.credits -= credits_required;
                        ep->ep_st.cred_cosumd += credits_required;

                        /* check if we need credits back from the target */
                        if (ep->cred_dist.credits <
                                        ep->cred_dist.cred_per_msg) {
                                /* tell the target we need credits ASAP! */
                                send_flags |= HTC_FLAGS_NEED_CREDIT_UPDATE;
                                ep->ep_st.cred_low_indicate += 1;
                                ath6kl_dbg(ATH6KL_DBG_HTC,
                                           "%s: host needs credits\n",
                                           __func__);
                        }
                }

                /* now we can fully dequeue */
                packet = list_first_entry(&ep->txq, struct htc_packet, list);

                list_del(&packet->list);
                /* save the number of credits this packet consumed */
                packet->info.tx.cred_used = credits_required;
                /* save send flags */
                packet->info.tx.flags = send_flags;
                packet->info.tx.seqno = ep->seqno;
                ep->seqno++;
                /* queue this packet into the caller's queue */
                list_add_tail(&packet->list, queue);
        }
}

static void get_htc_packet(struct htc_target *target,
                           struct htc_endpoint *ep,
                           struct list_head *queue, int resources)
{
        struct htc_packet *packet;

        /* NOTE : the TX lock is held when this function is called */

        /* loop until we can grab as many packets out of the queue as we can */
        while (resources) {
                if (list_empty(&ep->txq))
                        break;

                packet = list_first_entry(&ep->txq, struct htc_packet, list);
                list_del(&packet->list);

                ath6kl_dbg(ATH6KL_DBG_HTC,
                           "%s: got packet:0x%p , new queue depth: %d\n",
                           __func__, packet, get_queue_depth(&ep->txq));
                packet->info.tx.seqno = ep->seqno;
                packet->info.tx.flags = 0;
                packet->info.tx.cred_used = 0;
                ep->seqno++;

                /* queue this packet into the caller's queue */
                list_add_tail(&packet->list, queue);
                resources--;
        }
}

static int htc_issue_packets(struct htc_target *target,
                             struct htc_endpoint *ep,
                             struct list_head *pkt_queue)
{
        int status = 0;
        u16 payload_len;
        struct sk_buff *skb;
        struct htc_frame_hdr *htc_hdr;
        struct htc_packet *packet;

        ath6kl_dbg(ATH6KL_DBG_HTC,
                   "%s: queue: 0x%p, pkts %d\n", __func__,
                   pkt_queue, get_queue_depth(pkt_queue));

        while (!list_empty(pkt_queue)) {
                packet = list_first_entry(pkt_queue, struct htc_packet, list);
                list_del(&packet->list);

                skb = packet->skb;
                if (!skb) {
                        WARN_ON_ONCE(1);
                        status = -EINVAL;
                        break;
                }

                payload_len = packet->act_len;

                /* setup HTC frame header */
                htc_hdr = skb_push(skb, sizeof(*htc_hdr));
                if (!htc_hdr) {
                        WARN_ON_ONCE(1);
                        status = -EINVAL;
                        break;
                }

                packet->info.tx.flags |= HTC_FLAGS_TX_FIXUP_NETBUF;

                put_unaligned_le16(payload_len, &htc_hdr->payld_len);
                htc_hdr->flags = packet->info.tx.flags;
                htc_hdr->eid = (u8) packet->endpoint;
                htc_hdr->ctrl[0] = 0;
                htc_hdr->ctrl[1] = (u8) packet->info.tx.seqno;

                spin_lock_bh(&target->tx_lock);

                /* store in look up queue to match completions */
                list_add_tail(&packet->list, &ep->pipe.tx_lookup_queue);
                ep->ep_st.tx_issued += 1;
                spin_unlock_bh(&target->tx_lock);

                status = ath6kl_hif_pipe_send(target->dev->ar,
                                              ep->pipe.pipeid_ul, NULL, skb);

                if (status != 0) {
                        if (status != -ENOMEM) {
                                /* TODO: if more than 1 endpoint maps to the
                                 * same PipeID, it is possible to run out of
                                 * resources in the HIF layer.
                                 * Don't emit the error
                                 */
                                ath6kl_dbg(ATH6KL_DBG_HTC,
                                           "%s: failed status:%d\n",
                                           __func__, status);
                        }
                        spin_lock_bh(&target->tx_lock);
                        list_del(&packet->list);

                        /* reclaim credits */
                        ep->cred_dist.credits += packet->info.tx.cred_used;
                        spin_unlock_bh(&target->tx_lock);

                        /* put it back into the callers queue */
                        list_add(&packet->list, pkt_queue);
                        break;
                }
        }

        if (status != 0) {
                while (!list_empty(pkt_queue)) {
                        if (status != -ENOMEM) {
                                ath6kl_dbg(ATH6KL_DBG_HTC,
                                           "%s: failed pkt:0x%p status:%d\n",
                                           __func__, packet, status);
                        }

                        packet = list_first_entry(pkt_queue,
                                                  struct htc_packet, list);
                        list_del(&packet->list);
                        packet->status = status;
                        send_packet_completion(target, packet);
                }
        }

        return status;
}

static enum htc_send_queue_result htc_try_send(struct htc_target *target,
                                               struct htc_endpoint *ep,
                                               struct list_head *txq)
{
        struct list_head send_queue;    /* temp queue to hold packets */
        struct htc_packet *packet, *tmp_pkt;
        struct ath6kl *ar = target->dev->ar;
        enum htc_send_full_action action;
        int tx_resources, overflow, txqueue_depth, i, good_pkts;
        u8 pipeid;

        ath6kl_dbg(ATH6KL_DBG_HTC, "%s: (queue:0x%p depth:%d)\n",
                   __func__, txq,
                   (txq == NULL) ? 0 : get_queue_depth(txq));

        /* init the local send queue */
        INIT_LIST_HEAD(&send_queue);

        /*
         * txq equals to NULL means
         * caller didn't provide a queue, just wants us to
         * check queues and send
         */
        if (txq != NULL) {
                if (list_empty(txq)) {
                        /* empty queue */
                        return HTC_SEND_QUEUE_DROP;
                }

                spin_lock_bh(&target->tx_lock);
                txqueue_depth = get_queue_depth(&ep->txq);
                spin_unlock_bh(&target->tx_lock);

                if (txqueue_depth >= ep->max_txq_depth) {
                        /* we've already overflowed */
                        overflow = get_queue_depth(txq);
                } else {
                        /* get how much we will overflow by */
                        overflow = txqueue_depth;
                        overflow += get_queue_depth(txq);
                        /* get how much we will overflow the TX queue by */
                        overflow -= ep->max_txq_depth;
                }

                /* if overflow is negative or zero, we are okay */
                if (overflow > 0) {
                        ath6kl_dbg(ATH6KL_DBG_HTC,
                                   "%s: Endpoint %d, TX queue will overflow :%d, Tx Depth:%d, Max:%d\n",
                                   __func__, ep->eid, overflow, txqueue_depth,
                                   ep->max_txq_depth);
                }
                if ((overflow <= 0) ||
                    (ep->ep_cb.tx_full == NULL)) {
                        /*
                         * all packets will fit or caller did not provide send
                         * full indication handler -- just move all of them
                         * to the local send_queue object
                         */
                        list_splice_tail_init(txq, &send_queue);
                } else {
                        good_pkts = get_queue_depth(txq) - overflow;
                        if (good_pkts < 0) {
                                WARN_ON_ONCE(1);
                                return HTC_SEND_QUEUE_DROP;
                        }

                        /* we have overflowed, and a callback is provided */
                        /* dequeue all non-overflow packets to the sendqueue */
                        for (i = 0; i < good_pkts; i++) {
                                /* pop off caller's queue */
                                packet = list_first_entry(txq,
                                                          struct htc_packet,
                                                          list);
                                /* move to local queue */
                                list_move_tail(&packet->list, &send_queue);
                        }

                        /*
                         * the caller's queue has all the packets that won't fit
                         * walk through the caller's queue and indicate each to
                         * the send full handler
                         */
                        list_for_each_entry_safe(packet, tmp_pkt,
                                                 txq, list) {
                                ath6kl_dbg(ATH6KL_DBG_HTC,
                                           "%s: Indicate overflowed TX pkts: %p\n",
                                           __func__, packet);
                                action = ep->ep_cb.tx_full(ep->target, packet);
                                if (action == HTC_SEND_FULL_DROP) {
                                        /* callback wants the packet dropped */
                                        ep->ep_st.tx_dropped += 1;

                                        /* leave this one in the caller's queue
                                         * for cleanup */
                                } else {
                                        /* callback wants to keep this packet,
                                         * move from caller's queue to the send
                                         * queue */
                                        list_move_tail(&packet->list,
                                                       &send_queue);
                                }
                        }

                        if (list_empty(&send_queue)) {
                                /* no packets made it in, caller will cleanup */
                                return HTC_SEND_QUEUE_DROP;
                        }
                }
        }

        if (!ep->pipe.tx_credit_flow_enabled) {
                tx_resources =
                    ath6kl_hif_pipe_get_free_queue_number(ar,
                                                          ep->pipe.pipeid_ul);
        } else {
                tx_resources = 0;
        }

        spin_lock_bh(&target->tx_lock);
        if (!list_empty(&send_queue)) {
                /* transfer packets to tail */
                list_splice_tail_init(&send_queue, &ep->txq);
                if (!list_empty(&send_queue)) {
                        WARN_ON_ONCE(1);
                        spin_unlock_bh(&target->tx_lock);
                        return HTC_SEND_QUEUE_DROP;
                }
                INIT_LIST_HEAD(&send_queue);
        }

        /* increment tx processing count on entry */
        ep->tx_proc_cnt++;

        if (ep->tx_proc_cnt > 1) {
                /*
                 * Another thread or task is draining the TX queues on this
                 * endpoint that thread will reset the tx processing count
                 * when the queue is drained.
                 */
                ep->tx_proc_cnt--;
                spin_unlock_bh(&target->tx_lock);
                return HTC_SEND_QUEUE_OK;
        }

        /***** beyond this point only 1 thread may enter ******/

        /*
         * Now drain the endpoint TX queue for transmission as long as we have
         * enough transmit resources.
         */
        while (true) {
                if (get_queue_depth(&ep->txq) == 0)
                        break;

                if (ep->pipe.tx_credit_flow_enabled) {
                        /*
                         * Credit based mechanism provides flow control
                         * based on target transmit resource availability,
                         * we assume that the HIF layer will always have
                         * bus resources greater than target transmit
                         * resources.
                         */
                        get_htc_packet_credit_based(target, ep, &send_queue);
                } else {
                        /*
                         * Get all packets for this endpoint that we can
                         * for this pass.
                         */
                        get_htc_packet(target, ep, &send_queue, tx_resources);
                }

                if (get_queue_depth(&send_queue) == 0) {
                        /*
                         * Didn't get packets due to out of resources or TX
                         * queue was drained.
                         */
                        break;
                }

                spin_unlock_bh(&target->tx_lock);

                /* send what we can */
                htc_issue_packets(target, ep, &send_queue);

                if (!ep->pipe.tx_credit_flow_enabled) {
                        pipeid = ep->pipe.pipeid_ul;
                        tx_resources =
                            ath6kl_hif_pipe_get_free_queue_number(ar, pipeid);
                }

                spin_lock_bh(&target->tx_lock);
        }

        /* done with this endpoint, we can clear the count */
        ep->tx_proc_cnt = 0;
        spin_unlock_bh(&target->tx_lock);

        return HTC_SEND_QUEUE_OK;
}

/* htc control packet manipulation */
static void destroy_htc_txctrl_packet(struct htc_packet *packet)
{
        struct sk_buff *skb;
        skb = packet->skb;
        dev_kfree_skb(skb);
        kfree(packet);
}

static struct htc_packet *build_htc_txctrl_packet(void)
{
        struct htc_packet *packet = NULL;
        struct sk_buff *skb;

        packet = kzalloc_obj(struct htc_packet);
        if (packet == NULL)
                return NULL;

        skb = __dev_alloc_skb(HTC_CONTROL_BUFFER_SIZE, GFP_KERNEL);

        if (skb == NULL) {
                kfree(packet);
                return NULL;
        }
        packet->skb = skb;

        return packet;
}

static void htc_free_txctrl_packet(struct htc_target *target,
                                   struct htc_packet *packet)
{
        destroy_htc_txctrl_packet(packet);
}

static struct htc_packet *htc_alloc_txctrl_packet(struct htc_target *target)
{
        return build_htc_txctrl_packet();
}

static void htc_txctrl_complete(struct htc_target *target,
                                struct htc_packet *packet)
{
        htc_free_txctrl_packet(target, packet);
}

#define MAX_MESSAGE_SIZE 1536

static int htc_setup_target_buffer_assignments(struct htc_target *target)
{
        int status, credits, credit_per_maxmsg, i;
        struct htc_pipe_txcredit_alloc *entry;
        unsigned int hif_usbaudioclass = 0;

        credit_per_maxmsg = MAX_MESSAGE_SIZE / target->tgt_cred_sz;
        if (MAX_MESSAGE_SIZE % target->tgt_cred_sz)
                credit_per_maxmsg++;

        /* TODO, this should be configured by the caller! */

        credits = target->tgt_creds;
        entry = &target->pipe.txcredit_alloc[0];

        status = -ENOMEM;

        /* FIXME: hif_usbaudioclass is always zero */
        if (hif_usbaudioclass) {
                ath6kl_dbg(ATH6KL_DBG_HTC,
                           "%s: For USB Audio Class- Total:%d\n",
                           __func__, credits);
                entry++;
                entry++;
                /* Setup VO Service To have Max Credits */
                entry->service_id = WMI_DATA_VO_SVC;
                entry->credit_alloc = (credits - 6);
                if (entry->credit_alloc == 0)
                        entry->credit_alloc++;

                credits -= (int) entry->credit_alloc;
                if (credits <= 0)
                        return status;

                entry++;
                entry->service_id = WMI_CONTROL_SVC;
                entry->credit_alloc = credit_per_maxmsg;
                credits -= (int) entry->credit_alloc;
                if (credits <= 0)
                        return status;

                /* leftovers go to best effort */
                entry++;
                entry++;
                entry->service_id = WMI_DATA_BE_SVC;
                entry->credit_alloc = (u8) credits;
                status = 0;
        } else {
                entry++;
                entry->service_id = WMI_DATA_VI_SVC;
                entry->credit_alloc = credits / 4;
                if (entry->credit_alloc == 0)
                        entry->credit_alloc++;

                credits -= (int) entry->credit_alloc;
                if (credits <= 0)
                        return status;

                entry++;
                entry->service_id = WMI_DATA_VO_SVC;
                entry->credit_alloc = credits / 4;
                if (entry->credit_alloc == 0)
                        entry->credit_alloc++;

                credits -= (int) entry->credit_alloc;
                if (credits <= 0)
                        return status;

                entry++;
                entry->service_id = WMI_CONTROL_SVC;
                entry->credit_alloc = credit_per_maxmsg;
                credits -= (int) entry->credit_alloc;
                if (credits <= 0)
                        return status;

                entry++;
                entry->service_id = WMI_DATA_BK_SVC;
                entry->credit_alloc = credit_per_maxmsg;
                credits -= (int) entry->credit_alloc;
                if (credits <= 0)
                        return status;

                /* leftovers go to best effort */
                entry++;
                entry->service_id = WMI_DATA_BE_SVC;
                entry->credit_alloc = (u8) credits;
                status = 0;
        }

        if (status == 0) {
                for (i = 0; i < ENDPOINT_MAX; i++) {
                        if (target->pipe.txcredit_alloc[i].service_id != 0) {
                                ath6kl_dbg(ATH6KL_DBG_HTC,
                                           "HTC Service Index : %d TX : 0x%2.2X : alloc:%d\n",
                                           i,
                                           target->pipe.txcredit_alloc[i].
                                           service_id,
                                           target->pipe.txcredit_alloc[i].
                                           credit_alloc);
                        }
                }
        }
        return status;
}

/* process credit reports and call distribution function */
static void htc_process_credit_report(struct htc_target *target,
                                      struct htc_credit_report *rpt,
                                      int num_entries,
                                      enum htc_endpoint_id from_ep)
{
        int total_credits = 0, i;
        struct htc_endpoint *ep;

        /* lock out TX while we update credits */
        spin_lock_bh(&target->tx_lock);

        for (i = 0; i < num_entries; i++, rpt++) {
                if (rpt->eid >= ENDPOINT_MAX) {
                        WARN_ON_ONCE(1);
                        spin_unlock_bh(&target->tx_lock);
                        return;
                }

                ep = &target->endpoint[rpt->eid];
                ep->cred_dist.credits += rpt->credits;

                if (ep->cred_dist.credits && get_queue_depth(&ep->txq)) {
                        spin_unlock_bh(&target->tx_lock);
                        htc_try_send(target, ep, NULL);
                        spin_lock_bh(&target->tx_lock);
                }

                total_credits += rpt->credits;
        }
        ath6kl_dbg(ATH6KL_DBG_HTC,
                   "Report indicated %d credits to distribute\n",
                   total_credits);

        spin_unlock_bh(&target->tx_lock);
}

/* flush endpoint TX queue */
static void htc_flush_tx_endpoint(struct htc_target *target,
                                  struct htc_endpoint *ep, u16 tag)
{
        struct htc_packet *packet;

        spin_lock_bh(&target->tx_lock);
        while (get_queue_depth(&ep->txq)) {
                packet = list_first_entry(&ep->txq, struct htc_packet, list);
                list_del(&packet->list);
                packet->status = 0;
                send_packet_completion(target, packet);
        }
        spin_unlock_bh(&target->tx_lock);
}

/*
 * In the adapted HIF layer, struct sk_buff * are passed between HIF and HTC,
 * since upper layers expects struct htc_packet containers we use the completed
 * skb and lookup it's corresponding HTC packet buffer from a lookup list.
 * This is extra overhead that can be fixed by re-aligning HIF interfaces with
 * HTC.
 */
static struct htc_packet *htc_lookup_tx_packet(struct htc_target *target,
                                               struct htc_endpoint *ep,
                                               struct sk_buff *skb)
{
        struct htc_packet *packet, *tmp_pkt, *found_packet = NULL;

        spin_lock_bh(&target->tx_lock);

        /*
         * iterate from the front of tx lookup queue
         * this lookup should be fast since lower layers completes in-order and
         * so the completed packet should be at the head of the list generally
         */
        list_for_each_entry_safe(packet, tmp_pkt, &ep->pipe.tx_lookup_queue,
                                 list) {
                /* check for removal */
                if (skb == packet->skb) {
                        /* found it */
                        list_del(&packet->list);
                        found_packet = packet;
                        break;
                }
        }

        spin_unlock_bh(&target->tx_lock);

        return found_packet;
}

static int ath6kl_htc_pipe_tx_complete(struct ath6kl *ar, struct sk_buff *skb)
{
        struct htc_target *target = ar->htc_target;
        struct htc_frame_hdr *htc_hdr;
        struct htc_endpoint *ep;
        struct htc_packet *packet;
        u8 ep_id, *netdata;

        netdata = skb->data;

        htc_hdr = (struct htc_frame_hdr *) netdata;

        ep_id = htc_hdr->eid;
        ep = &target->endpoint[ep_id];

        packet = htc_lookup_tx_packet(target, ep, skb);
        if (packet == NULL) {
                /* may have already been flushed and freed */
                ath6kl_err("HTC TX lookup failed!\n");
        } else {
                /* will be giving this buffer back to upper layers */
                packet->status = 0;
                send_packet_completion(target, packet);
        }
        skb = NULL;

        if (!ep->pipe.tx_credit_flow_enabled) {
                /*
                 * note: when using TX credit flow, the re-checking of queues
                 * happens when credits flow back from the target. in the
                 * non-TX credit case, we recheck after the packet completes
                 */
                htc_try_send(target, ep, NULL);
        }

        return 0;
}

static int htc_send_packets_multiple(struct htc_target *target,
                                     struct list_head *pkt_queue)
{
        struct htc_endpoint *ep;
        struct htc_packet *packet, *tmp_pkt;

        if (list_empty(pkt_queue))
                return -EINVAL;

        /* get first packet to find out which ep the packets will go into */
        packet = list_first_entry(pkt_queue, struct htc_packet, list);

        if (packet->endpoint >= ENDPOINT_MAX) {
                WARN_ON_ONCE(1);
                return -EINVAL;
        }
        ep = &target->endpoint[packet->endpoint];

        htc_try_send(target, ep, pkt_queue);

        /* do completion on any packets that couldn't get in */
        if (!list_empty(pkt_queue)) {
                list_for_each_entry_safe(packet, tmp_pkt, pkt_queue, list) {
                        packet->status = -ENOMEM;
                }

                do_send_completion(ep, pkt_queue);
        }

        return 0;
}

/* htc pipe rx path */
static struct htc_packet *alloc_htc_packet_container(struct htc_target *target)
{
        struct htc_packet *packet;
        spin_lock_bh(&target->rx_lock);

        if (target->pipe.htc_packet_pool == NULL) {
                spin_unlock_bh(&target->rx_lock);
                return NULL;
        }

        packet = target->pipe.htc_packet_pool;
        target->pipe.htc_packet_pool = (struct htc_packet *) packet->list.next;

        spin_unlock_bh(&target->rx_lock);

        packet->list.next = NULL;
        return packet;
}

static void free_htc_packet_container(struct htc_target *target,
                                      struct htc_packet *packet)
{
        struct list_head *lh;

        spin_lock_bh(&target->rx_lock);

        if (target->pipe.htc_packet_pool == NULL) {
                target->pipe.htc_packet_pool = packet;
                packet->list.next = NULL;
        } else {
                lh = (struct list_head *) target->pipe.htc_packet_pool;
                packet->list.next = lh;
                target->pipe.htc_packet_pool = packet;
        }

        spin_unlock_bh(&target->rx_lock);
}

static int htc_process_trailer(struct htc_target *target, u8 *buffer,
                               int len, enum htc_endpoint_id from_ep)
{
        struct htc_credit_report *report;
        struct htc_record_hdr *record;
        u8 *record_buf;
        int status = 0;

        while (len > 0) {
                if (len < sizeof(struct htc_record_hdr)) {
                        status = -EINVAL;
                        break;
                }

                /* these are byte aligned structs */
                record = (struct htc_record_hdr *) buffer;
                len -= sizeof(struct htc_record_hdr);
                buffer += sizeof(struct htc_record_hdr);

                if (record->len > len) {
                        /* no room left in buffer for record */
                        ath6kl_dbg(ATH6KL_DBG_HTC,
                                   "invalid length: %d (id:%d) buffer has: %d bytes left\n",
                                   record->len, record->rec_id, len);
                        status = -EINVAL;
                        break;
                }

                /* start of record follows the header */
                record_buf = buffer;

                switch (record->rec_id) {
                case HTC_RECORD_CREDITS:
                        if (record->len < sizeof(struct htc_credit_report)) {
                                WARN_ON_ONCE(1);
                                return -EINVAL;
                        }

                        report = (struct htc_credit_report *) record_buf;
                        htc_process_credit_report(target, report,
                                                  record->len / sizeof(*report),
                                                  from_ep);
                        break;
                default:
                        ath6kl_dbg(ATH6KL_DBG_HTC,
                                   "unhandled record: id:%d length:%d\n",
                                   record->rec_id, record->len);
                        break;
                }

                /* advance buffer past this record for next time around */
                buffer += record->len;
                len -= record->len;
        }

        return status;
}

static void do_recv_completion(struct htc_endpoint *ep,
                               struct list_head *queue_to_indicate)
{
        struct htc_packet *packet;

        if (list_empty(queue_to_indicate)) {
                /* nothing to indicate */
                return;
        }

        /* using legacy EpRecv */
        while (!list_empty(queue_to_indicate)) {
                packet = list_first_entry(queue_to_indicate,
                                          struct htc_packet, list);
                list_del(&packet->list);
                ep->ep_cb.rx(ep->target, packet);
        }

        return;
}

static void recv_packet_completion(struct htc_target *target,
                                   struct htc_endpoint *ep,
                                   struct htc_packet *packet)
{
        struct list_head container;
        INIT_LIST_HEAD(&container);
        list_add_tail(&packet->list, &container);

        /* do completion */
        do_recv_completion(ep, &container);
}

static int ath6kl_htc_pipe_rx_complete(struct ath6kl *ar, struct sk_buff *skb,
                                       u8 pipeid)
{
        struct htc_target *target = ar->htc_target;
        u8 *netdata, *trailer, hdr_info;
        struct htc_frame_hdr *htc_hdr;
        u32 netlen, trailerlen = 0;
        struct htc_packet *packet;
        struct htc_endpoint *ep;
        u16 payload_len;
        int status = 0;

        /*
         * ar->htc_target can be NULL due to a race condition that can occur
         * during driver initialization(we do 'ath6kl_hif_power_on' before
         * initializing 'ar->htc_target' via 'ath6kl_htc_create').
         * 'ath6kl_hif_power_on' assigns 'ath6kl_recv_complete' as
         * usb_complete_t/callback function for 'usb_fill_bulk_urb'.
         * Thus the possibility of ar->htc_target being NULL
         * via ath6kl_recv_complete -> ath6kl_usb_io_comp_work.
         */
        if (!target) {
                ath6kl_dbg(ATH6KL_DBG_HTC, "Target not yet initialized\n");
                status = -EINVAL;
                goto free_skb;
        }


        netdata = skb->data;
        netlen = skb->len;

        htc_hdr = (struct htc_frame_hdr *) netdata;

        if (htc_hdr->eid >= ENDPOINT_MAX) {
                ath6kl_dbg(ATH6KL_DBG_HTC,
                           "HTC Rx: invalid EndpointID=%d\n",
                           htc_hdr->eid);
                status = -EINVAL;
                goto free_skb;
        }
        ep = &target->endpoint[htc_hdr->eid];

        payload_len = le16_to_cpu(get_unaligned(&htc_hdr->payld_len));

        if (netlen < (payload_len + HTC_HDR_LENGTH)) {
                ath6kl_dbg(ATH6KL_DBG_HTC,
                           "HTC Rx: insufficient length, got:%d expected =%zu\n",
                           netlen, payload_len + HTC_HDR_LENGTH);
                status = -EINVAL;
                goto free_skb;
        }

        /* get flags to check for trailer */
        hdr_info = htc_hdr->flags;
        if (hdr_info & HTC_FLG_RX_TRAILER) {
                /* extract the trailer length */
                hdr_info = htc_hdr->ctrl[0];
                if ((hdr_info < sizeof(struct htc_record_hdr)) ||
                    (hdr_info > payload_len)) {
                        ath6kl_dbg(ATH6KL_DBG_HTC,
                                   "invalid header: payloadlen should be %d, CB[0]: %d\n",
                                   payload_len, hdr_info);
                        status = -EINVAL;
                        goto free_skb;
                }

                trailerlen = hdr_info;
                /* process trailer after hdr/apps payload */
                trailer = (u8 *) htc_hdr + HTC_HDR_LENGTH +
                        payload_len - hdr_info;
                status = htc_process_trailer(target, trailer, hdr_info,
                                             htc_hdr->eid);
                if (status != 0)
                        goto free_skb;
        }

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

        if (htc_hdr->eid == ENDPOINT_0) {
                /* handle HTC control message */
                if (target->htc_flags & HTC_OP_STATE_SETUP_COMPLETE) {
                        /*
                         * fatal: target should not send unsolicited
                         * messageson the endpoint 0
                         */
                        ath6kl_dbg(ATH6KL_DBG_HTC,
                                   "HTC ignores Rx Ctrl after setup complete\n");
                        status = -EINVAL;
                        goto free_skb;
                }

                /* remove HTC header */
                skb_pull(skb, HTC_HDR_LENGTH);

                netdata = skb->data;
                netlen = skb->len;

                spin_lock_bh(&target->rx_lock);

                target->pipe.ctrl_response_valid = true;
                target->pipe.ctrl_response_len = min_t(int, netlen,
                                                       HTC_MAX_CTRL_MSG_LEN);
                memcpy(target->pipe.ctrl_response_buf, netdata,
                       target->pipe.ctrl_response_len);

                spin_unlock_bh(&target->rx_lock);

                dev_kfree_skb(skb);
                skb = NULL;

                goto free_skb;
        }

        /*
         * TODO: the message based HIF architecture allocates net bufs
         * for recv packets since it bridges that HIF to upper layers,
         * which expects HTC packets, we form the packets here
         */
        packet = alloc_htc_packet_container(target);
        if (packet == NULL) {
                status = -ENOMEM;
                goto free_skb;
        }

        packet->status = 0;
        packet->endpoint = htc_hdr->eid;
        packet->pkt_cntxt = skb;

        /* TODO: for backwards compatibility */
        packet->buf = skb_push(skb, 0) + HTC_HDR_LENGTH;
        packet->act_len = netlen - HTC_HDR_LENGTH - trailerlen;

        /*
         * TODO: this is a hack because the driver layer will set the
         * actual len of the skb again which will just double the len
         */
        skb_trim(skb, 0);

        recv_packet_completion(target, ep, packet);

        /* recover the packet container */
        free_htc_packet_container(target, packet);
        skb = NULL;

free_skb:
        dev_kfree_skb(skb);

        return status;
}

static void htc_flush_rx_queue(struct htc_target *target,
                               struct htc_endpoint *ep)
{
        struct list_head container;
        struct htc_packet *packet;

        spin_lock_bh(&target->rx_lock);

        while (1) {
                if (list_empty(&ep->rx_bufq))
                        break;

                packet = list_first_entry(&ep->rx_bufq,
                                          struct htc_packet, list);
                list_del(&packet->list);

                spin_unlock_bh(&target->rx_lock);
                packet->status = -ECANCELED;
                packet->act_len = 0;

                ath6kl_dbg(ATH6KL_DBG_HTC,
                           "Flushing RX packet:0x%p, length:%d, ep:%d\n",
                           packet, packet->buf_len,
                           packet->endpoint);

                INIT_LIST_HEAD(&container);
                list_add_tail(&packet->list, &container);

                /* give the packet back */
                do_recv_completion(ep, &container);
                spin_lock_bh(&target->rx_lock);
        }

        spin_unlock_bh(&target->rx_lock);
}

/* polling routine to wait for a control packet to be received */
static int htc_wait_recv_ctrl_message(struct htc_target *target)
{
        int count = HTC_TARGET_RESPONSE_POLL_COUNT;

        while (count > 0) {
                spin_lock_bh(&target->rx_lock);

                if (target->pipe.ctrl_response_valid) {
                        target->pipe.ctrl_response_valid = false;
                        spin_unlock_bh(&target->rx_lock);
                        break;
                }

                spin_unlock_bh(&target->rx_lock);

                count--;

                msleep_interruptible(HTC_TARGET_RESPONSE_POLL_WAIT);
        }

        if (count <= 0) {
                ath6kl_warn("htc pipe control receive timeout!\n");
                return -ETIMEDOUT;
        }

        return 0;
}

static void htc_rxctrl_complete(struct htc_target *context,
                                struct htc_packet *packet)
{
        struct sk_buff *skb = packet->skb;

        if (packet->endpoint == ENDPOINT_0 &&
            packet->status == -ECANCELED &&
            skb != NULL)
                dev_kfree_skb(skb);
}

/* htc pipe initialization */
static void reset_endpoint_states(struct htc_target *target)
{
        struct htc_endpoint *ep;
        int i;

        for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) {
                ep = &target->endpoint[i];
                ep->svc_id = 0;
                ep->len_max = 0;
                ep->max_txq_depth = 0;
                ep->eid = i;
                INIT_LIST_HEAD(&ep->txq);
                INIT_LIST_HEAD(&ep->pipe.tx_lookup_queue);
                INIT_LIST_HEAD(&ep->rx_bufq);
                ep->target = target;
                ep->pipe.tx_credit_flow_enabled = true;
        }
}

/* start HTC, this is called after all services are connected */
static int htc_config_target_hif_pipe(struct htc_target *target)
{
        return 0;
}

/* htc service functions */
static u8 htc_get_credit_alloc(struct htc_target *target, u16 service_id)
{
        u8 allocation = 0;
        int i;

        for (i = 0; i < ENDPOINT_MAX; i++) {
                if (target->pipe.txcredit_alloc[i].service_id == service_id)
                        allocation =
                                target->pipe.txcredit_alloc[i].credit_alloc;
        }

        if (allocation == 0) {
                ath6kl_dbg(ATH6KL_DBG_HTC,
                           "HTC Service TX : 0x%2.2X : allocation is zero!\n",
                           service_id);
        }

        return allocation;
}

static int ath6kl_htc_pipe_conn_service(struct htc_target *target,
                     struct htc_service_connect_req *conn_req,
                     struct htc_service_connect_resp *conn_resp)
{
        struct ath6kl *ar = target->dev->ar;
        struct htc_packet *packet = NULL;
        struct htc_conn_service_resp *resp_msg;
        struct htc_conn_service_msg *conn_msg;
        enum htc_endpoint_id assigned_epid = ENDPOINT_MAX;
        bool disable_credit_flowctrl = false;
        unsigned int max_msg_size = 0;
        struct htc_endpoint *ep;
        int length, status = 0;
        struct sk_buff *skb;
        u8 tx_alloc;
        u16 flags;

        if (conn_req->svc_id == 0) {
                WARN_ON_ONCE(1);
                status = -EINVAL;
                goto free_packet;
        }

        if (conn_req->svc_id == HTC_CTRL_RSVD_SVC) {
                /* special case for pseudo control service */
                assigned_epid = ENDPOINT_0;
                max_msg_size = HTC_MAX_CTRL_MSG_LEN;
                tx_alloc = 0;

        } else {
                tx_alloc = htc_get_credit_alloc(target, conn_req->svc_id);
                if (tx_alloc == 0) {
                        status = -ENOMEM;
                        goto free_packet;
                }

                /* allocate a packet to send to the target */
                packet = htc_alloc_txctrl_packet(target);

                if (packet == NULL) {
                        WARN_ON_ONCE(1);
                        status = -ENOMEM;
                        goto free_packet;
                }

                skb = packet->skb;
                length = sizeof(struct htc_conn_service_msg);

                /* assemble connect service message */
                conn_msg = skb_put(skb, length);
                if (conn_msg == NULL) {
                        WARN_ON_ONCE(1);
                        status = -EINVAL;
                        goto free_packet;
                }

                memset(conn_msg, 0,
                       sizeof(struct htc_conn_service_msg));
                conn_msg->msg_id = cpu_to_le16(HTC_MSG_CONN_SVC_ID);
                conn_msg->svc_id = cpu_to_le16(conn_req->svc_id);
                conn_msg->conn_flags = cpu_to_le16(conn_req->conn_flags &
                                        ~HTC_CONN_FLGS_SET_RECV_ALLOC_MASK);

                /* tell target desired recv alloc for this ep */
                flags = tx_alloc << HTC_CONN_FLGS_SET_RECV_ALLOC_SHIFT;
                conn_msg->conn_flags |= cpu_to_le16(flags);

                if (conn_req->conn_flags &
                    HTC_CONN_FLGS_DISABLE_CRED_FLOW_CTRL) {
                        disable_credit_flowctrl = true;
                }

                set_htc_pkt_info(packet, NULL, (u8 *) conn_msg,
                                 length,
                                 ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG);

                status = ath6kl_htc_pipe_tx(target, packet);

                /* we don't own it anymore */
                packet = NULL;
                if (status != 0)
                        goto free_packet;

                /* wait for response */
                status = htc_wait_recv_ctrl_message(target);
                if (status != 0)
                        goto free_packet;

                /* we controlled the buffer creation so it has to be
                 * properly aligned
                 */
                resp_msg = (struct htc_conn_service_resp *)
                    target->pipe.ctrl_response_buf;

                if (resp_msg->msg_id != cpu_to_le16(HTC_MSG_CONN_SVC_RESP_ID) ||
                    (target->pipe.ctrl_response_len < sizeof(*resp_msg))) {
                        /* this message is not valid */
                        WARN_ON_ONCE(1);
                        status = -EINVAL;
                        goto free_packet;
                }

                ath6kl_dbg(ATH6KL_DBG_TRC,
                           "%s: service 0x%X conn resp: status: %d ep: %d\n",
                           __func__, resp_msg->svc_id, resp_msg->status,
                           resp_msg->eid);

                conn_resp->resp_code = resp_msg->status;
                /* check response status */
                if (resp_msg->status != HTC_SERVICE_SUCCESS) {
                        ath6kl_dbg(ATH6KL_DBG_HTC,
                                   "Target failed service 0x%X connect request (status:%d)\n",
                                   resp_msg->svc_id, resp_msg->status);
                        status = -EINVAL;
                        goto free_packet;
                }

                assigned_epid = (enum htc_endpoint_id) resp_msg->eid;
                max_msg_size = le16_to_cpu(resp_msg->max_msg_sz);
        }

        /* the rest are parameter checks so set the error status */
        status = -EINVAL;

        if (assigned_epid >= ENDPOINT_MAX) {
                WARN_ON_ONCE(1);
                goto free_packet;
        }

        if (max_msg_size == 0) {
                WARN_ON_ONCE(1);
                goto free_packet;
        }

        ep = &target->endpoint[assigned_epid];
        ep->eid = assigned_epid;
        if (ep->svc_id != 0) {
                /* endpoint already in use! */
                WARN_ON_ONCE(1);
                goto free_packet;
        }

        /* return assigned endpoint to caller */
        conn_resp->endpoint = assigned_epid;
        conn_resp->len_max = max_msg_size;

        /* setup the endpoint */
        ep->svc_id = conn_req->svc_id; /* this marks ep in use */
        ep->max_txq_depth = conn_req->max_txq_depth;
        ep->len_max = max_msg_size;
        ep->cred_dist.credits = tx_alloc;
        ep->cred_dist.cred_sz = target->tgt_cred_sz;
        ep->cred_dist.cred_per_msg = max_msg_size / target->tgt_cred_sz;
        if (max_msg_size % target->tgt_cred_sz)
                ep->cred_dist.cred_per_msg++;

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

        /* initialize tx_drop_packet_threshold */
        ep->tx_drop_packet_threshold = MAX_HI_COOKIE_NUM;

        status = ath6kl_hif_pipe_map_service(ar, ep->svc_id,
                                             &ep->pipe.pipeid_ul,
                                             &ep->pipe.pipeid_dl);
        if (status != 0)
                goto free_packet;

        ath6kl_dbg(ATH6KL_DBG_HTC,
                   "SVC Ready: 0x%4.4X: ULpipe:%d DLpipe:%d id:%d\n",
                   ep->svc_id, ep->pipe.pipeid_ul,
                   ep->pipe.pipeid_dl, ep->eid);

        if (disable_credit_flowctrl && ep->pipe.tx_credit_flow_enabled) {
                ep->pipe.tx_credit_flow_enabled = false;
                ath6kl_dbg(ATH6KL_DBG_HTC,
                           "SVC: 0x%4.4X ep:%d TX flow control off\n",
                           ep->svc_id, assigned_epid);
        }

free_packet:
        if (packet != NULL)
                htc_free_txctrl_packet(target, packet);
        return status;
}

/* htc export functions */
static void *ath6kl_htc_pipe_create(struct ath6kl *ar)
{
        int status = 0;
        struct htc_endpoint *ep = NULL;
        struct htc_target *target = NULL;
        struct htc_packet *packet;
        int i;

        target = kzalloc_obj(struct htc_target);
        if (target == NULL) {
                ath6kl_err("htc create unable to allocate memory\n");
                status = -ENOMEM;
                goto fail_htc_create;
        }

        spin_lock_init(&target->htc_lock);
        spin_lock_init(&target->rx_lock);
        spin_lock_init(&target->tx_lock);

        reset_endpoint_states(target);

        for (i = 0; i < HTC_PACKET_CONTAINER_ALLOCATION; i++) {
                packet = kzalloc_obj(struct htc_packet);

                if (packet != NULL)
                        free_htc_packet_container(target, packet);
        }

        target->dev = kzalloc_obj(*target->dev);
        if (!target->dev) {
                ath6kl_err("unable to allocate memory\n");
                status = -ENOMEM;
                goto fail_htc_create;
        }
        target->dev->ar = ar;
        target->dev->htc_cnxt = target;

        /* Get HIF default pipe for HTC message exchange */
        ep = &target->endpoint[ENDPOINT_0];

        ath6kl_hif_pipe_get_default(ar, &ep->pipe.pipeid_ul,
                                    &ep->pipe.pipeid_dl);

        return target;

fail_htc_create:
        if (status != 0) {
                if (target != NULL)
                        ath6kl_htc_pipe_cleanup(target);

                target = NULL;
        }
        return target;
}

/* cleanup the HTC instance */
static void ath6kl_htc_pipe_cleanup(struct htc_target *target)
{
        struct htc_packet *packet;

        while (true) {
                packet = alloc_htc_packet_container(target);
                if (packet == NULL)
                        break;
                kfree(packet);
        }

        kfree(target->dev);

        /* kfree our instance */
        kfree(target);
}

static int ath6kl_htc_pipe_start(struct htc_target *target)
{
        struct sk_buff *skb;
        struct htc_setup_comp_ext_msg *setup;
        struct htc_packet *packet;

        htc_config_target_hif_pipe(target);

        /* allocate a buffer to send */
        packet = htc_alloc_txctrl_packet(target);
        if (packet == NULL) {
                WARN_ON_ONCE(1);
                return -ENOMEM;
        }

        skb = packet->skb;

        /* assemble setup complete message */
        setup = skb_put(skb, sizeof(*setup));
        memset(setup, 0, sizeof(struct htc_setup_comp_ext_msg));
        setup->msg_id = cpu_to_le16(HTC_MSG_SETUP_COMPLETE_EX_ID);

        ath6kl_dbg(ATH6KL_DBG_HTC, "HTC using TX credit flow control\n");

        set_htc_pkt_info(packet, NULL, (u8 *) setup,
                         sizeof(struct htc_setup_comp_ext_msg),
                         ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG);

        target->htc_flags |= HTC_OP_STATE_SETUP_COMPLETE;

        return ath6kl_htc_pipe_tx(target, packet);
}

static void ath6kl_htc_pipe_stop(struct htc_target *target)
{
        int i;
        struct htc_endpoint *ep;

        /* cleanup endpoints */
        for (i = 0; i < ENDPOINT_MAX; i++) {
                ep = &target->endpoint[i];
                htc_flush_rx_queue(target, ep);
                htc_flush_tx_endpoint(target, ep, HTC_TX_PACKET_TAG_ALL);
        }

        reset_endpoint_states(target);
        target->htc_flags &= ~HTC_OP_STATE_SETUP_COMPLETE;
}

static int ath6kl_htc_pipe_get_rxbuf_num(struct htc_target *target,
                                         enum htc_endpoint_id endpoint)
{
        int num;

        spin_lock_bh(&target->rx_lock);
        num = get_queue_depth(&(target->endpoint[endpoint].rx_bufq));
        spin_unlock_bh(&target->rx_lock);

        return num;
}

static int ath6kl_htc_pipe_tx(struct htc_target *target,
                              struct htc_packet *packet)
{
        struct list_head queue;

        ath6kl_dbg(ATH6KL_DBG_HTC,
                   "%s: endPointId: %d, buffer: 0x%p, length: %d\n",
                   __func__, packet->endpoint, packet->buf,
                   packet->act_len);

        INIT_LIST_HEAD(&queue);
        list_add_tail(&packet->list, &queue);

        return htc_send_packets_multiple(target, &queue);
}

static int ath6kl_htc_pipe_wait_target(struct htc_target *target)
{
        struct htc_ready_ext_msg *ready_msg;
        struct htc_service_connect_req connect;
        struct htc_service_connect_resp resp;
        int status = 0;

        status = htc_wait_recv_ctrl_message(target);

        if (status != 0)
                return status;

        if (target->pipe.ctrl_response_len < sizeof(*ready_msg)) {
                ath6kl_warn("invalid htc pipe ready msg len: %d\n",
                            target->pipe.ctrl_response_len);
                return -ECOMM;
        }

        ready_msg = (struct htc_ready_ext_msg *) target->pipe.ctrl_response_buf;

        if (ready_msg->ver2_0_info.msg_id != cpu_to_le16(HTC_MSG_READY_ID)) {
                ath6kl_warn("invalid htc pipe ready msg: 0x%x\n",
                            ready_msg->ver2_0_info.msg_id);
                return -ECOMM;
        }

        ath6kl_dbg(ATH6KL_DBG_HTC,
                   "Target Ready! : transmit resources : %d size:%d\n",
                   ready_msg->ver2_0_info.cred_cnt,
                   ready_msg->ver2_0_info.cred_sz);

        target->tgt_creds = le16_to_cpu(ready_msg->ver2_0_info.cred_cnt);
        target->tgt_cred_sz = le16_to_cpu(ready_msg->ver2_0_info.cred_sz);

        if ((target->tgt_creds == 0) || (target->tgt_cred_sz == 0))
                return -ECOMM;

        htc_setup_target_buffer_assignments(target);

        /* setup our pseudo HTC control endpoint connection */
        memset(&connect, 0, sizeof(connect));
        memset(&resp, 0, sizeof(resp));
        connect.ep_cb.tx_complete = htc_txctrl_complete;
        connect.ep_cb.rx = htc_rxctrl_complete;
        connect.max_txq_depth = NUM_CONTROL_TX_BUFFERS;
        connect.svc_id = HTC_CTRL_RSVD_SVC;

        /* connect fake service */
        status = ath6kl_htc_pipe_conn_service(target, &connect, &resp);

        return status;
}

static void ath6kl_htc_pipe_flush_txep(struct htc_target *target,
                                       enum htc_endpoint_id endpoint, u16 tag)
{
        struct htc_endpoint *ep = &target->endpoint[endpoint];

        if (ep->svc_id == 0) {
                WARN_ON_ONCE(1);
                /* not in use.. */
                return;
        }

        htc_flush_tx_endpoint(target, ep, tag);
}

static int ath6kl_htc_pipe_add_rxbuf_multiple(struct htc_target *target,
                                              struct list_head *pkt_queue)
{
        struct htc_packet *packet, *tmp_pkt, *first;
        struct htc_endpoint *ep;
        int status = 0;

        if (list_empty(pkt_queue))
                return -EINVAL;

        first = list_first_entry(pkt_queue, struct htc_packet, list);

        if (first->endpoint >= ENDPOINT_MAX) {
                WARN_ON_ONCE(1);
                return -EINVAL;
        }

        ath6kl_dbg(ATH6KL_DBG_HTC, "%s: epid: %d, cnt:%d, len: %d\n",
                   __func__, first->endpoint, get_queue_depth(pkt_queue),
                   first->buf_len);

        ep = &target->endpoint[first->endpoint];

        spin_lock_bh(&target->rx_lock);

        /* store receive packets */
        list_splice_tail_init(pkt_queue, &ep->rx_bufq);

        spin_unlock_bh(&target->rx_lock);

        if (status != 0) {
                /* walk through queue and mark each one canceled */
                list_for_each_entry_safe(packet, tmp_pkt, pkt_queue, list) {
                        packet->status = -ECANCELED;
                }

                do_recv_completion(ep, pkt_queue);
        }

        return status;
}

static void ath6kl_htc_pipe_activity_changed(struct htc_target *target,
                                             enum htc_endpoint_id ep,
                                             bool active)
{
        /* TODO */
}

static void ath6kl_htc_pipe_flush_rx_buf(struct htc_target *target)
{
        struct htc_endpoint *endpoint;
        struct htc_packet *packet, *tmp_pkt;
        int i;

        for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) {
                endpoint = &target->endpoint[i];

                spin_lock_bh(&target->rx_lock);

                list_for_each_entry_safe(packet, tmp_pkt,
                                         &endpoint->rx_bufq, list) {
                        list_del(&packet->list);
                        spin_unlock_bh(&target->rx_lock);
                        ath6kl_dbg(ATH6KL_DBG_HTC,
                                   "htc rx flush pkt 0x%p len %d ep %d\n",
                                   packet, packet->buf_len,
                                   packet->endpoint);
                        dev_kfree_skb(packet->pkt_cntxt);
                        spin_lock_bh(&target->rx_lock);
                }

                spin_unlock_bh(&target->rx_lock);
        }
}

static int ath6kl_htc_pipe_credit_setup(struct htc_target *target,
                                        struct ath6kl_htc_credit_info *info)
{
        return 0;
}

static const struct ath6kl_htc_ops ath6kl_htc_pipe_ops = {
        .create = ath6kl_htc_pipe_create,
        .wait_target = ath6kl_htc_pipe_wait_target,
        .start = ath6kl_htc_pipe_start,
        .conn_service = ath6kl_htc_pipe_conn_service,
        .tx = ath6kl_htc_pipe_tx,
        .stop = ath6kl_htc_pipe_stop,
        .cleanup = ath6kl_htc_pipe_cleanup,
        .flush_txep = ath6kl_htc_pipe_flush_txep,
        .flush_rx_buf = ath6kl_htc_pipe_flush_rx_buf,
        .activity_changed = ath6kl_htc_pipe_activity_changed,
        .get_rxbuf_num = ath6kl_htc_pipe_get_rxbuf_num,
        .add_rxbuf_multiple = ath6kl_htc_pipe_add_rxbuf_multiple,
        .credit_setup = ath6kl_htc_pipe_credit_setup,
        .tx_complete = ath6kl_htc_pipe_tx_complete,
        .rx_complete = ath6kl_htc_pipe_rx_complete,
};

void ath6kl_htc_pipe_attach(struct ath6kl *ar)
{
        ar->htc_ops = &ath6kl_htc_pipe_ops;
}