1 /* 2 * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2021-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 #ifndef _HAL_LI_RX_H_ 21 #define _HAL_LI_RX_H_ 22 23 #include <hal_rx.h> 24 25 /* 26 * macro to set the cookie into the rxdma ring entry 27 */ 28 #define HAL_RXDMA_COOKIE_SET(buff_addr_info, cookie) \ 29 ((*(((unsigned int *)buff_addr_info) + \ 30 (BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_OFFSET >> 2))) &= \ 31 ~BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_MASK); \ 32 ((*(((unsigned int *)buff_addr_info) + \ 33 (BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_OFFSET >> 2))) |= \ 34 ((cookie) << BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_LSB) & \ 35 BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_MASK) 36 37 /* 38 * macro to set the manager into the rxdma ring entry 39 */ 40 #define HAL_RXDMA_MANAGER_SET(buff_addr_info, manager) \ 41 ((*(((unsigned int *)buff_addr_info) + \ 42 (BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_OFFSET >> 2))) &= \ 43 ~BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_MASK); \ 44 ((*(((unsigned int *)buff_addr_info) + \ 45 (BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_OFFSET >> 2))) |= \ 46 ((manager) << BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_LSB) & \ 47 BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_MASK) 48 49 #define HAL_RX_ERROR_STATUS_GET(reo_desc) \ 50 (_HAL_MS((*_OFFSET_TO_WORD_PTR(reo_desc, \ 51 REO_DESTINATION_RING_7_REO_PUSH_REASON_OFFSET)),\ 52 REO_DESTINATION_RING_7_REO_PUSH_REASON_MASK, \ 53 REO_DESTINATION_RING_7_REO_PUSH_REASON_LSB)) 54 55 #define HAL_RX_BUF_COOKIE_GET(buff_addr_info) \ 56 (_HAL_MS((*_OFFSET_TO_WORD_PTR(buff_addr_info, \ 57 BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_OFFSET)), \ 58 BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_MASK, \ 59 BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_LSB)) 60 61 #define HAL_RX_BUF_RBM_GET(buff_addr_info) \ 62 (_HAL_MS((*_OFFSET_TO_WORD_PTR(buff_addr_info, \ 63 BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_OFFSET)),\ 64 BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_MASK, \ 65 BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_LSB)) 66 67 /* TODO: Convert the following structure fields accesseses to offsets */ 68 69 #define HAL_RX_REO_BUF_COOKIE_GET(reo_desc) \ 70 (HAL_RX_BUF_COOKIE_GET(& \ 71 (((struct reo_destination_ring *) \ 72 reo_desc)->buf_or_link_desc_addr_info))) 73 74 #define HAL_RX_MPDU_SEQUENCE_NUMBER_GET(mpdu_info_ptr) \ 75 ((mpdu_info_ptr \ 76 [RX_MPDU_DESC_INFO_0_MPDU_SEQUENCE_NUMBER_OFFSET >> 2] & \ 77 RX_MPDU_DESC_INFO_0_MPDU_SEQUENCE_NUMBER_MASK) >> \ 78 RX_MPDU_DESC_INFO_0_MPDU_SEQUENCE_NUMBER_LSB) 79 80 #define HAL_RX_MPDU_DESC_PEER_META_DATA_GET(mpdu_info_ptr) \ 81 ((mpdu_info_ptr \ 82 [RX_MPDU_DESC_INFO_1_PEER_META_DATA_OFFSET >> 2] & \ 83 RX_MPDU_DESC_INFO_1_PEER_META_DATA_MASK) >> \ 84 RX_MPDU_DESC_INFO_1_PEER_META_DATA_LSB) 85 86 #define HAL_RX_MPDU_MSDU_COUNT_GET(mpdu_info_ptr) \ 87 ((mpdu_info_ptr[RX_MPDU_DESC_INFO_0_MSDU_COUNT_OFFSET >> 2] & \ 88 RX_MPDU_DESC_INFO_0_MSDU_COUNT_MASK) >> \ 89 RX_MPDU_DESC_INFO_0_MSDU_COUNT_LSB) 90 91 #define HAL_RX_MPDU_FRAGMENT_FLAG_GET(mpdu_info_ptr) \ 92 (mpdu_info_ptr[RX_MPDU_DESC_INFO_0_FRAGMENT_FLAG_OFFSET >> 2] & \ 93 RX_MPDU_DESC_INFO_0_FRAGMENT_FLAG_MASK) 94 95 #define HAL_RX_MPDU_RETRY_BIT_GET(mpdu_info_ptr) \ 96 (mpdu_info_ptr[RX_MPDU_DESC_INFO_0_MPDU_RETRY_BIT_OFFSET >> 2] & \ 97 RX_MPDU_DESC_INFO_0_MPDU_RETRY_BIT_MASK) 98 99 #define HAL_RX_MPDU_AMPDU_FLAG_GET(mpdu_info_ptr) \ 100 (mpdu_info_ptr[RX_MPDU_DESC_INFO_0_AMPDU_FLAG_OFFSET >> 2] & \ 101 RX_MPDU_DESC_INFO_0_AMPDU_FLAG_MASK) 102 103 #define HAL_RX_MPDU_RAW_MPDU_GET(mpdu_info_ptr) \ 104 (mpdu_info_ptr[RX_MPDU_DESC_INFO_0_RAW_MPDU_OFFSET >> 2] & \ 105 RX_MPDU_DESC_INFO_0_RAW_MPDU_MASK) 106 107 #define HAL_RX_MPDU_FLAGS_GET(mpdu_info_ptr) \ 108 (HAL_RX_MPDU_FRAGMENT_FLAG_GET(mpdu_info_ptr) | \ 109 HAL_RX_MPDU_RETRY_BIT_GET(mpdu_info_ptr) | \ 110 HAL_RX_MPDU_AMPDU_FLAG_GET(mpdu_info_ptr) | \ 111 HAL_RX_MPDU_RAW_MPDU_GET(mpdu_info_ptr)) 112 113 #define HAL_RX_MPDU_BAR_FRAME_GET(mpdu_info_ptr) \ 114 ((mpdu_info_ptr[RX_MPDU_DESC_INFO_0_BAR_FRAME_OFFSET >> 2] & \ 115 RX_MPDU_DESC_INFO_0_BAR_FRAME_MASK) >> \ 116 RX_MPDU_DESC_INFO_0_BAR_FRAME_LSB) 117 118 /* 119 * NOTE: None of the following _GET macros need a right 120 * shift by the corresponding _LSB. This is because, they are 121 * finally taken and "OR'ed" into a single word again. 122 */ 123 #define HAL_RX_MSDU_CONTINUATION_FLAG_SET(msdu_info_ptr, val) \ 124 ((*(((uint32_t *)msdu_info_ptr) + \ 125 (RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_OFFSET >> 2))) |= \ 126 ((val) << RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_LSB) & \ 127 RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_MASK) 128 129 #define HAL_RX_MSDU_CONTINUATION_FLAG_GET(msdu_info_ptr) \ 130 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 131 RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_OFFSET)) & \ 132 RX_MSDU_DESC_INFO_0_MSDU_CONTINUATION_MASK) 133 134 #define HAL_RX_MSDU_REO_DST_IND_GET(msdu_info_ptr) \ 135 (_HAL_MS((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 136 RX_MSDU_DESC_INFO_0_REO_DESTINATION_INDICATION_OFFSET)), \ 137 RX_MSDU_DESC_INFO_0_REO_DESTINATION_INDICATION_MASK, \ 138 RX_MSDU_DESC_INFO_0_REO_DESTINATION_INDICATION_LSB)) 139 140 #define HAL_RX_MSDU_SA_IS_VALID_FLAG_GET(msdu_info_ptr) \ 141 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 142 RX_MSDU_DESC_INFO_0_SA_IS_VALID_OFFSET)) & \ 143 RX_MSDU_DESC_INFO_0_SA_IS_VALID_MASK) 144 145 #define HAL_RX_MSDU_SA_IDX_TIMEOUT_FLAG_GET(msdu_info_ptr) \ 146 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 147 RX_MSDU_DESC_INFO_0_SA_IDX_TIMEOUT_OFFSET)) & \ 148 RX_MSDU_DESC_INFO_0_SA_IDX_TIMEOUT_MASK) 149 150 #define HAL_RX_MSDU_DA_IS_VALID_FLAG_GET(msdu_info_ptr) \ 151 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 152 RX_MSDU_DESC_INFO_0_DA_IS_VALID_OFFSET)) & \ 153 RX_MSDU_DESC_INFO_0_DA_IS_VALID_MASK) 154 155 #define HAL_RX_MSDU_DA_IS_MCBC_FLAG_GET(msdu_info_ptr) \ 156 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 157 RX_MSDU_DESC_INFO_0_DA_IS_MCBC_OFFSET)) & \ 158 RX_MSDU_DESC_INFO_0_DA_IS_MCBC_MASK) 159 160 #define HAL_RX_MSDU_DA_IDX_TIMEOUT_FLAG_GET(msdu_info_ptr) \ 161 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 162 RX_MSDU_DESC_INFO_0_DA_IDX_TIMEOUT_OFFSET)) & \ 163 RX_MSDU_DESC_INFO_0_DA_IDX_TIMEOUT_MASK) 164 165 #define HAL_RX_REO_MSDU_REO_DST_IND_GET(reo_desc) \ 166 (HAL_RX_MSDU_REO_DST_IND_GET(& \ 167 (((struct reo_destination_ring *) \ 168 reo_desc)->rx_msdu_desc_info_details))) 169 170 #define HAL_RX_MPDU_ENCRYPT_TYPE_GET(_rx_mpdu_info) \ 171 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \ 172 RX_MPDU_INFO_3_ENCRYPT_TYPE_OFFSET)), \ 173 RX_MPDU_INFO_3_ENCRYPT_TYPE_MASK, \ 174 RX_MPDU_INFO_3_ENCRYPT_TYPE_LSB)) 175 176 #define HAL_RX_MSDU_DESC_INFO_SET(_msdu_info_ptr, _field, _val) \ 177 HAL_RX_FLD_SET(_msdu_info_ptr, RX_MSDU_DESC_INFO_0, \ 178 _field, _val) 179 180 #define HAL_RX_MPDU_DESC_INFO_SET(_mpdu_info_ptr, _field, _val) \ 181 HAL_RX_FLD_SET(_mpdu_info_ptr, RX_MPDU_DESC_INFO_0, \ 182 _field, _val) 183 184 /* 185 * Structures & Macros to obtain fields from the TLV's in the Rx packet 186 * pre-header. 187 */ 188 189 /* 190 * Every Rx packet starts at an offset from the top of the buffer. 191 * If the host hasn't subscribed to any specific TLV, there is 192 * still space reserved for the following TLV's from the start of 193 * the buffer: 194 * -- RX ATTENTION 195 * -- RX MPDU START 196 * -- RX MSDU START 197 * -- RX MSDU END 198 * -- RX MPDU END 199 * -- RX PACKET HEADER (802.11) 200 * If the host subscribes to any of the TLV's above, that TLV 201 * if populated by the HW 202 */ 203 204 #define NUM_DWORDS_TAG 1 205 206 /* By default the packet header TLV is 128 bytes */ 207 #define NUM_OF_BYTES_RX_802_11_HDR_TLV 128 208 #define NUM_OF_DWORDS_RX_802_11_HDR_TLV \ 209 (NUM_OF_BYTES_RX_802_11_HDR_TLV >> 2) 210 211 #define RX_PKT_OFFSET_WORDS \ 212 ( \ 213 NUM_OF_DWORDS_RX_ATTENTION + NUM_DWORDS_TAG \ 214 NUM_OF_DWORDS_RX_MPDU_START + NUM_DWORDS_TAG \ 215 NUM_OF_DWORDS_RX_MSDU_START + NUM_DWORDS_TAG \ 216 NUM_OF_DWORDS_RX_MSDU_END + NUM_DWORDS_TAG \ 217 NUM_OF_DWORDS_RX_MPDU_END + NUM_DWORDS_TAG \ 218 NUM_OF_DWORDS_RX_802_11_HDR_TLV + NUM_DWORDS_TAG \ 219 ) 220 221 #define RX_PKT_OFFSET_BYTES \ 222 (RX_PKT_OFFSET_WORDS << 2) 223 224 #define RX_PKT_HDR_TLV_LEN 120 225 226 /* 227 * Each RX descriptor TLV is preceded by 1 DWORD "tag" 228 */ 229 struct rx_attention_tlv { 230 uint32_t tag; 231 struct rx_attention rx_attn; 232 }; 233 234 struct rx_mpdu_start_tlv { 235 uint32_t tag; 236 struct rx_mpdu_start rx_mpdu_start; 237 }; 238 239 struct rx_msdu_start_tlv { 240 uint32_t tag; 241 struct rx_msdu_start rx_msdu_start; 242 }; 243 244 struct rx_msdu_end_tlv { 245 uint32_t tag; 246 struct rx_msdu_end rx_msdu_end; 247 }; 248 249 struct rx_mpdu_end_tlv { 250 uint32_t tag; 251 struct rx_mpdu_end rx_mpdu_end; 252 }; 253 254 struct rx_pkt_hdr_tlv { 255 uint32_t tag; /* 4 B */ 256 uint32_t phy_ppdu_id; /* 4 B */ 257 char rx_pkt_hdr[RX_PKT_HDR_TLV_LEN]; /* 120 B */ 258 }; 259 260 /* rx_pkt_tlvs structure should be used to process Data buffers, monitor status 261 * buffers, monitor destination buffers and monitor descriptor buffers. 262 */ 263 #ifdef RXDMA_OPTIMIZATION 264 /* 265 * The RX_PADDING_BYTES is required so that the TLV's don't 266 * spread across the 128 byte boundary 267 * RXDMA optimization requires: 268 * 1) MSDU_END & ATTENTION TLV's follow in that order 269 * 2) TLV's don't span across 128 byte lines 270 * 3) Rx Buffer is nicely aligned on the 128 byte boundary 271 */ 272 #define RX_PADDING0_BYTES 4 273 #define RX_PADDING1_BYTES 16 274 #if defined(IPA_OFFLOAD) && defined(IPA_WDS_EASYMESH_FEATURE) 275 struct rx_pkt_tlvs { 276 struct rx_msdu_end_tlv msdu_end_tlv; /* 72 bytes */ 277 struct rx_attention_tlv attn_tlv; /* 16 bytes */ 278 struct rx_mpdu_start_tlv mpdu_start_tlv;/* 96 bytes */ 279 struct rx_msdu_start_tlv msdu_start_tlv;/* 40 bytes */ 280 uint8_t rx_padding0[RX_PADDING0_BYTES]; /* 4 bytes */ 281 struct rx_mpdu_end_tlv mpdu_end_tlv; /* 12 bytes */ 282 uint8_t rx_padding1[RX_PADDING1_BYTES]; /* 16 bytes */ 283 #ifndef NO_RX_PKT_HDR_TLV 284 struct rx_pkt_hdr_tlv pkt_hdr_tlv; /* 128 bytes */ 285 #endif 286 }; 287 #else 288 struct rx_pkt_tlvs { 289 struct rx_msdu_end_tlv msdu_end_tlv; /* 72 bytes */ 290 struct rx_attention_tlv attn_tlv; /* 16 bytes */ 291 struct rx_msdu_start_tlv msdu_start_tlv;/* 40 bytes */ 292 uint8_t rx_padding0[RX_PADDING0_BYTES]; /* 4 bytes */ 293 struct rx_mpdu_start_tlv mpdu_start_tlv;/* 96 bytes */ 294 struct rx_mpdu_end_tlv mpdu_end_tlv; /* 12 bytes */ 295 uint8_t rx_padding1[RX_PADDING1_BYTES]; /* 16 bytes */ 296 #ifndef NO_RX_PKT_HDR_TLV 297 struct rx_pkt_hdr_tlv pkt_hdr_tlv; /* 128 bytes */ 298 #endif 299 }; 300 #endif 301 #else /* RXDMA_OPTIMIZATION */ 302 struct rx_pkt_tlvs { 303 struct rx_attention_tlv attn_tlv; 304 struct rx_mpdu_start_tlv mpdu_start_tlv; 305 struct rx_msdu_start_tlv msdu_start_tlv; 306 struct rx_msdu_end_tlv msdu_end_tlv; 307 struct rx_mpdu_end_tlv mpdu_end_tlv; 308 struct rx_pkt_hdr_tlv pkt_hdr_tlv; 309 }; 310 #endif /* RXDMA_OPTIMIZATION */ 311 312 /* rx_mon_pkt_tlvs structure should be used to process monitor data buffers */ 313 #ifdef RXDMA_OPTIMIZATION 314 struct rx_mon_pkt_tlvs { 315 struct rx_msdu_end_tlv msdu_end_tlv; /* 72 bytes */ 316 struct rx_attention_tlv attn_tlv; /* 16 bytes */ 317 struct rx_msdu_start_tlv msdu_start_tlv;/* 40 bytes */ 318 uint8_t rx_padding0[RX_PADDING0_BYTES]; /* 4 bytes */ 319 struct rx_mpdu_start_tlv mpdu_start_tlv;/* 96 bytes */ 320 struct rx_mpdu_end_tlv mpdu_end_tlv; /* 12 bytes */ 321 uint8_t rx_padding1[RX_PADDING1_BYTES]; /* 16 bytes */ 322 struct rx_pkt_hdr_tlv pkt_hdr_tlv; /* 128 bytes */ 323 }; 324 #else /* RXDMA_OPTIMIZATION */ 325 struct rx_mon_pkt_tlvs { 326 struct rx_attention_tlv attn_tlv; 327 struct rx_mpdu_start_tlv mpdu_start_tlv; 328 struct rx_msdu_start_tlv msdu_start_tlv; 329 struct rx_msdu_end_tlv msdu_end_tlv; 330 struct rx_mpdu_end_tlv mpdu_end_tlv; 331 struct rx_pkt_hdr_tlv pkt_hdr_tlv; 332 }; 333 #endif 334 335 #define SIZE_OF_MONITOR_TLV sizeof(struct rx_mon_pkt_tlvs) 336 #define SIZE_OF_DATA_RX_TLV sizeof(struct rx_pkt_tlvs) 337 338 #define RX_PKT_TLVS_LEN SIZE_OF_DATA_RX_TLV 339 340 #define RX_PKT_TLV_OFFSET(field) qdf_offsetof(struct rx_pkt_tlvs, field) 341 342 #define HAL_RX_PKT_TLV_MPDU_START_OFFSET(hal_soc) \ 343 RX_PKT_TLV_OFFSET(mpdu_start_tlv) 344 #define HAL_RX_PKT_TLV_MPDU_END_OFFSET(hal_soc) RX_PKT_TLV_OFFSET(mpdu_end_tlv) 345 #define HAL_RX_PKT_TLV_MSDU_START_OFFSET(hal_soc) \ 346 RX_PKT_TLV_OFFSET(msdu_start_tlv) 347 #define HAL_RX_PKT_TLV_MSDU_END_OFFSET(hal_soc) RX_PKT_TLV_OFFSET(msdu_end_tlv) 348 #define HAL_RX_PKT_TLV_ATTN_OFFSET(hal_soc) RX_PKT_TLV_OFFSET(attn_tlv) 349 #define HAL_RX_PKT_TLV_PKT_HDR_OFFSET(hal_soc) RX_PKT_TLV_OFFSET(pkt_hdr_tlv) 350 351 /** 352 * hal_rx_get_pkt_tlvs(): Function to retrieve pkt tlvs from nbuf 353 * 354 * @nbuf: Pointer to data buffer field 355 * Returns: pointer to rx_pkt_tlvs 356 */ 357 static inline 358 struct rx_pkt_tlvs *hal_rx_get_pkt_tlvs(uint8_t *rx_buf_start) 359 { 360 return (struct rx_pkt_tlvs *)rx_buf_start; 361 } 362 363 /** 364 * hal_rx_get_mpdu_info(): Function to retrieve mpdu info from pkt tlvs 365 * 366 * @pkt_tlvs: Pointer to pkt_tlvs 367 * Returns: pointer to rx_mpdu_info structure 368 */ 369 static inline 370 struct rx_mpdu_info *hal_rx_get_mpdu_info(struct rx_pkt_tlvs *pkt_tlvs) 371 { 372 return &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start.rx_mpdu_info_details; 373 } 374 375 /** 376 * hal_rx_mon_dest_get_buffer_info_from_tlv(): Retrieve mon dest frame info 377 * from the reserved bytes of rx_tlv_hdr. 378 * @buf: start of rx_tlv_hdr 379 * @buf_info: hal_rx_mon_dest_buf_info structure 380 * 381 * Return: void 382 */ 383 static inline void hal_rx_mon_dest_get_buffer_info_from_tlv( 384 uint8_t *buf, 385 struct hal_rx_mon_dest_buf_info *buf_info) 386 { 387 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 388 389 qdf_mem_copy(buf_info, pkt_tlvs->rx_padding0, 390 sizeof(struct hal_rx_mon_dest_buf_info)); 391 } 392 393 /* 394 * Get msdu_done bit from the RX_ATTENTION TLV 395 */ 396 #define HAL_RX_ATTN_MSDU_DONE_GET(_rx_attn) \ 397 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \ 398 RX_ATTENTION_2_MSDU_DONE_OFFSET)), \ 399 RX_ATTENTION_2_MSDU_DONE_MASK, \ 400 RX_ATTENTION_2_MSDU_DONE_LSB)) 401 402 #define HAL_RX_ATTN_FIRST_MPDU_GET(_rx_attn) \ 403 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \ 404 RX_ATTENTION_1_FIRST_MPDU_OFFSET)), \ 405 RX_ATTENTION_1_FIRST_MPDU_MASK, \ 406 RX_ATTENTION_1_FIRST_MPDU_LSB)) 407 408 #define HAL_RX_ATTN_TCP_UDP_CKSUM_FAIL_GET(_rx_attn) \ 409 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \ 410 RX_ATTENTION_1_TCP_UDP_CHKSUM_FAIL_OFFSET)), \ 411 RX_ATTENTION_1_TCP_UDP_CHKSUM_FAIL_MASK, \ 412 RX_ATTENTION_1_TCP_UDP_CHKSUM_FAIL_LSB)) 413 414 /* 415 * hal_rx_attn_tcp_udp_cksum_fail_get(): get tcp_udp cksum fail bit 416 * from rx attention 417 * @buf: pointer to rx_pkt_tlvs 418 * 419 * Return: tcp_udp_cksum_fail 420 */ 421 static inline bool 422 hal_rx_attn_tcp_udp_cksum_fail_get(uint8_t *buf) 423 { 424 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 425 struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn; 426 uint8_t tcp_udp_cksum_fail; 427 428 tcp_udp_cksum_fail = HAL_RX_ATTN_TCP_UDP_CKSUM_FAIL_GET(rx_attn); 429 430 return !!tcp_udp_cksum_fail; 431 } 432 433 #define HAL_RX_ATTN_IP_CKSUM_FAIL_GET(_rx_attn) \ 434 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \ 435 RX_ATTENTION_1_IP_CHKSUM_FAIL_OFFSET)), \ 436 RX_ATTENTION_1_IP_CHKSUM_FAIL_MASK, \ 437 RX_ATTENTION_1_IP_CHKSUM_FAIL_LSB)) 438 439 /* 440 * hal_rx_attn_ip_cksum_fail_get(): get ip cksum fail bit 441 * from rx attention 442 * @buf: pointer to rx_pkt_tlvs 443 * 444 * Return: ip_cksum_fail 445 */ 446 static inline bool 447 hal_rx_attn_ip_cksum_fail_get(uint8_t *buf) 448 { 449 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 450 struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn; 451 uint8_t ip_cksum_fail; 452 453 ip_cksum_fail = HAL_RX_ATTN_IP_CKSUM_FAIL_GET(rx_attn); 454 455 return !!ip_cksum_fail; 456 } 457 458 #define HAL_RX_ATTN_PHY_PPDU_ID_GET(_rx_attn) \ 459 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \ 460 RX_ATTENTION_0_PHY_PPDU_ID_OFFSET)), \ 461 RX_ATTENTION_0_PHY_PPDU_ID_MASK, \ 462 RX_ATTENTION_0_PHY_PPDU_ID_LSB)) 463 464 #define HAL_RX_ATTN_CCE_MATCH_GET(_rx_attn) \ 465 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \ 466 RX_ATTENTION_1_CCE_MATCH_OFFSET)), \ 467 RX_ATTENTION_1_CCE_MATCH_MASK, \ 468 RX_ATTENTION_1_CCE_MATCH_LSB)) 469 470 /* 471 * hal_rx_msdu_cce_match_get_li(): get CCE match bit 472 * from rx attention 473 * @buf: pointer to rx_pkt_tlvs 474 * Return: CCE match value 475 */ 476 static inline bool 477 hal_rx_msdu_cce_match_get_li(uint8_t *buf) 478 { 479 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 480 struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn; 481 uint8_t cce_match_val; 482 483 cce_match_val = HAL_RX_ATTN_CCE_MATCH_GET(rx_attn); 484 return !!cce_match_val; 485 } 486 487 /* 488 * Get peer_meta_data from RX_MPDU_INFO within RX_MPDU_START 489 */ 490 #define HAL_RX_MPDU_PEER_META_DATA_GET(_rx_mpdu_info) \ 491 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \ 492 RX_MPDU_INFO_8_PEER_META_DATA_OFFSET)), \ 493 RX_MPDU_INFO_8_PEER_META_DATA_MASK, \ 494 RX_MPDU_INFO_8_PEER_META_DATA_LSB)) 495 496 static inline uint32_t 497 hal_rx_mpdu_peer_meta_data_get_li(uint8_t *buf) 498 { 499 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 500 struct rx_mpdu_start *mpdu_start = 501 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 502 503 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 504 uint32_t peer_meta_data; 505 506 peer_meta_data = HAL_RX_MPDU_PEER_META_DATA_GET(mpdu_info); 507 508 return peer_meta_data; 509 } 510 511 #define HAL_RX_MPDU_INFO_AMPDU_FLAG_GET(_rx_mpdu_info) \ 512 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \ 513 RX_MPDU_INFO_12_AMPDU_FLAG_OFFSET)), \ 514 RX_MPDU_INFO_12_AMPDU_FLAG_MASK, \ 515 RX_MPDU_INFO_12_AMPDU_FLAG_LSB)) 516 517 #define HAL_RX_MPDU_PEER_META_DATA_SET(_rx_mpdu_info, peer_mdata) \ 518 ((*(((uint32_t *)_rx_mpdu_info) + \ 519 (RX_MPDU_INFO_8_PEER_META_DATA_OFFSET >> 2))) = \ 520 ((peer_mdata) << RX_MPDU_INFO_8_PEER_META_DATA_LSB) & \ 521 RX_MPDU_INFO_8_PEER_META_DATA_MASK) 522 523 /* 524 * @ hal_rx_mpdu_peer_meta_data_set: set peer meta data in RX mpdu start tlv 525 * 526 * @ buf: rx_tlv_hdr of the received packet 527 * @ peer_mdata: peer meta data to be set. 528 * @ Return: void 529 */ 530 static inline void 531 hal_rx_mpdu_peer_meta_data_set(uint8_t *buf, uint32_t peer_mdata) 532 { 533 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 534 struct rx_mpdu_start *mpdu_start = 535 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 536 537 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 538 539 HAL_RX_MPDU_PEER_META_DATA_SET(mpdu_info, peer_mdata); 540 } 541 542 /** 543 * LRO information needed from the TLVs 544 */ 545 #define HAL_RX_TLV_GET_LRO_ELIGIBLE(buf) \ 546 (_HAL_MS( \ 547 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 548 msdu_end_tlv.rx_msdu_end), \ 549 RX_MSDU_END_9_LRO_ELIGIBLE_OFFSET)), \ 550 RX_MSDU_END_9_LRO_ELIGIBLE_MASK, \ 551 RX_MSDU_END_9_LRO_ELIGIBLE_LSB)) 552 553 #define HAL_RX_TLV_GET_TCP_ACK(buf) \ 554 (_HAL_MS( \ 555 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 556 msdu_end_tlv.rx_msdu_end), \ 557 RX_MSDU_END_8_TCP_ACK_NUMBER_OFFSET)), \ 558 RX_MSDU_END_8_TCP_ACK_NUMBER_MASK, \ 559 RX_MSDU_END_8_TCP_ACK_NUMBER_LSB)) 560 561 #define HAL_RX_TLV_GET_TCP_SEQ(buf) \ 562 (_HAL_MS( \ 563 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 564 msdu_end_tlv.rx_msdu_end), \ 565 RX_MSDU_END_7_TCP_SEQ_NUMBER_OFFSET)), \ 566 RX_MSDU_END_7_TCP_SEQ_NUMBER_MASK, \ 567 RX_MSDU_END_7_TCP_SEQ_NUMBER_LSB)) 568 569 #define HAL_RX_TLV_GET_TCP_WIN(buf) \ 570 (_HAL_MS( \ 571 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 572 msdu_end_tlv.rx_msdu_end), \ 573 RX_MSDU_END_9_WINDOW_SIZE_OFFSET)), \ 574 RX_MSDU_END_9_WINDOW_SIZE_MASK, \ 575 RX_MSDU_END_9_WINDOW_SIZE_LSB)) 576 577 #define HAL_RX_TLV_GET_TCP_PURE_ACK(buf) \ 578 (_HAL_MS( \ 579 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 580 msdu_start_tlv.rx_msdu_start), \ 581 RX_MSDU_START_2_TCP_ONLY_ACK_OFFSET)), \ 582 RX_MSDU_START_2_TCP_ONLY_ACK_MASK, \ 583 RX_MSDU_START_2_TCP_ONLY_ACK_LSB)) 584 585 #define HAL_RX_TLV_GET_TCP_PROTO(buf) \ 586 (_HAL_MS( \ 587 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 588 msdu_start_tlv.rx_msdu_start), \ 589 RX_MSDU_START_2_TCP_PROTO_OFFSET)), \ 590 RX_MSDU_START_2_TCP_PROTO_MASK, \ 591 RX_MSDU_START_2_TCP_PROTO_LSB)) 592 593 #define HAL_RX_TLV_GET_UDP_PROTO(buf) \ 594 (_HAL_MS( \ 595 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 596 msdu_start_tlv.rx_msdu_start), \ 597 RX_MSDU_START_2_UDP_PROTO_OFFSET)), \ 598 RX_MSDU_START_2_UDP_PROTO_MASK, \ 599 RX_MSDU_START_2_UDP_PROTO_LSB)) 600 601 #define HAL_RX_TLV_GET_IPV6(buf) \ 602 (_HAL_MS( \ 603 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 604 msdu_start_tlv.rx_msdu_start), \ 605 RX_MSDU_START_2_IPV6_PROTO_OFFSET)), \ 606 RX_MSDU_START_2_IPV6_PROTO_MASK, \ 607 RX_MSDU_START_2_IPV6_PROTO_LSB)) 608 609 #define HAL_RX_TLV_GET_IP_OFFSET(buf) \ 610 (_HAL_MS( \ 611 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 612 msdu_start_tlv.rx_msdu_start), \ 613 RX_MSDU_START_1_L3_OFFSET_OFFSET)), \ 614 RX_MSDU_START_1_L3_OFFSET_MASK, \ 615 RX_MSDU_START_1_L3_OFFSET_LSB)) 616 617 #define HAL_RX_TLV_GET_TCP_OFFSET(buf) \ 618 (_HAL_MS( \ 619 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 620 msdu_start_tlv.rx_msdu_start), \ 621 RX_MSDU_START_1_L4_OFFSET_OFFSET)), \ 622 RX_MSDU_START_1_L4_OFFSET_MASK, \ 623 RX_MSDU_START_1_L4_OFFSET_LSB)) 624 625 #define HAL_RX_TLV_GET_FLOW_ID_TOEPLITZ(buf) \ 626 (_HAL_MS( \ 627 (*_OFFSET_TO_WORD_PTR(&(((struct rx_pkt_tlvs *)(buf))->\ 628 msdu_start_tlv.rx_msdu_start), \ 629 RX_MSDU_START_4_FLOW_ID_TOEPLITZ_OFFSET)), \ 630 RX_MSDU_START_4_FLOW_ID_TOEPLITZ_MASK, \ 631 RX_MSDU_START_4_FLOW_ID_TOEPLITZ_LSB)) 632 633 #define HAL_RX_MSDU_START_MSDU_LEN_GET(_rx_msdu_start) \ 634 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \ 635 RX_MSDU_START_1_MSDU_LENGTH_OFFSET)), \ 636 RX_MSDU_START_1_MSDU_LENGTH_MASK, \ 637 RX_MSDU_START_1_MSDU_LENGTH_LSB)) 638 639 #define HAL_RX_MSDU_START_BW_GET(_rx_msdu_start) \ 640 (_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_msdu_start),\ 641 RX_MSDU_START_5_RECEIVE_BANDWIDTH_OFFSET)), \ 642 RX_MSDU_START_5_RECEIVE_BANDWIDTH_MASK, \ 643 RX_MSDU_START_5_RECEIVE_BANDWIDTH_LSB)) 644 645 #define HAL_RX_MSDU_START_FLOWID_TOEPLITZ_GET(_rx_msdu_start) \ 646 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \ 647 RX_MSDU_START_4_FLOW_ID_TOEPLITZ_OFFSET)), \ 648 RX_MSDU_START_4_FLOW_ID_TOEPLITZ_MASK, \ 649 RX_MSDU_START_4_FLOW_ID_TOEPLITZ_LSB)) 650 651 /** 652 * hal_rx_msdu_start_toeplitz_get: API to get the toeplitz hash 653 * from rx_msdu_start TLV 654 * 655 * @ buf: pointer to the start of RX PKT TLV headers 656 * Return: toeplitz hash 657 */ 658 static inline uint32_t 659 hal_rx_msdu_start_toeplitz_get(uint8_t *buf) 660 { 661 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 662 struct rx_msdu_start *msdu_start = 663 &pkt_tlvs->msdu_start_tlv.rx_msdu_start; 664 665 return HAL_RX_MSDU_START_FLOWID_TOEPLITZ_GET(msdu_start); 666 } 667 668 #define HAL_RX_MSDU_START_SGI_GET(_rx_msdu_start) \ 669 (_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_msdu_start),\ 670 RX_MSDU_START_5_SGI_OFFSET)), \ 671 RX_MSDU_START_5_SGI_MASK, \ 672 RX_MSDU_START_5_SGI_LSB)) 673 674 #define HAL_RX_MSDU_START_RATE_MCS_GET(_rx_msdu_start) \ 675 (_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_msdu_start),\ 676 RX_MSDU_START_5_RATE_MCS_OFFSET)), \ 677 RX_MSDU_START_5_RATE_MCS_MASK, \ 678 RX_MSDU_START_5_RATE_MCS_LSB)) 679 680 #define HAL_RX_ATTN_DECRYPT_STATUS_GET(_rx_attn) \ 681 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \ 682 RX_ATTENTION_2_DECRYPT_STATUS_CODE_OFFSET)), \ 683 RX_ATTENTION_2_DECRYPT_STATUS_CODE_MASK, \ 684 RX_ATTENTION_2_DECRYPT_STATUS_CODE_LSB)) 685 686 /* 687 * Get key index from RX_MSDU_END 688 */ 689 #define HAL_RX_MSDU_END_KEYID_OCTET_GET(_rx_msdu_end) \ 690 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_end, \ 691 RX_MSDU_END_2_KEY_ID_OCTET_OFFSET)), \ 692 RX_MSDU_END_2_KEY_ID_OCTET_MASK, \ 693 RX_MSDU_END_2_KEY_ID_OCTET_LSB)) 694 695 #define HAL_RX_MSDU_START_RSSI_GET(_rx_msdu_start) \ 696 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \ 697 RX_MSDU_START_5_USER_RSSI_OFFSET)), \ 698 RX_MSDU_START_5_USER_RSSI_MASK, \ 699 RX_MSDU_START_5_USER_RSSI_LSB)) 700 /* 701 * hal_rx_msdu_start_get_rssi(): API to get the rssi of received pkt 702 * from rx_msdu_start 703 * 704 * @buf: pointer to the start of RX PKT TLV header 705 * Return: uint32_t(rssi) 706 */ 707 static inline uint32_t 708 hal_rx_msdu_start_get_rssi(uint8_t *buf) 709 { 710 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 711 struct rx_msdu_start *msdu_start = 712 &pkt_tlvs->msdu_start_tlv.rx_msdu_start; 713 uint32_t rssi; 714 715 rssi = HAL_RX_MSDU_START_RSSI_GET(msdu_start); 716 717 return rssi; 718 } 719 720 #define HAL_RX_MSDU_START_FREQ_GET(_rx_msdu_start) \ 721 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \ 722 RX_MSDU_START_7_SW_PHY_META_DATA_OFFSET)), \ 723 RX_MSDU_START_7_SW_PHY_META_DATA_MASK, \ 724 RX_MSDU_START_7_SW_PHY_META_DATA_LSB)) 725 726 #define HAL_RX_MSDU_START_PKT_TYPE_GET(_rx_msdu_start) \ 727 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_msdu_start, \ 728 RX_MSDU_START_5_PKT_TYPE_OFFSET)), \ 729 RX_MSDU_START_5_PKT_TYPE_MASK, \ 730 RX_MSDU_START_5_PKT_TYPE_LSB)) 731 732 #define HAL_RX_MPDU_AD4_31_0_GET(_rx_mpdu_info) \ 733 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \ 734 RX_MPDU_INFO_20_MAC_ADDR_AD4_31_0_OFFSET)), \ 735 RX_MPDU_INFO_20_MAC_ADDR_AD4_31_0_MASK, \ 736 RX_MPDU_INFO_20_MAC_ADDR_AD4_31_0_LSB)) 737 738 #define HAL_RX_MPDU_AD4_47_32_GET(_rx_mpdu_info) \ 739 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \ 740 RX_MPDU_INFO_21_MAC_ADDR_AD4_47_32_OFFSET)), \ 741 RX_MPDU_INFO_21_MAC_ADDR_AD4_47_32_MASK, \ 742 RX_MPDU_INFO_21_MAC_ADDR_AD4_47_32_LSB)) 743 744 /******************************************************************************* 745 * RX ERROR APIS 746 ******************************************************************************/ 747 748 #define HAL_RX_MPDU_END_DECRYPT_ERR_GET(_rx_mpdu_end) \ 749 (_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_mpdu_end),\ 750 RX_MPDU_END_1_RX_IN_TX_DECRYPT_BYP_OFFSET)), \ 751 RX_MPDU_END_1_RX_IN_TX_DECRYPT_BYP_MASK, \ 752 RX_MPDU_END_1_RX_IN_TX_DECRYPT_BYP_LSB)) 753 754 #define HAL_RX_MPDU_END_MIC_ERR_GET(_rx_mpdu_end) \ 755 (_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_mpdu_end),\ 756 RX_MPDU_END_1_TKIP_MIC_ERR_OFFSET)), \ 757 RX_MPDU_END_1_TKIP_MIC_ERR_MASK, \ 758 RX_MPDU_END_1_TKIP_MIC_ERR_LSB)) 759 760 761 /******************************************************************************* 762 * RX REO ERROR APIS 763 ******************************************************************************/ 764 765 766 #define HAL_RX_REO_BUF_TYPE_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \ 767 (REO_DESTINATION_RING_7_REO_DEST_BUFFER_TYPE_OFFSET >> 2))) & \ 768 REO_DESTINATION_RING_7_REO_DEST_BUFFER_TYPE_MASK) >> \ 769 REO_DESTINATION_RING_7_REO_DEST_BUFFER_TYPE_LSB) 770 771 #define HAL_RX_REO_QUEUE_NUMBER_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \ 772 (REO_DESTINATION_RING_7_RECEIVE_QUEUE_NUMBER_OFFSET >> 2))) & \ 773 REO_DESTINATION_RING_7_RECEIVE_QUEUE_NUMBER_MASK) >> \ 774 REO_DESTINATION_RING_7_RECEIVE_QUEUE_NUMBER_LSB) 775 776 #define HAL_RX_REO_ERROR_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \ 777 (REO_DESTINATION_RING_7_REO_ERROR_CODE_OFFSET >> 2))) & \ 778 REO_DESTINATION_RING_7_REO_ERROR_CODE_MASK) >> \ 779 REO_DESTINATION_RING_7_REO_ERROR_CODE_LSB) 780 781 /* 782 * hal_rx_msdu_link_desc_reinject: Re-injects the MSDU link descriptor to 783 * REO entrance ring 784 * 785 * @ soc: HAL version of the SOC pointer 786 * @ pa: Physical address of the MSDU Link Descriptor 787 * @ cookie: SW cookie to get to the virtual address 788 * @ error_enabled_reo_q: Argument to determine whether this needs to go 789 * to the error enabled REO queue 790 * 791 * Return: void 792 */ 793 static inline 794 void hal_rx_msdu_link_desc_reinject(struct hal_soc *soc, 795 uint64_t pa, 796 uint32_t cookie, 797 bool error_enabled_reo_q) 798 { 799 /* TODO */ 800 } 801 802 #define HAL_RX_WBM_FIRST_MSDU_GET(wbm_desc) \ 803 (((*(((uint32_t *)wbm_desc) + \ 804 (WBM_RELEASE_RING_4_FIRST_MSDU_OFFSET >> 2))) & \ 805 WBM_RELEASE_RING_4_FIRST_MSDU_MASK) >> \ 806 WBM_RELEASE_RING_4_FIRST_MSDU_LSB) 807 808 #define HAL_RX_WBM_LAST_MSDU_GET(wbm_desc) \ 809 (((*(((uint32_t *)wbm_desc) + \ 810 (WBM_RELEASE_RING_4_LAST_MSDU_OFFSET >> 2))) & \ 811 WBM_RELEASE_RING_4_LAST_MSDU_MASK) >> \ 812 WBM_RELEASE_RING_4_LAST_MSDU_LSB) 813 814 #define HAL_RX_WBM_BUF_COOKIE_GET(wbm_desc) \ 815 HAL_RX_BUF_COOKIE_GET(&((struct wbm_release_ring *) \ 816 wbm_desc)->released_buff_or_desc_addr_info) 817 818 #define HAL_RX_WBM_BUF_ADDR_39_32_GET(wbm_desc) \ 819 (HAL_RX_BUFFER_ADDR_39_32_GET(& \ 820 (((struct wbm_release_ring *) \ 821 wbm_desc)->released_buff_or_desc_addr_info))) 822 823 #define HAL_RX_WBM_BUF_ADDR_31_0_GET(wbm_desc) \ 824 (HAL_RX_BUFFER_ADDR_31_0_GET(& \ 825 (((struct wbm_release_ring *) \ 826 wbm_desc)->released_buff_or_desc_addr_info))) 827 828 static inline 829 uint32_t 830 HAL_RX_DESC_GET_DECAP_FORMAT(void *hw_desc_addr) { 831 struct rx_msdu_start *rx_msdu_start; 832 struct rx_pkt_tlvs *rx_desc = (struct rx_pkt_tlvs *)hw_desc_addr; 833 834 rx_msdu_start = &rx_desc->msdu_start_tlv.rx_msdu_start; 835 836 return HAL_RX_GET(rx_msdu_start, RX_MSDU_START_2, DECAP_FORMAT); 837 } 838 839 /** 840 * hal_rx_dump_rx_attention_tlv: dump RX attention TLV in structured 841 * humman readable format. 842 * @ rx_attn: pointer the rx_attention TLV in pkt. 843 * @ dbg_level: log level. 844 * 845 * Return: void 846 */ 847 static inline void hal_rx_dump_rx_attention_tlv(struct rx_attention *rx_attn, 848 uint8_t dbg_level) 849 { 850 hal_verbose_debug("rx_attention tlv (1/2) - " 851 "rxpcu_mpdu_filter_in_category: %x " 852 "sw_frame_group_id: %x " 853 "reserved_0: %x " 854 "phy_ppdu_id: %x " 855 "first_mpdu : %x " 856 "reserved_1a: %x " 857 "mcast_bcast: %x " 858 "ast_index_not_found: %x " 859 "ast_index_timeout: %x " 860 "power_mgmt: %x " 861 "non_qos: %x " 862 "null_data: %x " 863 "mgmt_type: %x " 864 "ctrl_type: %x " 865 "more_data: %x " 866 "eosp: %x " 867 "a_msdu_error: %x " 868 "fragment_flag: %x " 869 "order: %x " 870 "cce_match: %x " 871 "overflow_err: %x " 872 "msdu_length_err: %x " 873 "tcp_udp_chksum_fail: %x " 874 "ip_chksum_fail: %x " 875 "sa_idx_invalid: %x " 876 "da_idx_invalid: %x " 877 "reserved_1b: %x " 878 "rx_in_tx_decrypt_byp: %x ", 879 rx_attn->rxpcu_mpdu_filter_in_category, 880 rx_attn->sw_frame_group_id, 881 rx_attn->reserved_0, 882 rx_attn->phy_ppdu_id, 883 rx_attn->first_mpdu, 884 rx_attn->reserved_1a, 885 rx_attn->mcast_bcast, 886 rx_attn->ast_index_not_found, 887 rx_attn->ast_index_timeout, 888 rx_attn->power_mgmt, 889 rx_attn->non_qos, 890 rx_attn->null_data, 891 rx_attn->mgmt_type, 892 rx_attn->ctrl_type, 893 rx_attn->more_data, 894 rx_attn->eosp, 895 rx_attn->a_msdu_error, 896 rx_attn->fragment_flag, 897 rx_attn->order, 898 rx_attn->cce_match, 899 rx_attn->overflow_err, 900 rx_attn->msdu_length_err, 901 rx_attn->tcp_udp_chksum_fail, 902 rx_attn->ip_chksum_fail, 903 rx_attn->sa_idx_invalid, 904 rx_attn->da_idx_invalid, 905 rx_attn->reserved_1b, 906 rx_attn->rx_in_tx_decrypt_byp); 907 908 hal_verbose_debug("rx_attention tlv (2/2) - " 909 "encrypt_required: %x " 910 "directed: %x " 911 "buffer_fragment: %x " 912 "mpdu_length_err: %x " 913 "tkip_mic_err: %x " 914 "decrypt_err: %x " 915 "unencrypted_frame_err: %x " 916 "fcs_err: %x " 917 "flow_idx_timeout: %x " 918 "flow_idx_invalid: %x " 919 "wifi_parser_error: %x " 920 "amsdu_parser_error: %x " 921 "sa_idx_timeout: %x " 922 "da_idx_timeout: %x " 923 "msdu_limit_error: %x " 924 "da_is_valid: %x " 925 "da_is_mcbc: %x " 926 "sa_is_valid: %x " 927 "decrypt_status_code: %x " 928 "rx_bitmap_not_updated: %x " 929 "reserved_2: %x " 930 "msdu_done: %x ", 931 rx_attn->encrypt_required, 932 rx_attn->directed, 933 rx_attn->buffer_fragment, 934 rx_attn->mpdu_length_err, 935 rx_attn->tkip_mic_err, 936 rx_attn->decrypt_err, 937 rx_attn->unencrypted_frame_err, 938 rx_attn->fcs_err, 939 rx_attn->flow_idx_timeout, 940 rx_attn->flow_idx_invalid, 941 rx_attn->wifi_parser_error, 942 rx_attn->amsdu_parser_error, 943 rx_attn->sa_idx_timeout, 944 rx_attn->da_idx_timeout, 945 rx_attn->msdu_limit_error, 946 rx_attn->da_is_valid, 947 rx_attn->da_is_mcbc, 948 rx_attn->sa_is_valid, 949 rx_attn->decrypt_status_code, 950 rx_attn->rx_bitmap_not_updated, 951 rx_attn->reserved_2, 952 rx_attn->msdu_done); 953 } 954 955 /** 956 * hal_rx_dump_mpdu_end_tlv: dump RX mpdu_end TLV in structured 957 * human readable format. 958 * @ mpdu_end: pointer the mpdu_end TLV in pkt. 959 * @ dbg_level: log level. 960 * 961 * Return: void 962 */ 963 static inline void hal_rx_dump_mpdu_end_tlv(struct rx_mpdu_end *mpdu_end, 964 uint8_t dbg_level) 965 { 966 hal_verbose_debug("rx_mpdu_end tlv - " 967 "rxpcu_mpdu_filter_in_category: %x " 968 "sw_frame_group_id: %x " 969 "phy_ppdu_id: %x " 970 "unsup_ktype_short_frame: %x " 971 "rx_in_tx_decrypt_byp: %x " 972 "overflow_err: %x " 973 "mpdu_length_err: %x " 974 "tkip_mic_err: %x " 975 "decrypt_err: %x " 976 "unencrypted_frame_err: %x " 977 "pn_fields_contain_valid_info: %x " 978 "fcs_err: %x " 979 "msdu_length_err: %x " 980 "rxdma0_destination_ring: %x " 981 "rxdma1_destination_ring: %x " 982 "decrypt_status_code: %x " 983 "rx_bitmap_not_updated: %x ", 984 mpdu_end->rxpcu_mpdu_filter_in_category, 985 mpdu_end->sw_frame_group_id, 986 mpdu_end->phy_ppdu_id, 987 mpdu_end->unsup_ktype_short_frame, 988 mpdu_end->rx_in_tx_decrypt_byp, 989 mpdu_end->overflow_err, 990 mpdu_end->mpdu_length_err, 991 mpdu_end->tkip_mic_err, 992 mpdu_end->decrypt_err, 993 mpdu_end->unencrypted_frame_err, 994 mpdu_end->pn_fields_contain_valid_info, 995 mpdu_end->fcs_err, 996 mpdu_end->msdu_length_err, 997 mpdu_end->rxdma0_destination_ring, 998 mpdu_end->rxdma1_destination_ring, 999 mpdu_end->decrypt_status_code, 1000 mpdu_end->rx_bitmap_not_updated); 1001 } 1002 1003 #ifdef NO_RX_PKT_HDR_TLV 1004 static inline void hal_rx_dump_pkt_hdr_tlv(struct rx_pkt_tlvs *pkt_tlvs, 1005 uint8_t dbg_level) 1006 { 1007 } 1008 #else 1009 /** 1010 * hal_rx_dump_pkt_hdr_tlv: dump RX pkt header TLV in hex format 1011 * @ pkt_hdr_tlv: pointer the pkt_hdr_tlv in pkt. 1012 * @ dbg_level: log level. 1013 * 1014 * Return: void 1015 */ 1016 static inline void hal_rx_dump_pkt_hdr_tlv(struct rx_pkt_tlvs *pkt_tlvs, 1017 uint8_t dbg_level) 1018 { 1019 struct rx_pkt_hdr_tlv *pkt_hdr_tlv = &pkt_tlvs->pkt_hdr_tlv; 1020 1021 hal_verbose_debug("\n---------------\nrx_pkt_hdr_tlv" 1022 "\n---------------\nphy_ppdu_id %d ", 1023 pkt_hdr_tlv->phy_ppdu_id); 1024 hal_verbose_hex_dump(pkt_hdr_tlv->rx_pkt_hdr, 128); 1025 } 1026 #endif 1027 1028 #define HAL_RX_MPDU_GET_FRAME_CONTROL_FIELD(_rx_mpdu_info) \ 1029 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \ 1030 RX_MPDU_INFO_14_MPDU_FRAME_CONTROL_FIELD_OFFSET)), \ 1031 RX_MPDU_INFO_14_MPDU_FRAME_CONTROL_FIELD_MASK, \ 1032 RX_MPDU_INFO_14_MPDU_FRAME_CONTROL_FIELD_LSB)) 1033 /** 1034 * hal_rx_get_rx_more_frag_bit(): Function to retrieve more fragment bit 1035 * 1036 * @nbuf: Network buffer 1037 * Returns: rx more fragment bit 1038 */ 1039 static inline 1040 uint8_t hal_rx_get_rx_more_frag_bit(uint8_t *buf) 1041 { 1042 struct rx_pkt_tlvs *pkt_tlvs = hal_rx_get_pkt_tlvs(buf); 1043 struct rx_mpdu_info *rx_mpdu_info = hal_rx_get_mpdu_info(pkt_tlvs); 1044 uint16_t frame_ctrl = 0; 1045 1046 frame_ctrl = HAL_RX_MPDU_GET_FRAME_CONTROL_FIELD(rx_mpdu_info) >> 1047 DOT11_FC1_MORE_FRAG_OFFSET; 1048 1049 /* more fragment bit if at offset bit 4 */ 1050 return frame_ctrl; 1051 } 1052 1053 static inline 1054 void hal_rx_mpdu_desc_info_get_li(void *desc_addr, 1055 void *mpdu_desc_info_hdl) 1056 { 1057 struct reo_destination_ring *reo_dst_ring; 1058 struct hal_rx_mpdu_desc_info *mpdu_desc_info = 1059 (struct hal_rx_mpdu_desc_info *)mpdu_desc_info_hdl; 1060 uint32_t *mpdu_info; 1061 1062 reo_dst_ring = (struct reo_destination_ring *)desc_addr; 1063 1064 mpdu_info = (uint32_t *)&reo_dst_ring->rx_mpdu_desc_info_details; 1065 1066 mpdu_desc_info->msdu_count = HAL_RX_MPDU_MSDU_COUNT_GET(mpdu_info); 1067 mpdu_desc_info->mpdu_seq = HAL_RX_MPDU_SEQUENCE_NUMBER_GET(mpdu_info); 1068 mpdu_desc_info->mpdu_flags = HAL_RX_MPDU_FLAGS_GET(mpdu_info); 1069 mpdu_desc_info->peer_meta_data = 1070 HAL_RX_MPDU_DESC_PEER_META_DATA_GET(mpdu_info); 1071 mpdu_desc_info->bar_frame = HAL_RX_MPDU_BAR_FRAME_GET(mpdu_info); 1072 } 1073 1074 /** 1075 * hal_rx_attn_msdu_done_get_li() - Get msdi done flag from RX TLV 1076 * @buf: RX tlv address 1077 * 1078 * Return: msdu done flag 1079 */ 1080 static inline uint32_t hal_rx_attn_msdu_done_get_li(uint8_t *buf) 1081 { 1082 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 1083 struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn; 1084 uint32_t msdu_done; 1085 1086 msdu_done = HAL_RX_ATTN_MSDU_DONE_GET(rx_attn); 1087 1088 return msdu_done; 1089 } 1090 1091 #define HAL_RX_MSDU_FLAGS_GET(msdu_info_ptr) \ 1092 (HAL_RX_FIRST_MSDU_IN_MPDU_FLAG_GET(msdu_info_ptr) | \ 1093 HAL_RX_LAST_MSDU_IN_MPDU_FLAG_GET(msdu_info_ptr) | \ 1094 HAL_RX_MSDU_CONTINUATION_FLAG_GET(msdu_info_ptr) | \ 1095 HAL_RX_MSDU_SA_IS_VALID_FLAG_GET(msdu_info_ptr) | \ 1096 HAL_RX_MSDU_SA_IDX_TIMEOUT_FLAG_GET(msdu_info_ptr) | \ 1097 HAL_RX_MSDU_DA_IS_VALID_FLAG_GET(msdu_info_ptr) | \ 1098 HAL_RX_MSDU_DA_IS_MCBC_FLAG_GET(msdu_info_ptr) | \ 1099 HAL_RX_MSDU_DA_IDX_TIMEOUT_FLAG_GET(msdu_info_ptr)) 1100 1101 /** 1102 * hal_rx_msdu_flags_get_li() - Get msdu flags from ring desc 1103 * @msdu_desc_info_hdl: msdu desc info handle 1104 * 1105 * Return: msdu flags 1106 */ 1107 static inline 1108 uint32_t hal_rx_msdu_flags_get_li(rx_msdu_desc_info_t msdu_desc_info_hdl) 1109 { 1110 struct rx_msdu_desc_info *msdu_desc_info = 1111 (struct rx_msdu_desc_info *)msdu_desc_info_hdl; 1112 1113 return HAL_RX_MSDU_FLAGS_GET(msdu_desc_info); 1114 } 1115 1116 /* 1117 *hal_rx_msdu_desc_info_get_li: Gets the flags related to MSDU descriptor. 1118 *@desc_addr: REO ring descriptor addr 1119 *@msdu_desc_info: Holds MSDU descriptor info from HAL Rx descriptor 1120 * 1121 * Specifically flags needed are: first_msdu_in_mpdu, 1122 * last_msdu_in_mpdu, msdu_continuation, sa_is_valid, 1123 * sa_idx_timeout, da_is_valid, da_idx_timeout, da_is_MCBC 1124 * 1125 1126 *Return: void 1127 */ 1128 static inline void 1129 hal_rx_msdu_desc_info_get_li(void *desc_addr, 1130 struct hal_rx_msdu_desc_info *msdu_desc_info) 1131 { 1132 struct reo_destination_ring *reo_dst_ring; 1133 uint32_t *msdu_info; 1134 1135 reo_dst_ring = (struct reo_destination_ring *)desc_addr; 1136 1137 msdu_info = (uint32_t *)&reo_dst_ring->rx_msdu_desc_info_details; 1138 msdu_desc_info->msdu_flags = 1139 hal_rx_msdu_flags_get_li((struct rx_msdu_desc_info *)msdu_info); 1140 msdu_desc_info->msdu_len = HAL_RX_MSDU_PKT_LENGTH_GET(msdu_info); 1141 } 1142 1143 #define HAL_RX_MSDU_START_NSS_GET(_rx_msdu_start) \ 1144 (_HAL_MS((*_OFFSET_TO_WORD_PTR((_rx_msdu_start), \ 1145 RX_MSDU_START_5_NSS_OFFSET)), \ 1146 RX_MSDU_START_5_NSS_MASK, \ 1147 RX_MSDU_START_5_NSS_LSB)) 1148 1149 #define HAL_RX_ATTN_MSDU_LEN_ERR_GET(_rx_attn) \ 1150 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_attn, \ 1151 RX_ATTENTION_1_MSDU_LENGTH_ERR_OFFSET)), \ 1152 RX_ATTENTION_1_MSDU_LENGTH_ERR_MASK, \ 1153 RX_ATTENTION_1_MSDU_LENGTH_ERR_LSB)) 1154 1155 /** 1156 * hal_rx_attn_msdu_len_err_get_li(): Get msdu_len_err value from 1157 * rx attention tlvs 1158 * @buf: pointer to rx pkt tlvs hdr 1159 * 1160 * Return: msdu_len_err value 1161 */ 1162 static inline uint32_t 1163 hal_rx_attn_msdu_len_err_get_li(uint8_t *buf) 1164 { 1165 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 1166 struct rx_attention *rx_attn = &pkt_tlvs->attn_tlv.rx_attn; 1167 1168 return HAL_RX_ATTN_MSDU_LEN_ERR_GET(rx_attn); 1169 } 1170 #endif /* _HAL_LI_RX_H_ */ 1171