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_BE_RX_H_ 21 #define _HAL_BE_RX_H_ 22 23 #include "hal_be_hw_headers.h" 24 #include "hal_rx.h" 25 #include <wbm_release_ring_rx.h> 26 27 #define HAL_RX_DA_IDX_CHIP_ID_OFFSET 14 28 #define HAL_RX_DA_IDX_CHIP_ID_MASK 0x3 29 30 #define HAL_RX_DA_IDX_PEER_ID_MASK 0x3fff 31 #define HAL_RX_DA_IDX_ML_PEER_MASK 0x2000 32 33 /* 34 * macro to set the cookie into the rxdma ring entry 35 */ 36 #define HAL_RXDMA_COOKIE_SET(buff_addr_info, cookie) \ 37 ((*(((unsigned int *)buff_addr_info) + \ 38 (BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_OFFSET >> 2))) &= \ 39 ~BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_MASK); \ 40 ((*(((unsigned int *)buff_addr_info) + \ 41 (BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_OFFSET >> 2))) |= \ 42 (cookie << BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_LSB) & \ 43 BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_MASK) 44 45 /* 46 * macro to set the manager into the rxdma ring entry 47 */ 48 #define HAL_RXDMA_MANAGER_SET(buff_addr_info, manager) \ 49 ((*(((unsigned int *)buff_addr_info) + \ 50 (BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_OFFSET >> 2))) &= \ 51 ~BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_MASK); \ 52 ((*(((unsigned int *)buff_addr_info) + \ 53 (BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_OFFSET >> 2))) |= \ 54 (manager << BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_LSB) & \ 55 BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_MASK) 56 57 #define HAL_RX_ERROR_STATUS_GET(reo_desc) \ 58 (_HAL_MS((*_OFFSET_TO_WORD_PTR(reo_desc, \ 59 REO_DESTINATION_RING_REO_PUSH_REASON_OFFSET)),\ 60 REO_DESTINATION_RING_REO_PUSH_REASON_MASK, \ 61 REO_DESTINATION_RING_REO_PUSH_REASON_LSB)) 62 63 #define HAL_RX_BUF_COOKIE_GET(buff_addr_info) \ 64 (_HAL_MS((*_OFFSET_TO_WORD_PTR(buff_addr_info, \ 65 BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_OFFSET)), \ 66 BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_MASK, \ 67 BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_LSB)) 68 69 #define HAL_RX_BUF_RBM_GET(buff_addr_info) \ 70 (_HAL_MS((*_OFFSET_TO_WORD_PTR(buff_addr_info, \ 71 BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_OFFSET)),\ 72 BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_MASK, \ 73 BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_LSB)) 74 75 /* TODO: Convert the following structure fields accesseses to offsets */ 76 77 #define HAL_RX_REO_BUF_COOKIE_GET(reo_desc) \ 78 (HAL_RX_BUF_COOKIE_GET(& \ 79 (((struct reo_destination_ring *) \ 80 reo_desc)->buf_or_link_desc_addr_info))) 81 82 #define HAL_RX_MSDU_DESC_IP_CHKSUM_FAIL_GET(msdu_desc_info_ptr) \ 83 (_HAL_MS((*_OFFSET_TO_WORD_PTR((msdu_desc_info_ptr), \ 84 RX_MSDU_DESC_INFO_IP_CHKSUM_FAIL_OFFSET)), \ 85 RX_MSDU_DESC_INFO_IP_CHKSUM_FAIL_MASK, \ 86 RX_MSDU_DESC_INFO_IP_CHKSUM_FAIL_LSB)) 87 88 #define HAL_RX_REO_IP_CHKSUM_FAIL_GET(ring_desc) \ 89 (HAL_RX_MSDU_DESC_IP_CHKSUM_FAIL_GET(& \ 90 ((struct reo_destination_ring *)ring_desc)->rx_msdu_desc_info_details)) 91 92 #define HAL_RX_MSDU_DESC_TCP_UDP_CHKSUM_FAIL_GET(msdu_desc_info_ptr) \ 93 (_HAL_MS((*_OFFSET_TO_WORD_PTR((msdu_desc_info_ptr), \ 94 RX_MSDU_DESC_INFO_TCP_UDP_CHKSUM_FAIL_OFFSET)), \ 95 RX_MSDU_DESC_INFO_TCP_UDP_CHKSUM_FAIL_MASK, \ 96 RX_MSDU_DESC_INFO_TCP_UDP_CHKSUM_FAIL_LSB)) 97 98 #define HAL_RX_REO_TCP_UDP_CHKSUM_FAIL_GET(ring_desc) \ 99 (HAL_RX_MSDU_DESC_TCP_UDP_CHKSUM_FAIL_GET(& \ 100 ((struct reo_destination_ring *)ring_desc)->rx_msdu_desc_info_details)) 101 102 #define HAL_RX_MSDU_DESC_AMPDU_FLAG_GET(mpdu_info_ptr) \ 103 (_HAL_MS((*_OFFSET_TO_WORD_PTR((mpdu_info_ptr), \ 104 RX_MPDU_DESC_INFO_AMPDU_FLAG_OFFSET)), \ 105 RX_MPDU_DESC_INFO_AMPDU_FLAG_MASK, \ 106 RX_MPDU_DESC_INFO_AMPDU_FLAG_LSB)) 107 108 #define HAL_RX_MPDU_DESC_PEER_META_DATA_GET(mpdu_info_ptr) \ 109 ((mpdu_info_ptr \ 110 [RX_MPDU_DESC_INFO_PEER_META_DATA_OFFSET >> 2] & \ 111 RX_MPDU_DESC_INFO_PEER_META_DATA_MASK) >> \ 112 RX_MPDU_DESC_INFO_PEER_META_DATA_LSB) 113 114 #define HAL_RX_MPDU_MSDU_COUNT_GET(mpdu_info_ptr) \ 115 ((mpdu_info_ptr[RX_MPDU_DESC_INFO_MSDU_COUNT_OFFSET >> 2] & \ 116 RX_MPDU_DESC_INFO_MSDU_COUNT_MASK) >> \ 117 RX_MPDU_DESC_INFO_MSDU_COUNT_LSB) 118 119 #define HAL_RX_MPDU_FRAGMENT_FLAG_GET(mpdu_info_ptr) \ 120 (mpdu_info_ptr[RX_MPDU_DESC_INFO_FRAGMENT_FLAG_OFFSET >> 2] & \ 121 RX_MPDU_DESC_INFO_FRAGMENT_FLAG_MASK) 122 123 #define HAL_RX_MPDU_RETRY_BIT_GET(mpdu_info_ptr) \ 124 (mpdu_info_ptr[RX_MPDU_DESC_INFO_MPDU_RETRY_BIT_OFFSET >> 2] & \ 125 RX_MPDU_DESC_INFO_MPDU_RETRY_BIT_MASK) 126 127 #define HAL_RX_MPDU_AMPDU_FLAG_GET(mpdu_info_ptr) \ 128 (mpdu_info_ptr[RX_MPDU_DESC_INFO_AMPDU_FLAG_OFFSET >> 2] & \ 129 RX_MPDU_DESC_INFO_AMPDU_FLAG_MASK) 130 131 #define HAL_RX_MPDU_RAW_MPDU_GET(mpdu_info_ptr) \ 132 (mpdu_info_ptr[RX_MPDU_DESC_INFO_RAW_MPDU_OFFSET >> 2] & \ 133 RX_MPDU_DESC_INFO_RAW_MPDU_MASK) 134 135 #define HAL_RX_MPDU_BAR_FRAME_GET(mpdu_info_ptr) \ 136 ((mpdu_info_ptr[RX_MPDU_DESC_INFO_BAR_FRAME_OFFSET >> 2] & \ 137 RX_MPDU_DESC_INFO_BAR_FRAME_MASK) >> \ 138 RX_MPDU_DESC_INFO_BAR_FRAME_LSB) 139 140 #define HAL_RX_MPDU_TID_GET(mpdu_info_ptr) \ 141 ((mpdu_info_ptr[RX_MPDU_DESC_INFO_TID_OFFSET >> 2] & \ 142 RX_MPDU_DESC_INFO_TID_MASK) >> \ 143 RX_MPDU_DESC_INFO_TID_LSB) 144 145 #define HAL_RX_MPDU_MPDU_QOS_CONTROL_VALID_GET(mpdu_info_ptr) \ 146 ((mpdu_info_ptr[RX_MPDU_DESC_INFO_MPDU_QOS_CONTROL_VALID_OFFSET >> 2] &\ 147 RX_MPDU_DESC_INFO_MPDU_QOS_CONTROL_VALID_MASK) >> \ 148 RX_MPDU_DESC_INFO_MPDU_QOS_CONTROL_VALID_LSB) 149 150 /* 151 * NOTE: None of the following _GET macros need a right 152 * shift by the corresponding _LSB. This is because, they are 153 * finally taken and "OR'ed" into a single word again. 154 */ 155 #define HAL_RX_MSDU_CONTINUATION_FLAG_SET(msdu_info_ptr, val) \ 156 ((*(((uint32_t *)msdu_info_ptr) + \ 157 (RX_MSDU_DESC_INFO_MSDU_CONTINUATION_OFFSET >> 2))) |= \ 158 ((val) << RX_MSDU_DESC_INFO_MSDU_CONTINUATION_LSB) & \ 159 RX_MSDU_DESC_INFO_MSDU_CONTINUATION_MASK) 160 161 #define HAL_RX_MSDU_CONTINUATION_FLAG_GET(msdu_info_ptr) \ 162 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 163 RX_MSDU_DESC_INFO_MSDU_CONTINUATION_OFFSET)) & \ 164 RX_MSDU_DESC_INFO_MSDU_CONTINUATION_MASK) 165 166 #define HAL_RX_MSDU_REO_DST_IND_GET(msdu_info_ptr) \ 167 (_HAL_MS((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 168 RX_MSDU_EXT_DESC_INFO_REO_DESTINATION_INDICATION_OFFSET)), \ 169 RX_MSDU_EXT_DESC_INFO_REO_DESTINATION_INDICATION_MASK, \ 170 RX_MSDU_EXT_DESC_INFO_REO_DESTINATION_INDICATION_LSB)) 171 172 #define HAL_RX_MSDU_SA_IS_VALID_FLAG_GET(msdu_info_ptr) \ 173 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 174 RX_MSDU_DESC_INFO_SA_IS_VALID_OFFSET)) & \ 175 RX_MSDU_DESC_INFO_SA_IS_VALID_MASK) 176 177 #define HAL_RX_MSDU_DA_IS_VALID_FLAG_GET(msdu_info_ptr) \ 178 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 179 RX_MSDU_DESC_INFO_DA_IS_VALID_OFFSET)) & \ 180 RX_MSDU_DESC_INFO_DA_IS_VALID_MASK) 181 182 #define HAL_RX_MSDU_DA_IS_MCBC_FLAG_GET(msdu_info_ptr) \ 183 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 184 RX_MSDU_DESC_INFO_DA_IS_MCBC_OFFSET)) & \ 185 RX_MSDU_DESC_INFO_DA_IS_MCBC_MASK) 186 187 #define HAL_RX_MSDU_INTRA_BSS_FLAG_GET(msdu_info_ptr) \ 188 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 189 RX_MSDU_DESC_INFO_INTRA_BSS_OFFSET)) & \ 190 RX_MSDU_DESC_INFO_INTRA_BSS_MASK) 191 192 #define HAL_RX_MSDU_DEST_CHIP_ID_GET(msdu_info_ptr) \ 193 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 194 RX_MSDU_DESC_INFO_DEST_CHIP_ID_OFFSET)) & \ 195 RX_MSDU_DESC_INFO_DEST_CHIP_ID_MASK) 196 197 #define HAL_RX_MPDU_ENCRYPT_TYPE_GET(_rx_mpdu_info) \ 198 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \ 199 RX_MPDU_INFO_ENCRYPT_TYPE_OFFSET)), \ 200 RX_MPDU_INFO_ENCRYPT_TYPE_MASK, \ 201 RX_MPDU_INFO_ENCRYPT_TYPE_LSB)) 202 203 #define HAL_RX_MSDU_DESC_INFO_SET(_msdu_info_ptr, _field, _val) \ 204 HAL_RX_FLD_SET(_msdu_info_ptr, RX_MSDU_DESC_INFO, \ 205 _field, _val) 206 207 #define HAL_RX_MPDU_DESC_INFO_SET(_mpdu_info_ptr, _field, _val) \ 208 HAL_RX_FLD_SET(_mpdu_info_ptr, RX_MPDU_DESC_INFO, \ 209 _field, _val) 210 211 #define HAL_RX_REO_MSDU_REO_DST_IND_GET(reo_desc) \ 212 (HAL_RX_MSDU_REO_DST_IND_GET(& \ 213 (((struct reo_destination_ring *) \ 214 reo_desc)->rx_msdu_desc_info_details))) 215 216 #define HAL_RX_DEST_CHIP_ID_GET(msdu_metadata) \ 217 (((msdu_metadata)->da_idx >> HAL_RX_DA_IDX_CHIP_ID_OFFSET) & \ 218 HAL_RX_DA_IDX_CHIP_ID_MASK) 219 220 #define HAL_RX_PEER_ID_GET(msdu_metadata) \ 221 (((msdu_metadata)->da_idx) & HAL_RX_DA_IDX_PEER_ID_MASK) 222 223 /** 224 * enum hal_be_rx_wbm_error_source: Indicates which module initiated the 225 * release of this buffer or descriptor 226 * 227 * @ HAL_BE_RX_WBM_ERR_SRC_RXDMA: RXDMA released this buffer or descriptor 228 * @ HAL_BE_RX_WBM_ERR_SRC_REO: REO released this buffer or descriptor 229 * @ HAL_BE_RX_WBM_ERR_SRC_FW_RX: FW released this buffer or descriptor from the 230 * RX path 231 * @ HAL_BE_RX_WBM_ERR_SRC_SW_RX: SW released this buffer or descriptor from the 232 * RX path 233 * @ HAL_BE_RX_WBM_ERR_SRC_TQM : TQM released this buffer or descriptor 234 * @ HAL_BE_RX_WBM_ERR_SRC_FW_TX: FW released this buffer or descriptor from the 235 * RX path 236 * @ HAL_BE_RX_WBM_ERR_SRC_SW_TX: SW released this buffer or descriptor from the 237 * RX path 238 */ 239 enum hal_be_rx_wbm_error_source { 240 HAL_BE_RX_WBM_ERR_SRC_RXDMA = 0, 241 HAL_BE_RX_WBM_ERR_SRC_REO, 242 HAL_BE_RX_WBM_ERR_SRC_FW_RX, 243 HAL_BE_RX_WBM_ERR_SRC_SW_RX, 244 HAL_BE_RX_WBM_ERR_SRC_TQM, 245 HAL_BE_RX_WBM_ERR_SRC_FW_TX, 246 HAL_BE_RX_WBM_ERR_SRC_SW_TX, 247 }; 248 249 /** 250 * enum hal_be_wbm_release_dir - Direction of the buffer which was released to 251 * wbm. 252 * @HAL_BE_WBM_RELEASE_DIR_RX: Buffer released to WBM due to error 253 * @HAL_BE_WBM_RELEASE_DIR_TX: Buffer released to WBM from TX path 254 */ 255 enum hal_be_wbm_release_dir { 256 HAL_BE_WBM_RELEASE_DIR_RX, 257 HAL_BE_WBM_RELEASE_DIR_TX, 258 }; 259 260 static inline uint32_t hal_rx_get_mpdu_flags(uint32_t *mpdu_info) 261 { 262 uint32_t mpdu_flags = 0; 263 264 if (HAL_RX_MPDU_FRAGMENT_FLAG_GET(mpdu_info)) 265 mpdu_flags |= HAL_MPDU_F_FRAGMENT; 266 267 if (HAL_RX_MPDU_RETRY_BIT_GET(mpdu_info)) 268 mpdu_flags |= HAL_MPDU_F_RETRY_BIT; 269 270 if (HAL_RX_MPDU_AMPDU_FLAG_GET(mpdu_info)) 271 mpdu_flags |= HAL_MPDU_F_AMPDU_FLAG; 272 273 if (HAL_RX_MPDU_RAW_MPDU_GET(mpdu_info)) 274 mpdu_flags |= HAL_MPDU_F_RAW_AMPDU; 275 276 if (HAL_RX_MPDU_MPDU_QOS_CONTROL_VALID_GET(mpdu_info)) 277 mpdu_flags |= HAL_MPDU_F_QOS_CONTROL_VALID; 278 279 return mpdu_flags; 280 } 281 282 /******************************************************************************* 283 * RX REO ERROR APIS 284 ******************************************************************************/ 285 286 #define HAL_RX_REO_BUF_TYPE_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \ 287 (REO_DESTINATION_RING_REO_DEST_BUFFER_TYPE_OFFSET >> 2))) & \ 288 REO_DESTINATION_RING_REO_DEST_BUFFER_TYPE_MASK) >> \ 289 REO_DESTINATION_RING_REO_DEST_BUFFER_TYPE_LSB) 290 291 #define HAL_RX_REO_ERROR_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \ 292 (REO_DESTINATION_RING_REO_ERROR_CODE_OFFSET >> 2))) & \ 293 REO_DESTINATION_RING_REO_ERROR_CODE_MASK) >> \ 294 REO_DESTINATION_RING_REO_ERROR_CODE_LSB) 295 296 /* 297 * hal_rx_msdu_link_desc_reinject: Re-injects the MSDU link descriptor to 298 * REO entrance ring 299 * 300 * @ soc: HAL version of the SOC pointer 301 * @ pa: Physical address of the MSDU Link Descriptor 302 * @ cookie: SW cookie to get to the virtual address 303 * @ error_enabled_reo_q: Argument to determine whether this needs to go 304 * to the error enabled REO queue 305 * 306 * Return: void 307 */ 308 static inline void 309 hal_rx_msdu_link_desc_reinject(struct hal_soc *soc, uint64_t pa, 310 uint32_t cookie, bool error_enabled_reo_q) 311 { 312 /* TODO */ 313 } 314 315 #ifdef DP_HW_COOKIE_CONVERT_EXCEPTION 316 /* HW set dowrd-2 bit16 to 1 if HW CC is done */ 317 #define HAL_WBM2SW_COMPLETION_RING_RX_CC_DONE_OFFSET 0x8 318 #define HAL_WBM2SW_COMPLETION_RING_RX_CC_DONE_MASK 0x10000 319 #define HAL_WBM2SW_COMPLETION_RING_RX_CC_DONE_LSB 0x10 320 /** 321 * hal_rx_wbm_get_cookie_convert_done() - Get cookie conversion done flag 322 * @hal_desc: wbm Rx ring descriptor pointer 323 * 324 * This function will get the bit value that indicate HW cookie 325 * conversion done or not 326 * 327 * Return: 1 - HW cookie conversion done, 0 - not 328 */ 329 static inline uint8_t hal_rx_wbm_get_cookie_convert_done(void *hal_desc) 330 { 331 return HAL_RX_GET(hal_desc, HAL_WBM2SW_COMPLETION_RING_RX, 332 CC_DONE); 333 } 334 #endif 335 336 /** 337 * hal_rx_wbm_get_desc_va() - Get Desc virtual address within WBM Desc 338 * @hal_desc: RX WBM2SW ring descriptor pointer 339 * 340 * Return: RX descriptor virtual address 341 */ 342 static inline uintptr_t hal_rx_wbm_get_desc_va(void *hal_desc) 343 { 344 uint64_t va_from_desc; 345 346 va_from_desc = HAL_RX_GET(hal_desc, 347 WBM2SW_COMPLETION_RING_RX, 348 BUFFER_VIRT_ADDR_31_0) | 349 (((uint64_t)HAL_RX_GET(hal_desc, 350 WBM2SW_COMPLETION_RING_RX, 351 BUFFER_VIRT_ADDR_63_32)) << 32); 352 353 return (uintptr_t)va_from_desc; 354 } 355 356 #define HAL_RX_WBM_FIRST_MSDU_GET(wbm_desc) \ 357 (((*(((uint32_t *)wbm_desc) + \ 358 (WBM_RELEASE_RING_FIRST_MSDU_OFFSET >> 2))) & \ 359 WBM_RELEASE_RING_FIRST_MSDU_MASK) >> \ 360 WBM_RELEASE_RING_FIRST_MSDU_LSB) 361 362 #define HAL_RX_WBM_LAST_MSDU_GET(wbm_desc) \ 363 (((*(((uint32_t *)wbm_desc) + \ 364 (WBM_RELEASE_RING_LAST_MSDU_OFFSET >> 2))) & \ 365 WBM_RELEASE_RING_LAST_MSDU_MASK) >> \ 366 WBM_RELEASE_RING_LAST_MSDU_LSB) 367 368 #define HAL_RX_WBM_BUF_ADDR_39_32_GET(wbm_desc) \ 369 (HAL_RX_BUFFER_ADDR_39_32_GET(& \ 370 (((struct wbm_release_ring_rx *) \ 371 wbm_desc)->released_buff_or_desc_addr_info))) 372 373 #define HAL_RX_WBM_BUF_ADDR_31_0_GET(wbm_desc) \ 374 (HAL_RX_BUFFER_ADDR_31_0_GET(& \ 375 (((struct wbm_release_ring_rx *) \ 376 wbm_desc)->released_buff_or_desc_addr_info))) 377 378 #define HAL_RX_WBM_BUF_COOKIE_GET(wbm_desc) \ 379 HAL_RX_BUF_COOKIE_GET(&((struct wbm_release_ring_rx *) \ 380 wbm_desc)->released_buff_or_desc_addr_info) 381 382 #define HAL_RX_WBM_COMP_BUF_ADDR_31_0_GET(wbm_desc) \ 383 HAL_RX_GET(wbm_desc, WBM2SW_COMPLETION_RING_RX, BUFFER_PHYS_ADDR_31_0) 384 385 #define HAL_RX_WBM_COMP_BUF_ADDR_39_32_GET(wbm_desc) \ 386 HAL_RX_GET(wbm_desc, WBM2SW_COMPLETION_RING_RX, BUFFER_PHYS_ADDR_39_32) 387 388 #define HAL_RX_WBM_COMP_BUF_COOKIE_GET(wbm_desc) \ 389 HAL_RX_GET(wbm_desc, WBM2SW_COMPLETION_RING_RX, SW_BUFFER_COOKIE) 390 /** 391 * hal_rx_msdu_flags_get_be() - Get msdu flags from ring desc 392 * @msdu_desc_info_hdl: msdu desc info handle 393 * 394 * Return: msdu flags 395 */ 396 static inline 397 uint32_t hal_rx_msdu_flags_get_be(rx_msdu_desc_info_t msdu_desc_info_hdl) 398 { 399 struct rx_msdu_desc_info *msdu_desc_info = 400 (struct rx_msdu_desc_info *)msdu_desc_info_hdl; 401 uint32_t flags = 0; 402 403 if (HAL_RX_FIRST_MSDU_IN_MPDU_FLAG_GET(msdu_desc_info)) 404 flags |= HAL_MSDU_F_FIRST_MSDU_IN_MPDU; 405 406 if (HAL_RX_LAST_MSDU_IN_MPDU_FLAG_GET(msdu_desc_info)) 407 flags |= HAL_MSDU_F_LAST_MSDU_IN_MPDU; 408 409 if (HAL_RX_MSDU_CONTINUATION_FLAG_GET(msdu_desc_info)) 410 flags |= HAL_MSDU_F_MSDU_CONTINUATION; 411 412 if (HAL_RX_MSDU_SA_IS_VALID_FLAG_GET(msdu_desc_info)) 413 flags |= HAL_MSDU_F_SA_IS_VALID; 414 415 if (HAL_RX_MSDU_DA_IS_VALID_FLAG_GET(msdu_desc_info)) 416 flags |= HAL_MSDU_F_DA_IS_VALID; 417 418 if (HAL_RX_MSDU_DA_IS_MCBC_FLAG_GET(msdu_desc_info)) 419 flags |= HAL_MSDU_F_DA_IS_MCBC; 420 421 if (HAL_RX_MSDU_INTRA_BSS_FLAG_GET(msdu_desc_info)) 422 flags |= HAL_MSDU_F_INTRA_BSS; 423 424 return flags; 425 } 426 427 static inline 428 void hal_rx_mpdu_desc_info_get_be(void *desc_addr, 429 void *mpdu_desc_info_hdl) 430 { 431 struct reo_destination_ring *reo_dst_ring; 432 struct hal_rx_mpdu_desc_info *mpdu_desc_info = 433 (struct hal_rx_mpdu_desc_info *)mpdu_desc_info_hdl; 434 uint32_t *mpdu_info; 435 436 reo_dst_ring = (struct reo_destination_ring *)desc_addr; 437 438 mpdu_info = (uint32_t *)&reo_dst_ring->rx_mpdu_desc_info_details; 439 440 mpdu_desc_info->msdu_count = HAL_RX_MPDU_MSDU_COUNT_GET(mpdu_info); 441 mpdu_desc_info->mpdu_flags = hal_rx_get_mpdu_flags(mpdu_info); 442 mpdu_desc_info->peer_meta_data = 443 HAL_RX_MPDU_DESC_PEER_META_DATA_GET(mpdu_info); 444 mpdu_desc_info->bar_frame = HAL_RX_MPDU_BAR_FRAME_GET(mpdu_info); 445 mpdu_desc_info->tid = HAL_RX_MPDU_TID_GET(mpdu_info); 446 } 447 448 /* 449 *hal_rx_msdu_desc_info_get_be: Gets the flags related to MSDU descriptor. 450 *@desc_addr: REO ring descriptor addr 451 *@msdu_desc_info: Holds MSDU descriptor info from HAL Rx descriptor 452 * 453 * Specifically flags needed are: first_msdu_in_mpdu, 454 * last_msdu_in_mpdu, msdu_continuation, sa_is_valid, 455 * sa_idx_timeout, da_is_valid, da_idx_timeout, da_is_MCBC 456 * 457 458 *Return: void 459 */ 460 static inline void 461 hal_rx_msdu_desc_info_get_be(void *desc_addr, 462 struct hal_rx_msdu_desc_info *msdu_desc_info) 463 { 464 struct reo_destination_ring *reo_dst_ring; 465 uint32_t *msdu_info; 466 467 reo_dst_ring = (struct reo_destination_ring *)desc_addr; 468 469 msdu_info = (uint32_t *)&reo_dst_ring->rx_msdu_desc_info_details; 470 msdu_desc_info->msdu_flags = 471 hal_rx_msdu_flags_get_be((struct rx_msdu_desc_info *)msdu_info); 472 msdu_desc_info->msdu_len = HAL_RX_MSDU_PKT_LENGTH_GET(msdu_info); 473 } 474 475 /** 476 * hal_rx_get_reo_desc_va() - Get Desc virtual address within REO Desc 477 * @reo_desc: REO2SW ring descriptor pointer 478 * 479 * Return: RX descriptor virtual address 480 */ 481 static inline uintptr_t hal_rx_get_reo_desc_va(void *reo_desc) 482 { 483 uint64_t va_from_desc; 484 485 va_from_desc = HAL_RX_GET(reo_desc, 486 REO_DESTINATION_RING, 487 BUFFER_VIRT_ADDR_31_0) | 488 (((uint64_t)HAL_RX_GET(reo_desc, 489 REO_DESTINATION_RING, 490 BUFFER_VIRT_ADDR_63_32)) << 32); 491 492 return (uintptr_t)va_from_desc; 493 } 494 495 /** 496 * hal_rx_sw_exception_get_be() - Get sw_exception bit value from REO Desc 497 * @reo_desc: REO2SW ring descriptor pointer 498 * 499 * sw_exception bit might not exist in reo destination ring descriptor 500 * for some chipset, so just restrict this function for BE only. 501 * 502 * Return: sw_exception bit value 503 */ 504 static inline uint8_t hal_rx_sw_exception_get_be(void *reo_desc) 505 { 506 return HAL_RX_GET(reo_desc, REO_DESTINATION_RING, SW_EXCEPTION); 507 } 508 #endif /* _HAL_BE_RX_H_ */ 509