1 /* 2 * Copyright (c) 2013-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022-2023 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #ifndef __COPY_ENGINE_API_H__ 21 #define __COPY_ENGINE_API_H__ 22 23 #include "pld_common.h" 24 #include "ce_main.h" 25 #include "hif_main.h" 26 27 /* TBDXXX: Use int return values for consistency with Target */ 28 29 /* TBDXXX: Perhaps merge Host/Target-->common */ 30 31 /* 32 * Copy Engine support: low-level Target-side Copy Engine API. 33 * This is a hardware access layer used by code that understands 34 * how to use copy engines. 35 */ 36 37 /* 38 * A "struct CE_handle *" serves as an opaque pointer-sized 39 * handle to a specific copy engine. 40 */ 41 struct CE_handle; 42 43 /* 44 * "Send Completion" callback type for Send Completion Notification. 45 * 46 * If a Send Completion callback is registered and one or more sends 47 * have completed, the callback is invoked. 48 * 49 * per_ce_send_context is a context supplied by the calling layer 50 * (via ce_send_cb_register). It is associated with a copy engine. 51 * 52 * per_transfer_send_context is context supplied by the calling layer 53 * (via the "send" call). It may be different for each invocation 54 * of send. 55 * 56 * The buffer parameter is the first byte sent of the first buffer 57 * sent (if more than one buffer). 58 * 59 * nbytes is the number of bytes of that buffer that were sent. 60 * 61 * transfer_id matches the value used when the buffer or 62 * buf_list was sent. 63 * 64 * Implementation note: Pops 1 completed send buffer from Source ring 65 */ 66 typedef void (*ce_send_cb)(struct CE_handle *copyeng, 67 void *per_ce_send_context, 68 void *per_transfer_send_context, 69 qdf_dma_addr_t buffer, 70 unsigned int nbytes, 71 unsigned int transfer_id, 72 unsigned int sw_index, 73 unsigned int hw_index, 74 uint32_t toeplitz_hash_result); 75 76 /* 77 * "Buffer Received" callback type for Buffer Received Notification. 78 * 79 * Implementation note: Pops 1 completed recv buffer from Dest ring 80 */ 81 typedef void (*CE_recv_cb)(struct CE_handle *copyeng, 82 void *per_CE_recv_context, 83 void *per_transfer_recv_context, 84 qdf_dma_addr_t buffer, 85 unsigned int nbytes, 86 unsigned int transfer_id, 87 unsigned int flags); 88 89 /* 90 * Copy Engine Watermark callback type. 91 * 92 * Allows upper layers to be notified when watermarks are reached: 93 * space is available and/or running short in a source ring 94 * buffers are exhausted and/or abundant in a destination ring 95 * 96 * The flags parameter indicates which condition triggered this 97 * callback. See CE_WM_FLAG_*. 98 * 99 * Watermark APIs are provided to allow upper layers "batch" 100 * descriptor processing and to allow upper layers to 101 * throttle/unthrottle. 102 */ 103 typedef void (*CE_watermark_cb)(struct CE_handle *copyeng, 104 void *per_CE_wm_context, unsigned int flags); 105 106 107 #define CE_WM_FLAG_SEND_HIGH 1 108 #define CE_WM_FLAG_SEND_LOW 2 109 #define CE_WM_FLAG_RECV_HIGH 4 110 #define CE_WM_FLAG_RECV_LOW 8 111 #define CE_HTT_TX_CE 4 112 113 114 /** 115 * ce_service_srng_init() - Initialization routine for CE services 116 * in SRNG based targets 117 * Return : None 118 */ 119 void ce_service_srng_init(void); 120 121 /** 122 * ce_service_legacy_init() - Initialization routine for CE services 123 * in legacy targets 124 * Return : None 125 */ 126 void ce_service_legacy_init(void); 127 128 /* A list of buffers to be gathered and sent */ 129 struct ce_sendlist; 130 131 /* Copy Engine settable attributes */ 132 struct CE_attr; 133 134 /*==================Send=====================================================*/ 135 136 /* ce_send flags */ 137 /* disable ring's byte swap, even if the default policy is to swap */ 138 #define CE_SEND_FLAG_SWAP_DISABLE 1 139 140 /* 141 * Queue a source buffer to be sent to an anonymous destination buffer. 142 * copyeng - which copy engine to use 143 * buffer - address of buffer 144 * nbytes - number of bytes to send 145 * transfer_id - arbitrary ID; reflected to destination 146 * flags - CE_SEND_FLAG_* values 147 * Returns QDF_STATUS. 148 * 149 * Note: If no flags are specified, use CE's default data swap mode. 150 * 151 * Implementation note: pushes 1 buffer to Source ring 152 */ 153 QDF_STATUS ce_send(struct CE_handle *copyeng, 154 void *per_transfer_send_context, 155 qdf_dma_addr_t buffer, 156 unsigned int nbytes, 157 unsigned int transfer_id, 158 unsigned int flags, 159 unsigned int user_flags); 160 161 #ifdef WLAN_FEATURE_FASTPATH 162 int ce_send_fast(struct CE_handle *copyeng, qdf_nbuf_t msdu, 163 unsigned int transfer_id, uint32_t download_len); 164 165 #endif 166 167 /* 168 * ce_enqueue_desc() - enqueu desc to CE ring. 169 * @copyeng: which copy engine to use 170 * @msdu: data buffer 171 * @transfer_id: arbitrary ID; reflected to destination 172 * @download_len: length of the packet download to FW. 173 * 174 */ 175 int ce_enqueue_desc(struct CE_handle *copyeng, qdf_nbuf_t msdu, 176 unsigned int transfer_id, uint32_t download_len); 177 178 void ce_update_tx_ring(struct CE_handle *ce_tx_hdl, uint32_t num_htt_cmpls); 179 extern qdf_nbuf_t ce_batch_send(struct CE_handle *ce_tx_hdl, 180 qdf_nbuf_t msdu, 181 uint32_t transfer_id, 182 uint32_t len, 183 uint32_t sendhead); 184 185 QDF_STATUS ce_send_single(struct CE_handle *ce_tx_hdl, 186 qdf_nbuf_t msdu, 187 uint32_t transfer_id, 188 uint32_t len); 189 /* 190 * Register a Send Callback function. 191 * This function is called as soon as the contents of a Send 192 * have reached the destination, unless disable_interrupts is 193 * requested. In this case, the callback is invoked when the 194 * send status is polled, shortly after the send completes. 195 */ 196 void ce_send_cb_register(struct CE_handle *copyeng, 197 ce_send_cb fn_ptr, 198 void *per_ce_send_context, int disable_interrupts); 199 200 /* 201 * Return the size of a SendList. This allows the caller to allocate 202 * a SendList while the SendList structure remains opaque. 203 */ 204 unsigned int ce_sendlist_sizeof(void); 205 206 /* Initialize a sendlist */ 207 void ce_sendlist_init(struct ce_sendlist *sendlist); 208 209 /** 210 * ce_sendlist_buf_add() - Append a simple buffer (address/length) to a sendlist 211 * @sendlist: Sendlist 212 * @buffer: buffer 213 * @nbytes: number of bytes to append 214 * @flags: flags 215 * @user_flags: user flags 216 * 217 * Return: QDF_STATUS 218 */ 219 QDF_STATUS ce_sendlist_buf_add(struct ce_sendlist *sendlist, 220 qdf_dma_addr_t buffer, 221 unsigned int nbytes, 222 /* OR-ed with internal flags */ 223 uint32_t flags, 224 uint32_t user_flags); 225 226 /* 227 * ce_sendlist_send() - Queue a "sendlist" of buffers to be sent using gather to 228 * a single anonymous destination buffer 229 * @copyeng: which copy engine to use 230 * @per_transfer_send_context: Per transfer send context 231 * @sendlist: list of simple buffers to send using gather 232 * @transfer_id: arbitrary ID; reflected to destination 233 * 234 * Implementation note: Pushes multiple buffers with Gather to Source ring. 235 * 236 * Return: QDF_STATUS 237 */ 238 QDF_STATUS ce_sendlist_send(struct CE_handle *copyeng, 239 void *per_transfer_send_context, 240 struct ce_sendlist *sendlist, 241 unsigned int transfer_id); 242 243 /*==================Recv=====================================================*/ 244 245 /** 246 * ce_recv_buf_enqueue() - Make a buffer available to receive. The buffer must 247 * be at least of a minimal size appropriate for this copy engine (src_sz_max 248 * attribute). 249 * @copyeng: which copy engine to use 250 * @per_transfer_recv_context: context passed back to caller's recv_cb 251 * @buffer: address of buffer in CE space 252 * 253 * Implementation note: Pushes a buffer to Dest ring. 254 * 255 * Return: QDF_STATUS. 256 */ 257 QDF_STATUS ce_recv_buf_enqueue(struct CE_handle *copyeng, 258 void *per_transfer_recv_context, 259 qdf_dma_addr_t buffer); 260 261 /* 262 * Register a Receive Callback function. 263 * This function is called as soon as data is received 264 * from the source. 265 */ 266 void ce_recv_cb_register(struct CE_handle *copyeng, 267 CE_recv_cb fn_ptr, 268 void *per_CE_recv_context, 269 int disable_interrupts); 270 271 /*==================CE Watermark=============================================*/ 272 273 /* 274 * Register a Watermark Callback function. 275 * This function is called as soon as a watermark level 276 * is crossed. A Watermark Callback function is free to 277 * handle received data "en masse"; but then some coordination 278 * is required with a registered Receive Callback function. 279 * [Suggestion: Either handle Receives in a Receive Callback 280 * or en masse in a Watermark Callback; but not both.] 281 */ 282 void ce_watermark_cb_register(struct CE_handle *copyeng, 283 CE_watermark_cb fn_ptr, 284 void *per_CE_wm_context); 285 286 /* 287 * Set low/high watermarks for the send/source side of a copy engine. 288 * 289 * Typically, the destination side CPU manages watermarks for 290 * the receive side and the source side CPU manages watermarks 291 * for the send side. 292 * 293 * A low watermark of 0 is never hit (so the watermark function 294 * will never be called for a Low Watermark condition). 295 * 296 * A high watermark equal to nentries is never hit (so the 297 * watermark function will never be called for a High Watermark 298 * condition). 299 */ 300 void ce_send_watermarks_set(struct CE_handle *copyeng, 301 unsigned int low_alert_nentries, 302 unsigned int high_alert_nentries); 303 304 /* Set low/high watermarks for the receive/destination side of copy engine. */ 305 void ce_recv_watermarks_set(struct CE_handle *copyeng, 306 unsigned int low_alert_nentries, 307 unsigned int high_alert_nentries); 308 309 /* 310 * Return the number of entries that can be queued 311 * to a ring at an instant in time. 312 * 313 * For source ring, does not imply that destination-side 314 * buffers are available; merely indicates descriptor space 315 * in the source ring. 316 * 317 * For destination ring, does not imply that previously 318 * received buffers have been processed; merely indicates 319 * descriptor space in destination ring. 320 * 321 * Mainly for use with CE Watermark callback. 322 */ 323 unsigned int ce_send_entries_avail(struct CE_handle *copyeng); 324 unsigned int ce_recv_entries_avail(struct CE_handle *copyeng); 325 326 /* recv flags */ 327 /* Data is byte-swapped */ 328 #define CE_RECV_FLAG_SWAPPED 1 329 330 /** 331 * ce_completed_recv_next() - Supply data for the next completed unprocessed 332 * receive descriptor. 333 * @copyeng: which copy engine to use 334 * @per_CE_contextp: CE context 335 * @per_transfer_contextp: Transfer context 336 * @bufferp: buffer pointer 337 * @nbytesp: number of bytes 338 * @transfer_idp: Transfer idp 339 * @flagsp: flags 340 * 341 * For use 342 * with CE Watermark callback, 343 * in a recv_cb function when processing buf_lists 344 * in a recv_cb function in order to mitigate recv_cb's. 345 * 346 * Implementation note: Pops buffer from Dest ring. 347 * 348 * Return: QDF_STATUS 349 */ 350 QDF_STATUS ce_completed_recv_next(struct CE_handle *copyeng, 351 void **per_CE_contextp, 352 void **per_transfer_contextp, 353 qdf_dma_addr_t *bufferp, 354 unsigned int *nbytesp, 355 unsigned int *transfer_idp, 356 unsigned int *flagsp); 357 358 /** 359 * ce_completed_send_next() - Supply data for the next completed unprocessed 360 * send descriptor. 361 * @copyeng: which copy engine to use 362 * @per_CE_contextp: CE context 363 * @per_transfer_contextp: Transfer context 364 * @bufferp: buffer pointer 365 * @nbytesp: number of bytes 366 * @transfer_idp: Transfer idp 367 * @sw_idx: SW index 368 * @hw_idx: HW index 369 * @toeplitz_hash_result: toeplitz hash result 370 * 371 * For use 372 * with CE Watermark callback 373 * in a send_cb function in order to mitigate send_cb's. 374 * 375 * Implementation note: Pops 1 completed send buffer from Source ring 376 * 377 * Return: QDF_STATUS 378 */ 379 QDF_STATUS ce_completed_send_next(struct CE_handle *copyeng, 380 void **per_CE_contextp, 381 void **per_transfer_contextp, 382 qdf_dma_addr_t *bufferp, 383 unsigned int *nbytesp, 384 unsigned int *transfer_idp, 385 unsigned int *sw_idx, 386 unsigned int *hw_idx, 387 uint32_t *toeplitz_hash_result); 388 389 #ifdef CUSTOM_CB_SCHEDULER_SUPPORT 390 /*==================CE custom callbacks=================================*/ 391 392 /** 393 * ce_register_custom_cb() - Helper API to register the custom callback 394 * @copyeng: Pointer to CE handle 395 * @custom_cb: Custom call back function pointer 396 * @custom_cb_context: Custom callback context 397 * 398 * return: void 399 */ 400 void 401 ce_register_custom_cb(struct CE_handle *copyeng, void (*custom_cb)(void *), 402 void *custom_cb_context); 403 404 /** 405 * ce_unregister_custom_cb() - Helper API to unregister the custom callback 406 * @copyeng: Pointer to CE handle 407 * 408 * return: void 409 */ 410 void 411 ce_unregister_custom_cb(struct CE_handle *copyeng); 412 413 /** 414 * ce_enable_custom_cb() - Helper API to enable the custom callback 415 * @copyeng: Pointer to CE handle 416 * 417 * return: void 418 */ 419 void 420 ce_enable_custom_cb(struct CE_handle *copyeng); 421 422 /** 423 * ce_disable_custom_cb() - Helper API to disable the custom callback 424 * @copyeng: Pointer to CE handle 425 * 426 * return: void 427 */ 428 void 429 ce_disable_custom_cb(struct CE_handle *copyeng); 430 #endif /* CUSTOM_CB_SCHEDULER_SUPPORT */ 431 432 /*==================CE Engine Initialization=================================*/ 433 434 /* Initialize an instance of a CE */ 435 struct CE_handle *ce_init(struct hif_softc *scn, 436 unsigned int CE_id, struct CE_attr *attr); 437 438 /* 439 * hif_ce_desc_history_log_register() - Register hif_ce_desc_history buffers 440 * to SSR driver dump. 441 * @scn: HIF context 442 * 443 * Return: None 444 */ 445 void hif_ce_desc_history_log_register(struct hif_softc *scn); 446 447 /*==================CE Engine Shutdown=======================================*/ 448 /* 449 * Support clean shutdown by allowing the caller to revoke 450 * receive buffers. Target DMA must be stopped before using 451 * this API. 452 */ 453 QDF_STATUS 454 ce_revoke_recv_next(struct CE_handle *copyeng, 455 void **per_CE_contextp, 456 void **per_transfer_contextp, 457 qdf_dma_addr_t *bufferp); 458 459 /* 460 * Support clean shutdown by allowing the caller to cancel 461 * pending sends. Target DMA must be stopped before using 462 * this API. 463 */ 464 QDF_STATUS 465 ce_cancel_send_next(struct CE_handle *copyeng, 466 void **per_CE_contextp, 467 void **per_transfer_contextp, 468 qdf_dma_addr_t *bufferp, 469 unsigned int *nbytesp, 470 unsigned int *transfer_idp, 471 uint32_t *toeplitz_hash_result); 472 473 void ce_fini(struct CE_handle *copyeng); 474 475 /* 476 * hif_ce_desc_history_log_unregister() - unregister hif_ce_desc_history 477 * buffers from SSR driver dump. 478 * 479 * Return: None 480 */ 481 void hif_ce_desc_history_log_unregister(void); 482 483 /*==================CE Interrupt Handlers====================================*/ 484 void ce_per_engine_service_any(int irq, struct hif_softc *scn); 485 int ce_per_engine_service(struct hif_softc *scn, unsigned int CE_id); 486 void ce_per_engine_servicereap(struct hif_softc *scn, unsigned int CE_id); 487 488 /*===================CE cmpl interrupt Enable/Disable =======================*/ 489 void ce_disable_any_copy_compl_intr_nolock(struct hif_softc *scn); 490 void ce_enable_any_copy_compl_intr_nolock(struct hif_softc *scn); 491 492 /* API to check if any of the copy engine pipes has 493 * pending frames for processing 494 */ 495 bool ce_get_rx_pending(struct hif_softc *scn); 496 497 /** 498 * war_ce_src_ring_write_idx_set() - Set write index for CE source ring 499 * @scn: HIF context 500 * @ctrl_addr: address 501 * @write_index: write index 502 * 503 * Return: None 504 */ 505 void war_ce_src_ring_write_idx_set(struct hif_softc *scn, 506 u32 ctrl_addr, unsigned int write_index); 507 508 /* CE_attr.flags values */ 509 #define CE_ATTR_NO_SNOOP 0x01 /* Use NonSnooping PCIe accesses? */ 510 #define CE_ATTR_BYTE_SWAP_DATA 0x02 /* Byte swap data words */ 511 #define CE_ATTR_SWIZZLE_DESCRIPTORS 0x04 /* Swizzle descriptors? */ 512 #define CE_ATTR_DISABLE_INTR 0x08 /* no interrupt on copy completion */ 513 #define CE_ATTR_ENABLE_POLL 0x10 /* poll for residue descriptors */ 514 #define CE_ATTR_DIAG 0x20 /* Diag CE */ 515 #define CE_ATTR_INIT_ON_DEMAND 0x40 /* Initialized on demand */ 516 #define CE_ATTR_HI_TASKLET 0x80 /* HI_TASKLET CE */ 517 518 /** 519 * struct CE_attr - Attributes of an instance of a Copy Engine 520 * @flags: CE_ATTR_* values 521 * @priority: TBD 522 * @src_nentries: #entries in source ring - Must be a power of 2 523 * @src_sz_max: Max source send size for this CE. This is also the minimum 524 * size of a destination buffer 525 * @dest_nentries: #entries in destination ring - Must be a power of 2 526 * @reserved: Future Use 527 */ 528 struct CE_attr { 529 unsigned int flags; 530 unsigned int priority; 531 unsigned int src_nentries; 532 unsigned int src_sz_max; 533 unsigned int dest_nentries; 534 void *reserved; 535 }; 536 537 /* 538 * When using sendlist_send to transfer multiple buffer fragments, the 539 * transfer context of each fragment, except last one, will be filled 540 * with CE_SENDLIST_ITEM_CTXT. CE_completed_send will return success for 541 * each fragment done with send and the transfer context would be 542 * CE_SENDLIST_ITEM_CTXT. Upper layer could use this to identify the 543 * status of a send completion. 544 */ 545 #define CE_SENDLIST_ITEM_CTXT ((void *)0xcecebeef) 546 547 /* 548 * This is an opaque type that is at least large enough to hold 549 * a sendlist. A sendlist can only be accessed through CE APIs, 550 * but this allows a sendlist to be allocated on the run-time 551 * stack. TBDXXX: un-opaque would be simpler... 552 */ 553 struct ce_sendlist { 554 unsigned int word[62]; 555 }; 556 557 #define ATH_ISR_NOSCHED 0x0000 /* Do not schedule bottom half/DPC */ 558 #define ATH_ISR_SCHED 0x0001 /* Schedule the bottom half for execution */ 559 #define ATH_ISR_NOTMINE 0x0002 /* for shared IRQ's */ 560 561 #ifdef IPA_OFFLOAD 562 void ce_ipa_get_resource(struct CE_handle *ce, 563 qdf_shared_mem_t **ce_sr, 564 uint32_t *ce_sr_ring_size, 565 qdf_dma_addr_t *ce_reg_paddr); 566 #else 567 /** 568 * ce_ipa_get_resource() - get uc resource on copyengine 569 * @ce: copyengine context 570 * @ce_sr: copyengine source ring resource info 571 * @ce_sr_ring_size: copyengine source ring size 572 * @ce_reg_paddr: copyengine register physical address 573 * 574 * Copy engine should release resource to micro controller 575 * Micro controller needs 576 * - Copy engine source descriptor base address 577 * - Copy engine source descriptor size 578 * - PCI BAR address to access copy engine register 579 * 580 * Return: None 581 */ 582 static inline void ce_ipa_get_resource(struct CE_handle *ce, 583 qdf_shared_mem_t **ce_sr, 584 uint32_t *ce_sr_ring_size, 585 qdf_dma_addr_t *ce_reg_paddr) 586 { 587 } 588 #endif /* IPA_OFFLOAD */ 589 590 static inline void ce_pkt_error_count_incr( 591 struct HIF_CE_state *_hif_state, 592 enum ol_ath_hif_pkt_ecodes _hif_ecode) 593 { 594 struct hif_softc *scn = HIF_GET_SOFTC(_hif_state); 595 596 if (_hif_ecode == HIF_PIPE_NO_RESOURCE) 597 (scn->pkt_stats.hif_pipe_no_resrc_count) 598 += 1; 599 } 600 601 bool ce_check_rx_pending(struct CE_state *CE_state); 602 void *hif_ce_get_lro_ctx(struct hif_opaque_softc *hif_hdl, int ctx_id); 603 struct ce_ops *ce_services_srng(void); 604 struct ce_ops *ce_services_legacy(void); 605 bool ce_srng_based(struct hif_softc *scn); 606 /* Forward declaration */ 607 struct CE_ring_state; 608 609 struct ce_ops { 610 uint32_t (*ce_get_desc_size)(uint8_t ring_type); 611 int (*ce_ring_setup)(struct hif_softc *scn, uint8_t ring_type, 612 uint32_t ce_id, struct CE_ring_state *ring, 613 struct CE_attr *attr); 614 void (*ce_srng_cleanup)(struct hif_softc *scn, 615 struct CE_state *CE_state, uint8_t ring_type); 616 QDF_STATUS (*ce_send_nolock)(struct CE_handle *copyeng, 617 void *per_transfer_context, 618 qdf_dma_addr_t buffer, 619 uint32_t nbytes, 620 uint32_t transfer_id, 621 uint32_t flags, 622 uint32_t user_flags); 623 QDF_STATUS (*ce_sendlist_send)(struct CE_handle *copyeng, 624 void *per_transfer_context, 625 struct ce_sendlist *sendlist, 626 unsigned int transfer_id); 627 QDF_STATUS (*ce_revoke_recv_next)(struct CE_handle *copyeng, 628 void **per_CE_contextp, 629 void **per_transfer_contextp, 630 qdf_dma_addr_t *bufferp); 631 QDF_STATUS (*ce_cancel_send_next)(struct CE_handle *copyeng, 632 void **per_CE_contextp, void **per_transfer_contextp, 633 qdf_dma_addr_t *bufferp, unsigned int *nbytesp, 634 unsigned int *transfer_idp, 635 uint32_t *toeplitz_hash_result); 636 QDF_STATUS (*ce_recv_buf_enqueue)(struct CE_handle *copyeng, 637 void *per_recv_context, 638 qdf_dma_addr_t buffer); 639 bool (*watermark_int)(struct CE_state *CE_state, unsigned int *flags); 640 QDF_STATUS (*ce_completed_recv_next_nolock)( 641 struct CE_state *CE_state, 642 void **per_CE_contextp, 643 void **per_transfer_contextp, 644 qdf_dma_addr_t *bufferp, 645 unsigned int *nbytesp, 646 unsigned int *transfer_idp, 647 unsigned int *flagsp); 648 QDF_STATUS (*ce_completed_send_next_nolock)( 649 struct CE_state *CE_state, 650 void **per_CE_contextp, 651 void **per_transfer_contextp, 652 qdf_dma_addr_t *bufferp, 653 unsigned int *nbytesp, 654 unsigned int *transfer_idp, 655 unsigned int *sw_idx, 656 unsigned int *hw_idx, 657 uint32_t *toeplitz_hash_result); 658 unsigned int (*ce_recv_entries_done_nolock)(struct hif_softc *scn, 659 struct CE_state *CE_state); 660 unsigned int (*ce_send_entries_done_nolock)(struct hif_softc *scn, 661 struct CE_state *CE_state); 662 void (*ce_per_engine_handler_adjust)(struct CE_state *CE_state, 663 int disable_copy_compl_intr); 664 void (*ce_prepare_shadow_register_v2_cfg)(struct hif_softc *scn, 665 struct pld_shadow_reg_v2_cfg **shadow_config, 666 int *num_shadow_registers_configured); 667 int (*ce_get_index_info)(struct hif_softc *scn, void *ce_state, 668 struct ce_index *info); 669 #ifdef CONFIG_SHADOW_V3 670 void (*ce_prepare_shadow_register_v3_cfg)(struct hif_softc *scn, 671 struct pld_shadow_reg_v3_cfg **shadow_config, 672 int *num_shadow_registers_configured); 673 #endif 674 #ifdef FEATURE_DIRECT_LINK 675 QDF_STATUS (*ce_set_irq_config_by_ceid)(struct hif_softc *scn, 676 uint8_t ce_id, uint64_t addr, 677 uint32_t data); 678 uint16_t (*ce_get_direct_link_dest_buffers)(struct hif_softc *scn, 679 uint64_t **dma_addr, 680 uint32_t *buf_size); 681 QDF_STATUS (*ce_get_direct_link_ring_info)(struct hif_softc *scn, 682 struct hif_direct_link_ce_info *info, 683 uint8_t max_ce_info_len); 684 #endif 685 }; 686 687 int hif_ce_bus_early_suspend(struct hif_softc *scn); 688 int hif_ce_bus_late_resume(struct hif_softc *scn); 689 690 /* 691 * ce_engine_service_reg: 692 * @scn: hif_context 693 * @CE_id: Copy engine ID 694 * 695 * Called from ce_per_engine_service and goes through the regular interrupt 696 * handling that does not involve the WLAN fast path feature. 697 * 698 * Returns void 699 */ 700 void ce_engine_service_reg(struct hif_softc *scn, int CE_id); 701 702 /** 703 * ce_per_engine_service_fast() - CE handler routine to service fastpath msgs 704 * @scn: hif_context 705 * @ce_id: Copy engine ID 706 * 707 * Return: void 708 */ 709 void ce_per_engine_service_fast(struct hif_softc *scn, int ce_id); 710 711 void ce_tx_ring_write_idx_update_wrapper(struct CE_handle *ce_tx_hdl, 712 int coalesce); 713 714 /* 715 * ce_ring_flush_write_idx() - CE handler to flush write index 716 * @ce_tx_hdl: ce handle 717 * @force_flush: force flush the write idx if it set to true. 718 * 719 * Returns void 720 */ 721 void ce_flush_tx_ring_write_idx(struct CE_handle *ce_tx_hdl, bool force_flush); 722 #endif /* __COPY_ENGINE_API_H__ */ 723