1 // SPDX-License-Identifier: ISC 2 /* 3 * Copyright (c) 2005-2011 Atheros Communications Inc. 4 * Copyright (c) 2011-2017 Qualcomm Atheros, Inc. 5 */ 6 7 #include "core.h" 8 #include "hif.h" 9 #include "debug.h" 10 11 /********/ 12 /* Send */ 13 /********/ 14 15 static void ath10k_htc_control_tx_complete(struct ath10k *ar, 16 struct sk_buff *skb) 17 { 18 kfree_skb(skb); 19 } 20 21 static struct sk_buff *ath10k_htc_build_tx_ctrl_skb(void *ar) 22 { 23 struct sk_buff *skb; 24 struct ath10k_skb_cb *skb_cb; 25 26 skb = dev_alloc_skb(ATH10K_HTC_CONTROL_BUFFER_SIZE); 27 if (!skb) 28 return NULL; 29 30 skb_reserve(skb, 20); /* FIXME: why 20 bytes? */ 31 WARN_ONCE((unsigned long)skb->data & 3, "unaligned skb"); 32 33 skb_cb = ATH10K_SKB_CB(skb); 34 memset(skb_cb, 0, sizeof(*skb_cb)); 35 36 ath10k_dbg(ar, ATH10K_DBG_HTC, "%s: skb %pK\n", __func__, skb); 37 return skb; 38 } 39 40 static inline void ath10k_htc_restore_tx_skb(struct ath10k_htc *htc, 41 struct sk_buff *skb) 42 { 43 struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb); 44 45 if (htc->ar->bus_param.dev_type != ATH10K_DEV_TYPE_HL) 46 dma_unmap_single(htc->ar->dev, skb_cb->paddr, skb->len, DMA_TO_DEVICE); 47 skb_pull(skb, sizeof(struct ath10k_htc_hdr)); 48 } 49 50 void ath10k_htc_notify_tx_completion(struct ath10k_htc_ep *ep, 51 struct sk_buff *skb) 52 { 53 struct ath10k *ar = ep->htc->ar; 54 struct ath10k_htc_hdr *hdr; 55 56 ath10k_dbg(ar, ATH10K_DBG_HTC, "%s: ep %d skb %pK\n", __func__, 57 ep->eid, skb); 58 59 /* A corner case where the copy completion is reaching to host but still 60 * copy engine is processing it due to which host unmaps corresponding 61 * memory and causes SMMU fault, hence as workaround adding delay 62 * the unmapping memory to avoid SMMU faults. 63 */ 64 if (ar->hw_params.delay_unmap_buffer && 65 ep->ul_pipe_id == 3) 66 mdelay(2); 67 68 hdr = (struct ath10k_htc_hdr *)skb->data; 69 ath10k_htc_restore_tx_skb(ep->htc, skb); 70 71 if (!ep->ep_ops.ep_tx_complete) { 72 ath10k_warn(ar, "no tx handler for eid %d\n", ep->eid); 73 dev_kfree_skb_any(skb); 74 return; 75 } 76 77 if (hdr->flags & ATH10K_HTC_FLAG_SEND_BUNDLE) { 78 dev_kfree_skb_any(skb); 79 return; 80 } 81 82 ep->ep_ops.ep_tx_complete(ep->htc->ar, skb); 83 } 84 EXPORT_SYMBOL(ath10k_htc_notify_tx_completion); 85 86 static void ath10k_htc_prepare_tx_skb(struct ath10k_htc_ep *ep, 87 struct sk_buff *skb) 88 { 89 struct ath10k_htc_hdr *hdr; 90 91 hdr = (struct ath10k_htc_hdr *)skb->data; 92 memset(hdr, 0, sizeof(struct ath10k_htc_hdr)); 93 94 hdr->eid = ep->eid; 95 hdr->len = __cpu_to_le16(skb->len - sizeof(*hdr)); 96 hdr->flags = 0; 97 if (ep->tx_credit_flow_enabled && !ep->bundle_tx) 98 hdr->flags |= ATH10K_HTC_FLAG_NEED_CREDIT_UPDATE; 99 100 spin_lock_bh(&ep->htc->tx_lock); 101 hdr->seq_no = ep->seq_no++; 102 spin_unlock_bh(&ep->htc->tx_lock); 103 } 104 105 static int ath10k_htc_consume_credit(struct ath10k_htc_ep *ep, 106 unsigned int len, 107 bool consume) 108 { 109 struct ath10k_htc *htc = ep->htc; 110 struct ath10k *ar = htc->ar; 111 enum ath10k_htc_ep_id eid = ep->eid; 112 int credits, ret = 0; 113 114 if (!ep->tx_credit_flow_enabled) 115 return 0; 116 117 credits = DIV_ROUND_UP(len, ep->tx_credit_size); 118 spin_lock_bh(&htc->tx_lock); 119 120 if (ep->tx_credits < credits) { 121 ath10k_dbg(ar, ATH10K_DBG_HTC, 122 "htc insufficient credits ep %d required %d available %d consume %d\n", 123 eid, credits, ep->tx_credits, consume); 124 ret = -EAGAIN; 125 goto unlock; 126 } 127 128 if (consume) { 129 ep->tx_credits -= credits; 130 ath10k_dbg(ar, ATH10K_DBG_HTC, 131 "htc ep %d consumed %d credits total %d\n", 132 eid, credits, ep->tx_credits); 133 } 134 135 unlock: 136 spin_unlock_bh(&htc->tx_lock); 137 return ret; 138 } 139 140 static void ath10k_htc_release_credit(struct ath10k_htc_ep *ep, unsigned int len) 141 { 142 struct ath10k_htc *htc = ep->htc; 143 struct ath10k *ar = htc->ar; 144 enum ath10k_htc_ep_id eid = ep->eid; 145 int credits; 146 147 if (!ep->tx_credit_flow_enabled) 148 return; 149 150 credits = DIV_ROUND_UP(len, ep->tx_credit_size); 151 spin_lock_bh(&htc->tx_lock); 152 ep->tx_credits += credits; 153 ath10k_dbg(ar, ATH10K_DBG_HTC, 154 "htc ep %d reverted %d credits back total %d\n", 155 eid, credits, ep->tx_credits); 156 spin_unlock_bh(&htc->tx_lock); 157 158 if (ep->ep_ops.ep_tx_credits) 159 ep->ep_ops.ep_tx_credits(htc->ar); 160 } 161 162 int ath10k_htc_send(struct ath10k_htc *htc, 163 enum ath10k_htc_ep_id eid, 164 struct sk_buff *skb) 165 { 166 struct ath10k *ar = htc->ar; 167 struct ath10k_htc_ep *ep = &htc->endpoint[eid]; 168 struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb); 169 struct ath10k_hif_sg_item sg_item; 170 struct device *dev = htc->ar->dev; 171 int ret; 172 unsigned int skb_len; 173 174 if (htc->ar->state == ATH10K_STATE_WEDGED) 175 return -ECOMM; 176 177 if (eid >= ATH10K_HTC_EP_COUNT) { 178 ath10k_warn(ar, "Invalid endpoint id: %d\n", eid); 179 return -ENOENT; 180 } 181 182 skb_push(skb, sizeof(struct ath10k_htc_hdr)); 183 184 skb_len = skb->len; 185 ret = ath10k_htc_consume_credit(ep, skb_len, true); 186 if (ret) 187 goto err_pull; 188 189 ath10k_htc_prepare_tx_skb(ep, skb); 190 191 skb_cb->eid = eid; 192 if (ar->bus_param.dev_type != ATH10K_DEV_TYPE_HL) { 193 skb_cb->paddr = dma_map_single(dev, skb->data, skb->len, 194 DMA_TO_DEVICE); 195 ret = dma_mapping_error(dev, skb_cb->paddr); 196 if (ret) { 197 ret = -EIO; 198 goto err_credits; 199 } 200 } 201 202 sg_item.transfer_id = ep->eid; 203 sg_item.transfer_context = skb; 204 sg_item.vaddr = skb->data; 205 sg_item.paddr = skb_cb->paddr; 206 sg_item.len = skb->len; 207 208 ret = ath10k_hif_tx_sg(htc->ar, ep->ul_pipe_id, &sg_item, 1); 209 if (ret) 210 goto err_unmap; 211 212 return 0; 213 214 err_unmap: 215 if (ar->bus_param.dev_type != ATH10K_DEV_TYPE_HL) 216 dma_unmap_single(dev, skb_cb->paddr, skb->len, DMA_TO_DEVICE); 217 err_credits: 218 ath10k_htc_release_credit(ep, skb_len); 219 err_pull: 220 skb_pull(skb, sizeof(struct ath10k_htc_hdr)); 221 return ret; 222 } 223 224 void ath10k_htc_tx_completion_handler(struct ath10k *ar, struct sk_buff *skb) 225 { 226 struct ath10k_htc *htc = &ar->htc; 227 struct ath10k_skb_cb *skb_cb; 228 struct ath10k_htc_ep *ep; 229 230 if (WARN_ON_ONCE(!skb)) 231 return; 232 233 skb_cb = ATH10K_SKB_CB(skb); 234 ep = &htc->endpoint[skb_cb->eid]; 235 236 ath10k_htc_notify_tx_completion(ep, skb); 237 /* the skb now belongs to the completion handler */ 238 } 239 EXPORT_SYMBOL(ath10k_htc_tx_completion_handler); 240 241 /***********/ 242 /* Receive */ 243 /***********/ 244 245 static void 246 ath10k_htc_process_credit_report(struct ath10k_htc *htc, 247 const struct ath10k_htc_credit_report *report, 248 int len, 249 enum ath10k_htc_ep_id eid) 250 { 251 struct ath10k *ar = htc->ar; 252 struct ath10k_htc_ep *ep; 253 int i, n_reports; 254 255 if (len % sizeof(*report)) 256 ath10k_warn(ar, "Uneven credit report len %d", len); 257 258 n_reports = len / sizeof(*report); 259 260 spin_lock_bh(&htc->tx_lock); 261 for (i = 0; i < n_reports; i++, report++) { 262 if (report->eid >= ATH10K_HTC_EP_COUNT) 263 break; 264 265 ep = &htc->endpoint[report->eid]; 266 ep->tx_credits += report->credits; 267 268 ath10k_dbg(ar, ATH10K_DBG_HTC, "htc ep %d got %d credits (total %d)\n", 269 report->eid, report->credits, ep->tx_credits); 270 271 if (ep->ep_ops.ep_tx_credits) { 272 spin_unlock_bh(&htc->tx_lock); 273 ep->ep_ops.ep_tx_credits(htc->ar); 274 spin_lock_bh(&htc->tx_lock); 275 } 276 } 277 spin_unlock_bh(&htc->tx_lock); 278 } 279 280 static int 281 ath10k_htc_process_lookahead(struct ath10k_htc *htc, 282 const struct ath10k_htc_lookahead_report *report, 283 int len, 284 enum ath10k_htc_ep_id eid, 285 void *next_lookaheads, 286 int *next_lookaheads_len) 287 { 288 struct ath10k *ar = htc->ar; 289 290 /* Invalid lookahead flags are actually transmitted by 291 * the target in the HTC control message. 292 * Since this will happen at every boot we silently ignore 293 * the lookahead in this case 294 */ 295 if (report->pre_valid != ((~report->post_valid) & 0xFF)) 296 return 0; 297 298 if (next_lookaheads && next_lookaheads_len) { 299 ath10k_dbg(ar, ATH10K_DBG_HTC, 300 "htc rx lookahead found pre_valid 0x%x post_valid 0x%x\n", 301 report->pre_valid, report->post_valid); 302 303 /* look ahead bytes are valid, copy them over */ 304 memcpy((u8 *)next_lookaheads, report->lookahead, 4); 305 306 *next_lookaheads_len = 1; 307 } 308 309 return 0; 310 } 311 312 static int 313 ath10k_htc_process_lookahead_bundle(struct ath10k_htc *htc, 314 const struct ath10k_htc_lookahead_bundle *report, 315 int len, 316 enum ath10k_htc_ep_id eid, 317 void *next_lookaheads, 318 int *next_lookaheads_len) 319 { 320 struct ath10k *ar = htc->ar; 321 int bundle_cnt = len / sizeof(*report); 322 323 if (!bundle_cnt || (bundle_cnt > htc->max_msgs_per_htc_bundle)) { 324 ath10k_warn(ar, "Invalid lookahead bundle count: %d\n", 325 bundle_cnt); 326 return -EINVAL; 327 } 328 329 if (next_lookaheads && next_lookaheads_len) { 330 int i; 331 332 for (i = 0; i < bundle_cnt; i++) { 333 memcpy(((u8 *)next_lookaheads) + 4 * i, 334 report->lookahead, 4); 335 report++; 336 } 337 338 *next_lookaheads_len = bundle_cnt; 339 } 340 341 return 0; 342 } 343 344 int ath10k_htc_process_trailer(struct ath10k_htc *htc, 345 u8 *buffer, 346 int length, 347 enum ath10k_htc_ep_id src_eid, 348 void *next_lookaheads, 349 int *next_lookaheads_len) 350 { 351 struct ath10k_htc_lookahead_bundle *bundle; 352 struct ath10k *ar = htc->ar; 353 int status = 0; 354 struct ath10k_htc_record *record; 355 u8 *orig_buffer; 356 int orig_length; 357 size_t len; 358 359 orig_buffer = buffer; 360 orig_length = length; 361 362 while (length > 0) { 363 record = (struct ath10k_htc_record *)buffer; 364 365 if (length < sizeof(record->hdr)) { 366 status = -EINVAL; 367 break; 368 } 369 370 if (record->hdr.len > length) { 371 /* no room left in buffer for record */ 372 ath10k_warn(ar, "Invalid record length: %d\n", 373 record->hdr.len); 374 status = -EINVAL; 375 break; 376 } 377 378 switch (record->hdr.id) { 379 case ATH10K_HTC_RECORD_CREDITS: 380 len = sizeof(struct ath10k_htc_credit_report); 381 if (record->hdr.len < len) { 382 ath10k_warn(ar, "Credit report too long\n"); 383 status = -EINVAL; 384 break; 385 } 386 ath10k_htc_process_credit_report(htc, 387 record->credit_report, 388 record->hdr.len, 389 src_eid); 390 break; 391 case ATH10K_HTC_RECORD_LOOKAHEAD: 392 len = sizeof(struct ath10k_htc_lookahead_report); 393 if (record->hdr.len < len) { 394 ath10k_warn(ar, "Lookahead report too long\n"); 395 status = -EINVAL; 396 break; 397 } 398 status = ath10k_htc_process_lookahead(htc, 399 record->lookahead_report, 400 record->hdr.len, 401 src_eid, 402 next_lookaheads, 403 next_lookaheads_len); 404 break; 405 case ATH10K_HTC_RECORD_LOOKAHEAD_BUNDLE: 406 bundle = record->lookahead_bundle; 407 status = ath10k_htc_process_lookahead_bundle(htc, 408 bundle, 409 record->hdr.len, 410 src_eid, 411 next_lookaheads, 412 next_lookaheads_len); 413 break; 414 default: 415 ath10k_warn(ar, "Unhandled record: id:%d length:%d\n", 416 record->hdr.id, record->hdr.len); 417 break; 418 } 419 420 if (status) 421 break; 422 423 /* multiple records may be present in a trailer */ 424 buffer += sizeof(record->hdr) + record->hdr.len; 425 length -= sizeof(record->hdr) + record->hdr.len; 426 } 427 428 if (status) 429 ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc rx bad trailer", "", 430 orig_buffer, orig_length); 431 432 return status; 433 } 434 EXPORT_SYMBOL(ath10k_htc_process_trailer); 435 436 void ath10k_htc_rx_completion_handler(struct ath10k *ar, struct sk_buff *skb) 437 { 438 int status = 0; 439 struct ath10k_htc *htc = &ar->htc; 440 struct ath10k_htc_hdr *hdr; 441 struct ath10k_htc_ep *ep; 442 u16 payload_len; 443 u32 trailer_len = 0; 444 size_t min_len; 445 u8 eid; 446 bool trailer_present; 447 448 hdr = (struct ath10k_htc_hdr *)skb->data; 449 skb_pull(skb, sizeof(*hdr)); 450 451 eid = hdr->eid; 452 453 if (eid >= ATH10K_HTC_EP_COUNT) { 454 ath10k_warn(ar, "HTC Rx: invalid eid %d\n", eid); 455 ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc bad header", "", 456 hdr, sizeof(*hdr)); 457 goto out; 458 } 459 460 ep = &htc->endpoint[eid]; 461 if (ep->service_id == ATH10K_HTC_SVC_ID_UNUSED) { 462 ath10k_warn(ar, "htc rx endpoint %d is not connected\n", eid); 463 goto out; 464 } 465 466 payload_len = __le16_to_cpu(hdr->len); 467 468 if (payload_len + sizeof(*hdr) > ATH10K_HTC_MAX_LEN) { 469 ath10k_warn(ar, "HTC rx frame too long, len: %zu\n", 470 payload_len + sizeof(*hdr)); 471 ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc bad rx pkt len", "", 472 hdr, sizeof(*hdr)); 473 goto out; 474 } 475 476 if (skb->len < payload_len) { 477 ath10k_dbg(ar, ATH10K_DBG_HTC, 478 "HTC Rx: insufficient length, got %d, expected %d\n", 479 skb->len, payload_len); 480 ath10k_dbg_dump(ar, ATH10K_DBG_HTC, "htc bad rx pkt len", 481 "", hdr, sizeof(*hdr)); 482 goto out; 483 } 484 485 /* get flags to check for trailer */ 486 trailer_present = hdr->flags & ATH10K_HTC_FLAG_TRAILER_PRESENT; 487 if (trailer_present) { 488 u8 *trailer; 489 490 trailer_len = hdr->trailer_len; 491 min_len = sizeof(struct ath10k_ath10k_htc_record_hdr); 492 493 if ((trailer_len < min_len) || 494 (trailer_len > payload_len)) { 495 ath10k_warn(ar, "Invalid trailer length: %d\n", 496 trailer_len); 497 goto out; 498 } 499 500 trailer = (u8 *)hdr; 501 trailer += sizeof(*hdr); 502 trailer += payload_len; 503 trailer -= trailer_len; 504 status = ath10k_htc_process_trailer(htc, trailer, 505 trailer_len, hdr->eid, 506 NULL, NULL); 507 if (status) 508 goto out; 509 510 skb_trim(skb, skb->len - trailer_len); 511 } 512 513 if (((int)payload_len - (int)trailer_len) <= 0) 514 /* zero length packet with trailer data, just drop these */ 515 goto out; 516 517 ath10k_dbg(ar, ATH10K_DBG_HTC, "htc rx completion ep %d skb %pK\n", 518 eid, skb); 519 ep->ep_ops.ep_rx_complete(ar, skb); 520 521 /* skb is now owned by the rx completion handler */ 522 skb = NULL; 523 out: 524 kfree_skb(skb); 525 } 526 EXPORT_SYMBOL(ath10k_htc_rx_completion_handler); 527 528 static void ath10k_htc_control_rx_complete(struct ath10k *ar, 529 struct sk_buff *skb) 530 { 531 struct ath10k_htc *htc = &ar->htc; 532 struct ath10k_htc_msg *msg = (struct ath10k_htc_msg *)skb->data; 533 534 switch (__le16_to_cpu(msg->hdr.message_id)) { 535 case ATH10K_HTC_MSG_READY_ID: 536 case ATH10K_HTC_MSG_CONNECT_SERVICE_RESP_ID: 537 /* handle HTC control message */ 538 if (completion_done(&htc->ctl_resp)) { 539 /* this is a fatal error, target should not be 540 * sending unsolicited messages on the ep 0 541 */ 542 ath10k_warn(ar, "HTC rx ctrl still processing\n"); 543 complete(&htc->ctl_resp); 544 goto out; 545 } 546 547 htc->control_resp_len = 548 min_t(int, skb->len, 549 ATH10K_HTC_MAX_CTRL_MSG_LEN); 550 551 memcpy(htc->control_resp_buffer, skb->data, 552 htc->control_resp_len); 553 554 complete(&htc->ctl_resp); 555 break; 556 case ATH10K_HTC_MSG_SEND_SUSPEND_COMPLETE: 557 htc->htc_ops.target_send_suspend_complete(ar); 558 break; 559 default: 560 ath10k_warn(ar, "ignoring unsolicited htc ep0 event\n"); 561 break; 562 } 563 564 out: 565 kfree_skb(skb); 566 } 567 568 /***************/ 569 /* Init/Deinit */ 570 /***************/ 571 572 static const char *htc_service_name(enum ath10k_htc_svc_id id) 573 { 574 switch (id) { 575 case ATH10K_HTC_SVC_ID_RESERVED: 576 return "Reserved"; 577 case ATH10K_HTC_SVC_ID_RSVD_CTRL: 578 return "Control"; 579 case ATH10K_HTC_SVC_ID_WMI_CONTROL: 580 return "WMI"; 581 case ATH10K_HTC_SVC_ID_WMI_DATA_BE: 582 return "DATA BE"; 583 case ATH10K_HTC_SVC_ID_WMI_DATA_BK: 584 return "DATA BK"; 585 case ATH10K_HTC_SVC_ID_WMI_DATA_VI: 586 return "DATA VI"; 587 case ATH10K_HTC_SVC_ID_WMI_DATA_VO: 588 return "DATA VO"; 589 case ATH10K_HTC_SVC_ID_NMI_CONTROL: 590 return "NMI Control"; 591 case ATH10K_HTC_SVC_ID_NMI_DATA: 592 return "NMI Data"; 593 case ATH10K_HTC_SVC_ID_HTT_DATA_MSG: 594 return "HTT Data"; 595 case ATH10K_HTC_SVC_ID_HTT_DATA2_MSG: 596 return "HTT Data"; 597 case ATH10K_HTC_SVC_ID_HTT_DATA3_MSG: 598 return "HTT Data"; 599 case ATH10K_HTC_SVC_ID_TEST_RAW_STREAMS: 600 return "RAW"; 601 case ATH10K_HTC_SVC_ID_HTT_LOG_MSG: 602 return "PKTLOG"; 603 } 604 605 return "Unknown"; 606 } 607 608 static void ath10k_htc_reset_endpoint_states(struct ath10k_htc *htc) 609 { 610 struct ath10k_htc_ep *ep; 611 int i; 612 613 for (i = ATH10K_HTC_EP_0; i < ATH10K_HTC_EP_COUNT; i++) { 614 ep = &htc->endpoint[i]; 615 ep->service_id = ATH10K_HTC_SVC_ID_UNUSED; 616 ep->max_ep_message_len = 0; 617 ep->max_tx_queue_depth = 0; 618 ep->eid = i; 619 ep->htc = htc; 620 ep->tx_credit_flow_enabled = true; 621 } 622 } 623 624 static u8 ath10k_htc_get_credit_allocation(struct ath10k_htc *htc, 625 u16 service_id) 626 { 627 u8 allocation = 0; 628 629 /* The WMI control service is the only service with flow control. 630 * Let it have all transmit credits. 631 */ 632 if (service_id == ATH10K_HTC_SVC_ID_WMI_CONTROL) 633 allocation = htc->total_transmit_credits; 634 635 return allocation; 636 } 637 638 static int ath10k_htc_send_bundle(struct ath10k_htc_ep *ep, 639 struct sk_buff *bundle_skb, 640 struct sk_buff_head *tx_save_head) 641 { 642 struct ath10k_hif_sg_item sg_item; 643 struct ath10k_htc *htc = ep->htc; 644 struct ath10k *ar = htc->ar; 645 struct sk_buff *skb; 646 int ret, cn = 0; 647 unsigned int skb_len; 648 649 ath10k_dbg(ar, ATH10K_DBG_HTC, "bundle skb len %d\n", bundle_skb->len); 650 skb_len = bundle_skb->len; 651 ret = ath10k_htc_consume_credit(ep, skb_len, true); 652 653 if (!ret) { 654 sg_item.transfer_id = ep->eid; 655 sg_item.transfer_context = bundle_skb; 656 sg_item.vaddr = bundle_skb->data; 657 sg_item.len = bundle_skb->len; 658 659 ret = ath10k_hif_tx_sg(htc->ar, ep->ul_pipe_id, &sg_item, 1); 660 if (ret) 661 ath10k_htc_release_credit(ep, skb_len); 662 } 663 664 if (ret) 665 dev_kfree_skb_any(bundle_skb); 666 667 for (cn = 0; (skb = skb_dequeue_tail(tx_save_head)); cn++) { 668 if (ret) { 669 skb_pull(skb, sizeof(struct ath10k_htc_hdr)); 670 skb_queue_head(&ep->tx_req_head, skb); 671 } else { 672 skb_queue_tail(&ep->tx_complete_head, skb); 673 } 674 } 675 676 if (!ret) 677 queue_work(ar->workqueue_tx_complete, &ar->tx_complete_work); 678 679 ath10k_dbg(ar, ATH10K_DBG_HTC, 680 "bundle tx status %d eid %d req count %d count %d len %d\n", 681 ret, ep->eid, skb_queue_len(&ep->tx_req_head), cn, skb_len); 682 return ret; 683 } 684 685 static void ath10k_htc_send_one_skb(struct ath10k_htc_ep *ep, struct sk_buff *skb) 686 { 687 struct ath10k_htc *htc = ep->htc; 688 struct ath10k *ar = htc->ar; 689 int ret; 690 691 ret = ath10k_htc_send(htc, ep->eid, skb); 692 693 if (ret) 694 skb_queue_head(&ep->tx_req_head, skb); 695 696 ath10k_dbg(ar, ATH10K_DBG_HTC, "tx one status %d eid %d len %d pending count %d\n", 697 ret, ep->eid, skb->len, skb_queue_len(&ep->tx_req_head)); 698 } 699 700 static int ath10k_htc_send_bundle_skbs(struct ath10k_htc_ep *ep) 701 { 702 struct ath10k_htc *htc = ep->htc; 703 struct sk_buff *bundle_skb, *skb; 704 struct sk_buff_head tx_save_head; 705 struct ath10k_htc_hdr *hdr; 706 u8 *bundle_buf; 707 int ret = 0, credit_pad, credit_remainder, trans_len, bundles_left = 0; 708 709 if (htc->ar->state == ATH10K_STATE_WEDGED) 710 return -ECOMM; 711 712 if (ep->tx_credit_flow_enabled && 713 ep->tx_credits < ATH10K_MIN_CREDIT_PER_HTC_TX_BUNDLE) 714 return 0; 715 716 bundles_left = ATH10K_MAX_MSG_PER_HTC_TX_BUNDLE * ep->tx_credit_size; 717 bundle_skb = dev_alloc_skb(bundles_left); 718 719 if (!bundle_skb) 720 return -ENOMEM; 721 722 bundle_buf = bundle_skb->data; 723 skb_queue_head_init(&tx_save_head); 724 725 while (true) { 726 skb = skb_dequeue(&ep->tx_req_head); 727 if (!skb) 728 break; 729 730 credit_pad = 0; 731 trans_len = skb->len + sizeof(*hdr); 732 credit_remainder = trans_len % ep->tx_credit_size; 733 734 if (credit_remainder != 0) { 735 credit_pad = ep->tx_credit_size - credit_remainder; 736 trans_len += credit_pad; 737 } 738 739 ret = ath10k_htc_consume_credit(ep, 740 bundle_buf + trans_len - bundle_skb->data, 741 false); 742 if (ret) { 743 skb_queue_head(&ep->tx_req_head, skb); 744 break; 745 } 746 747 if (bundles_left < trans_len) { 748 bundle_skb->len = bundle_buf - bundle_skb->data; 749 ret = ath10k_htc_send_bundle(ep, bundle_skb, &tx_save_head); 750 751 if (ret) { 752 skb_queue_head(&ep->tx_req_head, skb); 753 return ret; 754 } 755 756 if (skb_queue_len(&ep->tx_req_head) == 0) { 757 ath10k_htc_send_one_skb(ep, skb); 758 return ret; 759 } 760 761 if (ep->tx_credit_flow_enabled && 762 ep->tx_credits < ATH10K_MIN_CREDIT_PER_HTC_TX_BUNDLE) { 763 skb_queue_head(&ep->tx_req_head, skb); 764 return 0; 765 } 766 767 bundles_left = 768 ATH10K_MAX_MSG_PER_HTC_TX_BUNDLE * ep->tx_credit_size; 769 bundle_skb = dev_alloc_skb(bundles_left); 770 771 if (!bundle_skb) { 772 skb_queue_head(&ep->tx_req_head, skb); 773 return -ENOMEM; 774 } 775 bundle_buf = bundle_skb->data; 776 skb_queue_head_init(&tx_save_head); 777 } 778 779 skb_push(skb, sizeof(struct ath10k_htc_hdr)); 780 ath10k_htc_prepare_tx_skb(ep, skb); 781 782 memcpy(bundle_buf, skb->data, skb->len); 783 hdr = (struct ath10k_htc_hdr *)bundle_buf; 784 hdr->flags |= ATH10K_HTC_FLAG_SEND_BUNDLE; 785 hdr->pad_len = __cpu_to_le16(credit_pad); 786 bundle_buf += trans_len; 787 bundles_left -= trans_len; 788 skb_queue_tail(&tx_save_head, skb); 789 } 790 791 if (bundle_buf != bundle_skb->data) { 792 bundle_skb->len = bundle_buf - bundle_skb->data; 793 ret = ath10k_htc_send_bundle(ep, bundle_skb, &tx_save_head); 794 } else { 795 dev_kfree_skb_any(bundle_skb); 796 } 797 798 return ret; 799 } 800 801 static void ath10k_htc_bundle_tx_work(struct work_struct *work) 802 { 803 struct ath10k *ar = container_of(work, struct ath10k, bundle_tx_work); 804 struct ath10k_htc_ep *ep; 805 struct sk_buff *skb; 806 int i; 807 808 for (i = 0; i < ARRAY_SIZE(ar->htc.endpoint); i++) { 809 ep = &ar->htc.endpoint[i]; 810 811 if (!ep->bundle_tx) 812 continue; 813 814 ath10k_dbg(ar, ATH10K_DBG_HTC, "bundle tx work eid %d count %d\n", 815 ep->eid, skb_queue_len(&ep->tx_req_head)); 816 817 if (skb_queue_len(&ep->tx_req_head) >= 818 ATH10K_MIN_MSG_PER_HTC_TX_BUNDLE) { 819 ath10k_htc_send_bundle_skbs(ep); 820 } else { 821 skb = skb_dequeue(&ep->tx_req_head); 822 823 if (!skb) 824 continue; 825 ath10k_htc_send_one_skb(ep, skb); 826 } 827 } 828 } 829 830 static void ath10k_htc_tx_complete_work(struct work_struct *work) 831 { 832 struct ath10k *ar = container_of(work, struct ath10k, tx_complete_work); 833 struct ath10k_htc_ep *ep; 834 enum ath10k_htc_ep_id eid; 835 struct sk_buff *skb; 836 int i; 837 838 for (i = 0; i < ARRAY_SIZE(ar->htc.endpoint); i++) { 839 ep = &ar->htc.endpoint[i]; 840 eid = ep->eid; 841 if (ep->bundle_tx && eid == ar->htt.eid) { 842 ath10k_dbg(ar, ATH10K_DBG_HTC, "bundle tx complete eid %d pending complete count%d\n", 843 ep->eid, skb_queue_len(&ep->tx_complete_head)); 844 845 while (true) { 846 skb = skb_dequeue(&ep->tx_complete_head); 847 if (!skb) 848 break; 849 ath10k_htc_notify_tx_completion(ep, skb); 850 } 851 } 852 } 853 } 854 855 int ath10k_htc_send_hl(struct ath10k_htc *htc, 856 enum ath10k_htc_ep_id eid, 857 struct sk_buff *skb) 858 { 859 struct ath10k_htc_ep *ep = &htc->endpoint[eid]; 860 struct ath10k *ar = htc->ar; 861 862 if (sizeof(struct ath10k_htc_hdr) + skb->len > ep->tx_credit_size) { 863 ath10k_dbg(ar, ATH10K_DBG_HTC, "tx exceed max len %d\n", skb->len); 864 return -ENOMEM; 865 } 866 867 ath10k_dbg(ar, ATH10K_DBG_HTC, "htc send hl eid %d bundle %d tx count %d len %d\n", 868 eid, ep->bundle_tx, skb_queue_len(&ep->tx_req_head), skb->len); 869 870 if (ep->bundle_tx) { 871 skb_queue_tail(&ep->tx_req_head, skb); 872 queue_work(ar->workqueue, &ar->bundle_tx_work); 873 return 0; 874 } else { 875 return ath10k_htc_send(htc, eid, skb); 876 } 877 } 878 879 void ath10k_htc_setup_tx_req(struct ath10k_htc_ep *ep) 880 { 881 if (ep->htc->max_msgs_per_htc_bundle >= ATH10K_MIN_MSG_PER_HTC_TX_BUNDLE && 882 !ep->bundle_tx) { 883 ep->bundle_tx = true; 884 skb_queue_head_init(&ep->tx_req_head); 885 skb_queue_head_init(&ep->tx_complete_head); 886 } 887 } 888 889 void ath10k_htc_stop_hl(struct ath10k *ar) 890 { 891 struct ath10k_htc_ep *ep; 892 int i; 893 894 cancel_work_sync(&ar->bundle_tx_work); 895 cancel_work_sync(&ar->tx_complete_work); 896 897 for (i = 0; i < ARRAY_SIZE(ar->htc.endpoint); i++) { 898 ep = &ar->htc.endpoint[i]; 899 900 if (!ep->bundle_tx) 901 continue; 902 903 ath10k_dbg(ar, ATH10K_DBG_HTC, "stop tx work eid %d count %d\n", 904 ep->eid, skb_queue_len(&ep->tx_req_head)); 905 906 skb_queue_purge(&ep->tx_req_head); 907 } 908 } 909 910 int ath10k_htc_wait_target(struct ath10k_htc *htc) 911 { 912 struct ath10k *ar = htc->ar; 913 int i, status = 0; 914 unsigned long time_left; 915 struct ath10k_htc_msg *msg; 916 u16 message_id; 917 918 time_left = wait_for_completion_timeout(&htc->ctl_resp, 919 ATH10K_HTC_WAIT_TIMEOUT_HZ); 920 if (!time_left) { 921 /* Workaround: In some cases the PCI HIF doesn't 922 * receive interrupt for the control response message 923 * even if the buffer was completed. It is suspected 924 * iomap writes unmasking PCI CE irqs aren't propagated 925 * properly in KVM PCI-passthrough sometimes. 926 */ 927 ath10k_warn(ar, "failed to receive control response completion, polling..\n"); 928 929 for (i = 0; i < CE_COUNT; i++) 930 ath10k_hif_send_complete_check(htc->ar, i, 1); 931 932 time_left = 933 wait_for_completion_timeout(&htc->ctl_resp, 934 ATH10K_HTC_WAIT_TIMEOUT_HZ); 935 936 if (!time_left) 937 status = -ETIMEDOUT; 938 } 939 940 if (status < 0) { 941 ath10k_err(ar, "ctl_resp never came in (%d)\n", status); 942 return status; 943 } 944 945 if (htc->control_resp_len < sizeof(msg->hdr) + sizeof(msg->ready)) { 946 ath10k_err(ar, "Invalid HTC ready msg len:%d\n", 947 htc->control_resp_len); 948 return -ECOMM; 949 } 950 951 msg = (struct ath10k_htc_msg *)htc->control_resp_buffer; 952 message_id = __le16_to_cpu(msg->hdr.message_id); 953 954 if (message_id != ATH10K_HTC_MSG_READY_ID) { 955 ath10k_err(ar, "Invalid HTC ready msg: 0x%x\n", message_id); 956 return -ECOMM; 957 } 958 959 if (ar->hw_params.use_fw_tx_credits) 960 htc->total_transmit_credits = __le16_to_cpu(msg->ready.credit_count); 961 else 962 htc->total_transmit_credits = 1; 963 964 htc->target_credit_size = __le16_to_cpu(msg->ready.credit_size); 965 966 ath10k_dbg(ar, ATH10K_DBG_HTC, 967 "Target ready! transmit resources: %d size:%d actual credits:%d\n", 968 htc->total_transmit_credits, 969 htc->target_credit_size, 970 msg->ready.credit_count); 971 972 if ((htc->total_transmit_credits == 0) || 973 (htc->target_credit_size == 0)) { 974 ath10k_err(ar, "Invalid credit size received\n"); 975 return -ECOMM; 976 } 977 978 /* The only way to determine if the ready message is an extended 979 * message is from the size. 980 */ 981 if (htc->control_resp_len >= 982 sizeof(msg->hdr) + sizeof(msg->ready_ext)) { 983 htc->alt_data_credit_size = 984 __le16_to_cpu(msg->ready_ext.reserved) & 985 ATH10K_HTC_MSG_READY_EXT_ALT_DATA_MASK; 986 htc->max_msgs_per_htc_bundle = 987 min_t(u8, msg->ready_ext.max_msgs_per_htc_bundle, 988 HTC_HOST_MAX_MSG_PER_RX_BUNDLE); 989 ath10k_dbg(ar, ATH10K_DBG_HTC, 990 "Extended ready message RX bundle size %d alt size %d\n", 991 htc->max_msgs_per_htc_bundle, 992 htc->alt_data_credit_size); 993 } 994 995 INIT_WORK(&ar->bundle_tx_work, ath10k_htc_bundle_tx_work); 996 INIT_WORK(&ar->tx_complete_work, ath10k_htc_tx_complete_work); 997 998 return 0; 999 } 1000 1001 void ath10k_htc_change_tx_credit_flow(struct ath10k_htc *htc, 1002 enum ath10k_htc_ep_id eid, 1003 bool enable) 1004 { 1005 struct ath10k *ar = htc->ar; 1006 struct ath10k_htc_ep *ep = &ar->htc.endpoint[eid]; 1007 1008 ep->tx_credit_flow_enabled = enable; 1009 } 1010 1011 int ath10k_htc_connect_service(struct ath10k_htc *htc, 1012 struct ath10k_htc_svc_conn_req *conn_req, 1013 struct ath10k_htc_svc_conn_resp *conn_resp) 1014 { 1015 struct ath10k *ar = htc->ar; 1016 struct ath10k_htc_msg *msg; 1017 struct ath10k_htc_conn_svc *req_msg; 1018 struct ath10k_htc_conn_svc_response resp_msg_dummy; 1019 struct ath10k_htc_conn_svc_response *resp_msg = &resp_msg_dummy; 1020 enum ath10k_htc_ep_id assigned_eid = ATH10K_HTC_EP_COUNT; 1021 struct ath10k_htc_ep *ep; 1022 struct sk_buff *skb; 1023 unsigned int max_msg_size = 0; 1024 int length, status; 1025 unsigned long time_left; 1026 bool disable_credit_flow_ctrl = false; 1027 u16 message_id, service_id, flags = 0; 1028 u8 tx_alloc = 0; 1029 1030 /* special case for HTC pseudo control service */ 1031 if (conn_req->service_id == ATH10K_HTC_SVC_ID_RSVD_CTRL) { 1032 disable_credit_flow_ctrl = true; 1033 assigned_eid = ATH10K_HTC_EP_0; 1034 max_msg_size = ATH10K_HTC_MAX_CTRL_MSG_LEN; 1035 memset(&resp_msg_dummy, 0, sizeof(resp_msg_dummy)); 1036 goto setup; 1037 } 1038 1039 tx_alloc = ath10k_htc_get_credit_allocation(htc, 1040 conn_req->service_id); 1041 if (!tx_alloc) 1042 ath10k_dbg(ar, ATH10K_DBG_BOOT, 1043 "boot htc service %s does not allocate target credits\n", 1044 htc_service_name(conn_req->service_id)); 1045 1046 skb = ath10k_htc_build_tx_ctrl_skb(htc->ar); 1047 if (!skb) { 1048 ath10k_err(ar, "Failed to allocate HTC packet\n"); 1049 return -ENOMEM; 1050 } 1051 1052 length = sizeof(msg->hdr) + sizeof(msg->connect_service); 1053 skb_put(skb, length); 1054 memset(skb->data, 0, length); 1055 1056 msg = (struct ath10k_htc_msg *)skb->data; 1057 msg->hdr.message_id = 1058 __cpu_to_le16(ATH10K_HTC_MSG_CONNECT_SERVICE_ID); 1059 1060 flags |= SM(tx_alloc, ATH10K_HTC_CONN_FLAGS_RECV_ALLOC); 1061 1062 /* Only enable credit flow control for WMI ctrl service */ 1063 if (conn_req->service_id != ATH10K_HTC_SVC_ID_WMI_CONTROL) { 1064 flags |= ATH10K_HTC_CONN_FLAGS_DISABLE_CREDIT_FLOW_CTRL; 1065 disable_credit_flow_ctrl = true; 1066 } 1067 1068 req_msg = &msg->connect_service; 1069 req_msg->flags = __cpu_to_le16(flags); 1070 req_msg->service_id = __cpu_to_le16(conn_req->service_id); 1071 1072 reinit_completion(&htc->ctl_resp); 1073 1074 status = ath10k_htc_send(htc, ATH10K_HTC_EP_0, skb); 1075 if (status) { 1076 kfree_skb(skb); 1077 return status; 1078 } 1079 1080 /* wait for response */ 1081 time_left = wait_for_completion_timeout(&htc->ctl_resp, 1082 ATH10K_HTC_CONN_SVC_TIMEOUT_HZ); 1083 if (!time_left) { 1084 ath10k_err(ar, "Service connect timeout\n"); 1085 return -ETIMEDOUT; 1086 } 1087 1088 /* we controlled the buffer creation, it's aligned */ 1089 msg = (struct ath10k_htc_msg *)htc->control_resp_buffer; 1090 resp_msg = &msg->connect_service_response; 1091 message_id = __le16_to_cpu(msg->hdr.message_id); 1092 service_id = __le16_to_cpu(resp_msg->service_id); 1093 1094 if ((message_id != ATH10K_HTC_MSG_CONNECT_SERVICE_RESP_ID) || 1095 (htc->control_resp_len < sizeof(msg->hdr) + 1096 sizeof(msg->connect_service_response))) { 1097 ath10k_err(ar, "Invalid resp message ID 0x%x", message_id); 1098 return -EPROTO; 1099 } 1100 1101 ath10k_dbg(ar, ATH10K_DBG_HTC, 1102 "HTC Service %s connect response: status: 0x%x, assigned ep: 0x%x\n", 1103 htc_service_name(service_id), 1104 resp_msg->status, resp_msg->eid); 1105 1106 conn_resp->connect_resp_code = resp_msg->status; 1107 1108 /* check response status */ 1109 if (resp_msg->status != ATH10K_HTC_CONN_SVC_STATUS_SUCCESS) { 1110 ath10k_err(ar, "HTC Service %s connect request failed: 0x%x)\n", 1111 htc_service_name(service_id), 1112 resp_msg->status); 1113 return -EPROTO; 1114 } 1115 1116 assigned_eid = (enum ath10k_htc_ep_id)resp_msg->eid; 1117 max_msg_size = __le16_to_cpu(resp_msg->max_msg_size); 1118 1119 setup: 1120 1121 if (assigned_eid >= ATH10K_HTC_EP_COUNT) 1122 return -EPROTO; 1123 1124 if (max_msg_size == 0) 1125 return -EPROTO; 1126 1127 ep = &htc->endpoint[assigned_eid]; 1128 ep->eid = assigned_eid; 1129 1130 if (ep->service_id != ATH10K_HTC_SVC_ID_UNUSED) 1131 return -EPROTO; 1132 1133 /* return assigned endpoint to caller */ 1134 conn_resp->eid = assigned_eid; 1135 conn_resp->max_msg_len = __le16_to_cpu(resp_msg->max_msg_size); 1136 1137 /* setup the endpoint */ 1138 ep->service_id = conn_req->service_id; 1139 ep->max_tx_queue_depth = conn_req->max_send_queue_depth; 1140 ep->max_ep_message_len = __le16_to_cpu(resp_msg->max_msg_size); 1141 ep->tx_credits = tx_alloc; 1142 ep->tx_credit_size = htc->target_credit_size; 1143 1144 if (conn_req->service_id == ATH10K_HTC_SVC_ID_HTT_DATA_MSG && 1145 htc->alt_data_credit_size != 0) 1146 ep->tx_credit_size = htc->alt_data_credit_size; 1147 1148 /* copy all the callbacks */ 1149 ep->ep_ops = conn_req->ep_ops; 1150 1151 status = ath10k_hif_map_service_to_pipe(htc->ar, 1152 ep->service_id, 1153 &ep->ul_pipe_id, 1154 &ep->dl_pipe_id); 1155 if (status) { 1156 ath10k_dbg(ar, ATH10K_DBG_BOOT, "unsupported HTC service id: %d\n", 1157 ep->service_id); 1158 return status; 1159 } 1160 1161 ath10k_dbg(ar, ATH10K_DBG_BOOT, 1162 "boot htc service '%s' ul pipe %d dl pipe %d eid %d ready\n", 1163 htc_service_name(ep->service_id), ep->ul_pipe_id, 1164 ep->dl_pipe_id, ep->eid); 1165 1166 if (disable_credit_flow_ctrl && ep->tx_credit_flow_enabled) { 1167 ep->tx_credit_flow_enabled = false; 1168 ath10k_dbg(ar, ATH10K_DBG_BOOT, 1169 "boot htc service '%s' eid %d TX flow control disabled\n", 1170 htc_service_name(ep->service_id), assigned_eid); 1171 } 1172 1173 return status; 1174 } 1175 1176 struct sk_buff *ath10k_htc_alloc_skb(struct ath10k *ar, int size) 1177 { 1178 struct sk_buff *skb; 1179 1180 skb = dev_alloc_skb(size + sizeof(struct ath10k_htc_hdr)); 1181 if (!skb) 1182 return NULL; 1183 1184 skb_reserve(skb, sizeof(struct ath10k_htc_hdr)); 1185 1186 /* FW/HTC requires 4-byte aligned streams */ 1187 if (!IS_ALIGNED((unsigned long)skb->data, 4)) 1188 ath10k_warn(ar, "Unaligned HTC tx skb\n"); 1189 1190 return skb; 1191 } 1192 1193 static void ath10k_htc_pktlog_process_rx(struct ath10k *ar, struct sk_buff *skb) 1194 { 1195 trace_ath10k_htt_pktlog(ar, skb->data, skb->len); 1196 dev_kfree_skb_any(skb); 1197 } 1198 1199 static int ath10k_htc_pktlog_connect(struct ath10k *ar) 1200 { 1201 struct ath10k_htc_svc_conn_resp conn_resp; 1202 struct ath10k_htc_svc_conn_req conn_req; 1203 int status; 1204 1205 memset(&conn_req, 0, sizeof(conn_req)); 1206 memset(&conn_resp, 0, sizeof(conn_resp)); 1207 1208 conn_req.ep_ops.ep_tx_complete = NULL; 1209 conn_req.ep_ops.ep_rx_complete = ath10k_htc_pktlog_process_rx; 1210 conn_req.ep_ops.ep_tx_credits = NULL; 1211 1212 /* connect to control service */ 1213 conn_req.service_id = ATH10K_HTC_SVC_ID_HTT_LOG_MSG; 1214 status = ath10k_htc_connect_service(&ar->htc, &conn_req, &conn_resp); 1215 if (status) { 1216 ath10k_warn(ar, "failed to connect to PKTLOG service: %d\n", 1217 status); 1218 return status; 1219 } 1220 1221 return 0; 1222 } 1223 1224 static bool ath10k_htc_pktlog_svc_supported(struct ath10k *ar) 1225 { 1226 u8 ul_pipe_id; 1227 u8 dl_pipe_id; 1228 int status; 1229 1230 status = ath10k_hif_map_service_to_pipe(ar, ATH10K_HTC_SVC_ID_HTT_LOG_MSG, 1231 &ul_pipe_id, 1232 &dl_pipe_id); 1233 if (status) { 1234 ath10k_dbg(ar, ATH10K_DBG_BOOT, "unsupported HTC pktlog service id: %d\n", 1235 ATH10K_HTC_SVC_ID_HTT_LOG_MSG); 1236 1237 return false; 1238 } 1239 1240 return true; 1241 } 1242 1243 int ath10k_htc_start(struct ath10k_htc *htc) 1244 { 1245 struct ath10k *ar = htc->ar; 1246 struct sk_buff *skb; 1247 int status = 0; 1248 struct ath10k_htc_msg *msg; 1249 1250 skb = ath10k_htc_build_tx_ctrl_skb(htc->ar); 1251 if (!skb) 1252 return -ENOMEM; 1253 1254 skb_put(skb, sizeof(msg->hdr) + sizeof(msg->setup_complete_ext)); 1255 memset(skb->data, 0, skb->len); 1256 1257 msg = (struct ath10k_htc_msg *)skb->data; 1258 msg->hdr.message_id = 1259 __cpu_to_le16(ATH10K_HTC_MSG_SETUP_COMPLETE_EX_ID); 1260 1261 if (ar->hif.bus == ATH10K_BUS_SDIO) { 1262 /* Extra setup params used by SDIO */ 1263 msg->setup_complete_ext.flags = 1264 __cpu_to_le32(ATH10K_HTC_SETUP_COMPLETE_FLAGS_RX_BNDL_EN); 1265 msg->setup_complete_ext.max_msgs_per_bundled_recv = 1266 htc->max_msgs_per_htc_bundle; 1267 } 1268 ath10k_dbg(ar, ATH10K_DBG_HTC, "HTC is using TX credit flow control\n"); 1269 1270 status = ath10k_htc_send(htc, ATH10K_HTC_EP_0, skb); 1271 if (status) { 1272 kfree_skb(skb); 1273 return status; 1274 } 1275 1276 if (ath10k_htc_pktlog_svc_supported(ar)) { 1277 status = ath10k_htc_pktlog_connect(ar); 1278 if (status) { 1279 ath10k_err(ar, "failed to connect to pktlog: %d\n", status); 1280 return status; 1281 } 1282 } 1283 1284 return 0; 1285 } 1286 1287 /* registered target arrival callback from the HIF layer */ 1288 int ath10k_htc_init(struct ath10k *ar) 1289 { 1290 int status; 1291 struct ath10k_htc *htc = &ar->htc; 1292 struct ath10k_htc_svc_conn_req conn_req; 1293 struct ath10k_htc_svc_conn_resp conn_resp; 1294 1295 spin_lock_init(&htc->tx_lock); 1296 1297 ath10k_htc_reset_endpoint_states(htc); 1298 1299 htc->ar = ar; 1300 1301 /* setup our pseudo HTC control endpoint connection */ 1302 memset(&conn_req, 0, sizeof(conn_req)); 1303 memset(&conn_resp, 0, sizeof(conn_resp)); 1304 conn_req.ep_ops.ep_tx_complete = ath10k_htc_control_tx_complete; 1305 conn_req.ep_ops.ep_rx_complete = ath10k_htc_control_rx_complete; 1306 conn_req.max_send_queue_depth = ATH10K_NUM_CONTROL_TX_BUFFERS; 1307 conn_req.service_id = ATH10K_HTC_SVC_ID_RSVD_CTRL; 1308 1309 /* connect fake service */ 1310 status = ath10k_htc_connect_service(htc, &conn_req, &conn_resp); 1311 if (status) { 1312 ath10k_err(ar, "could not connect to htc service (%d)\n", 1313 status); 1314 return status; 1315 } 1316 1317 init_completion(&htc->ctl_resp); 1318 1319 return 0; 1320 } 1321