1 /* 2 * Copyright (c) 2016-2018 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 #include "hal_hw_headers.h" 20 #include "hal_reo.h" 21 #include "hal_tx.h" 22 #include "qdf_module.h" 23 24 #define BLOCK_RES_MASK 0xF 25 static inline uint8_t hal_find_one_bit(uint8_t x) 26 { 27 uint8_t y = (x & (~x + 1)) & BLOCK_RES_MASK; 28 uint8_t pos; 29 30 for (pos = 0; y; y >>= 1) 31 pos++; 32 33 return pos-1; 34 } 35 36 static inline uint8_t hal_find_zero_bit(uint8_t x) 37 { 38 uint8_t y = (~x & (x+1)) & BLOCK_RES_MASK; 39 uint8_t pos; 40 41 for (pos = 0; y; y >>= 1) 42 pos++; 43 44 return pos-1; 45 } 46 47 inline void hal_reo_cmd_set_descr_addr(uint32_t *reo_desc, 48 enum hal_reo_cmd_type type, 49 uint32_t paddr_lo, 50 uint8_t paddr_hi) 51 { 52 switch (type) { 53 case CMD_GET_QUEUE_STATS: 54 HAL_DESC_SET_FIELD(reo_desc, REO_GET_QUEUE_STATS_1, 55 RX_REO_QUEUE_DESC_ADDR_31_0, paddr_lo); 56 HAL_DESC_SET_FIELD(reo_desc, REO_GET_QUEUE_STATS_2, 57 RX_REO_QUEUE_DESC_ADDR_39_32, paddr_hi); 58 break; 59 case CMD_FLUSH_QUEUE: 60 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_QUEUE_1, 61 FLUSH_DESC_ADDR_31_0, paddr_lo); 62 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_QUEUE_2, 63 FLUSH_DESC_ADDR_39_32, paddr_hi); 64 break; 65 case CMD_FLUSH_CACHE: 66 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_CACHE_1, 67 FLUSH_ADDR_31_0, paddr_lo); 68 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_CACHE_2, 69 FLUSH_ADDR_39_32, paddr_hi); 70 break; 71 case CMD_UPDATE_RX_REO_QUEUE: 72 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_1, 73 RX_REO_QUEUE_DESC_ADDR_31_0, paddr_lo); 74 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 75 RX_REO_QUEUE_DESC_ADDR_39_32, paddr_hi); 76 break; 77 default: 78 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 79 "%s: Invalid REO command type", __func__); 80 break; 81 } 82 } 83 84 inline int hal_reo_cmd_queue_stats(void *reo_ring, struct hal_soc *soc, 85 struct hal_reo_cmd_params *cmd) 86 87 { 88 uint32_t *reo_desc, val; 89 90 hal_srng_access_start(soc, reo_ring); 91 reo_desc = hal_srng_src_get_next(soc, reo_ring); 92 if (!reo_desc) { 93 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 94 "%s: Out of cmd ring entries", __func__); 95 hal_srng_access_end(soc, reo_ring); 96 return -EBUSY; 97 } 98 99 HAL_SET_TLV_HDR(reo_desc, WIFIREO_GET_QUEUE_STATS_E, 100 sizeof(struct reo_get_queue_stats)); 101 102 /* Offsets of descriptor fields defined in HW headers start from 103 * the field after TLV header */ 104 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 105 qdf_mem_zero((void *)reo_desc, sizeof(struct reo_get_queue_stats)); 106 107 HAL_DESC_SET_FIELD(reo_desc, UNIFORM_REO_CMD_HEADER_0, 108 REO_STATUS_REQUIRED, cmd->std.need_status); 109 110 hal_reo_cmd_set_descr_addr(reo_desc, CMD_GET_QUEUE_STATS, 111 cmd->std.addr_lo, 112 cmd->std.addr_hi); 113 114 HAL_DESC_SET_FIELD(reo_desc, REO_GET_QUEUE_STATS_2, CLEAR_STATS, 115 cmd->u.stats_params.clear); 116 117 hal_srng_access_end(soc, reo_ring); 118 119 val = reo_desc[CMD_HEADER_DW_OFFSET]; 120 return HAL_GET_FIELD(UNIFORM_REO_CMD_HEADER_0, REO_CMD_NUMBER, 121 val); 122 } 123 qdf_export_symbol(hal_reo_cmd_queue_stats); 124 125 inline int hal_reo_cmd_flush_queue(void *reo_ring, struct hal_soc *soc, 126 struct hal_reo_cmd_params *cmd) 127 { 128 uint32_t *reo_desc, val; 129 130 hal_srng_access_start(soc, reo_ring); 131 reo_desc = hal_srng_src_get_next(soc, reo_ring); 132 if (!reo_desc) { 133 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 134 "%s: Out of cmd ring entries", __func__); 135 hal_srng_access_end(soc, reo_ring); 136 return -EBUSY; 137 } 138 139 HAL_SET_TLV_HDR(reo_desc, WIFIREO_FLUSH_QUEUE_E, 140 sizeof(struct reo_flush_queue)); 141 142 /* Offsets of descriptor fields defined in HW headers start from 143 * the field after TLV header */ 144 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 145 qdf_mem_zero((void *)reo_desc, sizeof(struct reo_flush_queue)); 146 147 HAL_DESC_SET_FIELD(reo_desc, UNIFORM_REO_CMD_HEADER_0, 148 REO_STATUS_REQUIRED, cmd->std.need_status); 149 150 hal_reo_cmd_set_descr_addr(reo_desc, CMD_FLUSH_QUEUE, cmd->std.addr_lo, 151 cmd->std.addr_hi); 152 153 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_QUEUE_2, 154 BLOCK_DESC_ADDR_USAGE_AFTER_FLUSH, 155 cmd->u.fl_queue_params.block_use_after_flush); 156 157 if (cmd->u.fl_queue_params.block_use_after_flush) { 158 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_QUEUE_2, 159 BLOCK_RESOURCE_INDEX, cmd->u.fl_queue_params.index); 160 } 161 162 hal_srng_access_end(soc, reo_ring); 163 val = reo_desc[CMD_HEADER_DW_OFFSET]; 164 return HAL_GET_FIELD(UNIFORM_REO_CMD_HEADER_0, REO_CMD_NUMBER, 165 val); 166 } 167 qdf_export_symbol(hal_reo_cmd_flush_queue); 168 169 inline int hal_reo_cmd_flush_cache(void *reo_ring, struct hal_soc *soc, 170 struct hal_reo_cmd_params *cmd) 171 { 172 uint32_t *reo_desc, val; 173 struct hal_reo_cmd_flush_cache_params *cp; 174 uint8_t index = 0; 175 176 cp = &cmd->u.fl_cache_params; 177 178 hal_srng_access_start(soc, reo_ring); 179 180 /* We need a cache block resource for this operation, and REO HW has 181 * only 4 such blocking resources. These resources are managed using 182 * reo_res_bitmap, and we return failure if none is available. 183 */ 184 if (cp->block_use_after_flush) { 185 index = hal_find_zero_bit(soc->reo_res_bitmap); 186 if (index > 3) { 187 qdf_print("%s, No blocking resource available!", 188 __func__); 189 hal_srng_access_end(soc, reo_ring); 190 return -EBUSY; 191 } 192 soc->index = index; 193 } 194 195 reo_desc = hal_srng_src_get_next(soc, reo_ring); 196 if (!reo_desc) { 197 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 198 "%s: Out of cmd ring entries", __func__); 199 hal_srng_access_end(soc, reo_ring); 200 hal_srng_dump(reo_ring); 201 return -EBUSY; 202 } 203 204 HAL_SET_TLV_HDR(reo_desc, WIFIREO_FLUSH_CACHE_E, 205 sizeof(struct reo_flush_cache)); 206 207 /* Offsets of descriptor fields defined in HW headers start from 208 * the field after TLV header */ 209 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 210 qdf_mem_zero((void *)reo_desc, sizeof(struct reo_flush_cache)); 211 212 HAL_DESC_SET_FIELD(reo_desc, UNIFORM_REO_CMD_HEADER_0, 213 REO_STATUS_REQUIRED, cmd->std.need_status); 214 215 hal_reo_cmd_set_descr_addr(reo_desc, CMD_FLUSH_CACHE, cmd->std.addr_lo, 216 cmd->std.addr_hi); 217 218 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_CACHE_2, 219 FORWARD_ALL_MPDUS_IN_QUEUE, cp->fwd_mpdus_in_queue); 220 221 /* set it to 0 for now */ 222 cp->rel_block_index = 0; 223 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_CACHE_2, 224 RELEASE_CACHE_BLOCK_INDEX, cp->rel_block_index); 225 226 if (cp->block_use_after_flush) { 227 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_CACHE_2, 228 CACHE_BLOCK_RESOURCE_INDEX, index); 229 } 230 231 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_CACHE_2, 232 FLUSH_WITHOUT_INVALIDATE, cp->flush_no_inval); 233 234 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_CACHE_2, 235 BLOCK_CACHE_USAGE_AFTER_FLUSH, cp->block_use_after_flush); 236 237 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_CACHE_2, FLUSH_ENTIRE_CACHE, 238 cp->flush_all); 239 240 hal_srng_access_end(soc, reo_ring); 241 val = reo_desc[CMD_HEADER_DW_OFFSET]; 242 return HAL_GET_FIELD(UNIFORM_REO_CMD_HEADER_0, REO_CMD_NUMBER, 243 val); 244 } 245 qdf_export_symbol(hal_reo_cmd_flush_cache); 246 247 inline int hal_reo_cmd_unblock_cache(void *reo_ring, struct hal_soc *soc, 248 struct hal_reo_cmd_params *cmd) 249 250 { 251 uint32_t *reo_desc, val; 252 uint8_t index = 0; 253 254 hal_srng_access_start(soc, reo_ring); 255 256 if (cmd->u.unblk_cache_params.type == UNBLOCK_RES_INDEX) { 257 index = hal_find_one_bit(soc->reo_res_bitmap); 258 if (index > 3) { 259 hal_srng_access_end(soc, reo_ring); 260 qdf_print("%s: No blocking resource to unblock!", 261 __func__); 262 return -EBUSY; 263 } 264 } 265 266 reo_desc = hal_srng_src_get_next(soc, reo_ring); 267 if (!reo_desc) { 268 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 269 "%s: Out of cmd ring entries", __func__); 270 hal_srng_access_end(soc, reo_ring); 271 return -EBUSY; 272 } 273 274 HAL_SET_TLV_HDR(reo_desc, WIFIREO_UNBLOCK_CACHE_E, 275 sizeof(struct reo_unblock_cache)); 276 277 /* Offsets of descriptor fields defined in HW headers start from 278 * the field after TLV header */ 279 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 280 qdf_mem_zero((void *)reo_desc, sizeof(struct reo_unblock_cache)); 281 282 HAL_DESC_SET_FIELD(reo_desc, UNIFORM_REO_CMD_HEADER_0, 283 REO_STATUS_REQUIRED, cmd->std.need_status); 284 285 HAL_DESC_SET_FIELD(reo_desc, REO_UNBLOCK_CACHE_1, 286 UNBLOCK_TYPE, cmd->u.unblk_cache_params.type); 287 288 if (cmd->u.unblk_cache_params.type == UNBLOCK_RES_INDEX) { 289 HAL_DESC_SET_FIELD(reo_desc, REO_UNBLOCK_CACHE_1, 290 CACHE_BLOCK_RESOURCE_INDEX, 291 cmd->u.unblk_cache_params.index); 292 } 293 294 hal_srng_access_end(soc, reo_ring); 295 val = reo_desc[CMD_HEADER_DW_OFFSET]; 296 return HAL_GET_FIELD(UNIFORM_REO_CMD_HEADER_0, REO_CMD_NUMBER, 297 val); 298 } 299 qdf_export_symbol(hal_reo_cmd_unblock_cache); 300 301 inline int hal_reo_cmd_flush_timeout_list(void *reo_ring, struct hal_soc *soc, 302 struct hal_reo_cmd_params *cmd) 303 { 304 uint32_t *reo_desc, val; 305 306 hal_srng_access_start(soc, reo_ring); 307 reo_desc = hal_srng_src_get_next(soc, reo_ring); 308 if (!reo_desc) { 309 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 310 "%s: Out of cmd ring entries", __func__); 311 hal_srng_access_end(soc, reo_ring); 312 return -EBUSY; 313 } 314 315 HAL_SET_TLV_HDR(reo_desc, WIFIREO_FLUSH_TIMEOUT_LIST_E, 316 sizeof(struct reo_flush_timeout_list)); 317 318 /* Offsets of descriptor fields defined in HW headers start from 319 * the field after TLV header */ 320 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 321 qdf_mem_zero((void *)reo_desc, sizeof(struct reo_flush_timeout_list)); 322 323 HAL_DESC_SET_FIELD(reo_desc, UNIFORM_REO_CMD_HEADER_0, 324 REO_STATUS_REQUIRED, cmd->std.need_status); 325 326 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_TIMEOUT_LIST_1, AC_TIMOUT_LIST, 327 cmd->u.fl_tim_list_params.ac_list); 328 329 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_TIMEOUT_LIST_2, 330 MINIMUM_RELEASE_DESC_COUNT, 331 cmd->u.fl_tim_list_params.min_rel_desc); 332 333 HAL_DESC_SET_FIELD(reo_desc, REO_FLUSH_TIMEOUT_LIST_2, 334 MINIMUM_FORWARD_BUF_COUNT, 335 cmd->u.fl_tim_list_params.min_fwd_buf); 336 337 hal_srng_access_end(soc, reo_ring); 338 val = reo_desc[CMD_HEADER_DW_OFFSET]; 339 return HAL_GET_FIELD(UNIFORM_REO_CMD_HEADER_0, REO_CMD_NUMBER, 340 val); 341 } 342 qdf_export_symbol(hal_reo_cmd_flush_timeout_list); 343 344 inline int hal_reo_cmd_update_rx_queue(void *reo_ring, struct hal_soc *soc, 345 struct hal_reo_cmd_params *cmd) 346 { 347 uint32_t *reo_desc, val; 348 struct hal_reo_cmd_update_queue_params *p; 349 350 p = &cmd->u.upd_queue_params; 351 352 hal_srng_access_start(soc, reo_ring); 353 reo_desc = hal_srng_src_get_next(soc, reo_ring); 354 if (!reo_desc) { 355 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 356 "%s: Out of cmd ring entries", __func__); 357 hal_srng_access_end(soc, reo_ring); 358 return -EBUSY; 359 } 360 361 HAL_SET_TLV_HDR(reo_desc, WIFIREO_UPDATE_RX_REO_QUEUE_E, 362 sizeof(struct reo_update_rx_reo_queue)); 363 364 /* Offsets of descriptor fields defined in HW headers start from 365 * the field after TLV header */ 366 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 367 qdf_mem_zero((void *)reo_desc, sizeof(struct reo_update_rx_reo_queue)); 368 369 HAL_DESC_SET_FIELD(reo_desc, UNIFORM_REO_CMD_HEADER_0, 370 REO_STATUS_REQUIRED, cmd->std.need_status); 371 372 hal_reo_cmd_set_descr_addr(reo_desc, CMD_UPDATE_RX_REO_QUEUE, 373 cmd->std.addr_lo, cmd->std.addr_hi); 374 375 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 376 UPDATE_RECEIVE_QUEUE_NUMBER, p->update_rx_queue_num); 377 378 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, UPDATE_VLD, 379 p->update_vld); 380 381 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 382 UPDATE_ASSOCIATED_LINK_DESCRIPTOR_COUNTER, 383 p->update_assoc_link_desc); 384 385 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 386 UPDATE_DISABLE_DUPLICATE_DETECTION, 387 p->update_disable_dup_detect); 388 389 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 390 UPDATE_DISABLE_DUPLICATE_DETECTION, 391 p->update_disable_dup_detect); 392 393 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 394 UPDATE_SOFT_REORDER_ENABLE, 395 p->update_soft_reorder_enab); 396 397 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 398 UPDATE_AC, p->update_ac); 399 400 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 401 UPDATE_BAR, p->update_bar); 402 403 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 404 UPDATE_BAR, p->update_bar); 405 406 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 407 UPDATE_RTY, p->update_rty); 408 409 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 410 UPDATE_CHK_2K_MODE, p->update_chk_2k_mode); 411 412 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 413 UPDATE_OOR_MODE, p->update_oor_mode); 414 415 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 416 UPDATE_BA_WINDOW_SIZE, p->update_ba_window_size); 417 418 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 419 UPDATE_PN_CHECK_NEEDED, p->update_pn_check_needed); 420 421 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 422 UPDATE_PN_SHALL_BE_EVEN, p->update_pn_even); 423 424 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 425 UPDATE_PN_SHALL_BE_UNEVEN, p->update_pn_uneven); 426 427 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 428 UPDATE_PN_HANDLING_ENABLE, p->update_pn_hand_enab); 429 430 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 431 UPDATE_PN_SIZE, p->update_pn_size); 432 433 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 434 UPDATE_IGNORE_AMPDU_FLAG, p->update_ignore_ampdu); 435 436 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 437 UPDATE_SVLD, p->update_svld); 438 439 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 440 UPDATE_SSN, p->update_ssn); 441 442 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 443 UPDATE_SEQ_2K_ERROR_DETECTED_FLAG, 444 p->update_seq_2k_err_detect); 445 446 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 447 UPDATE_PN_VALID, p->update_pn_valid); 448 449 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_2, 450 UPDATE_PN, p->update_pn); 451 452 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 453 RECEIVE_QUEUE_NUMBER, p->rx_queue_num); 454 455 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 456 VLD, p->vld); 457 458 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 459 ASSOCIATED_LINK_DESCRIPTOR_COUNTER, 460 p->assoc_link_desc); 461 462 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 463 DISABLE_DUPLICATE_DETECTION, p->disable_dup_detect); 464 465 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 466 SOFT_REORDER_ENABLE, p->soft_reorder_enab); 467 468 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, AC, p->ac); 469 470 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 471 BAR, p->bar); 472 473 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 474 CHK_2K_MODE, p->chk_2k_mode); 475 476 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 477 RTY, p->rty); 478 479 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 480 OOR_MODE, p->oor_mode); 481 482 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 483 PN_CHECK_NEEDED, p->pn_check_needed); 484 485 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 486 PN_SHALL_BE_EVEN, p->pn_even); 487 488 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 489 PN_SHALL_BE_UNEVEN, p->pn_uneven); 490 491 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 492 PN_HANDLING_ENABLE, p->pn_hand_enab); 493 494 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_3, 495 IGNORE_AMPDU_FLAG, p->ignore_ampdu); 496 497 if (p->ba_window_size < 1) 498 p->ba_window_size = 1; 499 500 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_4, 501 BA_WINDOW_SIZE, p->ba_window_size - 1); 502 503 if (p->pn_size == 24) 504 p->pn_size = PN_SIZE_24; 505 else if (p->pn_size == 48) 506 p->pn_size = PN_SIZE_48; 507 else if (p->pn_size == 128) 508 p->pn_size = PN_SIZE_128; 509 510 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_4, 511 PN_SIZE, p->pn_size); 512 513 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_4, 514 SVLD, p->svld); 515 516 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_4, 517 SSN, p->ssn); 518 519 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_4, 520 SEQ_2K_ERROR_DETECTED_FLAG, p->seq_2k_err_detect); 521 522 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_4, 523 PN_ERROR_DETECTED_FLAG, p->pn_err_detect); 524 525 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_5, 526 PN_31_0, p->pn_31_0); 527 528 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_6, 529 PN_63_32, p->pn_63_32); 530 531 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_7, 532 PN_95_64, p->pn_95_64); 533 534 HAL_DESC_SET_FIELD(reo_desc, REO_UPDATE_RX_REO_QUEUE_8, 535 PN_127_96, p->pn_127_96); 536 537 hal_srng_access_end(soc, reo_ring); 538 val = reo_desc[CMD_HEADER_DW_OFFSET]; 539 return HAL_GET_FIELD(UNIFORM_REO_CMD_HEADER_0, REO_CMD_NUMBER, 540 val); 541 } 542 qdf_export_symbol(hal_reo_cmd_update_rx_queue); 543 544 inline void hal_reo_queue_stats_status(uint32_t *reo_desc, 545 struct hal_reo_queue_status *st) 546 { 547 uint32_t val; 548 549 /* Offsets of descriptor fields defined in HW headers start 550 * from the field after TLV header */ 551 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 552 553 /* header */ 554 HAL_REO_STATUS_GET_HEADER(reo_desc, REO_GET_QUEUE_STATS, st->header); 555 556 /* SSN */ 557 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_2, SSN)]; 558 st->ssn = HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_2, SSN, val); 559 560 /* current index */ 561 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_2, 562 CURRENT_INDEX)]; 563 st->curr_idx = 564 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_2, 565 CURRENT_INDEX, val); 566 567 /* PN bits */ 568 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_3, 569 PN_31_0)]; 570 st->pn_31_0 = 571 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_3, 572 PN_31_0, val); 573 574 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_4, 575 PN_63_32)]; 576 st->pn_63_32 = 577 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_4, 578 PN_63_32, val); 579 580 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_5, 581 PN_95_64)]; 582 st->pn_95_64 = 583 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_5, 584 PN_95_64, val); 585 586 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_6, 587 PN_127_96)]; 588 st->pn_127_96 = 589 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_6, 590 PN_127_96, val); 591 592 /* timestamps */ 593 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_7, 594 LAST_RX_ENQUEUE_TIMESTAMP)]; 595 st->last_rx_enq_tstamp = 596 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_7, 597 LAST_RX_ENQUEUE_TIMESTAMP, val); 598 599 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_8, 600 LAST_RX_DEQUEUE_TIMESTAMP)]; 601 st->last_rx_deq_tstamp = 602 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_8, 603 LAST_RX_DEQUEUE_TIMESTAMP, val); 604 605 /* rx bitmap */ 606 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_9, 607 RX_BITMAP_31_0)]; 608 st->rx_bitmap_31_0 = 609 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_9, 610 RX_BITMAP_31_0, val); 611 612 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_10, 613 RX_BITMAP_63_32)]; 614 st->rx_bitmap_63_32 = 615 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_10, 616 RX_BITMAP_63_32, val); 617 618 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_11, 619 RX_BITMAP_95_64)]; 620 st->rx_bitmap_95_64 = 621 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_11, 622 RX_BITMAP_95_64, val); 623 624 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_12, 625 RX_BITMAP_127_96)]; 626 st->rx_bitmap_127_96 = 627 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_12, 628 RX_BITMAP_127_96, val); 629 630 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_13, 631 RX_BITMAP_159_128)]; 632 st->rx_bitmap_159_128 = 633 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_13, 634 RX_BITMAP_159_128, val); 635 636 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_14, 637 RX_BITMAP_191_160)]; 638 st->rx_bitmap_191_160 = 639 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_14, 640 RX_BITMAP_191_160, val); 641 642 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_15, 643 RX_BITMAP_223_192)]; 644 st->rx_bitmap_223_192 = 645 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_15, 646 RX_BITMAP_223_192, val); 647 648 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_16, 649 RX_BITMAP_255_224)]; 650 st->rx_bitmap_255_224 = 651 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_16, 652 RX_BITMAP_255_224, val); 653 654 /* various counts */ 655 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_17, 656 CURRENT_MPDU_COUNT)]; 657 st->curr_mpdu_cnt = 658 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_17, 659 CURRENT_MPDU_COUNT, val); 660 661 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_17, 662 CURRENT_MSDU_COUNT)]; 663 st->curr_msdu_cnt = 664 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_17, 665 CURRENT_MSDU_COUNT, val); 666 667 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_18, 668 TIMEOUT_COUNT)]; 669 st->fwd_timeout_cnt = 670 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_18, 671 TIMEOUT_COUNT, val); 672 673 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_18, 674 FORWARD_DUE_TO_BAR_COUNT)]; 675 st->fwd_bar_cnt = 676 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_18, 677 FORWARD_DUE_TO_BAR_COUNT, val); 678 679 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_18, 680 DUPLICATE_COUNT)]; 681 st->dup_cnt = 682 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_18, 683 DUPLICATE_COUNT, val); 684 685 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_19, 686 FRAMES_IN_ORDER_COUNT)]; 687 st->frms_in_order_cnt = 688 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_19, 689 FRAMES_IN_ORDER_COUNT, val); 690 691 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_19, 692 BAR_RECEIVED_COUNT)]; 693 st->bar_rcvd_cnt = 694 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_19, 695 BAR_RECEIVED_COUNT, val); 696 697 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_20, 698 MPDU_FRAMES_PROCESSED_COUNT)]; 699 st->mpdu_frms_cnt = 700 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_20, 701 MPDU_FRAMES_PROCESSED_COUNT, val); 702 703 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_21, 704 MSDU_FRAMES_PROCESSED_COUNT)]; 705 st->msdu_frms_cnt = 706 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_21, 707 MSDU_FRAMES_PROCESSED_COUNT, val); 708 709 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_22, 710 TOTAL_PROCESSED_BYTE_COUNT)]; 711 st->total_cnt = 712 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_22, 713 TOTAL_PROCESSED_BYTE_COUNT, val); 714 715 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_23, 716 LATE_RECEIVE_MPDU_COUNT)]; 717 st->late_recv_mpdu_cnt = 718 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_23, 719 LATE_RECEIVE_MPDU_COUNT, val); 720 721 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_23, 722 WINDOW_JUMP_2K)]; 723 st->win_jump_2k = 724 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_23, 725 WINDOW_JUMP_2K, val); 726 727 val = reo_desc[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_23, 728 HOLE_COUNT)]; 729 st->hole_cnt = 730 HAL_GET_FIELD(REO_GET_QUEUE_STATS_STATUS_23, 731 HOLE_COUNT, val); 732 } 733 qdf_export_symbol(hal_reo_queue_stats_status); 734 735 inline void hal_reo_flush_queue_status(uint32_t *reo_desc, 736 struct hal_reo_flush_queue_status *st) 737 { 738 uint32_t val; 739 740 /* Offsets of descriptor fields defined in HW headers start 741 * from the field after TLV header */ 742 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 743 744 /* header */ 745 HAL_REO_STATUS_GET_HEADER(reo_desc, REO_FLUSH_QUEUE, st->header); 746 747 /* error bit */ 748 val = reo_desc[HAL_OFFSET(REO_FLUSH_QUEUE_STATUS_2, 749 ERROR_DETECTED)]; 750 st->error = HAL_GET_FIELD(REO_FLUSH_QUEUE_STATUS_2, ERROR_DETECTED, 751 val); 752 } 753 qdf_export_symbol(hal_reo_flush_queue_status); 754 755 inline void hal_reo_flush_cache_status(uint32_t *reo_desc, struct hal_soc *soc, 756 struct hal_reo_flush_cache_status *st) 757 { 758 uint32_t val; 759 760 /* Offsets of descriptor fields defined in HW headers start 761 * from the field after TLV header */ 762 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 763 764 /* header */ 765 HAL_REO_STATUS_GET_HEADER(reo_desc, REO_FLUSH_CACHE, st->header); 766 767 /* error bit */ 768 val = reo_desc[HAL_OFFSET_DW(REO_FLUSH_CACHE_STATUS_2, 769 ERROR_DETECTED)]; 770 st->error = HAL_GET_FIELD(REO_FLUSH_QUEUE_STATUS_2, ERROR_DETECTED, 771 val); 772 773 /* block error */ 774 val = reo_desc[HAL_OFFSET_DW(REO_FLUSH_CACHE_STATUS_2, 775 BLOCK_ERROR_DETAILS)]; 776 st->block_error = HAL_GET_FIELD(REO_FLUSH_CACHE_STATUS_2, 777 BLOCK_ERROR_DETAILS, 778 val); 779 if (!st->block_error) 780 qdf_set_bit(soc->index, (unsigned long *)&soc->reo_res_bitmap); 781 782 /* cache flush status */ 783 val = reo_desc[HAL_OFFSET_DW(REO_FLUSH_CACHE_STATUS_2, 784 CACHE_CONTROLLER_FLUSH_STATUS_HIT)]; 785 st->cache_flush_status = HAL_GET_FIELD(REO_FLUSH_CACHE_STATUS_2, 786 CACHE_CONTROLLER_FLUSH_STATUS_HIT, 787 val); 788 789 /* cache flush descriptor type */ 790 val = reo_desc[HAL_OFFSET_DW(REO_FLUSH_CACHE_STATUS_2, 791 CACHE_CONTROLLER_FLUSH_STATUS_DESC_TYPE)]; 792 st->cache_flush_status_desc_type = 793 HAL_GET_FIELD(REO_FLUSH_CACHE_STATUS_2, 794 CACHE_CONTROLLER_FLUSH_STATUS_DESC_TYPE, 795 val); 796 797 /* cache flush count */ 798 val = reo_desc[HAL_OFFSET_DW(REO_FLUSH_CACHE_STATUS_2, 799 CACHE_CONTROLLER_FLUSH_COUNT)]; 800 st->cache_flush_cnt = 801 HAL_GET_FIELD(REO_FLUSH_CACHE_STATUS_2, 802 CACHE_CONTROLLER_FLUSH_COUNT, 803 val); 804 805 } 806 qdf_export_symbol(hal_reo_flush_cache_status); 807 808 inline void hal_reo_unblock_cache_status(uint32_t *reo_desc, 809 struct hal_soc *soc, 810 struct hal_reo_unblk_cache_status *st) 811 { 812 uint32_t val; 813 814 /* Offsets of descriptor fields defined in HW headers start 815 * from the field after TLV header */ 816 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 817 818 /* header */ 819 HAL_REO_STATUS_GET_HEADER(reo_desc, REO_UNBLOCK_CACHE, st->header); 820 821 /* error bit */ 822 val = reo_desc[HAL_OFFSET_DW(REO_UNBLOCK_CACHE_STATUS_2, 823 ERROR_DETECTED)]; 824 st->error = HAL_GET_FIELD(REO_UNBLOCK_CACHE_STATUS_2, 825 ERROR_DETECTED, 826 val); 827 828 /* unblock type */ 829 val = reo_desc[HAL_OFFSET_DW(REO_UNBLOCK_CACHE_STATUS_2, 830 UNBLOCK_TYPE)]; 831 st->unblock_type = HAL_GET_FIELD(REO_UNBLOCK_CACHE_STATUS_2, 832 UNBLOCK_TYPE, 833 val); 834 835 if (!st->error && (st->unblock_type == UNBLOCK_RES_INDEX)) 836 qdf_clear_bit(soc->index, 837 (unsigned long *)&soc->reo_res_bitmap); 838 } 839 qdf_export_symbol(hal_reo_unblock_cache_status); 840 841 inline void hal_reo_flush_timeout_list_status( 842 uint32_t *reo_desc, 843 struct hal_reo_flush_timeout_list_status *st) 844 845 { 846 uint32_t val; 847 848 /* Offsets of descriptor fields defined in HW headers start 849 * from the field after TLV header */ 850 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 851 852 /* header */ 853 HAL_REO_STATUS_GET_HEADER(reo_desc, REO_FLUSH_TIMEOUT_LIST, st->header); 854 855 /* error bit */ 856 val = reo_desc[HAL_OFFSET_DW(REO_FLUSH_TIMEOUT_LIST_STATUS_2, 857 ERROR_DETECTED)]; 858 st->error = HAL_GET_FIELD(REO_FLUSH_TIMEOUT_LIST_STATUS_2, 859 ERROR_DETECTED, 860 val); 861 862 /* list empty */ 863 val = reo_desc[HAL_OFFSET_DW(REO_FLUSH_TIMEOUT_LIST_STATUS_2, 864 TIMOUT_LIST_EMPTY)]; 865 st->list_empty = HAL_GET_FIELD(REO_FLUSH_TIMEOUT_LIST_STATUS_2, 866 TIMOUT_LIST_EMPTY, 867 val); 868 869 /* release descriptor count */ 870 val = reo_desc[HAL_OFFSET_DW(REO_FLUSH_TIMEOUT_LIST_STATUS_3, 871 RELEASE_DESC_COUNT)]; 872 st->rel_desc_cnt = HAL_GET_FIELD(REO_FLUSH_TIMEOUT_LIST_STATUS_3, 873 RELEASE_DESC_COUNT, 874 val); 875 876 /* forward buf count */ 877 val = reo_desc[HAL_OFFSET_DW(REO_FLUSH_TIMEOUT_LIST_STATUS_3, 878 FORWARD_BUF_COUNT)]; 879 st->fwd_buf_cnt = HAL_GET_FIELD(REO_FLUSH_TIMEOUT_LIST_STATUS_3, 880 FORWARD_BUF_COUNT, 881 val); 882 } 883 qdf_export_symbol(hal_reo_flush_timeout_list_status); 884 885 inline void hal_reo_desc_thres_reached_status( 886 uint32_t *reo_desc, 887 struct hal_reo_desc_thres_reached_status *st) 888 { 889 uint32_t val; 890 891 /* Offsets of descriptor fields defined in HW headers start 892 * from the field after TLV header */ 893 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 894 895 /* header */ 896 HAL_REO_STATUS_GET_HEADER(reo_desc, 897 REO_DESCRIPTOR_THRESHOLD_REACHED, st->header); 898 899 /* threshold index */ 900 val = reo_desc[HAL_OFFSET_DW( 901 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_2, 902 THRESHOLD_INDEX)]; 903 st->thres_index = HAL_GET_FIELD( 904 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_2, 905 THRESHOLD_INDEX, 906 val); 907 908 /* link desc counters */ 909 val = reo_desc[HAL_OFFSET_DW( 910 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_3, 911 LINK_DESCRIPTOR_COUNTER0)]; 912 st->link_desc_counter0 = HAL_GET_FIELD( 913 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_3, 914 LINK_DESCRIPTOR_COUNTER0, 915 val); 916 917 val = reo_desc[HAL_OFFSET_DW( 918 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_4, 919 LINK_DESCRIPTOR_COUNTER1)]; 920 st->link_desc_counter1 = HAL_GET_FIELD( 921 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_4, 922 LINK_DESCRIPTOR_COUNTER1, 923 val); 924 925 val = reo_desc[HAL_OFFSET_DW( 926 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_5, 927 LINK_DESCRIPTOR_COUNTER2)]; 928 st->link_desc_counter2 = HAL_GET_FIELD( 929 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_5, 930 LINK_DESCRIPTOR_COUNTER2, 931 val); 932 933 val = reo_desc[HAL_OFFSET_DW( 934 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_6, 935 LINK_DESCRIPTOR_COUNTER_SUM)]; 936 st->link_desc_counter_sum = HAL_GET_FIELD( 937 REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_6, 938 LINK_DESCRIPTOR_COUNTER_SUM, 939 val); 940 } 941 qdf_export_symbol(hal_reo_desc_thres_reached_status); 942 943 inline void hal_reo_rx_update_queue_status(uint32_t *reo_desc, 944 struct hal_reo_update_rx_queue_status *st) 945 { 946 /* Offsets of descriptor fields defined in HW headers start 947 * from the field after TLV header */ 948 reo_desc += (sizeof(struct tlv_32_hdr) >> 2); 949 950 /* header */ 951 HAL_REO_STATUS_GET_HEADER(reo_desc, 952 REO_UPDATE_RX_REO_QUEUE, st->header); 953 } 954 qdf_export_symbol(hal_reo_rx_update_queue_status); 955 956 /** 957 * hal_reo_init_cmd_ring() - Initialize descriptors of REO command SRNG 958 * with command number 959 * @hal_soc: Handle to HAL SoC structure 960 * @hal_ring: Handle to HAL SRNG structure 961 * 962 * Return: none 963 */ 964 inline void hal_reo_init_cmd_ring(struct hal_soc *soc, void *hal_srng) 965 { 966 int cmd_num; 967 uint32_t *desc_addr; 968 struct hal_srng_params srng_params; 969 uint32_t desc_size; 970 uint32_t num_desc; 971 972 hal_get_srng_params(soc, hal_srng, &srng_params); 973 974 desc_addr = (uint32_t *)(srng_params.ring_base_vaddr); 975 desc_addr += (sizeof(struct tlv_32_hdr) >> 2); 976 desc_size = hal_srng_get_entrysize(soc, REO_CMD) >> 2; 977 num_desc = srng_params.num_entries; 978 cmd_num = 1; 979 while (num_desc) { 980 /* Offsets of descriptor fields defined in HW headers start 981 * from the field after TLV header */ 982 HAL_DESC_SET_FIELD(desc_addr, UNIFORM_REO_CMD_HEADER_0, 983 REO_CMD_NUMBER, cmd_num); 984 desc_addr += desc_size; 985 num_desc--; cmd_num++; 986 } 987 988 soc->reo_res_bitmap = 0; 989 } 990 qdf_export_symbol(hal_reo_init_cmd_ring); 991