1 /* 2 * Copyright (c) 2011-2020 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022 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 /** 21 * @file ol_txrx_htt_api.h 22 * @brief Define the host data API functions called by the host HTT SW. 23 */ 24 #ifndef _OL_TXRX_HTT_API__H_ 25 #define _OL_TXRX_HTT_API__H_ 26 27 #include <htt.h> /* HTT_TX_COMPL_IND_STAT */ 28 #include <athdefs.h> /* A_STATUS */ 29 #include <qdf_nbuf.h> /* qdf_nbuf_t */ 30 31 #include <cdp_txrx_cmn.h> /* ol_txrx_pdev_handle */ 32 #include <ol_defines.h> 33 34 #ifdef CONFIG_HL_SUPPORT ol_tx_msdu_id_storage(qdf_nbuf_t msdu)35 static inline uint16_t *ol_tx_msdu_id_storage(qdf_nbuf_t msdu) 36 { 37 return (uint16_t *) (&QDF_NBUF_CB_TX_DESC_ID(msdu)); 38 39 } 40 41 /** 42 * @brief Deduct one credit from target_tx and one from any of the groups 43 * @details 44 * Deduct one credit from target_tx credit and one credit from any of the 45 * groups, whichever has more number of credits. 46 * 47 * @param pdev - the data physical device 48 */ 49 int ol_tx_deduct_one_credit(struct ol_txrx_pdev_t *pdev); 50 #else ol_tx_msdu_id_storage(qdf_nbuf_t msdu)51 static inline uint16_t *ol_tx_msdu_id_storage(qdf_nbuf_t msdu) 52 { 53 qdf_assert(qdf_nbuf_headroom(msdu) >= (sizeof(uint16_t) * 2 - 1)); 54 return (uint16_t *) (((qdf_size_t) (qdf_nbuf_head(msdu) + 1)) & ~0x1); 55 } 56 ol_tx_deduct_one_credit(struct ol_txrx_pdev_t * pdev)57 static inline int ol_tx_deduct_one_credit(struct ol_txrx_pdev_t *pdev) 58 { 59 return 0; 60 } 61 #endif 62 /** 63 * @brief Tx MSDU download completion for a LL system 64 * @details 65 * Release the reference to the downloaded tx descriptor. 66 * In the unlikely event that the reference count is zero, free 67 * the tx descriptor and tx frame. 68 * 69 * @param pdev - (abstract) pointer to the txrx physical device 70 * @param status - indication of whether the download succeeded 71 * @param msdu - the downloaded tx frame 72 * @param msdu_id - the txrx ID of the tx frame - this is used for 73 * locating the frame's tx descriptor 74 */ 75 void 76 ol_tx_download_done_ll(void *pdev, 77 A_STATUS status, qdf_nbuf_t msdu, uint16_t msdu_id); 78 79 /** 80 * @brief Tx MSDU download completion for HL system without tx completion msgs 81 * @details 82 * Free the tx descriptor and tx frame. 83 * Invoke the HL tx download scheduler. 84 * 85 * @param pdev - (abstract) pointer to the txrx physical device 86 * @param status - indication of whether the download succeeded 87 * @param msdu - the downloaded tx frame 88 * @param msdu_id - the txrx ID of the tx frame - this is used for 89 * locating the frame's tx descriptor 90 */ 91 void 92 ol_tx_download_done_hl_free(void *pdev, 93 A_STATUS status, qdf_nbuf_t msdu, uint16_t msdu_id); 94 95 /** 96 * @brief Tx MSDU download completion for HL system with tx completion msgs 97 * @details 98 * Release the reference to the downloaded tx descriptor. 99 * In the unlikely event that the reference count is zero, free 100 * the tx descriptor and tx frame. 101 * Optionally, invoke the HL tx download scheduler. (It is probable that 102 * the HL tx download scheduler would operate in response to tx completion 103 * messages rather than download completion events.) 104 * 105 * @param pdev - (abstract) pointer to the txrx physical device 106 * @param status - indication of whether the download succeeded 107 * @param msdu - the downloaded tx frame 108 * @param msdu_id - the txrx ID of the tx frame - this is used for 109 * locating the frame's tx descriptor 110 */ 111 void 112 ol_tx_download_done_hl_retain(void *pdev, 113 A_STATUS status, 114 qdf_nbuf_t msdu, uint16_t msdu_id); 115 116 /* 117 * For now, make the host HTT -> host txrx tx completion status 118 * match the target HTT -> host HTT tx completion status, so no 119 * translation is needed. 120 */ 121 /* 122 * host-only statuses use a different part of the number space 123 * than host-target statuses 124 */ 125 #define HTT_HOST_ONLY_STATUS_CODE_START 128 126 enum htt_tx_status { 127 /* ok - successfully sent + acked */ 128 htt_tx_status_ok = HTT_TX_COMPL_IND_STAT_OK, 129 130 /* discard - not sent (congestion control) */ 131 htt_tx_status_discard = HTT_TX_COMPL_IND_STAT_DISCARD, 132 133 /* no_ack - sent, but no ack */ 134 htt_tx_status_no_ack = HTT_TX_COMPL_IND_STAT_NO_ACK, 135 136 /* drop may due to tx descriptor not enough*/ 137 htt_tx_status_drop = HTT_TX_COMPL_IND_STAT_DROP, 138 139 /* download_fail - host could not deliver the tx frame to target */ 140 htt_tx_status_download_fail = HTT_HOST_ONLY_STATUS_CODE_START, 141 }; 142 143 /** 144 * @brief Process a tx completion message sent by the target. 145 * @details 146 * When the target is done transmitting a tx frame (either because 147 * the frame was sent + acknowledged, or because the target gave up) 148 * it sends a tx completion message to the host. 149 * This notification function is used regardless of whether the 150 * transmission succeeded or not; the status argument indicates whether 151 * the transmission succeeded. 152 * This tx completion message indicates via the descriptor ID which 153 * tx frames were completed, and indicates via the status whether the 154 * frames were transmitted successfully. 155 * The host frees the completed descriptors / frames (updating stats 156 * in the process). 157 * 158 * @param pdev - the data physical device that sent the tx frames 159 * (registered with HTT as a context pointer during attach time) 160 * @param num_msdus - how many MSDUs are referenced by the tx completion 161 * message 162 * @param status - whether transmission was successful 163 * @param msg_word - the tx completion message 164 */ 165 void 166 ol_tx_completion_handler(ol_txrx_pdev_handle pdev, 167 int num_msdus, 168 enum htt_tx_status status, void *msg_word); 169 170 void ol_tx_credit_completion_handler(ol_txrx_pdev_handle pdev, int credits); 171 172 struct rate_report_t { 173 u_int16_t id; 174 u_int16_t phy:4; 175 u_int32_t rate; 176 }; 177 178 #if defined(CONFIG_HL_SUPPORT) && defined(QCA_BAD_PEER_TX_FLOW_CL) 179 180 /** 181 * @brief Process a link status report for all peers. 182 * @details 183 * The ol_txrx_peer_link_status_handler function performs basic peer link 184 * status analysis 185 * 186 * According to the design, there are 3 kinds of peers which will be 187 * treated differently: 188 * 1) normal: not do any flow control for the peer 189 * 2) limited: will apply flow control for the peer, but frames are allowed 190 * to send 191 * 3) paused: will apply flow control for the peer, no frame is allowed 192 * to send 193 * 194 * @param pdev - the data physical device that sent the tx frames 195 * @param status - the number of peers need to be handled 196 * @param peer_link_report - the link status dedail message 197 */ 198 void 199 ol_txrx_peer_link_status_handler( 200 ol_txrx_pdev_handle pdev, 201 u_int16_t peer_num, 202 struct rate_report_t *peer_link_status); 203 204 205 #else ol_txrx_peer_link_status_handler(ol_txrx_pdev_handle pdev,u_int16_t peer_num,struct rate_report_t * peer_link_status)206 static inline void ol_txrx_peer_link_status_handler( 207 ol_txrx_pdev_handle pdev, 208 u_int16_t peer_num, 209 struct rate_report_t *peer_link_status) 210 { 211 } 212 #endif 213 214 215 #ifdef FEATURE_HL_GROUP_CREDIT_FLOW_CONTROL 216 217 /** 218 * ol_txrx_update_tx_queue_groups() - update vdev tx queue group if 219 * vdev id mask and ac mask is not matching 220 * @pdev: the data physical device 221 * @group_id: TXQ group id 222 * @credit: TXQ group credit count 223 * @absolute: TXQ group absolute 224 * @vdev_id_mask: TXQ vdev group id mask 225 * @ac_mask: TQX access category mask 226 * 227 * Return: None 228 */ 229 void 230 ol_txrx_update_tx_queue_groups( 231 ol_txrx_pdev_handle pdev, 232 u_int8_t group_id, 233 int32_t credit, 234 u_int8_t absolute, 235 u_int32_t vdev_id_mask, 236 u_int32_t ac_mask 237 ); 238 239 /** 240 * ol_tx_desc_update_group_credit() - update group credits for txq group 241 * @pdev: the data physical device 242 * @tx_desc_id: desc id of tx completion message 243 * @credit: number of credits to update 244 * @absolute: absolute value 245 * @status: tx completion message status 246 * 247 * Return: None 248 */ 249 void 250 ol_tx_desc_update_group_credit( 251 ol_txrx_pdev_handle pdev, 252 u_int16_t tx_desc_id, 253 int credit, u_int8_t absolute, enum htt_tx_status status); 254 255 void ol_tx_deduct_one_any_group_credit(ol_txrx_pdev_handle pdev); 256 257 #ifdef DEBUG_HL_LOGGING 258 259 /** 260 * ol_tx_update_group_credit_stats() - update group credits stats for txq groups 261 * @pdev: the data physical device 262 * 263 * Return: None 264 */ 265 void 266 ol_tx_update_group_credit_stats(ol_txrx_pdev_handle pdev); 267 268 /** 269 * ol_tx_dump_group_credit_stats() - dump group credits stats for txq groups 270 * @pdev: the data physical device 271 * 272 * Return: None 273 */ 274 void 275 ol_tx_dump_group_credit_stats(ol_txrx_pdev_handle pdev); 276 277 /** 278 * ol_tx_clear_group_credit_stats() - clear group credits stats for txq groups 279 * @pdev: the data physical device 280 * 281 * Return: None 282 */ 283 void 284 ol_tx_clear_group_credit_stats(ol_txrx_pdev_handle pdev); 285 #else 286 ol_tx_update_group_credit_stats(ol_txrx_pdev_handle pdev)287 static inline void ol_tx_update_group_credit_stats(ol_txrx_pdev_handle pdev) 288 { 289 } 290 ol_tx_dump_group_credit_stats(ol_txrx_pdev_handle pdev)291 static inline void ol_tx_dump_group_credit_stats(ol_txrx_pdev_handle pdev) 292 { 293 } 294 ol_tx_clear_group_credit_stats(ol_txrx_pdev_handle pdev)295 static inline void ol_tx_clear_group_credit_stats(ol_txrx_pdev_handle pdev) 296 { 297 } 298 #endif 299 300 #else 301 static inline void ol_tx_desc_update_group_credit(ol_txrx_pdev_handle pdev,u_int16_t tx_desc_id,int credit,u_int8_t absolute,enum htt_tx_status status)302 ol_tx_desc_update_group_credit( 303 ol_txrx_pdev_handle pdev, 304 u_int16_t tx_desc_id, 305 int credit, u_int8_t absolute, enum htt_tx_status status) 306 { 307 } 308 ol_tx_deduct_one_any_group_credit(ol_txrx_pdev_handle pdev)309 static inline void ol_tx_deduct_one_any_group_credit(ol_txrx_pdev_handle pdev) 310 {} 311 #endif 312 313 /** 314 * @brief Init the total amount of target credit. 315 * @details 316 * 317 * @param pdev - the data physical device that sent the tx frames 318 * @param credit_delta - how much to increment the target's tx credit by 319 */ 320 void ol_tx_target_credit_init(struct ol_txrx_pdev_t *pdev, int credit_delta); 321 322 /** 323 * @brief Process a tx completion message for a single MSDU. 324 * @details 325 * The ol_tx_single_completion_handler function performs the same tx 326 * completion processing as the ol_tx_completion_handler, but for a 327 * single frame. 328 * ol_tx_completion_handler is optimized to handle batch completions 329 * as efficiently as possible; in contrast ol_tx_single_completion_handler 330 * handles single frames as simply and generally as possible. 331 * Thus, this ol_tx_single_completion_handler function is suitable for 332 * intermittent usage, such as for tx mgmt frames. 333 * 334 * @param pdev - the data physical device that sent the tx frames 335 * @param status - whether transmission was successful 336 * @param tx_msdu_id - ID of the frame which completed transmission 337 */ 338 void 339 ol_tx_single_completion_handler(ol_txrx_pdev_handle pdev, 340 enum htt_tx_status status, uint16_t tx_desc_id); 341 342 /** 343 * @brief Update the amount of target credit. 344 * @details 345 * When the target finishes with an old transmit frame, it can use the 346 * space that was occupied by the old tx frame to store a new tx frame. 347 * This function is used to inform the txrx layer, where the HL tx download 348 * scheduler resides, about such updates to the target's tx credit. 349 * This credit update is done explicitly, rather than having the txrx layer 350 * update the credit count itself inside the ol_tx_completion handler 351 * function. This provides HTT with the flexibility to limit the rate of 352 * downloads from the TXRX layer's download scheduler, by controlling how 353 * much credit the download scheduler gets, and also provides the flexibility 354 * to account for a change in the tx memory pool size within the target. 355 * This function is only used for HL systems; in LL systems, each tx frame 356 * is assumed to use exactly one credit (for its target-side tx descriptor), 357 * and any rate limiting is managed within the target. 358 * 359 * @param pdev - the data physical device that sent the tx frames 360 * @param credit_delta - how much to increment the target's tx credit by 361 */ 362 void ol_tx_target_credit_update(struct ol_txrx_pdev_t *pdev, int credit_delta); 363 364 /** 365 * @brief Process an rx indication message sent by the target. 366 * @details 367 * The target sends a rx indication message to the host as a 368 * notification that there are new rx frames available for the 369 * host to process. 370 * The HTT host layer locates the rx descriptors and rx frames 371 * associated with the indication, and calls this function to 372 * invoke the rx data processing on the new frames. 373 * (For LL, the rx descriptors and frames are delivered directly 374 * to the host via MAC DMA, while for HL the rx descriptor and 375 * frame for individual frames are combined with the rx indication 376 * message.) 377 * All MPDUs referenced by a rx indication message belong to the 378 * same peer-TID. 379 * 380 * @param pdev - the data physical device that received the frames 381 * (registered with HTT as a context pointer during attach time) 382 * @param rx_ind_msg - the network buffer holding the rx indication message 383 * (For HL, this netbuf also holds the rx desc and rx payload, but 384 * the data SW is agnostic to whether the desc and payload are 385 * piggybacked with the rx indication message.) 386 * @param peer_id - which peer sent this rx data 387 * @param tid - what (extended) traffic type the rx data is 388 * @param num_mpdu_ranges - how many ranges of MPDUs does the message describe. 389 * Each MPDU within the range has the same rx status. 390 */ 391 #ifdef WLAN_PARTIAL_REORDER_OFFLOAD 392 void 393 ol_rx_indication_handler(ol_txrx_pdev_handle pdev, 394 qdf_nbuf_t rx_ind_msg, 395 uint16_t peer_id, uint8_t tid, int num_mpdu_ranges); 396 #else 397 static inline void ol_rx_indication_handler(ol_txrx_pdev_handle pdev,qdf_nbuf_t rx_ind_msg,uint16_t peer_id,uint8_t tid,int num_mpdu_ranges)398 ol_rx_indication_handler(ol_txrx_pdev_handle pdev, 399 qdf_nbuf_t rx_ind_msg, 400 uint16_t peer_id, uint8_t tid, int num_mpdu_ranges) 401 { 402 } 403 #endif 404 405 /** 406 * @brief Process an rx fragment indication message sent by the target. 407 * @details 408 * The target sends a rx fragment indication message to the host as a 409 * notification that there are new rx fragment available for the 410 * host to process. 411 * The HTT host layer locates the rx descriptors and rx fragment 412 * associated with the indication, and calls this function to 413 * invoke the rx fragment data processing on the new fragment. 414 * 415 * @param pdev - the data physical device that received the frames 416 * (registered with HTT as a context pointer during attach time) 417 * @param rx_frag_ind_msg - the network buffer holding the rx fragment 418 * indication message 419 * @param peer_id - which peer sent this rx data 420 * @param tid - what (extended) traffic type the rx data is 421 */ 422 void ol_rx_frag_indication_handler(ol_txrx_pdev_handle pdev, 423 qdf_nbuf_t rx_frag_ind_msg, 424 uint16_t peer_id, uint8_t tid); 425 426 /** 427 * @brief Process rx offload deliver indication message sent by the target. 428 * @details 429 * When the target exits offload mode, target delivers packets that it has 430 * held in its memory to the host using this message. 431 * Low latency case: 432 * The message contains the number of MSDUs that are being delivered by the 433 * target to the host. The packet itself resides in host ring along with some 434 * metadata describing the peer id, vdev id, tid, FW desc and length of 435 * the packet being delivered. 436 * High latency case: 437 * The message itself contains the payload of the MSDU being delivered by 438 * the target to the host. The message also contains meta data describing 439 * the packet such as peer id, vdev id, tid, FW desc and length of the packet 440 * being delivered. Refer to htt.h for the exact structure of the message. 441 * @param pdev - the data physical device that received the frame. 442 * @param msg - offload deliver indication message 443 * @param msdu_cnt - number of MSDUs being delivred. 444 */ 445 void 446 ol_rx_offload_deliver_ind_handler(ol_txrx_pdev_handle pdev, 447 qdf_nbuf_t msg, uint16_t msdu_cnt); 448 449 /** 450 * @brief Process a peer map message sent by the target. 451 * @details 452 * Each time the target allocates a new peer ID, it will inform the 453 * host via the "peer map" message. This function processes that 454 * message. The host data SW looks for a peer object whose MAC address 455 * matches the MAC address specified in the peer map message, and then 456 * sets up a mapping between the peer ID specified in the message and 457 * the peer object that was found. 458 * 459 * @param pdev - data physical device handle 460 * (registered with HTT as a context pointer during attach time) 461 * @param peer_id - ID generated by the target to refer to the peer in question 462 * The target may create multiple IDs for a single peer. 463 * @param vdev_id - Reference to the virtual device the peer is associated with 464 * @param peer_mac_addr - MAC address of the peer in question 465 * @param tx_ready - whether transmits to this peer can be done already, or 466 * need to wait for a call to peer_tx_ready (only applies to HL systems) 467 */ 468 void 469 ol_rx_peer_map_handler(ol_txrx_pdev_handle pdev, 470 uint16_t peer_id, 471 uint8_t vdev_id, uint8_t *peer_mac_addr, int tx_ready); 472 473 /** 474 * @brief notify the host that the target is ready to transmit to a new peer. 475 * @details 476 * Some targets can immediately accept tx frames for a new peer, as soon as 477 * the peer's association completes. Other target need a short setup time 478 * before they are ready to accept tx frames for the new peer. 479 * If the target needs time for setup, it will provide a peer_tx_ready 480 * message when it is done with the setup. This function forwards this 481 * notification from the target to the host's tx queue manager. 482 * This function only applies for HL systems, in which the host determines 483 * which peer a given tx frame is for, and stores the tx frames in queues. 484 * 485 * @param pdev - data physical device handle 486 * (registered with HTT as a context pointer during attach time) 487 * @param peer_id - ID for the new peer which can now accept tx frames 488 */ 489 void ol_txrx_peer_tx_ready_handler(ol_txrx_pdev_handle pdev, uint16_t peer_id); 490 491 /** 492 * @brief Process a peer unmap message sent by the target. 493 * @details 494 * Each time the target frees a peer ID, it will inform the host via the 495 * "peer unmap" message. This function processes that message. 496 * The host data SW uses the peer ID from the message to find the peer 497 * object from peer_map[peer_id], then invalidates peer_map[peer_id] 498 * (by setting it to NULL), and checks whether there are any remaining 499 * references to the peer object. If not, the function deletes the 500 * peer object. 501 * 502 * @param pdev - data physical device handle 503 * (registered with HTT as a context pointer during attach time) 504 * @param peer_id - ID that is being freed. 505 * The target may create multiple IDs for a single peer. 506 */ 507 void ol_rx_peer_unmap_handler(ol_txrx_pdev_handle pdev, uint16_t peer_id); 508 509 /** 510 * @brief Process a security indication message sent by the target. 511 * @details 512 * When a key is assigned to a peer, the target will inform the host 513 * with a security indication message. 514 * The host remembers the security type, and infers whether a rx PN 515 * check is needed. 516 * 517 * @param pdev - data physical device handle 518 * @param peer_id - which peer the security info is for 519 * @param sec_type - which type of security / key the peer is using 520 * @param is_unicast - whether security spec is for a unicast or multicast key 521 * @param michael_key - key used for TKIP MIC (if sec_type == TKIP) 522 * @param rx_pn - RSC used for WAPI PN replay check (if sec_type == WAPI) 523 */ 524 void 525 ol_rx_sec_ind_handler(ol_txrx_pdev_handle pdev, 526 uint16_t peer_id, 527 enum htt_sec_type sec_type, 528 int is_unicast, uint32_t *michael_key, uint32_t *rx_pn); 529 530 /** 531 * @brief Process an ADDBA message sent by the target. 532 * @details 533 * When the target notifies the host of an ADDBA event for a specified 534 * peer-TID, the host will set up the rx reordering state for the peer-TID. 535 * Specifically, the host will create a rx reordering array whose length 536 * is based on the window size specified in the ADDBA. 537 * 538 * @param pdev - data physical device handle 539 * (registered with HTT as a context pointer during attach time) 540 * @param peer_id - which peer the ADDBA event is for 541 * @param tid - which traffic ID within the peer the ADDBA event is for 542 * @param win_sz - how many sequence numbers are in the ARQ block ack window 543 * set up by the ADDBA event 544 * @param start_seq_num - the initial value of the sequence number during the 545 * block ack agreement, as specified by the ADDBA request. 546 * @param failed - indicate whether the target's ADDBA setup succeeded: 547 * 0 -> success, 1 -> fail 548 */ 549 void 550 ol_rx_addba_handler(ol_txrx_pdev_handle pdev, 551 uint16_t peer_id, 552 uint8_t tid, 553 uint8_t win_sz, uint16_t start_seq_num, uint8_t failed); 554 555 /** 556 * @brief Process a DELBA message sent by the target. 557 * @details 558 * When the target notifies the host of a DELBA event for a specified 559 * peer-TID, the host will clean up the rx reordering state for the peer-TID. 560 * Specifically, the host will remove the rx reordering array, and will 561 * set the reorder window size to be 1 (stop and go ARQ). 562 * 563 * @param pdev - data physical device handle 564 * (registered with HTT as a context pointer during attach time) 565 * @param peer_id - which peer the ADDBA event is for 566 * @param tid - which traffic ID within the peer the ADDBA event is for 567 */ 568 void 569 ol_rx_delba_handler(ol_txrx_pdev_handle pdev, uint16_t peer_id, uint8_t tid); 570 571 enum htt_rx_flush_action { 572 htt_rx_flush_release, 573 htt_rx_flush_discard, 574 }; 575 576 /** 577 * @brief Process a rx reorder flush message sent by the target. 578 * @details 579 * The target's rx reorder logic can send a flush indication to the 580 * host's rx reorder buffering either as a flush IE within a rx 581 * indication message, or as a standalone rx reorder flush message. 582 * This ol_rx_flush_handler function processes the standalone rx 583 * reorder flush message from the target. 584 * The flush message specifies a range of sequence numbers whose 585 * rx frames are flushed. 586 * Some sequence numbers within the specified range may not have 587 * rx frames; the host needs to check for each sequence number in 588 * the specified range whether there are rx frames held for that 589 * sequence number. 590 * 591 * @param pdev - data physical device handle 592 * (registered with HTT as a context pointer during attach time) 593 * @param peer_id - which peer's rx data is being flushed 594 * @param tid - which traffic ID within the peer has the rx data being flushed 595 * @param seq_num_start - Which sequence number within the rx reordering 596 * buffer the flushing should start with. 597 * This is the LSBs of the 802.11 sequence number. 598 * This sequence number is masked with the rounded-to-power-of-two 599 * window size to generate a reorder buffer index. 600 * The flush includes this initial sequence number. 601 * @param seq_num_end - Which sequence number within the rx reordering 602 * buffer the flushing should stop at. 603 * This is the LSBs of the 802.11 sequence number. 604 * This sequence number is masked with the rounded-to-power-of-two 605 * window size to generate a reorder buffer index. 606 * The flush excludes this final sequence number. 607 * @param action - whether to release or discard the rx frames 608 */ 609 void 610 ol_rx_flush_handler(ol_txrx_pdev_handle pdev, 611 uint16_t peer_id, 612 uint8_t tid, 613 uint16_t seq_num_start, 614 uint16_t seq_num_end, enum htt_rx_flush_action action); 615 616 /** 617 * @brief Process a rx pn indication message 618 * @details 619 * When the peer is configured to get PN checking done in target, 620 * the target instead of sending reorder flush/release messages 621 * sends PN indication messages which contain the start and end 622 * sequence numbers to be flushed/released along with the sequence 623 * numbers of MPDUs that failed the PN check in target. 624 * 625 * @param pdev - data physical device handle 626 * (registered with HTT as a context pointer during attach time) 627 * @param peer_id - which peer's rx data is being flushed 628 * @param tid - which traffic ID within the peer 629 * @param seq_num_start - Which sequence number within the rx reordering 630 * buffer to start with. 631 * This is the LSBs of the 802.11 sequence number. 632 * This sequence number is masked with the rounded-to-power-of-two 633 * window size to generate a reorder buffer index. 634 * This is the initial sequence number. 635 * @param seq_num_end - Which sequence number within the rx reordering 636 * buffer to stop at. 637 * This is the LSBs of the 802.11 sequence number. 638 * This sequence number is masked with the rounded-to-power-of-two 639 * window size to generate a reorder buffer index. 640 * The processing stops right before this sequence number 641 * @param pn_ie_cnt - Indicates the number of PN information elements. 642 * @param pn_ie - Pointer to the array of PN information elements. Each 643 * PN information element contains the LSBs of the 802.11 sequence number 644 * of the MPDU that failed the PN checking in target. 645 */ 646 void 647 ol_rx_pn_ind_handler(ol_txrx_pdev_handle pdev, 648 uint16_t peer_id, 649 uint8_t tid, 650 uint16_t seq_num_start, 651 uint16_t seq_num_end, uint8_t pn_ie_cnt, uint8_t *pn_ie); 652 653 /** 654 * @brief Process a stats message sent by the target. 655 * @details 656 * The host can request target for stats. 657 * The target sends the stats to the host via a confirmation message. 658 * This ol_txrx_fw_stats_handler function processes the confirmation message. 659 * Currently, this processing consists of copying the stats from the message 660 * buffer into the txrx pdev object, and waking the sleeping host context 661 * that requested the stats. 662 * 663 * @param pdev - data physical device handle 664 * (registered with HTT as a context pointer during attach time) 665 * @param cookie - Value echoed from the cookie in the stats request 666 * message. This allows the host SW to find the stats request object. 667 * (Currently, this cookie is unused.) 668 * @param stats_info_list - stats confirmation message contents, containing 669 * a list of the stats requested from the target 670 */ 671 void 672 ol_txrx_fw_stats_handler(ol_txrx_pdev_handle pdev, 673 uint8_t cookie, uint8_t *stats_info_list); 674 675 /** 676 * @brief Process a tx inspect message sent by the target. 677 * @details: 678 * TODO: update 679 * This tx inspect message indicates via the descriptor ID 680 * which tx frames are to be inspected by host. The host 681 * re-injects the packet back to the host for a number of 682 * cases. 683 * 684 * @param pdev - the data physical device that sent the tx frames 685 * (registered with HTT as a context pointer during attach time) 686 * @param num_msdus - how many MSDUs are referenced by the tx completion 687 * message 688 * @param tx_msdu_id_iterator - abstract method of finding the IDs for the 689 * individual MSDUs referenced by the tx completion message, via the 690 * htt_tx_compl_desc_id API function 691 */ 692 void 693 ol_tx_inspect_handler(ol_txrx_pdev_handle pdev, 694 int num_msdus, void *tx_desc_id_iterator); 695 696 /** 697 * @brief Get the UAPSD mask. 698 * @details 699 * This function will return the UAPSD TID mask. 700 * 701 * @param txrx_pdev - pointer to the txrx pdev object 702 * @param peer_id - PeerID. 703 * @return uapsd mask value 704 */ 705 uint8_t 706 ol_txrx_peer_uapsdmask_get(struct ol_txrx_pdev_t *txrx_pdev, uint16_t peer_id); 707 708 /** 709 * @brief Get the Qos Capable. 710 * @details 711 * This function will return the txrx_peer qos_capable. 712 * 713 * @param txrx_pdev - pointer to the txrx pdev object 714 * @param peer_id - PeerID. 715 * @return qos_capable value 716 */ 717 uint8_t 718 ol_txrx_peer_qoscapable_get(struct ol_txrx_pdev_t *txrx_pdev, uint16_t peer_id); 719 720 /** 721 * @brief Process an rx indication message sent by the target. 722 * @details 723 * The target sends a rx indication message to the host as a 724 * notification that there are new rx frames available for the 725 * host to process. 726 * The HTT host layer locates the rx descriptors and rx frames 727 * associated with the indication, and calls this function to 728 * invoke the rx data processing on the new frames. 729 * All MPDUs referenced by a rx indication message belong to the 730 * same peer-TID. The frames indicated have been re-ordered by 731 * the target. 732 * 733 * @param pdev - the data physical device that received the frames 734 * (registered with HTT as a context pointer during attach time) 735 * @param rx_ind_msg - the network buffer holding the rx indication message 736 * @param peer_id - which peer sent this rx data 737 * @param tid - what (extended) traffic type the rx data is 738 * @param is_offload - is this an offload indication? 739 */ 740 #ifdef WLAN_FULL_REORDER_OFFLOAD 741 void 742 ol_rx_in_order_indication_handler(ol_txrx_pdev_handle pdev, 743 qdf_nbuf_t rx_ind_msg, 744 uint16_t peer_id, 745 uint8_t tid, uint8_t is_offload); 746 #else 747 static inline void ol_rx_in_order_indication_handler(ol_txrx_pdev_handle pdev,qdf_nbuf_t rx_ind_msg,uint16_t peer_id,uint8_t tid,uint8_t is_offload)748 ol_rx_in_order_indication_handler(ol_txrx_pdev_handle pdev, 749 qdf_nbuf_t rx_ind_msg, 750 uint16_t peer_id, 751 uint8_t tid, uint8_t is_offload) 752 { 753 } 754 #endif 755 756 #ifdef FEATURE_HL_GROUP_CREDIT_FLOW_CONTROL 757 758 /** 759 * ol_tx_get_max_tx_groups_supported() - get max TCQ groups supported 760 * @pdev: the data physical device that received the frames 761 * 762 * Return: number of max groups supported 763 */ 764 u_int32_t ol_tx_get_max_tx_groups_supported(struct ol_txrx_pdev_t *pdev); 765 #else 766 767 static inline u_int32_t ol_tx_get_max_tx_groups_supported(struct ol_txrx_pdev_t * pdev)768 ol_tx_get_max_tx_groups_supported(struct ol_txrx_pdev_t *pdev) 769 { 770 return 0; 771 } 772 #endif 773 774 #if defined(FEATURE_HL_GROUP_CREDIT_FLOW_CONTROL) && \ 775 defined(FEATURE_HL_DBS_GROUP_CREDIT_SHARING) 776 int ol_txrx_distribute_group_credits(struct ol_txrx_pdev_t *pdev, u8 group_id, 777 u32 membership_new); 778 #else ol_txrx_distribute_group_credits(struct ol_txrx_pdev_t * pdev,u8 group_id,u32 membership_new)779 static inline int ol_txrx_distribute_group_credits(struct ol_txrx_pdev_t *pdev, 780 u8 group_id, 781 u32 membership_new) 782 { 783 return 0; 784 } 785 #endif /* 786 * FEATURE_HL_GROUP_CREDIT_FLOW_CONTROL && 787 * FEATURE_HL_DBS_GROUP_CREDIT_SHARING 788 */ 789 790 #ifdef WLAN_CFR_ENABLE 791 /** 792 * ol_rx_cfr_capture_msg_handler() - handler for HTT_PEER_CFR_CAPTURE_MSG_TYPE_1 793 * @htt_t2h_msg: htt msg data 794 * 795 * Return: None 796 */ 797 void ol_rx_cfr_capture_msg_handler(qdf_nbuf_t htt_t2h_msg); 798 #else ol_rx_cfr_capture_msg_handler(qdf_nbuf_t htt_t2h_msg)799 static inline void ol_rx_cfr_capture_msg_handler(qdf_nbuf_t htt_t2h_msg) 800 { 801 } 802 #endif 803 804 #endif /* _OL_TXRX_HTT_API__H_ */ 805