1 /* 2 * Copyright (c) 2007-2011 Atheros Communications Inc. 3 * 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. 7 * 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. 15 */ 16 17 #include "core.h" 18 #include "debug.h" 19 #include "hif-ops.h" 20 21 #define HTC_PACKET_CONTAINER_ALLOCATION 32 22 #define HTC_CONTROL_BUFFER_SIZE (HTC_MAX_CTRL_MSG_LEN + HTC_HDR_LENGTH) 23 24 static int ath6kl_htc_pipe_tx(struct htc_target *handle, 25 struct htc_packet *packet); 26 static void ath6kl_htc_pipe_cleanup(struct htc_target *handle); 27 28 /* htc pipe tx path */ 29 static inline void restore_tx_packet(struct htc_packet *packet) 30 { 31 if (packet->info.tx.flags & HTC_FLAGS_TX_FIXUP_NETBUF) { 32 skb_pull(packet->skb, sizeof(struct htc_frame_hdr)); 33 packet->info.tx.flags &= ~HTC_FLAGS_TX_FIXUP_NETBUF; 34 } 35 } 36 37 static void do_send_completion(struct htc_endpoint *ep, 38 struct list_head *queue_to_indicate) 39 { 40 struct htc_packet *packet; 41 42 if (list_empty(queue_to_indicate)) { 43 /* nothing to indicate */ 44 return; 45 } 46 47 if (ep->ep_cb.tx_comp_multi != NULL) { 48 ath6kl_dbg(ATH6KL_DBG_HTC, 49 "%s: calling ep %d, send complete multiple callback (%d pkts)\n", 50 __func__, ep->eid, 51 get_queue_depth(queue_to_indicate)); 52 /* 53 * a multiple send complete handler is being used, 54 * pass the queue to the handler 55 */ 56 ep->ep_cb.tx_comp_multi(ep->target, queue_to_indicate); 57 /* 58 * all packets are now owned by the callback, 59 * reset queue to be safe 60 */ 61 INIT_LIST_HEAD(queue_to_indicate); 62 } else { 63 /* using legacy EpTxComplete */ 64 do { 65 packet = list_first_entry(queue_to_indicate, 66 struct htc_packet, list); 67 68 list_del(&packet->list); 69 ath6kl_dbg(ATH6KL_DBG_HTC, 70 "%s: calling ep %d send complete callback on packet 0x%p\n", 71 __func__, ep->eid, packet); 72 ep->ep_cb.tx_complete(ep->target, packet); 73 } while (!list_empty(queue_to_indicate)); 74 } 75 } 76 77 static void send_packet_completion(struct htc_target *target, 78 struct htc_packet *packet) 79 { 80 struct htc_endpoint *ep = &target->endpoint[packet->endpoint]; 81 struct list_head container; 82 83 restore_tx_packet(packet); 84 INIT_LIST_HEAD(&container); 85 list_add_tail(&packet->list, &container); 86 87 /* do completion */ 88 do_send_completion(ep, &container); 89 } 90 91 static void get_htc_packet_credit_based(struct htc_target *target, 92 struct htc_endpoint *ep, 93 struct list_head *queue) 94 { 95 int credits_required; 96 int remainder; 97 u8 send_flags; 98 struct htc_packet *packet; 99 unsigned int transfer_len; 100 101 /* NOTE : the TX lock is held when this function is called */ 102 103 /* loop until we can grab as many packets out of the queue as we can */ 104 while (true) { 105 send_flags = 0; 106 if (list_empty(&ep->txq)) 107 break; 108 109 /* get packet at head, but don't remove it */ 110 packet = list_first_entry(&ep->txq, struct htc_packet, list); 111 112 ath6kl_dbg(ATH6KL_DBG_HTC, 113 "%s: got head packet:0x%p , queue depth: %d\n", 114 __func__, packet, get_queue_depth(&ep->txq)); 115 116 transfer_len = packet->act_len + HTC_HDR_LENGTH; 117 118 if (transfer_len <= target->tgt_cred_sz) { 119 credits_required = 1; 120 } else { 121 /* figure out how many credits this message requires */ 122 credits_required = transfer_len / target->tgt_cred_sz; 123 remainder = transfer_len % target->tgt_cred_sz; 124 125 if (remainder) 126 credits_required++; 127 } 128 129 ath6kl_dbg(ATH6KL_DBG_HTC, "%s: creds required:%d got:%d\n", 130 __func__, credits_required, ep->cred_dist.credits); 131 132 if (ep->eid == ENDPOINT_0) { 133 /* 134 * endpoint 0 is special, it always has a credit and 135 * does not require credit based flow control 136 */ 137 credits_required = 0; 138 139 } else { 140 141 if (ep->cred_dist.credits < credits_required) 142 break; 143 144 ep->cred_dist.credits -= credits_required; 145 ep->ep_st.cred_cosumd += credits_required; 146 147 /* check if we need credits back from the target */ 148 if (ep->cred_dist.credits < 149 ep->cred_dist.cred_per_msg) { 150 /* tell the target we need credits ASAP! */ 151 send_flags |= HTC_FLAGS_NEED_CREDIT_UPDATE; 152 ep->ep_st.cred_low_indicate += 1; 153 ath6kl_dbg(ATH6KL_DBG_HTC, 154 "%s: host needs credits\n", 155 __func__); 156 } 157 } 158 159 /* now we can fully dequeue */ 160 packet = list_first_entry(&ep->txq, struct htc_packet, list); 161 162 list_del(&packet->list); 163 /* save the number of credits this packet consumed */ 164 packet->info.tx.cred_used = credits_required; 165 /* save send flags */ 166 packet->info.tx.flags = send_flags; 167 packet->info.tx.seqno = ep->seqno; 168 ep->seqno++; 169 /* queue this packet into the caller's queue */ 170 list_add_tail(&packet->list, queue); 171 } 172 173 } 174 175 static void get_htc_packet(struct htc_target *target, 176 struct htc_endpoint *ep, 177 struct list_head *queue, int resources) 178 { 179 struct htc_packet *packet; 180 181 /* NOTE : the TX lock is held when this function is called */ 182 183 /* loop until we can grab as many packets out of the queue as we can */ 184 while (resources) { 185 if (list_empty(&ep->txq)) 186 break; 187 188 packet = list_first_entry(&ep->txq, struct htc_packet, list); 189 list_del(&packet->list); 190 191 ath6kl_dbg(ATH6KL_DBG_HTC, 192 "%s: got packet:0x%p , new queue depth: %d\n", 193 __func__, packet, get_queue_depth(&ep->txq)); 194 packet->info.tx.seqno = ep->seqno; 195 packet->info.tx.flags = 0; 196 packet->info.tx.cred_used = 0; 197 ep->seqno++; 198 199 /* queue this packet into the caller's queue */ 200 list_add_tail(&packet->list, queue); 201 resources--; 202 } 203 } 204 205 static int htc_issue_packets(struct htc_target *target, 206 struct htc_endpoint *ep, 207 struct list_head *pkt_queue) 208 { 209 int status = 0; 210 u16 payload_len; 211 struct sk_buff *skb; 212 struct htc_frame_hdr *htc_hdr; 213 struct htc_packet *packet; 214 215 ath6kl_dbg(ATH6KL_DBG_HTC, 216 "%s: queue: 0x%p, pkts %d\n", __func__, 217 pkt_queue, get_queue_depth(pkt_queue)); 218 219 while (!list_empty(pkt_queue)) { 220 packet = list_first_entry(pkt_queue, struct htc_packet, list); 221 list_del(&packet->list); 222 223 skb = packet->skb; 224 if (!skb) { 225 WARN_ON_ONCE(1); 226 status = -EINVAL; 227 break; 228 } 229 230 payload_len = packet->act_len; 231 232 /* setup HTC frame header */ 233 htc_hdr = (struct htc_frame_hdr *) skb_push(skb, 234 sizeof(*htc_hdr)); 235 if (!htc_hdr) { 236 WARN_ON_ONCE(1); 237 status = -EINVAL; 238 break; 239 } 240 241 packet->info.tx.flags |= HTC_FLAGS_TX_FIXUP_NETBUF; 242 243 /* Endianess? */ 244 put_unaligned((u16) payload_len, &htc_hdr->payld_len); 245 htc_hdr->flags = packet->info.tx.flags; 246 htc_hdr->eid = (u8) packet->endpoint; 247 htc_hdr->ctrl[0] = 0; 248 htc_hdr->ctrl[1] = (u8) packet->info.tx.seqno; 249 250 spin_lock_bh(&target->tx_lock); 251 252 /* store in look up queue to match completions */ 253 list_add_tail(&packet->list, &ep->pipe.tx_lookup_queue); 254 ep->ep_st.tx_issued += 1; 255 spin_unlock_bh(&target->tx_lock); 256 257 status = ath6kl_hif_pipe_send(target->dev->ar, 258 ep->pipe.pipeid_ul, NULL, skb); 259 260 if (status != 0) { 261 if (status != -ENOMEM) { 262 /* TODO: if more than 1 endpoint maps to the 263 * same PipeID, it is possible to run out of 264 * resources in the HIF layer. 265 * Don't emit the error 266 */ 267 ath6kl_dbg(ATH6KL_DBG_HTC, 268 "%s: failed status:%d\n", 269 __func__, status); 270 } 271 spin_lock_bh(&target->tx_lock); 272 list_del(&packet->list); 273 274 /* reclaim credits */ 275 ep->cred_dist.credits += packet->info.tx.cred_used; 276 spin_unlock_bh(&target->tx_lock); 277 278 /* put it back into the callers queue */ 279 list_add(&packet->list, pkt_queue); 280 break; 281 } 282 283 } 284 285 if (status != 0) { 286 while (!list_empty(pkt_queue)) { 287 if (status != -ENOMEM) { 288 ath6kl_dbg(ATH6KL_DBG_HTC, 289 "%s: failed pkt:0x%p status:%d\n", 290 __func__, packet, status); 291 } 292 293 packet = list_first_entry(pkt_queue, 294 struct htc_packet, list); 295 list_del(&packet->list); 296 packet->status = status; 297 send_packet_completion(target, packet); 298 } 299 } 300 301 return status; 302 } 303 304 static enum htc_send_queue_result htc_try_send(struct htc_target *target, 305 struct htc_endpoint *ep, 306 struct list_head *txq) 307 { 308 struct list_head send_queue; /* temp queue to hold packets */ 309 struct htc_packet *packet, *tmp_pkt; 310 struct ath6kl *ar = target->dev->ar; 311 enum htc_send_full_action action; 312 int tx_resources, overflow, txqueue_depth, i, good_pkts; 313 u8 pipeid; 314 315 ath6kl_dbg(ATH6KL_DBG_HTC, "%s: (queue:0x%p depth:%d)\n", 316 __func__, txq, 317 (txq == NULL) ? 0 : get_queue_depth(txq)); 318 319 /* init the local send queue */ 320 INIT_LIST_HEAD(&send_queue); 321 322 /* 323 * txq equals to NULL means 324 * caller didn't provide a queue, just wants us to 325 * check queues and send 326 */ 327 if (txq != NULL) { 328 if (list_empty(txq)) { 329 /* empty queue */ 330 return HTC_SEND_QUEUE_DROP; 331 } 332 333 spin_lock_bh(&target->tx_lock); 334 txqueue_depth = get_queue_depth(&ep->txq); 335 spin_unlock_bh(&target->tx_lock); 336 337 if (txqueue_depth >= ep->max_txq_depth) { 338 /* we've already overflowed */ 339 overflow = get_queue_depth(txq); 340 } else { 341 /* get how much we will overflow by */ 342 overflow = txqueue_depth; 343 overflow += get_queue_depth(txq); 344 /* get how much we will overflow the TX queue by */ 345 overflow -= ep->max_txq_depth; 346 } 347 348 /* if overflow is negative or zero, we are okay */ 349 if (overflow > 0) { 350 ath6kl_dbg(ATH6KL_DBG_HTC, 351 "%s: Endpoint %d, TX queue will overflow :%d, Tx Depth:%d, Max:%d\n", 352 __func__, ep->eid, overflow, txqueue_depth, 353 ep->max_txq_depth); 354 } 355 if ((overflow <= 0) || 356 (ep->ep_cb.tx_full == NULL)) { 357 /* 358 * all packets will fit or caller did not provide send 359 * full indication handler -- just move all of them 360 * to the local send_queue object 361 */ 362 list_splice_tail_init(txq, &send_queue); 363 } else { 364 good_pkts = get_queue_depth(txq) - overflow; 365 if (good_pkts < 0) { 366 WARN_ON_ONCE(1); 367 return HTC_SEND_QUEUE_DROP; 368 } 369 370 /* we have overflowed, and a callback is provided */ 371 /* dequeue all non-overflow packets to the sendqueue */ 372 for (i = 0; i < good_pkts; i++) { 373 /* pop off caller's queue */ 374 packet = list_first_entry(txq, 375 struct htc_packet, 376 list); 377 list_del(&packet->list); 378 /* insert into local queue */ 379 list_add_tail(&packet->list, &send_queue); 380 } 381 382 /* 383 * the caller's queue has all the packets that won't fit 384 * walk through the caller's queue and indicate each to 385 * the send full handler 386 */ 387 list_for_each_entry_safe(packet, tmp_pkt, 388 txq, list) { 389 390 ath6kl_dbg(ATH6KL_DBG_HTC, 391 "%s: Indicat overflowed TX pkts: %p\n", 392 __func__, packet); 393 action = ep->ep_cb.tx_full(ep->target, packet); 394 if (action == HTC_SEND_FULL_DROP) { 395 /* callback wants the packet dropped */ 396 ep->ep_st.tx_dropped += 1; 397 398 /* leave this one in the caller's queue 399 * for cleanup */ 400 } else { 401 /* callback wants to keep this packet, 402 * remove from caller's queue */ 403 list_del(&packet->list); 404 /* put it in the send queue */ 405 list_add_tail(&packet->list, 406 &send_queue); 407 } 408 409 } 410 411 if (list_empty(&send_queue)) { 412 /* no packets made it in, caller will cleanup */ 413 return HTC_SEND_QUEUE_DROP; 414 } 415 } 416 } 417 418 if (!ep->pipe.tx_credit_flow_enabled) { 419 tx_resources = 420 ath6kl_hif_pipe_get_free_queue_number(ar, 421 ep->pipe.pipeid_ul); 422 } else { 423 tx_resources = 0; 424 } 425 426 spin_lock_bh(&target->tx_lock); 427 if (!list_empty(&send_queue)) { 428 /* transfer packets to tail */ 429 list_splice_tail_init(&send_queue, &ep->txq); 430 if (!list_empty(&send_queue)) { 431 WARN_ON_ONCE(1); 432 spin_unlock_bh(&target->tx_lock); 433 return HTC_SEND_QUEUE_DROP; 434 } 435 INIT_LIST_HEAD(&send_queue); 436 } 437 438 /* increment tx processing count on entry */ 439 ep->tx_proc_cnt++; 440 441 if (ep->tx_proc_cnt > 1) { 442 /* 443 * Another thread or task is draining the TX queues on this 444 * endpoint that thread will reset the tx processing count 445 * when the queue is drained. 446 */ 447 ep->tx_proc_cnt--; 448 spin_unlock_bh(&target->tx_lock); 449 return HTC_SEND_QUEUE_OK; 450 } 451 452 /***** beyond this point only 1 thread may enter ******/ 453 454 /* 455 * Now drain the endpoint TX queue for transmission as long as we have 456 * enough transmit resources. 457 */ 458 while (true) { 459 460 if (get_queue_depth(&ep->txq) == 0) 461 break; 462 463 if (ep->pipe.tx_credit_flow_enabled) { 464 /* 465 * Credit based mechanism provides flow control 466 * based on target transmit resource availability, 467 * we assume that the HIF layer will always have 468 * bus resources greater than target transmit 469 * resources. 470 */ 471 get_htc_packet_credit_based(target, ep, &send_queue); 472 } else { 473 /* 474 * Get all packets for this endpoint that we can 475 * for this pass. 476 */ 477 get_htc_packet(target, ep, &send_queue, tx_resources); 478 } 479 480 if (get_queue_depth(&send_queue) == 0) { 481 /* 482 * Didn't get packets due to out of resources or TX 483 * queue was drained. 484 */ 485 break; 486 } 487 488 spin_unlock_bh(&target->tx_lock); 489 490 /* send what we can */ 491 htc_issue_packets(target, ep, &send_queue); 492 493 if (!ep->pipe.tx_credit_flow_enabled) { 494 pipeid = ep->pipe.pipeid_ul; 495 tx_resources = 496 ath6kl_hif_pipe_get_free_queue_number(ar, pipeid); 497 } 498 499 spin_lock_bh(&target->tx_lock); 500 501 } 502 /* done with this endpoint, we can clear the count */ 503 ep->tx_proc_cnt = 0; 504 spin_unlock_bh(&target->tx_lock); 505 506 return HTC_SEND_QUEUE_OK; 507 } 508 509 /* htc control packet manipulation */ 510 static void destroy_htc_txctrl_packet(struct htc_packet *packet) 511 { 512 struct sk_buff *skb; 513 skb = packet->skb; 514 if (skb != NULL) 515 dev_kfree_skb(skb); 516 517 kfree(packet); 518 } 519 520 static struct htc_packet *build_htc_txctrl_packet(void) 521 { 522 struct htc_packet *packet = NULL; 523 struct sk_buff *skb; 524 525 packet = kzalloc(sizeof(struct htc_packet), GFP_KERNEL); 526 if (packet == NULL) 527 return NULL; 528 529 skb = __dev_alloc_skb(HTC_CONTROL_BUFFER_SIZE, GFP_KERNEL); 530 531 if (skb == NULL) { 532 kfree(packet); 533 return NULL; 534 } 535 packet->skb = skb; 536 537 return packet; 538 } 539 540 static void htc_free_txctrl_packet(struct htc_target *target, 541 struct htc_packet *packet) 542 { 543 destroy_htc_txctrl_packet(packet); 544 } 545 546 static struct htc_packet *htc_alloc_txctrl_packet(struct htc_target *target) 547 { 548 return build_htc_txctrl_packet(); 549 } 550 551 static void htc_txctrl_complete(struct htc_target *target, 552 struct htc_packet *packet) 553 { 554 htc_free_txctrl_packet(target, packet); 555 } 556 557 #define MAX_MESSAGE_SIZE 1536 558 559 static int htc_setup_target_buffer_assignments(struct htc_target *target) 560 { 561 int status, credits, credit_per_maxmsg, i; 562 struct htc_pipe_txcredit_alloc *entry; 563 unsigned int hif_usbaudioclass = 0; 564 565 credit_per_maxmsg = MAX_MESSAGE_SIZE / target->tgt_cred_sz; 566 if (MAX_MESSAGE_SIZE % target->tgt_cred_sz) 567 credit_per_maxmsg++; 568 569 /* TODO, this should be configured by the caller! */ 570 571 credits = target->tgt_creds; 572 entry = &target->pipe.txcredit_alloc[0]; 573 574 status = -ENOMEM; 575 576 /* FIXME: hif_usbaudioclass is always zero */ 577 if (hif_usbaudioclass) { 578 ath6kl_dbg(ATH6KL_DBG_HTC, 579 "%s: For USB Audio Class- Total:%d\n", 580 __func__, credits); 581 entry++; 582 entry++; 583 /* Setup VO Service To have Max Credits */ 584 entry->service_id = WMI_DATA_VO_SVC; 585 entry->credit_alloc = (credits - 6); 586 if (entry->credit_alloc == 0) 587 entry->credit_alloc++; 588 589 credits -= (int) entry->credit_alloc; 590 if (credits <= 0) 591 return status; 592 593 entry++; 594 entry->service_id = WMI_CONTROL_SVC; 595 entry->credit_alloc = credit_per_maxmsg; 596 credits -= (int) entry->credit_alloc; 597 if (credits <= 0) 598 return status; 599 600 /* leftovers go to best effort */ 601 entry++; 602 entry++; 603 entry->service_id = WMI_DATA_BE_SVC; 604 entry->credit_alloc = (u8) credits; 605 status = 0; 606 } else { 607 entry++; 608 entry->service_id = WMI_DATA_VI_SVC; 609 entry->credit_alloc = credits / 4; 610 if (entry->credit_alloc == 0) 611 entry->credit_alloc++; 612 613 credits -= (int) entry->credit_alloc; 614 if (credits <= 0) 615 return status; 616 617 entry++; 618 entry->service_id = WMI_DATA_VO_SVC; 619 entry->credit_alloc = credits / 4; 620 if (entry->credit_alloc == 0) 621 entry->credit_alloc++; 622 623 credits -= (int) entry->credit_alloc; 624 if (credits <= 0) 625 return status; 626 627 entry++; 628 entry->service_id = WMI_CONTROL_SVC; 629 entry->credit_alloc = credit_per_maxmsg; 630 credits -= (int) entry->credit_alloc; 631 if (credits <= 0) 632 return status; 633 634 entry++; 635 entry->service_id = WMI_DATA_BK_SVC; 636 entry->credit_alloc = credit_per_maxmsg; 637 credits -= (int) entry->credit_alloc; 638 if (credits <= 0) 639 return status; 640 641 /* leftovers go to best effort */ 642 entry++; 643 entry->service_id = WMI_DATA_BE_SVC; 644 entry->credit_alloc = (u8) credits; 645 status = 0; 646 } 647 648 if (status == 0) { 649 for (i = 0; i < ENDPOINT_MAX; i++) { 650 if (target->pipe.txcredit_alloc[i].service_id != 0) { 651 ath6kl_dbg(ATH6KL_DBG_HTC, 652 "HTC Service Index : %d TX : 0x%2.2X : alloc:%d\n", 653 i, 654 target->pipe.txcredit_alloc[i]. 655 service_id, 656 target->pipe.txcredit_alloc[i]. 657 credit_alloc); 658 } 659 } 660 } 661 return status; 662 } 663 664 /* process credit reports and call distribution function */ 665 static void htc_process_credit_report(struct htc_target *target, 666 struct htc_credit_report *rpt, 667 int num_entries, 668 enum htc_endpoint_id from_ep) 669 { 670 int total_credits = 0, i; 671 struct htc_endpoint *ep; 672 673 /* lock out TX while we update credits */ 674 spin_lock_bh(&target->tx_lock); 675 676 for (i = 0; i < num_entries; i++, rpt++) { 677 if (rpt->eid >= ENDPOINT_MAX) { 678 WARN_ON_ONCE(1); 679 spin_unlock_bh(&target->tx_lock); 680 return; 681 } 682 683 ep = &target->endpoint[rpt->eid]; 684 ep->cred_dist.credits += rpt->credits; 685 686 if (ep->cred_dist.credits && get_queue_depth(&ep->txq)) { 687 spin_unlock_bh(&target->tx_lock); 688 htc_try_send(target, ep, NULL); 689 spin_lock_bh(&target->tx_lock); 690 } 691 692 total_credits += rpt->credits; 693 } 694 ath6kl_dbg(ATH6KL_DBG_HTC, 695 "Report indicated %d credits to distribute\n", 696 total_credits); 697 698 spin_unlock_bh(&target->tx_lock); 699 } 700 701 /* flush endpoint TX queue */ 702 static void htc_flush_tx_endpoint(struct htc_target *target, 703 struct htc_endpoint *ep, u16 tag) 704 { 705 struct htc_packet *packet; 706 707 spin_lock_bh(&target->tx_lock); 708 while (get_queue_depth(&ep->txq)) { 709 packet = list_first_entry(&ep->txq, struct htc_packet, list); 710 list_del(&packet->list); 711 packet->status = 0; 712 send_packet_completion(target, packet); 713 } 714 spin_unlock_bh(&target->tx_lock); 715 } 716 717 /* 718 * In the adapted HIF layer, struct sk_buff * are passed between HIF and HTC, 719 * since upper layers expects struct htc_packet containers we use the completed 720 * skb and lookup it's corresponding HTC packet buffer from a lookup list. 721 * This is extra overhead that can be fixed by re-aligning HIF interfaces with 722 * HTC. 723 */ 724 static struct htc_packet *htc_lookup_tx_packet(struct htc_target *target, 725 struct htc_endpoint *ep, 726 struct sk_buff *skb) 727 { 728 struct htc_packet *packet, *tmp_pkt, *found_packet = NULL; 729 730 spin_lock_bh(&target->tx_lock); 731 732 /* 733 * interate from the front of tx lookup queue 734 * this lookup should be fast since lower layers completes in-order and 735 * so the completed packet should be at the head of the list generally 736 */ 737 list_for_each_entry_safe(packet, tmp_pkt, &ep->pipe.tx_lookup_queue, 738 list) { 739 /* check for removal */ 740 if (skb == packet->skb) { 741 /* found it */ 742 list_del(&packet->list); 743 found_packet = packet; 744 break; 745 } 746 } 747 748 spin_unlock_bh(&target->tx_lock); 749 750 return found_packet; 751 } 752 753 static int ath6kl_htc_pipe_tx_complete(struct ath6kl *ar, struct sk_buff *skb) 754 { 755 struct htc_target *target = ar->htc_target; 756 struct htc_frame_hdr *htc_hdr; 757 struct htc_endpoint *ep; 758 struct htc_packet *packet; 759 u8 ep_id, *netdata; 760 u32 netlen; 761 762 netdata = skb->data; 763 netlen = skb->len; 764 765 htc_hdr = (struct htc_frame_hdr *) netdata; 766 767 ep_id = htc_hdr->eid; 768 ep = &target->endpoint[ep_id]; 769 770 packet = htc_lookup_tx_packet(target, ep, skb); 771 if (packet == NULL) { 772 /* may have already been flushed and freed */ 773 ath6kl_err("HTC TX lookup failed!\n"); 774 } else { 775 /* will be giving this buffer back to upper layers */ 776 packet->status = 0; 777 send_packet_completion(target, packet); 778 } 779 skb = NULL; 780 781 if (!ep->pipe.tx_credit_flow_enabled) { 782 /* 783 * note: when using TX credit flow, the re-checking of queues 784 * happens when credits flow back from the target. in the 785 * non-TX credit case, we recheck after the packet completes 786 */ 787 htc_try_send(target, ep, NULL); 788 } 789 790 return 0; 791 } 792 793 static int htc_send_packets_multiple(struct htc_target *target, 794 struct list_head *pkt_queue) 795 { 796 struct htc_endpoint *ep; 797 struct htc_packet *packet, *tmp_pkt; 798 799 if (list_empty(pkt_queue)) 800 return -EINVAL; 801 802 /* get first packet to find out which ep the packets will go into */ 803 packet = list_first_entry(pkt_queue, struct htc_packet, list); 804 805 if (packet->endpoint >= ENDPOINT_MAX) { 806 WARN_ON_ONCE(1); 807 return -EINVAL; 808 } 809 ep = &target->endpoint[packet->endpoint]; 810 811 htc_try_send(target, ep, pkt_queue); 812 813 /* do completion on any packets that couldn't get in */ 814 if (!list_empty(pkt_queue)) { 815 list_for_each_entry_safe(packet, tmp_pkt, pkt_queue, list) { 816 packet->status = -ENOMEM; 817 } 818 819 do_send_completion(ep, pkt_queue); 820 } 821 822 return 0; 823 } 824 825 /* htc pipe rx path */ 826 static struct htc_packet *alloc_htc_packet_container(struct htc_target *target) 827 { 828 struct htc_packet *packet; 829 spin_lock_bh(&target->rx_lock); 830 831 if (target->pipe.htc_packet_pool == NULL) { 832 spin_unlock_bh(&target->rx_lock); 833 return NULL; 834 } 835 836 packet = target->pipe.htc_packet_pool; 837 target->pipe.htc_packet_pool = (struct htc_packet *) packet->list.next; 838 839 spin_unlock_bh(&target->rx_lock); 840 841 packet->list.next = NULL; 842 return packet; 843 } 844 845 static void free_htc_packet_container(struct htc_target *target, 846 struct htc_packet *packet) 847 { 848 struct list_head *lh; 849 850 spin_lock_bh(&target->rx_lock); 851 852 if (target->pipe.htc_packet_pool == NULL) { 853 target->pipe.htc_packet_pool = packet; 854 packet->list.next = NULL; 855 } else { 856 lh = (struct list_head *) target->pipe.htc_packet_pool; 857 packet->list.next = lh; 858 target->pipe.htc_packet_pool = packet; 859 } 860 861 spin_unlock_bh(&target->rx_lock); 862 } 863 864 static int htc_process_trailer(struct htc_target *target, u8 *buffer, 865 int len, enum htc_endpoint_id from_ep) 866 { 867 struct htc_credit_report *report; 868 struct htc_record_hdr *record; 869 u8 *record_buf, *orig_buf; 870 int orig_len, status; 871 872 orig_buf = buffer; 873 orig_len = len; 874 status = 0; 875 876 while (len > 0) { 877 if (len < sizeof(struct htc_record_hdr)) { 878 status = -EINVAL; 879 break; 880 } 881 882 /* these are byte aligned structs */ 883 record = (struct htc_record_hdr *) buffer; 884 len -= sizeof(struct htc_record_hdr); 885 buffer += sizeof(struct htc_record_hdr); 886 887 if (record->len > len) { 888 /* no room left in buffer for record */ 889 ath6kl_dbg(ATH6KL_DBG_HTC, 890 "invalid length: %d (id:%d) buffer has: %d bytes left\n", 891 record->len, record->rec_id, len); 892 status = -EINVAL; 893 break; 894 } 895 896 /* start of record follows the header */ 897 record_buf = buffer; 898 899 switch (record->rec_id) { 900 case HTC_RECORD_CREDITS: 901 if (record->len < sizeof(struct htc_credit_report)) { 902 WARN_ON_ONCE(1); 903 return -EINVAL; 904 } 905 906 report = (struct htc_credit_report *) record_buf; 907 htc_process_credit_report(target, report, 908 record->len / sizeof(*report), 909 from_ep); 910 break; 911 default: 912 ath6kl_dbg(ATH6KL_DBG_HTC, 913 "unhandled record: id:%d length:%d\n", 914 record->rec_id, record->len); 915 break; 916 } 917 918 if (status != 0) 919 break; 920 921 /* advance buffer past this record for next time around */ 922 buffer += record->len; 923 len -= record->len; 924 } 925 926 return status; 927 } 928 929 static void do_recv_completion(struct htc_endpoint *ep, 930 struct list_head *queue_to_indicate) 931 { 932 struct htc_packet *packet; 933 934 if (list_empty(queue_to_indicate)) { 935 /* nothing to indicate */ 936 return; 937 } 938 939 /* using legacy EpRecv */ 940 while (!list_empty(queue_to_indicate)) { 941 packet = list_first_entry(queue_to_indicate, 942 struct htc_packet, list); 943 list_del(&packet->list); 944 ep->ep_cb.rx(ep->target, packet); 945 } 946 947 return; 948 } 949 950 static void recv_packet_completion(struct htc_target *target, 951 struct htc_endpoint *ep, 952 struct htc_packet *packet) 953 { 954 struct list_head container; 955 INIT_LIST_HEAD(&container); 956 list_add_tail(&packet->list, &container); 957 958 /* do completion */ 959 do_recv_completion(ep, &container); 960 } 961 962 static int ath6kl_htc_pipe_rx_complete(struct ath6kl *ar, struct sk_buff *skb, 963 u8 pipeid) 964 { 965 struct htc_target *target = ar->htc_target; 966 u8 *netdata, *trailer, hdr_info; 967 struct htc_frame_hdr *htc_hdr; 968 u32 netlen, trailerlen = 0; 969 struct htc_packet *packet; 970 struct htc_endpoint *ep; 971 u16 payload_len; 972 int status = 0; 973 974 netdata = skb->data; 975 netlen = skb->len; 976 977 htc_hdr = (struct htc_frame_hdr *) netdata; 978 979 ep = &target->endpoint[htc_hdr->eid]; 980 981 if (htc_hdr->eid >= ENDPOINT_MAX) { 982 ath6kl_dbg(ATH6KL_DBG_HTC, 983 "HTC Rx: invalid EndpointID=%d\n", 984 htc_hdr->eid); 985 status = -EINVAL; 986 goto free_skb; 987 } 988 989 payload_len = le16_to_cpu(get_unaligned(&htc_hdr->payld_len)); 990 991 if (netlen < (payload_len + HTC_HDR_LENGTH)) { 992 ath6kl_dbg(ATH6KL_DBG_HTC, 993 "HTC Rx: insufficient length, got:%d expected =%u\n", 994 netlen, payload_len + HTC_HDR_LENGTH); 995 status = -EINVAL; 996 goto free_skb; 997 } 998 999 /* get flags to check for trailer */ 1000 hdr_info = htc_hdr->flags; 1001 if (hdr_info & HTC_FLG_RX_TRAILER) { 1002 /* extract the trailer length */ 1003 hdr_info = htc_hdr->ctrl[0]; 1004 if ((hdr_info < sizeof(struct htc_record_hdr)) || 1005 (hdr_info > payload_len)) { 1006 ath6kl_dbg(ATH6KL_DBG_HTC, 1007 "invalid header: payloadlen should be %d, CB[0]: %d\n", 1008 payload_len, hdr_info); 1009 status = -EINVAL; 1010 goto free_skb; 1011 } 1012 1013 trailerlen = hdr_info; 1014 /* process trailer after hdr/apps payload */ 1015 trailer = (u8 *) htc_hdr + HTC_HDR_LENGTH + 1016 payload_len - hdr_info; 1017 status = htc_process_trailer(target, trailer, hdr_info, 1018 htc_hdr->eid); 1019 if (status != 0) 1020 goto free_skb; 1021 } 1022 1023 if (((int) payload_len - (int) trailerlen) <= 0) { 1024 /* zero length packet with trailer, just drop these */ 1025 goto free_skb; 1026 } 1027 1028 if (htc_hdr->eid == ENDPOINT_0) { 1029 /* handle HTC control message */ 1030 if (target->htc_flags & HTC_OP_STATE_SETUP_COMPLETE) { 1031 /* 1032 * fatal: target should not send unsolicited 1033 * messageson the endpoint 0 1034 */ 1035 ath6kl_dbg(ATH6KL_DBG_HTC, 1036 "HTC ignores Rx Ctrl after setup complete\n"); 1037 status = -EINVAL; 1038 goto free_skb; 1039 } 1040 1041 /* remove HTC header */ 1042 skb_pull(skb, HTC_HDR_LENGTH); 1043 1044 netdata = skb->data; 1045 netlen = skb->len; 1046 1047 spin_lock_bh(&target->rx_lock); 1048 1049 target->pipe.ctrl_response_valid = true; 1050 target->pipe.ctrl_response_len = min_t(int, netlen, 1051 HTC_MAX_CTRL_MSG_LEN); 1052 memcpy(target->pipe.ctrl_response_buf, netdata, 1053 target->pipe.ctrl_response_len); 1054 1055 spin_unlock_bh(&target->rx_lock); 1056 1057 dev_kfree_skb(skb); 1058 skb = NULL; 1059 goto free_skb; 1060 } 1061 1062 /* 1063 * TODO: the message based HIF architecture allocates net bufs 1064 * for recv packets since it bridges that HIF to upper layers, 1065 * which expects HTC packets, we form the packets here 1066 */ 1067 packet = alloc_htc_packet_container(target); 1068 if (packet == NULL) { 1069 status = -ENOMEM; 1070 goto free_skb; 1071 } 1072 1073 packet->status = 0; 1074 packet->endpoint = htc_hdr->eid; 1075 packet->pkt_cntxt = skb; 1076 1077 /* TODO: for backwards compatibility */ 1078 packet->buf = skb_push(skb, 0) + HTC_HDR_LENGTH; 1079 packet->act_len = netlen - HTC_HDR_LENGTH - trailerlen; 1080 1081 /* 1082 * TODO: this is a hack because the driver layer will set the 1083 * actual len of the skb again which will just double the len 1084 */ 1085 skb_trim(skb, 0); 1086 1087 recv_packet_completion(target, ep, packet); 1088 1089 /* recover the packet container */ 1090 free_htc_packet_container(target, packet); 1091 skb = NULL; 1092 1093 free_skb: 1094 if (skb != NULL) 1095 dev_kfree_skb(skb); 1096 1097 return status; 1098 1099 } 1100 1101 static void htc_flush_rx_queue(struct htc_target *target, 1102 struct htc_endpoint *ep) 1103 { 1104 struct list_head container; 1105 struct htc_packet *packet; 1106 1107 spin_lock_bh(&target->rx_lock); 1108 1109 while (1) { 1110 if (list_empty(&ep->rx_bufq)) 1111 break; 1112 1113 packet = list_first_entry(&ep->rx_bufq, 1114 struct htc_packet, list); 1115 list_del(&packet->list); 1116 1117 spin_unlock_bh(&target->rx_lock); 1118 packet->status = -ECANCELED; 1119 packet->act_len = 0; 1120 1121 ath6kl_dbg(ATH6KL_DBG_HTC, 1122 "Flushing RX packet:0x%p, length:%d, ep:%d\n", 1123 packet, packet->buf_len, 1124 packet->endpoint); 1125 1126 INIT_LIST_HEAD(&container); 1127 list_add_tail(&packet->list, &container); 1128 1129 /* give the packet back */ 1130 do_recv_completion(ep, &container); 1131 spin_lock_bh(&target->rx_lock); 1132 } 1133 1134 spin_unlock_bh(&target->rx_lock); 1135 } 1136 1137 /* polling routine to wait for a control packet to be received */ 1138 static int htc_wait_recv_ctrl_message(struct htc_target *target) 1139 { 1140 int count = HTC_TARGET_RESPONSE_POLL_COUNT; 1141 1142 while (count > 0) { 1143 spin_lock_bh(&target->rx_lock); 1144 1145 if (target->pipe.ctrl_response_valid) { 1146 target->pipe.ctrl_response_valid = false; 1147 spin_unlock_bh(&target->rx_lock); 1148 break; 1149 } 1150 1151 spin_unlock_bh(&target->rx_lock); 1152 1153 count--; 1154 1155 msleep_interruptible(HTC_TARGET_RESPONSE_POLL_WAIT); 1156 } 1157 1158 if (count <= 0) { 1159 ath6kl_dbg(ATH6KL_DBG_HTC, "%s: Timeout!\n", __func__); 1160 return -ECOMM; 1161 } 1162 1163 return 0; 1164 } 1165 1166 static void htc_rxctrl_complete(struct htc_target *context, 1167 struct htc_packet *packet) 1168 { 1169 /* TODO, can't really receive HTC control messages yet.... */ 1170 ath6kl_dbg(ATH6KL_DBG_HTC, "%s: invalid call function\n", __func__); 1171 } 1172 1173 /* htc pipe initialization */ 1174 static void reset_endpoint_states(struct htc_target *target) 1175 { 1176 struct htc_endpoint *ep; 1177 int i; 1178 1179 for (i = ENDPOINT_0; i < ENDPOINT_MAX; i++) { 1180 ep = &target->endpoint[i]; 1181 ep->svc_id = 0; 1182 ep->len_max = 0; 1183 ep->max_txq_depth = 0; 1184 ep->eid = i; 1185 INIT_LIST_HEAD(&ep->txq); 1186 INIT_LIST_HEAD(&ep->pipe.tx_lookup_queue); 1187 INIT_LIST_HEAD(&ep->rx_bufq); 1188 ep->target = target; 1189 ep->pipe.tx_credit_flow_enabled = (bool) 1; /* FIXME */ 1190 } 1191 } 1192 1193 /* start HTC, this is called after all services are connected */ 1194 static int htc_config_target_hif_pipe(struct htc_target *target) 1195 { 1196 return 0; 1197 } 1198 1199 /* htc service functions */ 1200 static u8 htc_get_credit_alloc(struct htc_target *target, u16 service_id) 1201 { 1202 u8 allocation = 0; 1203 int i; 1204 1205 for (i = 0; i < ENDPOINT_MAX; i++) { 1206 if (target->pipe.txcredit_alloc[i].service_id == service_id) 1207 allocation = 1208 target->pipe.txcredit_alloc[i].credit_alloc; 1209 } 1210 1211 if (allocation == 0) { 1212 ath6kl_dbg(ATH6KL_DBG_HTC, 1213 "HTC Service TX : 0x%2.2X : allocation is zero!\n", 1214 service_id); 1215 } 1216 1217 return allocation; 1218 } 1219 1220 static int ath6kl_htc_pipe_conn_service(struct htc_target *target, 1221 struct htc_service_connect_req *conn_req, 1222 struct htc_service_connect_resp *conn_resp) 1223 { 1224 struct ath6kl *ar = target->dev->ar; 1225 struct htc_packet *packet = NULL; 1226 struct htc_conn_service_resp *resp_msg; 1227 struct htc_conn_service_msg *conn_msg; 1228 enum htc_endpoint_id assigned_epid = ENDPOINT_MAX; 1229 bool disable_credit_flowctrl = false; 1230 unsigned int max_msg_size = 0; 1231 struct htc_endpoint *ep; 1232 int length, status = 0; 1233 struct sk_buff *skb; 1234 u8 tx_alloc; 1235 u16 flags; 1236 1237 if (conn_req->svc_id == 0) { 1238 WARN_ON_ONCE(1); 1239 status = -EINVAL; 1240 goto free_packet; 1241 } 1242 1243 if (conn_req->svc_id == HTC_CTRL_RSVD_SVC) { 1244 /* special case for pseudo control service */ 1245 assigned_epid = ENDPOINT_0; 1246 max_msg_size = HTC_MAX_CTRL_MSG_LEN; 1247 tx_alloc = 0; 1248 1249 } else { 1250 1251 tx_alloc = htc_get_credit_alloc(target, conn_req->svc_id); 1252 if (tx_alloc == 0) { 1253 status = -ENOMEM; 1254 goto free_packet; 1255 } 1256 1257 /* allocate a packet to send to the target */ 1258 packet = htc_alloc_txctrl_packet(target); 1259 1260 if (packet == NULL) { 1261 WARN_ON_ONCE(1); 1262 status = -ENOMEM; 1263 goto free_packet; 1264 } 1265 1266 skb = packet->skb; 1267 length = sizeof(struct htc_conn_service_msg); 1268 1269 /* assemble connect service message */ 1270 conn_msg = (struct htc_conn_service_msg *) skb_put(skb, 1271 length); 1272 if (conn_msg == NULL) { 1273 WARN_ON_ONCE(1); 1274 status = -EINVAL; 1275 goto free_packet; 1276 } 1277 1278 memset(conn_msg, 0, 1279 sizeof(struct htc_conn_service_msg)); 1280 conn_msg->msg_id = cpu_to_le16(HTC_MSG_CONN_SVC_ID); 1281 conn_msg->svc_id = cpu_to_le16(conn_req->svc_id); 1282 conn_msg->conn_flags = cpu_to_le16(conn_req->conn_flags & 1283 ~HTC_CONN_FLGS_SET_RECV_ALLOC_MASK); 1284 1285 /* tell target desired recv alloc for this ep */ 1286 flags = tx_alloc << HTC_CONN_FLGS_SET_RECV_ALLOC_SHIFT; 1287 conn_msg->conn_flags |= cpu_to_le16(flags); 1288 1289 if (conn_req->conn_flags & 1290 HTC_CONN_FLGS_DISABLE_CRED_FLOW_CTRL) { 1291 disable_credit_flowctrl = true; 1292 } 1293 1294 set_htc_pkt_info(packet, NULL, (u8 *) conn_msg, 1295 length, 1296 ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); 1297 1298 status = ath6kl_htc_pipe_tx(target, packet); 1299 1300 /* we don't own it anymore */ 1301 packet = NULL; 1302 if (status != 0) 1303 goto free_packet; 1304 1305 /* wait for response */ 1306 status = htc_wait_recv_ctrl_message(target); 1307 if (status != 0) 1308 goto free_packet; 1309 1310 /* we controlled the buffer creation so it has to be 1311 * properly aligned 1312 */ 1313 resp_msg = (struct htc_conn_service_resp *) 1314 target->pipe.ctrl_response_buf; 1315 1316 if (resp_msg->msg_id != cpu_to_le16(HTC_MSG_CONN_SVC_RESP_ID) || 1317 (target->pipe.ctrl_response_len < sizeof(*resp_msg))) { 1318 /* this message is not valid */ 1319 WARN_ON_ONCE(1); 1320 status = -EINVAL; 1321 goto free_packet; 1322 } 1323 1324 ath6kl_dbg(ATH6KL_DBG_TRC, 1325 "%s: service 0x%X conn resp: status: %d ep: %d\n", 1326 __func__, resp_msg->svc_id, resp_msg->status, 1327 resp_msg->eid); 1328 1329 conn_resp->resp_code = resp_msg->status; 1330 /* check response status */ 1331 if (resp_msg->status != HTC_SERVICE_SUCCESS) { 1332 ath6kl_dbg(ATH6KL_DBG_HTC, 1333 "Target failed service 0x%X connect request (status:%d)\n", 1334 resp_msg->svc_id, resp_msg->status); 1335 status = -EINVAL; 1336 goto free_packet; 1337 } 1338 1339 assigned_epid = (enum htc_endpoint_id) resp_msg->eid; 1340 max_msg_size = le16_to_cpu(resp_msg->max_msg_sz); 1341 } 1342 1343 /* the rest are parameter checks so set the error status */ 1344 status = -EINVAL; 1345 1346 if (assigned_epid >= ENDPOINT_MAX) { 1347 WARN_ON_ONCE(1); 1348 goto free_packet; 1349 } 1350 1351 if (max_msg_size == 0) { 1352 WARN_ON_ONCE(1); 1353 goto free_packet; 1354 } 1355 1356 ep = &target->endpoint[assigned_epid]; 1357 ep->eid = assigned_epid; 1358 if (ep->svc_id != 0) { 1359 /* endpoint already in use! */ 1360 WARN_ON_ONCE(1); 1361 goto free_packet; 1362 } 1363 1364 /* return assigned endpoint to caller */ 1365 conn_resp->endpoint = assigned_epid; 1366 conn_resp->len_max = max_msg_size; 1367 1368 /* setup the endpoint */ 1369 ep->svc_id = conn_req->svc_id; /* this marks ep in use */ 1370 ep->max_txq_depth = conn_req->max_txq_depth; 1371 ep->len_max = max_msg_size; 1372 ep->cred_dist.credits = tx_alloc; 1373 ep->cred_dist.cred_sz = target->tgt_cred_sz; 1374 ep->cred_dist.cred_per_msg = max_msg_size / target->tgt_cred_sz; 1375 if (max_msg_size % target->tgt_cred_sz) 1376 ep->cred_dist.cred_per_msg++; 1377 1378 /* copy all the callbacks */ 1379 ep->ep_cb = conn_req->ep_cb; 1380 1381 /* initialize tx_drop_packet_threshold */ 1382 ep->tx_drop_packet_threshold = MAX_HI_COOKIE_NUM; 1383 1384 status = ath6kl_hif_pipe_map_service(ar, ep->svc_id, 1385 &ep->pipe.pipeid_ul, 1386 &ep->pipe.pipeid_dl); 1387 if (status != 0) 1388 goto free_packet; 1389 1390 ath6kl_dbg(ATH6KL_DBG_HTC, 1391 "SVC Ready: 0x%4.4X: ULpipe:%d DLpipe:%d id:%d\n", 1392 ep->svc_id, ep->pipe.pipeid_ul, 1393 ep->pipe.pipeid_dl, ep->eid); 1394 1395 if (disable_credit_flowctrl && ep->pipe.tx_credit_flow_enabled) { 1396 ep->pipe.tx_credit_flow_enabled = false; 1397 ath6kl_dbg(ATH6KL_DBG_HTC, 1398 "SVC: 0x%4.4X ep:%d TX flow control off\n", 1399 ep->svc_id, assigned_epid); 1400 } 1401 1402 free_packet: 1403 if (packet != NULL) 1404 htc_free_txctrl_packet(target, packet); 1405 return status; 1406 } 1407 1408 /* htc export functions */ 1409 static void *ath6kl_htc_pipe_create(struct ath6kl *ar) 1410 { 1411 int status = 0; 1412 struct htc_endpoint *ep = NULL; 1413 struct htc_target *target = NULL; 1414 struct htc_packet *packet; 1415 int i; 1416 1417 target = kzalloc(sizeof(struct htc_target), GFP_KERNEL); 1418 if (target == NULL) { 1419 ath6kl_err("htc create unable to allocate memory\n"); 1420 status = -ENOMEM; 1421 goto fail_htc_create; 1422 } 1423 1424 spin_lock_init(&target->htc_lock); 1425 spin_lock_init(&target->rx_lock); 1426 spin_lock_init(&target->tx_lock); 1427 1428 reset_endpoint_states(target); 1429 1430 for (i = 0; i < HTC_PACKET_CONTAINER_ALLOCATION; i++) { 1431 packet = kzalloc(sizeof(struct htc_packet), GFP_KERNEL); 1432 1433 if (packet != NULL) 1434 free_htc_packet_container(target, packet); 1435 } 1436 1437 target->dev = kzalloc(sizeof(*target->dev), GFP_KERNEL); 1438 if (!target->dev) { 1439 ath6kl_err("unable to allocate memory\n"); 1440 status = -ENOMEM; 1441 goto fail_htc_create; 1442 } 1443 target->dev->ar = ar; 1444 target->dev->htc_cnxt = target; 1445 1446 /* Get HIF default pipe for HTC message exchange */ 1447 ep = &target->endpoint[ENDPOINT_0]; 1448 1449 ath6kl_hif_pipe_get_default(ar, &ep->pipe.pipeid_ul, 1450 &ep->pipe.pipeid_dl); 1451 1452 return target; 1453 1454 fail_htc_create: 1455 if (status != 0) { 1456 if (target != NULL) 1457 ath6kl_htc_pipe_cleanup(target); 1458 1459 target = NULL; 1460 } 1461 return target; 1462 } 1463 1464 /* cleanup the HTC instance */ 1465 static void ath6kl_htc_pipe_cleanup(struct htc_target *target) 1466 { 1467 struct htc_packet *packet; 1468 1469 while (true) { 1470 packet = alloc_htc_packet_container(target); 1471 if (packet == NULL) 1472 break; 1473 kfree(packet); 1474 } 1475 1476 kfree(target->dev); 1477 1478 /* kfree our instance */ 1479 kfree(target); 1480 } 1481 1482 static int ath6kl_htc_pipe_start(struct htc_target *target) 1483 { 1484 struct sk_buff *skb; 1485 struct htc_setup_comp_ext_msg *setup; 1486 struct htc_packet *packet; 1487 1488 htc_config_target_hif_pipe(target); 1489 1490 /* allocate a buffer to send */ 1491 packet = htc_alloc_txctrl_packet(target); 1492 if (packet == NULL) { 1493 WARN_ON_ONCE(1); 1494 return -ENOMEM; 1495 } 1496 1497 skb = packet->skb; 1498 1499 /* assemble setup complete message */ 1500 setup = (struct htc_setup_comp_ext_msg *) skb_put(skb, 1501 sizeof(*setup)); 1502 memset(setup, 0, sizeof(struct htc_setup_comp_ext_msg)); 1503 setup->msg_id = cpu_to_le16(HTC_MSG_SETUP_COMPLETE_EX_ID); 1504 1505 ath6kl_dbg(ATH6KL_DBG_HTC, "HTC using TX credit flow control\n"); 1506 1507 set_htc_pkt_info(packet, NULL, (u8 *) setup, 1508 sizeof(struct htc_setup_comp_ext_msg), 1509 ENDPOINT_0, HTC_SERVICE_TX_PACKET_TAG); 1510 1511 target->htc_flags |= HTC_OP_STATE_SETUP_COMPLETE; 1512 1513 return ath6kl_htc_pipe_tx(target, packet); 1514 } 1515 1516 static void ath6kl_htc_pipe_stop(struct htc_target *target) 1517 { 1518 int i; 1519 struct htc_endpoint *ep; 1520 1521 /* cleanup endpoints */ 1522 for (i = 0; i < ENDPOINT_MAX; i++) { 1523 ep = &target->endpoint[i]; 1524 htc_flush_rx_queue(target, ep); 1525 htc_flush_tx_endpoint(target, ep, HTC_TX_PACKET_TAG_ALL); 1526 } 1527 1528 reset_endpoint_states(target); 1529 target->htc_flags &= ~HTC_OP_STATE_SETUP_COMPLETE; 1530 } 1531 1532 static int ath6kl_htc_pipe_get_rxbuf_num(struct htc_target *target, 1533 enum htc_endpoint_id endpoint) 1534 { 1535 int num; 1536 1537 spin_lock_bh(&target->rx_lock); 1538 num = get_queue_depth(&(target->endpoint[endpoint].rx_bufq)); 1539 spin_unlock_bh(&target->rx_lock); 1540 1541 return num; 1542 } 1543 1544 static int ath6kl_htc_pipe_tx(struct htc_target *target, 1545 struct htc_packet *packet) 1546 { 1547 struct list_head queue; 1548 1549 ath6kl_dbg(ATH6KL_DBG_HTC, 1550 "%s: endPointId: %d, buffer: 0x%p, length: %d\n", 1551 __func__, packet->endpoint, packet->buf, 1552 packet->act_len); 1553 1554 INIT_LIST_HEAD(&queue); 1555 list_add_tail(&packet->list, &queue); 1556 1557 return htc_send_packets_multiple(target, &queue); 1558 } 1559 1560 static int ath6kl_htc_pipe_wait_target(struct htc_target *target) 1561 { 1562 struct htc_ready_ext_msg *ready_msg; 1563 struct htc_service_connect_req connect; 1564 struct htc_service_connect_resp resp; 1565 int status = 0; 1566 1567 status = htc_wait_recv_ctrl_message(target); 1568 1569 if (status != 0) 1570 return status; 1571 1572 if (target->pipe.ctrl_response_len < sizeof(*ready_msg)) { 1573 ath6kl_dbg(ATH6KL_DBG_HTC, "invalid htc ready msg len:%d!\n", 1574 target->pipe.ctrl_response_len); 1575 return -ECOMM; 1576 } 1577 1578 ready_msg = (struct htc_ready_ext_msg *) target->pipe.ctrl_response_buf; 1579 1580 if (ready_msg->ver2_0_info.msg_id != cpu_to_le16(HTC_MSG_READY_ID)) { 1581 ath6kl_dbg(ATH6KL_DBG_HTC, "invalid htc ready msg : 0x%X !\n", 1582 ready_msg->ver2_0_info.msg_id); 1583 return -ECOMM; 1584 } 1585 1586 ath6kl_dbg(ATH6KL_DBG_HTC, 1587 "Target Ready! : transmit resources : %d size:%d\n", 1588 ready_msg->ver2_0_info.cred_cnt, 1589 ready_msg->ver2_0_info.cred_sz); 1590 1591 target->tgt_creds = le16_to_cpu(ready_msg->ver2_0_info.cred_cnt); 1592 target->tgt_cred_sz = le16_to_cpu(ready_msg->ver2_0_info.cred_sz); 1593 1594 if ((target->tgt_creds == 0) || (target->tgt_cred_sz == 0)) 1595 return -ECOMM; 1596 1597 htc_setup_target_buffer_assignments(target); 1598 1599 /* setup our pseudo HTC control endpoint connection */ 1600 memset(&connect, 0, sizeof(connect)); 1601 memset(&resp, 0, sizeof(resp)); 1602 connect.ep_cb.tx_complete = htc_txctrl_complete; 1603 connect.ep_cb.rx = htc_rxctrl_complete; 1604 connect.max_txq_depth = NUM_CONTROL_TX_BUFFERS; 1605 connect.svc_id = HTC_CTRL_RSVD_SVC; 1606 1607 /* connect fake service */ 1608 status = ath6kl_htc_pipe_conn_service(target, &connect, &resp); 1609 1610 return status; 1611 } 1612 1613 static void ath6kl_htc_pipe_flush_txep(struct htc_target *target, 1614 enum htc_endpoint_id endpoint, u16 tag) 1615 { 1616 struct htc_endpoint *ep = &target->endpoint[endpoint]; 1617 1618 if (ep->svc_id == 0) { 1619 WARN_ON_ONCE(1); 1620 /* not in use.. */ 1621 return; 1622 } 1623 1624 htc_flush_tx_endpoint(target, ep, tag); 1625 } 1626 1627 static int ath6kl_htc_pipe_add_rxbuf_multiple(struct htc_target *target, 1628 struct list_head *pkt_queue) 1629 { 1630 struct htc_packet *packet, *tmp_pkt, *first; 1631 struct htc_endpoint *ep; 1632 int status = 0; 1633 1634 if (list_empty(pkt_queue)) 1635 return -EINVAL; 1636 1637 first = list_first_entry(pkt_queue, struct htc_packet, list); 1638 1639 if (first->endpoint >= ENDPOINT_MAX) { 1640 WARN_ON_ONCE(1); 1641 return -EINVAL; 1642 } 1643 1644 ath6kl_dbg(ATH6KL_DBG_HTC, "%s: epid: %d, cnt:%d, len: %d\n", 1645 __func__, first->endpoint, get_queue_depth(pkt_queue), 1646 first->buf_len); 1647 1648 ep = &target->endpoint[first->endpoint]; 1649 1650 spin_lock_bh(&target->rx_lock); 1651 1652 /* store receive packets */ 1653 list_splice_tail_init(pkt_queue, &ep->rx_bufq); 1654 1655 spin_unlock_bh(&target->rx_lock); 1656 1657 if (status != 0) { 1658 /* walk through queue and mark each one canceled */ 1659 list_for_each_entry_safe(packet, tmp_pkt, pkt_queue, list) { 1660 packet->status = -ECANCELED; 1661 } 1662 1663 do_recv_completion(ep, pkt_queue); 1664 } 1665 1666 return status; 1667 } 1668 1669 static void ath6kl_htc_pipe_activity_changed(struct htc_target *target, 1670 enum htc_endpoint_id ep, 1671 bool active) 1672 { 1673 /* TODO */ 1674 } 1675 1676 static void ath6kl_htc_pipe_flush_rx_buf(struct htc_target *target) 1677 { 1678 /* TODO */ 1679 } 1680 1681 static int ath6kl_htc_pipe_credit_setup(struct htc_target *target, 1682 struct ath6kl_htc_credit_info *info) 1683 { 1684 return 0; 1685 } 1686 1687 static const struct ath6kl_htc_ops ath6kl_htc_pipe_ops = { 1688 .create = ath6kl_htc_pipe_create, 1689 .wait_target = ath6kl_htc_pipe_wait_target, 1690 .start = ath6kl_htc_pipe_start, 1691 .conn_service = ath6kl_htc_pipe_conn_service, 1692 .tx = ath6kl_htc_pipe_tx, 1693 .stop = ath6kl_htc_pipe_stop, 1694 .cleanup = ath6kl_htc_pipe_cleanup, 1695 .flush_txep = ath6kl_htc_pipe_flush_txep, 1696 .flush_rx_buf = ath6kl_htc_pipe_flush_rx_buf, 1697 .activity_changed = ath6kl_htc_pipe_activity_changed, 1698 .get_rxbuf_num = ath6kl_htc_pipe_get_rxbuf_num, 1699 .add_rxbuf_multiple = ath6kl_htc_pipe_add_rxbuf_multiple, 1700 .credit_setup = ath6kl_htc_pipe_credit_setup, 1701 .tx_complete = ath6kl_htc_pipe_tx_complete, 1702 .rx_complete = ath6kl_htc_pipe_rx_complete, 1703 }; 1704 1705 void ath6kl_htc_pipe_attach(struct ath6kl *ar) 1706 { 1707 ar->htc_ops = &ath6kl_htc_pipe_ops; 1708 } 1709