1 /* 2 * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved. 3 * 4 * Permission to use, copy, modify, and/or distribute this software for 5 * any purpose with or without fee is hereby granted, provided that the 6 * above copyright notice and this permission notice appear in all 7 * copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 10 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 11 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 12 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 13 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 14 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 15 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 16 * PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #ifndef _HAL_BE_RX_H_ 20 #define _HAL_BE_RX_H_ 21 22 #include "hal_be_hw_headers.h" 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_SW_BUFFER_COOKIE_OFFSET >> 2))) &= \ 31 ~BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_MASK); \ 32 ((*(((unsigned int *)buff_addr_info) + \ 33 (BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_OFFSET >> 2))) |= \ 34 (cookie << BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_LSB) & \ 35 BUFFER_ADDR_INFO_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_RETURN_BUFFER_MANAGER_OFFSET >> 2))) &= \ 43 ~BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_MASK); \ 44 ((*(((unsigned int *)buff_addr_info) + \ 45 (BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_OFFSET >> 2))) |= \ 46 (manager << BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_LSB) & \ 47 BUFFER_ADDR_INFO_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_REO_PUSH_REASON_OFFSET)),\ 52 REO_DESTINATION_RING_REO_PUSH_REASON_MASK, \ 53 REO_DESTINATION_RING_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_SW_BUFFER_COOKIE_OFFSET)), \ 58 BUFFER_ADDR_INFO_SW_BUFFER_COOKIE_MASK, \ 59 BUFFER_ADDR_INFO_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_RETURN_BUFFER_MANAGER_OFFSET)),\ 64 BUFFER_ADDR_INFO_RETURN_BUFFER_MANAGER_MASK, \ 65 BUFFER_ADDR_INFO_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_MSDU_DESC_IP_CHKSUM_FAIL_GET(msdu_desc_info_ptr) \ 75 (_HAL_MS((*_OFFSET_TO_WORD_PTR((msdu_desc_info_ptr), \ 76 RX_MSDU_DESC_INFO_IP_CHKSUM_FAIL_OFFSET)), \ 77 RX_MSDU_DESC_INFO_IP_CHKSUM_FAIL_MASK, \ 78 RX_MSDU_DESC_INFO_IP_CHKSUM_FAIL_LSB)) 79 80 #define HAL_RX_REO_IP_CHKSUM_FAIL_GET(ring_desc) \ 81 (HAL_RX_MSDU_DESC_IP_CHKSUM_FAIL_GET(& \ 82 ((struct reo_destination_ring *)ring_desc)->rx_msdu_desc_info_details)) 83 84 #define HAL_RX_MSDU_DESC_TCP_UDP_CHKSUM_FAIL_GET(msdu_desc_info_ptr) \ 85 (_HAL_MS((*_OFFSET_TO_WORD_PTR((msdu_desc_info_ptr), \ 86 RX_MSDU_DESC_INFO_TCP_UDP_CHKSUM_FAIL_OFFSET)), \ 87 RX_MSDU_DESC_INFO_TCP_UDP_CHKSUM_FAIL_MASK, \ 88 RX_MSDU_DESC_INFO_TCP_UDP_CHKSUM_FAIL_LSB)) 89 90 #define HAL_RX_REO_TCP_UDP_CHKSUM_FAIL_GET(ring_desc) \ 91 (HAL_RX_MSDU_DESC_TCP_UDP_CHKSUM_FAIL_GET(& \ 92 ((struct reo_destination_ring *)ring_desc)->rx_msdu_desc_info_details)) 93 94 #define HAL_RX_MSDU_DESC_AMPDU_FLAG_GET(mpdu_info_ptr) \ 95 (_HAL_MS((*_OFFSET_TO_WORD_PTR((mpdu_info_ptr), \ 96 RX_MPDU_DESC_INFO_AMPDU_FLAG_OFFSET)), \ 97 RX_MPDU_DESC_INFO_AMPDU_FLAG_MASK, \ 98 RX_MPDU_DESC_INFO_AMPDU_FLAG_LSB)) 99 100 #define HAL_RX_MPDU_DESC_PEER_META_DATA_GET(mpdu_info_ptr) \ 101 ((mpdu_info_ptr \ 102 [RX_MPDU_DESC_INFO_PEER_META_DATA_OFFSET >> 2] & \ 103 RX_MPDU_DESC_INFO_PEER_META_DATA_MASK) >> \ 104 RX_MPDU_DESC_INFO_PEER_META_DATA_LSB) 105 106 #define HAL_RX_MPDU_MSDU_COUNT_GET(mpdu_info_ptr) \ 107 ((mpdu_info_ptr[RX_MPDU_DESC_INFO_MSDU_COUNT_OFFSET >> 2] & \ 108 RX_MPDU_DESC_INFO_MSDU_COUNT_MASK) >> \ 109 RX_MPDU_DESC_INFO_MSDU_COUNT_LSB) 110 111 #define HAL_RX_MPDU_FRAGMENT_FLAG_GET(mpdu_info_ptr) \ 112 (mpdu_info_ptr[RX_MPDU_DESC_INFO_FRAGMENT_FLAG_OFFSET >> 2] & \ 113 RX_MPDU_DESC_INFO_FRAGMENT_FLAG_MASK) 114 115 #define HAL_RX_MPDU_RETRY_BIT_GET(mpdu_info_ptr) \ 116 (mpdu_info_ptr[RX_MPDU_DESC_INFO_MPDU_RETRY_BIT_OFFSET >> 2] & \ 117 RX_MPDU_DESC_INFO_MPDU_RETRY_BIT_MASK) 118 119 #define HAL_RX_MPDU_AMPDU_FLAG_GET(mpdu_info_ptr) \ 120 (mpdu_info_ptr[RX_MPDU_DESC_INFO_AMPDU_FLAG_OFFSET >> 2] & \ 121 RX_MPDU_DESC_INFO_AMPDU_FLAG_MASK) 122 123 #define HAL_RX_MPDU_RAW_MPDU_GET(mpdu_info_ptr) \ 124 (mpdu_info_ptr[RX_MPDU_DESC_INFO_RAW_MPDU_OFFSET >> 2] & \ 125 RX_MPDU_DESC_INFO_RAW_MPDU_MASK) 126 127 #define HAL_RX_MPDU_BAR_FRAME_GET(mpdu_info_ptr) \ 128 ((mpdu_info_ptr[RX_MPDU_DESC_INFO_BAR_FRAME_OFFSET >> 2] & \ 129 RX_MPDU_DESC_INFO_BAR_FRAME_MASK) >> \ 130 RX_MPDU_DESC_INFO_BAR_FRAME_LSB) 131 132 /* 133 * NOTE: None of the following _GET macros need a right 134 * shift by the corresponding _LSB. This is because, they are 135 * finally taken and "OR'ed" into a single word again. 136 */ 137 #define HAL_RX_MSDU_CONTINUATION_FLAG_SET(msdu_info_ptr, val) \ 138 ((*(((uint32_t *)msdu_info_ptr) + \ 139 (RX_MSDU_DESC_INFO_MSDU_CONTINUATION_OFFSET >> 2))) |= \ 140 ((val) << RX_MSDU_DESC_INFO_MSDU_CONTINUATION_LSB) & \ 141 RX_MSDU_DESC_INFO_MSDU_CONTINUATION_MASK) 142 143 #define HAL_RX_MSDU_CONTINUATION_FLAG_GET(msdu_info_ptr) \ 144 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 145 RX_MSDU_DESC_INFO_MSDU_CONTINUATION_OFFSET)) & \ 146 RX_MSDU_DESC_INFO_MSDU_CONTINUATION_MASK) 147 148 #define HAL_RX_MSDU_REO_DST_IND_GET(msdu_info_ptr) \ 149 (_HAL_MS((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 150 RX_MSDU_EXT_DESC_INFO_REO_DESTINATION_INDICATION_OFFSET)), \ 151 RX_MSDU_EXT_DESC_INFO_REO_DESTINATION_INDICATION_MASK, \ 152 RX_MSDU_EXT_DESC_INFO_REO_DESTINATION_INDICATION_LSB)) 153 154 #define HAL_RX_MSDU_SA_IS_VALID_FLAG_GET(msdu_info_ptr) \ 155 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 156 RX_MSDU_DESC_INFO_SA_IS_VALID_OFFSET)) & \ 157 RX_MSDU_DESC_INFO_SA_IS_VALID_MASK) 158 159 #define HAL_RX_MSDU_DA_IS_VALID_FLAG_GET(msdu_info_ptr) \ 160 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 161 RX_MSDU_DESC_INFO_DA_IS_VALID_OFFSET)) & \ 162 RX_MSDU_DESC_INFO_DA_IS_VALID_MASK) 163 164 #define HAL_RX_MSDU_DA_IS_MCBC_FLAG_GET(msdu_info_ptr) \ 165 ((*_OFFSET_TO_WORD_PTR(msdu_info_ptr, \ 166 RX_MSDU_DESC_INFO_DA_IS_MCBC_OFFSET)) & \ 167 RX_MSDU_DESC_INFO_DA_IS_MCBC_MASK) 168 169 #define HAL_RX_MPDU_ENCRYPT_TYPE_GET(_rx_mpdu_info) \ 170 (_HAL_MS((*_OFFSET_TO_WORD_PTR(_rx_mpdu_info, \ 171 RX_MPDU_INFO_ENCRYPT_TYPE_OFFSET)), \ 172 RX_MPDU_INFO_ENCRYPT_TYPE_MASK, \ 173 RX_MPDU_INFO_ENCRYPT_TYPE_LSB)) 174 175 #define HAL_RX_MSDU_DESC_INFO_SET(_msdu_info_ptr, _field, _val) \ 176 HAL_RX_FLD_SET(_msdu_info_ptr, RX_MSDU_DESC_INFO, \ 177 _field, _val) 178 179 #define HAL_RX_MPDU_DESC_INFO_SET(_mpdu_info_ptr, _field, _val) \ 180 HAL_RX_FLD_SET(_mpdu_info_ptr, RX_MPDU_DESC_INFO, \ 181 _field, _val) 182 183 #define HAL_RX_REO_MSDU_REO_DST_IND_GET(reo_desc) \ 184 (HAL_RX_MSDU_REO_DST_IND_GET(& \ 185 (((struct reo_destination_ring *) \ 186 reo_desc)->rx_msdu_desc_info_details))) 187 188 /** 189 * enum hal_be_rx_wbm_error_source: Indicates which module initiated the 190 * release of this buffer or descriptor 191 * 192 * @ HAL_BE_RX_WBM_ERR_SRC_RXDMA: RXDMA released this buffer or descriptor 193 * @ HAL_BE_RX_WBM_ERR_SRC_REO: REO released this buffer or descriptor 194 * @ HAL_BE_RX_WBM_ERR_SRC_FW_RX: FW released this buffer or descriptor from the 195 * RX path 196 * @ HAL_BE_RX_WBM_ERR_SRC_SW_RX: SW released this buffer or descriptor from the 197 * RX path 198 * @ HAL_BE_RX_WBM_ERR_SRC_TQM : TQM released this buffer or descriptor 199 * @ HAL_BE_RX_WBM_ERR_SRC_FW_TX: FW released this buffer or descriptor from the 200 * RX path 201 * @ HAL_BE_RX_WBM_ERR_SRC_SW_TX: SW released this buffer or descriptor from the 202 * RX path 203 */ 204 enum hal_be_rx_wbm_error_source { 205 HAL_BE_RX_WBM_ERR_SRC_RXDMA = 0, 206 HAL_BE_RX_WBM_ERR_SRC_REO, 207 HAL_BE_RX_WBM_ERR_SRC_FW_RX, 208 HAL_BE_RX_WBM_ERR_SRC_SW_RX, 209 HAL_BE_RX_WBM_ERR_SRC_TQM, 210 HAL_BE_RX_WBM_ERR_SRC_FW_TX, 211 HAL_BE_RX_WBM_ERR_SRC_SW_TX, 212 }; 213 214 /** 215 * enum hal_be_wbm_release_dir - Direction of the buffer which was released to 216 * wbm. 217 * @HAL_BE_WBM_RELEASE_DIR_RX: Buffer released to WBM due to error 218 * @HAL_BE_WBM_RELEASE_DIR_TX: Buffer released to WBM from TX path 219 */ 220 enum hal_be_wbm_release_dir { 221 HAL_BE_WBM_RELEASE_DIR_RX, 222 HAL_BE_WBM_RELEASE_DIR_TX, 223 }; 224 225 static inline uint32_t hal_rx_get_mpdu_flags(uint32_t *mpdu_info) 226 { 227 uint32_t mpdu_flags = 0; 228 229 if (HAL_RX_MPDU_FRAGMENT_FLAG_GET(mpdu_info)) 230 mpdu_flags |= HAL_MPDU_F_FRAGMENT; 231 232 if (HAL_RX_MPDU_RETRY_BIT_GET(mpdu_info)) 233 mpdu_flags |= HAL_MPDU_F_RETRY_BIT; 234 235 if (HAL_RX_MPDU_AMPDU_FLAG_GET(mpdu_info)) 236 mpdu_flags |= HAL_MPDU_F_AMPDU_FLAG; 237 238 if (HAL_RX_MPDU_RAW_MPDU_GET(mpdu_info)) 239 mpdu_flags |= HAL_MPDU_F_RAW_AMPDU; 240 241 return mpdu_flags; 242 } 243 244 /******************************************************************************* 245 * RX REO ERROR APIS 246 ******************************************************************************/ 247 248 #define HAL_RX_REO_BUF_TYPE_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \ 249 (REO_DESTINATION_RING_REO_DEST_BUFFER_TYPE_OFFSET >> 2))) & \ 250 REO_DESTINATION_RING_REO_DEST_BUFFER_TYPE_MASK) >> \ 251 REO_DESTINATION_RING_REO_DEST_BUFFER_TYPE_LSB) 252 253 #define HAL_RX_REO_QUEUE_NUMBER_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \ 254 (REO_DESTINATION_RING_RX_MPDU_DESC_INFO_DETAILS_TID_OFFSET >> 2))) & \ 255 REO_DESTINATION_RING_RX_MPDU_DESC_INFO_DETAILS_TID_MASK) >> \ 256 REO_DESTINATION_RING_RX_MPDU_DESC_INFO_DETAILS_TID_LSB) 257 258 #define HAL_RX_REO_ERROR_GET(reo_desc) (((*(((uint32_t *)reo_desc) + \ 259 (REO_DESTINATION_RING_REO_ERROR_CODE_OFFSET >> 2))) & \ 260 REO_DESTINATION_RING_REO_ERROR_CODE_MASK) >> \ 261 REO_DESTINATION_RING_REO_ERROR_CODE_LSB) 262 263 /* 264 * hal_rx_msdu_link_desc_reinject: Re-injects the MSDU link descriptor to 265 * REO entrance ring 266 * 267 * @ soc: HAL version of the SOC pointer 268 * @ pa: Physical address of the MSDU Link Descriptor 269 * @ cookie: SW cookie to get to the virtual address 270 * @ error_enabled_reo_q: Argument to determine whether this needs to go 271 * to the error enabled REO queue 272 * 273 * Return: void 274 */ 275 static inline void 276 hal_rx_msdu_link_desc_reinject(struct hal_soc *soc, uint64_t pa, 277 uint32_t cookie, bool error_enabled_reo_q) 278 { 279 /* TODO */ 280 } 281 282 #ifdef DP_HW_COOKIE_CONVERT_EXCEPTION 283 /* HW set dowrd-2 bit16 to 1 if HW CC is done */ 284 #define HAL_WBM2SW_COMPLETION_RING_RX_CC_DONE_OFFSET 0x8 285 #define HAL_WBM2SW_COMPLETION_RING_RX_CC_DONE_MASK 0x10000 286 #define HAL_WBM2SW_COMPLETION_RING_RX_CC_DONE_LSB 0x10 287 /** 288 * hal_rx_wbm_get_cookie_convert_done() - Get cookie conversion done flag 289 * @hal_desc: wbm Rx ring descriptor pointer 290 * 291 * This function will get the bit value that indicate HW cookie 292 * conversion done or not 293 * 294 * Return: 1 - HW cookie conversion done, 0 - not 295 */ 296 static inline uint8_t hal_rx_wbm_get_cookie_convert_done(void *hal_desc) 297 { 298 return HAL_RX_GET(hal_desc, HAL_WBM2SW_COMPLETION_RING_RX, 299 CC_DONE); 300 } 301 #endif 302 303 /** 304 * hal_rx_wbm_get_desc_va() - Get Desc virtual address within WBM Desc 305 * @hal_desc: RX WBM2SW ring descriptor pointer 306 * 307 * Return: RX descriptor virtual address 308 */ 309 static inline uintptr_t hal_rx_wbm_get_desc_va(void *hal_desc) 310 { 311 uint64_t va_from_desc; 312 313 va_from_desc = HAL_RX_GET(hal_desc, 314 WBM2SW_COMPLETION_RING_RX, 315 BUFFER_VIRT_ADDR_31_0) | 316 (((uint64_t)HAL_RX_GET(hal_desc, 317 WBM2SW_COMPLETION_RING_RX, 318 BUFFER_VIRT_ADDR_63_32)) << 32); 319 320 return (uintptr_t)va_from_desc; 321 } 322 323 #define HAL_RX_WBM_FIRST_MSDU_GET(wbm_desc) \ 324 (((*(((uint32_t *)wbm_desc) + \ 325 (WBM_RELEASE_RING_FIRST_MSDU_OFFSET >> 2))) & \ 326 WBM_RELEASE_RING_FIRST_MSDU_MASK) >> \ 327 WBM_RELEASE_RING_FIRST_MSDU_LSB) 328 329 #define HAL_RX_WBM_LAST_MSDU_GET(wbm_desc) \ 330 (((*(((uint32_t *)wbm_desc) + \ 331 (WBM_RELEASE_RING_LAST_MSDU_OFFSET >> 2))) & \ 332 WBM_RELEASE_RING_LAST_MSDU_MASK) >> \ 333 WBM_RELEASE_RING_LAST_MSDU_LSB) 334 335 #define HAL_RX_WBM_BUF_COOKIE_GET(wbm_desc) \ 336 HAL_RX_BUF_COOKIE_GET(&((struct wbm_release_ring *) \ 337 wbm_desc)->released_buff_or_desc_addr_info) 338 339 /** 340 * hal_rx_msdu_flags_get_be() - Get msdu flags from ring desc 341 * @msdu_desc_info_hdl: msdu desc info handle 342 * 343 * Return: msdu flags 344 */ 345 static inline 346 uint32_t hal_rx_msdu_flags_get_be(rx_msdu_desc_info_t msdu_desc_info_hdl) 347 { 348 struct rx_msdu_desc_info *msdu_desc_info = 349 (struct rx_msdu_desc_info *)msdu_desc_info_hdl; 350 uint32_t flags = 0; 351 352 if (HAL_RX_FIRST_MSDU_IN_MPDU_FLAG_GET(msdu_desc_info)) 353 flags |= HAL_MSDU_F_FIRST_MSDU_IN_MPDU; 354 355 if (HAL_RX_LAST_MSDU_IN_MPDU_FLAG_GET(msdu_desc_info)) 356 flags |= HAL_MSDU_F_LAST_MSDU_IN_MPDU; 357 358 if (HAL_RX_MSDU_CONTINUATION_FLAG_GET(msdu_desc_info)) 359 flags |= HAL_MSDU_F_MSDU_CONTINUATION; 360 361 if (HAL_RX_MSDU_SA_IS_VALID_FLAG_GET(msdu_desc_info)) 362 flags |= HAL_MSDU_F_SA_IS_VALID; 363 364 if (HAL_RX_MSDU_DA_IS_VALID_FLAG_GET(msdu_desc_info)) 365 flags |= HAL_MSDU_F_DA_IS_VALID; 366 367 if (HAL_RX_MSDU_DA_IS_MCBC_FLAG_GET(msdu_desc_info)) 368 flags |= HAL_MSDU_F_DA_IS_MCBC; 369 370 return flags; 371 } 372 373 static inline 374 void hal_rx_mpdu_desc_info_get_be(void *desc_addr, 375 void *mpdu_desc_info_hdl) 376 { 377 struct reo_destination_ring *reo_dst_ring; 378 struct hal_rx_mpdu_desc_info *mpdu_desc_info = 379 (struct hal_rx_mpdu_desc_info *)mpdu_desc_info_hdl; 380 uint32_t *mpdu_info; 381 382 reo_dst_ring = (struct reo_destination_ring *)desc_addr; 383 384 mpdu_info = (uint32_t *)&reo_dst_ring->rx_mpdu_desc_info_details; 385 386 mpdu_desc_info->msdu_count = HAL_RX_MPDU_MSDU_COUNT_GET(mpdu_info); 387 mpdu_desc_info->mpdu_flags = hal_rx_get_mpdu_flags(mpdu_info); 388 mpdu_desc_info->peer_meta_data = 389 HAL_RX_MPDU_DESC_PEER_META_DATA_GET(mpdu_info); 390 mpdu_desc_info->bar_frame = HAL_RX_MPDU_BAR_FRAME_GET(mpdu_info); 391 } 392 393 /* 394 *hal_rx_msdu_desc_info_get_be: Gets the flags related to MSDU descriptor. 395 *@desc_addr: REO ring descriptor addr 396 *@msdu_desc_info: Holds MSDU descriptor info from HAL Rx descriptor 397 * 398 * Specifically flags needed are: first_msdu_in_mpdu, 399 * last_msdu_in_mpdu, msdu_continuation, sa_is_valid, 400 * sa_idx_timeout, da_is_valid, da_idx_timeout, da_is_MCBC 401 * 402 403 *Return: void 404 */ 405 static inline void 406 hal_rx_msdu_desc_info_get_be(void *desc_addr, 407 struct hal_rx_msdu_desc_info *msdu_desc_info) 408 { 409 struct reo_destination_ring *reo_dst_ring; 410 uint32_t *msdu_info; 411 412 reo_dst_ring = (struct reo_destination_ring *)desc_addr; 413 414 msdu_info = (uint32_t *)&reo_dst_ring->rx_msdu_desc_info_details; 415 msdu_desc_info->msdu_flags = 416 hal_rx_msdu_flags_get_be((struct rx_msdu_desc_info *)msdu_info); 417 msdu_desc_info->msdu_len = HAL_RX_MSDU_PKT_LENGTH_GET(msdu_info); 418 } 419 420 /** 421 * hal_rx_get_reo_desc_va() - Get Desc virtual address within REO Desc 422 * @reo_desc: REO2SW ring descriptor pointer 423 * 424 * Return: RX descriptor virtual address 425 */ 426 static inline uintptr_t hal_rx_get_reo_desc_va(void *reo_desc) 427 { 428 uint64_t va_from_desc; 429 430 va_from_desc = HAL_RX_GET(reo_desc, 431 REO_DESTINATION_RING, 432 BUFFER_VIRT_ADDR_31_0) | 433 (((uint64_t)HAL_RX_GET(reo_desc, 434 REO_DESTINATION_RING, 435 BUFFER_VIRT_ADDR_63_32)) << 32); 436 437 return (uintptr_t)va_from_desc; 438 } 439 440 #endif /* _HAL_BE_RX_H_ */ 441