2 * Copyright (c) 2007-2011 Atheros Communications Inc.
4 * Permission to use, copy, modify, and/or distribute this software for any
5 * purpose with or without fee is hereby granted, provided that the above
6 * copyright notice and this permission notice appear in all copies.
8 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
21 #include <asm/unaligned.h>
23 #define CALC_TXRX_PADDED_LEN(dev, len) (__ALIGN_MASK((len), (dev)->block_mask))
25 static void ath6kl_htc_tx_buf_align(u8 **buf, unsigned long len)
29 if (!IS_ALIGNED((unsigned long) *buf, 4)) {
30 align_addr = PTR_ALIGN(*buf - 4, 4);
31 memmove(align_addr, *buf, len);
36 static void ath6kl_htc_tx_prep_pkt(struct htc_packet *packet, u8 flags,
39 struct htc_frame_hdr *hdr;
41 packet->buf -= HTC_HDR_LENGTH;
42 hdr = (struct htc_frame_hdr *)packet->buf;
45 put_unaligned((u16)packet->act_len, &hdr->payld_len);
47 hdr->eid = packet->endpoint;
52 static void htc_reclaim_txctrl_buf(struct htc_target *target,
53 struct htc_packet *pkt)
55 spin_lock_bh(&target->htc_lock);
56 list_add_tail(&pkt->list, &target->free_ctrl_txbuf);
57 spin_unlock_bh(&target->htc_lock);
60 static struct htc_packet *htc_get_control_buf(struct htc_target *target,
63 struct htc_packet *packet = NULL;
64 struct list_head *buf_list;
66 buf_list = tx ? &target->free_ctrl_txbuf : &target->free_ctrl_rxbuf;
68 spin_lock_bh(&target->htc_lock);
70 if (list_empty(buf_list)) {
71 spin_unlock_bh(&target->htc_lock);
75 packet = list_first_entry(buf_list, struct htc_packet, list);
76 list_del(&packet->list);
77 spin_unlock_bh(&target->htc_lock);
80 packet->buf = packet->buf_start + HTC_HDR_LENGTH;
85 static void htc_tx_comp_update(struct htc_target *target,
86 struct htc_endpoint *endpoint,
87 struct htc_packet *packet)
89 packet->completion = NULL;
90 packet->buf += HTC_HDR_LENGTH;
95 ath6kl_err("req failed (status:%d, ep:%d, len:%d creds:%d)\n",
96 packet->status, packet->endpoint, packet->act_len,
97 packet->info.tx.cred_used);
99 /* on failure to submit, reclaim credits for this packet */
100 spin_lock_bh(&target->tx_lock);
101 endpoint->cred_dist.cred_to_dist +=
102 packet->info.tx.cred_used;
103 endpoint->cred_dist.txq_depth = get_queue_depth(&endpoint->txq);
105 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "ctxt:0x%p dist:0x%p\n",
106 target->cred_dist_cntxt, &target->cred_dist_list);
108 ath6k_credit_distribute(target->cred_dist_cntxt,
109 &target->cred_dist_list,
110 HTC_CREDIT_DIST_SEND_COMPLETE);
112 spin_unlock_bh(&target->tx_lock);
115 static void htc_tx_complete(struct htc_endpoint *endpoint,
116 struct list_head *txq)
121 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
122 "send complete ep %d, (%d pkts)\n",
123 endpoint->eid, get_queue_depth(txq));
125 ath6kl_tx_complete(endpoint->target->dev->ar, txq);
128 static void htc_tx_comp_handler(struct htc_target *target,
129 struct htc_packet *packet)
131 struct htc_endpoint *endpoint = &target->endpoint[packet->endpoint];
132 struct list_head container;
134 htc_tx_comp_update(target, endpoint, packet);
135 INIT_LIST_HEAD(&container);
136 list_add_tail(&packet->list, &container);
138 htc_tx_complete(endpoint, &container);
141 static void htc_async_tx_scat_complete(struct htc_target *target,
142 struct hif_scatter_req *scat_req)
144 struct htc_endpoint *endpoint;
145 struct htc_packet *packet;
146 struct list_head tx_compq;
149 INIT_LIST_HEAD(&tx_compq);
151 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
152 "htc_async_tx_scat_complete total len: %d entries: %d\n",
153 scat_req->len, scat_req->scat_entries);
155 if (scat_req->status)
156 ath6kl_err("send scatter req failed: %d\n", scat_req->status);
158 packet = scat_req->scat_list[0].packet;
159 endpoint = &target->endpoint[packet->endpoint];
161 /* walk through the scatter list and process */
162 for (i = 0; i < scat_req->scat_entries; i++) {
163 packet = scat_req->scat_list[i].packet;
169 packet->status = scat_req->status;
170 htc_tx_comp_update(target, endpoint, packet);
171 list_add_tail(&packet->list, &tx_compq);
174 /* free scatter request */
175 hif_scatter_req_add(target->dev->ar, scat_req);
177 /* complete all packets */
178 htc_tx_complete(endpoint, &tx_compq);
181 static int ath6kl_htc_tx_issue(struct htc_target *target,
182 struct htc_packet *packet)
186 u32 padded_len, send_len;
188 if (!packet->completion)
191 send_len = packet->act_len + HTC_HDR_LENGTH;
193 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "%s: transmit len : %d (%s)\n",
194 __func__, send_len, sync ? "sync" : "async");
196 padded_len = CALC_TXRX_PADDED_LEN(target, send_len);
198 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
199 "DevSendPacket, padded len: %d mbox:0x%X (mode:%s)\n",
201 target->dev->ar->mbox_info.htc_addr,
202 sync ? "sync" : "async");
205 status = hif_read_write_sync(target->dev->ar,
206 target->dev->ar->mbox_info.htc_addr,
207 packet->buf, padded_len,
208 HIF_WR_SYNC_BLOCK_INC);
210 packet->status = status;
211 packet->buf += HTC_HDR_LENGTH;
213 status = hif_write_async(target->dev->ar,
214 target->dev->ar->mbox_info.htc_addr,
215 packet->buf, padded_len,
216 HIF_WR_ASYNC_BLOCK_INC, packet);
221 static int htc_check_credits(struct htc_target *target,
222 struct htc_endpoint *ep, u8 *flags,
223 enum htc_endpoint_id eid, unsigned int len,
227 *req_cred = (len > target->tgt_cred_sz) ?
228 DIV_ROUND_UP(len, target->tgt_cred_sz) : 1;
230 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "creds required:%d got:%d\n",
231 *req_cred, ep->cred_dist.credits);
233 if (ep->cred_dist.credits < *req_cred) {
234 if (eid == ENDPOINT_0)
237 /* Seek more credits */
238 ep->cred_dist.seek_cred = *req_cred - ep->cred_dist.credits;
240 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "ctxt:0x%p dist:0x%p\n",
241 target->cred_dist_cntxt, &ep->cred_dist);
243 ath6k_seek_credits(target->cred_dist_cntxt, &ep->cred_dist);
245 ep->cred_dist.seek_cred = 0;
247 if (ep->cred_dist.credits < *req_cred) {
248 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
249 "not enough credits for ep %d - leaving packet in queue\n",
255 ep->cred_dist.credits -= *req_cred;
256 ep->ep_st.cred_cosumd += *req_cred;
258 /* When we are getting low on credits, ask for more */
259 if (ep->cred_dist.credits < ep->cred_dist.cred_per_msg) {
260 ep->cred_dist.seek_cred =
261 ep->cred_dist.cred_per_msg - ep->cred_dist.credits;
263 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "ctxt:0x%p dist:0x%p\n",
264 target->cred_dist_cntxt, &ep->cred_dist);
266 ath6k_seek_credits(target->cred_dist_cntxt, &ep->cred_dist);
268 /* see if we were successful in getting more */
269 if (ep->cred_dist.credits < ep->cred_dist.cred_per_msg) {
270 /* tell the target we need credits ASAP! */
271 *flags |= HTC_FLAGS_NEED_CREDIT_UPDATE;
272 ep->ep_st.cred_low_indicate += 1;
273 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "host needs credits\n");
280 static void ath6kl_htc_tx_pkts_get(struct htc_target *target,
281 struct htc_endpoint *endpoint,
282 struct list_head *queue)
286 struct htc_packet *packet;
293 if (list_empty(&endpoint->txq))
295 packet = list_first_entry(&endpoint->txq, struct htc_packet,
298 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
299 "got head pkt:0x%p , queue depth: %d\n",
300 packet, get_queue_depth(&endpoint->txq));
302 len = CALC_TXRX_PADDED_LEN(target,
303 packet->act_len + HTC_HDR_LENGTH);
305 if (htc_check_credits(target, endpoint, &flags,
306 packet->endpoint, len, &req_cred))
309 /* now we can fully move onto caller's queue */
310 packet = list_first_entry(&endpoint->txq, struct htc_packet,
312 list_move_tail(&packet->list, queue);
314 /* save the number of credits this packet consumed */
315 packet->info.tx.cred_used = req_cred;
317 /* all TX packets are handled asynchronously */
318 packet->completion = htc_tx_comp_handler;
319 packet->context = target;
320 endpoint->ep_st.tx_issued += 1;
322 /* save send flags */
323 packet->info.tx.flags = flags;
324 packet->info.tx.seqno = endpoint->seqno;
329 /* See if the padded tx length falls on a credit boundary */
330 static int htc_get_credit_padding(unsigned int cred_sz, int *len,
331 struct htc_endpoint *ep)
333 int rem_cred, cred_pad;
335 rem_cred = *len % cred_sz;
337 /* No padding needed */
341 if (!(ep->conn_flags & HTC_FLGS_TX_BNDL_PAD_EN))
345 * The transfer consumes a "partial" credit, this
346 * packet cannot be bundled unless we add
347 * additional "dummy" padding (max 255 bytes) to
348 * consume the entire credit.
350 cred_pad = *len < cred_sz ? (cred_sz - *len) : rem_cred;
352 if ((cred_pad > 0) && (cred_pad <= 255))
355 /* The amount of padding is too large, send as non-bundled */
361 static int ath6kl_htc_tx_setup_scat_list(struct htc_target *target,
362 struct htc_endpoint *endpoint,
363 struct hif_scatter_req *scat_req,
365 struct list_head *queue)
367 struct htc_packet *packet;
368 int i, len, rem_scat, cred_pad;
371 rem_scat = target->max_tx_bndl_sz;
373 for (i = 0; i < n_scat; i++) {
374 scat_req->scat_list[i].packet = NULL;
376 if (list_empty(queue))
379 packet = list_first_entry(queue, struct htc_packet, list);
380 len = CALC_TXRX_PADDED_LEN(target,
381 packet->act_len + HTC_HDR_LENGTH);
383 cred_pad = htc_get_credit_padding(target->tgt_cred_sz,
385 if (cred_pad < 0 || rem_scat < len) {
391 /* now remove it from the queue */
392 list_del(&packet->list);
394 scat_req->scat_list[i].packet = packet;
395 /* prepare packet and flag message as part of a send bundle */
396 ath6kl_htc_tx_prep_pkt(packet,
397 packet->info.tx.flags | HTC_FLAGS_SEND_BUNDLE,
398 cred_pad, packet->info.tx.seqno);
399 /* Make sure the buffer is 4-byte aligned */
400 ath6kl_htc_tx_buf_align(&packet->buf,
401 packet->act_len + HTC_HDR_LENGTH);
402 scat_req->scat_list[i].buf = packet->buf;
403 scat_req->scat_list[i].len = len;
405 scat_req->len += len;
406 scat_req->scat_entries++;
407 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
408 "%d, adding pkt : 0x%p len:%d (remaining space:%d)\n",
409 i, packet, len, rem_scat);
412 /* Roll back scatter setup in case of any failure */
413 if (scat_req->scat_entries < HTC_MIN_HTC_MSGS_TO_BUNDLE) {
414 for (i = scat_req->scat_entries - 1; i >= 0; i--) {
415 packet = scat_req->scat_list[i].packet;
417 packet->buf += HTC_HDR_LENGTH;
418 list_add(&packet->list, queue);
428 * Drain a queue and send as bundles this function may return without fully
429 * draining the queue when
431 * 1. scatter resources are exhausted
432 * 2. a message that will consume a partial credit will stop the
433 * bundling process early
434 * 3. we drop below the minimum number of messages for a bundle
436 static void ath6kl_htc_tx_bundle(struct htc_endpoint *endpoint,
437 struct list_head *queue,
438 int *sent_bundle, int *n_bundle_pkts)
440 struct htc_target *target = endpoint->target;
441 struct hif_scatter_req *scat_req = NULL;
442 int n_scat, n_sent_bundle = 0, tot_pkts_bundle = 0;
447 n_scat = get_queue_depth(queue);
448 n_scat = min(n_scat, target->msg_per_bndl_max);
450 if (n_scat < HTC_MIN_HTC_MSGS_TO_BUNDLE)
451 /* not enough to bundle */
454 scat_req = hif_scatter_req_get(target->dev->ar);
457 /* no scatter resources */
458 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
459 "no more scatter resources\n");
463 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "pkts to scatter: %d\n",
467 scat_req->scat_entries = 0;
469 status = ath6kl_htc_tx_setup_scat_list(target, endpoint,
472 if (status == -EAGAIN) {
473 hif_scatter_req_add(target->dev->ar, scat_req);
477 /* send path is always asynchronous */
478 scat_req->complete = htc_async_tx_scat_complete;
480 tot_pkts_bundle += scat_req->scat_entries;
482 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
483 "send scatter total bytes: %d , entries: %d\n",
484 scat_req->len, scat_req->scat_entries);
485 ath6kldev_submit_scat_req(target->dev, scat_req, false);
491 *sent_bundle = n_sent_bundle;
492 *n_bundle_pkts = tot_pkts_bundle;
493 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "%s (sent:%d)\n",
494 __func__, n_sent_bundle);
499 static void ath6kl_htc_tx_from_queue(struct htc_target *target,
500 struct htc_endpoint *endpoint)
502 struct list_head txq;
503 struct htc_packet *packet;
507 spin_lock_bh(&target->tx_lock);
509 endpoint->tx_proc_cnt++;
510 if (endpoint->tx_proc_cnt > 1) {
511 endpoint->tx_proc_cnt--;
512 spin_unlock_bh(&target->tx_lock);
513 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "htc_try_send (busy)\n");
518 * drain the endpoint TX queue for transmission as long
519 * as we have enough credits.
521 INIT_LIST_HEAD(&txq);
525 if (list_empty(&endpoint->txq))
528 ath6kl_htc_tx_pkts_get(target, endpoint, &txq);
530 if (list_empty(&txq))
533 spin_unlock_bh(&target->tx_lock);
539 /* try to send a bundle on each pass */
540 if ((target->tx_bndl_enable) &&
541 (get_queue_depth(&txq) >=
542 HTC_MIN_HTC_MSGS_TO_BUNDLE)) {
543 int temp1 = 0, temp2 = 0;
545 ath6kl_htc_tx_bundle(endpoint, &txq,
547 bundle_sent += temp1;
548 n_pkts_bundle += temp2;
551 if (list_empty(&txq))
554 packet = list_first_entry(&txq, struct htc_packet,
556 list_del(&packet->list);
558 ath6kl_htc_tx_prep_pkt(packet, packet->info.tx.flags,
559 0, packet->info.tx.seqno);
560 ath6kl_htc_tx_issue(target, packet);
563 spin_lock_bh(&target->tx_lock);
565 endpoint->ep_st.tx_bundles += bundle_sent;
566 endpoint->ep_st.tx_pkt_bundled += n_pkts_bundle;
569 endpoint->tx_proc_cnt = 0;
570 spin_unlock_bh(&target->tx_lock);
573 static bool ath6kl_htc_tx_try(struct htc_target *target,
574 struct htc_endpoint *endpoint,
575 struct htc_packet *tx_pkt)
577 struct htc_ep_callbacks ep_cb;
579 bool overflow = false;
581 ep_cb = endpoint->ep_cb;
583 spin_lock_bh(&target->tx_lock);
584 txq_depth = get_queue_depth(&endpoint->txq);
585 spin_unlock_bh(&target->tx_lock);
587 if (txq_depth >= endpoint->max_txq_depth)
591 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
592 "ep %d, tx queue will overflow :%d , tx depth:%d, max:%d\n",
593 endpoint->eid, overflow, txq_depth,
594 endpoint->max_txq_depth);
596 if (overflow && ep_cb.tx_full) {
597 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
598 "indicating overflowed tx packet: 0x%p\n", tx_pkt);
600 if (ep_cb.tx_full(endpoint->target, tx_pkt) ==
601 HTC_SEND_FULL_DROP) {
602 endpoint->ep_st.tx_dropped += 1;
607 spin_lock_bh(&target->tx_lock);
608 list_add_tail(&tx_pkt->list, &endpoint->txq);
609 spin_unlock_bh(&target->tx_lock);
611 ath6kl_htc_tx_from_queue(target, endpoint);
616 static void htc_chk_ep_txq(struct htc_target *target)
618 struct htc_endpoint *endpoint;
619 struct htc_endpoint_credit_dist *cred_dist;
622 * Run through the credit distribution list to see if there are
623 * packets queued. NOTE: no locks need to be taken since the
624 * distribution list is not dynamic (cannot be re-ordered) and we
625 * are not modifying any state.
627 list_for_each_entry(cred_dist, &target->cred_dist_list, list) {
628 endpoint = (struct htc_endpoint *)cred_dist->htc_rsvd;
630 spin_lock_bh(&target->tx_lock);
631 if (!list_empty(&endpoint->txq)) {
632 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
633 "ep %d has %d credits and %d packets in tx queue\n",
635 endpoint->cred_dist.credits,
636 get_queue_depth(&endpoint->txq));
637 spin_unlock_bh(&target->tx_lock);
639 * Try to start the stalled queue, this list is
640 * ordered by priority. If there are credits
641 * available the highest priority queue will get a
642 * chance to reclaim credits from lower priority
645 ath6kl_htc_tx_from_queue(target, endpoint);
646 spin_lock_bh(&target->tx_lock);
648 spin_unlock_bh(&target->tx_lock);
652 static int htc_setup_tx_complete(struct htc_target *target)
654 struct htc_packet *send_pkt = NULL;
657 send_pkt = htc_get_control_buf(target, true);
662 if (target->htc_tgt_ver >= HTC_VERSION_2P1) {
663 struct htc_setup_comp_ext_msg *setup_comp_ext;
667 (struct htc_setup_comp_ext_msg *)send_pkt->buf;
668 memset(setup_comp_ext, 0, sizeof(*setup_comp_ext));
669 setup_comp_ext->msg_id =
670 cpu_to_le16(HTC_MSG_SETUP_COMPLETE_EX_ID);
672 if (target->msg_per_bndl_max > 0) {
673 /* Indicate HTC bundling to the target */
674 flags |= HTC_SETUP_COMP_FLG_RX_BNDL_EN;
675 setup_comp_ext->msg_per_rxbndl =
676 target->msg_per_bndl_max;
679 memcpy(&setup_comp_ext->flags, &flags,
680 sizeof(setup_comp_ext->flags));
681 set_htc_pkt_info(send_pkt, NULL, (u8 *) setup_comp_ext,
682 sizeof(struct htc_setup_comp_ext_msg),
683 ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG);
686 struct htc_setup_comp_msg *setup_comp;
687 setup_comp = (struct htc_setup_comp_msg *)send_pkt->buf;
688 memset(setup_comp, 0, sizeof(struct htc_setup_comp_msg));
689 setup_comp->msg_id = cpu_to_le16(HTC_MSG_SETUP_COMPLETE_ID);
690 set_htc_pkt_info(send_pkt, NULL, (u8 *) setup_comp,
691 sizeof(struct htc_setup_comp_msg),
692 ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG);
695 /* we want synchronous operation */
696 send_pkt->completion = NULL;
697 ath6kl_htc_tx_prep_pkt(send_pkt, 0, 0, 0);
698 status = ath6kl_htc_tx_issue(target, send_pkt);
700 if (send_pkt != NULL)
701 htc_reclaim_txctrl_buf(target, send_pkt);
706 void ath6kl_htc_set_credit_dist(struct htc_target *target,
707 struct htc_credit_state_info *cred_dist_cntxt,
708 u16 srvc_pri_order[], int list_len)
710 struct htc_endpoint *endpoint;
713 target->cred_dist_cntxt = cred_dist_cntxt;
715 list_add_tail(&target->endpoint[ENDPOINT_0].cred_dist.list,
716 &target->cred_dist_list);
718 for (i = 0; i < list_len; i++) {
719 for (ep = ENDPOINT_1; ep < ENDPOINT_MAX; ep++) {
720 endpoint = &target->endpoint[ep];
721 if (endpoint->svc_id == srvc_pri_order[i]) {
722 list_add_tail(&endpoint->cred_dist.list,
723 &target->cred_dist_list);
727 if (ep >= ENDPOINT_MAX) {
734 int ath6kl_htc_tx(struct htc_target *target, struct htc_packet *packet)
736 struct htc_endpoint *endpoint;
737 struct list_head queue;
739 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
740 "htc_tx: ep id: %d, buf: 0x%p, len: %d\n",
741 packet->endpoint, packet->buf, packet->act_len);
743 if (packet->endpoint >= ENDPOINT_MAX) {
748 endpoint = &target->endpoint[packet->endpoint];
750 if (!ath6kl_htc_tx_try(target, endpoint, packet)) {
751 packet->status = (target->htc_flags & HTC_OP_STATE_STOPPING) ?
752 -ECANCELED : -ENOSPC;
753 INIT_LIST_HEAD(&queue);
754 list_add(&packet->list, &queue);
755 htc_tx_complete(endpoint, &queue);
761 /* flush endpoint TX queue */
762 void ath6kl_htc_flush_txep(struct htc_target *target,
763 enum htc_endpoint_id eid, u16 tag)
765 struct htc_packet *packet, *tmp_pkt;
766 struct list_head discard_q, container;
767 struct htc_endpoint *endpoint = &target->endpoint[eid];
769 if (!endpoint->svc_id) {
774 /* initialize the discard queue */
775 INIT_LIST_HEAD(&discard_q);
777 spin_lock_bh(&target->tx_lock);
779 list_for_each_entry_safe(packet, tmp_pkt, &endpoint->txq, list) {
780 if ((tag == HTC_TX_PACKET_TAG_ALL) ||
781 (tag == packet->info.tx.tag))
782 list_move_tail(&packet->list, &discard_q);
785 spin_unlock_bh(&target->tx_lock);
787 list_for_each_entry_safe(packet, tmp_pkt, &discard_q, list) {
788 packet->status = -ECANCELED;
789 list_del(&packet->list);
790 ath6kl_dbg(ATH6KL_DBG_TRC,
791 "flushing tx pkt:0x%p, len:%d, ep:%d tag:0x%X\n",
792 packet, packet->act_len,
793 packet->endpoint, packet->info.tx.tag);
795 INIT_LIST_HEAD(&container);
796 list_add_tail(&packet->list, &container);
797 htc_tx_complete(endpoint, &container);
802 static void ath6kl_htc_flush_txep_all(struct htc_target *target)
804 struct htc_endpoint *endpoint;
807 dump_cred_dist_stats(target);
809 for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) {
810 endpoint = &target->endpoint[i];
811 if (endpoint->svc_id == 0)
814 ath6kl_htc_flush_txep(target, i, HTC_TX_PACKET_TAG_ALL);
818 void ath6kl_htc_indicate_activity_change(struct htc_target *target,
819 enum htc_endpoint_id eid, bool active)
821 struct htc_endpoint *endpoint = &target->endpoint[eid];
824 if (endpoint->svc_id == 0) {
829 spin_lock_bh(&target->tx_lock);
832 if (!(endpoint->cred_dist.dist_flags & HTC_EP_ACTIVE)) {
833 endpoint->cred_dist.dist_flags |= HTC_EP_ACTIVE;
837 if (endpoint->cred_dist.dist_flags & HTC_EP_ACTIVE) {
838 endpoint->cred_dist.dist_flags &= ~HTC_EP_ACTIVE;
844 endpoint->cred_dist.txq_depth =
845 get_queue_depth(&endpoint->txq);
847 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "ctxt:0x%p dist:0x%p\n",
848 target->cred_dist_cntxt, &target->cred_dist_list);
850 ath6k_credit_distribute(target->cred_dist_cntxt,
851 &target->cred_dist_list,
852 HTC_CREDIT_DIST_ACTIVITY_CHANGE);
855 spin_unlock_bh(&target->tx_lock);
858 htc_chk_ep_txq(target);
863 static inline void ath6kl_htc_rx_update_stats(struct htc_endpoint *endpoint,
866 endpoint->ep_st.rx_pkts++;
867 if (n_look_ahds == 1)
868 endpoint->ep_st.rx_lkahds++;
869 else if (n_look_ahds > 1)
870 endpoint->ep_st.rx_bundle_lkahd++;
873 static inline bool htc_valid_rx_frame_len(struct htc_target *target,
874 enum htc_endpoint_id eid, int len)
876 return (eid == target->dev->ar->ctrl_ep) ?
877 len <= ATH6KL_BUFFER_SIZE : len <= ATH6KL_AMSDU_BUFFER_SIZE;
880 static int htc_add_rxbuf(struct htc_target *target, struct htc_packet *packet)
882 struct list_head queue;
884 INIT_LIST_HEAD(&queue);
885 list_add_tail(&packet->list, &queue);
886 return ath6kl_htc_add_rxbuf_multiple(target, &queue);
889 static void htc_reclaim_rxbuf(struct htc_target *target,
890 struct htc_packet *packet,
891 struct htc_endpoint *ep)
893 if (packet->info.rx.rx_flags & HTC_RX_PKT_NO_RECYCLE) {
894 htc_rxpkt_reset(packet);
895 packet->status = -ECANCELED;
896 ep->ep_cb.rx(ep->target, packet);
898 htc_rxpkt_reset(packet);
899 htc_add_rxbuf((void *)(target), packet);
903 static void reclaim_rx_ctrl_buf(struct htc_target *target,
904 struct htc_packet *packet)
906 spin_lock_bh(&target->htc_lock);
907 list_add_tail(&packet->list, &target->free_ctrl_rxbuf);
908 spin_unlock_bh(&target->htc_lock);
911 static int ath6kl_htc_rx_packet(struct htc_target *target,
912 struct htc_packet *packet,
915 struct ath6kl_device *dev = target->dev;
919 padded_len = CALC_TXRX_PADDED_LEN(target, rx_len);
921 if (padded_len > packet->buf_len) {
922 ath6kl_err("not enough receive space for packet - padlen:%d recvlen:%d bufferlen:%d\n",
923 padded_len, rx_len, packet->buf_len);
927 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
928 "dev_rx_pkt (0x%p : hdr:0x%X) padded len: %d mbox:0x%X (mode:%s)\n",
929 packet, packet->info.rx.exp_hdr,
930 padded_len, dev->ar->mbox_info.htc_addr, "sync");
932 status = hif_read_write_sync(dev->ar,
933 dev->ar->mbox_info.htc_addr,
934 packet->buf, padded_len,
935 HIF_RD_SYNC_BLOCK_FIX);
937 packet->status = status;
943 * optimization for recv packets, we can indicate a
944 * "hint" that there are more single-packets to fetch
947 static void ath6kl_htc_rx_set_indicate(u32 lk_ahd,
948 struct htc_endpoint *endpoint,
949 struct htc_packet *packet)
951 struct htc_frame_hdr *htc_hdr = (struct htc_frame_hdr *)&lk_ahd;
953 if (htc_hdr->eid == packet->endpoint) {
954 if (!list_empty(&endpoint->rx_bufq))
955 packet->info.rx.indicat_flags |=
956 HTC_RX_FLAGS_INDICATE_MORE_PKTS;
960 static void ath6kl_htc_rx_chk_water_mark(struct htc_endpoint *endpoint)
962 struct htc_ep_callbacks ep_cb = endpoint->ep_cb;
964 if (ep_cb.rx_refill_thresh > 0) {
965 spin_lock_bh(&endpoint->target->rx_lock);
966 if (get_queue_depth(&endpoint->rx_bufq)
967 < ep_cb.rx_refill_thresh) {
968 spin_unlock_bh(&endpoint->target->rx_lock);
969 ep_cb.rx_refill(endpoint->target, endpoint->eid);
972 spin_unlock_bh(&endpoint->target->rx_lock);
976 /* This function is called with rx_lock held */
977 static int ath6kl_htc_rx_setup(struct htc_target *target,
978 struct htc_endpoint *ep,
979 u32 *lk_ahds, struct list_head *queue, int n_msg)
981 struct htc_packet *packet;
982 /* FIXME: type of lk_ahds can't be right */
983 struct htc_frame_hdr *htc_hdr = (struct htc_frame_hdr *)lk_ahds;
984 struct htc_ep_callbacks ep_cb;
985 int status = 0, j, full_len;
988 full_len = CALC_TXRX_PADDED_LEN(target,
989 le16_to_cpu(htc_hdr->payld_len) +
992 if (!htc_valid_rx_frame_len(target, ep->eid, full_len)) {
993 ath6kl_warn("Rx buffer requested with invalid length\n");
998 for (j = 0; j < n_msg; j++) {
1001 * Reset flag, any packets allocated using the
1002 * rx_alloc() API cannot be recycled on
1003 * cleanup,they must be explicitly returned.
1007 if (ep_cb.rx_allocthresh &&
1008 (full_len > ep_cb.rx_alloc_thresh)) {
1009 ep->ep_st.rx_alloc_thresh_hit += 1;
1010 ep->ep_st.rxalloc_thresh_byte +=
1011 le16_to_cpu(htc_hdr->payld_len);
1013 spin_unlock_bh(&target->rx_lock);
1016 packet = ep_cb.rx_allocthresh(ep->target, ep->eid,
1018 spin_lock_bh(&target->rx_lock);
1020 /* refill handler is being used */
1021 if (list_empty(&ep->rx_bufq)) {
1022 if (ep_cb.rx_refill) {
1023 spin_unlock_bh(&target->rx_lock);
1024 ep_cb.rx_refill(ep->target, ep->eid);
1025 spin_lock_bh(&target->rx_lock);
1029 if (list_empty(&ep->rx_bufq))
1032 packet = list_first_entry(&ep->rx_bufq,
1033 struct htc_packet, list);
1034 list_del(&packet->list);
1039 target->rx_st_flags |= HTC_RECV_WAIT_BUFFERS;
1040 target->ep_waiting = ep->eid;
1045 packet->info.rx.rx_flags = 0;
1046 packet->info.rx.indicat_flags = 0;
1051 * flag that these packets cannot be
1052 * recycled, they have to be returned to
1055 packet->info.rx.rx_flags |= HTC_RX_PKT_NO_RECYCLE;
1057 /* Caller needs to free this upon any failure */
1058 list_add_tail(&packet->list, queue);
1060 if (target->htc_flags & HTC_OP_STATE_STOPPING) {
1061 status = -ECANCELED;
1066 packet->info.rx.rx_flags |= HTC_RX_PKT_REFRESH_HDR;
1067 packet->info.rx.exp_hdr = 0xFFFFFFFF;
1069 /* set expected look ahead */
1070 packet->info.rx.exp_hdr = *lk_ahds;
1072 packet->act_len = le16_to_cpu(htc_hdr->payld_len) +
1079 static int ath6kl_htc_rx_alloc(struct htc_target *target,
1080 u32 lk_ahds[], int msg,
1081 struct htc_endpoint *endpoint,
1082 struct list_head *queue)
1085 struct htc_packet *packet, *tmp_pkt;
1086 struct htc_frame_hdr *htc_hdr;
1089 spin_lock_bh(&target->rx_lock);
1091 for (i = 0; i < msg; i++) {
1093 htc_hdr = (struct htc_frame_hdr *)&lk_ahds[i];
1095 if (htc_hdr->eid >= ENDPOINT_MAX) {
1096 ath6kl_err("invalid ep in look-ahead: %d\n",
1102 if (htc_hdr->eid != endpoint->eid) {
1103 ath6kl_err("invalid ep in look-ahead: %d should be : %d (index:%d)\n",
1104 htc_hdr->eid, endpoint->eid, i);
1109 if (le16_to_cpu(htc_hdr->payld_len) > HTC_MAX_PAYLOAD_LENGTH) {
1110 ath6kl_err("payload len %d exceeds max htc : %d !\n",
1112 (u32) HTC_MAX_PAYLOAD_LENGTH);
1117 if (endpoint->svc_id == 0) {
1118 ath6kl_err("ep %d is not connected !\n", htc_hdr->eid);
1123 if (htc_hdr->flags & HTC_FLG_RX_BNDL_CNT) {
1125 * HTC header indicates that every packet to follow
1126 * has the same padded length so that it can be
1127 * optimally fetched as a full bundle.
1129 n_msg = (htc_hdr->flags & HTC_FLG_RX_BNDL_CNT) >>
1130 HTC_FLG_RX_BNDL_CNT_S;
1132 /* the count doesn't include the starter frame */
1134 if (n_msg > target->msg_per_bndl_max) {
1139 endpoint->ep_st.rx_bundle_from_hdr += 1;
1140 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
1141 "htc hdr indicates :%d msg can be fetched as a bundle\n",
1144 /* HTC header only indicates 1 message to fetch */
1147 /* Setup packet buffers for each message */
1148 status = ath6kl_htc_rx_setup(target, endpoint, &lk_ahds[i],
1152 * This is due to unavailabilty of buffers to rx entire data.
1153 * Return no error so that free buffers from queue can be used
1154 * to receive partial data.
1156 if (status == -ENOSPC) {
1157 spin_unlock_bh(&target->rx_lock);
1165 spin_unlock_bh(&target->rx_lock);
1168 list_for_each_entry_safe(packet, tmp_pkt, queue, list) {
1169 list_del(&packet->list);
1170 htc_reclaim_rxbuf(target, packet,
1171 &target->endpoint[packet->endpoint]);
1178 static void htc_ctrl_rx(struct htc_target *context, struct htc_packet *packets)
1180 if (packets->endpoint != ENDPOINT_0) {
1185 if (packets->status == -ECANCELED) {
1186 reclaim_rx_ctrl_buf(context, packets);
1190 if (packets->act_len > 0) {
1191 ath6kl_err("htc_ctrl_rx, got message with len:%zu\n",
1192 packets->act_len + HTC_HDR_LENGTH);
1194 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES,
1195 "Unexpected ENDPOINT 0 Message", "",
1196 packets->buf - HTC_HDR_LENGTH,
1197 packets->act_len + HTC_HDR_LENGTH);
1200 htc_reclaim_rxbuf(context, packets, &context->endpoint[0]);
1203 static void htc_proc_cred_rpt(struct htc_target *target,
1204 struct htc_credit_report *rpt,
1206 enum htc_endpoint_id from_ep)
1208 struct htc_endpoint *endpoint;
1209 int tot_credits = 0, i;
1212 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
1213 "htc_proc_cred_rpt, credit report entries:%d\n", n_entries);
1215 spin_lock_bh(&target->tx_lock);
1217 for (i = 0; i < n_entries; i++, rpt++) {
1218 if (rpt->eid >= ENDPOINT_MAX) {
1220 spin_unlock_bh(&target->tx_lock);
1224 endpoint = &target->endpoint[rpt->eid];
1226 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, " ep %d got %d credits\n",
1227 rpt->eid, rpt->credits);
1229 endpoint->ep_st.tx_cred_rpt += 1;
1230 endpoint->ep_st.cred_retnd += rpt->credits;
1232 if (from_ep == rpt->eid) {
1234 * This credit report arrived on the same endpoint
1235 * indicating it arrived in an RX packet.
1237 endpoint->ep_st.cred_from_rx += rpt->credits;
1238 endpoint->ep_st.cred_rpt_from_rx += 1;
1239 } else if (from_ep == ENDPOINT_0) {
1240 /* credit arrived on endpoint 0 as a NULL message */
1241 endpoint->ep_st.cred_from_ep0 += rpt->credits;
1242 endpoint->ep_st.cred_rpt_ep0 += 1;
1244 endpoint->ep_st.cred_from_other += rpt->credits;
1245 endpoint->ep_st.cred_rpt_from_other += 1;
1248 if (rpt->eid == ENDPOINT_0)
1249 /* always give endpoint 0 credits back */
1250 endpoint->cred_dist.credits += rpt->credits;
1252 endpoint->cred_dist.cred_to_dist += rpt->credits;
1257 * Refresh tx depth for distribution function that will
1258 * recover these credits NOTE: this is only valid when
1259 * there are credits to recover!
1261 endpoint->cred_dist.txq_depth =
1262 get_queue_depth(&endpoint->txq);
1264 tot_credits += rpt->credits;
1267 ath6kl_dbg(ATH6KL_DBG_HTC_SEND,
1268 "report indicated %d credits to distribute\n",
1273 * This was a credit return based on a completed send
1274 * operations note, this is done with the lock held
1276 ath6kl_dbg(ATH6KL_DBG_HTC_SEND, "ctxt:0x%p dist:0x%p\n",
1277 target->cred_dist_cntxt, &target->cred_dist_list);
1279 ath6k_credit_distribute(target->cred_dist_cntxt,
1280 &target->cred_dist_list,
1281 HTC_CREDIT_DIST_SEND_COMPLETE);
1284 spin_unlock_bh(&target->tx_lock);
1287 htc_chk_ep_txq(target);
1290 static int htc_parse_trailer(struct htc_target *target,
1291 struct htc_record_hdr *record,
1292 u8 *record_buf, u32 *next_lk_ahds,
1293 enum htc_endpoint_id endpoint,
1296 struct htc_bundle_lkahd_rpt *bundle_lkahd_rpt;
1297 struct htc_lookahead_report *lk_ahd;
1300 switch (record->rec_id) {
1301 case HTC_RECORD_CREDITS:
1302 len = record->len / sizeof(struct htc_credit_report);
1308 htc_proc_cred_rpt(target,
1309 (struct htc_credit_report *) record_buf,
1312 case HTC_RECORD_LOOKAHEAD:
1313 len = record->len / sizeof(*lk_ahd);
1319 lk_ahd = (struct htc_lookahead_report *) record_buf;
1320 if ((lk_ahd->pre_valid == ((~lk_ahd->post_valid) & 0xFF))
1323 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
1324 "lk_ahd report found (pre valid:0x%X, post valid:0x%X)\n",
1325 lk_ahd->pre_valid, lk_ahd->post_valid);
1327 /* look ahead bytes are valid, copy them over */
1328 memcpy((u8 *)&next_lk_ahds[0], lk_ahd->lk_ahd, 4);
1330 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES, "Next Look Ahead",
1331 "", next_lk_ahds, 4);
1336 case HTC_RECORD_LOOKAHEAD_BUNDLE:
1337 len = record->len / sizeof(*bundle_lkahd_rpt);
1338 if (!len || (len > HTC_HOST_MAX_MSG_PER_BUNDLE)) {
1347 (struct htc_bundle_lkahd_rpt *) record_buf;
1349 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES, "Bundle lk_ahd",
1350 "", record_buf, record->len);
1352 for (i = 0; i < len; i++) {
1353 memcpy((u8 *)&next_lk_ahds[i],
1354 bundle_lkahd_rpt->lk_ahd, 4);
1362 ath6kl_err("unhandled record: id:%d len:%d\n",
1363 record->rec_id, record->len);
1371 static int htc_proc_trailer(struct htc_target *target,
1372 u8 *buf, int len, u32 *next_lk_ahds,
1373 int *n_lk_ahds, enum htc_endpoint_id endpoint)
1375 struct htc_record_hdr *record;
1381 ath6kl_dbg(ATH6KL_DBG_HTC_RECV, "+htc_proc_trailer (len:%d)\n", len);
1383 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES, "Recv Trailer", "",
1392 if (len < sizeof(struct htc_record_hdr)) {
1396 /* these are byte aligned structs */
1397 record = (struct htc_record_hdr *) buf;
1398 len -= sizeof(struct htc_record_hdr);
1399 buf += sizeof(struct htc_record_hdr);
1401 if (record->len > len) {
1402 ath6kl_err("invalid record len: %d (id:%d) buf has: %d bytes left\n",
1403 record->len, record->rec_id, len);
1409 status = htc_parse_trailer(target, record, record_buf,
1410 next_lk_ahds, endpoint, n_lk_ahds);
1415 /* advance buffer past this record for next time around */
1421 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES, "BAD Recv Trailer",
1422 "", orig_buf, orig_len);
1427 static int ath6kl_htc_rx_process_hdr(struct htc_target *target,
1428 struct htc_packet *packet,
1429 u32 *next_lkahds, int *n_lkahds)
1434 struct htc_frame_hdr *htc_hdr = (struct htc_frame_hdr *)packet->buf;
1436 if (n_lkahds != NULL)
1439 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES, "HTC Recv PKT", "htc ",
1440 packet->buf, packet->act_len);
1443 * NOTE: we cannot assume the alignment of buf, so we use the safe
1444 * macros to retrieve 16 bit fields.
1446 payload_len = le16_to_cpu(get_unaligned(&htc_hdr->payld_len));
1448 memcpy((u8 *)&lk_ahd, packet->buf, sizeof(lk_ahd));
1450 if (packet->info.rx.rx_flags & HTC_RX_PKT_REFRESH_HDR) {
1452 * Refresh the expected header and the actual length as it
1453 * was unknown when this packet was grabbed as part of the
1456 packet->info.rx.exp_hdr = lk_ahd;
1457 packet->act_len = payload_len + HTC_HDR_LENGTH;
1459 /* validate the actual header that was refreshed */
1460 if (packet->act_len > packet->buf_len) {
1461 ath6kl_err("refreshed hdr payload len (%d) in bundled recv is invalid (hdr: 0x%X)\n",
1462 payload_len, lk_ahd);
1464 * Limit this to max buffer just to print out some
1467 packet->act_len = min(packet->act_len, packet->buf_len);
1472 if (packet->endpoint != htc_hdr->eid) {
1473 ath6kl_err("refreshed hdr ep (%d) does not match expected ep (%d)\n",
1474 htc_hdr->eid, packet->endpoint);
1480 if (lk_ahd != packet->info.rx.exp_hdr) {
1481 ath6kl_err("%s(): lk_ahd mismatch! (pPkt:0x%p flags:0x%X)\n",
1482 __func__, packet, packet->info.rx.rx_flags);
1483 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES, "Expected Message lk_ahd",
1484 "", &packet->info.rx.exp_hdr, 4);
1485 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES, "Current Frame Header",
1486 "", (u8 *)&lk_ahd, sizeof(lk_ahd));
1491 if (htc_hdr->flags & HTC_FLG_RX_TRAILER) {
1492 if (htc_hdr->ctrl[0] < sizeof(struct htc_record_hdr) ||
1493 htc_hdr->ctrl[0] > payload_len) {
1494 ath6kl_err("%s(): invalid hdr (payload len should be :%d, CB[0] is:%d)\n",
1495 __func__, payload_len, htc_hdr->ctrl[0]);
1500 if (packet->info.rx.rx_flags & HTC_RX_PKT_IGNORE_LOOKAHEAD) {
1505 status = htc_proc_trailer(target, packet->buf + HTC_HDR_LENGTH
1506 + payload_len - htc_hdr->ctrl[0],
1507 htc_hdr->ctrl[0], next_lkahds,
1508 n_lkahds, packet->endpoint);
1513 packet->act_len -= htc_hdr->ctrl[0];
1516 packet->buf += HTC_HDR_LENGTH;
1517 packet->act_len -= HTC_HDR_LENGTH;
1521 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES, "BAD HTC Recv PKT",
1523 packet->act_len < 256 ? packet->act_len : 256);
1525 if (packet->act_len > 0)
1526 ath6kl_dbg_dump(ATH6KL_DBG_RAW_BYTES,
1527 "HTC - Application Msg", "",
1528 packet->buf, packet->act_len);
1534 static void ath6kl_htc_rx_complete(struct htc_endpoint *endpoint,
1535 struct htc_packet *packet)
1537 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
1538 "htc calling ep %d recv callback on packet 0x%p\n",
1539 endpoint->eid, packet);
1540 endpoint->ep_cb.rx(endpoint->target, packet);
1543 static int ath6kl_htc_rx_bundle(struct htc_target *target,
1544 struct list_head *rxq,
1545 struct list_head *sync_compq,
1546 int *n_pkt_fetched, bool part_bundle)
1548 struct hif_scatter_req *scat_req;
1549 struct htc_packet *packet;
1550 int rem_space = target->max_rx_bndl_sz;
1551 int n_scat_pkt, status = 0, i, len;
1553 n_scat_pkt = get_queue_depth(rxq);
1554 n_scat_pkt = min(n_scat_pkt, target->msg_per_bndl_max);
1556 if ((get_queue_depth(rxq) - n_scat_pkt) > 0) {
1558 * We were forced to split this bundle receive operation
1559 * all packets in this partial bundle must have their
1560 * lookaheads ignored.
1565 * This would only happen if the target ignored our max
1568 ath6kl_warn("%s(): partial bundle detected num:%d , %d\n",
1569 __func__, get_queue_depth(rxq), n_scat_pkt);
1574 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
1575 "%s(): (numpackets: %d , actual : %d)\n",
1576 __func__, get_queue_depth(rxq), n_scat_pkt);
1578 scat_req = hif_scatter_req_get(target->dev->ar);
1580 if (scat_req == NULL)
1583 for (i = 0; i < n_scat_pkt; i++) {
1586 packet = list_first_entry(rxq, struct htc_packet, list);
1587 list_del(&packet->list);
1589 pad_len = CALC_TXRX_PADDED_LEN(target,
1592 if ((rem_space - pad_len) < 0) {
1593 list_add(&packet->list, rxq);
1597 rem_space -= pad_len;
1599 if (part_bundle || (i < (n_scat_pkt - 1)))
1601 * Packet 0..n-1 cannot be checked for look-aheads
1602 * since we are fetching a bundle the last packet
1603 * however can have it's lookahead used
1605 packet->info.rx.rx_flags |=
1606 HTC_RX_PKT_IGNORE_LOOKAHEAD;
1608 /* NOTE: 1 HTC packet per scatter entry */
1609 scat_req->scat_list[i].buf = packet->buf;
1610 scat_req->scat_list[i].len = pad_len;
1612 packet->info.rx.rx_flags |= HTC_RX_PKT_PART_OF_BUNDLE;
1614 list_add_tail(&packet->list, sync_compq);
1616 WARN_ON(!scat_req->scat_list[i].len);
1617 len += scat_req->scat_list[i].len;
1620 scat_req->len = len;
1621 scat_req->scat_entries = i;
1623 status = ath6kldev_submit_scat_req(target->dev, scat_req, true);
1628 /* free scatter request */
1629 hif_scatter_req_add(target->dev->ar, scat_req);
1636 static int ath6kl_htc_rx_process_packets(struct htc_target *target,
1637 struct list_head *comp_pktq,
1641 struct htc_packet *packet, *tmp_pkt;
1642 struct htc_endpoint *ep;
1645 list_for_each_entry_safe(packet, tmp_pkt, comp_pktq, list) {
1646 ep = &target->endpoint[packet->endpoint];
1648 /* process header for each of the recv packet */
1649 status = ath6kl_htc_rx_process_hdr(target, packet, lk_ahds,
1654 list_del(&packet->list);
1656 if (list_empty(comp_pktq)) {
1658 * Last packet's more packet flag is set
1659 * based on the lookahead.
1662 ath6kl_htc_rx_set_indicate(lk_ahds[0],
1666 * Packets in a bundle automatically have
1669 packet->info.rx.indicat_flags |=
1670 HTC_RX_FLAGS_INDICATE_MORE_PKTS;
1672 ath6kl_htc_rx_update_stats(ep, *n_lk_ahd);
1674 if (packet->info.rx.rx_flags & HTC_RX_PKT_PART_OF_BUNDLE)
1675 ep->ep_st.rx_bundl += 1;
1677 ath6kl_htc_rx_complete(ep, packet);
1683 static int ath6kl_htc_rx_fetch(struct htc_target *target,
1684 struct list_head *rx_pktq,
1685 struct list_head *comp_pktq)
1688 bool part_bundle = false;
1691 /* now go fetch the list of HTC packets */
1692 while (!list_empty(rx_pktq)) {
1695 if (target->rx_bndl_enable && (get_queue_depth(rx_pktq) > 1)) {
1697 * There are enough packets to attempt a
1698 * bundle transfer and recv bundling is
1701 status = ath6kl_htc_rx_bundle(target, rx_pktq,
1708 if (!list_empty(rx_pktq))
1712 if (!fetched_pkts) {
1713 struct htc_packet *packet;
1715 packet = list_first_entry(rx_pktq, struct htc_packet,
1718 list_del(&packet->list);
1720 /* fully synchronous */
1721 packet->completion = NULL;
1723 if (!list_empty(rx_pktq))
1725 * look_aheads in all packet
1726 * except the last one in the
1727 * bundle must be ignored
1729 packet->info.rx.rx_flags |=
1730 HTC_RX_PKT_IGNORE_LOOKAHEAD;
1732 /* go fetch the packet */
1733 status = ath6kl_htc_rx_packet(target, packet,
1738 list_add_tail(&packet->list, comp_pktq);
1745 int ath6kl_htc_rxmsg_pending_handler(struct htc_target *target,
1746 u32 msg_look_ahead[], int *num_pkts)
1748 struct htc_packet *packets, *tmp_pkt;
1749 struct htc_endpoint *endpoint;
1750 struct list_head rx_pktq, comp_pktq;
1752 u32 look_aheads[HTC_HOST_MAX_MSG_PER_BUNDLE];
1753 int num_look_ahead = 1;
1754 enum htc_endpoint_id id;
1760 * On first entry copy the look_aheads into our temp array for
1763 memcpy(look_aheads, msg_look_ahead, sizeof(look_aheads));
1768 * First lookahead sets the expected endpoint IDs for all
1769 * packets in a bundle.
1771 id = ((struct htc_frame_hdr *)&look_aheads[0])->eid;
1772 endpoint = &target->endpoint[id];
1774 if (id >= ENDPOINT_MAX) {
1775 ath6kl_err("MsgPend, invalid endpoint in look-ahead: %d\n",
1781 INIT_LIST_HEAD(&rx_pktq);
1782 INIT_LIST_HEAD(&comp_pktq);
1785 * Try to allocate as many HTC RX packets indicated by the
1788 status = ath6kl_htc_rx_alloc(target, look_aheads,
1789 num_look_ahead, endpoint,
1794 if (get_queue_depth(&rx_pktq) >= 2)
1796 * A recv bundle was detected, force IRQ status
1799 target->chk_irq_status_cnt = 1;
1801 n_fetched += get_queue_depth(&rx_pktq);
1805 status = ath6kl_htc_rx_fetch(target, &rx_pktq, &comp_pktq);
1808 ath6kl_htc_rx_chk_water_mark(endpoint);
1810 /* Process fetched packets */
1811 status = ath6kl_htc_rx_process_packets(target, &comp_pktq,
1815 if (!num_look_ahead || status)
1819 * For SYNCH processing, if we get here, we are running
1820 * through the loop again due to a detected lookahead. Set
1821 * flag that we should re-check IRQ status registers again
1822 * before leaving IRQ processing, this can net better
1823 * performance in high throughput situations.
1825 target->chk_irq_status_cnt = 1;
1829 ath6kl_err("failed to get pending recv messages: %d\n",
1832 * Cleanup any packets we allocated but didn't use to
1833 * actually fetch any packets.
1835 list_for_each_entry_safe(packets, tmp_pkt, &rx_pktq, list) {
1836 list_del(&packets->list);
1837 htc_reclaim_rxbuf(target, packets,
1838 &target->endpoint[packets->endpoint]);
1841 /* cleanup any packets in sync completion queue */
1842 list_for_each_entry_safe(packets, tmp_pkt, &comp_pktq, list) {
1843 list_del(&packets->list);
1844 htc_reclaim_rxbuf(target, packets,
1845 &target->endpoint[packets->endpoint]);
1848 if (target->htc_flags & HTC_OP_STATE_STOPPING) {
1849 ath6kl_warn("host is going to stop blocking receiver for htc_stop\n");
1850 ath6kldev_rx_control(target->dev, false);
1855 * Before leaving, check to see if host ran out of buffers and
1856 * needs to stop the receiver.
1858 if (target->rx_st_flags & HTC_RECV_WAIT_BUFFERS) {
1859 ath6kl_warn("host has no rx buffers blocking receiver to prevent overrun\n");
1860 ath6kldev_rx_control(target->dev, false);
1862 *num_pkts = n_fetched;
1868 * Synchronously wait for a control message from the target,
1869 * This function is used at initialization time ONLY. At init messages
1870 * on ENDPOINT 0 are expected.
1872 static struct htc_packet *htc_wait_for_ctrl_msg(struct htc_target *target)
1874 struct htc_packet *packet = NULL;
1875 struct htc_frame_hdr *htc_hdr;
1878 if (ath6kldev_poll_mboxmsg_rx(target->dev, &look_ahead,
1879 HTC_TARGET_RESPONSE_TIMEOUT))
1882 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
1883 "htc_wait_for_ctrl_msg: look_ahead : 0x%X\n", look_ahead);
1885 htc_hdr = (struct htc_frame_hdr *)&look_ahead;
1887 if (htc_hdr->eid != ENDPOINT_0)
1890 packet = htc_get_control_buf(target, false);
1895 packet->info.rx.rx_flags = 0;
1896 packet->info.rx.exp_hdr = look_ahead;
1897 packet->act_len = le16_to_cpu(htc_hdr->payld_len) + HTC_HDR_LENGTH;
1899 if (packet->act_len > packet->buf_len)
1902 /* we want synchronous operation */
1903 packet->completion = NULL;
1905 /* get the message from the device, this will block */
1906 if (ath6kl_htc_rx_packet(target, packet, packet->act_len))
1909 /* process receive header */
1910 packet->status = ath6kl_htc_rx_process_hdr(target, packet, NULL, NULL);
1912 if (packet->status) {
1913 ath6kl_err("htc_wait_for_ctrl_msg, ath6kl_htc_rx_process_hdr failed (status = %d)\n",
1921 if (packet != NULL) {
1922 htc_rxpkt_reset(packet);
1923 reclaim_rx_ctrl_buf(target, packet);
1929 int ath6kl_htc_add_rxbuf_multiple(struct htc_target *target,
1930 struct list_head *pkt_queue)
1932 struct htc_endpoint *endpoint;
1933 struct htc_packet *first_pkt;
1934 bool rx_unblock = false;
1935 int status = 0, depth;
1937 if (list_empty(pkt_queue))
1940 first_pkt = list_first_entry(pkt_queue, struct htc_packet, list);
1942 if (first_pkt->endpoint >= ENDPOINT_MAX)
1945 depth = get_queue_depth(pkt_queue);
1947 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
1948 "htc_add_rxbuf_multiple: ep id: %d, cnt:%d, len: %d\n",
1949 first_pkt->endpoint, depth, first_pkt->buf_len);
1951 endpoint = &target->endpoint[first_pkt->endpoint];
1953 if (target->htc_flags & HTC_OP_STATE_STOPPING) {
1954 struct htc_packet *packet, *tmp_pkt;
1956 /* walk through queue and mark each one canceled */
1957 list_for_each_entry_safe(packet, tmp_pkt, pkt_queue, list) {
1958 packet->status = -ECANCELED;
1959 list_del(&packet->list);
1960 ath6kl_htc_rx_complete(endpoint, packet);
1966 spin_lock_bh(&target->rx_lock);
1968 list_splice_tail_init(pkt_queue, &endpoint->rx_bufq);
1970 /* check if we are blocked waiting for a new buffer */
1971 if (target->rx_st_flags & HTC_RECV_WAIT_BUFFERS) {
1972 if (target->ep_waiting == first_pkt->endpoint) {
1973 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
1974 "receiver was blocked on ep:%d, unblocking.\n",
1975 target->ep_waiting);
1976 target->rx_st_flags &= ~HTC_RECV_WAIT_BUFFERS;
1977 target->ep_waiting = ENDPOINT_MAX;
1982 spin_unlock_bh(&target->rx_lock);
1984 if (rx_unblock && !(target->htc_flags & HTC_OP_STATE_STOPPING))
1985 /* TODO : implement a buffer threshold count? */
1986 ath6kldev_rx_control(target->dev, true);
1991 void ath6kl_htc_flush_rx_buf(struct htc_target *target)
1993 struct htc_endpoint *endpoint;
1994 struct htc_packet *packet, *tmp_pkt;
1997 for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) {
1998 endpoint = &target->endpoint[i];
1999 if (!endpoint->svc_id)
2003 spin_lock_bh(&target->rx_lock);
2004 list_for_each_entry_safe(packet, tmp_pkt,
2005 &endpoint->rx_bufq, list) {
2006 list_del(&packet->list);
2007 spin_unlock_bh(&target->rx_lock);
2008 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
2009 "flushing rx pkt:0x%p, len:%d, ep:%d\n",
2010 packet, packet->buf_len,
2012 dev_kfree_skb(packet->pkt_cntxt);
2013 spin_lock_bh(&target->rx_lock);
2015 spin_unlock_bh(&target->rx_lock);
2019 int ath6kl_htc_conn_service(struct htc_target *target,
2020 struct htc_service_connect_req *conn_req,
2021 struct htc_service_connect_resp *conn_resp)
2023 struct htc_packet *rx_pkt = NULL;
2024 struct htc_packet *tx_pkt = NULL;
2025 struct htc_conn_service_resp *resp_msg;
2026 struct htc_conn_service_msg *conn_msg;
2027 struct htc_endpoint *endpoint;
2028 enum htc_endpoint_id assigned_ep = ENDPOINT_MAX;
2029 unsigned int max_msg_sz = 0;
2032 ath6kl_dbg(ATH6KL_DBG_TRC,
2033 "htc_conn_service, target:0x%p service id:0x%X\n",
2034 target, conn_req->svc_id);
2036 if (conn_req->svc_id == HTC_CTRL_RSVD_SVC) {
2037 /* special case for pseudo control service */
2038 assigned_ep = ENDPOINT_0;
2039 max_msg_sz = HTC_MAX_CTRL_MSG_LEN;
2041 /* allocate a packet to send to the target */
2042 tx_pkt = htc_get_control_buf(target, true);
2047 conn_msg = (struct htc_conn_service_msg *)tx_pkt->buf;
2048 memset(conn_msg, 0, sizeof(*conn_msg));
2049 conn_msg->msg_id = cpu_to_le16(HTC_MSG_CONN_SVC_ID);
2050 conn_msg->svc_id = cpu_to_le16(conn_req->svc_id);
2051 conn_msg->conn_flags = cpu_to_le16(conn_req->conn_flags);
2053 set_htc_pkt_info(tx_pkt, NULL, (u8 *) conn_msg,
2054 sizeof(*conn_msg) + conn_msg->svc_meta_len,
2055 ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG);
2057 /* we want synchronous operation */
2058 tx_pkt->completion = NULL;
2059 ath6kl_htc_tx_prep_pkt(tx_pkt, 0, 0, 0);
2060 status = ath6kl_htc_tx_issue(target, tx_pkt);
2065 /* wait for response */
2066 rx_pkt = htc_wait_for_ctrl_msg(target);
2073 resp_msg = (struct htc_conn_service_resp *)rx_pkt->buf;
2075 if ((le16_to_cpu(resp_msg->msg_id) != HTC_MSG_CONN_SVC_RESP_ID)
2076 || (rx_pkt->act_len < sizeof(*resp_msg))) {
2081 conn_resp->resp_code = resp_msg->status;
2082 /* check response status */
2083 if (resp_msg->status != HTC_SERVICE_SUCCESS) {
2084 ath6kl_err("target failed service 0x%X connect request (status:%d)\n",
2085 resp_msg->svc_id, resp_msg->status);
2090 assigned_ep = (enum htc_endpoint_id)resp_msg->eid;
2091 max_msg_sz = le16_to_cpu(resp_msg->max_msg_sz);
2094 if (assigned_ep >= ENDPOINT_MAX || !max_msg_sz) {
2099 endpoint = &target->endpoint[assigned_ep];
2100 endpoint->eid = assigned_ep;
2101 if (endpoint->svc_id) {
2106 /* return assigned endpoint to caller */
2107 conn_resp->endpoint = assigned_ep;
2108 conn_resp->len_max = max_msg_sz;
2110 /* setup the endpoint */
2112 /* this marks the endpoint in use */
2113 endpoint->svc_id = conn_req->svc_id;
2115 endpoint->max_txq_depth = conn_req->max_txq_depth;
2116 endpoint->len_max = max_msg_sz;
2117 endpoint->ep_cb = conn_req->ep_cb;
2118 endpoint->cred_dist.svc_id = conn_req->svc_id;
2119 endpoint->cred_dist.htc_rsvd = endpoint;
2120 endpoint->cred_dist.endpoint = assigned_ep;
2121 endpoint->cred_dist.cred_sz = target->tgt_cred_sz;
2123 if (conn_req->max_rxmsg_sz) {
2125 * Override cred_per_msg calculation, this optimizes
2126 * the credit-low indications since the host will actually
2127 * issue smaller messages in the Send path.
2129 if (conn_req->max_rxmsg_sz > max_msg_sz) {
2133 endpoint->cred_dist.cred_per_msg =
2134 conn_req->max_rxmsg_sz / target->tgt_cred_sz;
2136 endpoint->cred_dist.cred_per_msg =
2137 max_msg_sz / target->tgt_cred_sz;
2139 if (!endpoint->cred_dist.cred_per_msg)
2140 endpoint->cred_dist.cred_per_msg = 1;
2142 /* save local connection flags */
2143 endpoint->conn_flags = conn_req->flags;
2147 htc_reclaim_txctrl_buf(target, tx_pkt);
2150 htc_rxpkt_reset(rx_pkt);
2151 reclaim_rx_ctrl_buf(target, rx_pkt);
2157 static void reset_ep_state(struct htc_target *target)
2159 struct htc_endpoint *endpoint;
2162 for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) {
2163 endpoint = &target->endpoint[i];
2164 memset(&endpoint->cred_dist, 0, sizeof(endpoint->cred_dist));
2165 endpoint->svc_id = 0;
2166 endpoint->len_max = 0;
2167 endpoint->max_txq_depth = 0;
2168 memset(&endpoint->ep_st, 0,
2169 sizeof(endpoint->ep_st));
2170 INIT_LIST_HEAD(&endpoint->rx_bufq);
2171 INIT_LIST_HEAD(&endpoint->txq);
2172 endpoint->target = target;
2175 /* reset distribution list */
2176 INIT_LIST_HEAD(&target->cred_dist_list);
2179 int ath6kl_htc_get_rxbuf_num(struct htc_target *target,
2180 enum htc_endpoint_id endpoint)
2184 spin_lock_bh(&target->rx_lock);
2185 num = get_queue_depth(&(target->endpoint[endpoint].rx_bufq));
2186 spin_unlock_bh(&target->rx_lock);
2190 static void htc_setup_msg_bndl(struct htc_target *target)
2192 /* limit what HTC can handle */
2193 target->msg_per_bndl_max = min(HTC_HOST_MAX_MSG_PER_BUNDLE,
2194 target->msg_per_bndl_max);
2196 if (ath6kl_hif_enable_scatter(target->dev->ar)) {
2197 target->msg_per_bndl_max = 0;
2201 /* limit bundle what the device layer can handle */
2202 target->msg_per_bndl_max = min(target->max_scat_entries,
2203 target->msg_per_bndl_max);
2205 ath6kl_dbg(ATH6KL_DBG_TRC,
2206 "htc bundling allowed. max msg per htc bundle: %d\n",
2207 target->msg_per_bndl_max);
2209 /* Max rx bundle size is limited by the max tx bundle size */
2210 target->max_rx_bndl_sz = target->max_xfer_szper_scatreq;
2211 /* Max tx bundle size if limited by the extended mbox address range */
2212 target->max_tx_bndl_sz = min(HIF_MBOX0_EXT_WIDTH,
2213 target->max_xfer_szper_scatreq);
2215 ath6kl_dbg(ATH6KL_DBG_ANY, "max recv: %d max send: %d\n",
2216 target->max_rx_bndl_sz, target->max_tx_bndl_sz);
2218 if (target->max_tx_bndl_sz)
2219 target->tx_bndl_enable = true;
2221 if (target->max_rx_bndl_sz)
2222 target->rx_bndl_enable = true;
2224 if ((target->tgt_cred_sz % target->block_sz) != 0) {
2225 ath6kl_warn("credit size: %d is not block aligned! Disabling send bundling\n",
2226 target->tgt_cred_sz);
2229 * Disallow send bundling since the credit size is
2230 * not aligned to a block size the I/O block
2231 * padding will spill into the next credit buffer
2234 target->tx_bndl_enable = false;
2238 int ath6kl_htc_wait_target(struct htc_target *target)
2240 struct htc_packet *packet = NULL;
2241 struct htc_ready_ext_msg *rdy_msg;
2242 struct htc_service_connect_req connect;
2243 struct htc_service_connect_resp resp;
2246 /* we should be getting 1 control message that the target is ready */
2247 packet = htc_wait_for_ctrl_msg(target);
2252 /* we controlled the buffer creation so it's properly aligned */
2253 rdy_msg = (struct htc_ready_ext_msg *)packet->buf;
2255 if ((le16_to_cpu(rdy_msg->ver2_0_info.msg_id) != HTC_MSG_READY_ID) ||
2256 (packet->act_len < sizeof(struct htc_ready_msg))) {
2258 goto fail_wait_target;
2261 if (!rdy_msg->ver2_0_info.cred_cnt || !rdy_msg->ver2_0_info.cred_sz) {
2263 goto fail_wait_target;
2266 target->tgt_creds = le16_to_cpu(rdy_msg->ver2_0_info.cred_cnt);
2267 target->tgt_cred_sz = le16_to_cpu(rdy_msg->ver2_0_info.cred_sz);
2269 ath6kl_dbg(ATH6KL_DBG_HTC_RECV,
2270 "target ready: credits: %d credit size: %d\n",
2271 target->tgt_creds, target->tgt_cred_sz);
2273 /* check if this is an extended ready message */
2274 if (packet->act_len >= sizeof(struct htc_ready_ext_msg)) {
2275 /* this is an extended message */
2276 target->htc_tgt_ver = rdy_msg->htc_ver;
2277 target->msg_per_bndl_max = rdy_msg->msg_per_htc_bndl;
2280 target->htc_tgt_ver = HTC_VERSION_2P0;
2281 target->msg_per_bndl_max = 0;
2284 ath6kl_dbg(ATH6KL_DBG_TRC, "using htc protocol version : %s (%d)\n",
2285 (target->htc_tgt_ver == HTC_VERSION_2P0) ? "2.0" : ">= 2.1",
2286 target->htc_tgt_ver);
2288 if (target->msg_per_bndl_max > 0)
2289 htc_setup_msg_bndl(target);
2291 /* setup our pseudo HTC control endpoint connection */
2292 memset(&connect, 0, sizeof(connect));
2293 memset(&resp, 0, sizeof(resp));
2294 connect.ep_cb.rx = htc_ctrl_rx;
2295 connect.ep_cb.rx_refill = NULL;
2296 connect.ep_cb.tx_full = NULL;
2297 connect.max_txq_depth = NUM_CONTROL_BUFFERS;
2298 connect.svc_id = HTC_CTRL_RSVD_SVC;
2300 /* connect fake service */
2301 status = ath6kl_htc_conn_service((void *)target, &connect, &resp);
2304 ath6kl_hif_cleanup_scatter(target->dev->ar);
2308 htc_rxpkt_reset(packet);
2309 reclaim_rx_ctrl_buf(target, packet);
2316 * Start HTC, enable interrupts and let the target know
2317 * host has finished setup.
2319 int ath6kl_htc_start(struct htc_target *target)
2321 struct htc_packet *packet;
2324 /* Disable interrupts at the chip level */
2325 ath6kldev_disable_intrs(target->dev);
2327 target->htc_flags = 0;
2328 target->rx_st_flags = 0;
2330 /* Push control receive buffers into htc control endpoint */
2331 while ((packet = htc_get_control_buf(target, false)) != NULL) {
2332 status = htc_add_rxbuf(target, packet);
2337 /* NOTE: the first entry in the distribution list is ENDPOINT_0 */
2338 ath6k_credit_init(target->cred_dist_cntxt, &target->cred_dist_list,
2341 dump_cred_dist_stats(target);
2343 /* Indicate to the target of the setup completion */
2344 status = htc_setup_tx_complete(target);
2349 /* unmask interrupts */
2350 status = ath6kldev_unmask_intrs(target->dev);
2353 ath6kl_htc_stop(target);
2358 /* htc_stop: stop interrupt reception, and flush all queued buffers */
2359 void ath6kl_htc_stop(struct htc_target *target)
2361 spin_lock_bh(&target->htc_lock);
2362 target->htc_flags |= HTC_OP_STATE_STOPPING;
2363 spin_unlock_bh(&target->htc_lock);
2366 * Masking interrupts is a synchronous operation, when this
2367 * function returns all pending HIF I/O has completed, we can
2368 * safely flush the queues.
2370 ath6kldev_mask_intrs(target->dev);
2372 ath6kl_htc_flush_txep_all(target);
2374 ath6kl_htc_flush_rx_buf(target);
2376 reset_ep_state(target);
2379 void *ath6kl_htc_create(struct ath6kl *ar)
2381 struct htc_target *target = NULL;
2382 struct htc_packet *packet;
2383 int status = 0, i = 0;
2384 u32 block_size, ctrl_bufsz;
2386 target = kzalloc(sizeof(*target), GFP_KERNEL);
2388 ath6kl_err("unable to allocate memory\n");
2392 target->dev = kzalloc(sizeof(*target->dev), GFP_KERNEL);
2394 ath6kl_err("unable to allocate memory\n");
2396 goto fail_create_htc;
2399 spin_lock_init(&target->htc_lock);
2400 spin_lock_init(&target->rx_lock);
2401 spin_lock_init(&target->tx_lock);
2403 INIT_LIST_HEAD(&target->free_ctrl_txbuf);
2404 INIT_LIST_HEAD(&target->free_ctrl_rxbuf);
2405 INIT_LIST_HEAD(&target->cred_dist_list);
2407 target->dev->ar = ar;
2408 target->dev->htc_cnxt = target;
2409 target->ep_waiting = ENDPOINT_MAX;
2411 reset_ep_state(target);
2413 status = ath6kldev_setup(target->dev);
2416 goto fail_create_htc;
2418 block_size = ar->mbox_info.block_size;
2420 ctrl_bufsz = (block_size > HTC_MAX_CTRL_MSG_LEN) ?
2421 (block_size + HTC_HDR_LENGTH) :
2422 (HTC_MAX_CTRL_MSG_LEN + HTC_HDR_LENGTH);
2424 for (i = 0; i < NUM_CONTROL_BUFFERS; i++) {
2425 packet = kzalloc(sizeof(*packet), GFP_KERNEL);
2429 packet->buf_start = kzalloc(ctrl_bufsz, GFP_KERNEL);
2430 if (!packet->buf_start) {
2435 packet->buf_len = ctrl_bufsz;
2436 if (i < NUM_CONTROL_RX_BUFFERS) {
2437 packet->act_len = 0;
2438 packet->buf = packet->buf_start;
2439 packet->endpoint = ENDPOINT_0;
2440 list_add_tail(&packet->list, &target->free_ctrl_rxbuf);
2442 list_add_tail(&packet->list, &target->free_ctrl_txbuf);
2446 if (i != NUM_CONTROL_BUFFERS || status) {
2448 ath6kl_htc_cleanup(target);
2456 /* cleanup the HTC instance */
2457 void ath6kl_htc_cleanup(struct htc_target *target)
2459 struct htc_packet *packet, *tmp_packet;
2461 ath6kl_hif_cleanup_scatter(target->dev->ar);
2463 list_for_each_entry_safe(packet, tmp_packet,
2464 &target->free_ctrl_txbuf, list) {
2465 list_del(&packet->list);
2466 kfree(packet->buf_start);
2470 list_for_each_entry_safe(packet, tmp_packet,
2471 &target->free_ctrl_rxbuf, list) {
2472 list_del(&packet->list);
2473 kfree(packet->buf_start);