1 /* 2 * Copyright (c) 2016-2020 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 #include "hal_hw_headers.h" 19 #include "hal_internal.h" 20 #include "hal_api.h" 21 #include "target_type.h" 22 #include "wcss_version.h" 23 #include "qdf_module.h" 24 #include "hal_flow.h" 25 #include "rx_flow_search_entry.h" 26 #include "hal_rx_flow_info.h" 27 28 #define UNIFIED_RXPCU_PPDU_END_INFO_8_RX_PPDU_DURATION_OFFSET \ 29 RXPCU_PPDU_END_INFO_8_RX_PPDU_DURATION_OFFSET 30 #define UNIFIED_RXPCU_PPDU_END_INFO_8_RX_PPDU_DURATION_MASK \ 31 RXPCU_PPDU_END_INFO_8_RX_PPDU_DURATION_MASK 32 #define UNIFIED_RXPCU_PPDU_END_INFO_8_RX_PPDU_DURATION_LSB \ 33 RXPCU_PPDU_END_INFO_8_RX_PPDU_DURATION_LSB 34 #define UNIFIED_PHYRX_HT_SIG_0_HT_SIG_INFO_PHYRX_HT_SIG_INFO_DETAILS_OFFSET \ 35 PHYRX_HT_SIG_0_HT_SIG_INFO_PHYRX_HT_SIG_INFO_DETAILS_OFFSET 36 #define UNIFIED_PHYRX_L_SIG_B_0_L_SIG_B_INFO_PHYRX_L_SIG_B_INFO_DETAILS_OFFSET \ 37 PHYRX_L_SIG_B_0_L_SIG_B_INFO_PHYRX_L_SIG_B_INFO_DETAILS_OFFSET 38 #define UNIFIED_PHYRX_L_SIG_A_0_L_SIG_A_INFO_PHYRX_L_SIG_A_INFO_DETAILS_OFFSET \ 39 PHYRX_L_SIG_A_0_L_SIG_A_INFO_PHYRX_L_SIG_A_INFO_DETAILS_OFFSET 40 #define UNIFIED_PHYRX_VHT_SIG_A_0_VHT_SIG_A_INFO_PHYRX_VHT_SIG_A_INFO_DETAILS_OFFSET \ 41 PHYRX_VHT_SIG_A_0_VHT_SIG_A_INFO_PHYRX_VHT_SIG_A_INFO_DETAILS_OFFSET 42 #define UNIFIED_PHYRX_HE_SIG_A_SU_0_HE_SIG_A_SU_INFO_PHYRX_HE_SIG_A_SU_INFO_DETAILS_OFFSET \ 43 PHYRX_HE_SIG_A_SU_0_HE_SIG_A_SU_INFO_PHYRX_HE_SIG_A_SU_INFO_DETAILS_OFFSET 44 #define UNIFIED_PHYRX_HE_SIG_A_MU_DL_0_HE_SIG_A_MU_DL_INFO_PHYRX_HE_SIG_A_MU_DL_INFO_DETAILS_OFFSET \ 45 PHYRX_HE_SIG_A_MU_DL_0_HE_SIG_A_MU_DL_INFO_PHYRX_HE_SIG_A_MU_DL_INFO_DETAILS_OFFSET 46 #define UNIFIED_PHYRX_HE_SIG_B1_MU_0_HE_SIG_B1_MU_INFO_PHYRX_HE_SIG_B1_MU_INFO_DETAILS_OFFSET \ 47 PHYRX_HE_SIG_B1_MU_0_HE_SIG_B1_MU_INFO_PHYRX_HE_SIG_B1_MU_INFO_DETAILS_OFFSET 48 #define UNIFIED_PHYRX_HE_SIG_B2_MU_0_HE_SIG_B2_MU_INFO_PHYRX_HE_SIG_B2_MU_INFO_DETAILS_OFFSET \ 49 PHYRX_HE_SIG_B2_MU_0_HE_SIG_B2_MU_INFO_PHYRX_HE_SIG_B2_MU_INFO_DETAILS_OFFSET 50 #define UNIFIED_PHYRX_HE_SIG_B2_OFDMA_0_HE_SIG_B2_OFDMA_INFO_PHYRX_HE_SIG_B2_OFDMA_INFO_DETAILS_OFFSET \ 51 PHYRX_HE_SIG_B2_OFDMA_0_HE_SIG_B2_OFDMA_INFO_PHYRX_HE_SIG_B2_OFDMA_INFO_DETAILS_OFFSET 52 #define UNIFIED_PHYRX_RSSI_LEGACY_3_RECEIVE_RSSI_INFO_PRE_RSSI_INFO_DETAILS_OFFSET \ 53 PHYRX_RSSI_LEGACY_3_RECEIVE_RSSI_INFO_PRE_RSSI_INFO_DETAILS_OFFSET 54 #define UNIFIED_PHYRX_RSSI_LEGACY_19_RECEIVE_RSSI_INFO_PREAMBLE_RSSI_INFO_DETAILS_OFFSET \ 55 PHYRX_RSSI_LEGACY_19_RECEIVE_RSSI_INFO_PREAMBLE_RSSI_INFO_DETAILS_OFFSET 56 #define UNIFIED_RX_MPDU_START_0_RX_MPDU_INFO_RX_MPDU_INFO_DETAILS_OFFSET \ 57 RX_MPDU_START_0_RX_MPDU_INFO_RX_MPDU_INFO_DETAILS_OFFSET 58 #define UNIFIED_RX_MSDU_LINK_8_RX_MSDU_DETAILS_MSDU_0_OFFSET \ 59 RX_MSDU_LINK_8_RX_MSDU_DETAILS_MSDU_0_OFFSET 60 #define UNIFIED_RX_MSDU_DETAILS_2_RX_MSDU_DESC_INFO_RX_MSDU_DESC_INFO_DETAILS_OFFSET \ 61 RX_MSDU_DETAILS_2_RX_MSDU_DESC_INFO_RX_MSDU_DESC_INFO_DETAILS_OFFSET 62 #define UNIFIED_RX_MPDU_DETAILS_2_RX_MPDU_DESC_INFO_RX_MPDU_DESC_INFO_DETAILS_OFFSET \ 63 RX_MPDU_DETAILS_2_RX_MPDU_DESC_INFO_RX_MPDU_DESC_INFO_DETAILS_OFFSET 64 #define UNIFIED_REO_DESTINATION_RING_2_RX_MPDU_DESC_INFO_RX_MPDU_DESC_INFO_DETAILS_OFFSET \ 65 REO_DESTINATION_RING_2_RX_MPDU_DESC_INFO_RX_MPDU_DESC_INFO_DETAILS_OFFSET 66 #define UNIFORM_REO_STATUS_HEADER_STATUS_HEADER_GENERIC \ 67 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER 68 #define UNIFIED_RX_MSDU_DETAILS_2_RX_MSDU_DESC_INFO_RX_MSDU_DESC_INFO_DETAILS_OFFSE \ 69 RX_MSDU_DETAILS_2_RX_MSDU_DESC_INFO_RX_MSDU_DESC_INFO_DETAILS_OFFSET 70 #define UNIFIED_RX_MSDU_LINK_8_RX_MSDU_DETAILS_MSDU_0_OFFSET \ 71 RX_MSDU_LINK_8_RX_MSDU_DETAILS_MSDU_0_OFFSET 72 #define UNIFIED_TCL_DATA_CMD_0_BUFFER_ADDR_INFO_BUF_ADDR_INFO_OFFSET \ 73 TCL_DATA_CMD_0_BUFFER_ADDR_INFO_BUF_ADDR_INFO_OFFSET 74 #define UNIFIED_TCL_DATA_CMD_1_BUFFER_ADDR_INFO_BUF_ADDR_INFO_OFFSET \ 75 TCL_DATA_CMD_1_BUFFER_ADDR_INFO_BUF_ADDR_INFO_OFFSET 76 #define UNIFIED_TCL_DATA_CMD_2_BUF_OR_EXT_DESC_TYPE_OFFSET \ 77 TCL_DATA_CMD_2_BUF_OR_EXT_DESC_TYPE_OFFSET 78 #define UNIFIED_BUFFER_ADDR_INFO_0_BUFFER_ADDR_31_0_LSB \ 79 BUFFER_ADDR_INFO_0_BUFFER_ADDR_31_0_LSB 80 #define UNIFIED_BUFFER_ADDR_INFO_0_BUFFER_ADDR_31_0_MASK \ 81 BUFFER_ADDR_INFO_0_BUFFER_ADDR_31_0_MASK 82 #define UNIFIED_BUFFER_ADDR_INFO_1_BUFFER_ADDR_39_32_LSB \ 83 BUFFER_ADDR_INFO_1_BUFFER_ADDR_39_32_LSB 84 #define UNIFIED_BUFFER_ADDR_INFO_1_BUFFER_ADDR_39_32_MASK \ 85 BUFFER_ADDR_INFO_1_BUFFER_ADDR_39_32_MASK 86 #define UNIFIED_BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_LSB \ 87 BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_LSB 88 #define UNIFIED_BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_MASK \ 89 BUFFER_ADDR_INFO_1_RETURN_BUFFER_MANAGER_MASK 90 #define UNIFIED_BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_LSB \ 91 BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_LSB 92 #define UNIFIED_BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_MASK \ 93 BUFFER_ADDR_INFO_1_SW_BUFFER_COOKIE_MASK 94 #define UNIFIED_TCL_DATA_CMD_2_BUF_OR_EXT_DESC_TYPE_LSB \ 95 TCL_DATA_CMD_2_BUF_OR_EXT_DESC_TYPE_LSB 96 #define UNIFIED_TCL_DATA_CMD_2_BUF_OR_EXT_DESC_TYPE_MASK \ 97 TCL_DATA_CMD_2_BUF_OR_EXT_DESC_TYPE_MASK 98 #define UNIFIED_WBM_RELEASE_RING_6_TX_RATE_STATS_INFO_TX_RATE_STATS_MASK \ 99 WBM_RELEASE_RING_6_TX_RATE_STATS_INFO_TX_RATE_STATS_MASK 100 #define UNIFIED_WBM_RELEASE_RING_6_TX_RATE_STATS_INFO_TX_RATE_STATS_OFFSET \ 101 WBM_RELEASE_RING_6_TX_RATE_STATS_INFO_TX_RATE_STATS_OFFSET 102 #define UNIFIED_WBM_RELEASE_RING_6_TX_RATE_STATS_INFO_TX_RATE_STATS_LSB \ 103 WBM_RELEASE_RING_6_TX_RATE_STATS_INFO_TX_RATE_STATS_LSB 104 105 #include "hal_8074v1_tx.h" 106 #include "hal_8074v1_rx.h" 107 #include <hal_generic_api.h> 108 #include <hal_wbm.h> 109 110 /** 111 * hal_get_window_address_8074(): Function to get hp/tp address 112 * @hal_soc: Pointer to hal_soc 113 * @addr: address offset of register 114 * 115 * Return: modified address offset of register 116 */ 117 static inline qdf_iomem_t hal_get_window_address_8074(struct hal_soc *hal_soc, 118 qdf_iomem_t addr) 119 { 120 return addr; 121 } 122 123 /** 124 * hal_rx_get_rx_fragment_number_8074v1(): Function to retrieve 125 * rx fragment number 126 * 127 * @nbuf: Network buffer 128 * Returns: rx fragment number 129 */ 130 static 131 uint8_t hal_rx_get_rx_fragment_number_8074v1(uint8_t *buf) 132 { 133 struct rx_pkt_tlvs *pkt_tlvs = hal_rx_get_pkt_tlvs(buf); 134 struct rx_mpdu_info *rx_mpdu_info = hal_rx_get_mpdu_info(pkt_tlvs); 135 136 /* Return first 4 bits as fragment number */ 137 return (HAL_RX_MPDU_GET_SEQUENCE_NUMBER(rx_mpdu_info) & 138 DOT11_SEQ_FRAG_MASK); 139 } 140 141 /** 142 * hal_rx_msdu_end_da_is_mcbc_get_8074v1(): API to check if 143 * pkt is MCBC from rx_msdu_end TLV 144 * 145 * @ buf: pointer to the start of RX PKT TLV headers 146 * Return: da_is_mcbc 147 */ 148 static uint8_t 149 hal_rx_msdu_end_da_is_mcbc_get_8074v1(uint8_t *buf) 150 { 151 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 152 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 153 154 return HAL_RX_MSDU_END_DA_IS_MCBC_GET(msdu_end); 155 } 156 157 /** 158 * hal_rx_msdu_end_sa_is_valid_get_8074v1(): API to get_8074v1 the 159 * sa_is_valid bit from rx_msdu_end TLV 160 * 161 * @ buf: pointer to the start of RX PKT TLV headers 162 * Return: sa_is_valid bit 163 */ 164 static uint8_t 165 hal_rx_msdu_end_sa_is_valid_get_8074v1(uint8_t *buf) 166 { 167 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 168 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 169 uint8_t sa_is_valid; 170 171 sa_is_valid = HAL_RX_MSDU_END_SA_IS_VALID_GET(msdu_end); 172 173 return sa_is_valid; 174 } 175 176 /** 177 * hal_rx_msdu_end_sa_idx_get_8074v1(): API to get_8074v1 the 178 * sa_idx from rx_msdu_end TLV 179 * 180 * @ buf: pointer to the start of RX PKT TLV headers 181 * Return: sa_idx (SA AST index) 182 */ 183 static uint16_t hal_rx_msdu_end_sa_idx_get_8074v1(uint8_t *buf) 184 { 185 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 186 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 187 uint16_t sa_idx; 188 189 sa_idx = HAL_RX_MSDU_END_SA_IDX_GET(msdu_end); 190 191 return sa_idx; 192 } 193 194 /** 195 * hal_rx_desc_is_first_msdu_8074v1() - Check if first msdu 196 * 197 * @hal_soc_hdl: hal_soc handle 198 * @hw_desc_addr: hardware descriptor address 199 * 200 * Return: 0 - success/ non-zero failure 201 */ 202 static uint32_t hal_rx_desc_is_first_msdu_8074v1(void *hw_desc_addr) 203 { 204 struct rx_pkt_tlvs *rx_tlvs = (struct rx_pkt_tlvs *)hw_desc_addr; 205 struct rx_msdu_end *msdu_end = &rx_tlvs->msdu_end_tlv.rx_msdu_end; 206 207 return HAL_RX_GET(msdu_end, RX_MSDU_END_5, FIRST_MSDU); 208 } 209 210 /** 211 * hal_rx_msdu_end_l3_hdr_padding_get_8074v1(): API to get_8074v1 the 212 * l3_header padding from rx_msdu_end TLV 213 * 214 * @ buf: pointer to the start of RX PKT TLV headers 215 * Return: number of l3 header padding bytes 216 */ 217 static uint32_t hal_rx_msdu_end_l3_hdr_padding_get_8074v1(uint8_t *buf) 218 { 219 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 220 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 221 uint32_t l3_header_padding; 222 223 l3_header_padding = HAL_RX_MSDU_END_L3_HEADER_PADDING_GET(msdu_end); 224 225 return l3_header_padding; 226 } 227 228 /* 229 * @ hal_rx_encryption_info_valid_8074v1: Returns encryption type. 230 * 231 * @ buf: rx_tlv_hdr of the received packet 232 * @ Return: encryption type 233 */ 234 static uint32_t hal_rx_encryption_info_valid_8074v1(uint8_t *buf) 235 { 236 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 237 struct rx_mpdu_start *mpdu_start = 238 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 239 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 240 uint32_t encryption_info = HAL_RX_MPDU_ENCRYPTION_INFO_VALID(mpdu_info); 241 242 return encryption_info; 243 } 244 245 /* 246 * @ hal_rx_print_pn_8074v1: Prints the PN of rx packet. 247 * 248 * @ buf: rx_tlv_hdr of the received packet 249 * @ Return: void 250 */ 251 static void hal_rx_print_pn_8074v1(uint8_t *buf) 252 { 253 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 254 struct rx_mpdu_start *mpdu_start = 255 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 256 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 257 258 uint32_t pn_31_0 = HAL_RX_MPDU_PN_31_0_GET(mpdu_info); 259 uint32_t pn_63_32 = HAL_RX_MPDU_PN_63_32_GET(mpdu_info); 260 uint32_t pn_95_64 = HAL_RX_MPDU_PN_95_64_GET(mpdu_info); 261 uint32_t pn_127_96 = HAL_RX_MPDU_PN_127_96_GET(mpdu_info); 262 263 hal_debug("PN number pn_127_96 0x%x pn_95_64 0x%x pn_63_32 0x%x pn_31_0 0x%x ", 264 pn_127_96, pn_95_64, pn_63_32, pn_31_0); 265 } 266 267 /** 268 * hal_rx_msdu_end_first_msdu_get_8074v1: API to get first msdu status 269 * from rx_msdu_end TLV 270 * 271 * @ buf: pointer to the start of RX PKT TLV headers 272 * Return: first_msdu 273 */ 274 static uint8_t 275 hal_rx_msdu_end_first_msdu_get_8074v1(uint8_t *buf) 276 { 277 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 278 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 279 uint8_t first_msdu; 280 281 first_msdu = HAL_RX_MSDU_END_FIRST_MSDU_GET(msdu_end); 282 283 return first_msdu; 284 } 285 286 /** 287 * hal_rx_msdu_end_da_is_valid_get_8074v1: API to check if da is valid 288 * from rx_msdu_end TLV 289 * 290 * @ buf: pointer to the start of RX PKT TLV headers 291 * Return: da_is_valid 292 */ 293 static uint8_t hal_rx_msdu_end_da_is_valid_get_8074v1(uint8_t *buf) 294 { 295 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 296 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 297 uint8_t da_is_valid; 298 299 da_is_valid = HAL_RX_MSDU_END_DA_IS_VALID_GET(msdu_end); 300 301 return da_is_valid; 302 } 303 304 /** 305 * hal_rx_msdu_end_last_msdu_get_8074v1: API to get last msdu status 306 * from rx_msdu_end TLV 307 * 308 * @ buf: pointer to the start of RX PKT TLV headers 309 * Return: last_msdu 310 */ 311 static uint8_t hal_rx_msdu_end_last_msdu_get_8074v1(uint8_t *buf) 312 { 313 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 314 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 315 uint8_t last_msdu; 316 317 last_msdu = HAL_RX_MSDU_END_LAST_MSDU_GET(msdu_end); 318 319 return last_msdu; 320 } 321 322 /* 323 * hal_rx_get_mpdu_mac_ad4_valid_8074v1(): Retrieves if mpdu 4th addr is valid 324 * 325 * @nbuf: Network buffer 326 * Returns: value of mpdu 4th address valid field 327 */ 328 static bool hal_rx_get_mpdu_mac_ad4_valid_8074v1(uint8_t *buf) 329 { 330 struct rx_pkt_tlvs *pkt_tlvs = hal_rx_get_pkt_tlvs(buf); 331 struct rx_mpdu_info *rx_mpdu_info = hal_rx_get_mpdu_info(pkt_tlvs); 332 bool ad4_valid = 0; 333 334 ad4_valid = HAL_RX_MPDU_GET_MAC_AD4_VALID(rx_mpdu_info); 335 336 return ad4_valid; 337 } 338 339 /** 340 * hal_rx_mpdu_start_sw_peer_id_get_8074v1: Retrieve sw peer_id 341 * @buf: network buffer 342 * 343 * Return: sw peer_id 344 */ 345 static uint32_t hal_rx_mpdu_start_sw_peer_id_get_8074v1(uint8_t *buf) 346 { 347 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 348 struct rx_mpdu_start *mpdu_start = 349 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 350 351 return HAL_RX_MPDU_INFO_SW_PEER_ID_GET( 352 &mpdu_start->rx_mpdu_info_details); 353 } 354 355 /* 356 * hal_rx_mpdu_get_to_ds_8074v1(): API to get the tods info 357 * from rx_mpdu_start 358 * 359 * @buf: pointer to the start of RX PKT TLV header 360 * Return: uint32_t(to_ds) 361 */ 362 363 static uint32_t hal_rx_mpdu_get_to_ds_8074v1(uint8_t *buf) 364 { 365 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 366 struct rx_mpdu_start *mpdu_start = 367 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 368 369 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 370 371 return HAL_RX_MPDU_GET_TODS(mpdu_info); 372 } 373 374 /* 375 * hal_rx_mpdu_get_fr_ds_8074v1(): API to get the from ds info 376 * from rx_mpdu_start 377 * 378 * @buf: pointer to the start of RX PKT TLV header 379 * Return: uint32_t(fr_ds) 380 */ 381 static uint32_t hal_rx_mpdu_get_fr_ds_8074v1(uint8_t *buf) 382 { 383 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 384 struct rx_mpdu_start *mpdu_start = 385 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 386 387 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 388 389 return HAL_RX_MPDU_GET_FROMDS(mpdu_info); 390 } 391 392 /* 393 * hal_rx_get_mpdu_frame_control_valid_8074v1(): Retrieves mpdu 394 * frame control valid 395 * 396 * @nbuf: Network buffer 397 * Returns: value of frame control valid field 398 */ 399 static uint8_t hal_rx_get_mpdu_frame_control_valid_8074v1(uint8_t *buf) 400 { 401 struct rx_pkt_tlvs *pkt_tlvs = hal_rx_get_pkt_tlvs(buf); 402 struct rx_mpdu_info *rx_mpdu_info = hal_rx_get_mpdu_info(pkt_tlvs); 403 404 return HAL_RX_MPDU_GET_FRAME_CONTROL_VALID(rx_mpdu_info); 405 } 406 407 /* 408 * hal_rx_mpdu_get_addr1_8074v1(): API to check get address1 of the mpdu 409 * 410 * @buf: pointer to the start of RX PKT TLV headera 411 * @mac_addr: pointer to mac address 412 * Return: success/failure 413 */ 414 static QDF_STATUS hal_rx_mpdu_get_addr1_8074v1(uint8_t *buf, 415 uint8_t *mac_addr) 416 { 417 struct __attribute__((__packed__)) hal_addr1 { 418 uint32_t ad1_31_0; 419 uint16_t ad1_47_32; 420 }; 421 422 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 423 struct rx_mpdu_start *mpdu_start = 424 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 425 426 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 427 struct hal_addr1 *addr = (struct hal_addr1 *)mac_addr; 428 uint32_t mac_addr_ad1_valid; 429 430 mac_addr_ad1_valid = HAL_RX_MPDU_MAC_ADDR_AD1_VALID_GET(mpdu_info); 431 432 if (mac_addr_ad1_valid) { 433 addr->ad1_31_0 = HAL_RX_MPDU_AD1_31_0_GET(mpdu_info); 434 addr->ad1_47_32 = HAL_RX_MPDU_AD1_47_32_GET(mpdu_info); 435 return QDF_STATUS_SUCCESS; 436 } 437 438 return QDF_STATUS_E_FAILURE; 439 } 440 441 /* 442 * hal_rx_mpdu_get_addr2_8074v1(): API to check get address2 of the mpdu 443 * in the packet 444 * 445 * @buf: pointer to the start of RX PKT TLV header 446 * @mac_addr: pointer to mac address 447 * Return: success/failure 448 */ 449 static QDF_STATUS hal_rx_mpdu_get_addr2_8074v1(uint8_t *buf, uint8_t *mac_addr) 450 { 451 struct __attribute__((__packed__)) hal_addr2 { 452 uint16_t ad2_15_0; 453 uint32_t ad2_47_16; 454 }; 455 456 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 457 struct rx_mpdu_start *mpdu_start = 458 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 459 460 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 461 struct hal_addr2 *addr = (struct hal_addr2 *)mac_addr; 462 uint32_t mac_addr_ad2_valid; 463 464 mac_addr_ad2_valid = HAL_RX_MPDU_MAC_ADDR_AD2_VALID_GET(mpdu_info); 465 466 if (mac_addr_ad2_valid) { 467 addr->ad2_15_0 = HAL_RX_MPDU_AD2_15_0_GET(mpdu_info); 468 addr->ad2_47_16 = HAL_RX_MPDU_AD2_47_16_GET(mpdu_info); 469 return QDF_STATUS_SUCCESS; 470 } 471 472 return QDF_STATUS_E_FAILURE; 473 } 474 475 /* 476 * hal_rx_mpdu_get_addr3_8074v1(): API to get address3 of the mpdu 477 * in the packet 478 * 479 * @buf: pointer to the start of RX PKT TLV header 480 * @mac_addr: pointer to mac address 481 * Return: success/failure 482 */ 483 static QDF_STATUS hal_rx_mpdu_get_addr3_8074v1(uint8_t *buf, uint8_t *mac_addr) 484 { 485 struct __attribute__((__packed__)) hal_addr3 { 486 uint32_t ad3_31_0; 487 uint16_t ad3_47_32; 488 }; 489 490 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 491 struct rx_mpdu_start *mpdu_start = 492 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 493 494 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 495 struct hal_addr3 *addr = (struct hal_addr3 *)mac_addr; 496 uint32_t mac_addr_ad3_valid; 497 498 mac_addr_ad3_valid = HAL_RX_MPDU_MAC_ADDR_AD3_VALID_GET(mpdu_info); 499 500 if (mac_addr_ad3_valid) { 501 addr->ad3_31_0 = HAL_RX_MPDU_AD3_31_0_GET(mpdu_info); 502 addr->ad3_47_32 = HAL_RX_MPDU_AD3_47_32_GET(mpdu_info); 503 return QDF_STATUS_SUCCESS; 504 } 505 506 return QDF_STATUS_E_FAILURE; 507 } 508 509 /* 510 * hal_rx_mpdu_get_addr4_8074v1(): API to get address4 of the mpdu 511 * in the packet 512 * 513 * @buf: pointer to the start of RX PKT TLV header 514 * @mac_addr: pointer to mac address 515 * Return: success/failure 516 */ 517 static QDF_STATUS hal_rx_mpdu_get_addr4_8074v1(uint8_t *buf, uint8_t *mac_addr) 518 { 519 struct __attribute__((__packed__)) hal_addr4 { 520 uint32_t ad4_31_0; 521 uint16_t ad4_47_32; 522 }; 523 524 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 525 struct rx_mpdu_start *mpdu_start = 526 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 527 528 struct rx_mpdu_info *mpdu_info = &mpdu_start->rx_mpdu_info_details; 529 struct hal_addr4 *addr = (struct hal_addr4 *)mac_addr; 530 uint32_t mac_addr_ad4_valid; 531 532 mac_addr_ad4_valid = HAL_RX_MPDU_MAC_ADDR_AD4_VALID_GET(mpdu_info); 533 534 if (mac_addr_ad4_valid) { 535 addr->ad4_31_0 = HAL_RX_MPDU_AD4_31_0_GET(mpdu_info); 536 addr->ad4_47_32 = HAL_RX_MPDU_AD4_47_32_GET(mpdu_info); 537 return QDF_STATUS_SUCCESS; 538 } 539 540 return QDF_STATUS_E_FAILURE; 541 } 542 543 /* 544 * hal_rx_get_mpdu_sequence_control_valid_8074v1(): Get mpdu 545 * sequence control valid 546 * 547 * @nbuf: Network buffer 548 * Returns: value of sequence control valid field 549 */ 550 static uint8_t hal_rx_get_mpdu_sequence_control_valid_8074v1(uint8_t *buf) 551 { 552 struct rx_pkt_tlvs *pkt_tlvs = hal_rx_get_pkt_tlvs(buf); 553 struct rx_mpdu_info *rx_mpdu_info = hal_rx_get_mpdu_info(pkt_tlvs); 554 555 return HAL_RX_MPDU_GET_SEQUENCE_CONTROL_VALID(rx_mpdu_info); 556 } 557 558 /** 559 * hal_rx_is_unicast_8074v1: check packet is unicast frame or not. 560 * 561 * @ buf: pointer to rx pkt TLV. 562 * 563 * Return: true on unicast. 564 */ 565 static bool hal_rx_is_unicast_8074v1(uint8_t *buf) 566 { 567 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 568 struct rx_mpdu_start *mpdu_start = 569 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 570 uint32_t grp_id; 571 uint8_t *rx_mpdu_info = (uint8_t *)&mpdu_start->rx_mpdu_info_details; 572 573 grp_id = (_HAL_MS((*_OFFSET_TO_WORD_PTR((rx_mpdu_info), 574 RX_MPDU_INFO_0_SW_FRAME_GROUP_ID_OFFSET)), 575 RX_MPDU_INFO_0_SW_FRAME_GROUP_ID_MASK, 576 RX_MPDU_INFO_0_SW_FRAME_GROUP_ID_LSB)); 577 578 return (HAL_MPDU_SW_FRAME_GROUP_UNICAST_DATA == grp_id) ? true : false; 579 } 580 581 /** 582 * hal_rx_tid_get_8074v1: get tid based on qos control valid. 583 * 584 * @ buf: pointer to rx pkt TLV. 585 * 586 * Return: tid 587 */ 588 static uint32_t hal_rx_tid_get_8074v1(hal_soc_handle_t hal_soc_hdl, 589 uint8_t *buf) 590 { 591 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 592 struct rx_mpdu_start *mpdu_start = 593 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 594 uint8_t *rx_mpdu_info = (uint8_t *)&mpdu_start->rx_mpdu_info_details; 595 uint8_t qos_control_valid = 596 (_HAL_MS((*_OFFSET_TO_WORD_PTR((rx_mpdu_info), 597 RX_MPDU_INFO_2_MPDU_QOS_CONTROL_VALID_OFFSET)), 598 RX_MPDU_INFO_2_MPDU_QOS_CONTROL_VALID_MASK, 599 RX_MPDU_INFO_2_MPDU_QOS_CONTROL_VALID_LSB)); 600 601 if (qos_control_valid) 602 return hal_rx_mpdu_start_tid_get_8074(buf); 603 604 return HAL_RX_NON_QOS_TID; 605 } 606 607 /** 608 * hal_rx_hw_desc_get_ppduid_get_8074v1(): retrieve ppdu id 609 * @rx_tlv_hdr: Rx tlv header 610 * @rxdma_dst_ring_desc: Rx HW descriptor 611 * 612 * Return: ppdu id 613 */ 614 static uint32_t hal_rx_hw_desc_get_ppduid_get_8074v1(void *rx_tlv_hdr, 615 void *rxdma_dst_ring_desc) 616 { 617 struct rx_mpdu_info *rx_mpdu_info; 618 struct rx_pkt_tlvs *rx_desc = (struct rx_pkt_tlvs *)rx_tlv_hdr; 619 620 rx_mpdu_info = 621 &rx_desc->mpdu_start_tlv.rx_mpdu_start.rx_mpdu_info_details; 622 623 return HAL_RX_GET(rx_mpdu_info, RX_MPDU_INFO_0, PHY_PPDU_ID); 624 } 625 626 /** 627 * hal_reo_status_get_header_8074v1 - Process reo desc info 628 * @d - Pointer to reo descriptior 629 * @b - tlv type info 630 * @h1 - Pointer to hal_reo_status_header where info to be stored 631 * 632 * Return - none. 633 * 634 */ 635 static void hal_reo_status_get_header_8074v1(uint32_t *d, int b, void *h1) 636 { 637 uint32_t val1 = 0; 638 struct hal_reo_status_header *h = 639 (struct hal_reo_status_header *)h1; 640 641 switch (b) { 642 case HAL_REO_QUEUE_STATS_STATUS_TLV: 643 val1 = d[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_0, 644 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER)]; 645 break; 646 case HAL_REO_FLUSH_QUEUE_STATUS_TLV: 647 val1 = d[HAL_OFFSET_DW(REO_FLUSH_QUEUE_STATUS_0, 648 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER)]; 649 break; 650 case HAL_REO_FLUSH_CACHE_STATUS_TLV: 651 val1 = d[HAL_OFFSET_DW(REO_FLUSH_CACHE_STATUS_0, 652 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER)]; 653 break; 654 case HAL_REO_UNBLK_CACHE_STATUS_TLV: 655 val1 = d[HAL_OFFSET_DW(REO_UNBLOCK_CACHE_STATUS_0, 656 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER)]; 657 break; 658 case HAL_REO_TIMOUT_LIST_STATUS_TLV: 659 val1 = d[HAL_OFFSET_DW(REO_FLUSH_TIMEOUT_LIST_STATUS_0, 660 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER)]; 661 break; 662 case HAL_REO_DESC_THRES_STATUS_TLV: 663 val1 = 664 d[HAL_OFFSET_DW(REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_0, 665 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER)]; 666 break; 667 case HAL_REO_UPDATE_RX_QUEUE_STATUS_TLV: 668 val1 = d[HAL_OFFSET_DW(REO_UPDATE_RX_REO_QUEUE_STATUS_0, 669 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER)]; 670 break; 671 default: 672 qdf_nofl_err("ERROR: Unknown tlv\n"); 673 break; 674 } 675 h->cmd_num = 676 HAL_GET_FIELD( 677 UNIFORM_REO_STATUS_HEADER_0, REO_STATUS_NUMBER, 678 val1); 679 h->exec_time = 680 HAL_GET_FIELD(UNIFORM_REO_STATUS_HEADER_0, 681 CMD_EXECUTION_TIME, val1); 682 h->status = 683 HAL_GET_FIELD(UNIFORM_REO_STATUS_HEADER_0, 684 REO_CMD_EXECUTION_STATUS, val1); 685 switch (b) { 686 case HAL_REO_QUEUE_STATS_STATUS_TLV: 687 val1 = d[HAL_OFFSET_DW(REO_GET_QUEUE_STATS_STATUS_1, 688 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER_GENERIC)]; 689 break; 690 case HAL_REO_FLUSH_QUEUE_STATUS_TLV: 691 val1 = d[HAL_OFFSET_DW(REO_FLUSH_QUEUE_STATUS_1, 692 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER_GENERIC)]; 693 break; 694 case HAL_REO_FLUSH_CACHE_STATUS_TLV: 695 val1 = d[HAL_OFFSET_DW(REO_FLUSH_CACHE_STATUS_1, 696 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER_GENERIC)]; 697 break; 698 case HAL_REO_UNBLK_CACHE_STATUS_TLV: 699 val1 = d[HAL_OFFSET_DW(REO_UNBLOCK_CACHE_STATUS_1, 700 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER_GENERIC)]; 701 break; 702 case HAL_REO_TIMOUT_LIST_STATUS_TLV: 703 val1 = d[HAL_OFFSET_DW(REO_FLUSH_TIMEOUT_LIST_STATUS_1, 704 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER_GENERIC)]; 705 break; 706 case HAL_REO_DESC_THRES_STATUS_TLV: 707 val1 = 708 d[HAL_OFFSET_DW(REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS_1, 709 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER_GENERIC)]; 710 break; 711 case HAL_REO_UPDATE_RX_QUEUE_STATUS_TLV: 712 val1 = d[HAL_OFFSET_DW(REO_UPDATE_RX_REO_QUEUE_STATUS_1, 713 UNIFORM_REO_STATUS_HEADER_STATUS_HEADER_GENERIC)]; 714 break; 715 default: 716 qdf_nofl_err("ERROR: Unknown tlv\n"); 717 break; 718 } 719 h->tstamp = 720 HAL_GET_FIELD(UNIFORM_REO_STATUS_HEADER_1, TIMESTAMP, val1); 721 } 722 723 /** 724 * hal_rx_mpdu_start_mpdu_qos_control_valid_get_8074v1(): 725 * Retrieve qos control valid bit from the tlv. 726 * @buf: pointer to rx pkt TLV. 727 * 728 * Return: qos control value. 729 */ 730 static inline uint32_t 731 hal_rx_mpdu_start_mpdu_qos_control_valid_get_8074v1(uint8_t *buf) 732 { 733 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 734 struct rx_mpdu_start *mpdu_start = 735 &pkt_tlvs->mpdu_start_tlv.rx_mpdu_start; 736 737 return HAL_RX_MPDU_INFO_QOS_CONTROL_VALID_GET( 738 &mpdu_start->rx_mpdu_info_details); 739 } 740 741 /** 742 * hal_rx_msdu_end_sa_sw_peer_id_get_8074v1(): API to get the 743 * sa_sw_peer_id from rx_msdu_end TLV 744 * @buf: pointer to the start of RX PKT TLV headers 745 * 746 * Return: sa_sw_peer_id index 747 */ 748 static inline uint32_t 749 hal_rx_msdu_end_sa_sw_peer_id_get_8074v1(uint8_t *buf) 750 { 751 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 752 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 753 754 return HAL_RX_MSDU_END_SA_SW_PEER_ID_GET(msdu_end); 755 } 756 757 /** 758 * hal_tx_desc_set_mesh_en_8074v1 - Set mesh_enable flag in Tx descriptor 759 * @desc: Handle to Tx Descriptor 760 * @en: For raw WiFi frames, this indicates transmission to a mesh STA, 761 * enabling the interpretation of the 'Mesh Control Present' bit 762 * (bit 8) of QoS Control (otherwise this bit is ignored), 763 * For native WiFi frames, this indicates that a 'Mesh Control' field 764 * is present between the header and the LLC. 765 * 766 * Return: void 767 */ 768 static inline 769 void hal_tx_desc_set_mesh_en_8074v1(void *desc, uint8_t en) 770 { 771 HAL_SET_FLD(desc, TCL_DATA_CMD_4, MESH_ENABLE) |= 772 HAL_TX_SM(TCL_DATA_CMD_4, MESH_ENABLE, en); 773 } 774 775 static 776 void *hal_rx_msdu0_buffer_addr_lsb_8074v1(void *link_desc_va) 777 { 778 return (void *)HAL_RX_MSDU0_BUFFER_ADDR_LSB(link_desc_va); 779 } 780 781 static 782 void *hal_rx_msdu_desc_info_ptr_get_8074v1(void *msdu0) 783 { 784 return (void *)HAL_RX_MSDU_DESC_INFO_PTR_GET(msdu0); 785 } 786 787 static 788 void *hal_ent_mpdu_desc_info_8074v1(void *ent_ring_desc) 789 { 790 return (void *)HAL_ENT_MPDU_DESC_INFO(ent_ring_desc); 791 } 792 793 static 794 void *hal_dst_mpdu_desc_info_8074v1(void *dst_ring_desc) 795 { 796 return (void *)HAL_DST_MPDU_DESC_INFO(dst_ring_desc); 797 } 798 799 static 800 uint8_t hal_rx_get_fc_valid_8074v1(uint8_t *buf) 801 { 802 return HAL_RX_GET_FC_VALID(buf); 803 } 804 805 static uint8_t hal_rx_get_to_ds_flag_8074v1(uint8_t *buf) 806 { 807 return HAL_RX_GET_TO_DS_FLAG(buf); 808 } 809 810 static uint8_t hal_rx_get_mac_addr2_valid_8074v1(uint8_t *buf) 811 { 812 return HAL_RX_GET_MAC_ADDR2_VALID(buf); 813 } 814 815 static uint8_t hal_rx_get_filter_category_8074v1(uint8_t *buf) 816 { 817 return HAL_RX_GET_FILTER_CATEGORY(buf); 818 } 819 820 static uint32_t 821 hal_rx_get_ppdu_id_8074v1(uint8_t *buf) 822 { 823 struct rx_mpdu_info *rx_mpdu_info; 824 struct rx_pkt_tlvs *rx_desc = (struct rx_pkt_tlvs *)buf; 825 826 rx_mpdu_info = 827 &rx_desc->mpdu_start_tlv.rx_mpdu_start.rx_mpdu_info_details; 828 829 return HAL_RX_GET_PPDU_ID(rx_mpdu_info); 830 } 831 832 /** 833 * hal_reo_config_8074v1(): Set reo config parameters 834 * @soc: hal soc handle 835 * @reg_val: value to be set 836 * @reo_params: reo parameters 837 * 838 * Return: void 839 */ 840 static void 841 hal_reo_config_8074v1(struct hal_soc *soc, 842 uint32_t reg_val, 843 struct hal_reo_params *reo_params) 844 { 845 HAL_REO_R0_CONFIG(soc, reg_val, reo_params); 846 } 847 848 /** 849 * hal_rx_msdu_desc_info_get_ptr_8074v1() - Get msdu desc info ptr 850 * @msdu_details_ptr - Pointer to msdu_details_ptr 851 * 852 * Return - Pointer to rx_msdu_desc_info structure. 853 * 854 */ 855 static void *hal_rx_msdu_desc_info_get_ptr_8074v1(void *msdu_details_ptr) 856 { 857 return HAL_RX_MSDU_DESC_INFO_GET(msdu_details_ptr); 858 } 859 860 /** 861 * hal_rx_link_desc_msdu0_ptr_8074v1 - Get pointer to rx_msdu details 862 * @link_desc - Pointer to link desc 863 * 864 * Return - Pointer to rx_msdu_details structure 865 * 866 */ 867 static void *hal_rx_link_desc_msdu0_ptr_8074v1(void *link_desc) 868 { 869 return HAL_RX_LINK_DESC_MSDU0_PTR(link_desc); 870 } 871 872 /** 873 * hal_rx_msdu_flow_idx_get_8074v1: API to get flow index 874 * from rx_msdu_end TLV 875 * @buf: pointer to the start of RX PKT TLV headers 876 * 877 * Return: flow index value from MSDU END TLV 878 */ 879 static inline uint32_t hal_rx_msdu_flow_idx_get_8074v1(uint8_t *buf) 880 { 881 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 882 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 883 884 return HAL_RX_MSDU_END_FLOW_IDX_GET(msdu_end); 885 } 886 887 /** 888 * hal_rx_msdu_flow_idx_invalid_8074v1: API to get flow index invalid 889 * from rx_msdu_end TLV 890 * @buf: pointer to the start of RX PKT TLV headers 891 * 892 * Return: flow index invalid value from MSDU END TLV 893 */ 894 static bool hal_rx_msdu_flow_idx_invalid_8074v1(uint8_t *buf) 895 { 896 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 897 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 898 899 return HAL_RX_MSDU_END_FLOW_IDX_INVALID_GET(msdu_end); 900 } 901 902 /** 903 * hal_rx_msdu_flow_idx_timeout_8074v1: API to get flow index timeout 904 * from rx_msdu_end TLV 905 * @buf: pointer to the start of RX PKT TLV headers 906 * 907 * Return: flow index timeout value from MSDU END TLV 908 */ 909 static bool hal_rx_msdu_flow_idx_timeout_8074v1(uint8_t *buf) 910 { 911 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 912 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 913 914 return HAL_RX_MSDU_END_FLOW_IDX_TIMEOUT_GET(msdu_end); 915 } 916 917 /** 918 * hal_rx_msdu_fse_metadata_get_8074v1: API to get FSE metadata 919 * from rx_msdu_end TLV 920 * @buf: pointer to the start of RX PKT TLV headers 921 * 922 * Return: fse metadata value from MSDU END TLV 923 */ 924 static uint32_t hal_rx_msdu_fse_metadata_get_8074v1(uint8_t *buf) 925 { 926 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 927 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 928 929 return HAL_RX_MSDU_END_FSE_METADATA_GET(msdu_end); 930 } 931 932 /** 933 * hal_rx_msdu_cce_metadata_get_8074v1: API to get CCE metadata 934 * from rx_msdu_end TLV 935 * @buf: pointer to the start of RX PKT TLV headers 936 * 937 * Return: cce_metadata 938 */ 939 static uint16_t 940 hal_rx_msdu_cce_metadata_get_8074v1(uint8_t *buf) 941 { 942 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 943 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 944 945 return HAL_RX_MSDU_END_CCE_METADATA_GET(msdu_end); 946 } 947 948 /** 949 * hal_rx_msdu_get_flow_params_8074v1: API to get flow index, flow index invalid 950 * and flow index timeout from rx_msdu_end TLV 951 * @buf: pointer to the start of RX PKT TLV headers 952 * @flow_invalid: pointer to return value of flow_idx_valid 953 * @flow_timeout: pointer to return value of flow_idx_timeout 954 * @flow_index: pointer to return value of flow_idx 955 * 956 * Return: none 957 */ 958 static inline void 959 hal_rx_msdu_get_flow_params_8074v1(uint8_t *buf, 960 bool *flow_invalid, 961 bool *flow_timeout, 962 uint32_t *flow_index) 963 { 964 struct rx_pkt_tlvs *pkt_tlvs = (struct rx_pkt_tlvs *)buf; 965 struct rx_msdu_end *msdu_end = &pkt_tlvs->msdu_end_tlv.rx_msdu_end; 966 967 *flow_invalid = HAL_RX_MSDU_END_FLOW_IDX_INVALID_GET(msdu_end); 968 *flow_timeout = HAL_RX_MSDU_END_FLOW_IDX_TIMEOUT_GET(msdu_end); 969 *flow_index = HAL_RX_MSDU_END_FLOW_IDX_GET(msdu_end); 970 } 971 972 /** 973 * hal_rx_tlv_get_tcp_chksum_8074v1() - API to get tcp checksum 974 * @buf: rx_tlv_hdr 975 * 976 * Return: tcp checksum 977 */ 978 static uint16_t 979 hal_rx_tlv_get_tcp_chksum_8074v1(uint8_t *buf) 980 { 981 return HAL_RX_TLV_GET_TCP_CHKSUM(buf); 982 } 983 984 /** 985 * hal_rx_get_rx_sequence_8074v1(): Function to retrieve rx sequence number 986 * 987 * @nbuf: Network buffer 988 * Returns: rx sequence number 989 */ 990 static 991 uint16_t hal_rx_get_rx_sequence_8074v1(uint8_t *buf) 992 { 993 struct rx_pkt_tlvs *pkt_tlvs = hal_rx_get_pkt_tlvs(buf); 994 struct rx_mpdu_info *rx_mpdu_info = hal_rx_get_mpdu_info(pkt_tlvs); 995 996 return HAL_RX_MPDU_GET_SEQUENCE_NUMBER(rx_mpdu_info); 997 } 998 999 /** 1000 * hal_rx_mpdu_start_tlv_tag_valid_8074v1 () - API to check if RX_MPDU_START 1001 * tlv tag is valid 1002 * 1003 * @rx_tlv_hdr: start address of rx_pkt_tlvs 1004 * 1005 * Return: true if RX_MPDU_START is valied, else false. 1006 */ 1007 uint8_t hal_rx_mpdu_start_tlv_tag_valid_8074v1(void *rx_tlv_hdr) 1008 { 1009 struct rx_pkt_tlvs *rx_desc = (struct rx_pkt_tlvs *)rx_tlv_hdr; 1010 uint32_t tlv_tag; 1011 1012 tlv_tag = HAL_RX_GET_USER_TLV32_TYPE( 1013 &rx_desc->mpdu_start_tlv); 1014 1015 return tlv_tag == WIFIRX_MPDU_START_E ? true : false; 1016 } 1017 1018 /** 1019 * hal_rx_flow_setup_fse_8074v1() - Setup a flow search entry in HW FST 1020 * @fst: Pointer to the Rx Flow Search Table 1021 * @table_offset: offset into the table where the flow is to be setup 1022 * @flow: Flow Parameters 1023 * 1024 * Return: Success/Failure 1025 */ 1026 static void * 1027 hal_rx_flow_setup_fse_8074v1(uint8_t *rx_fst, uint32_t table_offset, 1028 uint8_t *rx_flow) 1029 { 1030 struct hal_rx_fst *fst = (struct hal_rx_fst *)rx_fst; 1031 struct hal_rx_flow *flow = (struct hal_rx_flow *)rx_flow; 1032 uint8_t *fse; 1033 bool fse_valid; 1034 1035 if (table_offset >= fst->max_entries) { 1036 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_ERROR, 1037 "HAL FSE table offset %u exceeds max entries %u", 1038 table_offset, fst->max_entries); 1039 return NULL; 1040 } 1041 1042 fse = (uint8_t *)fst->base_vaddr + 1043 (table_offset * HAL_RX_FST_ENTRY_SIZE); 1044 1045 fse_valid = HAL_GET_FLD(fse, RX_FLOW_SEARCH_ENTRY_9, VALID); 1046 1047 if (fse_valid) { 1048 QDF_TRACE(QDF_MODULE_ID_TXRX, QDF_TRACE_LEVEL_DEBUG, 1049 "HAL FSE %pK already valid", fse); 1050 return NULL; 1051 } 1052 1053 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_0, SRC_IP_127_96) = 1054 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_0, SRC_IP_127_96, 1055 qdf_htonl(flow->tuple_info.src_ip_127_96)); 1056 1057 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_1, SRC_IP_95_64) = 1058 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_1, SRC_IP_95_64, 1059 qdf_htonl(flow->tuple_info.src_ip_95_64)); 1060 1061 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_2, SRC_IP_63_32) = 1062 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_2, SRC_IP_63_32, 1063 qdf_htonl(flow->tuple_info.src_ip_63_32)); 1064 1065 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_3, SRC_IP_31_0) = 1066 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_3, SRC_IP_31_0, 1067 qdf_htonl(flow->tuple_info.src_ip_31_0)); 1068 1069 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_4, DEST_IP_127_96) = 1070 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_4, DEST_IP_127_96, 1071 qdf_htonl(flow->tuple_info.dest_ip_127_96)); 1072 1073 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_5, DEST_IP_95_64) = 1074 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_5, DEST_IP_95_64, 1075 qdf_htonl(flow->tuple_info.dest_ip_95_64)); 1076 1077 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_6, DEST_IP_63_32) = 1078 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_6, DEST_IP_63_32, 1079 qdf_htonl(flow->tuple_info.dest_ip_63_32)); 1080 1081 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_7, DEST_IP_31_0) = 1082 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_7, DEST_IP_31_0, 1083 qdf_htonl(flow->tuple_info.dest_ip_31_0)); 1084 1085 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_8, DEST_PORT); 1086 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_8, DEST_PORT) |= 1087 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_8, DEST_PORT, 1088 (flow->tuple_info.dest_port)); 1089 1090 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_8, SRC_PORT); 1091 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_8, SRC_PORT) |= 1092 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_8, SRC_PORT, 1093 (flow->tuple_info.src_port)); 1094 1095 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_9, L4_PROTOCOL); 1096 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_9, L4_PROTOCOL) |= 1097 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_9, L4_PROTOCOL, 1098 flow->tuple_info.l4_protocol); 1099 1100 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_9, REO_DESTINATION_HANDLER); 1101 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_9, REO_DESTINATION_HANDLER) |= 1102 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_9, REO_DESTINATION_HANDLER, 1103 flow->reo_destination_handler); 1104 1105 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_9, VALID); 1106 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_9, VALID) |= 1107 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_9, VALID, 1); 1108 1109 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_10, METADATA); 1110 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_10, METADATA) = 1111 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_10, METADATA, 1112 flow->fse_metadata); 1113 1114 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_11, REO_DESTINATION_INDICATION); 1115 HAL_SET_FLD(fse, RX_FLOW_SEARCH_ENTRY_11, REO_DESTINATION_INDICATION) |= 1116 HAL_SET_FLD_SM(RX_FLOW_SEARCH_ENTRY_11, 1117 REO_DESTINATION_INDICATION, 1118 flow->reo_destination_indication); 1119 1120 /* Reset all the other fields in FSE */ 1121 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_9, RESERVED_9); 1122 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_11, MSDU_DROP); 1123 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_11, RESERVED_11); 1124 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_11, MSDU_COUNT); 1125 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_12, MSDU_BYTE_COUNT); 1126 HAL_CLR_FLD(fse, RX_FLOW_SEARCH_ENTRY_13, TIMESTAMP); 1127 1128 return fse; 1129 } 1130 1131 static 1132 void hal_compute_reo_remap_ix2_ix3_8074v1(uint32_t *ring, uint32_t num_rings, 1133 uint32_t *remap1, uint32_t *remap2) 1134 { 1135 switch (num_rings) { 1136 case 1: 1137 *remap1 = HAL_REO_REMAP_IX2(ring[0], 16) | 1138 HAL_REO_REMAP_IX2(ring[0], 17) | 1139 HAL_REO_REMAP_IX2(ring[0], 18) | 1140 HAL_REO_REMAP_IX2(ring[0], 19) | 1141 HAL_REO_REMAP_IX2(ring[0], 20) | 1142 HAL_REO_REMAP_IX2(ring[0], 21) | 1143 HAL_REO_REMAP_IX2(ring[0], 22) | 1144 HAL_REO_REMAP_IX2(ring[0], 23); 1145 1146 *remap2 = HAL_REO_REMAP_IX3(ring[0], 24) | 1147 HAL_REO_REMAP_IX3(ring[0], 25) | 1148 HAL_REO_REMAP_IX3(ring[0], 26) | 1149 HAL_REO_REMAP_IX3(ring[0], 27) | 1150 HAL_REO_REMAP_IX3(ring[0], 28) | 1151 HAL_REO_REMAP_IX3(ring[0], 29) | 1152 HAL_REO_REMAP_IX3(ring[0], 30) | 1153 HAL_REO_REMAP_IX3(ring[0], 31); 1154 break; 1155 case 2: 1156 *remap1 = HAL_REO_REMAP_IX2(ring[0], 16) | 1157 HAL_REO_REMAP_IX2(ring[0], 17) | 1158 HAL_REO_REMAP_IX2(ring[1], 18) | 1159 HAL_REO_REMAP_IX2(ring[1], 19) | 1160 HAL_REO_REMAP_IX2(ring[0], 20) | 1161 HAL_REO_REMAP_IX2(ring[0], 21) | 1162 HAL_REO_REMAP_IX2(ring[1], 22) | 1163 HAL_REO_REMAP_IX2(ring[1], 23); 1164 1165 *remap2 = HAL_REO_REMAP_IX3(ring[0], 24) | 1166 HAL_REO_REMAP_IX3(ring[0], 25) | 1167 HAL_REO_REMAP_IX3(ring[1], 26) | 1168 HAL_REO_REMAP_IX3(ring[1], 27) | 1169 HAL_REO_REMAP_IX3(ring[0], 28) | 1170 HAL_REO_REMAP_IX3(ring[0], 29) | 1171 HAL_REO_REMAP_IX3(ring[1], 30) | 1172 HAL_REO_REMAP_IX3(ring[1], 31); 1173 break; 1174 case 3: 1175 *remap1 = HAL_REO_REMAP_IX2(ring[0], 16) | 1176 HAL_REO_REMAP_IX2(ring[1], 17) | 1177 HAL_REO_REMAP_IX2(ring[2], 18) | 1178 HAL_REO_REMAP_IX2(ring[0], 19) | 1179 HAL_REO_REMAP_IX2(ring[1], 20) | 1180 HAL_REO_REMAP_IX2(ring[2], 21) | 1181 HAL_REO_REMAP_IX2(ring[0], 22) | 1182 HAL_REO_REMAP_IX2(ring[1], 23); 1183 1184 *remap2 = HAL_REO_REMAP_IX3(ring[2], 24) | 1185 HAL_REO_REMAP_IX3(ring[0], 25) | 1186 HAL_REO_REMAP_IX3(ring[1], 26) | 1187 HAL_REO_REMAP_IX3(ring[2], 27) | 1188 HAL_REO_REMAP_IX3(ring[0], 28) | 1189 HAL_REO_REMAP_IX3(ring[1], 29) | 1190 HAL_REO_REMAP_IX3(ring[2], 30) | 1191 HAL_REO_REMAP_IX3(ring[0], 31); 1192 break; 1193 case 4: 1194 *remap1 = HAL_REO_REMAP_IX2(ring[0], 16) | 1195 HAL_REO_REMAP_IX2(ring[1], 17) | 1196 HAL_REO_REMAP_IX2(ring[2], 18) | 1197 HAL_REO_REMAP_IX2(ring[3], 19) | 1198 HAL_REO_REMAP_IX2(ring[0], 20) | 1199 HAL_REO_REMAP_IX2(ring[1], 21) | 1200 HAL_REO_REMAP_IX2(ring[2], 22) | 1201 HAL_REO_REMAP_IX2(ring[3], 23); 1202 1203 *remap2 = HAL_REO_REMAP_IX3(ring[0], 24) | 1204 HAL_REO_REMAP_IX3(ring[1], 25) | 1205 HAL_REO_REMAP_IX3(ring[2], 26) | 1206 HAL_REO_REMAP_IX3(ring[3], 27) | 1207 HAL_REO_REMAP_IX3(ring[0], 28) | 1208 HAL_REO_REMAP_IX3(ring[1], 29) | 1209 HAL_REO_REMAP_IX3(ring[2], 30) | 1210 HAL_REO_REMAP_IX3(ring[3], 31); 1211 break; 1212 } 1213 } 1214 1215 struct hal_hw_txrx_ops qca8074_hal_hw_txrx_ops = { 1216 1217 /* init and setup */ 1218 hal_srng_dst_hw_init_generic, 1219 hal_srng_src_hw_init_generic, 1220 hal_get_hw_hptp_generic, 1221 hal_reo_setup_generic, 1222 hal_setup_link_idle_list_generic, 1223 hal_get_window_address_8074, 1224 NULL, 1225 1226 /* tx */ 1227 hal_tx_desc_set_dscp_tid_table_id_8074, 1228 hal_tx_set_dscp_tid_map_8074, 1229 hal_tx_update_dscp_tid_8074, 1230 hal_tx_desc_set_lmac_id_8074, 1231 hal_tx_desc_set_buf_addr_generic, 1232 hal_tx_desc_set_search_type_generic, 1233 hal_tx_desc_set_search_index_generic, 1234 hal_tx_desc_set_cache_set_num_generic, 1235 hal_tx_comp_get_status_generic, 1236 hal_tx_comp_get_release_reason_generic, 1237 hal_get_wbm_internal_error_generic, 1238 hal_tx_desc_set_mesh_en_8074v1, 1239 hal_tx_init_cmd_credit_ring_8074v1, 1240 1241 /* rx */ 1242 hal_rx_msdu_start_nss_get_8074, 1243 hal_rx_mon_hw_desc_get_mpdu_status_8074, 1244 hal_rx_get_tlv_8074, 1245 hal_rx_proc_phyrx_other_receive_info_tlv_8074, 1246 hal_rx_dump_msdu_start_tlv_8074, 1247 hal_rx_dump_msdu_end_tlv_8074, 1248 hal_get_link_desc_size_8074, 1249 hal_rx_mpdu_start_tid_get_8074, 1250 hal_rx_msdu_start_reception_type_get_8074, 1251 hal_rx_msdu_end_da_idx_get_8074, 1252 hal_rx_msdu_desc_info_get_ptr_8074v1, 1253 hal_rx_link_desc_msdu0_ptr_8074v1, 1254 hal_reo_status_get_header_8074v1, 1255 hal_rx_status_get_tlv_info_generic, 1256 hal_rx_wbm_err_info_get_generic, 1257 hal_rx_dump_mpdu_start_tlv_generic, 1258 1259 hal_tx_set_pcp_tid_map_generic, 1260 hal_tx_update_pcp_tid_generic, 1261 hal_tx_update_tidmap_prty_generic, 1262 hal_rx_get_rx_fragment_number_8074v1, 1263 hal_rx_msdu_end_da_is_mcbc_get_8074v1, 1264 hal_rx_msdu_end_sa_is_valid_get_8074v1, 1265 hal_rx_msdu_end_sa_idx_get_8074v1, 1266 hal_rx_desc_is_first_msdu_8074v1, 1267 hal_rx_msdu_end_l3_hdr_padding_get_8074v1, 1268 hal_rx_encryption_info_valid_8074v1, 1269 hal_rx_print_pn_8074v1, 1270 hal_rx_msdu_end_first_msdu_get_8074v1, 1271 hal_rx_msdu_end_da_is_valid_get_8074v1, 1272 hal_rx_msdu_end_last_msdu_get_8074v1, 1273 hal_rx_get_mpdu_mac_ad4_valid_8074v1, 1274 hal_rx_mpdu_start_sw_peer_id_get_8074v1, 1275 hal_rx_mpdu_get_to_ds_8074v1, 1276 hal_rx_mpdu_get_fr_ds_8074v1, 1277 hal_rx_get_mpdu_frame_control_valid_8074v1, 1278 hal_rx_mpdu_get_addr1_8074v1, 1279 hal_rx_mpdu_get_addr2_8074v1, 1280 hal_rx_mpdu_get_addr3_8074v1, 1281 hal_rx_mpdu_get_addr4_8074v1, 1282 hal_rx_get_mpdu_sequence_control_valid_8074v1, 1283 hal_rx_is_unicast_8074v1, 1284 hal_rx_tid_get_8074v1, 1285 hal_rx_hw_desc_get_ppduid_get_8074v1, 1286 hal_rx_mpdu_start_mpdu_qos_control_valid_get_8074v1, 1287 hal_rx_msdu_end_sa_sw_peer_id_get_8074v1, 1288 hal_rx_msdu0_buffer_addr_lsb_8074v1, 1289 hal_rx_msdu_desc_info_ptr_get_8074v1, 1290 hal_ent_mpdu_desc_info_8074v1, 1291 hal_dst_mpdu_desc_info_8074v1, 1292 hal_rx_get_fc_valid_8074v1, 1293 hal_rx_get_to_ds_flag_8074v1, 1294 hal_rx_get_mac_addr2_valid_8074v1, 1295 hal_rx_get_filter_category_8074v1, 1296 hal_rx_get_ppdu_id_8074v1, 1297 hal_reo_config_8074v1, 1298 hal_rx_msdu_flow_idx_get_8074v1, 1299 hal_rx_msdu_flow_idx_invalid_8074v1, 1300 hal_rx_msdu_flow_idx_timeout_8074v1, 1301 hal_rx_msdu_fse_metadata_get_8074v1, 1302 hal_rx_msdu_cce_metadata_get_8074v1, 1303 hal_rx_msdu_get_flow_params_8074v1, 1304 hal_rx_tlv_get_tcp_chksum_8074v1, 1305 hal_rx_get_rx_sequence_8074v1, 1306 NULL, 1307 NULL, 1308 /* rx - msdu fast path info fields */ 1309 hal_rx_msdu_packet_metadata_get_generic, 1310 NULL, 1311 NULL, 1312 NULL, 1313 NULL, 1314 NULL, 1315 NULL, 1316 hal_rx_mpdu_start_tlv_tag_valid_8074v1, 1317 NULL, 1318 NULL, 1319 1320 /* rx - TLV struct offsets */ 1321 hal_rx_msdu_end_offset_get_generic, 1322 hal_rx_attn_offset_get_generic, 1323 hal_rx_msdu_start_offset_get_generic, 1324 hal_rx_mpdu_start_offset_get_generic, 1325 hal_rx_mpdu_end_offset_get_generic, 1326 hal_rx_flow_setup_fse_8074v1, 1327 hal_compute_reo_remap_ix2_ix3_8074v1 1328 }; 1329 1330 struct hal_hw_srng_config hw_srng_table_8074[] = { 1331 /* TODO: max_rings can populated by querying HW capabilities */ 1332 { /* REO_DST */ 1333 .start_ring_id = HAL_SRNG_REO2SW1, 1334 .max_rings = 4, 1335 .entry_size = sizeof(struct reo_destination_ring) >> 2, 1336 .lmac_ring = FALSE, 1337 .ring_dir = HAL_SRNG_DST_RING, 1338 .reg_start = { 1339 HWIO_REO_R0_REO2SW1_RING_BASE_LSB_ADDR( 1340 SEQ_WCSS_UMAC_REO_REG_OFFSET), 1341 HWIO_REO_R2_REO2SW1_RING_HP_ADDR( 1342 SEQ_WCSS_UMAC_REO_REG_OFFSET) 1343 }, 1344 .reg_size = { 1345 HWIO_REO_R0_REO2SW2_RING_BASE_LSB_ADDR(0) - 1346 HWIO_REO_R0_REO2SW1_RING_BASE_LSB_ADDR(0), 1347 HWIO_REO_R2_REO2SW2_RING_HP_ADDR(0) - 1348 HWIO_REO_R2_REO2SW1_RING_HP_ADDR(0), 1349 }, 1350 .max_size = 1351 HWIO_REO_R0_REO2SW1_RING_BASE_MSB_RING_SIZE_BMSK >> 1352 HWIO_REO_R0_REO2SW1_RING_BASE_MSB_RING_SIZE_SHFT, 1353 }, 1354 { /* REO_EXCEPTION */ 1355 /* Designating REO2TCL ring as exception ring. This ring is 1356 * similar to other REO2SW rings though it is named as REO2TCL. 1357 * Any of theREO2SW rings can be used as exception ring. 1358 */ 1359 .start_ring_id = HAL_SRNG_REO2TCL, 1360 .max_rings = 1, 1361 .entry_size = sizeof(struct reo_destination_ring) >> 2, 1362 .lmac_ring = FALSE, 1363 .ring_dir = HAL_SRNG_DST_RING, 1364 .reg_start = { 1365 HWIO_REO_R0_REO2TCL_RING_BASE_LSB_ADDR( 1366 SEQ_WCSS_UMAC_REO_REG_OFFSET), 1367 HWIO_REO_R2_REO2TCL_RING_HP_ADDR( 1368 SEQ_WCSS_UMAC_REO_REG_OFFSET) 1369 }, 1370 /* Single ring - provide ring size if multiple rings of this 1371 * type are supported 1372 */ 1373 .reg_size = {}, 1374 .max_size = 1375 HWIO_REO_R0_REO2TCL_RING_BASE_MSB_RING_SIZE_BMSK >> 1376 HWIO_REO_R0_REO2TCL_RING_BASE_MSB_RING_SIZE_SHFT, 1377 }, 1378 { /* REO_REINJECT */ 1379 .start_ring_id = HAL_SRNG_SW2REO, 1380 .max_rings = 1, 1381 .entry_size = sizeof(struct reo_entrance_ring) >> 2, 1382 .lmac_ring = FALSE, 1383 .ring_dir = HAL_SRNG_SRC_RING, 1384 .reg_start = { 1385 HWIO_REO_R0_SW2REO_RING_BASE_LSB_ADDR( 1386 SEQ_WCSS_UMAC_REO_REG_OFFSET), 1387 HWIO_REO_R2_SW2REO_RING_HP_ADDR( 1388 SEQ_WCSS_UMAC_REO_REG_OFFSET) 1389 }, 1390 /* Single ring - provide ring size if multiple rings of this 1391 * type are supported 1392 */ 1393 .reg_size = {}, 1394 .max_size = HWIO_REO_R0_SW2REO_RING_BASE_MSB_RING_SIZE_BMSK >> 1395 HWIO_REO_R0_SW2REO_RING_BASE_MSB_RING_SIZE_SHFT, 1396 }, 1397 { /* REO_CMD */ 1398 .start_ring_id = HAL_SRNG_REO_CMD, 1399 .max_rings = 1, 1400 .entry_size = (sizeof(struct tlv_32_hdr) + 1401 sizeof(struct reo_get_queue_stats)) >> 2, 1402 .lmac_ring = FALSE, 1403 .ring_dir = HAL_SRNG_SRC_RING, 1404 .reg_start = { 1405 HWIO_REO_R0_REO_CMD_RING_BASE_LSB_ADDR( 1406 SEQ_WCSS_UMAC_REO_REG_OFFSET), 1407 HWIO_REO_R2_REO_CMD_RING_HP_ADDR( 1408 SEQ_WCSS_UMAC_REO_REG_OFFSET), 1409 }, 1410 /* Single ring - provide ring size if multiple rings of this 1411 * type are supported 1412 */ 1413 .reg_size = {}, 1414 .max_size = HWIO_REO_R0_REO_CMD_RING_BASE_MSB_RING_SIZE_BMSK >> 1415 HWIO_REO_R0_REO_CMD_RING_BASE_MSB_RING_SIZE_SHFT, 1416 }, 1417 { /* REO_STATUS */ 1418 .start_ring_id = HAL_SRNG_REO_STATUS, 1419 .max_rings = 1, 1420 .entry_size = (sizeof(struct tlv_32_hdr) + 1421 sizeof(struct reo_get_queue_stats_status)) >> 2, 1422 .lmac_ring = FALSE, 1423 .ring_dir = HAL_SRNG_DST_RING, 1424 .reg_start = { 1425 HWIO_REO_R0_REO_STATUS_RING_BASE_LSB_ADDR( 1426 SEQ_WCSS_UMAC_REO_REG_OFFSET), 1427 HWIO_REO_R2_REO_STATUS_RING_HP_ADDR( 1428 SEQ_WCSS_UMAC_REO_REG_OFFSET), 1429 }, 1430 /* Single ring - provide ring size if multiple rings of this 1431 * type are supported 1432 */ 1433 .reg_size = {}, 1434 .max_size = 1435 HWIO_REO_R0_REO_STATUS_RING_BASE_MSB_RING_SIZE_BMSK >> 1436 HWIO_REO_R0_REO_STATUS_RING_BASE_MSB_RING_SIZE_SHFT, 1437 }, 1438 { /* TCL_DATA */ 1439 .start_ring_id = HAL_SRNG_SW2TCL1, 1440 .max_rings = 3, 1441 .entry_size = (sizeof(struct tlv_32_hdr) + 1442 sizeof(struct tcl_data_cmd)) >> 2, 1443 .lmac_ring = FALSE, 1444 .ring_dir = HAL_SRNG_SRC_RING, 1445 .reg_start = { 1446 HWIO_TCL_R0_SW2TCL1_RING_BASE_LSB_ADDR( 1447 SEQ_WCSS_UMAC_MAC_TCL_REG_OFFSET), 1448 HWIO_TCL_R2_SW2TCL1_RING_HP_ADDR( 1449 SEQ_WCSS_UMAC_MAC_TCL_REG_OFFSET), 1450 }, 1451 .reg_size = { 1452 HWIO_TCL_R0_SW2TCL2_RING_BASE_LSB_ADDR(0) - 1453 HWIO_TCL_R0_SW2TCL1_RING_BASE_LSB_ADDR(0), 1454 HWIO_TCL_R2_SW2TCL2_RING_HP_ADDR(0) - 1455 HWIO_TCL_R2_SW2TCL1_RING_HP_ADDR(0), 1456 }, 1457 .max_size = 1458 HWIO_TCL_R0_SW2TCL1_RING_BASE_MSB_RING_SIZE_BMSK >> 1459 HWIO_TCL_R0_SW2TCL1_RING_BASE_MSB_RING_SIZE_SHFT, 1460 }, 1461 { /* TCL_CMD */ 1462 .start_ring_id = HAL_SRNG_SW2TCL_CMD, 1463 .max_rings = 1, 1464 .entry_size = (sizeof(struct tlv_32_hdr) + 1465 sizeof(struct tcl_data_cmd)) >> 2, 1466 .lmac_ring = FALSE, 1467 .ring_dir = HAL_SRNG_SRC_RING, 1468 .reg_start = { 1469 HWIO_TCL_R0_SW2TCL_CMD_RING_BASE_LSB_ADDR( 1470 SEQ_WCSS_UMAC_MAC_TCL_REG_OFFSET), 1471 HWIO_TCL_R2_SW2TCL_CMD_RING_HP_ADDR( 1472 SEQ_WCSS_UMAC_MAC_TCL_REG_OFFSET), 1473 }, 1474 /* Single ring - provide ring size if multiple rings of this 1475 * type are supported 1476 */ 1477 .reg_size = {}, 1478 .max_size = 1479 HWIO_TCL_R0_SW2TCL_CMD_RING_BASE_MSB_RING_SIZE_BMSK >> 1480 HWIO_TCL_R0_SW2TCL_CMD_RING_BASE_MSB_RING_SIZE_SHFT, 1481 }, 1482 { /* TCL_STATUS */ 1483 .start_ring_id = HAL_SRNG_TCL_STATUS, 1484 .max_rings = 1, 1485 .entry_size = (sizeof(struct tlv_32_hdr) + 1486 sizeof(struct tcl_status_ring)) >> 2, 1487 .lmac_ring = FALSE, 1488 .ring_dir = HAL_SRNG_DST_RING, 1489 .reg_start = { 1490 HWIO_TCL_R0_TCL_STATUS1_RING_BASE_LSB_ADDR( 1491 SEQ_WCSS_UMAC_MAC_TCL_REG_OFFSET), 1492 HWIO_TCL_R2_TCL_STATUS1_RING_HP_ADDR( 1493 SEQ_WCSS_UMAC_MAC_TCL_REG_OFFSET), 1494 }, 1495 /* Single ring - provide ring size if multiple rings of this 1496 * type are supported 1497 */ 1498 .reg_size = {}, 1499 .max_size = 1500 HWIO_TCL_R0_TCL_STATUS1_RING_BASE_MSB_RING_SIZE_BMSK >> 1501 HWIO_TCL_R0_TCL_STATUS1_RING_BASE_MSB_RING_SIZE_SHFT, 1502 }, 1503 { /* CE_SRC */ 1504 .start_ring_id = HAL_SRNG_CE_0_SRC, 1505 .max_rings = 12, 1506 .entry_size = sizeof(struct ce_src_desc) >> 2, 1507 .lmac_ring = FALSE, 1508 .ring_dir = HAL_SRNG_SRC_RING, 1509 .reg_start = { 1510 HWIO_WFSS_CE_CHANNEL_DST_R0_DEST_RING_BASE_LSB_ADDR( 1511 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_SRC_REG_OFFSET), 1512 HWIO_WFSS_CE_CHANNEL_DST_R2_DEST_RING_HP_ADDR( 1513 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_SRC_REG_OFFSET), 1514 }, 1515 .reg_size = { 1516 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_1_CHANNEL_SRC_REG_OFFSET - 1517 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_SRC_REG_OFFSET, 1518 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_1_CHANNEL_SRC_REG_OFFSET - 1519 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_SRC_REG_OFFSET, 1520 }, 1521 .max_size = 1522 HWIO_WFSS_CE_CHANNEL_DST_R0_DEST_RING_BASE_MSB_RING_SIZE_BMSK >> 1523 HWIO_WFSS_CE_CHANNEL_DST_R0_DEST_RING_BASE_MSB_RING_SIZE_SHFT, 1524 }, 1525 { /* CE_DST */ 1526 .start_ring_id = HAL_SRNG_CE_0_DST, 1527 .max_rings = 12, 1528 .entry_size = 8 >> 2, 1529 /*TODO: entry_size above should actually be 1530 * sizeof(struct ce_dst_desc) >> 2, but couldn't find definition 1531 * of struct ce_dst_desc in HW header files 1532 */ 1533 .lmac_ring = FALSE, 1534 .ring_dir = HAL_SRNG_SRC_RING, 1535 .reg_start = { 1536 HWIO_WFSS_CE_CHANNEL_DST_R0_DEST_RING_BASE_LSB_ADDR( 1537 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_DST_REG_OFFSET), 1538 HWIO_WFSS_CE_CHANNEL_DST_R2_DEST_RING_HP_ADDR( 1539 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_DST_REG_OFFSET), 1540 }, 1541 .reg_size = { 1542 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_1_CHANNEL_DST_REG_OFFSET - 1543 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_DST_REG_OFFSET, 1544 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_1_CHANNEL_DST_REG_OFFSET - 1545 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_DST_REG_OFFSET, 1546 }, 1547 .max_size = 1548 HWIO_WFSS_CE_CHANNEL_DST_R0_DEST_RING_BASE_MSB_RING_SIZE_BMSK >> 1549 HWIO_WFSS_CE_CHANNEL_DST_R0_DEST_RING_BASE_MSB_RING_SIZE_SHFT, 1550 }, 1551 { /* CE_DST_STATUS */ 1552 .start_ring_id = HAL_SRNG_CE_0_DST_STATUS, 1553 .max_rings = 12, 1554 .entry_size = sizeof(struct ce_stat_desc) >> 2, 1555 .lmac_ring = FALSE, 1556 .ring_dir = HAL_SRNG_DST_RING, 1557 .reg_start = { 1558 HWIO_WFSS_CE_CHANNEL_DST_R0_STATUS_RING_BASE_LSB_ADDR( 1559 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_DST_REG_OFFSET), 1560 HWIO_WFSS_CE_CHANNEL_DST_R2_STATUS_RING_HP_ADDR( 1561 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_DST_REG_OFFSET), 1562 }, 1563 /* TODO: check destination status ring registers */ 1564 .reg_size = { 1565 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_1_CHANNEL_DST_REG_OFFSET - 1566 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_DST_REG_OFFSET, 1567 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_1_CHANNEL_DST_REG_OFFSET - 1568 SEQ_WCSS_UMAC_WFSS_CE_0_REG_WFSS_CE_0_CHANNEL_DST_REG_OFFSET, 1569 }, 1570 .max_size = 1571 HWIO_WFSS_CE_CHANNEL_DST_R0_STATUS_RING_BASE_MSB_RING_SIZE_BMSK >> 1572 HWIO_WFSS_CE_CHANNEL_DST_R0_STATUS_RING_BASE_MSB_RING_SIZE_SHFT, 1573 }, 1574 { /* WBM_IDLE_LINK */ 1575 .start_ring_id = HAL_SRNG_WBM_IDLE_LINK, 1576 .max_rings = 1, 1577 .entry_size = sizeof(struct wbm_link_descriptor_ring) >> 2, 1578 .lmac_ring = FALSE, 1579 .ring_dir = HAL_SRNG_SRC_RING, 1580 .reg_start = { 1581 HWIO_WBM_R0_WBM_IDLE_LINK_RING_BASE_LSB_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET), 1582 HWIO_WBM_R2_WBM_IDLE_LINK_RING_HP_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET), 1583 }, 1584 /* Single ring - provide ring size if multiple rings of this 1585 * type are supported 1586 */ 1587 .reg_size = {}, 1588 .max_size = 1589 HWIO_WBM_R0_WBM_IDLE_LINK_RING_BASE_MSB_RING_SIZE_BMSK >> 1590 HWIO_WBM_R0_WBM_IDLE_LINK_RING_BASE_MSB_RING_SIZE_SHFT, 1591 }, 1592 { /* SW2WBM_RELEASE */ 1593 .start_ring_id = HAL_SRNG_WBM_SW_RELEASE, 1594 .max_rings = 1, 1595 .entry_size = sizeof(struct wbm_release_ring) >> 2, 1596 .lmac_ring = FALSE, 1597 .ring_dir = HAL_SRNG_SRC_RING, 1598 .reg_start = { 1599 HWIO_WBM_R0_SW_RELEASE_RING_BASE_LSB_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET), 1600 HWIO_WBM_R2_SW_RELEASE_RING_HP_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET), 1601 }, 1602 /* Single ring - provide ring size if multiple rings of this 1603 * type are supported 1604 */ 1605 .reg_size = {}, 1606 .max_size = 1607 HWIO_WBM_R0_SW_RELEASE_RING_BASE_MSB_RING_SIZE_BMSK >> 1608 HWIO_WBM_R0_SW_RELEASE_RING_BASE_MSB_RING_SIZE_SHFT, 1609 }, 1610 { /* WBM2SW_RELEASE */ 1611 .start_ring_id = HAL_SRNG_WBM2SW0_RELEASE, 1612 .max_rings = 4, 1613 .entry_size = sizeof(struct wbm_release_ring) >> 2, 1614 .lmac_ring = FALSE, 1615 .ring_dir = HAL_SRNG_DST_RING, 1616 .reg_start = { 1617 HWIO_WBM_R0_WBM2SW0_RELEASE_RING_BASE_LSB_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET), 1618 HWIO_WBM_R2_WBM2SW0_RELEASE_RING_HP_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET), 1619 }, 1620 .reg_size = { 1621 HWIO_WBM_R0_WBM2SW1_RELEASE_RING_BASE_LSB_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET) - 1622 HWIO_WBM_R0_WBM2SW0_RELEASE_RING_BASE_LSB_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET), 1623 HWIO_WBM_R2_WBM2SW1_RELEASE_RING_HP_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET) - 1624 HWIO_WBM_R2_WBM2SW0_RELEASE_RING_HP_ADDR(SEQ_WCSS_UMAC_WBM_REG_OFFSET), 1625 }, 1626 .max_size = 1627 HWIO_WBM_R0_WBM2SW0_RELEASE_RING_BASE_MSB_RING_SIZE_BMSK >> 1628 HWIO_WBM_R0_WBM2SW0_RELEASE_RING_BASE_MSB_RING_SIZE_SHFT, 1629 }, 1630 { /* RXDMA_BUF */ 1631 .start_ring_id = HAL_SRNG_WMAC1_SW2RXDMA0_BUF0, 1632 #ifdef IPA_OFFLOAD 1633 .max_rings = 3, 1634 #else 1635 .max_rings = 2, 1636 #endif 1637 .entry_size = sizeof(struct wbm_buffer_ring) >> 2, 1638 .lmac_ring = TRUE, 1639 .ring_dir = HAL_SRNG_SRC_RING, 1640 /* reg_start is not set because LMAC rings are not accessed 1641 * from host 1642 */ 1643 .reg_start = {}, 1644 .reg_size = {}, 1645 .max_size = HAL_RXDMA_MAX_RING_SIZE, 1646 }, 1647 { /* RXDMA_DST */ 1648 .start_ring_id = HAL_SRNG_WMAC1_RXDMA2SW0, 1649 .max_rings = 1, 1650 .entry_size = sizeof(struct reo_entrance_ring) >> 2, 1651 .lmac_ring = TRUE, 1652 .ring_dir = HAL_SRNG_DST_RING, 1653 /* reg_start is not set because LMAC rings are not accessed 1654 * from host 1655 */ 1656 .reg_start = {}, 1657 .reg_size = {}, 1658 .max_size = HAL_RXDMA_MAX_RING_SIZE, 1659 }, 1660 { /* RXDMA_MONITOR_BUF */ 1661 .start_ring_id = HAL_SRNG_WMAC1_SW2RXDMA2_BUF, 1662 .max_rings = 1, 1663 .entry_size = sizeof(struct wbm_buffer_ring) >> 2, 1664 .lmac_ring = TRUE, 1665 .ring_dir = HAL_SRNG_SRC_RING, 1666 /* reg_start is not set because LMAC rings are not accessed 1667 * from host 1668 */ 1669 .reg_start = {}, 1670 .reg_size = {}, 1671 .max_size = HAL_RXDMA_MAX_RING_SIZE, 1672 }, 1673 { /* RXDMA_MONITOR_STATUS */ 1674 .start_ring_id = HAL_SRNG_WMAC1_SW2RXDMA1_STATBUF, 1675 .max_rings = 1, 1676 .entry_size = sizeof(struct wbm_buffer_ring) >> 2, 1677 .lmac_ring = TRUE, 1678 .ring_dir = HAL_SRNG_SRC_RING, 1679 /* reg_start is not set because LMAC rings are not accessed 1680 * from host 1681 */ 1682 .reg_start = {}, 1683 .reg_size = {}, 1684 .max_size = HAL_RXDMA_MAX_RING_SIZE, 1685 }, 1686 { /* RXDMA_MONITOR_DST */ 1687 .start_ring_id = HAL_SRNG_WMAC1_RXDMA2SW1, 1688 .max_rings = 1, 1689 .entry_size = sizeof(struct reo_entrance_ring) >> 2, 1690 .lmac_ring = TRUE, 1691 .ring_dir = HAL_SRNG_DST_RING, 1692 /* reg_start is not set because LMAC rings are not accessed 1693 * from host 1694 */ 1695 .reg_start = {}, 1696 .reg_size = {}, 1697 .max_size = HAL_RXDMA_MAX_RING_SIZE, 1698 }, 1699 { /* RXDMA_MONITOR_DESC */ 1700 .start_ring_id = HAL_SRNG_WMAC1_SW2RXDMA1_DESC, 1701 .max_rings = 1, 1702 .entry_size = sizeof(struct wbm_buffer_ring) >> 2, 1703 .lmac_ring = TRUE, 1704 .ring_dir = HAL_SRNG_SRC_RING, 1705 /* reg_start is not set because LMAC rings are not accessed 1706 * from host 1707 */ 1708 .reg_start = {}, 1709 .reg_size = {}, 1710 .max_size = HAL_RXDMA_MAX_RING_SIZE, 1711 }, 1712 { /* DIR_BUF_RX_DMA_SRC */ 1713 .start_ring_id = HAL_SRNG_DIR_BUF_RX_SRC_DMA_RING, 1714 .max_rings = 1, 1715 .entry_size = 2, 1716 .lmac_ring = TRUE, 1717 .ring_dir = HAL_SRNG_SRC_RING, 1718 /* reg_start is not set because LMAC rings are not accessed 1719 * from host 1720 */ 1721 .reg_start = {}, 1722 .reg_size = {}, 1723 .max_size = HAL_RXDMA_MAX_RING_SIZE, 1724 }, 1725 #ifdef WLAN_FEATURE_CIF_CFR 1726 { /* WIFI_POS_SRC */ 1727 .start_ring_id = HAL_SRNG_WIFI_POS_SRC_DMA_RING, 1728 .max_rings = 1, 1729 .entry_size = sizeof(wmi_oem_dma_buf_release_entry) >> 2, 1730 .lmac_ring = TRUE, 1731 .ring_dir = HAL_SRNG_SRC_RING, 1732 /* reg_start is not set because LMAC rings are not accessed 1733 * from host 1734 */ 1735 .reg_start = {}, 1736 .reg_size = {}, 1737 .max_size = HAL_RXDMA_MAX_RING_SIZE, 1738 }, 1739 #endif 1740 }; 1741 1742 int32_t hal_hw_reg_offset_qca8074[] = { 1743 /* dst */ 1744 REG_OFFSET(DST, HP), 1745 REG_OFFSET(DST, TP), 1746 REG_OFFSET(DST, ID), 1747 REG_OFFSET(DST, MISC), 1748 REG_OFFSET(DST, HP_ADDR_LSB), 1749 REG_OFFSET(DST, HP_ADDR_MSB), 1750 REG_OFFSET(DST, MSI1_BASE_LSB), 1751 REG_OFFSET(DST, MSI1_BASE_MSB), 1752 REG_OFFSET(DST, MSI1_DATA), 1753 REG_OFFSET(DST, BASE_LSB), 1754 REG_OFFSET(DST, BASE_MSB), 1755 REG_OFFSET(DST, PRODUCER_INT_SETUP), 1756 /* src */ 1757 REG_OFFSET(SRC, HP), 1758 REG_OFFSET(SRC, TP), 1759 REG_OFFSET(SRC, ID), 1760 REG_OFFSET(SRC, MISC), 1761 REG_OFFSET(SRC, TP_ADDR_LSB), 1762 REG_OFFSET(SRC, TP_ADDR_MSB), 1763 REG_OFFSET(SRC, MSI1_BASE_LSB), 1764 REG_OFFSET(SRC, MSI1_BASE_MSB), 1765 REG_OFFSET(SRC, MSI1_DATA), 1766 REG_OFFSET(SRC, BASE_LSB), 1767 REG_OFFSET(SRC, BASE_MSB), 1768 REG_OFFSET(SRC, CONSUMER_INT_SETUP_IX0), 1769 REG_OFFSET(SRC, CONSUMER_INT_SETUP_IX1), 1770 }; 1771 1772 /** 1773 * hal_qca8074_attach() - Attach 8074 target specific hal_soc ops, 1774 * offset and srng table 1775 */ 1776 void hal_qca8074_attach(struct hal_soc *hal_soc) 1777 { 1778 hal_soc->hw_srng_table = hw_srng_table_8074; 1779 hal_soc->hal_hw_reg_offset = hal_hw_reg_offset_qca8074; 1780 hal_soc->ops = &qca8074_hal_hw_txrx_ops; 1781 } 1782