1 // SPDX-License-Identifier: BSD-3-Clause-Clear 2 /* 3 * Copyright (c) 2018-2019 The Linux Foundation. All rights reserved. 4 */ 5 6 #include "dp_rx.h" 7 #include "debug.h" 8 #include "hif.h" 9 10 const struct ce_attr ath11k_host_ce_config_ipq8074[] = { 11 /* CE0: host->target HTC control and raw streams */ 12 { 13 .flags = CE_ATTR_FLAGS, 14 .src_nentries = 16, 15 .src_sz_max = 2048, 16 .dest_nentries = 0, 17 .send_cb = ath11k_htc_tx_completion_handler, 18 }, 19 20 /* CE1: target->host HTT + HTC control */ 21 { 22 .flags = CE_ATTR_FLAGS, 23 .src_nentries = 0, 24 .src_sz_max = 2048, 25 .dest_nentries = 512, 26 .recv_cb = ath11k_htc_rx_completion_handler, 27 }, 28 29 /* CE2: target->host WMI */ 30 { 31 .flags = CE_ATTR_FLAGS, 32 .src_nentries = 0, 33 .src_sz_max = 2048, 34 .dest_nentries = 512, 35 .recv_cb = ath11k_htc_rx_completion_handler, 36 }, 37 38 /* CE3: host->target WMI (mac0) */ 39 { 40 .flags = CE_ATTR_FLAGS, 41 .src_nentries = 32, 42 .src_sz_max = 2048, 43 .dest_nentries = 0, 44 .send_cb = ath11k_htc_tx_completion_handler, 45 }, 46 47 /* CE4: host->target HTT */ 48 { 49 .flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR, 50 .src_nentries = 2048, 51 .src_sz_max = 256, 52 .dest_nentries = 0, 53 }, 54 55 /* CE5: target->host pktlog */ 56 { 57 .flags = CE_ATTR_FLAGS, 58 .src_nentries = 0, 59 .src_sz_max = 2048, 60 .dest_nentries = 512, 61 .recv_cb = ath11k_dp_htt_htc_t2h_msg_handler, 62 }, 63 64 /* CE6: target autonomous hif_memcpy */ 65 { 66 .flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR, 67 .src_nentries = 0, 68 .src_sz_max = 0, 69 .dest_nentries = 0, 70 }, 71 72 /* CE7: host->target WMI (mac1) */ 73 { 74 .flags = CE_ATTR_FLAGS, 75 .src_nentries = 32, 76 .src_sz_max = 2048, 77 .dest_nentries = 0, 78 .send_cb = ath11k_htc_tx_completion_handler, 79 }, 80 81 /* CE8: target autonomous hif_memcpy */ 82 { 83 .flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR, 84 .src_nentries = 0, 85 .src_sz_max = 0, 86 .dest_nentries = 0, 87 }, 88 89 /* CE9: host->target WMI (mac2) */ 90 { 91 .flags = CE_ATTR_FLAGS, 92 .src_nentries = 32, 93 .src_sz_max = 2048, 94 .dest_nentries = 0, 95 .send_cb = ath11k_htc_tx_completion_handler, 96 }, 97 98 /* CE10: target->host HTT */ 99 { 100 .flags = CE_ATTR_FLAGS, 101 .src_nentries = 0, 102 .src_sz_max = 2048, 103 .dest_nentries = 512, 104 .recv_cb = ath11k_htc_rx_completion_handler, 105 }, 106 107 /* CE11: Not used */ 108 { 109 .flags = CE_ATTR_FLAGS, 110 .src_nentries = 0, 111 .src_sz_max = 0, 112 .dest_nentries = 0, 113 }, 114 }; 115 116 const struct ce_attr ath11k_host_ce_config_qca6390[] = { 117 /* CE0: host->target HTC control and raw streams */ 118 { 119 .flags = CE_ATTR_FLAGS, 120 .src_nentries = 16, 121 .src_sz_max = 2048, 122 .dest_nentries = 0, 123 }, 124 125 /* CE1: target->host HTT + HTC control */ 126 { 127 .flags = CE_ATTR_FLAGS, 128 .src_nentries = 0, 129 .src_sz_max = 2048, 130 .dest_nentries = 512, 131 .recv_cb = ath11k_htc_rx_completion_handler, 132 }, 133 134 /* CE2: target->host WMI */ 135 { 136 .flags = CE_ATTR_FLAGS, 137 .src_nentries = 0, 138 .src_sz_max = 2048, 139 .dest_nentries = 512, 140 .recv_cb = ath11k_htc_rx_completion_handler, 141 }, 142 143 /* CE3: host->target WMI (mac0) */ 144 { 145 .flags = CE_ATTR_FLAGS, 146 .src_nentries = 32, 147 .src_sz_max = 2048, 148 .dest_nentries = 0, 149 .send_cb = ath11k_htc_tx_completion_handler, 150 }, 151 152 /* CE4: host->target HTT */ 153 { 154 .flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR, 155 .src_nentries = 2048, 156 .src_sz_max = 256, 157 .dest_nentries = 0, 158 }, 159 160 /* CE5: target->host pktlog */ 161 { 162 .flags = CE_ATTR_FLAGS, 163 .src_nentries = 0, 164 .src_sz_max = 2048, 165 .dest_nentries = 512, 166 .recv_cb = ath11k_dp_htt_htc_t2h_msg_handler, 167 }, 168 169 /* CE6: target autonomous hif_memcpy */ 170 { 171 .flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR, 172 .src_nentries = 0, 173 .src_sz_max = 0, 174 .dest_nentries = 0, 175 }, 176 177 /* CE7: host->target WMI (mac1) */ 178 { 179 .flags = CE_ATTR_FLAGS, 180 .src_nentries = 32, 181 .src_sz_max = 2048, 182 .dest_nentries = 0, 183 .send_cb = ath11k_htc_tx_completion_handler, 184 }, 185 186 /* CE8: target autonomous hif_memcpy */ 187 { 188 .flags = CE_ATTR_FLAGS, 189 .src_nentries = 0, 190 .src_sz_max = 0, 191 .dest_nentries = 0, 192 }, 193 194 }; 195 196 const struct ce_attr ath11k_host_ce_config_qcn9074[] = { 197 /* CE0: host->target HTC control and raw streams */ 198 { 199 .flags = CE_ATTR_FLAGS, 200 .src_nentries = 16, 201 .src_sz_max = 2048, 202 .dest_nentries = 0, 203 }, 204 205 /* CE1: target->host HTT + HTC control */ 206 { 207 .flags = CE_ATTR_FLAGS, 208 .src_nentries = 0, 209 .src_sz_max = 2048, 210 .dest_nentries = 512, 211 .recv_cb = ath11k_htc_rx_completion_handler, 212 }, 213 214 /* CE2: target->host WMI */ 215 { 216 .flags = CE_ATTR_FLAGS, 217 .src_nentries = 0, 218 .src_sz_max = 2048, 219 .dest_nentries = 32, 220 .recv_cb = ath11k_htc_rx_completion_handler, 221 }, 222 223 /* CE3: host->target WMI (mac0) */ 224 { 225 .flags = CE_ATTR_FLAGS, 226 .src_nentries = 32, 227 .src_sz_max = 2048, 228 .dest_nentries = 0, 229 .send_cb = ath11k_htc_tx_completion_handler, 230 }, 231 232 /* CE4: host->target HTT */ 233 { 234 .flags = CE_ATTR_FLAGS | CE_ATTR_DIS_INTR, 235 .src_nentries = 2048, 236 .src_sz_max = 256, 237 .dest_nentries = 0, 238 }, 239 240 /* CE5: target->host pktlog */ 241 { 242 .flags = CE_ATTR_FLAGS, 243 .src_nentries = 0, 244 .src_sz_max = 2048, 245 .dest_nentries = 512, 246 .recv_cb = ath11k_dp_htt_htc_t2h_msg_handler, 247 }, 248 }; 249 250 static bool ath11k_ce_need_shadow_fix(int ce_id) 251 { 252 /* only ce4 needs shadow workaroud*/ 253 if (ce_id == 4) 254 return true; 255 return false; 256 } 257 258 void ath11k_ce_stop_shadow_timers(struct ath11k_base *ab) 259 { 260 int i; 261 262 if (!ab->hw_params.supports_shadow_regs) 263 return; 264 265 for (i = 0; i < ab->hw_params.ce_count; i++) 266 if (ath11k_ce_need_shadow_fix(i)) 267 ath11k_dp_shadow_stop_timer(ab, &ab->ce.hp_timer[i]); 268 } 269 270 static int ath11k_ce_rx_buf_enqueue_pipe(struct ath11k_ce_pipe *pipe, 271 struct sk_buff *skb, dma_addr_t paddr) 272 { 273 struct ath11k_base *ab = pipe->ab; 274 struct ath11k_ce_ring *ring = pipe->dest_ring; 275 struct hal_srng *srng; 276 unsigned int write_index; 277 unsigned int nentries_mask = ring->nentries_mask; 278 u32 *desc; 279 int ret; 280 281 lockdep_assert_held(&ab->ce.ce_lock); 282 283 write_index = ring->write_index; 284 285 srng = &ab->hal.srng_list[ring->hal_ring_id]; 286 287 spin_lock_bh(&srng->lock); 288 289 ath11k_hal_srng_access_begin(ab, srng); 290 291 if (unlikely(ath11k_hal_srng_src_num_free(ab, srng, false) < 1)) { 292 ret = -ENOSPC; 293 goto exit; 294 } 295 296 desc = ath11k_hal_srng_src_get_next_entry(ab, srng); 297 if (!desc) { 298 ret = -ENOSPC; 299 goto exit; 300 } 301 302 ath11k_hal_ce_dst_set_desc(desc, paddr); 303 304 ring->skb[write_index] = skb; 305 write_index = CE_RING_IDX_INCR(nentries_mask, write_index); 306 ring->write_index = write_index; 307 308 pipe->rx_buf_needed--; 309 310 ret = 0; 311 exit: 312 ath11k_hal_srng_access_end(ab, srng); 313 314 spin_unlock_bh(&srng->lock); 315 316 return ret; 317 } 318 319 static int ath11k_ce_rx_post_pipe(struct ath11k_ce_pipe *pipe) 320 { 321 struct ath11k_base *ab = pipe->ab; 322 struct sk_buff *skb; 323 dma_addr_t paddr; 324 int ret = 0; 325 326 if (!(pipe->dest_ring || pipe->status_ring)) 327 return 0; 328 329 spin_lock_bh(&ab->ce.ce_lock); 330 while (pipe->rx_buf_needed) { 331 skb = dev_alloc_skb(pipe->buf_sz); 332 if (!skb) { 333 ret = -ENOMEM; 334 goto exit; 335 } 336 337 WARN_ON_ONCE(!IS_ALIGNED((unsigned long)skb->data, 4)); 338 339 paddr = dma_map_single(ab->dev, skb->data, 340 skb->len + skb_tailroom(skb), 341 DMA_FROM_DEVICE); 342 if (unlikely(dma_mapping_error(ab->dev, paddr))) { 343 ath11k_warn(ab, "failed to dma map ce rx buf\n"); 344 dev_kfree_skb_any(skb); 345 ret = -EIO; 346 goto exit; 347 } 348 349 ATH11K_SKB_RXCB(skb)->paddr = paddr; 350 351 ret = ath11k_ce_rx_buf_enqueue_pipe(pipe, skb, paddr); 352 353 if (ret) { 354 ath11k_warn(ab, "failed to enqueue rx buf: %d\n", ret); 355 dma_unmap_single(ab->dev, paddr, 356 skb->len + skb_tailroom(skb), 357 DMA_FROM_DEVICE); 358 dev_kfree_skb_any(skb); 359 goto exit; 360 } 361 } 362 363 exit: 364 spin_unlock_bh(&ab->ce.ce_lock); 365 return ret; 366 } 367 368 static int ath11k_ce_completed_recv_next(struct ath11k_ce_pipe *pipe, 369 struct sk_buff **skb, int *nbytes) 370 { 371 struct ath11k_base *ab = pipe->ab; 372 struct hal_srng *srng; 373 unsigned int sw_index; 374 unsigned int nentries_mask; 375 u32 *desc; 376 int ret = 0; 377 378 spin_lock_bh(&ab->ce.ce_lock); 379 380 sw_index = pipe->dest_ring->sw_index; 381 nentries_mask = pipe->dest_ring->nentries_mask; 382 383 srng = &ab->hal.srng_list[pipe->status_ring->hal_ring_id]; 384 385 spin_lock_bh(&srng->lock); 386 387 ath11k_hal_srng_access_begin(ab, srng); 388 389 desc = ath11k_hal_srng_dst_get_next_entry(ab, srng); 390 if (!desc) { 391 ret = -EIO; 392 goto err; 393 } 394 395 *nbytes = ath11k_hal_ce_dst_status_get_length(desc); 396 if (*nbytes == 0) { 397 ret = -EIO; 398 goto err; 399 } 400 401 *skb = pipe->dest_ring->skb[sw_index]; 402 pipe->dest_ring->skb[sw_index] = NULL; 403 404 sw_index = CE_RING_IDX_INCR(nentries_mask, sw_index); 405 pipe->dest_ring->sw_index = sw_index; 406 407 pipe->rx_buf_needed++; 408 err: 409 ath11k_hal_srng_access_end(ab, srng); 410 411 spin_unlock_bh(&srng->lock); 412 413 spin_unlock_bh(&ab->ce.ce_lock); 414 415 return ret; 416 } 417 418 static void ath11k_ce_recv_process_cb(struct ath11k_ce_pipe *pipe) 419 { 420 struct ath11k_base *ab = pipe->ab; 421 struct sk_buff *skb; 422 struct sk_buff_head list; 423 unsigned int nbytes, max_nbytes; 424 int ret; 425 426 __skb_queue_head_init(&list); 427 while (ath11k_ce_completed_recv_next(pipe, &skb, &nbytes) == 0) { 428 max_nbytes = skb->len + skb_tailroom(skb); 429 dma_unmap_single(ab->dev, ATH11K_SKB_RXCB(skb)->paddr, 430 max_nbytes, DMA_FROM_DEVICE); 431 432 if (unlikely(max_nbytes < nbytes)) { 433 ath11k_warn(ab, "rxed more than expected (nbytes %d, max %d)", 434 nbytes, max_nbytes); 435 dev_kfree_skb_any(skb); 436 continue; 437 } 438 439 skb_put(skb, nbytes); 440 __skb_queue_tail(&list, skb); 441 } 442 443 while ((skb = __skb_dequeue(&list))) { 444 ath11k_dbg(ab, ATH11K_DBG_AHB, "rx ce pipe %d len %d\n", 445 pipe->pipe_num, skb->len); 446 pipe->recv_cb(ab, skb); 447 } 448 449 ret = ath11k_ce_rx_post_pipe(pipe); 450 if (ret && ret != -ENOSPC) { 451 ath11k_warn(ab, "failed to post rx buf to pipe: %d err: %d\n", 452 pipe->pipe_num, ret); 453 mod_timer(&ab->rx_replenish_retry, 454 jiffies + ATH11K_CE_RX_POST_RETRY_JIFFIES); 455 } 456 } 457 458 static struct sk_buff *ath11k_ce_completed_send_next(struct ath11k_ce_pipe *pipe) 459 { 460 struct ath11k_base *ab = pipe->ab; 461 struct hal_srng *srng; 462 unsigned int sw_index; 463 unsigned int nentries_mask; 464 struct sk_buff *skb; 465 u32 *desc; 466 467 spin_lock_bh(&ab->ce.ce_lock); 468 469 sw_index = pipe->src_ring->sw_index; 470 nentries_mask = pipe->src_ring->nentries_mask; 471 472 srng = &ab->hal.srng_list[pipe->src_ring->hal_ring_id]; 473 474 spin_lock_bh(&srng->lock); 475 476 ath11k_hal_srng_access_begin(ab, srng); 477 478 desc = ath11k_hal_srng_src_reap_next(ab, srng); 479 if (!desc) { 480 skb = ERR_PTR(-EIO); 481 goto err_unlock; 482 } 483 484 skb = pipe->src_ring->skb[sw_index]; 485 486 pipe->src_ring->skb[sw_index] = NULL; 487 488 sw_index = CE_RING_IDX_INCR(nentries_mask, sw_index); 489 pipe->src_ring->sw_index = sw_index; 490 491 err_unlock: 492 spin_unlock_bh(&srng->lock); 493 494 spin_unlock_bh(&ab->ce.ce_lock); 495 496 return skb; 497 } 498 499 static void ath11k_ce_tx_process_cb(struct ath11k_ce_pipe *pipe) 500 { 501 struct ath11k_base *ab = pipe->ab; 502 struct sk_buff *skb; 503 struct sk_buff_head list; 504 505 __skb_queue_head_init(&list); 506 while (!IS_ERR(skb = ath11k_ce_completed_send_next(pipe))) { 507 if (!skb) 508 continue; 509 510 dma_unmap_single(ab->dev, ATH11K_SKB_CB(skb)->paddr, skb->len, 511 DMA_TO_DEVICE); 512 513 if ((!pipe->send_cb) || ab->hw_params.credit_flow) { 514 dev_kfree_skb_any(skb); 515 continue; 516 } 517 518 __skb_queue_tail(&list, skb); 519 } 520 521 while ((skb = __skb_dequeue(&list))) { 522 ath11k_dbg(ab, ATH11K_DBG_AHB, "tx ce pipe %d len %d\n", 523 pipe->pipe_num, skb->len); 524 pipe->send_cb(ab, skb); 525 } 526 } 527 528 static void ath11k_ce_srng_msi_ring_params_setup(struct ath11k_base *ab, u32 ce_id, 529 struct hal_srng_params *ring_params) 530 { 531 u32 msi_data_start; 532 u32 msi_data_count, msi_data_idx; 533 u32 msi_irq_start; 534 u32 addr_lo; 535 u32 addr_hi; 536 int ret; 537 538 ret = ath11k_get_user_msi_vector(ab, "CE", 539 &msi_data_count, &msi_data_start, 540 &msi_irq_start); 541 542 if (ret) 543 return; 544 545 ath11k_get_msi_address(ab, &addr_lo, &addr_hi); 546 ath11k_get_ce_msi_idx(ab, ce_id, &msi_data_idx); 547 548 ring_params->msi_addr = addr_lo; 549 ring_params->msi_addr |= (dma_addr_t)(((uint64_t)addr_hi) << 32); 550 ring_params->msi_data = (msi_data_idx % msi_data_count) + msi_data_start; 551 ring_params->flags |= HAL_SRNG_FLAGS_MSI_INTR; 552 } 553 554 static int ath11k_ce_init_ring(struct ath11k_base *ab, 555 struct ath11k_ce_ring *ce_ring, 556 int ce_id, enum hal_ring_type type) 557 { 558 struct hal_srng_params params = { 0 }; 559 int ret; 560 561 params.ring_base_paddr = ce_ring->base_addr_ce_space; 562 params.ring_base_vaddr = ce_ring->base_addr_owner_space; 563 params.num_entries = ce_ring->nentries; 564 565 if (!(CE_ATTR_DIS_INTR & ab->hw_params.host_ce_config[ce_id].flags)) 566 ath11k_ce_srng_msi_ring_params_setup(ab, ce_id, ¶ms); 567 568 switch (type) { 569 case HAL_CE_SRC: 570 if (!(CE_ATTR_DIS_INTR & ab->hw_params.host_ce_config[ce_id].flags)) 571 params.intr_batch_cntr_thres_entries = 1; 572 break; 573 case HAL_CE_DST: 574 params.max_buffer_len = ab->hw_params.host_ce_config[ce_id].src_sz_max; 575 if (!(ab->hw_params.host_ce_config[ce_id].flags & CE_ATTR_DIS_INTR)) { 576 params.intr_timer_thres_us = 1024; 577 params.flags |= HAL_SRNG_FLAGS_LOW_THRESH_INTR_EN; 578 params.low_threshold = ce_ring->nentries - 3; 579 } 580 break; 581 case HAL_CE_DST_STATUS: 582 if (!(ab->hw_params.host_ce_config[ce_id].flags & CE_ATTR_DIS_INTR)) { 583 params.intr_batch_cntr_thres_entries = 1; 584 params.intr_timer_thres_us = 0x1000; 585 } 586 break; 587 default: 588 ath11k_warn(ab, "Invalid CE ring type %d\n", type); 589 return -EINVAL; 590 } 591 592 /* TODO: Init other params needed by HAL to init the ring */ 593 594 ret = ath11k_hal_srng_setup(ab, type, ce_id, 0, ¶ms); 595 if (ret < 0) { 596 ath11k_warn(ab, "failed to setup srng: %d ring_id %d\n", 597 ret, ce_id); 598 return ret; 599 } 600 601 ce_ring->hal_ring_id = ret; 602 603 if (ab->hw_params.supports_shadow_regs && 604 ath11k_ce_need_shadow_fix(ce_id)) 605 ath11k_dp_shadow_init_timer(ab, &ab->ce.hp_timer[ce_id], 606 ATH11K_SHADOW_CTRL_TIMER_INTERVAL, 607 ce_ring->hal_ring_id); 608 609 return 0; 610 } 611 612 static struct ath11k_ce_ring * 613 ath11k_ce_alloc_ring(struct ath11k_base *ab, int nentries, int desc_sz) 614 { 615 struct ath11k_ce_ring *ce_ring; 616 dma_addr_t base_addr; 617 618 ce_ring = kzalloc(struct_size(ce_ring, skb, nentries), GFP_KERNEL); 619 if (ce_ring == NULL) 620 return ERR_PTR(-ENOMEM); 621 622 ce_ring->nentries = nentries; 623 ce_ring->nentries_mask = nentries - 1; 624 625 /* Legacy platforms that do not support cache 626 * coherent DMA are unsupported 627 */ 628 ce_ring->base_addr_owner_space_unaligned = 629 dma_alloc_coherent(ab->dev, 630 nentries * desc_sz + CE_DESC_RING_ALIGN, 631 &base_addr, GFP_KERNEL); 632 if (!ce_ring->base_addr_owner_space_unaligned) { 633 kfree(ce_ring); 634 return ERR_PTR(-ENOMEM); 635 } 636 637 ce_ring->base_addr_ce_space_unaligned = base_addr; 638 639 ce_ring->base_addr_owner_space = PTR_ALIGN( 640 ce_ring->base_addr_owner_space_unaligned, 641 CE_DESC_RING_ALIGN); 642 ce_ring->base_addr_ce_space = ALIGN( 643 ce_ring->base_addr_ce_space_unaligned, 644 CE_DESC_RING_ALIGN); 645 646 return ce_ring; 647 } 648 649 static int ath11k_ce_alloc_pipe(struct ath11k_base *ab, int ce_id) 650 { 651 struct ath11k_ce_pipe *pipe = &ab->ce.ce_pipe[ce_id]; 652 const struct ce_attr *attr = &ab->hw_params.host_ce_config[ce_id]; 653 struct ath11k_ce_ring *ring; 654 int nentries; 655 int desc_sz; 656 657 pipe->attr_flags = attr->flags; 658 659 if (attr->src_nentries) { 660 pipe->send_cb = attr->send_cb; 661 nentries = roundup_pow_of_two(attr->src_nentries); 662 desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_SRC); 663 ring = ath11k_ce_alloc_ring(ab, nentries, desc_sz); 664 if (IS_ERR(ring)) 665 return PTR_ERR(ring); 666 pipe->src_ring = ring; 667 } 668 669 if (attr->dest_nentries) { 670 pipe->recv_cb = attr->recv_cb; 671 nentries = roundup_pow_of_two(attr->dest_nentries); 672 desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_DST); 673 ring = ath11k_ce_alloc_ring(ab, nentries, desc_sz); 674 if (IS_ERR(ring)) 675 return PTR_ERR(ring); 676 pipe->dest_ring = ring; 677 678 desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_DST_STATUS); 679 ring = ath11k_ce_alloc_ring(ab, nentries, desc_sz); 680 if (IS_ERR(ring)) 681 return PTR_ERR(ring); 682 pipe->status_ring = ring; 683 } 684 685 return 0; 686 } 687 688 void ath11k_ce_per_engine_service(struct ath11k_base *ab, u16 ce_id) 689 { 690 struct ath11k_ce_pipe *pipe = &ab->ce.ce_pipe[ce_id]; 691 const struct ce_attr *attr = &ab->hw_params.host_ce_config[ce_id]; 692 693 if (attr->src_nentries) 694 ath11k_ce_tx_process_cb(pipe); 695 696 if (pipe->recv_cb) 697 ath11k_ce_recv_process_cb(pipe); 698 } 699 700 void ath11k_ce_poll_send_completed(struct ath11k_base *ab, u8 pipe_id) 701 { 702 struct ath11k_ce_pipe *pipe = &ab->ce.ce_pipe[pipe_id]; 703 const struct ce_attr *attr = &ab->hw_params.host_ce_config[pipe_id]; 704 705 if ((pipe->attr_flags & CE_ATTR_DIS_INTR) && attr->src_nentries) 706 ath11k_ce_tx_process_cb(pipe); 707 } 708 EXPORT_SYMBOL(ath11k_ce_per_engine_service); 709 710 int ath11k_ce_send(struct ath11k_base *ab, struct sk_buff *skb, u8 pipe_id, 711 u16 transfer_id) 712 { 713 struct ath11k_ce_pipe *pipe = &ab->ce.ce_pipe[pipe_id]; 714 struct hal_srng *srng; 715 u32 *desc; 716 unsigned int write_index, sw_index; 717 unsigned int nentries_mask; 718 int ret = 0; 719 u8 byte_swap_data = 0; 720 int num_used; 721 722 /* Check if some entries could be regained by handling tx completion if 723 * the CE has interrupts disabled and the used entries is more than the 724 * defined usage threshold. 725 */ 726 if (pipe->attr_flags & CE_ATTR_DIS_INTR) { 727 spin_lock_bh(&ab->ce.ce_lock); 728 write_index = pipe->src_ring->write_index; 729 730 sw_index = pipe->src_ring->sw_index; 731 732 if (write_index >= sw_index) 733 num_used = write_index - sw_index; 734 else 735 num_used = pipe->src_ring->nentries - sw_index + 736 write_index; 737 738 spin_unlock_bh(&ab->ce.ce_lock); 739 740 if (num_used > ATH11K_CE_USAGE_THRESHOLD) 741 ath11k_ce_poll_send_completed(ab, pipe->pipe_num); 742 } 743 744 if (test_bit(ATH11K_FLAG_CRASH_FLUSH, &ab->dev_flags)) 745 return -ESHUTDOWN; 746 747 spin_lock_bh(&ab->ce.ce_lock); 748 749 write_index = pipe->src_ring->write_index; 750 nentries_mask = pipe->src_ring->nentries_mask; 751 752 srng = &ab->hal.srng_list[pipe->src_ring->hal_ring_id]; 753 754 spin_lock_bh(&srng->lock); 755 756 ath11k_hal_srng_access_begin(ab, srng); 757 758 if (unlikely(ath11k_hal_srng_src_num_free(ab, srng, false) < 1)) { 759 ath11k_hal_srng_access_end(ab, srng); 760 ret = -ENOBUFS; 761 goto err_unlock; 762 } 763 764 desc = ath11k_hal_srng_src_get_next_reaped(ab, srng); 765 if (!desc) { 766 ath11k_hal_srng_access_end(ab, srng); 767 ret = -ENOBUFS; 768 goto err_unlock; 769 } 770 771 if (pipe->attr_flags & CE_ATTR_BYTE_SWAP_DATA) 772 byte_swap_data = 1; 773 774 ath11k_hal_ce_src_set_desc(desc, ATH11K_SKB_CB(skb)->paddr, 775 skb->len, transfer_id, byte_swap_data); 776 777 pipe->src_ring->skb[write_index] = skb; 778 pipe->src_ring->write_index = CE_RING_IDX_INCR(nentries_mask, 779 write_index); 780 781 ath11k_hal_srng_access_end(ab, srng); 782 783 if (ath11k_ce_need_shadow_fix(pipe_id)) 784 ath11k_dp_shadow_start_timer(ab, srng, &ab->ce.hp_timer[pipe_id]); 785 786 spin_unlock_bh(&srng->lock); 787 788 spin_unlock_bh(&ab->ce.ce_lock); 789 790 return 0; 791 792 err_unlock: 793 spin_unlock_bh(&srng->lock); 794 795 spin_unlock_bh(&ab->ce.ce_lock); 796 797 return ret; 798 } 799 800 static void ath11k_ce_rx_pipe_cleanup(struct ath11k_ce_pipe *pipe) 801 { 802 struct ath11k_base *ab = pipe->ab; 803 struct ath11k_ce_ring *ring = pipe->dest_ring; 804 struct sk_buff *skb; 805 int i; 806 807 if (!(ring && pipe->buf_sz)) 808 return; 809 810 for (i = 0; i < ring->nentries; i++) { 811 skb = ring->skb[i]; 812 if (!skb) 813 continue; 814 815 ring->skb[i] = NULL; 816 dma_unmap_single(ab->dev, ATH11K_SKB_RXCB(skb)->paddr, 817 skb->len + skb_tailroom(skb), DMA_FROM_DEVICE); 818 dev_kfree_skb_any(skb); 819 } 820 } 821 822 static void ath11k_ce_shadow_config(struct ath11k_base *ab) 823 { 824 int i; 825 826 for (i = 0; i < ab->hw_params.ce_count; i++) { 827 if (ab->hw_params.host_ce_config[i].src_nentries) 828 ath11k_hal_srng_update_shadow_config(ab, 829 HAL_CE_SRC, i); 830 831 if (ab->hw_params.host_ce_config[i].dest_nentries) { 832 ath11k_hal_srng_update_shadow_config(ab, 833 HAL_CE_DST, i); 834 835 ath11k_hal_srng_update_shadow_config(ab, 836 HAL_CE_DST_STATUS, i); 837 } 838 } 839 } 840 841 void ath11k_ce_get_shadow_config(struct ath11k_base *ab, 842 u32 **shadow_cfg, u32 *shadow_cfg_len) 843 { 844 if (!ab->hw_params.supports_shadow_regs) 845 return; 846 847 ath11k_hal_srng_get_shadow_config(ab, shadow_cfg, shadow_cfg_len); 848 849 /* shadow is already configured */ 850 if (*shadow_cfg_len) 851 return; 852 853 /* shadow isn't configured yet, configure now. 854 * non-CE srngs are configured firstly, then 855 * all CE srngs. 856 */ 857 ath11k_hal_srng_shadow_config(ab); 858 ath11k_ce_shadow_config(ab); 859 860 /* get the shadow configuration */ 861 ath11k_hal_srng_get_shadow_config(ab, shadow_cfg, shadow_cfg_len); 862 } 863 EXPORT_SYMBOL(ath11k_ce_get_shadow_config); 864 865 void ath11k_ce_cleanup_pipes(struct ath11k_base *ab) 866 { 867 struct ath11k_ce_pipe *pipe; 868 int pipe_num; 869 870 ath11k_ce_stop_shadow_timers(ab); 871 872 for (pipe_num = 0; pipe_num < ab->hw_params.ce_count; pipe_num++) { 873 pipe = &ab->ce.ce_pipe[pipe_num]; 874 ath11k_ce_rx_pipe_cleanup(pipe); 875 876 /* Cleanup any src CE's which have interrupts disabled */ 877 ath11k_ce_poll_send_completed(ab, pipe_num); 878 879 /* NOTE: Should we also clean up tx buffer in all pipes? */ 880 } 881 } 882 EXPORT_SYMBOL(ath11k_ce_cleanup_pipes); 883 884 void ath11k_ce_rx_post_buf(struct ath11k_base *ab) 885 { 886 struct ath11k_ce_pipe *pipe; 887 int i; 888 int ret; 889 890 for (i = 0; i < ab->hw_params.ce_count; i++) { 891 pipe = &ab->ce.ce_pipe[i]; 892 ret = ath11k_ce_rx_post_pipe(pipe); 893 if (ret) { 894 if (ret == -ENOSPC) 895 continue; 896 897 ath11k_warn(ab, "failed to post rx buf to pipe: %d err: %d\n", 898 i, ret); 899 mod_timer(&ab->rx_replenish_retry, 900 jiffies + ATH11K_CE_RX_POST_RETRY_JIFFIES); 901 902 return; 903 } 904 } 905 } 906 EXPORT_SYMBOL(ath11k_ce_rx_post_buf); 907 908 void ath11k_ce_rx_replenish_retry(struct timer_list *t) 909 { 910 struct ath11k_base *ab = from_timer(ab, t, rx_replenish_retry); 911 912 ath11k_ce_rx_post_buf(ab); 913 } 914 915 int ath11k_ce_init_pipes(struct ath11k_base *ab) 916 { 917 struct ath11k_ce_pipe *pipe; 918 int i; 919 int ret; 920 921 ath11k_ce_get_shadow_config(ab, &ab->qmi.ce_cfg.shadow_reg_v2, 922 &ab->qmi.ce_cfg.shadow_reg_v2_len); 923 924 for (i = 0; i < ab->hw_params.ce_count; i++) { 925 pipe = &ab->ce.ce_pipe[i]; 926 927 if (pipe->src_ring) { 928 ret = ath11k_ce_init_ring(ab, pipe->src_ring, i, 929 HAL_CE_SRC); 930 if (ret) { 931 ath11k_warn(ab, "failed to init src ring: %d\n", 932 ret); 933 /* Should we clear any partial init */ 934 return ret; 935 } 936 937 pipe->src_ring->write_index = 0; 938 pipe->src_ring->sw_index = 0; 939 } 940 941 if (pipe->dest_ring) { 942 ret = ath11k_ce_init_ring(ab, pipe->dest_ring, i, 943 HAL_CE_DST); 944 if (ret) { 945 ath11k_warn(ab, "failed to init dest ring: %d\n", 946 ret); 947 /* Should we clear any partial init */ 948 return ret; 949 } 950 951 pipe->rx_buf_needed = pipe->dest_ring->nentries ? 952 pipe->dest_ring->nentries - 2 : 0; 953 954 pipe->dest_ring->write_index = 0; 955 pipe->dest_ring->sw_index = 0; 956 } 957 958 if (pipe->status_ring) { 959 ret = ath11k_ce_init_ring(ab, pipe->status_ring, i, 960 HAL_CE_DST_STATUS); 961 if (ret) { 962 ath11k_warn(ab, "failed to init dest status ing: %d\n", 963 ret); 964 /* Should we clear any partial init */ 965 return ret; 966 } 967 968 pipe->status_ring->write_index = 0; 969 pipe->status_ring->sw_index = 0; 970 } 971 } 972 973 return 0; 974 } 975 976 void ath11k_ce_free_pipes(struct ath11k_base *ab) 977 { 978 struct ath11k_ce_pipe *pipe; 979 struct ath11k_ce_ring *ce_ring; 980 int desc_sz; 981 int i; 982 983 for (i = 0; i < ab->hw_params.ce_count; i++) { 984 pipe = &ab->ce.ce_pipe[i]; 985 986 if (ath11k_ce_need_shadow_fix(i)) 987 ath11k_dp_shadow_stop_timer(ab, &ab->ce.hp_timer[i]); 988 989 if (pipe->src_ring) { 990 desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_SRC); 991 ce_ring = pipe->src_ring; 992 dma_free_coherent(ab->dev, 993 pipe->src_ring->nentries * desc_sz + 994 CE_DESC_RING_ALIGN, 995 ce_ring->base_addr_owner_space_unaligned, 996 ce_ring->base_addr_ce_space_unaligned); 997 kfree(pipe->src_ring); 998 pipe->src_ring = NULL; 999 } 1000 1001 if (pipe->dest_ring) { 1002 desc_sz = ath11k_hal_ce_get_desc_size(HAL_CE_DESC_DST); 1003 ce_ring = pipe->dest_ring; 1004 dma_free_coherent(ab->dev, 1005 pipe->dest_ring->nentries * desc_sz + 1006 CE_DESC_RING_ALIGN, 1007 ce_ring->base_addr_owner_space_unaligned, 1008 ce_ring->base_addr_ce_space_unaligned); 1009 kfree(pipe->dest_ring); 1010 pipe->dest_ring = NULL; 1011 } 1012 1013 if (pipe->status_ring) { 1014 desc_sz = 1015 ath11k_hal_ce_get_desc_size(HAL_CE_DESC_DST_STATUS); 1016 ce_ring = pipe->status_ring; 1017 dma_free_coherent(ab->dev, 1018 pipe->status_ring->nentries * desc_sz + 1019 CE_DESC_RING_ALIGN, 1020 ce_ring->base_addr_owner_space_unaligned, 1021 ce_ring->base_addr_ce_space_unaligned); 1022 kfree(pipe->status_ring); 1023 pipe->status_ring = NULL; 1024 } 1025 } 1026 } 1027 EXPORT_SYMBOL(ath11k_ce_free_pipes); 1028 1029 int ath11k_ce_alloc_pipes(struct ath11k_base *ab) 1030 { 1031 struct ath11k_ce_pipe *pipe; 1032 int i; 1033 int ret; 1034 const struct ce_attr *attr; 1035 1036 spin_lock_init(&ab->ce.ce_lock); 1037 1038 for (i = 0; i < ab->hw_params.ce_count; i++) { 1039 attr = &ab->hw_params.host_ce_config[i]; 1040 pipe = &ab->ce.ce_pipe[i]; 1041 pipe->pipe_num = i; 1042 pipe->ab = ab; 1043 pipe->buf_sz = attr->src_sz_max; 1044 1045 ret = ath11k_ce_alloc_pipe(ab, i); 1046 if (ret) { 1047 /* Free any parial successful allocation */ 1048 ath11k_ce_free_pipes(ab); 1049 return ret; 1050 } 1051 } 1052 1053 return 0; 1054 } 1055 EXPORT_SYMBOL(ath11k_ce_alloc_pipes); 1056 1057 /* For Big Endian Host, Copy Engine byte_swap is enabled 1058 * When Copy Engine does byte_swap, need to byte swap again for the 1059 * Host to get/put buffer content in the correct byte order 1060 */ 1061 void ath11k_ce_byte_swap(void *mem, u32 len) 1062 { 1063 int i; 1064 #if defined(__FreeBSD__) 1065 u32 *m = mem; 1066 #endif 1067 1068 if (IS_ENABLED(CONFIG_CPU_BIG_ENDIAN)) { 1069 if (!mem) 1070 return; 1071 1072 for (i = 0; i < (len / 4); i++) { 1073 #if defined(__linux__) 1074 *(u32 *)mem = swab32(*(u32 *)mem); 1075 mem += 4; 1076 #elif defined(__FreeBSD__) 1077 *m = swab32(*m); 1078 m++; 1079 #endif 1080 } 1081 } 1082 } 1083 1084 int ath11k_ce_get_attr_flags(struct ath11k_base *ab, int ce_id) 1085 { 1086 if (ce_id >= ab->hw_params.ce_count) 1087 return -EINVAL; 1088 1089 return ab->hw_params.host_ce_config[ce_id].flags; 1090 } 1091 EXPORT_SYMBOL(ath11k_ce_get_attr_flags); 1092