wifi: ath12k: driver for Qualcomm Wi-Fi 7 devices
Subsystems (2)
PATCH v2 19/50 wifi: ath12k: add hal.c
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hal.c | 2177 +++++++++++++++++++++++++++++++++ 1 file changed, 2177 insertions(+)
drivers/net/wireless/ath/ath12k/hal.c new file +2177 -0
@@ -0,0 +1,2177 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ +#include <linux/dma-mapping.h> +#include "hal_tx.h" +#include "hal_rx.h" +#include "debug.h" +#include "hal_desc.h" +#include "hif.h" + +static const struct hal_srng_config hw_srng_config_template[] = { +/* TODO: max_rings can populated by querying HW capabilities */ + [HAL_REO_DST ] = { + .start_ring_id =HAL_SRNG_RING_ID_REO2SW1 , + .max_rings =8 , + .entry_size =sizeof (struct hal_reo_dest_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_DST , + .max_size =HAL_REO_REO2SW1_RING_BASE_MSB_RING_SIZE , + }, + [HAL_REO_EXCEPTION ] = { +/* Designating REO2SW0 ring as exception ring. +* Any of theREO2SW rings can be used as exception ring. +*/ + .start_ring_id =HAL_SRNG_RING_ID_REO2SW0 , + .max_rings =1 , + .entry_size =sizeof (struct hal_reo_dest_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_DST , + .max_size =HAL_REO_REO2SW0_RING_BASE_MSB_RING_SIZE , + }, + [HAL_REO_REINJECT ] = { + .start_ring_id =HAL_SRNG_RING_ID_SW2REO , + .max_rings =4 , + .entry_size =sizeof (struct hal_reo_entrance_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_REO_SW2REO_RING_BASE_MSB_RING_SIZE , + }, + [HAL_REO_CMD ] = { + .start_ring_id =HAL_SRNG_RING_ID_REO_CMD , + .max_rings =1 , + .entry_size = (sizeof (struct hal_tlv_64_hdr ) + +sizeof (struct hal_reo_get_queue_stats )) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_REO_CMD_RING_BASE_MSB_RING_SIZE , + }, + [HAL_REO_STATUS ] = { + .start_ring_id =HAL_SRNG_RING_ID_REO_STATUS , + .max_rings =1 , + .entry_size = (sizeof (struct hal_tlv_64_hdr ) + +sizeof (struct hal_reo_get_queue_stats_status )) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_DST , + .max_size =HAL_REO_STATUS_RING_BASE_MSB_RING_SIZE , + }, + [HAL_TCL_DATA ] = { + .start_ring_id =HAL_SRNG_RING_ID_SW2TCL1 , + .max_rings =6 , + .entry_size =sizeof (struct hal_tcl_data_cmd ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_SW2TCL1_RING_BASE_MSB_RING_SIZE , + }, + [HAL_TCL_CMD ] = { + .start_ring_id =HAL_SRNG_RING_ID_SW2TCL_CMD , + .max_rings =1 , + .entry_size =sizeof (struct hal_tcl_gse_cmd ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_SW2TCL1_CMD_RING_BASE_MSB_RING_SIZE , + }, + [HAL_TCL_STATUS ] = { + .start_ring_id =HAL_SRNG_RING_ID_TCL_STATUS , + .max_rings =1 , + .entry_size = (sizeof (struct hal_tlv_hdr ) + +sizeof (struct hal_tcl_status_ring )) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_DST , + .max_size =HAL_TCL_STATUS_RING_BASE_MSB_RING_SIZE , + }, + [HAL_CE_SRC ] = { + .start_ring_id =HAL_SRNG_RING_ID_CE0_SRC , + .max_rings =16 , + .entry_size =sizeof (struct hal_ce_srng_src_desc ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_CE_SRC_RING_BASE_MSB_RING_SIZE , + }, + [HAL_CE_DST ] = { + .start_ring_id =HAL_SRNG_RING_ID_CE0_DST , + .max_rings =16 , + .entry_size =sizeof (struct hal_ce_srng_dest_desc ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_CE_DST_RING_BASE_MSB_RING_SIZE , + }, + [HAL_CE_DST_STATUS ] = { + .start_ring_id =HAL_SRNG_RING_ID_CE0_DST_STATUS , + .max_rings =16 , + .entry_size =sizeof (struct hal_ce_srng_dst_status_desc ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_DST , + .max_size =HAL_CE_DST_STATUS_RING_BASE_MSB_RING_SIZE , + }, + [HAL_WBM_IDLE_LINK ] = { + .start_ring_id =HAL_SRNG_RING_ID_WBM_IDLE_LINK , + .max_rings =1 , + .entry_size =sizeof (struct hal_wbm_link_desc ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_WBM_IDLE_LINK_RING_BASE_MSB_RING_SIZE , + }, + [HAL_SW2WBM_RELEASE ] = { + .start_ring_id =HAL_SRNG_RING_ID_WBM_SW0_RELEASE , + .max_rings =2 , + .entry_size =sizeof (struct hal_wbm_release_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_SW2WBM_RELEASE_RING_BASE_MSB_RING_SIZE , + }, + [HAL_WBM2SW_RELEASE ] = { + .start_ring_id =HAL_SRNG_RING_ID_WBM2SW0_RELEASE , + .max_rings =8 , + .entry_size =sizeof (struct hal_wbm_release_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_UMAC , + .ring_dir =HAL_SRNG_DIR_DST , + .max_size =HAL_WBM2SW_RELEASE_RING_BASE_MSB_RING_SIZE , + }, + [HAL_RXDMA_BUF ] = { + .start_ring_id =HAL_SRNG_SW2RXDMA_BUF0 , + .max_rings =1 , + .entry_size =sizeof (struct hal_wbm_buffer_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_DMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_RXDMA_RING_MAX_SIZE_BE , + }, + [HAL_RXDMA_DST ] = { + .start_ring_id =HAL_SRNG_RING_ID_WMAC1_RXDMA2SW0 , + .max_rings =0 , + .entry_size =0 , + .mac_type =ATH12K_HAL_SRNG_PMAC , + .ring_dir =HAL_SRNG_DIR_DST , + .max_size =HAL_RXDMA_RING_MAX_SIZE_BE , + }, + [HAL_RXDMA_MONITOR_BUF ] = { + .start_ring_id =HAL_SRNG_SW2RXMON_BUF0 , + .max_rings =1 , + .entry_size =sizeof (struct hal_mon_buf_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_PMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_RXDMA_RING_MAX_SIZE_BE , + }, + [HAL_RXDMA_MONITOR_STATUS ] = {0 , }, + [HAL_RXDMA_MONITOR_DESC ] = {0 , }, + [HAL_RXDMA_DIR_BUF ] = { + .start_ring_id =HAL_SRNG_RING_ID_RXDMA_DIR_BUF , + .max_rings =2 , + .entry_size =8 >>2 ,/* TODO: Define the struct */ + .mac_type =ATH12K_HAL_SRNG_PMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_RXDMA_RING_MAX_SIZE_BE , + }, + [HAL_PPE2TCL ] = { + .start_ring_id =HAL_SRNG_RING_ID_PPE2TCL1 , + .max_rings =1 , + .entry_size =sizeof (struct hal_tcl_entrance_from_ppe_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_PMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_SW2TCL1_RING_BASE_MSB_RING_SIZE , + }, + [HAL_PPE_RELEASE ] = { + .start_ring_id =HAL_SRNG_RING_ID_WBM_PPE_RELEASE , + .max_rings =1 , + .entry_size =sizeof (struct hal_wbm_release_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_PMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_WBM2PPE_RELEASE_RING_BASE_MSB_RING_SIZE , + }, + [HAL_TX_MONITOR_BUF ] = { + .start_ring_id =HAL_SRNG_SW2TXMON_BUF0 , + .max_rings =1 , + .entry_size =sizeof (struct hal_mon_buf_ring ) >>2 , + .mac_type =ATH12K_HAL_SRNG_PMAC , + .ring_dir =HAL_SRNG_DIR_SRC , + .max_size =HAL_RXDMA_RING_MAX_SIZE_BE , + }, + [HAL_RXDMA_MONITOR_DST ] = { + .start_ring_id =HAL_SRNG_RING_ID_WMAC1_SW2RXMON_BUF0 , + .max_rings =1 , + .entry_size =sizeof (struct hal_mon_dest_desc ) >>2 , + .mac_type =ATH12K_HAL_SRNG_PMAC , + .ring_dir =HAL_SRNG_DIR_DST , + .max_size =HAL_RXDMA_RING_MAX_SIZE_BE , + }, + [HAL_TX_MONITOR_DST ] = { + .start_ring_id =HAL_SRNG_RING_ID_WMAC1_TXMON2SW0_BUF0 , + .max_rings =1 , + .entry_size =sizeof (struct hal_mon_dest_desc ) >>2 , + .mac_type =ATH12K_HAL_SRNG_PMAC , + .ring_dir =HAL_SRNG_DIR_DST , + .max_size =HAL_RXDMA_RING_MAX_SIZE_BE , + } +}; + +static const struct ath12k_hal_tcl_to_wbm_rbm_map +ath12k_hal_qcn9274_tcl_to_wbm_rbm_map[DP_TCL_NUM_RING_MAX ] = { + { + .wbm_ring_num =0 , + .rbm_id =HAL_RX_BUF_RBM_SW0_BM , + }, + { + .wbm_ring_num =1 , + .rbm_id =HAL_RX_BUF_RBM_SW1_BM , + }, + { + .wbm_ring_num =2 , + .rbm_id =HAL_RX_BUF_RBM_SW2_BM , + }, + { + .wbm_ring_num =4 , + .rbm_id =HAL_RX_BUF_RBM_SW4_BM , + } +}; + +static const struct ath12k_hal_tcl_to_wbm_rbm_map +ath12k_hal_wcn7850_tcl_to_wbm_rbm_map[DP_TCL_NUM_RING_MAX ] = { + { + .wbm_ring_num =0 , + .rbm_id =HAL_RX_BUF_RBM_SW0_BM , + }, + { + .wbm_ring_num =2 , + .rbm_id =HAL_RX_BUF_RBM_SW2_BM , + }, + { + .wbm_ring_num =4 , + .rbm_id =HAL_RX_BUF_RBM_SW4_BM , + }, +}; + +static bool ath12k_hw_qcn9274_rx_desc_get_first_msdu (struct hal_rx_desc *desc) +{ +return !!le16_get_bits (desc->u.qcn9274.msdu_end.info5, +RX_MSDU_END_INFO5_FIRST_MSDU ); +} + +static bool ath12k_hw_qcn9274_rx_desc_get_last_msdu (struct hal_rx_desc *desc) +{ +return !!le16_get_bits (desc->u.qcn9274.msdu_end.info5, +RX_MSDU_END_INFO5_LAST_MSDU ); +} + +static u8 ath12k_hw_qcn9274_rx_desc_get_l3_pad_bytes (struct hal_rx_desc *desc) +{ +return le16_get_bits (desc->u.qcn9274.msdu_end.info5, +RX_MSDU_END_INFO5_L3_HDR_PADDING ); +} + +static bool ath12k_hw_qcn9274_rx_desc_encrypt_valid (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.qcn9274.mpdu_start.info4, +RX_MPDU_START_INFO4_ENCRYPT_INFO_VALID ); +} + +static u32 ath12k_hw_qcn9274_rx_desc_get_encrypt_type (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.mpdu_start.info2, +RX_MPDU_START_INFO2_ENC_TYPE ); +} + +static u8 ath12k_hw_qcn9274_rx_desc_get_decap_type (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.msdu_end.info11, +RX_MSDU_END_INFO11_DECAP_FORMAT ); +} + +static u8 ath12k_hw_qcn9274_rx_desc_get_mesh_ctl (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.msdu_end.info11, +RX_MSDU_END_INFO11_MESH_CTRL_PRESENT ); +} + +static bool ath12k_hw_qcn9274_rx_desc_get_mpdu_seq_ctl_vld (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.qcn9274.mpdu_start.info4, +RX_MPDU_START_INFO4_MPDU_SEQ_CTRL_VALID ); +} + +static bool ath12k_hw_qcn9274_rx_desc_get_mpdu_fc_valid (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.qcn9274.mpdu_start.info4, +RX_MPDU_START_INFO4_MPDU_FCTRL_VALID ); +} + +static u16 ath12k_hw_qcn9274_rx_desc_get_mpdu_start_seq_no (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.mpdu_start.info4, +RX_MPDU_START_INFO4_MPDU_SEQ_NUM ); +} + +static u16 ath12k_hw_qcn9274_rx_desc_get_msdu_len (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.msdu_end.info10, +RX_MSDU_END_INFO10_MSDU_LENGTH ); +} + +static u8 ath12k_hw_qcn9274_rx_desc_get_msdu_sgi (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.msdu_end.info12, +RX_MSDU_END_INFO12_SGI ); +} + +static u8 ath12k_hw_qcn9274_rx_desc_get_msdu_rate_mcs (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.msdu_end.info12, +RX_MSDU_END_INFO12_RATE_MCS ); +} + +static u8 ath12k_hw_qcn9274_rx_desc_get_msdu_rx_bw (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.msdu_end.info12, +RX_MSDU_END_INFO12_RECV_BW ); +} + +static u32 ath12k_hw_qcn9274_rx_desc_get_msdu_freq (struct hal_rx_desc *desc) +{ +return __le32_to_cpu (desc->u.qcn9274.msdu_end.phy_meta_data); +} + +static u8 ath12k_hw_qcn9274_rx_desc_get_msdu_pkt_type (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.msdu_end.info12, +RX_MSDU_END_INFO12_PKT_TYPE ); +} + +static u8 ath12k_hw_qcn9274_rx_desc_get_msdu_nss (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.qcn9274.msdu_end.info12, +RX_MSDU_END_INFO12_MIMO_SS_BITMAP ); +} + +static u8 ath12k_hw_qcn9274_rx_desc_get_mpdu_tid (struct hal_rx_desc *desc) +{ +return le16_get_bits (desc->u.qcn9274.msdu_end.info5, +RX_MSDU_END_INFO5_TID ); +} + +static u16 ath12k_hw_qcn9274_rx_desc_get_mpdu_peer_id (struct hal_rx_desc *desc) +{ +return __le16_to_cpu (desc->u.qcn9274.mpdu_start.sw_peer_id); +} + +static void ath12k_hw_qcn9274_rx_desc_copy_end_tlv (struct hal_rx_desc *fdesc, +struct hal_rx_desc *ldesc) +{ +memcpy (&fdesc->u.qcn9274.msdu_end, &ldesc->u.qcn9274.msdu_end, +sizeof (struct rx_msdu_end_qcn9274 )); +} + +static u32 ath12k_hw_qcn9274_rx_desc_get_mpdu_ppdu_id (struct hal_rx_desc *desc) +{ +return __le16_to_cpu (desc->u.qcn9274.mpdu_start.phy_ppdu_id); +} + +static void ath12k_hw_qcn9274_rx_desc_set_msdu_len (struct hal_rx_desc *desc,u16 len) +{ +u32 info =__le32_to_cpu (desc->u.qcn9274.msdu_end.info10); + + info &= ~RX_MSDU_END_INFO10_MSDU_LENGTH ; + info |=u32_encode_bits (len,RX_MSDU_END_INFO10_MSDU_LENGTH ); + + desc->u.qcn9274.msdu_end.info10 =__cpu_to_le32 (info); +} + +static u8 *ath12k_hw_qcn9274_rx_desc_get_msdu_payload (struct hal_rx_desc *desc) +{ +return &desc->u.qcn9274.msdu_payload[0 ]; +} + +static u32 ath12k_hw_qcn9274_rx_desc_get_mpdu_start_offset (void ) +{ +return offsetof(struct hal_rx_desc_qcn9274 , mpdu_start); +} + +static u32 ath12k_hw_qcn9274_rx_desc_get_msdu_end_offset (void ) +{ +return offsetof(struct hal_rx_desc_qcn9274 , msdu_end); +} + +static bool ath12k_hw_qcn9274_rx_desc_mac_addr2_valid (struct hal_rx_desc *desc) +{ +return __le32_to_cpu (desc->u.qcn9274.mpdu_start.info4) & +RX_MPDU_START_INFO4_MAC_ADDR2_VALID ; +} + +static u8 *ath12k_hw_qcn9274_rx_desc_mpdu_start_addr2 (struct hal_rx_desc *desc) +{ +return desc->u.qcn9274.mpdu_start.addr2; +} + +static bool ath12k_hw_qcn9274_rx_desc_is_mcbc (struct hal_rx_desc *desc) +{ +return __le32_to_cpu (desc->u.qcn9274.mpdu_start.info6) & +RX_MPDU_START_INFO6_MCAST_BCAST ; +} + +static void ath12k_hw_qcn9274_rx_desc_get_dot11_hdr (struct hal_rx_desc *desc, +struct ieee80211_hdr *hdr) +{ + hdr->frame_control = desc->u.qcn9274.mpdu_start.frame_ctrl; + hdr->duration_id = desc->u.qcn9274.mpdu_start.duration; +ether_addr_copy (hdr->addr1, desc->u.qcn9274.mpdu_start.addr1); +ether_addr_copy (hdr->addr2, desc->u.qcn9274.mpdu_start.addr2); +ether_addr_copy (hdr->addr3, desc->u.qcn9274.mpdu_start.addr3); +if (__le32_to_cpu (desc->u.qcn9274.mpdu_start.info4) & +RX_MPDU_START_INFO4_MAC_ADDR4_VALID ) { +ether_addr_copy (hdr->addr4, desc->u.qcn9274.mpdu_start.addr4); + } + hdr->seq_ctrl = desc->u.qcn9274.mpdu_start.seq_ctrl; +} + +static void ath12k_hw_qcn9274_rx_desc_get_crypto_hdr (struct hal_rx_desc *desc, +u8 *crypto_hdr, +enum hal_encrypt_type enctype) +{ +unsigned int key_id; + +switch (enctype) { +case HAL_ENCRYPT_TYPE_OPEN : +return ; +case HAL_ENCRYPT_TYPE_TKIP_NO_MIC : +case HAL_ENCRYPT_TYPE_TKIP_MIC : + crypto_hdr[0 ] = +HAL_RX_MPDU_INFO_PN_GET_BYTE2 (desc->u.qcn9274.mpdu_start.pn[0 ]); + crypto_hdr[1 ] =0 ; + crypto_hdr[2 ] = +HAL_RX_MPDU_INFO_PN_GET_BYTE1 (desc->u.qcn9274.mpdu_start.pn[0 ]); +break ; +case HAL_ENCRYPT_TYPE_CCMP_128 : +case HAL_ENCRYPT_TYPE_CCMP_256 : +case HAL_ENCRYPT_TYPE_GCMP_128 : +case HAL_ENCRYPT_TYPE_AES_GCMP_256 : + crypto_hdr[0 ] = +HAL_RX_MPDU_INFO_PN_GET_BYTE1 (desc->u.qcn9274.mpdu_start.pn[0 ]); + crypto_hdr[1 ] = +HAL_RX_MPDU_INFO_PN_GET_BYTE2 (desc->u.qcn9274.mpdu_start.pn[0 ]); + crypto_hdr[2 ] =0 ; +break ; +case HAL_ENCRYPT_TYPE_WEP_40 : +case HAL_ENCRYPT_TYPE_WEP_104 : +case HAL_ENCRYPT_TYPE_WEP_128 : +case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4 : +case HAL_ENCRYPT_TYPE_WAPI : +return ; + } + key_id =le32_get_bits (desc->u.qcn9274.mpdu_start.info5, +RX_MPDU_START_INFO5_KEY_ID ); + crypto_hdr[3 ] =0x20 | (key_id <<6 ); + crypto_hdr[4 ] =HAL_RX_MPDU_INFO_PN_GET_BYTE3 (desc->u.qcn9274.mpdu_start.pn[0 ]); + crypto_hdr[5 ] =HAL_RX_MPDU_INFO_PN_GET_BYTE4 (desc->u.qcn9274.mpdu_start.pn[0 ]); + crypto_hdr[6 ] =HAL_RX_MPDU_INFO_PN_GET_BYTE1 (desc->u.qcn9274.mpdu_start.pn[1 ]); + crypto_hdr[7 ] =HAL_RX_MPDU_INFO_PN_GET_BYTE2 (desc->u.qcn9274.mpdu_start.pn[1 ]); +} + +static u16 ath12k_hw_qcn9274_rx_desc_get_mpdu_frame_ctl (struct hal_rx_desc *desc) +{ +return __le16_to_cpu (desc->u.qcn9274.mpdu_start.frame_ctrl); +} + +static int ath12k_hal_srng_create_config_qcn9274 (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +struct hal_srng_config *s; + + hal->srng_config =kmemdup (hw_srng_config_template, +sizeof (hw_srng_config_template), +GFP_KERNEL ); +if (!hal->srng_config) +return -ENOMEM ; + + s = &hal->srng_config[HAL_REO_DST ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO1_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO1_RING_HP ; + s->reg_size[0 ] =HAL_REO2_RING_BASE_LSB (ab) -HAL_REO1_RING_BASE_LSB (ab); + s->reg_size[1 ] =HAL_REO2_RING_HP -HAL_REO1_RING_HP ; + + s = &hal->srng_config[HAL_REO_EXCEPTION ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_SW0_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_SW0_RING_HP ; + + s = &hal->srng_config[HAL_REO_REINJECT ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_SW2REO_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_SW2REO_RING_HP ; + s->reg_size[0 ] =HAL_SW2REO1_RING_BASE_LSB (ab) -HAL_SW2REO_RING_BASE_LSB (ab); + s->reg_size[1 ] =HAL_SW2REO1_RING_HP -HAL_SW2REO_RING_HP ; + + s = &hal->srng_config[HAL_REO_CMD ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_CMD_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_CMD_HP ; + + s = &hal->srng_config[HAL_REO_STATUS ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_STATUS_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_STATUS_HP ; + + s = &hal->srng_config[HAL_TCL_DATA ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL1_RING_BASE_LSB ; + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL1_RING_HP ; + s->reg_size[0 ] =HAL_TCL2_RING_BASE_LSB -HAL_TCL1_RING_BASE_LSB ; + s->reg_size[1 ] =HAL_TCL2_RING_HP -HAL_TCL1_RING_HP ; + + s = &hal->srng_config[HAL_TCL_CMD ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_RING_HP ; + + s = &hal->srng_config[HAL_TCL_STATUS ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_STATUS_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_STATUS_RING_HP ; + + s = &hal->srng_config[HAL_CE_SRC ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_CE0_SRC_REG +HAL_CE_DST_RING_BASE_LSB ; + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_CE0_SRC_REG +HAL_CE_DST_RING_HP ; + s->reg_size[0 ] =HAL_SEQ_WCSS_UMAC_CE1_SRC_REG - +HAL_SEQ_WCSS_UMAC_CE0_SRC_REG ; + s->reg_size[1 ] =HAL_SEQ_WCSS_UMAC_CE1_SRC_REG - +HAL_SEQ_WCSS_UMAC_CE0_SRC_REG ; + + s = &hal->srng_config[HAL_CE_DST ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_CE0_DST_REG +HAL_CE_DST_RING_BASE_LSB ; + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_CE0_DST_REG +HAL_CE_DST_RING_HP ; + s->reg_size[0 ] =HAL_SEQ_WCSS_UMAC_CE1_DST_REG - +HAL_SEQ_WCSS_UMAC_CE0_DST_REG ; + s->reg_size[1 ] =HAL_SEQ_WCSS_UMAC_CE1_DST_REG - +HAL_SEQ_WCSS_UMAC_CE0_DST_REG ; + + s = &hal->srng_config[HAL_CE_DST_STATUS ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_CE0_DST_REG + +HAL_CE_DST_STATUS_RING_BASE_LSB ; + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_CE0_DST_REG +HAL_CE_DST_STATUS_RING_HP ; + s->reg_size[0 ] =HAL_SEQ_WCSS_UMAC_CE1_DST_REG - +HAL_SEQ_WCSS_UMAC_CE0_DST_REG ; + s->reg_size[1 ] =HAL_SEQ_WCSS_UMAC_CE1_DST_REG - +HAL_SEQ_WCSS_UMAC_CE0_DST_REG ; + + s = &hal->srng_config[HAL_WBM_IDLE_LINK ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM_IDLE_LINK_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM_IDLE_LINK_RING_HP ; + + s = &hal->srng_config[HAL_SW2WBM_RELEASE ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SW_RELEASE_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM_SW_RELEASE_RING_HP ; + s->reg_size[0 ] =HAL_WBM_SW1_RELEASE_RING_BASE_LSB (ab) - +HAL_WBM_SW_RELEASE_RING_BASE_LSB (ab); + s->reg_size[1 ] =HAL_WBM_SW1_RELEASE_RING_HP -HAL_WBM_SW_RELEASE_RING_HP ; + + s = &hal->srng_config[HAL_WBM2SW_RELEASE ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM0_RELEASE_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM0_RELEASE_RING_HP ; + s->reg_size[0 ] =HAL_WBM1_RELEASE_RING_BASE_LSB (ab) - +HAL_WBM0_RELEASE_RING_BASE_LSB (ab); + s->reg_size[1 ] =HAL_WBM1_RELEASE_RING_HP -HAL_WBM0_RELEASE_RING_HP ; + +/* Some LMAC rings are not accesed from the host: +* RXDMA_BUG, RXDMA_DST, RXDMA_MONITOR_BUF, RXDMA_MONITOR_STATUS, +* RXDMA_MONITOR_DST, RXDMA_MONITOR_DESC, RXDMA_DIR_BUF_SRC, +* RXDMA_RX_MONITOR_BUF, TX_MONITOR_BUF, TX_MONITOR_DST, SW2RXDMA +*/ + s = &hal->srng_config[HAL_PPE2TCL ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_PPE2TCL1_RING_BASE_LSB ; + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_PPE2TCL1_RING_HP ; + + s = &hal->srng_config[HAL_PPE_RELEASE ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_PPE_RELEASE_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM_PPE_RELEASE_RING_HP ; + +return 0 ; +} + +static bool ath12k_hw_qcn9274_dp_rx_h_msdu_done (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.qcn9274.msdu_end.info14, +RX_MSDU_END_INFO14_MSDU_DONE ); +} + +static bool ath12k_hw_qcn9274_dp_rx_h_l4_cksum_fail (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.qcn9274.msdu_end.info13, +RX_MSDU_END_INFO13_TCP_UDP_CKSUM_FAIL ); +} + +static bool ath12k_hw_qcn9274_dp_rx_h_ip_cksum_fail (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.qcn9274.msdu_end.info13, +RX_MSDU_END_INFO13_IP_CKSUM_FAIL ); +} + +static bool ath12k_hw_qcn9274_dp_rx_h_is_decrypted (struct hal_rx_desc *desc) +{ +return (le32_get_bits (desc->u.qcn9274.msdu_end.info14, +RX_MSDU_END_INFO14_DECRYPT_STATUS_CODE ) == +RX_DESC_DECRYPT_STATUS_CODE_OK ); +} + +static u32 ath12k_hw_qcn9274_dp_rx_h_mpdu_err (struct hal_rx_desc *desc) +{ +u32 info =__le32_to_cpu (desc->u.qcn9274.msdu_end.info13); +u32 errmap =0 ; + +if (info &RX_MSDU_END_INFO13_FCS_ERR ) + errmap |=HAL_RX_MPDU_ERR_FCS ; + +if (info &RX_MSDU_END_INFO13_DECRYPT_ERR ) + errmap |=HAL_RX_MPDU_ERR_DECRYPT ; + +if (info &RX_MSDU_END_INFO13_TKIP_MIC_ERR ) + errmap |=HAL_RX_MPDU_ERR_TKIP_MIC ; + +if (info &RX_MSDU_END_INFO13_A_MSDU_ERROR ) + errmap |=HAL_RX_MPDU_ERR_AMSDU_ERR ; + +if (info &RX_MSDU_END_INFO13_OVERFLOW_ERR ) + errmap |=HAL_RX_MPDU_ERR_OVERFLOW ; + +if (info &RX_MSDU_END_INFO13_MSDU_LEN_ERR ) + errmap |=HAL_RX_MPDU_ERR_MSDU_LEN ; + +if (info &RX_MSDU_END_INFO13_MPDU_LEN_ERR ) + errmap |=HAL_RX_MPDU_ERR_MPDU_LEN ; + +return errmap; +} + +const struct hal_ops hal_qcn9274_ops = { + .rx_desc_get_first_msdu = ath12k_hw_qcn9274_rx_desc_get_first_msdu, + .rx_desc_get_last_msdu = ath12k_hw_qcn9274_rx_desc_get_last_msdu, + .rx_desc_get_l3_pad_bytes = ath12k_hw_qcn9274_rx_desc_get_l3_pad_bytes, + .rx_desc_encrypt_valid = ath12k_hw_qcn9274_rx_desc_encrypt_valid, + .rx_desc_get_encrypt_type = ath12k_hw_qcn9274_rx_desc_get_encrypt_type, + .rx_desc_get_decap_type = ath12k_hw_qcn9274_rx_desc_get_decap_type, + .rx_desc_get_mesh_ctl = ath12k_hw_qcn9274_rx_desc_get_mesh_ctl, + .rx_desc_get_mpdu_seq_ctl_vld = ath12k_hw_qcn9274_rx_desc_get_mpdu_seq_ctl_vld, + .rx_desc_get_mpdu_fc_valid = ath12k_hw_qcn9274_rx_desc_get_mpdu_fc_valid, + .rx_desc_get_mpdu_start_seq_no = ath12k_hw_qcn9274_rx_desc_get_mpdu_start_seq_no, + .rx_desc_get_msdu_len = ath12k_hw_qcn9274_rx_desc_get_msdu_len, + .rx_desc_get_msdu_sgi = ath12k_hw_qcn9274_rx_desc_get_msdu_sgi, + .rx_desc_get_msdu_rate_mcs = ath12k_hw_qcn9274_rx_desc_get_msdu_rate_mcs, + .rx_desc_get_msdu_rx_bw = ath12k_hw_qcn9274_rx_desc_get_msdu_rx_bw, + .rx_desc_get_msdu_freq = ath12k_hw_qcn9274_rx_desc_get_msdu_freq, + .rx_desc_get_msdu_pkt_type = ath12k_hw_qcn9274_rx_desc_get_msdu_pkt_type, + .rx_desc_get_msdu_nss = ath12k_hw_qcn9274_rx_desc_get_msdu_nss, + .rx_desc_get_mpdu_tid = ath12k_hw_qcn9274_rx_desc_get_mpdu_tid, + .rx_desc_get_mpdu_peer_id = ath12k_hw_qcn9274_rx_desc_get_mpdu_peer_id, + .rx_desc_copy_end_tlv = ath12k_hw_qcn9274_rx_desc_copy_end_tlv, + .rx_desc_get_mpdu_ppdu_id = ath12k_hw_qcn9274_rx_desc_get_mpdu_ppdu_id, + .rx_desc_set_msdu_len = ath12k_hw_qcn9274_rx_desc_set_msdu_len, + .rx_desc_get_msdu_payload = ath12k_hw_qcn9274_rx_desc_get_msdu_payload, + .rx_desc_get_mpdu_start_offset = ath12k_hw_qcn9274_rx_desc_get_mpdu_start_offset, + .rx_desc_get_msdu_end_offset = ath12k_hw_qcn9274_rx_desc_get_msdu_end_offset, + .rx_desc_mac_addr2_valid = ath12k_hw_qcn9274_rx_desc_mac_addr2_valid, + .rx_desc_mpdu_start_addr2 = ath12k_hw_qcn9274_rx_desc_mpdu_start_addr2, + .rx_desc_is_mcbc = ath12k_hw_qcn9274_rx_desc_is_mcbc, + .rx_desc_get_dot11_hdr = ath12k_hw_qcn9274_rx_desc_get_dot11_hdr, + .rx_desc_get_crypto_header = ath12k_hw_qcn9274_rx_desc_get_crypto_hdr, + .rx_desc_get_mpdu_frame_ctl = ath12k_hw_qcn9274_rx_desc_get_mpdu_frame_ctl, + .create_srng_config = ath12k_hal_srng_create_config_qcn9274, + .tcl_to_wbm_rbm_map = ath12k_hal_qcn9274_tcl_to_wbm_rbm_map, + .dp_rx_h_msdu_done = ath12k_hw_qcn9274_dp_rx_h_msdu_done, + .dp_rx_h_l4_cksum_fail = ath12k_hw_qcn9274_dp_rx_h_l4_cksum_fail, + .dp_rx_h_ip_cksum_fail = ath12k_hw_qcn9274_dp_rx_h_ip_cksum_fail, + .dp_rx_h_is_decrypted = ath12k_hw_qcn9274_dp_rx_h_is_decrypted, + .dp_rx_h_mpdu_err = ath12k_hw_qcn9274_dp_rx_h_mpdu_err, +}; + +static bool ath12k_hw_wcn7850_rx_desc_get_first_msdu (struct hal_rx_desc *desc) +{ +return !!le16_get_bits (desc->u.wcn7850.msdu_end.info5, +RX_MSDU_END_INFO5_FIRST_MSDU ); +} + +static bool ath12k_hw_wcn7850_rx_desc_get_last_msdu (struct hal_rx_desc *desc) +{ +return !!le16_get_bits (desc->u.wcn7850.msdu_end.info5, +RX_MSDU_END_INFO5_LAST_MSDU ); +} + +static u8 ath12k_hw_wcn7850_rx_desc_get_l3_pad_bytes (struct hal_rx_desc *desc) +{ +return le16_get_bits (desc->u.wcn7850.msdu_end.info5, +RX_MSDU_END_INFO5_L3_HDR_PADDING ); +} + +static bool ath12k_hw_wcn7850_rx_desc_encrypt_valid (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.wcn7850.mpdu_start.info4, +RX_MPDU_START_INFO4_ENCRYPT_INFO_VALID ); +} + +static u32 ath12k_hw_wcn7850_rx_desc_get_encrypt_type (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.mpdu_start.info2, +RX_MPDU_START_INFO2_ENC_TYPE ); +} + +static u8 ath12k_hw_wcn7850_rx_desc_get_decap_type (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.msdu_end.info11, +RX_MSDU_END_INFO11_DECAP_FORMAT ); +} + +static u8 ath12k_hw_wcn7850_rx_desc_get_mesh_ctl (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.msdu_end.info11, +RX_MSDU_END_INFO11_MESH_CTRL_PRESENT ); +} + +static bool ath12k_hw_wcn7850_rx_desc_get_mpdu_seq_ctl_vld (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.wcn7850.mpdu_start.info4, +RX_MPDU_START_INFO4_MPDU_SEQ_CTRL_VALID ); +} + +static bool ath12k_hw_wcn7850_rx_desc_get_mpdu_fc_valid (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.wcn7850.mpdu_start.info4, +RX_MPDU_START_INFO4_MPDU_FCTRL_VALID ); +} + +static u16 ath12k_hw_wcn7850_rx_desc_get_mpdu_start_seq_no (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.mpdu_start.info4, +RX_MPDU_START_INFO4_MPDU_SEQ_NUM ); +} + +static u16 ath12k_hw_wcn7850_rx_desc_get_msdu_len (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.msdu_end.info10, +RX_MSDU_END_INFO10_MSDU_LENGTH ); +} + +static u8 ath12k_hw_wcn7850_rx_desc_get_msdu_sgi (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.msdu_end.info12, +RX_MSDU_END_INFO12_SGI ); +} + +static u8 ath12k_hw_wcn7850_rx_desc_get_msdu_rate_mcs (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.msdu_end.info12, +RX_MSDU_END_INFO12_RATE_MCS ); +} + +static u8 ath12k_hw_wcn7850_rx_desc_get_msdu_rx_bw (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.msdu_end.info12, +RX_MSDU_END_INFO12_RECV_BW ); +} + +static u32 ath12k_hw_wcn7850_rx_desc_get_msdu_freq (struct hal_rx_desc *desc) +{ +return __le32_to_cpu (desc->u.wcn7850.msdu_end.phy_meta_data); +} + +static u8 ath12k_hw_wcn7850_rx_desc_get_msdu_pkt_type (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.msdu_end.info12, +RX_MSDU_END_INFO12_PKT_TYPE ); +} + +static u8 ath12k_hw_wcn7850_rx_desc_get_msdu_nss (struct hal_rx_desc *desc) +{ +return le32_get_bits (desc->u.wcn7850.msdu_end.info12, +RX_MSDU_END_INFO12_MIMO_SS_BITMAP ); +} + +static u8 ath12k_hw_wcn7850_rx_desc_get_mpdu_tid (struct hal_rx_desc *desc) +{ +return le16_get_bits (desc->u.wcn7850.msdu_end.info5, +RX_MSDU_END_INFO5_TID ); +} + +static u16 ath12k_hw_wcn7850_rx_desc_get_mpdu_peer_id (struct hal_rx_desc *desc) +{ +return __le16_to_cpu (desc->u.wcn7850.mpdu_start.sw_peer_id); +} + +static void ath12k_hw_wcn7850_rx_desc_copy_end_tlv (struct hal_rx_desc *fdesc, +struct hal_rx_desc *ldesc) +{ +memcpy (&fdesc->u.wcn7850.msdu_end, &ldesc->u.wcn7850.msdu_end, +sizeof (struct rx_msdu_end_qcn9274 )); +} + +static u32 ath12k_hw_wcn7850_rx_desc_get_mpdu_start_tag (struct hal_rx_desc *desc) +{ +return le64_get_bits (desc->u.wcn7850.mpdu_start_tag, +HAL_TLV_HDR_TAG ); +} + +static u32 ath12k_hw_wcn7850_rx_desc_get_mpdu_ppdu_id (struct hal_rx_desc *desc) +{ +return __le16_to_cpu (desc->u.wcn7850.mpdu_start.phy_ppdu_id); +} + +static void ath12k_hw_wcn7850_rx_desc_set_msdu_len (struct hal_rx_desc *desc,u16 len) +{ +u32 info =__le32_to_cpu (desc->u.wcn7850.msdu_end.info10); + + info &= ~RX_MSDU_END_INFO10_MSDU_LENGTH ; + info |=u32_encode_bits (len,RX_MSDU_END_INFO10_MSDU_LENGTH ); + + desc->u.wcn7850.msdu_end.info10 =__cpu_to_le32 (info); +} + +static u8 *ath12k_hw_wcn7850_rx_desc_get_msdu_payload (struct hal_rx_desc *desc) +{ +return &desc->u.wcn7850.msdu_payload[0 ]; +} + +static u32 ath12k_hw_wcn7850_rx_desc_get_mpdu_start_offset (void ) +{ +return offsetof(struct hal_rx_desc_wcn7850 , mpdu_start_tag); +} + +static u32 ath12k_hw_wcn7850_rx_desc_get_msdu_end_offset (void ) +{ +return offsetof(struct hal_rx_desc_wcn7850 , msdu_end_tag); +} + +static bool ath12k_hw_wcn7850_rx_desc_mac_addr2_valid (struct hal_rx_desc *desc) +{ +return __le32_to_cpu (desc->u.wcn7850.mpdu_start.info4) & +RX_MPDU_START_INFO4_MAC_ADDR2_VALID ; +} + +static u8 *ath12k_hw_wcn7850_rx_desc_mpdu_start_addr2 (struct hal_rx_desc *desc) +{ +return desc->u.wcn7850.mpdu_start.addr2; +} + +static bool ath12k_hw_wcn7850_rx_desc_is_mcbc (struct hal_rx_desc *desc) +{ +return __le32_to_cpu (desc->u.wcn7850.mpdu_start.info6) & +RX_MPDU_START_INFO6_MCAST_BCAST ; +} + +static void ath12k_hw_wcn7850_rx_desc_get_dot11_hdr (struct hal_rx_desc *desc, +struct ieee80211_hdr *hdr) +{ + hdr->frame_control = desc->u.wcn7850.mpdu_start.frame_ctrl; + hdr->duration_id = desc->u.wcn7850.mpdu_start.duration; +ether_addr_copy (hdr->addr1, desc->u.wcn7850.mpdu_start.addr1); +ether_addr_copy (hdr->addr2, desc->u.wcn7850.mpdu_start.addr2); +ether_addr_copy (hdr->addr3, desc->u.wcn7850.mpdu_start.addr3); +if (__le32_to_cpu (desc->u.wcn7850.mpdu_start.info4) & +RX_MPDU_START_INFO4_MAC_ADDR4_VALID ) { +ether_addr_copy (hdr->addr4, desc->u.wcn7850.mpdu_start.addr4); + } + hdr->seq_ctrl = desc->u.wcn7850.mpdu_start.seq_ctrl; +} + +static void ath12k_hw_wcn7850_rx_desc_get_crypto_hdr (struct hal_rx_desc *desc, +u8 *crypto_hdr, +enum hal_encrypt_type enctype) +{ +unsigned int key_id; + +switch (enctype) { +case HAL_ENCRYPT_TYPE_OPEN : +return ; +case HAL_ENCRYPT_TYPE_TKIP_NO_MIC : +case HAL_ENCRYPT_TYPE_TKIP_MIC : + crypto_hdr[0 ] = +HAL_RX_MPDU_INFO_PN_GET_BYTE2 (desc->u.wcn7850.mpdu_start.pn[0 ]); + crypto_hdr[1 ] =0 ; + crypto_hdr[2 ] = +HAL_RX_MPDU_INFO_PN_GET_BYTE1 (desc->u.wcn7850.mpdu_start.pn[0 ]); +break ; +case HAL_ENCRYPT_TYPE_CCMP_128 : +case HAL_ENCRYPT_TYPE_CCMP_256 : +case HAL_ENCRYPT_TYPE_GCMP_128 : +case HAL_ENCRYPT_TYPE_AES_GCMP_256 : + crypto_hdr[0 ] = +HAL_RX_MPDU_INFO_PN_GET_BYTE1 (desc->u.wcn7850.mpdu_start.pn[0 ]); + crypto_hdr[1 ] = +HAL_RX_MPDU_INFO_PN_GET_BYTE2 (desc->u.wcn7850.mpdu_start.pn[0 ]); + crypto_hdr[2 ] =0 ; +break ; +case HAL_ENCRYPT_TYPE_WEP_40 : +case HAL_ENCRYPT_TYPE_WEP_104 : +case HAL_ENCRYPT_TYPE_WEP_128 : +case HAL_ENCRYPT_TYPE_WAPI_GCM_SM4 : +case HAL_ENCRYPT_TYPE_WAPI : +return ; + } + key_id =u32_get_bits (__le32_to_cpu (desc->u.wcn7850.mpdu_start.info5), +RX_MPDU_START_INFO5_KEY_ID ); + crypto_hdr[3 ] =0x20 | (key_id <<6 ); + crypto_hdr[4 ] =HAL_RX_MPDU_INFO_PN_GET_BYTE3 (desc->u.wcn7850.mpdu_start.pn[0 ]); + crypto_hdr[5 ] =HAL_RX_MPDU_INFO_PN_GET_BYTE4 (desc->u.wcn7850.mpdu_start.pn[0 ]); + crypto_hdr[6 ] =HAL_RX_MPDU_INFO_PN_GET_BYTE1 (desc->u.wcn7850.mpdu_start.pn[1 ]); + crypto_hdr[7 ] =HAL_RX_MPDU_INFO_PN_GET_BYTE2 (desc->u.wcn7850.mpdu_start.pn[1 ]); +} + +static u16 ath12k_hw_wcn7850_rx_desc_get_mpdu_frame_ctl (struct hal_rx_desc *desc) +{ +return __le16_to_cpu (desc->u.wcn7850.mpdu_start.frame_ctrl); +} + +static int ath12k_hal_srng_create_config_wcn7850 (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +struct hal_srng_config *s; + + hal->srng_config =kmemdup (hw_srng_config_template, +sizeof (hw_srng_config_template), +GFP_KERNEL ); +if (!hal->srng_config) +return -ENOMEM ; + + s = &hal->srng_config[HAL_REO_DST ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO1_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO1_RING_HP ; + s->reg_size[0 ] =HAL_REO2_RING_BASE_LSB (ab) -HAL_REO1_RING_BASE_LSB (ab); + s->reg_size[1 ] =HAL_REO2_RING_HP -HAL_REO1_RING_HP ; + + s = &hal->srng_config[HAL_REO_EXCEPTION ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_SW0_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_SW0_RING_HP ; + + s = &hal->srng_config[HAL_REO_REINJECT ]; + s->max_rings =1 ; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_SW2REO_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_SW2REO_RING_HP ; + + s = &hal->srng_config[HAL_REO_CMD ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_CMD_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_CMD_HP ; + + s = &hal->srng_config[HAL_REO_STATUS ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_STATUS_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_REO_REG +HAL_REO_STATUS_HP ; + + s = &hal->srng_config[HAL_TCL_DATA ]; + s->max_rings =5 ; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL1_RING_BASE_LSB ; + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL1_RING_HP ; + s->reg_size[0 ] =HAL_TCL2_RING_BASE_LSB -HAL_TCL1_RING_BASE_LSB ; + s->reg_size[1 ] =HAL_TCL2_RING_HP -HAL_TCL1_RING_HP ; + + s = &hal->srng_config[HAL_TCL_CMD ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_RING_HP ; + + s = &hal->srng_config[HAL_TCL_STATUS ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_STATUS_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL_STATUS_RING_HP ; + + s = &hal->srng_config[HAL_CE_SRC ]; + s->max_rings =12 ; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_CE0_SRC_REG +HAL_CE_DST_RING_BASE_LSB ; + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_CE0_SRC_REG +HAL_CE_DST_RING_HP ; + s->reg_size[0 ] =HAL_SEQ_WCSS_UMAC_CE1_SRC_REG - +HAL_SEQ_WCSS_UMAC_CE0_SRC_REG ; + s->reg_size[1 ] =HAL_SEQ_WCSS_UMAC_CE1_SRC_REG - +HAL_SEQ_WCSS_UMAC_CE0_SRC_REG ; + + s = &hal->srng_config[HAL_CE_DST ]; + s->max_rings =12 ; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_CE0_DST_REG +HAL_CE_DST_RING_BASE_LSB ; + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_CE0_DST_REG +HAL_CE_DST_RING_HP ; + s->reg_size[0 ] =HAL_SEQ_WCSS_UMAC_CE1_DST_REG - +HAL_SEQ_WCSS_UMAC_CE0_DST_REG ; + s->reg_size[1 ] =HAL_SEQ_WCSS_UMAC_CE1_DST_REG - +HAL_SEQ_WCSS_UMAC_CE0_DST_REG ; + + s = &hal->srng_config[HAL_CE_DST_STATUS ]; + s->max_rings =12 ; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_CE0_DST_REG + +HAL_CE_DST_STATUS_RING_BASE_LSB ; + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_CE0_DST_REG +HAL_CE_DST_STATUS_RING_HP ; + s->reg_size[0 ] =HAL_SEQ_WCSS_UMAC_CE1_DST_REG - +HAL_SEQ_WCSS_UMAC_CE0_DST_REG ; + s->reg_size[1 ] =HAL_SEQ_WCSS_UMAC_CE1_DST_REG - +HAL_SEQ_WCSS_UMAC_CE0_DST_REG ; + + s = &hal->srng_config[HAL_WBM_IDLE_LINK ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM_IDLE_LINK_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM_IDLE_LINK_RING_HP ; + + s = &hal->srng_config[HAL_SW2WBM_RELEASE ]; + s->max_rings =1 ; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SW_RELEASE_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM_SW_RELEASE_RING_HP ; + + s = &hal->srng_config[HAL_WBM2SW_RELEASE ]; + s->reg_start[0 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM0_RELEASE_RING_BASE_LSB (ab); + s->reg_start[1 ] =HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM0_RELEASE_RING_HP ; + s->reg_size[0 ] =HAL_WBM1_RELEASE_RING_BASE_LSB (ab) - +HAL_WBM0_RELEASE_RING_BASE_LSB (ab); + s->reg_size[1 ] =HAL_WBM1_RELEASE_RING_HP -HAL_WBM0_RELEASE_RING_HP ; + + s = &hal->srng_config[HAL_RXDMA_BUF ]; + s->max_rings =2 ; + s->mac_type =ATH12K_HAL_SRNG_PMAC ; + + s = &hal->srng_config[HAL_RXDMA_DST ]; + s->max_rings =1 ; + s->entry_size =sizeof (struct hal_reo_entrance_ring ) >>2 ; + +/* below rings are not used */ + s = &hal->srng_config[HAL_RXDMA_DIR_BUF ]; + s->max_rings =0 ; + + s = &hal->srng_config[HAL_PPE2TCL ]; + s->max_rings =0 ; + + s = &hal->srng_config[HAL_PPE_RELEASE ]; + s->max_rings =0 ; + + s = &hal->srng_config[HAL_TX_MONITOR_BUF ]; + s->max_rings =0 ; + + s = &hal->srng_config[HAL_TX_MONITOR_DST ]; + s->max_rings =0 ; + + s = &hal->srng_config[HAL_PPE2TCL ]; + s->max_rings =0 ; + +return 0 ; +} + +static bool ath12k_hw_wcn7850_dp_rx_h_msdu_done (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.wcn7850.msdu_end.info14, +RX_MSDU_END_INFO14_MSDU_DONE ); +} + +static bool ath12k_hw_wcn7850_dp_rx_h_l4_cksum_fail (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.wcn7850.msdu_end.info13, +RX_MSDU_END_INFO13_TCP_UDP_CKSUM_FAIL ); +} + +static bool ath12k_hw_wcn7850_dp_rx_h_ip_cksum_fail (struct hal_rx_desc *desc) +{ +return !!le32_get_bits (desc->u.wcn7850.msdu_end.info13, +RX_MSDU_END_INFO13_IP_CKSUM_FAIL ); +} + +static bool ath12k_hw_wcn7850_dp_rx_h_is_decrypted (struct hal_rx_desc *desc) +{ +return (le32_get_bits (desc->u.wcn7850.msdu_end.info14, +RX_MSDU_END_INFO14_DECRYPT_STATUS_CODE ) == +RX_DESC_DECRYPT_STATUS_CODE_OK ); +} + +static u32 ath12k_hw_wcn7850_dp_rx_h_mpdu_err (struct hal_rx_desc *desc) +{ +u32 info =__le32_to_cpu (desc->u.wcn7850.msdu_end.info13); +u32 errmap =0 ; + +if (info &RX_MSDU_END_INFO13_FCS_ERR ) + errmap |=HAL_RX_MPDU_ERR_FCS ; + +if (info &RX_MSDU_END_INFO13_DECRYPT_ERR ) + errmap |=HAL_RX_MPDU_ERR_DECRYPT ; + +if (info &RX_MSDU_END_INFO13_TKIP_MIC_ERR ) + errmap |=HAL_RX_MPDU_ERR_TKIP_MIC ; + +if (info &RX_MSDU_END_INFO13_A_MSDU_ERROR ) + errmap |=HAL_RX_MPDU_ERR_AMSDU_ERR ; + +if (info &RX_MSDU_END_INFO13_OVERFLOW_ERR ) + errmap |=HAL_RX_MPDU_ERR_OVERFLOW ; + +if (info &RX_MSDU_END_INFO13_MSDU_LEN_ERR ) + errmap |=HAL_RX_MPDU_ERR_MSDU_LEN ; + +if (info &RX_MSDU_END_INFO13_MPDU_LEN_ERR ) + errmap |=HAL_RX_MPDU_ERR_MPDU_LEN ; + +return errmap; +} + +const struct hal_ops hal_wcn7850_ops = { + .rx_desc_get_first_msdu = ath12k_hw_wcn7850_rx_desc_get_first_msdu, + .rx_desc_get_last_msdu = ath12k_hw_wcn7850_rx_desc_get_last_msdu, + .rx_desc_get_l3_pad_bytes = ath12k_hw_wcn7850_rx_desc_get_l3_pad_bytes, + .rx_desc_encrypt_valid = ath12k_hw_wcn7850_rx_desc_encrypt_valid, + .rx_desc_get_encrypt_type = ath12k_hw_wcn7850_rx_desc_get_encrypt_type, + .rx_desc_get_decap_type = ath12k_hw_wcn7850_rx_desc_get_decap_type, + .rx_desc_get_mesh_ctl = ath12k_hw_wcn7850_rx_desc_get_mesh_ctl, + .rx_desc_get_mpdu_seq_ctl_vld = ath12k_hw_wcn7850_rx_desc_get_mpdu_seq_ctl_vld, + .rx_desc_get_mpdu_fc_valid = ath12k_hw_wcn7850_rx_desc_get_mpdu_fc_valid, + .rx_desc_get_mpdu_start_seq_no = ath12k_hw_wcn7850_rx_desc_get_mpdu_start_seq_no, + .rx_desc_get_msdu_len = ath12k_hw_wcn7850_rx_desc_get_msdu_len, + .rx_desc_get_msdu_sgi = ath12k_hw_wcn7850_rx_desc_get_msdu_sgi, + .rx_desc_get_msdu_rate_mcs = ath12k_hw_wcn7850_rx_desc_get_msdu_rate_mcs, + .rx_desc_get_msdu_rx_bw = ath12k_hw_wcn7850_rx_desc_get_msdu_rx_bw, + .rx_desc_get_msdu_freq = ath12k_hw_wcn7850_rx_desc_get_msdu_freq, + .rx_desc_get_msdu_pkt_type = ath12k_hw_wcn7850_rx_desc_get_msdu_pkt_type, + .rx_desc_get_msdu_nss = ath12k_hw_wcn7850_rx_desc_get_msdu_nss, + .rx_desc_get_mpdu_tid = ath12k_hw_wcn7850_rx_desc_get_mpdu_tid, + .rx_desc_get_mpdu_peer_id = ath12k_hw_wcn7850_rx_desc_get_mpdu_peer_id, + .rx_desc_copy_end_tlv = ath12k_hw_wcn7850_rx_desc_copy_end_tlv, + .rx_desc_get_mpdu_start_tag = ath12k_hw_wcn7850_rx_desc_get_mpdu_start_tag, + .rx_desc_get_mpdu_ppdu_id = ath12k_hw_wcn7850_rx_desc_get_mpdu_ppdu_id, + .rx_desc_set_msdu_len = ath12k_hw_wcn7850_rx_desc_set_msdu_len, + .rx_desc_get_msdu_payload = ath12k_hw_wcn7850_rx_desc_get_msdu_payload, + .rx_desc_get_mpdu_start_offset = ath12k_hw_wcn7850_rx_desc_get_mpdu_start_offset, + .rx_desc_get_msdu_end_offset = ath12k_hw_wcn7850_rx_desc_get_msdu_end_offset, + .rx_desc_mac_addr2_valid = ath12k_hw_wcn7850_rx_desc_mac_addr2_valid, + .rx_desc_mpdu_start_addr2 = ath12k_hw_wcn7850_rx_desc_mpdu_start_addr2, + .rx_desc_is_mcbc = ath12k_hw_wcn7850_rx_desc_is_mcbc, + .rx_desc_get_dot11_hdr = ath12k_hw_wcn7850_rx_desc_get_dot11_hdr, + .rx_desc_get_crypto_header = ath12k_hw_wcn7850_rx_desc_get_crypto_hdr, + .rx_desc_get_mpdu_frame_ctl = ath12k_hw_wcn7850_rx_desc_get_mpdu_frame_ctl, + .create_srng_config = ath12k_hal_srng_create_config_wcn7850, + .tcl_to_wbm_rbm_map = ath12k_hal_wcn7850_tcl_to_wbm_rbm_map, + .dp_rx_h_msdu_done = ath12k_hw_wcn7850_dp_rx_h_msdu_done, + .dp_rx_h_l4_cksum_fail = ath12k_hw_wcn7850_dp_rx_h_l4_cksum_fail, + .dp_rx_h_ip_cksum_fail = ath12k_hw_wcn7850_dp_rx_h_ip_cksum_fail, + .dp_rx_h_is_decrypted = ath12k_hw_wcn7850_dp_rx_h_is_decrypted, + .dp_rx_h_mpdu_err = ath12k_hw_wcn7850_dp_rx_h_mpdu_err, +}; + +static int ath12k_hal_alloc_cont_rdp (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +size_t size; + + size =sizeof (u32) *HAL_SRNG_RING_ID_MAX ; + hal->rdp.vaddr =dma_alloc_coherent (ab->dev, size, &hal->rdp.paddr, +GFP_KERNEL ); +if (!hal->rdp.vaddr) +return -ENOMEM ; + +return 0 ; +} + +static void ath12k_hal_free_cont_rdp (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +size_t size; + +if (!hal->rdp.vaddr) +return ; + + size =sizeof (u32) *HAL_SRNG_RING_ID_MAX ; +dma_free_coherent (ab->dev, size, + hal->rdp.vaddr, hal->rdp.paddr); + hal->rdp.vaddr =NULL ; +} + +static int ath12k_hal_alloc_cont_wrp (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +size_t size; + + size =sizeof (u32) * (HAL_SRNG_NUM_PMAC_RINGS +HAL_SRNG_NUM_DMAC_RINGS ); + hal->wrp.vaddr =dma_alloc_coherent (ab->dev, size, &hal->wrp.paddr, +GFP_KERNEL ); +if (!hal->wrp.vaddr) +return -ENOMEM ; + +return 0 ; +} + +static void ath12k_hal_free_cont_wrp (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +size_t size; + +if (!hal->wrp.vaddr) +return ; + + size =sizeof (u32) * (HAL_SRNG_NUM_PMAC_RINGS +HAL_SRNG_NUM_DMAC_RINGS ); +dma_free_coherent (ab->dev, size, + hal->wrp.vaddr, hal->wrp.paddr); + hal->wrp.vaddr =NULL ; +} + +static void ath12k_hal_ce_dst_setup (struct ath12k_base *ab, +struct hal_srng *srng,int ring_num) +{ +struct hal_srng_config *srng_config = &ab->hal.srng_config[HAL_CE_DST ]; +u32 addr; +u32 val; + + addr =HAL_CE_DST_RING_CTRL + + srng_config->reg_start[HAL_SRNG_REG_GRP_R0 ] + + ring_num * srng_config->reg_size[HAL_SRNG_REG_GRP_R0 ]; + + val =ath12k_hif_read32 (ab, addr); + val &= ~HAL_CE_DST_R0_DEST_CTRL_MAX_LEN ; + val |=u32_encode_bits (srng->u.dst_ring.max_buffer_length, +HAL_CE_DST_R0_DEST_CTRL_MAX_LEN ); +ath12k_hif_write32 (ab, addr, val); +} + +static void ath12k_hal_srng_dst_hw_init (struct ath12k_base *ab, +struct hal_srng *srng) +{ +struct ath12k_hal *hal = &ab->hal; +u32 val; +u64 hp_addr; +u32 reg_base; + + reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R0 ]; + +if (srng->flags &HAL_SRNG_FLAGS_MSI_INTR ) { +ath12k_hif_write32 (ab, reg_base + +HAL_REO1_RING_MSI1_BASE_LSB_OFFSET , + srng->msi_addr); + + val =u32_encode_bits (((u64 )srng->msi_addr >>HAL_ADDR_MSB_REG_SHIFT ), +HAL_REO1_RING_MSI1_BASE_MSB_ADDR ) | +HAL_REO1_RING_MSI1_BASE_MSB_MSI1_ENABLE ; +ath12k_hif_write32 (ab, reg_base + +HAL_REO1_RING_MSI1_BASE_MSB_OFFSET , val); + +ath12k_hif_write32 (ab, + reg_base +HAL_REO1_RING_MSI1_DATA_OFFSET , + srng->msi_data); + } + +ath12k_hif_write32 (ab, reg_base, srng->ring_base_paddr); + + val =u32_encode_bits (((u64 )srng->ring_base_paddr >>HAL_ADDR_MSB_REG_SHIFT ), +HAL_REO1_RING_BASE_MSB_RING_BASE_ADDR_MSB ) | +u32_encode_bits ((srng->entry_size * srng->num_entries), +HAL_REO1_RING_BASE_MSB_RING_SIZE ); +ath12k_hif_write32 (ab, reg_base +HAL_REO1_RING_BASE_MSB_OFFSET , val); + + val =u32_encode_bits (srng->ring_id,HAL_REO1_RING_ID_RING_ID ) | +u32_encode_bits (srng->entry_size,HAL_REO1_RING_ID_ENTRY_SIZE ); +ath12k_hif_write32 (ab, reg_base +HAL_REO1_RING_ID_OFFSET (ab), val); + +/* interrupt setup */ + val =u32_encode_bits ((srng->intr_timer_thres_us >>3 ), +HAL_REO1_RING_PRDR_INT_SETUP_INTR_TMR_THOLD ); + + val |=u32_encode_bits ((srng->intr_batch_cntr_thres_entries * srng->entry_size), +HAL_REO1_RING_PRDR_INT_SETUP_BATCH_COUNTER_THOLD ); + +ath12k_hif_write32 (ab, + reg_base +HAL_REO1_RING_PRODUCER_INT_SETUP_OFFSET , + val); + + hp_addr = hal->rdp.paddr + + ((unsigned long )srng->u.dst_ring.hp_addr - + (unsigned long )hal->rdp.vaddr); +ath12k_hif_write32 (ab, reg_base +HAL_REO1_RING_HP_ADDR_LSB_OFFSET , + hp_addr &HAL_ADDR_LSB_REG_MASK ); +ath12k_hif_write32 (ab, reg_base +HAL_REO1_RING_HP_ADDR_MSB_OFFSET , + hp_addr >>HAL_ADDR_MSB_REG_SHIFT ); + +/* Initialize head and tail pointers to indicate ring is empty */ + reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R2 ]; +ath12k_hif_write32 (ab, reg_base,0 ); +ath12k_hif_write32 (ab, reg_base +HAL_REO1_RING_TP_OFFSET ,0 ); + *srng->u.dst_ring.hp_addr =0 ; + + reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R0 ]; + val =0 ; +if (srng->flags &HAL_SRNG_FLAGS_DATA_TLV_SWAP ) + val |=HAL_REO1_RING_MISC_DATA_TLV_SWAP ; +if (srng->flags &HAL_SRNG_FLAGS_RING_PTR_SWAP ) + val |=HAL_REO1_RING_MISC_HOST_FW_SWAP ; +if (srng->flags &HAL_SRNG_FLAGS_MSI_SWAP ) + val |=HAL_REO1_RING_MISC_MSI_SWAP ; + val |=HAL_REO1_RING_MISC_SRNG_ENABLE ; + +ath12k_hif_write32 (ab, reg_base +HAL_REO1_RING_MISC_OFFSET , val); +} + +static void ath12k_hal_srng_src_hw_init (struct ath12k_base *ab, +struct hal_srng *srng) +{ +struct ath12k_hal *hal = &ab->hal; +u32 val; +u64 tp_addr; +u32 reg_base; + + reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R0 ]; + +if (srng->flags &HAL_SRNG_FLAGS_MSI_INTR ) { +ath12k_hif_write32 (ab, reg_base + +HAL_TCL1_RING_MSI1_BASE_LSB_OFFSET (ab), + srng->msi_addr); + + val =u32_encode_bits (((u64 )srng->msi_addr >>HAL_ADDR_MSB_REG_SHIFT ), +HAL_TCL1_RING_MSI1_BASE_MSB_ADDR ) | +HAL_TCL1_RING_MSI1_BASE_MSB_MSI1_ENABLE ; +ath12k_hif_write32 (ab, reg_base + +HAL_TCL1_RING_MSI1_BASE_MSB_OFFSET (ab), + val); + +ath12k_hif_write32 (ab, reg_base + +HAL_TCL1_RING_MSI1_DATA_OFFSET (ab), + srng->msi_data); + } + +ath12k_hif_write32 (ab, reg_base, srng->ring_base_paddr); + + val =u32_encode_bits (((u64 )srng->ring_base_paddr >>HAL_ADDR_MSB_REG_SHIFT ), +HAL_TCL1_RING_BASE_MSB_RING_BASE_ADDR_MSB ) | +u32_encode_bits ((srng->entry_size * srng->num_entries), +HAL_TCL1_RING_BASE_MSB_RING_SIZE ); +ath12k_hif_write32 (ab, reg_base +HAL_TCL1_RING_BASE_MSB_OFFSET , val); + + val =u32_encode_bits (srng->entry_size,HAL_REO1_RING_ID_ENTRY_SIZE ); +ath12k_hif_write32 (ab, reg_base +HAL_TCL1_RING_ID_OFFSET (ab), val); + + val =u32_encode_bits (srng->intr_timer_thres_us, +HAL_TCL1_RING_CONSR_INT_SETUP_IX0_INTR_TMR_THOLD ); + + val |=u32_encode_bits ((srng->intr_batch_cntr_thres_entries * srng->entry_size), +HAL_TCL1_RING_CONSR_INT_SETUP_IX0_BATCH_COUNTER_THOLD ); + +ath12k_hif_write32 (ab, + reg_base +HAL_TCL1_RING_CONSR_INT_SETUP_IX0_OFFSET (ab), + val); + + val =0 ; +if (srng->flags &HAL_SRNG_FLAGS_LOW_THRESH_INTR_EN ) { + val |=u32_encode_bits (srng->u.src_ring.low_threshold, +HAL_TCL1_RING_CONSR_INT_SETUP_IX1_LOW_THOLD ); + } +ath12k_hif_write32 (ab, + reg_base +HAL_TCL1_RING_CONSR_INT_SETUP_IX1_OFFSET (ab), + val); + +if (srng->ring_id !=HAL_SRNG_RING_ID_WBM_IDLE_LINK ) { + tp_addr = hal->rdp.paddr + + ((unsigned long )srng->u.src_ring.tp_addr - + (unsigned long )hal->rdp.vaddr); +ath12k_hif_write32 (ab, + reg_base +HAL_TCL1_RING_TP_ADDR_LSB_OFFSET (ab), + tp_addr &HAL_ADDR_LSB_REG_MASK ); +ath12k_hif_write32 (ab, + reg_base +HAL_TCL1_RING_TP_ADDR_MSB_OFFSET (ab), + tp_addr >>HAL_ADDR_MSB_REG_SHIFT ); + } + +/* Initialize head and tail pointers to indicate ring is empty */ + reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R2 ]; +ath12k_hif_write32 (ab, reg_base,0 ); +ath12k_hif_write32 (ab, reg_base +HAL_TCL1_RING_TP_OFFSET ,0 ); + *srng->u.src_ring.tp_addr =0 ; + + reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R0 ]; + val =0 ; +if (srng->flags &HAL_SRNG_FLAGS_DATA_TLV_SWAP ) + val |=HAL_TCL1_RING_MISC_DATA_TLV_SWAP ; +if (srng->flags &HAL_SRNG_FLAGS_RING_PTR_SWAP ) + val |=HAL_TCL1_RING_MISC_HOST_FW_SWAP ; +if (srng->flags &HAL_SRNG_FLAGS_MSI_SWAP ) + val |=HAL_TCL1_RING_MISC_MSI_SWAP ; + +/* Loop count is not used for SRC rings */ + val |=HAL_TCL1_RING_MISC_MSI_LOOPCNT_DISABLE ; + + val |=HAL_TCL1_RING_MISC_SRNG_ENABLE ; + +if (srng->ring_id ==HAL_SRNG_RING_ID_WBM_IDLE_LINK ) + val |=HAL_TCL1_RING_MISC_MSI_RING_ID_DISABLE ; + +ath12k_hif_write32 (ab, reg_base +HAL_TCL1_RING_MISC_OFFSET (ab), val); +} + +static void ath12k_hal_srng_hw_init (struct ath12k_base *ab, +struct hal_srng *srng) +{ +if (srng->ring_dir ==HAL_SRNG_DIR_SRC ) +ath12k_hal_srng_src_hw_init (ab, srng); +else +ath12k_hal_srng_dst_hw_init (ab, srng); +} + +static int ath12k_hal_srng_get_ring_id (struct ath12k_base *ab, +enum hal_ring_type type, +int ring_num,int mac_id) +{ +struct hal_srng_config *srng_config = &ab->hal.srng_config[type]; +int ring_id; + +if (ring_num >= srng_config->max_rings) { +ath12k_warn (ab,"invalid ring number :%d\n" , ring_num); +return -EINVAL ; + } + + ring_id = srng_config->start_ring_id + ring_num; +if (srng_config->mac_type ==ATH12K_HAL_SRNG_PMAC ) + ring_id += mac_id *HAL_SRNG_RINGS_PER_PMAC ; + +if (WARN_ON (ring_id >=HAL_SRNG_RING_ID_MAX )) +return -EINVAL ; + +return ring_id; +} + +int ath12k_hal_srng_get_entrysize (struct ath12k_base *ab,u32 ring_type) +{ +struct hal_srng_config *srng_config; + +if (WARN_ON (ring_type >=HAL_MAX_RING_TYPES )) +return -EINVAL ; + + srng_config = &ab->hal.srng_config[ring_type]; + +return (srng_config->entry_size <<2 ); +} + +int ath12k_hal_srng_get_max_entries (struct ath12k_base *ab,u32 ring_type) +{ +struct hal_srng_config *srng_config; + +if (WARN_ON (ring_type >=HAL_MAX_RING_TYPES )) +return -EINVAL ; + + srng_config = &ab->hal.srng_config[ring_type]; + +return (srng_config->max_size / srng_config->entry_size); +} + +void ath12k_hal_srng_get_params (struct ath12k_base *ab,struct hal_srng *srng, +struct hal_srng_params *params) +{ + params->ring_base_paddr = srng->ring_base_paddr; + params->ring_base_vaddr = srng->ring_base_vaddr; + params->num_entries = srng->num_entries; + params->intr_timer_thres_us = srng->intr_timer_thres_us; + params->intr_batch_cntr_thres_entries = + srng->intr_batch_cntr_thres_entries; + params->low_threshold = srng->u.src_ring.low_threshold; + params->msi_addr = srng->msi_addr; + params->msi2_addr = srng->msi2_addr; + params->msi_data = srng->msi_data; + params->msi2_data = srng->msi2_data; + params->flags = srng->flags; +} + +dma_addr_t ath12k_hal_srng_get_hp_addr (struct ath12k_base *ab, +struct hal_srng *srng) +{ +if (!(srng->flags &HAL_SRNG_FLAGS_LMAC_RING )) +return 0 ; + +if (srng->ring_dir ==HAL_SRNG_DIR_SRC ) +return ab->hal.wrp.paddr + + ((unsigned long )srng->u.src_ring.hp_addr - + (unsigned long )ab->hal.wrp.vaddr); +else +return ab->hal.rdp.paddr + + ((unsigned long )srng->u.dst_ring.hp_addr - + (unsigned long )ab->hal.rdp.vaddr); +} + +dma_addr_t ath12k_hal_srng_get_tp_addr (struct ath12k_base *ab, +struct hal_srng *srng) +{ +if (!(srng->flags &HAL_SRNG_FLAGS_LMAC_RING )) +return 0 ; + +if (srng->ring_dir ==HAL_SRNG_DIR_SRC ) +return ab->hal.rdp.paddr + + ((unsigned long )srng->u.src_ring.tp_addr - + (unsigned long )ab->hal.rdp.vaddr); +else +return ab->hal.wrp.paddr + + ((unsigned long )srng->u.dst_ring.tp_addr - + (unsigned long )ab->hal.wrp.vaddr); +} + +u32 ath12k_hal_ce_get_desc_size (enum hal_ce_desc type) +{ +switch (type) { +case HAL_CE_DESC_SRC : +return sizeof (struct hal_ce_srng_src_desc ); +case HAL_CE_DESC_DST : +return sizeof (struct hal_ce_srng_dest_desc ); +case HAL_CE_DESC_DST_STATUS : +return sizeof (struct hal_ce_srng_dst_status_desc ); + } + +return 0 ; +} + +void ath12k_hal_ce_src_set_desc (struct hal_ce_srng_src_desc *desc,dma_addr_t paddr, +u32 len,u32 id,u8 byte_swap_data) +{ + desc->buffer_addr_low =cpu_to_le32 (paddr &HAL_ADDR_LSB_REG_MASK ); + desc->buffer_addr_info = +le32_encode_bits (((u64 )paddr >>HAL_ADDR_MSB_REG_SHIFT ), +HAL_CE_SRC_DESC_ADDR_INFO_ADDR_HI ) | +le32_encode_bits (byte_swap_data, +HAL_CE_SRC_DESC_ADDR_INFO_BYTE_SWAP ) | +le32_encode_bits (0 ,HAL_CE_SRC_DESC_ADDR_INFO_GATHER ) | +le32_encode_bits (len,HAL_CE_SRC_DESC_ADDR_INFO_LEN ); + desc->meta_info =le32_encode_bits (id,HAL_CE_SRC_DESC_META_INFO_DATA ); +} + +void ath12k_hal_ce_dst_set_desc (struct hal_ce_srng_dest_desc *desc,dma_addr_t paddr) +{ + desc->buffer_addr_low =cpu_to_le32 (paddr &HAL_ADDR_LSB_REG_MASK ); + desc->buffer_addr_info = +le32_encode_bits (((u64 )paddr >>HAL_ADDR_MSB_REG_SHIFT ), +HAL_CE_DEST_DESC_ADDR_INFO_ADDR_HI ); +} + +u32 ath12k_hal_ce_dst_status_get_length (struct hal_ce_srng_dst_status_desc *desc) +{ +u32 len; + + len =le32_get_bits (desc->flags,HAL_CE_DST_STATUS_DESC_FLAGS_LEN ); + desc->flags &= ~cpu_to_le32 (HAL_CE_DST_STATUS_DESC_FLAGS_LEN ); + +return len; +} + +void ath12k_hal_set_link_desc_addr (struct hal_wbm_link_desc *desc,u32 cookie, +dma_addr_t paddr) +{ + desc->buf_addr_info.info0 =le32_encode_bits ((paddr &HAL_ADDR_LSB_REG_MASK ), +BUFFER_ADDR_INFO0_ADDR ); + desc->buf_addr_info.info1 = +le32_encode_bits (((u64 )paddr >>HAL_ADDR_MSB_REG_SHIFT ), +BUFFER_ADDR_INFO1_ADDR ) | +le32_encode_bits (1 ,BUFFER_ADDR_INFO1_RET_BUF_MGR ) | +le32_encode_bits (cookie,BUFFER_ADDR_INFO1_SW_COOKIE ); +} + +void *ath12k_hal_srng_dst_peek (struct ath12k_base *ab,struct hal_srng *srng) +{ +lockdep_assert_held (&srng->lock); + +if (srng->u.dst_ring.tp != srng->u.dst_ring.cached_hp) +return (srng->ring_base_vaddr + srng->u.dst_ring.tp); + +return NULL ; +} + +void *ath12k_hal_srng_dst_get_next_entry (struct ath12k_base *ab, +struct hal_srng *srng) +{ +void *desc; + +lockdep_assert_held (&srng->lock); + +if (srng->u.dst_ring.tp == srng->u.dst_ring.cached_hp) +return NULL ; + + desc = srng->ring_base_vaddr + srng->u.dst_ring.tp; + + srng->u.dst_ring.tp = (srng->u.dst_ring.tp + srng->entry_size) % + srng->ring_size; + +return desc; +} + +int ath12k_hal_srng_dst_num_free (struct ath12k_base *ab,struct hal_srng *srng, +bool sync_hw_ptr) +{ +u32 tp, hp; + +lockdep_assert_held (&srng->lock); + + tp = srng->u.dst_ring.tp; + +if (sync_hw_ptr) { + hp = *srng->u.dst_ring.hp_addr; + srng->u.dst_ring.cached_hp = hp; + }else { + hp = srng->u.dst_ring.cached_hp; + } + +if (hp >= tp) +return (hp - tp) / srng->entry_size; +else +return (srng->ring_size - tp + hp) / srng->entry_size; +} + +/* Returns number of available entries in src ring */ +int ath12k_hal_srng_src_num_free (struct ath12k_base *ab,struct hal_srng *srng, +bool sync_hw_ptr) +{ +u32 tp, hp; + +lockdep_assert_held (&srng->lock); + + hp = srng->u.src_ring.hp; + +if (sync_hw_ptr) { + tp = *srng->u.src_ring.tp_addr; + srng->u.src_ring.cached_tp = tp; + }else { + tp = srng->u.src_ring.cached_tp; + } + +if (tp > hp) +return ((tp - hp) / srng->entry_size) -1 ; +else +return ((srng->ring_size - hp + tp) / srng->entry_size) -1 ; +} + +void *ath12k_hal_srng_src_get_next_entry (struct ath12k_base *ab, +struct hal_srng *srng) +{ +void *desc; +u32 next_hp; + +lockdep_assert_held (&srng->lock); + +/* TODO: Using % is expensive, but we have to do this since size of some +* SRNG rings is not power of 2 (due to descriptor sizes). Need to see +* if separate function is defined for rings having power of 2 ring size +* (TCL2SW, REO2SW, SW2RXDMA and CE rings) so that we can avoid the +* overhead of % by using mask (with &). +*/ + next_hp = (srng->u.src_ring.hp + srng->entry_size) % srng->ring_size; + +if (next_hp == srng->u.src_ring.cached_tp) +return NULL ; + + desc = srng->ring_base_vaddr + srng->u.src_ring.hp; + srng->u.src_ring.hp = next_hp; + +/* TODO: Reap functionality is not used by all rings. If particular +* ring does not use reap functionality, we need not update reap_hp +* with next_hp pointer. Need to make sure a separate function is used +* before doing any optimization by removing below code updating +* reap_hp. +*/ + srng->u.src_ring.reap_hp = next_hp; + +return desc; +} + +void *ath12k_hal_srng_src_reap_next (struct ath12k_base *ab, +struct hal_srng *srng) +{ +void *desc; +u32 next_reap_hp; + +lockdep_assert_held (&srng->lock); + + next_reap_hp = (srng->u.src_ring.reap_hp + srng->entry_size) % + srng->ring_size; + +if (next_reap_hp == srng->u.src_ring.cached_tp) +return NULL ; + + desc = srng->ring_base_vaddr + next_reap_hp; + srng->u.src_ring.reap_hp = next_reap_hp; + +return desc; +} + +void *ath12k_hal_srng_src_get_next_reaped (struct ath12k_base *ab, +struct hal_srng *srng) +{ +void *desc; + +lockdep_assert_held (&srng->lock); + +if (srng->u.src_ring.hp == srng->u.src_ring.reap_hp) +return NULL ; + + desc = srng->ring_base_vaddr + srng->u.src_ring.hp; + srng->u.src_ring.hp = (srng->u.src_ring.hp + srng->entry_size) % + srng->ring_size; + +return desc; +} + +void ath12k_hal_srng_access_begin (struct ath12k_base *ab,struct hal_srng *srng) +{ +lockdep_assert_held (&srng->lock); + +if (srng->ring_dir ==HAL_SRNG_DIR_SRC ) + srng->u.src_ring.cached_tp = + *(volatile u32 *)srng->u.src_ring.tp_addr; +else + srng->u.dst_ring.cached_hp = *srng->u.dst_ring.hp_addr; +} + +/* Update cached ring head/tail pointers to HW. ath12k_hal_srng_access_begin() +* should have been called before this. +*/ +void ath12k_hal_srng_access_end (struct ath12k_base *ab,struct hal_srng *srng) +{ +lockdep_assert_held (&srng->lock); + +/* TODO: See if we need a write memory barrier here */ +if (srng->flags &HAL_SRNG_FLAGS_LMAC_RING ) { +/* For LMAC rings, ring pointer updates are done through FW and +* hence written to a shared memory location that is read by FW +*/ +if (srng->ring_dir ==HAL_SRNG_DIR_SRC ) { + srng->u.src_ring.last_tp = + *(volatile u32 *)srng->u.src_ring.tp_addr; + *srng->u.src_ring.hp_addr = srng->u.src_ring.hp; + }else { + srng->u.dst_ring.last_hp = *srng->u.dst_ring.hp_addr; + *srng->u.dst_ring.tp_addr = srng->u.dst_ring.tp; + } + }else { +if (srng->ring_dir ==HAL_SRNG_DIR_SRC ) { + srng->u.src_ring.last_tp = + *(volatile u32 *)srng->u.src_ring.tp_addr; +ath12k_hif_write32 (ab, + (unsigned long )srng->u.src_ring.hp_addr - + (unsigned long )ab->mem, + srng->u.src_ring.hp); + }else { + srng->u.dst_ring.last_hp = *srng->u.dst_ring.hp_addr; +ath12k_hif_write32 (ab, + (unsigned long )srng->u.dst_ring.tp_addr - + (unsigned long )ab->mem, + srng->u.dst_ring.tp); + } + } + + srng->timestamp = jiffies; +} + +void ath12k_hal_setup_link_idle_list (struct ath12k_base *ab, +struct hal_wbm_idle_scatter_list *sbuf, +u32 nsbufs,u32 tot_link_desc, +u32 end_offset) +{ +struct ath12k_buffer_addr *link_addr; +int i; +u32 reg_scatter_buf_sz =HAL_WBM_IDLE_SCATTER_BUF_SIZE /64 ; +u32 val; + + link_addr = (void *)sbuf[0 ].vaddr +HAL_WBM_IDLE_SCATTER_BUF_SIZE ; + +for (i =1 ; i < nsbufs; i++) { + link_addr->info0 =cpu_to_le32 (sbuf[i].paddr &HAL_ADDR_LSB_REG_MASK ); + + link_addr->info1 = +le32_encode_bits ((u64 )sbuf[i].paddr >>HAL_ADDR_MSB_REG_SHIFT , +HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_39_32 ) | +le32_encode_bits (BASE_ADDR_MATCH_TAG_VAL , +HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_MATCH_TAG ); + + link_addr = (void *)sbuf[i].vaddr + +HAL_WBM_IDLE_SCATTER_BUF_SIZE ; + } + + val =u32_encode_bits (reg_scatter_buf_sz,HAL_WBM_SCATTER_BUFFER_SIZE ) | +u32_encode_bits (0x1 ,HAL_WBM_LINK_DESC_IDLE_LIST_MODE ); + +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_R0_IDLE_LIST_CONTROL_ADDR (ab), + val); + + val =u32_encode_bits (reg_scatter_buf_sz * nsbufs, +HAL_WBM_SCATTER_RING_SIZE_OF_IDLE_LINK_DESC_LIST ); +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG +HAL_WBM_R0_IDLE_LIST_SIZE_ADDR (ab), + val); + + val =u32_encode_bits (sbuf[0 ].paddr &HAL_ADDR_LSB_REG_MASK , +BUFFER_ADDR_INFO0_ADDR ); +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SCATTERED_RING_BASE_LSB (ab), + val); + + val =u32_encode_bits (BASE_ADDR_MATCH_TAG_VAL , +HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_MATCH_TAG ) | +u32_encode_bits ((u64 )sbuf[0 ].paddr >>HAL_ADDR_MSB_REG_SHIFT , +HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_39_32 ); +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SCATTERED_RING_BASE_MSB (ab), + val); + +/* Setup head and tail pointers for the idle list */ + val =u32_encode_bits (sbuf[nsbufs -1 ].paddr,BUFFER_ADDR_INFO0_ADDR ); +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SCATTERED_DESC_PTR_HEAD_INFO_IX0 (ab), + val); + + val =u32_encode_bits (((u64 )sbuf[nsbufs -1 ].paddr >>HAL_ADDR_MSB_REG_SHIFT ), +HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_39_32 ) | +u32_encode_bits ((end_offset >>2 ), +HAL_WBM_SCATTERED_DESC_HEAD_P_OFFSET_IX1 ); +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SCATTERED_DESC_PTR_HEAD_INFO_IX1 (ab), + val); + + val =u32_encode_bits (sbuf[0 ].paddr,BUFFER_ADDR_INFO0_ADDR ); +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SCATTERED_DESC_PTR_HEAD_INFO_IX0 (ab), + val); + + val =u32_encode_bits (sbuf[0 ].paddr,BUFFER_ADDR_INFO0_ADDR ); +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SCATTERED_DESC_PTR_TAIL_INFO_IX0 (ab), + val); + + val =u32_encode_bits (((u64 )sbuf[0 ].paddr >>HAL_ADDR_MSB_REG_SHIFT ), +HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_39_32 ) | +u32_encode_bits (0 ,HAL_WBM_SCATTERED_DESC_TAIL_P_OFFSET_IX1 ); +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SCATTERED_DESC_PTR_TAIL_INFO_IX1 (ab), + val); + + val =2 * tot_link_desc; +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_SCATTERED_DESC_PTR_HP_ADDR (ab), + val); + +/* Enable the SRNG */ + val =u32_encode_bits (1 ,HAL_WBM_IDLE_LINK_RING_MISC_SRNG_ENABLE ) | +u32_encode_bits (1 ,HAL_WBM_IDLE_LINK_RING_MISC_RIND_ID_DISABLE ); +ath12k_hif_write32 (ab, +HAL_SEQ_WCSS_UMAC_WBM_REG + +HAL_WBM_IDLE_LINK_RING_MISC_ADDR (ab), + val); +} + +int ath12k_hal_srng_setup (struct ath12k_base *ab,enum hal_ring_type type, +int ring_num,int mac_id, +struct hal_srng_params *params) +{ +struct ath12k_hal *hal = &ab->hal; +struct hal_srng_config *srng_config = &ab->hal.srng_config[type]; +struct hal_srng *srng; +int ring_id; +u32 idx; +int i; +u32 reg_base; + + ring_id =ath12k_hal_srng_get_ring_id (ab, type, ring_num, mac_id); +if (ring_id <0 ) +return ring_id; + + srng = &hal->srng_list[ring_id]; + + srng->ring_id = ring_id; + srng->ring_dir = srng_config->ring_dir; + srng->ring_base_paddr = params->ring_base_paddr; + srng->ring_base_vaddr = params->ring_base_vaddr; + srng->entry_size = srng_config->entry_size; + srng->num_entries = params->num_entries; + srng->ring_size = srng->entry_size * srng->num_entries; + srng->intr_batch_cntr_thres_entries = + params->intr_batch_cntr_thres_entries; + srng->intr_timer_thres_us = params->intr_timer_thres_us; + srng->flags = params->flags; + srng->msi_addr = params->msi_addr; + srng->msi2_addr = params->msi2_addr; + srng->msi_data = params->msi_data; + srng->msi2_data = params->msi2_data; + srng->initialized =1 ; +spin_lock_init (&srng->lock); +lockdep_set_class (&srng->lock, &srng->lock_key); + +for (i =0 ; i <HAL_SRNG_NUM_REG_GRP ; i++) { + srng->hwreg_base[i] = srng_config->reg_start[i] + + (ring_num * srng_config->reg_size[i]); + } + +memset (srng->ring_base_vaddr,0 , + (srng->entry_size * srng->num_entries) <<2 ); + + reg_base = srng->hwreg_base[HAL_SRNG_REG_GRP_R2 ]; + +if (srng->ring_dir ==HAL_SRNG_DIR_SRC ) { + srng->u.src_ring.hp =0 ; + srng->u.src_ring.cached_tp =0 ; + srng->u.src_ring.reap_hp = srng->ring_size - srng->entry_size; + srng->u.src_ring.tp_addr = (void *)(hal->rdp.vaddr + ring_id); + srng->u.src_ring.low_threshold = params->low_threshold * + srng->entry_size; +if (srng_config->mac_type ==ATH12K_HAL_SRNG_UMAC ) { +if (!ab->hw_params->supports_shadow_regs) + srng->u.src_ring.hp_addr = + (u32 *)((unsigned long )ab->mem + reg_base); +else +ath12k_dbg (ab,ATH12K_DBG_HAL , +"hal type %d ring_num %d reg_base 0x%x shadow 0x%lx\n" , + type, ring_num, + reg_base, + (unsigned long )srng->u.src_ring.hp_addr - + (unsigned long )ab->mem); + }else { + idx = ring_id -HAL_SRNG_RING_ID_DMAC_CMN_ID_START ; + srng->u.src_ring.hp_addr = (void *)(hal->wrp.vaddr + + idx); + srng->flags |=HAL_SRNG_FLAGS_LMAC_RING ; + } + }else { +/* During initialization loop count in all the descriptors +* will be set to zero, and HW will set it to 1 on completing +* descriptor update in first loop, and increments it by 1 on +* subsequent loops (loop count wraps around after reaching +* 0xffff). The 'loop_cnt' in SW ring state is the expected +* loop count in descriptors updated by HW (to be processed +* by SW). +*/ + srng->u.dst_ring.loop_cnt =1 ; + srng->u.dst_ring.tp =0 ; + srng->u.dst_ring.cached_hp =0 ; + srng->u.dst_ring.hp_addr = (void *)(hal->rdp.vaddr + ring_id); +if (srng_config->mac_type ==ATH12K_HAL_SRNG_UMAC ) { +if (!ab->hw_params->supports_shadow_regs) + srng->u.dst_ring.tp_addr = + (u32 *)((unsigned long )ab->mem + reg_base + + (HAL_REO1_RING_TP -HAL_REO1_RING_HP )); +else +ath12k_dbg (ab,ATH12K_DBG_HAL , +"type %d ring_num %d target_reg 0x%x shadow 0x%lx\n" , + type, ring_num, + reg_base +HAL_REO1_RING_TP -HAL_REO1_RING_HP , + (unsigned long )srng->u.dst_ring.tp_addr - + (unsigned long )ab->mem); + }else { +/* For PMAC & DMAC rings, tail pointer updates will be done +* through FW by writing to a shared memory location +*/ + idx = ring_id -HAL_SRNG_RING_ID_DMAC_CMN_ID_START ; + srng->u.dst_ring.tp_addr = (void *)(hal->wrp.vaddr + + idx); + srng->flags |=HAL_SRNG_FLAGS_LMAC_RING ; + } + } + +if (srng_config->mac_type !=ATH12K_HAL_SRNG_UMAC ) +return ring_id; + +ath12k_hal_srng_hw_init (ab, srng); + +if (type ==HAL_CE_DST ) { + srng->u.dst_ring.max_buffer_length = params->max_buffer_len; +ath12k_hal_ce_dst_setup (ab, srng, ring_num); + } + +return ring_id; +} + +static void ath12k_hal_srng_update_hp_tp_addr (struct ath12k_base *ab, +int shadow_cfg_idx, +enum hal_ring_type ring_type, +int ring_num) +{ +struct hal_srng *srng; +struct ath12k_hal *hal = &ab->hal; +int ring_id; +struct hal_srng_config *srng_config = &hal->srng_config[ring_type]; + + ring_id =ath12k_hal_srng_get_ring_id (ab, ring_type, ring_num,0 ); +if (ring_id <0 ) +return ; + + srng = &hal->srng_list[ring_id]; + +if (srng_config->ring_dir ==HAL_SRNG_DIR_DST ) + srng->u.dst_ring.tp_addr = (u32 *)(HAL_SHADOW_REG (shadow_cfg_idx) + + (unsigned long )ab->mem); +else + srng->u.src_ring.hp_addr = (u32 *)(HAL_SHADOW_REG (shadow_cfg_idx) + + (unsigned long )ab->mem); +} + +int ath12k_hal_srng_update_shadow_config (struct ath12k_base *ab, +enum hal_ring_type ring_type, +int ring_num) +{ +struct ath12k_hal *hal = &ab->hal; +struct hal_srng_config *srng_config = &hal->srng_config[ring_type]; +int shadow_cfg_idx = hal->num_shadow_reg_configured; +u32 target_reg; + +if (shadow_cfg_idx >=HAL_SHADOW_NUM_REGS ) +return -EINVAL ; + + hal->num_shadow_reg_configured++; + + target_reg = srng_config->reg_start[HAL_HP_OFFSET_IN_REG_START ]; + target_reg += srng_config->reg_size[HAL_HP_OFFSET_IN_REG_START ] * + ring_num; + +/* For destination ring, shadow the TP */ +if (srng_config->ring_dir ==HAL_SRNG_DIR_DST ) + target_reg +=HAL_OFFSET_FROM_HP_TO_TP ; + + hal->shadow_reg_addr[shadow_cfg_idx] = target_reg; + +/* update hp/tp addr to hal structure*/ +ath12k_hal_srng_update_hp_tp_addr (ab, shadow_cfg_idx, ring_type, + ring_num); + +ath12k_dbg (ab,ATH12K_DBG_HAL , +"target_reg %x, shadow reg 0x%x shadow_idx 0x%x, ring_type %d, ring num %d" , + target_reg, +HAL_SHADOW_REG (shadow_cfg_idx), + shadow_cfg_idx, + ring_type, ring_num); + +return 0 ; +} + +void ath12k_hal_srng_shadow_config (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +int ring_type, ring_num; + +/* update all the non-CE srngs. */ +for (ring_type =0 ; ring_type <HAL_MAX_RING_TYPES ; ring_type++) { +struct hal_srng_config *srng_config = &hal->srng_config[ring_type]; + +if (ring_type ==HAL_CE_SRC || + ring_type ==HAL_CE_DST || + ring_type ==HAL_CE_DST_STATUS ) +continue ; + +if (srng_config->mac_type ==ATH12K_HAL_SRNG_DMAC || + srng_config->mac_type ==ATH12K_HAL_SRNG_PMAC ) +continue ; + +for (ring_num =0 ; ring_num < srng_config->max_rings; ring_num++) +ath12k_hal_srng_update_shadow_config (ab, ring_type, ring_num); + } +} + +void ath12k_hal_srng_get_shadow_config (struct ath12k_base *ab, +u32 **cfg,u32 *len) +{ +struct ath12k_hal *hal = &ab->hal; + + *len = hal->num_shadow_reg_configured; + *cfg = hal->shadow_reg_addr; +} + +void ath12k_hal_srng_shadow_update_hp_tp (struct ath12k_base *ab, +struct hal_srng *srng) +{ +lockdep_assert_held (&srng->lock); + +/* check whether the ring is empty. Update the shadow +* HP only when then ring isn't' empty. +*/ +if (srng->ring_dir ==HAL_SRNG_DIR_SRC && + *srng->u.src_ring.tp_addr != srng->u.src_ring.hp) +ath12k_hal_srng_access_end (ab, srng); +} + +static void ath12k_hal_register_srng_lock_keys (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +u32 ring_id; + +for (ring_id =0 ; ring_id <HAL_SRNG_RING_ID_MAX ; ring_id++) +lockdep_register_key (&hal->srng_list[ring_id].lock_key); +} + +static void ath12k_hal_unregister_srng_lock_keys (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +u32 ring_id; + +for (ring_id =0 ; ring_id <HAL_SRNG_RING_ID_MAX ; ring_id++) +lockdep_unregister_key (&hal->srng_list[ring_id].lock_key); +} + +int ath12k_hal_srng_init (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; +int ret; + +memset (hal,0 ,sizeof (*hal)); + + ret = ab->hw_params->hal_ops->create_srng_config (ab); +if (ret) + goto err_hal; + + ret =ath12k_hal_alloc_cont_rdp (ab); +if (ret) + goto err_hal; + + ret =ath12k_hal_alloc_cont_wrp (ab); +if (ret) + goto err_free_cont_rdp; + +ath12k_hal_register_srng_lock_keys (ab); + +return 0 ; + +err_free_cont_rdp: +ath12k_hal_free_cont_rdp (ab); + +err_hal: +return ret; +} + +void ath12k_hal_srng_deinit (struct ath12k_base *ab) +{ +struct ath12k_hal *hal = &ab->hal; + +ath12k_hal_unregister_srng_lock_keys (ab); +ath12k_hal_free_cont_rdp (ab); +ath12k_hal_free_cont_wrp (ab); +kfree (hal->srng_config); + hal->srng_config =NULL ; +} + +void ath12k_hal_dump_srng_stats (struct ath12k_base *ab) +{ +struct hal_srng *srng; +struct ath12k_ext_irq_grp *irq_grp; +struct ath12k_ce_pipe *ce_pipe; +int i; + +ath12k_err (ab,"Last interrupt received for each CE:\n" ); +for (i =0 ; i < ab->hw_params->ce_count; i++) { + ce_pipe = &ab->ce.ce_pipe[i]; + +if (ath12k_ce_get_attr_flags (ab, i) &CE_ATTR_DIS_INTR ) +continue ; + +ath12k_err (ab,"CE_id %d pipe_num %d %ums before\n" , + i, ce_pipe->pipe_num, +jiffies_to_msecs (jiffies - ce_pipe->timestamp)); + } + +ath12k_err (ab,"\nLast interrupt received for each group:\n" ); +for (i =0 ; i <ATH12K_EXT_IRQ_GRP_NUM_MAX ; i++) { + irq_grp = &ab->ext_irq_grp[i]; +ath12k_err (ab,"group_id %d %ums before\n" , + irq_grp->grp_id, +jiffies_to_msecs (jiffies - irq_grp->timestamp)); + } + +for (i =0 ; i <HAL_SRNG_RING_ID_MAX ; i++) { + srng = &ab->hal.srng_list[i]; + +if (!srng->initialized) +continue ; + +if (srng->ring_dir ==HAL_SRNG_DIR_SRC ) +ath12k_err (ab, +"src srng id %u hp %u, reap_hp %u, cur tp %u, cached tp %u last tp %u napi processed before %ums\n" , + srng->ring_id, srng->u.src_ring.hp, + srng->u.src_ring.reap_hp, + *srng->u.src_ring.tp_addr, srng->u.src_ring.cached_tp, + srng->u.src_ring.last_tp, +jiffies_to_msecs (jiffies - srng->timestamp)); +else if (srng->ring_dir ==HAL_SRNG_DIR_DST ) +ath12k_err (ab, +"dst srng id %u tp %u, cur hp %u, cached hp %u last hp %u napi processed before %ums\n" , + srng->ring_id, srng->u.dst_ring.tp, + *srng->u.dst_ring.hp_addr, + srng->u.dst_ring.cached_hp, + srng->u.dst_ring.last_hp, +jiffies_to_msecs (jiffies - srng->timestamp)); + } +}
PATCH v2 20/50 wifi: ath12k: add hal.h
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hal.h | 1166 +++++++++++++++++++++++++++++++++ 1 file changed, 1166 insertions(+)
drivers/net/wireless/ath/ath12k/hal.h new file +1166 -0
@@ -0,0 +1,1166 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#ifndef ATH12K_HAL_H +#define ATH12K_HAL_H + +#include "hal_desc.h" +#include "rx_desc.h" + +struct ath12k_base ; + +#define HAL_LINK_DESC_SIZE (32 << 2) +#define HAL_LINK_DESC_ALIGN 128 +#define HAL_NUM_MPDUS_PER_LINK_DESC 6 +#define HAL_NUM_TX_MSDUS_PER_LINK_DESC 7 +#define HAL_NUM_RX_MSDUS_PER_LINK_DESC 6 +#define HAL_NUM_MPDU_LINKS_PER_QUEUE_DESC 12 +#define HAL_MAX_AVAIL_BLK_RES 3 + +#define HAL_RING_BASE_ALIGN 8 + +#define HAL_WBM_IDLE_SCATTER_BUF_SIZE_MAX 32704 +/* TODO: Check with hw team on the supported scatter buf size */ +#define HAL_WBM_IDLE_SCATTER_NEXT_PTR_SIZE 8 +#define HAL_WBM_IDLE_SCATTER_BUF_SIZE (HAL_WBM_IDLE_SCATTER_BUF_SIZE_MAX - \ + HAL_WBM_IDLE_SCATTER_NEXT_PTR_SIZE) + +/* TODO: 16 entries per radio times MAX_VAPS_SUPPORTED */ +#define HAL_DSCP_TID_MAP_TBL_NUM_ENTRIES_MAX 32 +#define HAL_DSCP_TID_TBL_SIZE 24 + +/* calculate the register address from bar0 of shadow register x */ +#define HAL_SHADOW_BASE_ADDR 0x000008fc +#define HAL_SHADOW_NUM_REGS 40 +#define HAL_HP_OFFSET_IN_REG_START 1 +#define HAL_OFFSET_FROM_HP_TO_TP 4 + +#define HAL_SHADOW_REG (x) (HAL_SHADOW_BASE_ADDR + (4 * (x))) + +/* WCSS Relative address */ +#define HAL_SEQ_WCSS_UMAC_OFFSET 0x00a00000 +#define HAL_SEQ_WCSS_UMAC_REO_REG 0x00a38000 +#define HAL_SEQ_WCSS_UMAC_TCL_REG 0x00a44000 +#define HAL_SEQ_WCSS_UMAC_CE0_SRC_REG 0x01b80000 +#define HAL_SEQ_WCSS_UMAC_CE0_DST_REG 0x01b81000 +#define HAL_SEQ_WCSS_UMAC_CE1_SRC_REG 0x01b82000 +#define HAL_SEQ_WCSS_UMAC_CE1_DST_REG 0x01b83000 +#define HAL_SEQ_WCSS_UMAC_WBM_REG 0x00a34000 + +#define HAL_CE_WFSS_CE_REG_BASE 0x01b80000 + +#define HAL_TCL_SW_CONFIG_BANK_ADDR 0x00a4408c + +/* SW2TCL(x) R0 ring configuration address */ +#define HAL_TCL1_RING_CMN_CTRL_REG 0x00000020 +#define HAL_TCL1_RING_DSCP_TID_MAP 0x00000240 +#define HAL_TCL1_RING_BASE_LSB 0x00000900 +#define HAL_TCL1_RING_BASE_MSB 0x00000904 +#define HAL_TCL1_RING_ID (ab) ((ab)->hw_params->regs->hal_tcl1_ring_id) +#define HAL_TCL1_RING_MISC (ab) \ + ((ab)->hw_params->regs->hal_tcl1_ring_misc) +#define HAL_TCL1_RING_TP_ADDR_LSB (ab) \ + ((ab)->hw_params->regs->hal_tcl1_ring_tp_addr_lsb) +#define HAL_TCL1_RING_TP_ADDR_MSB (ab) \ + ((ab)->hw_params->regs->hal_tcl1_ring_tp_addr_msb) +#define HAL_TCL1_RING_CONSUMER_INT_SETUP_IX0 (ab) \ + ((ab)->hw_params->regs->hal_tcl1_ring_consumer_int_setup_ix0) +#define HAL_TCL1_RING_CONSUMER_INT_SETUP_IX1 (ab) \ + ((ab)->hw_params->regs->hal_tcl1_ring_consumer_int_setup_ix1) +#define HAL_TCL1_RING_MSI1_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_tcl1_ring_msi1_base_lsb) +#define HAL_TCL1_RING_MSI1_BASE_MSB (ab) \ + ((ab)->hw_params->regs->hal_tcl1_ring_msi1_base_msb) +#define HAL_TCL1_RING_MSI1_DATA (ab) \ + ((ab)->hw_params->regs->hal_tcl1_ring_msi1_data) +#define HAL_TCL2_RING_BASE_LSB 0x00000978 +#define HAL_TCL_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_tcl_ring_base_lsb) + +#define HAL_TCL1_RING_MSI1_BASE_LSB_OFFSET (ab) \ + (HAL_TCL1_RING_MSI1_BASE_LSB(ab) - HAL_TCL1_RING_BASE_LSB) +#define HAL_TCL1_RING_MSI1_BASE_MSB_OFFSET (ab) \ + (HAL_TCL1_RING_MSI1_BASE_MSB(ab) - HAL_TCL1_RING_BASE_LSB) +#define HAL_TCL1_RING_MSI1_DATA_OFFSET (ab) \ + (HAL_TCL1_RING_MSI1_DATA(ab) - HAL_TCL1_RING_BASE_LSB) +#define HAL_TCL1_RING_BASE_MSB_OFFSET \ + (HAL_TCL1_RING_BASE_MSB - HAL_TCL1_RING_BASE_LSB) +#define HAL_TCL1_RING_ID_OFFSET (ab) \ + (HAL_TCL1_RING_ID(ab) - HAL_TCL1_RING_BASE_LSB) +#define HAL_TCL1_RING_CONSR_INT_SETUP_IX0_OFFSET (ab) \ + (HAL_TCL1_RING_CONSUMER_INT_SETUP_IX0(ab) - HAL_TCL1_RING_BASE_LSB) +#define HAL_TCL1_RING_CONSR_INT_SETUP_IX1_OFFSET (ab) \ + (HAL_TCL1_RING_CONSUMER_INT_SETUP_IX1(ab) - HAL_TCL1_RING_BASE_LSB) +#define HAL_TCL1_RING_TP_ADDR_LSB_OFFSET (ab) \ + (HAL_TCL1_RING_TP_ADDR_LSB(ab) - HAL_TCL1_RING_BASE_LSB) +#define HAL_TCL1_RING_TP_ADDR_MSB_OFFSET (ab) \ + (HAL_TCL1_RING_TP_ADDR_MSB(ab) - HAL_TCL1_RING_BASE_LSB) +#define HAL_TCL1_RING_MISC_OFFSET (ab) \ + (HAL_TCL1_RING_MISC(ab) - HAL_TCL1_RING_BASE_LSB) + +/* SW2TCL(x) R2 ring pointers (head/tail) address */ +#define HAL_TCL1_RING_HP 0x00002000 +#define HAL_TCL1_RING_TP 0x00002004 +#define HAL_TCL2_RING_HP 0x00002008 +#define HAL_TCL_RING_HP 0x00002028 + +#define HAL_TCL1_RING_TP_OFFSET \ + (HAL_TCL1_RING_TP - HAL_TCL1_RING_HP) + +/* TCL STATUS ring address */ +#define HAL_TCL_STATUS_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_tcl_status_ring_base_lsb) +#define HAL_TCL_STATUS_RING_HP 0x00002048 + +/* PPE2TCL1 Ring address */ +#define HAL_TCL_PPE2TCL1_RING_BASE_LSB 0x00000c48 +#define HAL_TCL_PPE2TCL1_RING_HP 0x00002038 + +/* WBM PPE Release Ring address */ +#define HAL_WBM_PPE_RELEASE_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_ppe_rel_ring_base) +#define HAL_WBM_PPE_RELEASE_RING_HP 0x00003020 + +/* REO2SW(x) R0 ring configuration address */ +#define HAL_REO1_GEN_ENABLE 0x00000000 +#define HAL_REO1_MISC_CTRL_ADDR (ab) \ + ((ab)->hw_params->regs->hal_reo1_misc_ctrl_addr) +#define HAL_REO1_DEST_RING_CTRL_IX_0 0x00000004 +#define HAL_REO1_DEST_RING_CTRL_IX_1 0x00000008 +#define HAL_REO1_DEST_RING_CTRL_IX_2 0x0000000c +#define HAL_REO1_DEST_RING_CTRL_IX_3 0x00000010 +#define HAL_REO1_SW_COOKIE_CFG0 (ab) ((ab)->hw_params->regs->hal_reo1_sw_cookie_cfg0) +#define HAL_REO1_SW_COOKIE_CFG1 (ab) ((ab)->hw_params->regs->hal_reo1_sw_cookie_cfg1) +#define HAL_REO1_QDESC_LUT_BASE0 (ab) ((ab)->hw_params->regs->hal_reo1_qdesc_lut_base0) +#define HAL_REO1_QDESC_LUT_BASE1 (ab) ((ab)->hw_params->regs->hal_reo1_qdesc_lut_base1) +#define HAL_REO1_RING_BASE_LSB (ab) ((ab)->hw_params->regs->hal_reo1_ring_base_lsb) +#define HAL_REO1_RING_BASE_MSB (ab) ((ab)->hw_params->regs->hal_reo1_ring_base_msb) +#define HAL_REO1_RING_ID (ab) ((ab)->hw_params->regs->hal_reo1_ring_id) +#define HAL_REO1_RING_MISC (ab) ((ab)->hw_params->regs->hal_reo1_ring_misc) +#define HAL_REO1_RING_HP_ADDR_LSB (ab) ((ab)->hw_params->regs->hal_reo1_ring_hp_addr_lsb) +#define HAL_REO1_RING_HP_ADDR_MSB (ab) ((ab)->hw_params->regs->hal_reo1_ring_hp_addr_msb) +#define HAL_REO1_RING_PRODUCER_INT_SETUP (ab) \ + ((ab)->hw_params->regs->hal_reo1_ring_producer_int_setup) +#define HAL_REO1_RING_MSI1_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_reo1_ring_msi1_base_lsb) +#define HAL_REO1_RING_MSI1_BASE_MSB (ab) \ + ((ab)->hw_params->regs->hal_reo1_ring_msi1_base_msb) +#define HAL_REO1_RING_MSI1_DATA (ab) ((ab)->hw_params->regs->hal_reo1_ring_msi1_data) +#define HAL_REO2_RING_BASE_LSB (ab) ((ab)->hw_params->regs->hal_reo2_ring_base) +#define HAL_REO1_AGING_THRESH_IX_0 (ab) ((ab)->hw_params->regs->hal_reo1_aging_thres_ix0) +#define HAL_REO1_AGING_THRESH_IX_1 (ab) ((ab)->hw_params->regs->hal_reo1_aging_thres_ix1) +#define HAL_REO1_AGING_THRESH_IX_2 (ab) ((ab)->hw_params->regs->hal_reo1_aging_thres_ix2) +#define HAL_REO1_AGING_THRESH_IX_3 (ab) ((ab)->hw_params->regs->hal_reo1_aging_thres_ix3) + +#define HAL_REO1_RING_MSI1_BASE_LSB_OFFSET \ + (HAL_REO1_RING_MSI1_BASE_LSB(ab) - HAL_REO1_RING_BASE_LSB(ab)) +#define HAL_REO1_RING_MSI1_BASE_MSB_OFFSET \ + (HAL_REO1_RING_MSI1_BASE_MSB(ab) - HAL_REO1_RING_BASE_LSB(ab)) +#define HAL_REO1_RING_MSI1_DATA_OFFSET \ + (HAL_REO1_RING_MSI1_DATA(ab) - HAL_REO1_RING_BASE_LSB(ab)) +#define HAL_REO1_RING_BASE_MSB_OFFSET \ + (HAL_REO1_RING_BASE_MSB(ab) - HAL_REO1_RING_BASE_LSB(ab)) + +#define HAL_REO1_RING_ID_OFFSET (ab) \ + ({ \ + struct ath12k_base *_ab = (ab); \ + (HAL_REO1_RING_ID(_ab) - HAL_REO1_RING_BASE_LSB(_ab)); \ + }) + +#define HAL_REO1_RING_PRODUCER_INT_SETUP_OFFSET \ + (HAL_REO1_RING_PRODUCER_INT_SETUP(ab) - HAL_REO1_RING_BASE_LSB(ab)) +#define HAL_REO1_RING_HP_ADDR_LSB_OFFSET \ + (HAL_REO1_RING_HP_ADDR_LSB(ab) - HAL_REO1_RING_BASE_LSB(ab)) +#define HAL_REO1_RING_HP_ADDR_MSB_OFFSET \ + (HAL_REO1_RING_HP_ADDR_MSB(ab) - HAL_REO1_RING_BASE_LSB(ab)) +#define HAL_REO1_RING_MISC_OFFSET \ + (HAL_REO1_RING_MISC(ab) - HAL_REO1_RING_BASE_LSB(ab)) + +/* REO2SW(x) R2 ring pointers (head/tail) address */ +#define HAL_REO1_RING_HP 0x00003048 +#define HAL_REO1_RING_TP 0x0000304c +#define HAL_REO2_RING_HP 0x00003050 + +#define HAL_REO1_RING_TP_OFFSET (HAL_REO1_RING_TP - HAL_REO1_RING_HP) + +/* REO2SW0 ring configuration address */ +#define HAL_REO_SW0_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_reo2_sw0_ring_base) + +/* REO2SW0 R2 ring pointer (head/tail) address */ +#define HAL_REO_SW0_RING_HP 0x00003088 + +/* REO CMD R0 address */ +#define HAL_REO_CMD_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_reo_cmd_ring_base) + +/* REO CMD R2 address */ +#define HAL_REO_CMD_HP 0x00003020 + +/* SW2REO R0 address */ +#define HAL_SW2REO_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_sw2reo_ring_base) +#define HAL_SW2REO1_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_sw2reo1_ring_base) + +/* SW2REO R2 address */ +#define HAL_SW2REO_RING_HP 0x00003028 +#define HAL_SW2REO1_RING_HP 0x00003030 + +/* CE ring R0 address */ +#define HAL_CE_SRC_RING_BASE_LSB 0x00000000 +#define HAL_CE_DST_RING_BASE_LSB 0x00000000 +#define HAL_CE_DST_STATUS_RING_BASE_LSB 0x00000058 +#define HAL_CE_DST_RING_CTRL 0x000000b0 + +/* CE ring R2 address */ +#define HAL_CE_DST_RING_HP 0x00000400 +#define HAL_CE_DST_STATUS_RING_HP 0x00000408 + +/* REO status address */ +#define HAL_REO_STATUS_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_reo_status_ring_base) +#define HAL_REO_STATUS_HP 0x000030a8 + +/* WBM Idle R0 address */ +#define HAL_WBM_IDLE_LINK_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_wbm_idle_ring_base_lsb) +#define HAL_WBM_IDLE_LINK_RING_MISC_ADDR (ab) \ + ((ab)->hw_params->regs->hal_wbm_idle_ring_misc_addr) +#define HAL_WBM_R0_IDLE_LIST_CONTROL_ADDR (ab) \ + ((ab)->hw_params->regs->hal_wbm_r0_idle_list_cntl_addr) +#define HAL_WBM_R0_IDLE_LIST_SIZE_ADDR (ab) \ + ((ab)->hw_params->regs->hal_wbm_r0_idle_list_size_addr) +#define HAL_WBM_SCATTERED_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_wbm_scattered_ring_base_lsb) +#define HAL_WBM_SCATTERED_RING_BASE_MSB (ab) \ + ((ab)->hw_params->regs->hal_wbm_scattered_ring_base_msb) +#define HAL_WBM_SCATTERED_DESC_PTR_HEAD_INFO_IX0 (ab) \ + ((ab)->hw_params->regs->hal_wbm_scattered_desc_head_info_ix0) +#define HAL_WBM_SCATTERED_DESC_PTR_HEAD_INFO_IX1 (ab) \ + ((ab)->hw_params->regs->hal_wbm_scattered_desc_head_info_ix1) +#define HAL_WBM_SCATTERED_DESC_PTR_TAIL_INFO_IX0 (ab) \ + ((ab)->hw_params->regs->hal_wbm_scattered_desc_tail_info_ix0) +#define HAL_WBM_SCATTERED_DESC_PTR_TAIL_INFO_IX1 (ab) \ + ((ab)->hw_params->regs->hal_wbm_scattered_desc_tail_info_ix1) +#define HAL_WBM_SCATTERED_DESC_PTR_HP_ADDR (ab) \ + ((ab)->hw_params->regs->hal_wbm_scattered_desc_ptr_hp_addr) + +/* WBM Idle R2 address */ +#define HAL_WBM_IDLE_LINK_RING_HP 0x000030b8 + +/* SW2WBM R0 release address */ +#define HAL_WBM_SW_RELEASE_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_wbm_sw_release_ring_base_lsb) +#define HAL_WBM_SW1_RELEASE_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_wbm_sw1_release_ring_base_lsb) + +/* SW2WBM R2 release address */ +#define HAL_WBM_SW_RELEASE_RING_HP 0x00003010 +#define HAL_WBM_SW1_RELEASE_RING_HP 0x00003018 + +/* WBM2SW R0 release address */ +#define HAL_WBM0_RELEASE_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_wbm0_release_ring_base_lsb) + +#define HAL_WBM1_RELEASE_RING_BASE_LSB (ab) \ + ((ab)->hw_params->regs->hal_wbm1_release_ring_base_lsb) + +/* WBM2SW R2 release address */ +#define HAL_WBM0_RELEASE_RING_HP 0x000030c8 +#define HAL_WBM1_RELEASE_RING_HP 0x000030d0 + +/* WBM cookie config address and mask */ +#define HAL_WBM_SW_COOKIE_CFG0 0x00000040 +#define HAL_WBM_SW_COOKIE_CFG1 0x00000044 +#define HAL_WBM_SW_COOKIE_CFG2 0x00000090 +#define HAL_WBM_SW_COOKIE_CONVERT_CFG 0x00000094 + +#define HAL_WBM_SW_COOKIE_CFG_CMEM_BASE_ADDR_MSB GENMASK(7, 0) +#define HAL_WBM_SW_COOKIE_CFG_COOKIE_PPT_MSB GENMASK(12, 8) +#define HAL_WBM_SW_COOKIE_CFG_COOKIE_SPT_MSB GENMASK(17, 13) +#define HAL_WBM_SW_COOKIE_CFG_ALIGN BIT(18) +#define HAL_WBM_SW_COOKIE_CFG_RELEASE_PATH_EN BIT(0) +#define HAL_WBM_SW_COOKIE_CFG_ERR_PATH_EN BIT(1) +#define HAL_WBM_SW_COOKIE_CFG_CONV_IND_EN BIT(3) + +#define HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW0_EN BIT(1) +#define HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW1_EN BIT(2) +#define HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW2_EN BIT(3) +#define HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW3_EN BIT(4) +#define HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW4_EN BIT(5) +#define HAL_WBM_SW_COOKIE_CONV_CFG_GLOBAL_EN BIT(8) + +/* TCL ring feild mask and offset */ +#define HAL_TCL1_RING_BASE_MSB_RING_SIZE GENMASK(27, 8) +#define HAL_TCL1_RING_BASE_MSB_RING_BASE_ADDR_MSB GENMASK(7, 0) +#define HAL_TCL1_RING_ID_ENTRY_SIZE GENMASK(7, 0) +#define HAL_TCL1_RING_MISC_MSI_RING_ID_DISABLE BIT(0) +#define HAL_TCL1_RING_MISC_MSI_LOOPCNT_DISABLE BIT(1) +#define HAL_TCL1_RING_MISC_MSI_SWAP BIT(3) +#define HAL_TCL1_RING_MISC_HOST_FW_SWAP BIT(4) +#define HAL_TCL1_RING_MISC_DATA_TLV_SWAP BIT(5) +#define HAL_TCL1_RING_MISC_SRNG_ENABLE BIT(6) +#define HAL_TCL1_RING_CONSR_INT_SETUP_IX0_INTR_TMR_THOLD GENMASK(31, 16) +#define HAL_TCL1_RING_CONSR_INT_SETUP_IX0_BATCH_COUNTER_THOLD GENMASK(14, 0) +#define HAL_TCL1_RING_CONSR_INT_SETUP_IX1_LOW_THOLD GENMASK(15, 0) +#define HAL_TCL1_RING_MSI1_BASE_MSB_MSI1_ENABLE BIT(8) +#define HAL_TCL1_RING_MSI1_BASE_MSB_ADDR GENMASK(7, 0) +#define HAL_TCL1_RING_CMN_CTRL_DSCP_TID_MAP_PROG_EN BIT(23) +#define HAL_TCL1_RING_FIELD_DSCP_TID_MAP GENMASK(31, 0) +#define HAL_TCL1_RING_FIELD_DSCP_TID_MAP0 GENMASK(2, 0) +#define HAL_TCL1_RING_FIELD_DSCP_TID_MAP1 GENMASK(5, 3) +#define HAL_TCL1_RING_FIELD_DSCP_TID_MAP2 GENMASK(8, 6) +#define HAL_TCL1_RING_FIELD_DSCP_TID_MAP3 GENMASK(11, 9) +#define HAL_TCL1_RING_FIELD_DSCP_TID_MAP4 GENMASK(14, 12) +#define HAL_TCL1_RING_FIELD_DSCP_TID_MAP5 GENMASK(17, 15) +#define HAL_TCL1_RING_FIELD_DSCP_TID_MAP6 GENMASK(20, 18) +#define HAL_TCL1_RING_FIELD_DSCP_TID_MAP7 GENMASK(23, 21) + +/* REO ring feild mask and offset */ +#define HAL_REO1_RING_BASE_MSB_RING_SIZE GENMASK(27, 8) +#define HAL_REO1_RING_BASE_MSB_RING_BASE_ADDR_MSB GENMASK(7, 0) +#define HAL_REO1_RING_ID_RING_ID GENMASK(15, 8) +#define HAL_REO1_RING_ID_ENTRY_SIZE GENMASK(7, 0) +#define HAL_REO1_RING_MISC_MSI_SWAP BIT(3) +#define HAL_REO1_RING_MISC_HOST_FW_SWAP BIT(4) +#define HAL_REO1_RING_MISC_DATA_TLV_SWAP BIT(5) +#define HAL_REO1_RING_MISC_SRNG_ENABLE BIT(6) +#define HAL_REO1_RING_PRDR_INT_SETUP_INTR_TMR_THOLD GENMASK(31, 16) +#define HAL_REO1_RING_PRDR_INT_SETUP_BATCH_COUNTER_THOLD GENMASK(14, 0) +#define HAL_REO1_RING_MSI1_BASE_MSB_MSI1_ENABLE BIT(8) +#define HAL_REO1_RING_MSI1_BASE_MSB_ADDR GENMASK(7, 0) +#define HAL_REO1_MISC_CTL_FRAG_DST_RING GENMASK(20, 17) +#define HAL_REO1_MISC_CTL_BAR_DST_RING GENMASK(24, 21) +#define HAL_REO1_GEN_ENABLE_AGING_LIST_ENABLE BIT(2) +#define HAL_REO1_GEN_ENABLE_AGING_FLUSH_ENABLE BIT(3) +#define HAL_REO1_SW_COOKIE_CFG_CMEM_BASE_ADDR_MSB GENMASK(7, 0) +#define HAL_REO1_SW_COOKIE_CFG_COOKIE_PPT_MSB GENMASK(12, 8) +#define HAL_REO1_SW_COOKIE_CFG_COOKIE_SPT_MSB GENMASK(17, 13) +#define HAL_REO1_SW_COOKIE_CFG_ALIGN BIT(18) +#define HAL_REO1_SW_COOKIE_CFG_ENABLE BIT(19) +#define HAL_REO1_SW_COOKIE_CFG_GLOBAL_ENABLE BIT(20) + +/* CE ring bit field mask and shift */ +#define HAL_CE_DST_R0_DEST_CTRL_MAX_LEN GENMASK(15, 0) + +#define HAL_ADDR_LSB_REG_MASK 0xffffffff + +#define HAL_ADDR_MSB_REG_SHIFT 32 + +/* WBM ring bit field mask and shift */ +#define HAL_WBM_LINK_DESC_IDLE_LIST_MODE BIT(1) +#define HAL_WBM_SCATTER_BUFFER_SIZE GENMASK(10, 2) +#define HAL_WBM_SCATTER_RING_SIZE_OF_IDLE_LINK_DESC_LIST GENMASK(31, 16) +#define HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_39_32 GENMASK(7, 0) +#define HAL_WBM_SCATTERED_DESC_MSB_BASE_ADDR_MATCH_TAG GENMASK(31, 8) + +#define HAL_WBM_SCATTERED_DESC_HEAD_P_OFFSET_IX1 GENMASK(20, 8) +#define HAL_WBM_SCATTERED_DESC_TAIL_P_OFFSET_IX1 GENMASK(20, 8) + +#define HAL_WBM_IDLE_LINK_RING_MISC_SRNG_ENABLE BIT(6) +#define HAL_WBM_IDLE_LINK_RING_MISC_RIND_ID_DISABLE BIT(0) + +#define BASE_ADDR_MATCH_TAG_VAL 0x5 + +#define HAL_REO_REO2SW1_RING_BASE_MSB_RING_SIZE 0x000fffff +#define HAL_REO_REO2SW0_RING_BASE_MSB_RING_SIZE 0x000fffff +#define HAL_REO_SW2REO_RING_BASE_MSB_RING_SIZE 0x0000ffff +#define HAL_REO_CMD_RING_BASE_MSB_RING_SIZE 0x0000ffff +#define HAL_REO_STATUS_RING_BASE_MSB_RING_SIZE 0x0000ffff +#define HAL_SW2TCL1_RING_BASE_MSB_RING_SIZE 0x000fffff +#define HAL_SW2TCL1_CMD_RING_BASE_MSB_RING_SIZE 0x000fffff +#define HAL_TCL_STATUS_RING_BASE_MSB_RING_SIZE 0x0000ffff +#define HAL_CE_SRC_RING_BASE_MSB_RING_SIZE 0x0000ffff +#define HAL_CE_DST_RING_BASE_MSB_RING_SIZE 0x0000ffff +#define HAL_CE_DST_STATUS_RING_BASE_MSB_RING_SIZE 0x0000ffff +#define HAL_WBM_IDLE_LINK_RING_BASE_MSB_RING_SIZE 0x000fffff +#define HAL_SW2WBM_RELEASE_RING_BASE_MSB_RING_SIZE 0x0000ffff +#define HAL_WBM2SW_RELEASE_RING_BASE_MSB_RING_SIZE 0x000fffff +#define HAL_RXDMA_RING_MAX_SIZE 0x0000ffff +#define HAL_RXDMA_RING_MAX_SIZE_BE 0x000fffff +#define HAL_WBM2PPE_RELEASE_RING_BASE_MSB_RING_SIZE 0x000fffff + +#define HAL_WBM2SW_REL_ERR_RING_NUM 3 +/* Add any other errors here and return them in +* ath12k_hal_rx_desc_get_err(). +*/ + +enum hal_srng_ring_id { +HAL_SRNG_RING_ID_REO2SW0 =0 , +HAL_SRNG_RING_ID_REO2SW1 , +HAL_SRNG_RING_ID_REO2SW2 , +HAL_SRNG_RING_ID_REO2SW3 , +HAL_SRNG_RING_ID_REO2SW4 , +HAL_SRNG_RING_ID_REO2SW5 , +HAL_SRNG_RING_ID_REO2SW6 , +HAL_SRNG_RING_ID_REO2SW7 , +HAL_SRNG_RING_ID_REO2SW8 , +HAL_SRNG_RING_ID_REO2TCL , +HAL_SRNG_RING_ID_REO2PPE , + +HAL_SRNG_RING_ID_SW2REO =16 , +HAL_SRNG_RING_ID_SW2REO1 , +HAL_SRNG_RING_ID_SW2REO2 , +HAL_SRNG_RING_ID_SW2REO3 , + +HAL_SRNG_RING_ID_REO_CMD , +HAL_SRNG_RING_ID_REO_STATUS , + +HAL_SRNG_RING_ID_SW2TCL1 =24 , +HAL_SRNG_RING_ID_SW2TCL2 , +HAL_SRNG_RING_ID_SW2TCL3 , +HAL_SRNG_RING_ID_SW2TCL4 , +HAL_SRNG_RING_ID_SW2TCL5 , +HAL_SRNG_RING_ID_SW2TCL6 , +HAL_SRNG_RING_ID_PPE2TCL1 =30 , + +HAL_SRNG_RING_ID_SW2TCL_CMD =40 , +HAL_SRNG_RING_ID_SW2TCL1_CMD , +HAL_SRNG_RING_ID_TCL_STATUS , + +HAL_SRNG_RING_ID_CE0_SRC =64 , +HAL_SRNG_RING_ID_CE1_SRC , +HAL_SRNG_RING_ID_CE2_SRC , +HAL_SRNG_RING_ID_CE3_SRC , +HAL_SRNG_RING_ID_CE4_SRC , +HAL_SRNG_RING_ID_CE5_SRC , +HAL_SRNG_RING_ID_CE6_SRC , +HAL_SRNG_RING_ID_CE7_SRC , +HAL_SRNG_RING_ID_CE8_SRC , +HAL_SRNG_RING_ID_CE9_SRC , +HAL_SRNG_RING_ID_CE10_SRC , +HAL_SRNG_RING_ID_CE11_SRC , +HAL_SRNG_RING_ID_CE12_SRC , +HAL_SRNG_RING_ID_CE13_SRC , +HAL_SRNG_RING_ID_CE14_SRC , +HAL_SRNG_RING_ID_CE15_SRC , + +HAL_SRNG_RING_ID_CE0_DST =81 , +HAL_SRNG_RING_ID_CE1_DST , +HAL_SRNG_RING_ID_CE2_DST , +HAL_SRNG_RING_ID_CE3_DST , +HAL_SRNG_RING_ID_CE4_DST , +HAL_SRNG_RING_ID_CE5_DST , +HAL_SRNG_RING_ID_CE6_DST , +HAL_SRNG_RING_ID_CE7_DST , +HAL_SRNG_RING_ID_CE8_DST , +HAL_SRNG_RING_ID_CE9_DST , +HAL_SRNG_RING_ID_CE10_DST , +HAL_SRNG_RING_ID_CE11_DST , +HAL_SRNG_RING_ID_CE12_DST , +HAL_SRNG_RING_ID_CE13_DST , +HAL_SRNG_RING_ID_CE14_DST , +HAL_SRNG_RING_ID_CE15_DST , + +HAL_SRNG_RING_ID_CE0_DST_STATUS =100 , +HAL_SRNG_RING_ID_CE1_DST_STATUS , +HAL_SRNG_RING_ID_CE2_DST_STATUS , +HAL_SRNG_RING_ID_CE3_DST_STATUS , +HAL_SRNG_RING_ID_CE4_DST_STATUS , +HAL_SRNG_RING_ID_CE5_DST_STATUS , +HAL_SRNG_RING_ID_CE6_DST_STATUS , +HAL_SRNG_RING_ID_CE7_DST_STATUS , +HAL_SRNG_RING_ID_CE8_DST_STATUS , +HAL_SRNG_RING_ID_CE9_DST_STATUS , +HAL_SRNG_RING_ID_CE10_DST_STATUS , +HAL_SRNG_RING_ID_CE11_DST_STATUS , +HAL_SRNG_RING_ID_CE12_DST_STATUS , +HAL_SRNG_RING_ID_CE13_DST_STATUS , +HAL_SRNG_RING_ID_CE14_DST_STATUS , +HAL_SRNG_RING_ID_CE15_DST_STATUS , + +HAL_SRNG_RING_ID_WBM_IDLE_LINK =120 , +HAL_SRNG_RING_ID_WBM_SW0_RELEASE , +HAL_SRNG_RING_ID_WBM_SW1_RELEASE , +HAL_SRNG_RING_ID_WBM_PPE_RELEASE =123 , + +HAL_SRNG_RING_ID_WBM2SW0_RELEASE =128 , +HAL_SRNG_RING_ID_WBM2SW1_RELEASE , +HAL_SRNG_RING_ID_WBM2SW2_RELEASE , +HAL_SRNG_RING_ID_WBM2SW3_RELEASE ,/* RX ERROR RING */ +HAL_SRNG_RING_ID_WBM2SW4_RELEASE , +HAL_SRNG_RING_ID_WBM2SW5_RELEASE , +HAL_SRNG_RING_ID_WBM2SW6_RELEASE , +HAL_SRNG_RING_ID_WBM2SW7_RELEASE , + +HAL_SRNG_RING_ID_UMAC_ID_END =159 , + +/* Common DMAC rings shared by all LMACs */ +HAL_SRNG_RING_ID_DMAC_CMN_ID_START =160 , +HAL_SRNG_SW2RXDMA_BUF0 =HAL_SRNG_RING_ID_DMAC_CMN_ID_START , +HAL_SRNG_SW2RXDMA_BUF1 =161 , +HAL_SRNG_SW2RXDMA_BUF2 =162 , + +HAL_SRNG_SW2RXMON_BUF0 =168 , + +HAL_SRNG_SW2TXMON_BUF0 =176 , + +HAL_SRNG_RING_ID_DMAC_CMN_ID_END =183 , +HAL_SRNG_RING_ID_PMAC1_ID_START =184 , + +HAL_SRNG_RING_ID_WMAC1_SW2RXMON_BUF0 =HAL_SRNG_RING_ID_PMAC1_ID_START , + +HAL_SRNG_RING_ID_WMAC1_RXDMA2SW0 , +HAL_SRNG_RING_ID_WMAC1_RXDMA2SW1 , +HAL_SRNG_RING_ID_WMAC1_RXMON2SW0 =HAL_SRNG_RING_ID_WMAC1_RXDMA2SW1 , +HAL_SRNG_RING_ID_WMAC1_SW2RXDMA1_DESC , +HAL_SRNG_RING_ID_RXDMA_DIR_BUF , +HAL_SRNG_RING_ID_WMAC1_SW2TXMON_BUF0 , +HAL_SRNG_RING_ID_WMAC1_TXMON2SW0_BUF0 , + +HAL_SRNG_RING_ID_PMAC1_ID_END , +}; + +/* SRNG registers are split into two groups R0 and R2 */ +#define HAL_SRNG_REG_GRP_R0 0 +#define HAL_SRNG_REG_GRP_R2 1 +#define HAL_SRNG_NUM_REG_GRP 2 + +/* TODO: number of PMACs */ +#define HAL_SRNG_NUM_PMACS 3 +#define HAL_SRNG_NUM_DMAC_RINGS (HAL_SRNG_RING_ID_DMAC_CMN_ID_END - \ + HAL_SRNG_RING_ID_DMAC_CMN_ID_START) +#define HAL_SRNG_RINGS_PER_PMAC (HAL_SRNG_RING_ID_PMAC1_ID_END - \ + HAL_SRNG_RING_ID_PMAC1_ID_START) +#define HAL_SRNG_NUM_PMAC_RINGS (HAL_SRNG_NUM_PMACS * HAL_SRNG_RINGS_PER_PMAC) +#define HAL_SRNG_RING_ID_MAX (HAL_SRNG_RING_ID_DMAC_CMN_ID_END + \ + HAL_SRNG_NUM_PMAC_RINGS) + +enum hal_ring_type { +HAL_REO_DST , +HAL_REO_EXCEPTION , +HAL_REO_REINJECT , +HAL_REO_CMD , +HAL_REO_STATUS , +HAL_TCL_DATA , +HAL_TCL_CMD , +HAL_TCL_STATUS , +HAL_CE_SRC , +HAL_CE_DST , +HAL_CE_DST_STATUS , +HAL_WBM_IDLE_LINK , +HAL_SW2WBM_RELEASE , +HAL_WBM2SW_RELEASE , +HAL_RXDMA_BUF , +HAL_RXDMA_DST , +HAL_RXDMA_MONITOR_BUF , +HAL_RXDMA_MONITOR_STATUS , +HAL_RXDMA_MONITOR_DST , +HAL_RXDMA_MONITOR_DESC , +HAL_RXDMA_DIR_BUF , +HAL_PPE2TCL , +HAL_PPE_RELEASE , +HAL_TX_MONITOR_BUF , +HAL_TX_MONITOR_DST , +HAL_MAX_RING_TYPES , +}; + +#define HAL_RX_MAX_BA_WINDOW 256 + +#define HAL_DEFAULT_BE_BK_VI_REO_TIMEOUT_USEC (100 * 1000) +#define HAL_DEFAULT_VO_REO_TIMEOUT_USEC (40 * 1000) + +/** +* enum hal_reo_cmd_type: Enum for REO command type +* @HAL_REO_CMD_GET_QUEUE_STATS: Get REO queue status/stats +* @HAL_REO_CMD_FLUSH_QUEUE: Flush all frames in REO queue +* @HAL_REO_CMD_FLUSH_CACHE: Flush descriptor entries in the cache +* @HAL_REO_CMD_UNBLOCK_CACHE: Unblock a descriptor's address that was blocked +* earlier with a 'REO_FLUSH_CACHE' command +* @HAL_REO_CMD_FLUSH_TIMEOUT_LIST: Flush buffers/descriptors from timeout list +* @HAL_REO_CMD_UPDATE_RX_QUEUE: Update REO queue settings +*/ +enum hal_reo_cmd_type { +HAL_REO_CMD_GET_QUEUE_STATS =0 , +HAL_REO_CMD_FLUSH_QUEUE =1 , +HAL_REO_CMD_FLUSH_CACHE =2 , +HAL_REO_CMD_UNBLOCK_CACHE =3 , +HAL_REO_CMD_FLUSH_TIMEOUT_LIST =4 , +HAL_REO_CMD_UPDATE_RX_QUEUE =5 , +}; + +/** +* enum hal_reo_cmd_status: Enum for execution status of REO command +* @HAL_REO_CMD_SUCCESS: Command has successfully executed +* @HAL_REO_CMD_BLOCKED: Command could not be executed as the queue +* or cache was blocked +* @HAL_REO_CMD_FAILED: Command execution failed, could be due to +* invalid queue desc +* @HAL_REO_CMD_RESOURCE_BLOCKED: +* @HAL_REO_CMD_DRAIN: +*/ +enum hal_reo_cmd_status { +HAL_REO_CMD_SUCCESS =0 , +HAL_REO_CMD_BLOCKED =1 , +HAL_REO_CMD_FAILED =2 , +HAL_REO_CMD_RESOURCE_BLOCKED =3 , +HAL_REO_CMD_DRAIN =0xff , +}; + +struct hal_wbm_idle_scatter_list { +dma_addr_t paddr; +struct hal_wbm_link_desc *vaddr; +}; + +struct hal_srng_params { +dma_addr_t ring_base_paddr; +u32 *ring_base_vaddr; +int num_entries; +u32 intr_batch_cntr_thres_entries; +u32 intr_timer_thres_us; +u32 flags; +u32 max_buffer_len; +u32 low_threshold; +u32 high_threshold; +dma_addr_t msi_addr; +dma_addr_t msi2_addr; +u32 msi_data; +u32 msi2_data; + +/* Add more params as needed */ +}; + +enum hal_srng_dir { +HAL_SRNG_DIR_SRC , +HAL_SRNG_DIR_DST +}; + +/* srng flags */ +#define HAL_SRNG_FLAGS_MSI_SWAP 0x00000008 +#define HAL_SRNG_FLAGS_RING_PTR_SWAP 0x00000010 +#define HAL_SRNG_FLAGS_DATA_TLV_SWAP 0x00000020 +#define HAL_SRNG_FLAGS_LOW_THRESH_INTR_EN 0x00010000 +#define HAL_SRNG_FLAGS_MSI_INTR 0x00020000 +#define HAL_SRNG_FLAGS_HIGH_THRESH_INTR_EN 0x00080000 +#define HAL_SRNG_FLAGS_LMAC_RING 0x80000000 + +#define HAL_SRNG_TLV_HDR_TAG GENMASK(9, 1) +#define HAL_SRNG_TLV_HDR_LEN GENMASK(25, 10) + +/* Common SRNG ring structure for source and destination rings */ +struct hal_srng { +/* Unique SRNG ring ID */ +u8 ring_id; + +/* Ring initialization done */ +u8 initialized; + +/* Interrupt/MSI value assigned to this ring */ +int irq; + +/* Physical base address of the ring */ +dma_addr_t ring_base_paddr; + +/* Virtual base address of the ring */ +u32 *ring_base_vaddr; + +/* Number of entries in ring */ +u32 num_entries; + +/* Ring size */ +u32 ring_size; + +/* Ring size mask */ +u32 ring_size_mask; + +/* Size of ring entry */ +u32 entry_size; + +/* Interrupt timer threshold - in micro seconds */ +u32 intr_timer_thres_us; + +/* Interrupt batch counter threshold - in number of ring entries */ +u32 intr_batch_cntr_thres_entries; + +/* MSI Address */ +dma_addr_t msi_addr; + +/* MSI data */ +u32 msi_data; + +/* MSI2 Address */ +dma_addr_t msi2_addr; + +/* MSI2 data */ +u32 msi2_data; + +/* Misc flags */ +u32 flags; + +/* Lock for serializing ring index updates */ +spinlock_t lock; + +struct lock_class_key lock_key; + +/* Start offset of SRNG register groups for this ring +* TBD: See if this is required - register address can be derived +* from ring ID +*/ +u32 hwreg_base[HAL_SRNG_NUM_REG_GRP ]; + +u64 timestamp; + +/* Source or Destination ring */ +enum hal_srng_dir ring_dir; + +union { +struct { +/* SW tail pointer */ +u32 tp; + +/* Shadow head pointer location to be updated by HW */ +volatile u32 *hp_addr; + +/* Cached head pointer */ +u32 cached_hp; + +/* Tail pointer location to be updated by SW - This +* will be a register address and need not be +* accessed through SW structure +*/ +u32 *tp_addr; + +/* Current SW loop cnt */ +u32 loop_cnt; + +/* max transfer size */ +u16 max_buffer_length; + +/* head pointer at access end */ +u32 last_hp; + } dst_ring; + +struct { +/* SW head pointer */ +u32 hp; + +/* SW reap head pointer */ +u32 reap_hp; + +/* Shadow tail pointer location to be updated by HW */ +u32 *tp_addr; + +/* Cached tail pointer */ +u32 cached_tp; + +/* Head pointer location to be updated by SW - This +* will be a register address and need not be accessed +* through SW structure +*/ +u32 *hp_addr; + +/* Low threshold - in number of ring entries */ +u32 low_threshold; + +/* tail pointer at access end */ +u32 last_tp; + } src_ring; + } u; +}; + +/* Interrupt mitigation - Batch threshold in terms of numer of frames */ +#define HAL_SRNG_INT_BATCH_THRESHOLD_TX 256 +#define HAL_SRNG_INT_BATCH_THRESHOLD_RX 128 +#define HAL_SRNG_INT_BATCH_THRESHOLD_OTHER 1 + +/* Interrupt mitigation - timer threshold in us */ +#define HAL_SRNG_INT_TIMER_THRESHOLD_TX 1000 +#define HAL_SRNG_INT_TIMER_THRESHOLD_RX 500 +#define HAL_SRNG_INT_TIMER_THRESHOLD_OTHER 256 + +enum hal_srng_mac_type { +ATH12K_HAL_SRNG_UMAC , +ATH12K_HAL_SRNG_DMAC , +ATH12K_HAL_SRNG_PMAC +}; + +/* HW SRNG configuration table */ +struct hal_srng_config { +int start_ring_id; +u16 max_rings; +u16 entry_size; +u32 reg_start[HAL_SRNG_NUM_REG_GRP ]; +u16 reg_size[HAL_SRNG_NUM_REG_GRP ]; +enum hal_srng_mac_type mac_type; +enum hal_srng_dir ring_dir; +u32 max_size; +}; + +/** +* enum hal_rx_buf_return_buf_manager +* +* @HAL_RX_BUF_RBM_WBM_IDLE_BUF_LIST: Buffer returned to WBM idle buffer list +* @HAL_RX_BUF_RBM_WBM_CHIP0_IDLE_DESC_LIST: Descriptor returned to WBM idle +* descriptor list, where the chip 0 WBM is chosen in case of a multi-chip config +* @HAL_RX_BUF_RBM_WBM_CHIP1_IDLE_DESC_LIST: Descriptor returned to WBM idle +* descriptor list, where the chip 1 WBM is chosen in case of a multi-chip config +* @HAL_RX_BUF_RBM_WBM_CHIP2_IDLE_DESC_LIST: Descriptor returned to WBM idle +* descriptor list, where the chip 2 WBM is chosen in case of a multi-chip config +* @HAL_RX_BUF_RBM_FW_BM: Buffer returned to FW +* @HAL_RX_BUF_RBM_SW0_BM: For ring 0 -- returned to host +* @HAL_RX_BUF_RBM_SW1_BM: For ring 1 -- returned to host +* @HAL_RX_BUF_RBM_SW2_BM: For ring 2 -- returned to host +* @HAL_RX_BUF_RBM_SW3_BM: For ring 3 -- returned to host +* @HAL_RX_BUF_RBM_SW4_BM: For ring 4 -- returned to host +* @HAL_RX_BUF_RBM_SW5_BM: For ring 5 -- returned to host +* @HAL_RX_BUF_RBM_SW6_BM: For ring 6 -- returned to host +*/ + +enum hal_rx_buf_return_buf_manager { +HAL_RX_BUF_RBM_WBM_IDLE_BUF_LIST , +HAL_RX_BUF_RBM_WBM_CHIP0_IDLE_DESC_LIST , +HAL_RX_BUF_RBM_WBM_CHIP1_IDLE_DESC_LIST , +HAL_RX_BUF_RBM_WBM_CHIP2_IDLE_DESC_LIST , +HAL_RX_BUF_RBM_FW_BM , +HAL_RX_BUF_RBM_SW0_BM , +HAL_RX_BUF_RBM_SW1_BM , +HAL_RX_BUF_RBM_SW2_BM , +HAL_RX_BUF_RBM_SW3_BM , +HAL_RX_BUF_RBM_SW4_BM , +HAL_RX_BUF_RBM_SW5_BM , +HAL_RX_BUF_RBM_SW6_BM , +}; + +#define HAL_SRNG_DESC_LOOP_CNT 0xf0000000 + +#define HAL_REO_CMD_FLG_NEED_STATUS BIT(0) +#define HAL_REO_CMD_FLG_STATS_CLEAR BIT(1) +#define HAL_REO_CMD_FLG_FLUSH_BLOCK_LATER BIT(2) +#define HAL_REO_CMD_FLG_FLUSH_RELEASE_BLOCKING BIT(3) +#define HAL_REO_CMD_FLG_FLUSH_NO_INVAL BIT(4) +#define HAL_REO_CMD_FLG_FLUSH_FWD_ALL_MPDUS BIT(5) +#define HAL_REO_CMD_FLG_FLUSH_ALL BIT(6) +#define HAL_REO_CMD_FLG_UNBLK_RESOURCE BIT(7) +#define HAL_REO_CMD_FLG_UNBLK_CACHE BIT(8) + +/* Should be matching with HAL_REO_UPD_RX_QUEUE_INFO0_UPD_* feilds */ +#define HAL_REO_CMD_UPD0_RX_QUEUE_NUM BIT(8) +#define HAL_REO_CMD_UPD0_VLD BIT(9) +#define HAL_REO_CMD_UPD0_ALDC BIT(10) +#define HAL_REO_CMD_UPD0_DIS_DUP_DETECTION BIT(11) +#define HAL_REO_CMD_UPD0_SOFT_REORDER_EN BIT(12) +#define HAL_REO_CMD_UPD0_AC BIT(13) +#define HAL_REO_CMD_UPD0_BAR BIT(14) +#define HAL_REO_CMD_UPD0_RETRY BIT(15) +#define HAL_REO_CMD_UPD0_CHECK_2K_MODE BIT(16) +#define HAL_REO_CMD_UPD0_OOR_MODE BIT(17) +#define HAL_REO_CMD_UPD0_BA_WINDOW_SIZE BIT(18) +#define HAL_REO_CMD_UPD0_PN_CHECK BIT(19) +#define HAL_REO_CMD_UPD0_EVEN_PN BIT(20) +#define HAL_REO_CMD_UPD0_UNEVEN_PN BIT(21) +#define HAL_REO_CMD_UPD0_PN_HANDLE_ENABLE BIT(22) +#define HAL_REO_CMD_UPD0_PN_SIZE BIT(23) +#define HAL_REO_CMD_UPD0_IGNORE_AMPDU_FLG BIT(24) +#define HAL_REO_CMD_UPD0_SVLD BIT(25) +#define HAL_REO_CMD_UPD0_SSN BIT(26) +#define HAL_REO_CMD_UPD0_SEQ_2K_ERR BIT(27) +#define HAL_REO_CMD_UPD0_PN_ERR BIT(28) +#define HAL_REO_CMD_UPD0_PN_VALID BIT(29) +#define HAL_REO_CMD_UPD0_PN BIT(30) + +/* Should be matching with HAL_REO_UPD_RX_QUEUE_INFO1_* feilds */ +#define HAL_REO_CMD_UPD1_VLD BIT(16) +#define HAL_REO_CMD_UPD1_ALDC GENMASK(18, 17) +#define HAL_REO_CMD_UPD1_DIS_DUP_DETECTION BIT(19) +#define HAL_REO_CMD_UPD1_SOFT_REORDER_EN BIT(20) +#define HAL_REO_CMD_UPD1_AC GENMASK(22, 21) +#define HAL_REO_CMD_UPD1_BAR BIT(23) +#define HAL_REO_CMD_UPD1_RETRY BIT(24) +#define HAL_REO_CMD_UPD1_CHECK_2K_MODE BIT(25) +#define HAL_REO_CMD_UPD1_OOR_MODE BIT(26) +#define HAL_REO_CMD_UPD1_PN_CHECK BIT(27) +#define HAL_REO_CMD_UPD1_EVEN_PN BIT(28) +#define HAL_REO_CMD_UPD1_UNEVEN_PN BIT(29) +#define HAL_REO_CMD_UPD1_PN_HANDLE_ENABLE BIT(30) +#define HAL_REO_CMD_UPD1_IGNORE_AMPDU_FLG BIT(31) + +/* Should be matching with HAL_REO_UPD_RX_QUEUE_INFO2_* feilds */ +#define HAL_REO_CMD_UPD2_SVLD BIT(10) +#define HAL_REO_CMD_UPD2_SSN GENMASK(22, 11) +#define HAL_REO_CMD_UPD2_SEQ_2K_ERR BIT(23) +#define HAL_REO_CMD_UPD2_PN_ERR BIT(24) + +struct ath12k_hal_reo_cmd { +u32 addr_lo; +u32 flag; +u32 upd0; +u32 upd1; +u32 upd2; +u32 pn[4 ]; +u16 rx_queue_num; +u16 min_rel; +u16 min_fwd; +u8 addr_hi; +u8 ac_list; +u8 blocking_idx; +u16 ba_window_size; +u8 pn_size; +}; + +enum hal_pn_type { +HAL_PN_TYPE_NONE , +HAL_PN_TYPE_WPA , +HAL_PN_TYPE_WAPI_EVEN , +HAL_PN_TYPE_WAPI_UNEVEN , +}; + +enum hal_ce_desc { +HAL_CE_DESC_SRC , +HAL_CE_DESC_DST , +HAL_CE_DESC_DST_STATUS , +}; + +#define HAL_HASH_ROUTING_RING_TCL 0 +#define HAL_HASH_ROUTING_RING_SW1 1 +#define HAL_HASH_ROUTING_RING_SW2 2 +#define HAL_HASH_ROUTING_RING_SW3 3 +#define HAL_HASH_ROUTING_RING_SW4 4 +#define HAL_HASH_ROUTING_RING_REL 5 +#define HAL_HASH_ROUTING_RING_FW 6 + +struct hal_reo_status_header { +u16 cmd_num; +enum hal_reo_cmd_status cmd_status; +u16 cmd_exe_time; +u32 timestamp; +}; + +struct hal_reo_status_queue_stats { +u16 ssn; +u16 curr_idx; +u32 pn[4 ]; +u32 last_rx_queue_ts; +u32 last_rx_dequeue_ts; +u32 rx_bitmap[8 ];/* Bitmap from 0-255 */ +u32 curr_mpdu_cnt; +u32 curr_msdu_cnt; +u16 fwd_due_to_bar_cnt; +u16 dup_cnt; +u32 frames_in_order_cnt; +u32 num_mpdu_processed_cnt; +u32 num_msdu_processed_cnt; +u32 total_num_processed_byte_cnt; +u32 late_rx_mpdu_cnt; +u32 reorder_hole_cnt; +u8 timeout_cnt; +u8 bar_rx_cnt; +u8 num_window_2k_jump_cnt; +}; + +struct hal_reo_status_flush_queue { +bool err_detected; +}; + +enum hal_reo_status_flush_cache_err_code { +HAL_REO_STATUS_FLUSH_CACHE_ERR_CODE_SUCCESS , +HAL_REO_STATUS_FLUSH_CACHE_ERR_CODE_IN_USE , +HAL_REO_STATUS_FLUSH_CACHE_ERR_CODE_NOT_FOUND , +}; + +struct hal_reo_status_flush_cache { +bool err_detected; +enum hal_reo_status_flush_cache_err_code err_code; +bool cache_controller_flush_status_hit; +u8 cache_controller_flush_status_desc_type; +u8 cache_controller_flush_status_client_id; +u8 cache_controller_flush_status_err; +u8 cache_controller_flush_status_cnt; +}; + +enum hal_reo_status_unblock_cache_type { +HAL_REO_STATUS_UNBLOCK_BLOCKING_RESOURCE , +HAL_REO_STATUS_UNBLOCK_ENTIRE_CACHE_USAGE , +}; + +struct hal_reo_status_unblock_cache { +bool err_detected; +enum hal_reo_status_unblock_cache_type unblock_type; +}; + +struct hal_reo_status_flush_timeout_list { +bool err_detected; +bool list_empty; +u16 release_desc_cnt; +u16 fwd_buf_cnt; +}; + +enum hal_reo_threshold_idx { +HAL_REO_THRESHOLD_IDX_DESC_COUNTER0 , +HAL_REO_THRESHOLD_IDX_DESC_COUNTER1 , +HAL_REO_THRESHOLD_IDX_DESC_COUNTER2 , +HAL_REO_THRESHOLD_IDX_DESC_COUNTER_SUM , +}; + +struct hal_reo_status_desc_thresh_reached { +enum hal_reo_threshold_idx threshold_idx; +u32 link_desc_counter0; +u32 link_desc_counter1; +u32 link_desc_counter2; +u32 link_desc_counter_sum; +}; + +struct hal_reo_status { +struct hal_reo_status_header uniform_hdr; +u8 loop_cnt; +union { +struct hal_reo_status_queue_stats queue_stats; +struct hal_reo_status_flush_queue flush_queue; +struct hal_reo_status_flush_cache flush_cache; +struct hal_reo_status_unblock_cache unblock_cache; +struct hal_reo_status_flush_timeout_list timeout_list; +struct hal_reo_status_desc_thresh_reached desc_thresh_reached; + } u; +}; + +/* HAL context to be used to access SRNG APIs (currently used by data path +* and transport (CE) modules) +*/ +struct ath12k_hal { +/* HAL internal state for all SRNG rings. +*/ +struct hal_srng srng_list[HAL_SRNG_RING_ID_MAX ]; + +/* SRNG configuration table */ +struct hal_srng_config *srng_config; + +/* Remote pointer memory for HW/FW updates */ +struct { +u32 *vaddr; +dma_addr_t paddr; + } rdp; + +/* Shared memory for ring pointer updates from host to FW */ +struct { +u32 *vaddr; +dma_addr_t paddr; + } wrp; + +/* Available REO blocking resources bitmap */ +u8 avail_blk_resource; + +u8 current_blk_index; + +/* shadow register configuration */ +u32 shadow_reg_addr[HAL_SHADOW_NUM_REGS ]; +int num_shadow_reg_configured; +}; + +/* Maps WBM ring number and Return Buffer Manager Id per TCL ring */ +struct ath12k_hal_tcl_to_wbm_rbm_map { +u8 wbm_ring_num; +u8 rbm_id; +}; + +struct hal_ops { +bool (*rx_desc_get_first_msdu)(struct hal_rx_desc *desc); +bool (*rx_desc_get_last_msdu)(struct hal_rx_desc *desc); +u8 (*rx_desc_get_l3_pad_bytes)(struct hal_rx_desc *desc); +u8 *(*rx_desc_get_hdr_status)(struct hal_rx_desc *desc); +bool (*rx_desc_encrypt_valid)(struct hal_rx_desc *desc); +u32 (*rx_desc_get_encrypt_type)(struct hal_rx_desc *desc); +u8 (*rx_desc_get_decap_type)(struct hal_rx_desc *desc); +u8 (*rx_desc_get_mesh_ctl)(struct hal_rx_desc *desc); +bool (*rx_desc_get_mpdu_seq_ctl_vld)(struct hal_rx_desc *desc); +bool (*rx_desc_get_mpdu_fc_valid)(struct hal_rx_desc *desc); +u16 (*rx_desc_get_mpdu_start_seq_no)(struct hal_rx_desc *desc); +u16 (*rx_desc_get_msdu_len)(struct hal_rx_desc *desc); +u8 (*rx_desc_get_msdu_sgi)(struct hal_rx_desc *desc); +u8 (*rx_desc_get_msdu_rate_mcs)(struct hal_rx_desc *desc); +u8 (*rx_desc_get_msdu_rx_bw)(struct hal_rx_desc *desc); +u32 (*rx_desc_get_msdu_freq)(struct hal_rx_desc *desc); +u8 (*rx_desc_get_msdu_pkt_type)(struct hal_rx_desc *desc); +u8 (*rx_desc_get_msdu_nss)(struct hal_rx_desc *desc); +u8 (*rx_desc_get_mpdu_tid)(struct hal_rx_desc *desc); +u16 (*rx_desc_get_mpdu_peer_id)(struct hal_rx_desc *desc); +void (*rx_desc_copy_end_tlv)(struct hal_rx_desc *fdesc, +struct hal_rx_desc *ldesc); +u32 (*rx_desc_get_mpdu_start_tag)(struct hal_rx_desc *desc); +u32 (*rx_desc_get_mpdu_ppdu_id)(struct hal_rx_desc *desc); +void (*rx_desc_set_msdu_len)(struct hal_rx_desc *desc,u16 len); +struct rx_attention *(*rx_desc_get_attention)(struct hal_rx_desc *desc); +u8 *(*rx_desc_get_msdu_payload)(struct hal_rx_desc *desc); +u32 (*rx_desc_get_mpdu_start_offset)(void ); +u32 (*rx_desc_get_msdu_end_offset)(void ); +bool (*rx_desc_mac_addr2_valid)(struct hal_rx_desc *desc); +u8 * (*rx_desc_mpdu_start_addr2)(struct hal_rx_desc *desc); +bool (*rx_desc_is_mcbc)(struct hal_rx_desc *desc); +void (*rx_desc_get_dot11_hdr)(struct hal_rx_desc *desc, +struct ieee80211_hdr *hdr); +u16 (*rx_desc_get_mpdu_frame_ctl)(struct hal_rx_desc *desc); +void (*rx_desc_get_crypto_header)(struct hal_rx_desc *desc, +u8 *crypto_hdr, +enum hal_encrypt_type enctype); +int (*create_srng_config)(struct ath12k_base *ab); +bool (*dp_rx_h_msdu_done)(struct hal_rx_desc *desc); +bool (*dp_rx_h_l4_cksum_fail)(struct hal_rx_desc *desc); +bool (*dp_rx_h_ip_cksum_fail)(struct hal_rx_desc *desc); +bool (*dp_rx_h_is_decrypted)(struct hal_rx_desc *desc); +u32 (*dp_rx_h_mpdu_err)(struct hal_rx_desc *desc); +const struct ath12k_hal_tcl_to_wbm_rbm_map *tcl_to_wbm_rbm_map; +}; + +extern const struct hal_ops hal_qcn9274_ops; +extern const struct hal_ops hal_wcn7850_ops; + +u32 ath12k_hal_reo_qdesc_size (u32 ba_window_size,u8 tid); +void ath12k_hal_reo_qdesc_setup (struct hal_rx_reo_queue *qdesc, +int tid,u32 ba_window_size, +u32 start_seq,enum hal_pn_type type); +void ath12k_hal_reo_init_cmd_ring (struct ath12k_base *ab, +struct hal_srng *srng); +void ath12k_hal_reo_hw_setup (struct ath12k_base *ab,u32 ring_hash_map); +void ath12k_hal_setup_link_idle_list (struct ath12k_base *ab, +struct hal_wbm_idle_scatter_list *sbuf, +u32 nsbufs,u32 tot_link_desc, +u32 end_offset); + +dma_addr_t ath12k_hal_srng_get_tp_addr (struct ath12k_base *ab, +struct hal_srng *srng); +dma_addr_t ath12k_hal_srng_get_hp_addr (struct ath12k_base *ab, +struct hal_srng *srng); +void ath12k_hal_set_link_desc_addr (struct hal_wbm_link_desc *desc,u32 cookie, +dma_addr_t paddr); +u32 ath12k_hal_ce_get_desc_size (enum hal_ce_desc type); +void ath12k_hal_ce_src_set_desc (struct hal_ce_srng_src_desc *desc,dma_addr_t paddr, +u32 len,u32 id,u8 byte_swap_data); +void ath12k_hal_ce_dst_set_desc (struct hal_ce_srng_dest_desc *desc,dma_addr_t paddr); +u32 ath12k_hal_ce_dst_status_get_length (struct hal_ce_srng_dst_status_desc *desc); +int ath12k_hal_srng_get_entrysize (struct ath12k_base *ab,u32 ring_type); +int ath12k_hal_srng_get_max_entries (struct ath12k_base *ab,u32 ring_type); +void ath12k_hal_srng_get_params (struct ath12k_base *ab,struct hal_srng *srng, +struct hal_srng_params *params); +void *ath12k_hal_srng_dst_get_next_entry (struct ath12k_base *ab, +struct hal_srng *srng); +void *ath12k_hal_srng_dst_peek (struct ath12k_base *ab,struct hal_srng *srng); +int ath12k_hal_srng_dst_num_free (struct ath12k_base *ab,struct hal_srng *srng, +bool sync_hw_ptr); +void *ath12k_hal_srng_src_get_next_reaped (struct ath12k_base *ab, +struct hal_srng *srng); +void *ath12k_hal_srng_src_reap_next (struct ath12k_base *ab, +struct hal_srng *srng); +void *ath12k_hal_srng_src_get_next_entry (struct ath12k_base *ab, +struct hal_srng *srng); +int ath12k_hal_srng_src_num_free (struct ath12k_base *ab,struct hal_srng *srng, +bool sync_hw_ptr); +void ath12k_hal_srng_access_begin (struct ath12k_base *ab, +struct hal_srng *srng); +void ath12k_hal_srng_access_end (struct ath12k_base *ab,struct hal_srng *srng); +int ath12k_hal_srng_setup (struct ath12k_base *ab,enum hal_ring_type type, +int ring_num,int mac_id, +struct hal_srng_params *params); +int ath12k_hal_srng_init (struct ath12k_base *ath12k); +void ath12k_hal_srng_deinit (struct ath12k_base *ath12k); +void ath12k_hal_dump_srng_stats (struct ath12k_base *ab); +void ath12k_hal_srng_get_shadow_config (struct ath12k_base *ab, +u32 **cfg,u32 *len); +int ath12k_hal_srng_update_shadow_config (struct ath12k_base *ab, +enum hal_ring_type ring_type, +int ring_num); +void ath12k_hal_srng_shadow_config (struct ath12k_base *ab); +void ath12k_hal_srng_shadow_update_hp_tp (struct ath12k_base *ab, +struct hal_srng *srng); +#endif
Signature · 3 lines
ath12k mailing list [email protected] https://lists.infradead.org/mailman/listinfo/ath12k
PATCH v2 21/50 wifi: ath12k: add hal_desc.h
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hal_desc.h | 2961 ++++++++++++++++++++++++++++ 1 file changed, 2961 insertions(+)
drivers/net/wireless/ath/ath12k/hal_desc.h new file +2961 -0
@@ -0,0 +1,2961 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ +#include "core.h" + +#ifndef ATH12K_HAL_DESC_H +#define ATH12K_HAL_DESC_H + +#define BUFFER_ADDR_INFO0_ADDR GENMASK(31, 0) + +#define BUFFER_ADDR_INFO1_ADDR GENMASK(7, 0) +#define BUFFER_ADDR_INFO1_RET_BUF_MGR GENMASK(11, 8) +#define BUFFER_ADDR_INFO1_SW_COOKIE GENMASK(31, 12) + +struct ath12k_buffer_addr { +__le32 info0; +__le32 info1; +} __packed; + +/* ath12k_buffer_addr +* +* buffer_addr_31_0 +* Address (lower 32 bits) of the MSDU buffer or MSDU_EXTENSION +* descriptor or Link descriptor +* +* buffer_addr_39_32 +* Address (upper 8 bits) of the MSDU buffer or MSDU_EXTENSION +* descriptor or Link descriptor +* +* return_buffer_manager (RBM) +* Consumer: WBM +* Producer: SW/FW +* Indicates to which buffer manager the buffer or MSDU_EXTENSION +* descriptor or link descriptor that is being pointed to shall be +* returned after the frame has been processed. It is used by WBM +* for routing purposes. +* +* Values are defined in enum %HAL_RX_BUF_RBM_ +* +* sw_buffer_cookie +* Cookie field exclusively used by SW. HW ignores the contents, +* accept that it passes the programmed value on to other +* descriptors together with the physical address. +* +* Field can be used by SW to for example associate the buffers +* physical address with the virtual address. +* +* NOTE1: +* The three most significant bits can have a special meaning +* in case this struct is embedded in a TX_MPDU_DETAILS STRUCT, +* and field transmit_bw_restriction is set +* +* In case of NON punctured transmission: +* Sw_buffer_cookie[19:17] = 3'b000: 20 MHz TX only +* Sw_buffer_cookie[19:17] = 3'b001: 40 MHz TX only +* Sw_buffer_cookie[19:17] = 3'b010: 80 MHz TX only +* Sw_buffer_cookie[19:17] = 3'b011: 160 MHz TX only +* Sw_buffer_cookie[19:17] = 3'b101: 240 MHz TX only +* Sw_buffer_cookie[19:17] = 3'b100: 320 MHz TX only +* Sw_buffer_cookie[19:18] = 2'b11: reserved +* +* In case of punctured transmission: +* Sw_buffer_cookie[19:16] = 4'b0000: pattern 0 only +* Sw_buffer_cookie[19:16] = 4'b0001: pattern 1 only +* Sw_buffer_cookie[19:16] = 4'b0010: pattern 2 only +* Sw_buffer_cookie[19:16] = 4'b0011: pattern 3 only +* Sw_buffer_cookie[19:16] = 4'b0100: pattern 4 only +* Sw_buffer_cookie[19:16] = 4'b0101: pattern 5 only +* Sw_buffer_cookie[19:16] = 4'b0110: pattern 6 only +* Sw_buffer_cookie[19:16] = 4'b0111: pattern 7 only +* Sw_buffer_cookie[19:16] = 4'b1000: pattern 8 only +* Sw_buffer_cookie[19:16] = 4'b1001: pattern 9 only +* Sw_buffer_cookie[19:16] = 4'b1010: pattern 10 only +* Sw_buffer_cookie[19:16] = 4'b1011: pattern 11 only +* Sw_buffer_cookie[19:18] = 2'b11: reserved +* +* Note: a punctured transmission is indicated by the presence +* of TLV TX_PUNCTURE_SETUP embedded in the scheduler TLV +* +* Sw_buffer_cookie[20:17]: Tid: The TID field in the QoS control +* field +* +* Sw_buffer_cookie[16]: Mpdu_qos_control_valid: This field +* indicates MPDUs with a QoS control field. +* +*/ + +enum hal_tlv_tag { +HAL_MACTX_CBF_START =0 /* 0x0 */ , +HAL_PHYRX_DATA =1 /* 0x1 */ , +HAL_PHYRX_CBF_DATA_RESP =2 /* 0x2 */ , +HAL_PHYRX_ABORT_REQUEST =3 /* 0x3 */ , +HAL_PHYRX_USER_ABORT_NOTIFICATION =4 /* 0x4 */ , +HAL_MACTX_DATA_RESP =5 /* 0x5 */ , +HAL_MACTX_CBF_DATA =6 /* 0x6 */ , +HAL_MACTX_CBF_DONE =7 /* 0x7 */ , +HAL_PHYRX_LMR_DATA_RESP =8 /* 0x8 */ , +HAL_RXPCU_TO_UCODE_START =9 /* 0x9 */ , +HAL_RXPCU_TO_UCODE_DELIMITER_FOR_FULL_MPDU =10 /* 0xa */ , +HAL_RXPCU_TO_UCODE_FULL_MPDU_DATA =11 /* 0xb */ , +HAL_RXPCU_TO_UCODE_FCS_STATUS =12 /* 0xc */ , +HAL_RXPCU_TO_UCODE_MPDU_DELIMITER =13 /* 0xd */ , +HAL_RXPCU_TO_UCODE_DELIMITER_FOR_MPDU_HEADER =14 /* 0xe */ , +HAL_RXPCU_TO_UCODE_MPDU_HEADER_DATA =15 /* 0xf */ , +HAL_RXPCU_TO_UCODE_END =16 /* 0x10 */ , +HAL_MACRX_CBF_READ_REQUEST =32 /* 0x20 */ , +HAL_MACRX_CBF_DATA_REQUEST =33 /* 0x21 */ , +HAL_MACRXXPECT_NDP_RECEPTION =34 /* 0x22 */ , +HAL_MACRX_FREEZE_CAPTURE_CHANNEL =35 /* 0x23 */ , +HAL_MACRX_NDP_TIMEOUT =36 /* 0x24 */ , +HAL_MACRX_ABORT_ACK =37 /* 0x25 */ , +HAL_MACRX_REQ_IMPLICIT_FB =38 /* 0x26 */ , +HAL_MACRX_CHAIN_MASK =39 /* 0x27 */ , +HAL_MACRX_NAP_USER =40 /* 0x28 */ , +HAL_MACRX_ABORT_REQUEST =41 /* 0x29 */ , +HAL_PHYTX_OTHER_TRANSMIT_INFO16 =42 /* 0x2a */ , +HAL_PHYTX_ABORT_ACK =43 /* 0x2b */ , +HAL_PHYTX_ABORT_REQUEST =44 /* 0x2c */ , +HAL_PHYTX_PKT_END =45 /* 0x2d */ , +HAL_PHYTX_PPDU_HEADER_INFO_REQUEST =46 /* 0x2e */ , +HAL_PHYTX_REQUEST_CTRL_INFO =47 /* 0x2f */ , +HAL_PHYTX_DATA_REQUEST =48 /* 0x30 */ , +HAL_PHYTX_BF_CV_LOADING_DONE =49 /* 0x31 */ , +HAL_PHYTX_NAP_ACK =50 /* 0x32 */ , +HAL_PHYTX_NAP_DONE =51 /* 0x33 */ , +HAL_PHYTX_OFF_ACK =52 /* 0x34 */ , +HAL_PHYTX_ON_ACK =53 /* 0x35 */ , +HAL_PHYTX_SYNTH_OFF_ACK =54 /* 0x36 */ , +HAL_PHYTX_DEBUG16 =55 /* 0x37 */ , +HAL_MACTX_ABORT_REQUEST =56 /* 0x38 */ , +HAL_MACTX_ABORT_ACK =57 /* 0x39 */ , +HAL_MACTX_PKT_END =58 /* 0x3a */ , +HAL_MACTX_PRE_PHY_DESC =59 /* 0x3b */ , +HAL_MACTX_BF_PARAMS_COMMON =60 /* 0x3c */ , +HAL_MACTX_BF_PARAMS_PER_USER =61 /* 0x3d */ , +HAL_MACTX_PREFETCH_CV =62 /* 0x3e */ , +HAL_MACTX_USER_DESC_COMMON =63 /* 0x3f */ , +HAL_MACTX_USER_DESC_PER_USER =64 /* 0x40 */ , +HAL_XAMPLE_USER_TLV_16 =65 /* 0x41 */ , +HAL_XAMPLE_TLV_16 =66 /* 0x42 */ , +HAL_MACTX_PHY_OFF =67 /* 0x43 */ , +HAL_MACTX_PHY_ON =68 /* 0x44 */ , +HAL_MACTX_SYNTH_OFF =69 /* 0x45 */ , +HAL_MACTXXPECT_CBF_COMMON =70 /* 0x46 */ , +HAL_MACTXXPECT_CBF_PER_USER =71 /* 0x47 */ , +HAL_MACTX_PHY_DESC =72 /* 0x48 */ , +HAL_MACTX_L_SIG_A =73 /* 0x49 */ , +HAL_MACTX_L_SIG_B =74 /* 0x4a */ , +HAL_MACTX_HT_SIG =75 /* 0x4b */ , +HAL_MACTX_VHT_SIG_A =76 /* 0x4c */ , +HAL_MACTX_VHT_SIG_B_SU20 =77 /* 0x4d */ , +HAL_MACTX_VHT_SIG_B_SU40 =78 /* 0x4e */ , +HAL_MACTX_VHT_SIG_B_SU80 =79 /* 0x4f */ , +HAL_MACTX_VHT_SIG_B_SU160 =80 /* 0x50 */ , +HAL_MACTX_VHT_SIG_B_MU20 =81 /* 0x51 */ , +HAL_MACTX_VHT_SIG_B_MU40 =82 /* 0x52 */ , +HAL_MACTX_VHT_SIG_B_MU80 =83 /* 0x53 */ , +HAL_MACTX_VHT_SIG_B_MU160 =84 /* 0x54 */ , +HAL_MACTX_SERVICE =85 /* 0x55 */ , +HAL_MACTX_HE_SIG_A_SU =86 /* 0x56 */ , +HAL_MACTX_HE_SIG_A_MU_DL =87 /* 0x57 */ , +HAL_MACTX_HE_SIG_A_MU_UL =88 /* 0x58 */ , +HAL_MACTX_HE_SIG_B1_MU =89 /* 0x59 */ , +HAL_MACTX_HE_SIG_B2_MU =90 /* 0x5a */ , +HAL_MACTX_HE_SIG_B2_OFDMA =91 /* 0x5b */ , +HAL_MACTX_DELETE_CV =92 /* 0x5c */ , +HAL_MACTX_MU_UPLINK_COMMON =93 /* 0x5d */ , +HAL_MACTX_MU_UPLINK_USER_SETUP =94 /* 0x5e */ , +HAL_MACTX_OTHER_TRANSMIT_INFO =95 /* 0x5f */ , +HAL_MACTX_PHY_NAP =96 /* 0x60 */ , +HAL_MACTX_DEBUG =97 /* 0x61 */ , +HAL_PHYRX_ABORT_ACK =98 /* 0x62 */ , +HAL_PHYRX_GENERATED_CBF_DETAILS =99 /* 0x63 */ , +HAL_PHYRX_RSSI_LEGACY =100 /* 0x64 */ , +HAL_PHYRX_RSSI_HT =101 /* 0x65 */ , +HAL_PHYRX_USER_INFO =102 /* 0x66 */ , +HAL_PHYRX_PKT_END =103 /* 0x67 */ , +HAL_PHYRX_DEBUG =104 /* 0x68 */ , +HAL_PHYRX_CBF_TRANSFER_DONE =105 /* 0x69 */ , +HAL_PHYRX_CBF_TRANSFER_ABORT =106 /* 0x6a */ , +HAL_PHYRX_L_SIG_A =107 /* 0x6b */ , +HAL_PHYRX_L_SIG_B =108 /* 0x6c */ , +HAL_PHYRX_HT_SIG =109 /* 0x6d */ , +HAL_PHYRX_VHT_SIG_A =110 /* 0x6e */ , +HAL_PHYRX_VHT_SIG_B_SU20 =111 /* 0x6f */ , +HAL_PHYRX_VHT_SIG_B_SU40 =112 /* 0x70 */ , +HAL_PHYRX_VHT_SIG_B_SU80 =113 /* 0x71 */ , +HAL_PHYRX_VHT_SIG_B_SU160 =114 /* 0x72 */ , +HAL_PHYRX_VHT_SIG_B_MU20 =115 /* 0x73 */ , +HAL_PHYRX_VHT_SIG_B_MU40 =116 /* 0x74 */ , +HAL_PHYRX_VHT_SIG_B_MU80 =117 /* 0x75 */ , +HAL_PHYRX_VHT_SIG_B_MU160 =118 /* 0x76 */ , +HAL_PHYRX_HE_SIG_A_SU =119 /* 0x77 */ , +HAL_PHYRX_HE_SIG_A_MU_DL =120 /* 0x78 */ , +HAL_PHYRX_HE_SIG_A_MU_UL =121 /* 0x79 */ , +HAL_PHYRX_HE_SIG_B1_MU =122 /* 0x7a */ , +HAL_PHYRX_HE_SIG_B2_MU =123 /* 0x7b */ , +HAL_PHYRX_HE_SIG_B2_OFDMA =124 /* 0x7c */ , +HAL_PHYRX_OTHER_RECEIVE_INFO =125 /* 0x7d */ , +HAL_PHYRX_COMMON_USER_INFO =126 /* 0x7e */ , +HAL_PHYRX_DATA_DONE =127 /* 0x7f */ , +HAL_COEX_TX_REQ =128 /* 0x80 */ , +HAL_DUMMY =129 /* 0x81 */ , +HALXAMPLE_TLV_32_NAME =130 /* 0x82 */ , +HAL_MPDU_LIMIT =131 /* 0x83 */ , +HAL_NA_LENGTH_END =132 /* 0x84 */ , +HAL_OLE_BUF_STATUS =133 /* 0x85 */ , +HAL_PCU_PPDU_SETUP_DONE =134 /* 0x86 */ , +HAL_PCU_PPDU_SETUP_END =135 /* 0x87 */ , +HAL_PCU_PPDU_SETUP_INIT =136 /* 0x88 */ , +HAL_PCU_PPDU_SETUP_START =137 /* 0x89 */ , +HAL_PDG_FES_SETUP =138 /* 0x8a */ , +HAL_PDG_RESPONSE =139 /* 0x8b */ , +HAL_PDG_TX_REQ =140 /* 0x8c */ , +HAL_SCH_WAIT_INSTR =141 /* 0x8d */ , +HAL_TQM_FLOWMPTY_STATUS =143 /* 0x8f */ , +HAL_TQM_FLOW_NOTMPTY_STATUS =144 /* 0x90 */ , +HAL_TQM_GEN_MPDU_LENGTH_LIST =145 /* 0x91 */ , +HAL_TQM_GEN_MPDU_LENGTH_LIST_STATUS =146 /* 0x92 */ , +HAL_TQM_GEN_MPDUS =147 /* 0x93 */ , +HAL_TQM_GEN_MPDUS_STATUS =148 /* 0x94 */ , +HAL_TQM_REMOVE_MPDU =149 /* 0x95 */ , +HAL_TQM_REMOVE_MPDU_STATUS =150 /* 0x96 */ , +HAL_TQM_REMOVE_MSDU =151 /* 0x97 */ , +HAL_TQM_REMOVE_MSDU_STATUS =152 /* 0x98 */ , +HAL_TQM_UPDATE_TX_MPDU_COUNT =153 /* 0x99 */ , +HAL_TQM_WRITE_CMD =154 /* 0x9a */ , +HAL_OFDMA_TRIGGER_DETAILS =155 /* 0x9b */ , +HAL_TX_DATA =156 /* 0x9c */ , +HAL_TX_FES_SETUP =157 /* 0x9d */ , +HAL_RX_PACKET =158 /* 0x9e */ , +HALXPECTED_RESPONSE =159 /* 0x9f */ , +HAL_TX_MPDU_END =160 /* 0xa0 */ , +HAL_TX_MPDU_START =161 /* 0xa1 */ , +HAL_TX_MSDU_END =162 /* 0xa2 */ , +HAL_TX_MSDU_START =163 /* 0xa3 */ , +HAL_TX_SW_MODE_SETUP =164 /* 0xa4 */ , +HAL_TXPCU_BUFFER_STATUS =165 /* 0xa5 */ , +HAL_TXPCU_USER_BUFFER_STATUS =166 /* 0xa6 */ , +HAL_DATA_TO_TIME_CONFIG =167 /* 0xa7 */ , +HALXAMPLE_USER_TLV_32 =168 /* 0xa8 */ , +HAL_MPDU_INFO =169 /* 0xa9 */ , +HAL_PDG_USER_SETUP =170 /* 0xaa */ , +HAL_TX_11AH_SETUP =171 /* 0xab */ , +HAL_REO_UPDATE_RX_REO_QUEUE_STATUS =172 /* 0xac */ , +HAL_TX_PEER_ENTRY =173 /* 0xad */ , +HAL_TX_RAW_OR_NATIVE_FRAME_SETUP =174 /* 0xae */ , +HALXAMPLE_USER_TLV_44 =175 /* 0xaf */ , +HAL_TX_FLUSH =176 /* 0xb0 */ , +HAL_TX_FLUSH_REQ =177 /* 0xb1 */ , +HAL_TQM_WRITE_CMD_STATUS =178 /* 0xb2 */ , +HAL_TQM_GET_MPDU_QUEUE_STATS =179 /* 0xb3 */ , +HAL_TQM_GET_MSDU_FLOW_STATS =180 /* 0xb4 */ , +HALXAMPLE_USER_CTLV_44 =181 /* 0xb5 */ , +HAL_TX_FES_STATUS_START =182 /* 0xb6 */ , +HAL_TX_FES_STATUS_USER_PPDU =183 /* 0xb7 */ , +HAL_TX_FES_STATUS_USER_RESPONSE =184 /* 0xb8 */ , +HAL_TX_FES_STATUS_END =185 /* 0xb9 */ , +HAL_RX_TRIG_INFO =186 /* 0xba */ , +HAL_RXPCU_TX_SETUP_CLEAR =187 /* 0xbb */ , +HAL_RX_FRAME_BITMAP_REQ =188 /* 0xbc */ , +HAL_RX_FRAME_BITMAP_ACK =189 /* 0xbd */ , +HAL_COEX_RX_STATUS =190 /* 0xbe */ , +HAL_RX_START_PARAM =191 /* 0xbf */ , +HAL_RX_PPDU_START =192 /* 0xc0 */ , +HAL_RX_PPDU_END =193 /* 0xc1 */ , +HAL_RX_MPDU_START =194 /* 0xc2 */ , +HAL_RX_MPDU_END =195 /* 0xc3 */ , +HAL_RX_MSDU_START =196 /* 0xc4 */ , +HAL_RX_MSDU_END =197 /* 0xc5 */ , +HAL_RX_ATTENTION =198 /* 0xc6 */ , +HAL_RECEIVED_RESPONSE_INFO =199 /* 0xc7 */ , +HAL_RX_PHY_SLEEP =200 /* 0xc8 */ , +HAL_RX_HEADER =201 /* 0xc9 */ , +HAL_RX_PEER_ENTRY =202 /* 0xca */ , +HAL_RX_FLUSH =203 /* 0xcb */ , +HAL_RX_RESPONSE_REQUIRED_INFO =204 /* 0xcc */ , +HAL_RX_FRAMELESS_BAR_DETAILS =205 /* 0xcd */ , +HAL_TQM_GET_MPDU_QUEUE_STATS_STATUS =206 /* 0xce */ , +HAL_TQM_GET_MSDU_FLOW_STATS_STATUS =207 /* 0xcf */ , +HAL_TX_CBF_INFO =208 /* 0xd0 */ , +HAL_PCU_PPDU_SETUP_USER =209 /* 0xd1 */ , +HAL_RX_MPDU_PCU_START =210 /* 0xd2 */ , +HAL_RX_PM_INFO =211 /* 0xd3 */ , +HAL_RX_USER_PPDU_END =212 /* 0xd4 */ , +HAL_RX_PRE_PPDU_START =213 /* 0xd5 */ , +HAL_RX_PREAMBLE =214 /* 0xd6 */ , +HAL_TX_FES_SETUP_COMPLETE =215 /* 0xd7 */ , +HAL_TX_LAST_MPDU_FETCHED =216 /* 0xd8 */ , +HAL_TXDMA_STOP_REQUEST =217 /* 0xd9 */ , +HAL_RXPCU_SETUP =218 /* 0xda */ , +HAL_RXPCU_USER_SETUP =219 /* 0xdb */ , +HAL_TX_FES_STATUS_ACK_OR_BA =220 /* 0xdc */ , +HAL_TQM_ACKED_MPDU =221 /* 0xdd */ , +HAL_COEX_TX_RESP =222 /* 0xde */ , +HAL_COEX_TX_STATUS =223 /* 0xdf */ , +HAL_MACTX_COEX_PHY_CTRL =224 /* 0xe0 */ , +HAL_COEX_STATUS_BROADCAST =225 /* 0xe1 */ , +HAL_RESPONSE_START_STATUS =226 /* 0xe2 */ , +HAL_RESPONSEND_STATUS =227 /* 0xe3 */ , +HAL_CRYPTO_STATUS =228 /* 0xe4 */ , +HAL_RECEIVED_TRIGGER_INFO =229 /* 0xe5 */ , +HAL_COEX_TX_STOP_CTRL =230 /* 0xe6 */ , +HAL_RX_PPDU_ACK_REPORT =231 /* 0xe7 */ , +HAL_RX_PPDU_NO_ACK_REPORT =232 /* 0xe8 */ , +HAL_SCH_COEX_STATUS =233 /* 0xe9 */ , +HAL_SCHEDULER_COMMAND_STATUS =234 /* 0xea */ , +HAL_SCHEDULER_RX_PPDU_NO_RESPONSE_STATUS =235 /* 0xeb */ , +HAL_TX_FES_STATUS_PROT =236 /* 0xec */ , +HAL_TX_FES_STATUS_START_PPDU =237 /* 0xed */ , +HAL_TX_FES_STATUS_START_PROT =238 /* 0xee */ , +HAL_TXPCU_PHYTX_DEBUG32 =239 /* 0xef */ , +HAL_TXPCU_PHYTX_OTHER_TRANSMIT_INFO32 =240 /* 0xf0 */ , +HAL_TX_MPDU_COUNT_TRANSFERND =241 /* 0xf1 */ , +HAL_WHO_ANCHOR_OFFSET =242 /* 0xf2 */ , +HAL_WHO_ANCHOR_VALUE =243 /* 0xf3 */ , +HAL_WHO_CCE_INFO =244 /* 0xf4 */ , +HAL_WHO_COMMIT =245 /* 0xf5 */ , +HAL_WHO_COMMIT_DONE =246 /* 0xf6 */ , +HAL_WHO_FLUSH =247 /* 0xf7 */ , +HAL_WHO_L2_LLC =248 /* 0xf8 */ , +HAL_WHO_L2_PAYLOAD =249 /* 0xf9 */ , +HAL_WHO_L3_CHECKSUM =250 /* 0xfa */ , +HAL_WHO_L3_INFO =251 /* 0xfb */ , +HAL_WHO_L4_CHECKSUM =252 /* 0xfc */ , +HAL_WHO_L4_INFO =253 /* 0xfd */ , +HAL_WHO_MSDU =254 /* 0xfe */ , +HAL_WHO_MSDU_MISC =255 /* 0xff */ , +HAL_WHO_PACKET_DATA =256 /* 0x100 */ , +HAL_WHO_PACKET_HDR =257 /* 0x101 */ , +HAL_WHO_PPDU_END =258 /* 0x102 */ , +HAL_WHO_PPDU_START =259 /* 0x103 */ , +HAL_WHO_TSO =260 /* 0x104 */ , +HAL_WHO_WMAC_HEADER_PV0 =261 /* 0x105 */ , +HAL_WHO_WMAC_HEADER_PV1 =262 /* 0x106 */ , +HAL_WHO_WMAC_IV =263 /* 0x107 */ , +HAL_MPDU_INFO_END =264 /* 0x108 */ , +HAL_MPDU_INFO_BITMAP =265 /* 0x109 */ , +HAL_TX_QUEUE_EXTENSION =266 /* 0x10a */ , +HAL_SCHEDULER_SELFGEN_RESPONSE_STATUS =267 /* 0x10b */ , +HAL_TQM_UPDATE_TX_MPDU_COUNT_STATUS =268 /* 0x10c */ , +HAL_TQM_ACKED_MPDU_STATUS =269 /* 0x10d */ , +HAL_TQM_ADD_MSDU_STATUS =270 /* 0x10e */ , +HAL_TQM_LIST_GEN_DONE =271 /* 0x10f */ , +HAL_WHO_TERMINATE =272 /* 0x110 */ , +HAL_TX_LAST_MPDU_END =273 /* 0x111 */ , +HAL_TX_CV_DATA =274 /* 0x112 */ , +HAL_PPDU_TX_END =275 /* 0x113 */ , +HAL_PROT_TX_END =276 /* 0x114 */ , +HAL_MPDU_INFO_GLOBAL_END =277 /* 0x115 */ , +HAL_TQM_SCH_INSTR_GLOBAL_END =278 /* 0x116 */ , +HAL_RX_PPDU_END_USER_STATS =279 /* 0x117 */ , +HAL_RX_PPDU_END_USER_STATS_EXT =280 /* 0x118 */ , +HAL_REO_GET_QUEUE_STATS =281 /* 0x119 */ , +HAL_REO_FLUSH_QUEUE =282 /* 0x11a */ , +HAL_REO_FLUSH_CACHE =283 /* 0x11b */ , +HAL_REO_UNBLOCK_CACHE =284 /* 0x11c */ , +HAL_REO_GET_QUEUE_STATS_STATUS =285 /* 0x11d */ , +HAL_REO_FLUSH_QUEUE_STATUS =286 /* 0x11e */ , +HAL_REO_FLUSH_CACHE_STATUS =287 /* 0x11f */ , +HAL_REO_UNBLOCK_CACHE_STATUS =288 /* 0x120 */ , +HAL_TQM_FLUSH_CACHE =289 /* 0x121 */ , +HAL_TQM_UNBLOCK_CACHE =290 /* 0x122 */ , +HAL_TQM_FLUSH_CACHE_STATUS =291 /* 0x123 */ , +HAL_TQM_UNBLOCK_CACHE_STATUS =292 /* 0x124 */ , +HAL_RX_PPDU_END_STATUS_DONE =293 /* 0x125 */ , +HAL_RX_STATUS_BUFFER_DONE =294 /* 0x126 */ , +HAL_TX_DATA_SYNC =297 /* 0x129 */ , +HAL_PHYRX_CBF_READ_REQUEST_ACK =298 /* 0x12a */ , +HAL_TQM_GET_MPDU_HEAD_INFO =299 /* 0x12b */ , +HAL_TQM_SYNC_CMD =300 /* 0x12c */ , +HAL_TQM_GET_MPDU_HEAD_INFO_STATUS =301 /* 0x12d */ , +HAL_TQM_SYNC_CMD_STATUS =302 /* 0x12e */ , +HAL_TQM_THRESHOLD_DROP_NOTIFICATION_STATUS =303 /* 0x12f */ , +HAL_TQM_DESCRIPTOR_THRESHOLD_REACHED_STATUS =304 /* 0x130 */ , +HAL_REO_FLUSH_TIMEOUT_LIST =305 /* 0x131 */ , +HAL_REO_FLUSH_TIMEOUT_LIST_STATUS =306 /* 0x132 */ , +HAL_REO_DESCRIPTOR_THRESHOLD_REACHED_STATUS =307 /* 0x133 */ , +HAL_SCHEDULER_RX_SIFS_RESPONSE_TRIGGER_STATUS =308 /* 0x134 */ , +HALXAMPLE_USER_TLV_32_NAME =309 /* 0x135 */ , +HAL_RX_PPDU_START_USER_INFO =310 /* 0x136 */ , +HAL_RX_RING_MASK =311 /* 0x137 */ , +HAL_COEX_MAC_NAP =312 /* 0x138 */ , +HAL_RXPCU_PPDU_END_INFO =313 /* 0x139 */ , +HAL_WHO_MESH_CONTROL =314 /* 0x13a */ , +HAL_PDG_SW_MODE_BW_START =315 /* 0x13b */ , +HAL_PDG_SW_MODE_BW_END =316 /* 0x13c */ , +HAL_PDG_WAIT_FOR_MAC_REQUEST =317 /* 0x13d */ , +HAL_PDG_WAIT_FOR_PHY_REQUEST =318 /* 0x13e */ , +HAL_SCHEDULER_END =319 /* 0x13f */ , +HAL_RX_PPDU_START_DROPPED =320 /* 0x140 */ , +HAL_RX_PPDU_END_DROPPED =321 /* 0x141 */ , +HAL_RX_PPDU_END_STATUS_DONE_DROPPED =322 /* 0x142 */ , +HAL_RX_MPDU_START_DROPPED =323 /* 0x143 */ , +HAL_RX_MSDU_START_DROPPED =324 /* 0x144 */ , +HAL_RX_MSDU_END_DROPPED =325 /* 0x145 */ , +HAL_RX_MPDU_END_DROPPED =326 /* 0x146 */ , +HAL_RX_ATTENTION_DROPPED =327 /* 0x147 */ , +HAL_TXPCU_USER_SETUP =328 /* 0x148 */ , +HAL_RXPCU_USER_SETUP_EXT =329 /* 0x149 */ , +HAL_CMD_PART_0_END =330 /* 0x14a */ , +HAL_MACTX_SYNTH_ON =331 /* 0x14b */ , +HAL_SCH_CRITICAL_TLV_REFERENCE =332 /* 0x14c */ , +HAL_TQM_MPDU_GLOBAL_START =333 /* 0x14d */ , +HALXAMPLE_TLV_32 =334 /* 0x14e */ , +HAL_TQM_UPDATE_TX_MSDU_FLOW =335 /* 0x14f */ , +HAL_TQM_UPDATE_TX_MPDU_QUEUE_HEAD =336 /* 0x150 */ , +HAL_TQM_UPDATE_TX_MSDU_FLOW_STATUS =337 /* 0x151 */ , +HAL_TQM_UPDATE_TX_MPDU_QUEUE_HEAD_STATUS =338 /* 0x152 */ , +HAL_REO_UPDATE_RX_REO_QUEUE =339 /* 0x153 */ , +HAL_TQM_MPDU_QUEUEMPTY_STATUS =340 /* 0x154 */ , +HAL_TQM_2_SCH_MPDU_AVAILABLE =341 /* 0x155 */ , +HAL_PDG_TRIG_RESPONSE =342 /* 0x156 */ , +HAL_TRIGGER_RESPONSE_TX_DONE =343 /* 0x157 */ , +HAL_ABORT_FROM_PHYRX_DETAILS =344 /* 0x158 */ , +HAL_SCH_TQM_CMD_WRAPPER =345 /* 0x159 */ , +HAL_MPDUS_AVAILABLE =346 /* 0x15a */ , +HAL_RECEIVED_RESPONSE_INFO_PART2 =347 /* 0x15b */ , +HAL_PHYRX_TX_START_TIMING =348 /* 0x15c */ , +HAL_TXPCU_PREAMBLE_DONE =349 /* 0x15d */ , +HAL_NDP_PREAMBLE_DONE =350 /* 0x15e */ , +HAL_SCH_TQM_CMD_WRAPPER_RBO_DROP =351 /* 0x15f */ , +HAL_SCH_TQM_CMD_WRAPPER_CONT_DROP =352 /* 0x160 */ , +HAL_MACTX_CLEAR_PREV_TX_INFO =353 /* 0x161 */ , +HAL_TX_PUNCTURE_SETUP =354 /* 0x162 */ , +HAL_R2R_STATUS_END =355 /* 0x163 */ , +HAL_MACTX_PREFETCH_CV_COMMON =356 /* 0x164 */ , +HAL_END_OF_FLUSH_MARKER =357 /* 0x165 */ , +HAL_MACTX_MU_UPLINK_COMMON_PUNC =358 /* 0x166 */ , +HAL_MACTX_MU_UPLINK_USER_SETUP_PUNC =359 /* 0x167 */ , +HAL_RECEIVED_RESPONSE_USER_7_0 =360 /* 0x168 */ , +HAL_RECEIVED_RESPONSE_USER_15_8 =361 /* 0x169 */ , +HAL_RECEIVED_RESPONSE_USER_23_16 =362 /* 0x16a */ , +HAL_RECEIVED_RESPONSE_USER_31_24 =363 /* 0x16b */ , +HAL_RECEIVED_RESPONSE_USER_36_32 =364 /* 0x16c */ , +HAL_TX_LOOPBACK_SETUP =365 /* 0x16d */ , +HAL_PHYRX_OTHER_RECEIVE_INFO_RU_DETAILS =366 /* 0x16e */ , +HAL_SCH_WAIT_INSTR_TX_PATH =367 /* 0x16f */ , +HAL_MACTX_OTHER_TRANSMIT_INFO_TX2TX =368 /* 0x170 */ , +HAL_MACTX_OTHER_TRANSMIT_INFOMUPHY_SETUP =369 /* 0x171 */ , +HAL_PHYRX_OTHER_RECEIVE_INFOVM_DETAILS =370 /* 0x172 */ , +HAL_TX_WUR_DATA =371 /* 0x173 */ , +HAL_RX_PPDU_END_START =372 /* 0x174 */ , +HAL_RX_PPDU_END_MIDDLE =373 /* 0x175 */ , +HAL_RX_PPDU_END_LAST =374 /* 0x176 */ , +HAL_MACTX_BACKOFF_BASED_TRANSMISSION =375 /* 0x177 */ , +HAL_MACTX_OTHER_TRANSMIT_INFO_DL_OFDMA_TX =376 /* 0x178 */ , +HAL_SRP_INFO =377 /* 0x179 */ , +HAL_OBSS_SR_INFO =378 /* 0x17a */ , +HAL_SCHEDULER_SW_MSG_STATUS =379 /* 0x17b */ , +HAL_HWSCH_RXPCU_MAC_INFO_ANNOUNCEMENT =380 /* 0x17c */ , +HAL_RXPCU_SETUP_COMPLETE =381 /* 0x17d */ , +HAL_SNOOP_PPDU_START =382 /* 0x17e */ , +HAL_SNOOP_MPDU_USR_DBG_INFO =383 /* 0x17f */ , +HAL_SNOOP_MSDU_USR_DBG_INFO =384 /* 0x180 */ , +HAL_SNOOP_MSDU_USR_DATA =385 /* 0x181 */ , +HAL_SNOOP_MPDU_USR_STAT_INFO =386 /* 0x182 */ , +HAL_SNOOP_PPDU_END =387 /* 0x183 */ , +HAL_SNOOP_SPARE =388 /* 0x184 */ , +HAL_PHYRX_OTHER_RECEIVE_INFO_MU_RSSI_COMMON =390 /* 0x186 */ , +HAL_PHYRX_OTHER_RECEIVE_INFO_MU_RSSI_USER =391 /* 0x187 */ , +HAL_MACTX_OTHER_TRANSMIT_INFO_SCH_DETAILS =392 /* 0x188 */ , +HAL_PHYRX_OTHER_RECEIVE_INFO_108PVM_DETAILS =393 /* 0x189 */ , +HAL_SCH_TLV_WRAPPER =394 /* 0x18a */ , +HAL_SCHEDULER_STATUS_WRAPPER =395 /* 0x18b */ , +HAL_MPDU_INFO_6X =396 /* 0x18c */ , +HAL_MACTX_11AZ_USER_DESC_PER_USER =397 /* 0x18d */ , +HAL_MACTX_U_SIGHT_SU_MU =398 /* 0x18e */ , +HAL_MACTX_U_SIGHT_TB =399 /* 0x18f */ , +HAL_PHYRX_U_SIGHT_SU_MU =403 /* 0x193 */ , +HAL_PHYRX_U_SIGHT_TB =404 /* 0x194 */ , +HAL_MACRX_LMR_READ_REQUEST =408 /* 0x198 */ , +HAL_MACRX_LMR_DATA_REQUEST =409 /* 0x199 */ , +HAL_PHYRX_LMR_TRANSFER_DONE =410 /* 0x19a */ , +HAL_PHYRX_LMR_TRANSFER_ABORT =411 /* 0x19b */ , +HAL_PHYRX_LMR_READ_REQUEST_ACK =412 /* 0x19c */ , +HAL_MACRX_SECURE_LTF_SEQ_PTR =413 /* 0x19d */ , +HAL_PHYRX_USER_INFO_MU_UL =414 /* 0x19e */ , +HAL_MPDU_QUEUE_OVERVIEW =415 /* 0x19f */ , +HAL_SCHEDULER_NAV_INFO =416 /* 0x1a0 */ , +HAL_LMR_PEER_ENTRY =418 /* 0x1a2 */ , +HAL_LMR_MPDU_START =419 /* 0x1a3 */ , +HAL_LMR_DATA =420 /* 0x1a4 */ , +HAL_LMR_MPDU_END =421 /* 0x1a5 */ , +HAL_REO_GET_QUEUE_1K_STATS_STATUS =422 /* 0x1a6 */ , +HAL_RX_FRAME_1K_BITMAP_ACK =423 /* 0x1a7 */ , +HAL_TX_FES_STATUS_1K_BA =424 /* 0x1a8 */ , +HAL_TQM_ACKED_1K_MPDU =425 /* 0x1a9 */ , +HAL_MACRX_INBSS_OBSS_IND =426 /* 0x1aa */ , +HAL_PHYRX_LOCATION =427 /* 0x1ab */ , +HAL_MLO_TX_NOTIFICATION_SU =428 /* 0x1ac */ , +HAL_MLO_TX_NOTIFICATION_MU =429 /* 0x1ad */ , +HAL_MLO_TX_REQ_SU =430 /* 0x1ae */ , +HAL_MLO_TX_REQ_MU =431 /* 0x1af */ , +HAL_MLO_TX_RESP =432 /* 0x1b0 */ , +HAL_MLO_RX_NOTIFICATION =433 /* 0x1b1 */ , +HAL_MLO_BKOFF_TRUNC_REQ =434 /* 0x1b2 */ , +HAL_MLO_TBTT_NOTIFICATION =435 /* 0x1b3 */ , +HAL_MLO_MESSAGE =436 /* 0x1b4 */ , +HAL_MLO_TS_SYNC_MSG =437 /* 0x1b5 */ , +HAL_MLO_FES_SETUP =438 /* 0x1b6 */ , +HAL_MLO_PDG_FES_SETUP_SU =439 /* 0x1b7 */ , +HAL_MLO_PDG_FES_SETUP_MU =440 /* 0x1b8 */ , +HAL_MPDU_INFO_1K_BITMAP =441 /* 0x1b9 */ , +HAL_MON_BUF_ADDR =442 /* 0x1ba */ , +HAL_TX_FRAG_STATE =443 /* 0x1bb */ , +HAL_MACTXHT_SIG_USR_OFDMA =446 /* 0x1be */ , +HAL_PHYRXHT_SIG_CMN_PUNC =448 /* 0x1c0 */ , +HAL_PHYRXHT_SIG_CMN_OFDMA =450 /* 0x1c2 */ , +HAL_PHYRXHT_SIG_USR_OFDMA =454 /* 0x1c6 */ , +HAL_PHYRX_PKT_END_PART1 =456 /* 0x1c8 */ , +HAL_MACTXXPECT_NDP_RECEPTION =457 /* 0x1c9 */ , +HAL_MACTX_SECURE_LTF_SEQ_PTR =458 /* 0x1ca */ , +HAL_MLO_PDG_BKOFF_TRUNC_NOTIFY =460 /* 0x1cc */ , +HAL_PHYRX_11AZ_INTEGRITY_DATA =461 /* 0x1cd */ , +HAL_PHYTX_LOCATION =462 /* 0x1ce */ , +HAL_PHYTX_11AZ_INTEGRITY_DATA =463 /* 0x1cf */ , +HAL_MACTXHT_SIG_USR_SU =466 /* 0x1d2 */ , +HAL_MACTXHT_SIG_USR_MU_MIMO =467 /* 0x1d3 */ , +HAL_PHYRXHT_SIG_USR_SU =468 /* 0x1d4 */ , +HAL_PHYRXHT_SIG_USR_MU_MIMO =469 /* 0x1d5 */ , +HAL_PHYRX_GENERIC_U_SIG =470 /* 0x1d6 */ , +HAL_PHYRX_GENERICHT_SIG =471 /* 0x1d7 */ , +HAL_OVERWRITE_RESP_START =472 /* 0x1d8 */ , +HAL_OVERWRITE_RESP_PREAMBLE_INFO =473 /* 0x1d9 */ , +HAL_OVERWRITE_RESP_FRAME_INFO =474 /* 0x1da */ , +HAL_OVERWRITE_RESP_END =475 /* 0x1db */ , +HAL_RXPCUARLY_RX_INDICATION =476 /* 0x1dc */ , +HAL_MON_DROP =477 /* 0x1dd */ , +HAL_MACRX_MU_UPLINK_COMMON_SNIFF =478 /* 0x1de */ , +HAL_MACRX_MU_UPLINK_USER_SETUP_SNIFF =479 /* 0x1df */ , +HAL_MACRX_MU_UPLINK_USER_SEL_SNIFF =480 /* 0x1e0 */ , +HAL_MACRX_MU_UPLINK_FCS_STATUS_SNIFF =481 /* 0x1e1 */ , +HAL_MACTX_PREFETCH_CV_DMA =482 /* 0x1e2 */ , +HAL_MACTX_PREFETCH_CV_PER_USER =483 /* 0x1e3 */ , +HAL_PHYRX_OTHER_RECEIVE_INFO_ALL_SIGB_DETAILS =484 /* 0x1e4 */ , +HAL_MACTX_BF_PARAMS_UPDATE_COMMON =485 /* 0x1e5 */ , +HAL_MACTX_BF_PARAMS_UPDATE_PER_USER =486 /* 0x1e6 */ , +HAL_RANGING_USER_DETAILS =487 /* 0x1e7 */ , +HAL_PHYTX_CV_CORR_STATUS =488 /* 0x1e8 */ , +HAL_PHYTX_CV_CORR_COMMON =489 /* 0x1e9 */ , +HAL_PHYTX_CV_CORR_USER =490 /* 0x1ea */ , +HAL_MACTX_CV_CORR_COMMON =491 /* 0x1eb */ , +HAL_MACTX_CV_CORR_MAC_INFO_GROUP =492 /* 0x1ec */ , +HAL_BW_PUNCTUREVAL_WRAPPER =493 /* 0x1ed */ , +HAL_MACTX_RX_NOTIFICATION_FOR_PHY =494 /* 0x1ee */ , +HAL_MACTX_TX_NOTIFICATION_FOR_PHY =495 /* 0x1ef */ , +HAL_MACTX_MU_UPLINK_COMMON_PER_BW =496 /* 0x1f0 */ , +HAL_MACTX_MU_UPLINK_USER_SETUP_PER_BW =497 /* 0x1f1 */ , +HAL_RX_PPDU_END_USER_STATS_EXT2 =498 /* 0x1f2 */ , +HAL_FW2SW_MON =499 /* 0x1f3 */ , +HAL_WSI_DIRECT_MESSAGE =500 /* 0x1f4 */ , +HAL_MACTXMLSR_PRE_SWITCH =501 /* 0x1f5 */ , +HAL_MACTXMLSR_SWITCH =502 /* 0x1f6 */ , +HAL_MACTXMLSR_SWITCH_BACK =503 /* 0x1f7 */ , +HAL_PHYTXMLSR_SWITCH_ACK =504 /* 0x1f8 */ , +HAL_PHYTXMLSR_SWITCH_BACK_ACK =505 /* 0x1f9 */ , +HAL_SPARE_REUSE_TAG_0 =506 /* 0x1fa */ , +HAL_SPARE_REUSE_TAG_1 =507 /* 0x1fb */ , +HAL_SPARE_REUSE_TAG_2 =508 /* 0x1fc */ , +HAL_SPARE_REUSE_TAG_3 =509 /* 0x1fd */ , +/* FIXME: Assign correct value for HAL_TCL_DATA_CMD */ +HAL_TCL_DATA_CMD =510 , +HAL_TLV_BASE =511 /* 0x1ff */ , +}; + +#define HAL_TLV_HDR_TAG GENMASK(9, 1) +#define HAL_TLV_HDR_LEN GENMASK(25, 10) +#define HAL_TLV_USR_ID GENMASK(31, 26) + +#define HAL_TLV_ALIGN 4 + +struct hal_tlv_hdr { +__le32 tl; +u8 value[]; +} __packed; + +#define HAL_TLV_64_HDR_TAG GENMASK(9, 1) +#define HAL_TLV_64_HDR_LEN GENMASK(21, 10) + +struct hal_tlv_64_hdr { +u64 tl; +u8 value[]; +} __packed; + +#define RX_MPDU_DESC_INFO0_MSDU_COUNT GENMASK(7, 0) +#define RX_MPDU_DESC_INFO0_FRAG_FLAG BIT(8) +#define RX_MPDU_DESC_INFO0_MPDU_RETRY BIT(9) +#define RX_MPDU_DESC_INFO0_AMPDU_FLAG BIT(10) +#define RX_MPDU_DESC_INFO0_BAR_FRAME BIT(11) +#define RX_MPDU_DESC_INFO0_VALID_PN BIT(12) +#define RX_MPDU_DESC_INFO0_RAW_MPDU BIT(13) +#define RX_MPDU_DESC_INFO0_MORE_FRAG_FLAG BIT(14) +#define RX_MPDU_DESC_INFO0_SRC_INFO GENMASK(26, 15) +#define RX_MPDU_DESC_INFO0_MPDU_QOS_CTRL_VALID BIT(27) +#define RX_MPDU_DESC_INFO0_TID GENMASK(31, 28) + +/* TODO revisit after meta data is concluded */ +#define RX_MPDU_DESC_META_DATA_PEER_ID GENMASK(15, 0) + +struct rx_mpdu_desc { +__le32 info0;/* %RX_MPDU_DESC_INFO */ +__le32 peer_meta_data; +} __packed; + +/* rx_mpdu_desc +* Producer: RXDMA +* Consumer: REO/SW/FW +* +* msdu_count +* The number of MSDUs within the MPDU +* +* fragment_flag +* When set, this MPDU is a fragment and REO should forward this +* fragment MPDU to the REO destination ring without any reorder +* checks, pn checks or bitmap update. This implies that REO is +* forwarding the pointer to the MSDU link descriptor. +* +* mpdu_retry_bit +* The retry bit setting from the MPDU header of the received frame +* +* ampdu_flag +* Indicates the MPDU was received as part of an A-MPDU. +* +* bar_frame +* Indicates the received frame is a BAR frame. After processing, +* this frame shall be pushed to SW or deleted. +* +* valid_pn +* When not set, REO will not perform a PN sequence number check. +* +* raw_mpdu +* Field only valid when first_msdu_in_mpdu_flag is set. Indicates +* the contents in the MSDU buffer contains a 'RAW' MPDU. This +* 'RAW' MPDU might be spread out over multiple MSDU buffers. +* +* more_fragment_flag +* The More Fragment bit setting from the MPDU header of the +* received frame +* +* src_info +* Source (Virtual) device/interface info associated with this peer. +* This field gets passed on by REO to PPE in the EDMA descriptor. +* +* mpdu_qos_control_valid +* When set, the MPDU has a QoS control field +* +* tid +* Field only valid when mpdu_qos_control_valid is set +*/ + +enum hal_rx_msdu_desc_reo_dest_ind { +HAL_RX_MSDU_DESC_REO_DEST_IND_TCL , +HAL_RX_MSDU_DESC_REO_DEST_IND_SW1 , +HAL_RX_MSDU_DESC_REO_DEST_IND_SW2 , +HAL_RX_MSDU_DESC_REO_DEST_IND_SW3 , +HAL_RX_MSDU_DESC_REO_DEST_IND_SW4 , +HAL_RX_MSDU_DESC_REO_DEST_IND_RELEASE , +HAL_RX_MSDU_DESC_REO_DEST_IND_FW , +HAL_RX_MSDU_DESC_REO_DEST_IND_SW5 , +HAL_RX_MSDU_DESC_REO_DEST_IND_SW6 , +HAL_RX_MSDU_DESC_REO_DEST_IND_SW7 , +HAL_RX_MSDU_DESC_REO_DEST_IND_SW8 , +}; + +#define RX_MSDU_DESC_INFO0_FIRST_MSDU_IN_MPDU BIT(0) +#define RX_MSDU_DESC_INFO0_LAST_MSDU_IN_MPDU BIT(1) +#define RX_MSDU_DESC_INFO0_MSDU_CONTINUATION BIT(2) +#define RX_MSDU_DESC_INFO0_MSDU_LENGTH GENMASK(16, 3) +#define RX_MSDU_DESC_INFO0_MSDU_DROP BIT(17) +#define RX_MSDU_DESC_INFO0_VALID_SA BIT(18) +#define RX_MSDU_DESC_INFO0_VALID_DA BIT(19) +#define RX_MSDU_DESC_INFO0_DA_MCBC BIT(20) +#define RX_MSDU_DESC_INFO0_L3_HDR_PAD_MSB BIT(21) +#define RX_MSDU_DESC_INFO0_TCP_UDP_CHKSUM_FAIL BIT(22) +#define RX_MSDU_DESC_INFO0_IP_CHKSUM_FAIL BIT(23) +#define RX_MSDU_DESC_INFO0_FROM_DS BIT(24) +#define RX_MSDU_DESC_INFO0_TO_DS BIT(25) +#define RX_MSDU_DESC_INFO0_INTRA_BSS BIT(26) +#define RX_MSDU_DESC_INFO0_DST_CHIP_ID GENMASK(28, 27) +#define RX_MSDU_DESC_INFO0_DECAP_FORMAT GENMASK(30, 29) + +#define HAL_RX_MSDU_PKT_LENGTH_GET (val) \ + (u32_get_bits((val), RX_MSDU_DESC_INFO0_MSDU_LENGTH)) + +struct rx_msdu_desc { +__le32 info0; +} __packed; + +/* rx_msdu_desc +* +* first_msdu_in_mpdu +* Indicates first msdu in mpdu. +* +* last_msdu_in_mpdu +* Indicates last msdu in mpdu. This flag can be true only when +* 'Msdu_continuation' set to 0. This implies that when an msdu +* is spread out over multiple buffers and thus msdu_continuation +* is set, only for the very last buffer of the msdu, can the +* 'last_msdu_in_mpdu' be set. +* +* When both first_msdu_in_mpdu and last_msdu_in_mpdu are set, +* the MPDU that this MSDU belongs to only contains a single MSDU. +* +* msdu_continuation +* When set, this MSDU buffer was not able to hold the entire MSDU. +* The next buffer will therefor contain additional information +* related to this MSDU. +* +* msdu_length +* Field is only valid in combination with the 'first_msdu_in_mpdu' +* being set. Full MSDU length in bytes after decapsulation. This +* field is still valid for MPDU frames without A-MSDU. It still +* represents MSDU length after decapsulation Or in case of RAW +* MPDUs, it indicates the length of the entire MPDU (without FCS +* field). +* +* msdu_drop +* Indicates that REO shall drop this MSDU and not forward it to +* any other ring. +* +* valid_sa +* Indicates OLE found a valid SA entry for this MSDU. +* +* valid_da +* When set, OLE found a valid DA entry for this MSDU. +* +* da_mcbc +* Field Only valid if valid_da is set. Indicates the DA address +* is a Multicast or Broadcast address for this MSDU. +* +* l3_header_padding_msb +* Passed on from 'RX_MSDU_END' TLV (only the MSB is reported as +* the LSB is always zero). Number of bytes padded to make sure +* that the L3 header will always start of a Dword boundary +* +* tcp_udp_checksum_fail +* Passed on from 'RX_ATTENTION' TLV +* Indicates that the computed checksum did not match the checksum +* in the TCP/UDP header. +* +* ip_checksum_fail +* Passed on from 'RX_ATTENTION' TLV +* Indicates that the computed checksum did not match the checksum +* in the IP header. +* +* from_DS +* Set if the 'from DS' bit is set in the frame control. +* +* to_DS +* Set if the 'to DS' bit is set in the frame control. +* +* intra_bss +* This packet needs intra-BSS routing by SW as the 'vdev_id' +* for the destination is the same as the 'vdev_id' that this +* MSDU was got in. +* +* dest_chip_id +* If intra_bss is set, copied by RXOLE/RXDMA from 'ADDR_SEARCH_ENTRY' +* to support intra-BSS routing with multi-chip multi-link operation. +* This indicates into which chip's TCL the packet should be queued. +* +* decap_format +* Indicates the format after decapsulation: +*/ + +#define RX_MSDU_EXT_DESC_INFO0_REO_DEST_IND GENMASK(4, 0) +#define RX_MSDU_EXT_DESC_INFO0_SERVICE_CODE GENMASK(13, 5) +#define RX_MSDU_EXT_DESC_INFO0_PRIORITY_VALID BIT(14) +#define RX_MSDU_EXT_DESC_INFO0_DATA_OFFSET GENMASK(26, 15) +#define RX_MSDU_EXT_DESC_INFO0_SRC_LINK_ID GENMASK(29, 27) + +struct rx_msdu_ext_desc { +__le32 info0; +} __packed; + +/* rx_msdu_ext_desc +* +* reo_destination_indication +* The ID of the REO exit ring where the MSDU frame shall push +* after (MPDU level) reordering has finished. +* +* service_code +* Opaque service code between PPE and Wi-Fi +* +* priority_valid +* +* data_offset +* The offset to Rx packet data within the buffer (including +* Rx DMA offset programming and L3 header padding inserted +* by Rx OLE). +* +* src_link_id +* Set to the link ID of the PMAC that received the frame +*/ + +enum hal_reo_dest_ring_buffer_type { +HAL_REO_DEST_RING_BUFFER_TYPE_MSDU , +HAL_REO_DEST_RING_BUFFER_TYPE_LINK_DESC , +}; + +enum hal_reo_dest_ring_push_reason { +HAL_REO_DEST_RING_PUSH_REASON_ERR_DETECTED , +HAL_REO_DEST_RING_PUSH_REASON_ROUTING_INSTRUCTION , +}; + +enum hal_reo_dest_ring_error_code { +HAL_REO_DEST_RING_ERROR_CODE_DESC_ADDR_ZERO , +HAL_REO_DEST_RING_ERROR_CODE_DESC_INVALID , +HAL_REO_DEST_RING_ERROR_CODE_AMPDU_IN_NON_BA , +HAL_REO_DEST_RING_ERROR_CODE_NON_BA_DUPLICATE , +HAL_REO_DEST_RING_ERROR_CODE_BA_DUPLICATE , +HAL_REO_DEST_RING_ERROR_CODE_FRAME_2K_JUMP , +HAL_REO_DEST_RING_ERROR_CODE_BAR_2K_JUMP , +HAL_REO_DEST_RING_ERROR_CODE_FRAME_OOR , +HAL_REO_DEST_RING_ERROR_CODE_BAR_OOR , +HAL_REO_DEST_RING_ERROR_CODE_NO_BA_SESSION , +HAL_REO_DEST_RING_ERROR_CODE_FRAME_SN_EQUALS_SSN , +HAL_REO_DEST_RING_ERROR_CODE_PN_CHECK_FAILED , +HAL_REO_DEST_RING_ERROR_CODE_2K_ERR_FLAG_SET , +HAL_REO_DEST_RING_ERROR_CODE_PN_ERR_FLAG_SET , +HAL_REO_DEST_RING_ERROR_CODE_DESC_BLOCKED , +HAL_REO_DEST_RING_ERROR_CODE_MAX , +}; + +#define HAL_REO_DEST_RING_INFO0_BUFFER_TYPE BIT(0) +#define HAL_REO_DEST_RING_INFO0_PUSH_REASON GENMASK(2, 1) +#define HAL_REO_DEST_RING_INFO0_ERROR_CODE GENMASK(7, 3) +#define HAL_REO_DEST_RING_INFO0_MSDU_DATA_SIZE GENMASK(11, 8) +#define HAL_REO_DEST_RING_INFO0_SW_EXCEPTION BIT(12) +#define HAL_REO_DEST_RING_INFO0_SRC_LINK_ID GENMASK(15, 13) +#define HAL_REO_DEST_RING_INFO0_SIGNATURE GENMASK(19, 16) +#define HAL_REO_DEST_RING_INFO0_RING_ID GENMASK(27, 20) +#define HAL_REO_DEST_RING_INFO0_LOOPING_COUNT GENMASK(31, 28) + +struct hal_reo_dest_ring { +struct ath12k_buffer_addr buf_addr_info; +struct rx_mpdu_desc rx_mpdu_info; +struct rx_msdu_desc rx_msdu_info; +__le32 buf_va_lo; +__le32 buf_va_hi; +__le32 info0;/* %HAL_REO_DEST_RING_INFO0_ */ +} __packed; + +/* hal_reo_dest_ring +* +* Producer: RXDMA +* Consumer: REO/SW/FW +* +* buf_addr_info +* Details of the physical address of a buffer or MSDU +* link descriptor. +* +* rx_mpdu_info +* General information related to the MPDU that is passed +* on from REO entrance ring to the REO destination ring. +* +* rx_msdu_info +* General information related to the MSDU that is passed +* on from RXDMA all the way to the REO destination ring. +* +* buf_va_lo +* Field only valid if Reo_dest_buffer_type is set to MSDU_buf_address +* Lower 32 bits of the 64-bit virtual address corresponding +* to Buf_or_link_desc_addr_info +* +* buf_va_hi +* Address (upper 32 bits) of the REO queue descriptor. +* Upper 32 bits of the 64-bit virtual address corresponding +* to Buf_or_link_desc_addr_info +* +* buffer_type +* Indicates the type of address provided in the buf_addr_info. +* Values are defined in enum %HAL_REO_DEST_RING_BUFFER_TYPE_. +* +* push_reason +* Reason for pushing this frame to this exit ring. Values are +* defined in enum %HAL_REO_DEST_RING_PUSH_REASON_. +* +* error_code +* Valid only when 'push_reason' is set. All error codes are +* defined in enum %HAL_REO_DEST_RING_ERROR_CODE_. +* +* captured_msdu_data_size +* The number of following REO_DESTINATION STRUCTs that have +* been replaced with msdu_data extracted from the msdu_buffer +* and copied into the ring for easy FW/SW access. +* +* sw_exception +* This field has the same setting as the SW_exception field +* in the corresponding REO_entrance_ring descriptor. +* When set, the REO entrance descriptor is generated by FW, +* and the MPDU was processed in the following way: +* - NO re-order function is needed. +* - MPDU delinking is determined by the setting of Entrance +* ring field: SW_excection_mpdu_delink +* - Destination ring selection is based on the setting of +* the Entrance ring field SW_exception_destination _ring_valid +* +* src_link_id +* Set to the link ID of the PMAC that received the frame +* +* signature +* Set to value 0x8 when msdu capture mode is enabled for this ring +* +* ring_id +* The buffer pointer ring id. +* 0 - Idle ring +* 1 - N refers to other rings. +* +* looping_count +* Indicates the number of times the producer of entries into +* this ring has looped around the ring. +*/ + +#define HAL_REO_TO_PPE_RING_INFO0_DATA_LENGTH GENMASK(15, 0) +#define HAL_REO_TO_PPE_RING_INFO0_DATA_OFFSET GENMASK(23, 16) +#define HAL_REO_TO_PPE_RING_INFO0_POOL_ID GENMASK(28, 24) +#define HAL_REO_TO_PPE_RING_INFO0_PREHEADER BIT(29) +#define HAL_REO_TO_PPE_RING_INFO0_TSO_EN BIT(30) +#define HAL_REO_TO_PPE_RING_INFO0_MORE BIT(31) + +struct hal_reo_to_ppe_ring { +__le32 buffer_addr; +__le32 info0;/* %HAL_REO_TO_PPE_RING_INFO0_ */ +} __packed; + +/* hal_reo_to_ppe_ring +* +* Producer: REO +* Consumer: PPE +* +* buf_addr_info +* Details of the physical address of a buffer or MSDU +* link descriptor. +* +* data_length +* Length of valid data in bytes +* +* data_offset +* Offset to the data from buffer pointer. Can be used to +* strip header in the data for tunnel termination etc. +* +* pool_id +* REO has global configuration register for this field. +* It may have several free buffer pools, each +* RX-Descriptor ring can fetch free buffer from specific +* buffer pool; pool id will indicate which pool the buffer +* will be released to; POOL_ID Zero returned to SW +* +* preheader +* Disabled: 0 (Default) +* Enabled: 1 +* +* tso_en +* Disabled: 0 (Default) +* Enabled: 1 +* +* more +* More Segments followed +*/ + +enum hal_reo_entr_rxdma_push_reason { +HAL_REO_ENTR_RING_RXDMA_PUSH_REASON_ERR_DETECTED , +HAL_REO_ENTR_RING_RXDMA_PUSH_REASON_ROUTING_INSTRUCTION , +HAL_REO_ENTR_RING_RXDMA_PUSH_REASON_RX_FLUSH , +}; + +enum hal_reo_entr_rxdma_ecode { +HAL_REO_ENTR_RING_RXDMA_ECODE_OVERFLOW_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_MPDU_LEN_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_FCS_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_DECRYPT_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_TKIP_MIC_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_UNECRYPTED_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_MSDU_LEN_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_MSDU_LIMIT_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_WIFI_PARSE_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_AMSDU_PARSE_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_SA_TIMEOUT_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_DA_TIMEOUT_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_FLOW_TIMEOUT_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_FLUSH_REQUEST_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_AMSDU_FRAG_ERR , +HAL_REO_ENTR_RING_RXDMA_ECODE_MAX , +}; + +enum hal_rx_reo_dest_ring { +HAL_RX_REO_DEST_RING_TCL , +HAL_RX_REO_DEST_RING_SW1 , +HAL_RX_REO_DEST_RING_SW2 , +HAL_RX_REO_DEST_RING_SW3 , +HAL_RX_REO_DEST_RING_SW4 , +HAL_RX_REO_DEST_RING_RELEASE , +HAL_RX_REO_DEST_RING_FW , +HAL_RX_REO_DEST_RING_SW5 , +HAL_RX_REO_DEST_RING_SW6 , +HAL_RX_REO_DEST_RING_SW7 , +HAL_RX_REO_DEST_RING_SW8 , +}; + +#define HAL_REO_ENTR_RING_INFO0_QUEUE_ADDR_HI GENMASK(7, 0) +#define HAL_REO_ENTR_RING_INFO0_MPDU_BYTE_COUNT GENMASK(21, 8) +#define HAL_REO_ENTR_RING_INFO0_DEST_IND GENMASK(26, 22) +#define HAL_REO_ENTR_RING_INFO0_FRAMELESS_BAR BIT(27) + +#define HAL_REO_ENTR_RING_INFO1_RXDMA_PUSH_REASON GENMASK(1, 0) +#define HAL_REO_ENTR_RING_INFO1_RXDMA_ERROR_CODE GENMASK(6, 2) +#define HAL_REO_ENTR_RING_INFO1_MPDU_FRAG_NUM GENMASK(10, 7) +#define HAL_REO_ENTR_RING_INFO1_SW_EXCEPTION BIT(11) +#define HAL_REO_ENTR_RING_INFO1_SW_EXCEPT_MPDU_DELINK BIT(12) +#define HAL_REO_ENTR_RING_INFO1_SW_EXCEPTION_RING_VLD BIT(13) +#define HAL_REO_ENTR_RING_INFO1_SW_EXCEPTION_RING GENMASK(18, 14) +#define HAL_REO_ENTR_RING_INFO1_MPDU_SEQ_NUM GENMASK(30, 19) + +#define HAL_REO_ENTR_RING_INFO2_PHY_PPDU_ID GENMASK(15, 0) +#define HAL_REO_ENTR_RING_INFO2_SRC_LINK_ID GENMASK(18, 16) +#define HAL_REO_ENTR_RING_INFO2_RING_ID GENMASK(27, 20) +#define HAL_REO_ENTR_RING_INFO2_LOOPING_COUNT GENMASK(31, 28) + +struct hal_reo_entrance_ring { +struct ath12k_buffer_addr buf_addr_info; +struct rx_mpdu_desc rx_mpdu_info; +__le32 queue_addr_lo; +__le32 info0;/* %HAL_REO_ENTR_RING_INFO0_ */ +__le32 info1;/* %HAL_REO_ENTR_RING_INFO1_ */ +__le32 info2;/* %HAL_REO_DEST_RING_INFO2_ */ + +} __packed; + +/* hal_reo_entrance_ring +* +* Producer: RXDMA +* Consumer: REO +* +* buf_addr_info +* Details of the physical address of a buffer or MSDU +* link descriptor. +* +* rx_mpdu_info +* General information related to the MPDU that is passed +* on from REO entrance ring to the REO destination ring. +* +* queue_addr_lo +* Address (lower 32 bits) of the REO queue descriptor. +* +* queue_addr_hi +* Address (upper 8 bits) of the REO queue descriptor. +* +* mpdu_byte_count +* An approximation of the number of bytes received in this MPDU. +* Used to keeps stats on the amount of data flowing +* through a queue. +* +* reo_destination_indication +* The id of the reo exit ring where the msdu frame shall push +* after (MPDU level) reordering has finished. Values are defined +* in enum %HAL_RX_MSDU_DESC_REO_DEST_IND_. +* +* frameless_bar +* Indicates that this REO entrance ring struct contains BAR info +* from a multi TID BAR frame. The original multi TID BAR frame +* itself contained all the REO info for the first TID, but all +* the subsequent TID info and their linkage to the REO descriptors +* is passed down as 'frameless' BAR info. +* +* The only fields valid in this descriptor when this bit is set +* are queue_addr_lo, queue_addr_hi, mpdu_sequence_number, +* bar_frame and peer_meta_data. +* +* rxdma_push_reason +* Reason for pushing this frame to this exit ring. Values are +* defined in enum %HAL_REO_ENTR_RING_RXDMA_PUSH_REASON_. +* +* rxdma_error_code +* Valid only when 'push_reason' is set. All error codes are +* defined in enum %HAL_REO_ENTR_RING_RXDMA_ECODE_. +* +* mpdu_fragment_number +* Field only valid when Reo_level_mpdu_frame_info. +* Rx_mpdu_desc_info_details.Fragment_flag is set. +* +* sw_exception +* When not set, REO is performing all its default MPDU processing +* operations, +* When set, this REO entrance descriptor is generated by FW, and +* should be processed as an exception. This implies: +* NO re-order function is needed. +* MPDU delinking is determined by the setting of field +* SW_excection_mpdu_delink +* +* sw_exception_mpdu_delink +* Field only valid when SW_exception is set. +* 1'b0: REO should NOT delink the MPDU, and thus pass this +* MPDU on to the destination ring as is. This implies that +* in the REO_DESTINATION_RING struct field +* Buf_or_link_desc_addr_info should point to an MSDU link +* descriptor +* 1'b1: REO should perform the normal MPDU delink into MSDU operations. +* +* sw_exception_dest_ring +* Field only valid when fields SW_exception and SW +* exception_destination_ring_valid are set. values are defined +* in %HAL_RX_REO_DEST_RING_. +* +* mpdu_seq_number +* The field can have two different meanings based on the setting +* of sub-field Reo level mpdu frame info. +* Rx_mpdu_desc_info_details. BAR_frame +* 'BAR_frame' is NOT set: +* The MPDU sequence number of the received frame. +* 'BAR_frame' is set. +* The MPDU Start sequence number from the BAR frame +* +* phy_ppdu_id +* A PPDU counter value that PHY increments for every PPDU received +* +* src_link_id +* Set to the link ID of the PMAC that received the frame +* +* ring_id +* The buffer pointer ring id. +* 0 - Idle ring +* 1 - N refers to other rings. +* +* looping_count +* Indicates the number of times the producer of entries into +* this ring has looped around the ring. +*/ + +#define HAL_REO_CMD_HDR_INFO0_CMD_NUMBER GENMASK(15, 0) +#define HAL_REO_CMD_HDR_INFO0_STATUS_REQUIRED BIT(16) + +struct hal_reo_cmd_hdr { +__le32 info0; +} __packed; + +#define HAL_REO_GET_QUEUE_STATS_INFO0_QUEUE_ADDR_HI GENMASK(7, 0) +#define HAL_REO_GET_QUEUE_STATS_INFO0_CLEAR_STATS BIT(8) + +struct hal_reo_get_queue_stats { +struct hal_reo_cmd_hdr cmd; +__le32 queue_addr_lo; +__le32 info0; +__le32 rsvd0[6 ]; +__le32 tlv64_pad; +} __packed; + +/* hal_reo_get_queue_stats +* Producer: SW +* Consumer: REO +* +* cmd +* Details for command execution tracking purposes. +* +* queue_addr_lo +* Address (lower 32 bits) of the REO queue descriptor. +* +* queue_addr_hi +* Address (upper 8 bits) of the REO queue descriptor. +* +* clear_stats +* Clear stats settings. When set, Clear the stats after +* generating the status. +* +* Following stats will be cleared. +* Timeout_count +* Forward_due_to_bar_count +* Duplicate_count +* Frames_in_order_count +* BAR_received_count +* MPDU_Frames_processed_count +* MSDU_Frames_processed_count +* Total_processed_byte_count +* Late_receive_MPDU_count +* window_jump_2k +* Hole_count +*/ + +#define HAL_REO_FLUSH_QUEUE_INFO0_DESC_ADDR_HI GENMASK(7, 0) +#define HAL_REO_FLUSH_QUEUE_INFO0_BLOCK_DESC_ADDR BIT(8) +#define HAL_REO_FLUSH_QUEUE_INFO0_BLOCK_RESRC_IDX GENMASK(10, 9) + +struct hal_reo_flush_queue { +struct hal_reo_cmd_hdr cmd; +__le32 desc_addr_lo; +__le32 info0; +__le32 rsvd0[6 ]; +} __packed; + +#define HAL_REO_FLUSH_CACHE_INFO0_CACHE_ADDR_HI GENMASK(7, 0) +#define HAL_REO_FLUSH_CACHE_INFO0_FWD_ALL_MPDUS BIT(8) +#define HAL_REO_FLUSH_CACHE_INFO0_RELEASE_BLOCK_IDX BIT(9) +#define HAL_REO_FLUSH_CACHE_INFO0_BLOCK_RESRC_IDX GENMASK(11, 10) +#define HAL_REO_FLUSH_CACHE_INFO0_FLUSH_WO_INVALIDATE BIT(12) +#define HAL_REO_FLUSH_CACHE_INFO0_BLOCK_CACHE_USAGE BIT(13) +#define HAL_REO_FLUSH_CACHE_INFO0_FLUSH_ALL BIT(14) + +struct hal_reo_flush_cache { +struct hal_reo_cmd_hdr cmd; +__le32 cache_addr_lo; +__le32 info0; +__le32 rsvd0[6 ]; +} __packed; + +#define HAL_TCL_DATA_CMD_INFO0_CMD_TYPE BIT(0) +#define HAL_TCL_DATA_CMD_INFO0_DESC_TYPE BIT(1) +#define HAL_TCL_DATA_CMD_INFO0_BANK_ID GENMASK(7, 2) +#define HAL_TCL_DATA_CMD_INFO0_TX_NOTIFY_FRAME GENMASK(10, 8) +#define HAL_TCL_DATA_CMD_INFO0_HDR_LEN_READ_SEL BIT(11) +#define HAL_TCL_DATA_CMD_INFO0_BUF_TIMESTAMP GENMASK(30, 12) +#define HAL_TCL_DATA_CMD_INFO0_BUF_TIMESTAMP_VLD BIT(31) + +#define HAL_TCL_DATA_CMD_INFO1_CMD_NUM GENMASK(31, 16) + +#define HAL_TCL_DATA_CMD_INFO2_DATA_LEN GENMASK(15, 0) +#define HAL_TCL_DATA_CMD_INFO2_IP4_CKSUM_EN BIT(16) +#define HAL_TCL_DATA_CMD_INFO2_UDP4_CKSUM_EN BIT(17) +#define HAL_TCL_DATA_CMD_INFO2_UDP6_CKSUM_EN BIT(18) +#define HAL_TCL_DATA_CMD_INFO2_TCP4_CKSUM_EN BIT(19) +#define HAL_TCL_DATA_CMD_INFO2_TCP6_CKSUM_EN BIT(20) +#define HAL_TCL_DATA_CMD_INFO2_TO_FW BIT(21) +#define HAL_TCL_DATA_CMD_INFO2_PKT_OFFSET GENMASK(31, 23) + +#define HAL_TCL_DATA_CMD_INFO3_TID_OVERWRITE BIT(0) +#define HAL_TCL_DATA_CMD_INFO3_FLOW_OVERRIDE_EN BIT(1) +#define HAL_TCL_DATA_CMD_INFO3_CLASSIFY_INFO_SEL GENMASK(3, 2) +#define HAL_TCL_DATA_CMD_INFO3_TID GENMASK(7, 4) +#define HAL_TCL_DATA_CMD_INFO3_FLOW_OVERRIDE BIT(8) +#define HAL_TCL_DATA_CMD_INFO3_PMAC_ID GENMASK(10, 9) +#define HAL_TCL_DATA_CMD_INFO3_MSDU_COLOR GENMASK(12, 11) +#define HAL_TCL_DATA_CMD_INFO3_VDEV_ID GENMASK(31, 24) + +#define HAL_TCL_DATA_CMD_INFO4_SEARCH_INDEX GENMASK(19, 0) +#define HAL_TCL_DATA_CMD_INFO4_CACHE_SET_NUM GENMASK(23, 20) +#define HAL_TCL_DATA_CMD_INFO4_IDX_LOOKUP_OVERRIDE BIT(24) + +#define HAL_TCL_DATA_CMD_INFO5_RING_ID GENMASK(27, 20) +#define HAL_TCL_DATA_CMD_INFO5_LOOPING_COUNT GENMASK(31, 28) + +enum hal_encrypt_type { +HAL_ENCRYPT_TYPE_WEP_40 , +HAL_ENCRYPT_TYPE_WEP_104 , +HAL_ENCRYPT_TYPE_TKIP_NO_MIC , +HAL_ENCRYPT_TYPE_WEP_128 , +HAL_ENCRYPT_TYPE_TKIP_MIC , +HAL_ENCRYPT_TYPE_WAPI , +HAL_ENCRYPT_TYPE_CCMP_128 , +HAL_ENCRYPT_TYPE_OPEN , +HAL_ENCRYPT_TYPE_CCMP_256 , +HAL_ENCRYPT_TYPE_GCMP_128 , +HAL_ENCRYPT_TYPE_AES_GCMP_256 , +HAL_ENCRYPT_TYPE_WAPI_GCM_SM4 , +}; + +enum hal_tcl_encap_type { +HAL_TCL_ENCAP_TYPE_RAW , +HAL_TCL_ENCAP_TYPE_NATIVE_WIFI , +HAL_TCL_ENCAP_TYPE_ETHERNET , +HAL_TCL_ENCAP_TYPE_802_3 =3 , +}; + +enum hal_tcl_desc_type { +HAL_TCL_DESC_TYPE_BUFFER , +HAL_TCL_DESC_TYPE_EXT_DESC , +}; + +enum hal_wbm_htt_tx_comp_status { +HAL_WBM_REL_HTT_TX_COMP_STATUS_OK , +HAL_WBM_REL_HTT_TX_COMP_STATUS_DROP , +HAL_WBM_REL_HTT_TX_COMP_STATUS_TTL , +HAL_WBM_REL_HTT_TX_COMP_STATUS_REINJ , +HAL_WBM_REL_HTT_TX_COMP_STATUS_INSPECT , +HAL_WBM_REL_HTT_TX_COMP_STATUS_MEC_NOTIFY , +HAL_WBM_REL_HTT_TX_COMP_STATUS_MAX , +}; + +struct hal_tcl_data_cmd { +struct ath12k_buffer_addr buf_addr_info; +__le32 info0; +__le32 info1; +__le32 info2; +__le32 info3; +__le32 info4; +__le32 info5; +} __packed; + +/* hal_tcl_data_cmd +* +* buf_addr_info +* Details of the physical address of a buffer or MSDU +* link descriptor. +* +* tcl_cmd_type +* used to select the type of TCL Command decriptor +* +* desc_type +* Indicates the type of address provided in the buf_addr_info. +* Values are defined in enum %HAL_REO_DEST_RING_BUFFER_TYPE_. +* +* bank_id +* used to select one of the TCL register banks for fields removed +* from 'TCL_DATA_CMD' that do not change often within one virtual +* device or a set of virtual devices: +* +* tx_notify_frame +* TCL copies this value to 'TQM_ENTRANCE_RING' field FW_tx_notify_frame. +* +* hdr_length_read_sel +* used to select the per 'encap_type' register set for MSDU header +* read length +* +* buffer_timestamp +* buffer_timestamp_valid +* Frame system entrance timestamp. It shall be filled by first +* module (SW, TCL or TQM) that sees the frames first. +* +* cmd_num +* This number can be used to match against status. +* +* data_length +* MSDU length in case of direct descriptor. Length of link +* extension descriptor in case of Link extension descriptor. +* +* *_checksum_en +* Enable checksum replacement for ipv4, udp_over_ipv4, ipv6, +* udp_over_ipv6, tcp_over_ipv4 and tcp_over_ipv6. +* +* to_fw +* Forward packet to FW along with classification result. The +* packet will not be forward to TQM when this bit is set. +* 1'b0: Use classification result to forward the packet. +* 1'b1: Override classification result & forward packet only to fw +* +* packet_offset +* Packet offset from Metadata in case of direct buffer descriptor. +* +* hlos_tid_overwrite +* +* When set, TCL shall ignore the IP DSCP and VLAN PCP +* fields and use HLOS_TID as the final TID. Otherwise TCL +* shall consider the DSCP and PCP fields as well as HLOS_TID +* and choose a final TID based on the configured priority +* +* flow_override_enable +* TCL uses this to select the flow pointer from the peer table, +* which can be overridden by SW for pre-encrypted raw WiFi packets +* that cannot be parsed for UDP or for other MLO +* 0 - FP_PARSE_IP: Use the flow-pointer based on parsing the IPv4 +* or IPv6 header. +* 1 - FP_USE_OVERRIDE: Use the who_classify_info_sel and +* flow_override fields to select the flow-pointer +* +* who_classify_info_sel +* Field only valid when flow_override_enable is set to FP_USE_OVERRIDE. +* This field is used to select one of the 'WHO_CLASSIFY_INFO's in the +* peer table in case more than 2 flows are mapped to a single TID. +* 0: To choose Flow 0 and 1 of any TID use this value. +* 1: To choose Flow 2 and 3 of any TID use this value. +* 2: To choose Flow 4 and 5 of any TID use this value. +* 3: To choose Flow 6 and 7 of any TID use this value. +* +* If who_classify_info sel is not in sync with the num_tx_classify_info +* field from address search, then TCL will set 'who_classify_info_sel' +* to 0 use flows 0 and 1. +* +* hlos_tid +* HLOS MSDU priority +* Field is used when HLOS_TID_overwrite is set. +* +* flow_override +* Field only valid when flow_override_enable is set to FP_USE_OVERRIDE +* TCL uses this to select the flow pointer from the peer table, +* which can be overridden by SW for pre-encrypted raw WiFi packets +* that cannot be parsed for UDP or for other MLO +* 0 - FP_USE_NON_UDP: Use the non-UDP flow pointer (flow 0) +* 1 - FP_USE_UDP: Use the UDP flow pointer (flow 1) +* +* pmac_id +* TCL uses this PMAC_ID in address search, i.e, while +* finding matching entry for the packet in AST corresponding +* to given PMAC_ID +* +* If PMAC ID is all 1s (=> value 3), it indicates wildcard +* match for any PMAC +* +* vdev_id +* Virtual device ID to check against the address search entry to +* avoid security issues from transmitting packets from an incorrect +* virtual device +* +* search_index +* The index that will be used for index based address or +* flow search. The field is valid when 'search_type' is 1 or 2. +* +* cache_set_num +* +* Cache set number that should be used to cache the index +* based search results, for address and flow search. This +* value should be equal to LSB four bits of the hash value of +* match data, in case of search index points to an entry which +* may be used in content based search also. The value can be +* anything when the entry pointed by search index will not be +* used for content based search. +* +* index_loop_override +* When set, address search and packet routing is forced to use +* 'search_index' instead of following the register configuration +* seleced by Bank_id. +* +* ring_id +* The buffer pointer ring ID. +* 0 refers to the IDLE ring +* 1 - N refers to other rings +* +* looping_count +* +* A count value that indicates the number of times the +* producer of entries into the Ring has looped around the +* ring. +* +* At initialization time, this value is set to 0. On the +* first loop, this value is set to 1. After the max value is +* reached allowed by the number of bits for this field, the +* count value continues with 0 again. +* +* In case SW is the consumer of the ring entries, it can +* use this field to figure out up to where the producer of +* entries has created new entries. This eliminates the need to +* check where the head pointer' of the ring is located once +* the SW starts processing an interrupt indicating that new +* entries have been put into this ring... +* +* Also note that SW if it wants only needs to look at the +* LSB bit of this count value. +*/ + +#define HAL_TCL_DESC_LEN sizeof(struct hal_tcl_data_cmd) + +#define HAL_TX_MSDU_EXT_INFO0_BUF_PTR_LO GENMASK(31, 0) + +#define HAL_TX_MSDU_EXT_INFO1_BUF_PTR_HI GENMASK(7, 0) +#define HAL_TX_MSDU_EXT_INFO1_EXTN_OVERRIDE BIT(8) +#define HAL_TX_MSDU_EXT_INFO1_ENCAP_TYPE GENMASK(10, 9) +#define HAL_TX_MSDU_EXT_INFO1_ENCRYPT_TYPE GENMASK(14, 11) +#define HAL_TX_MSDU_EXT_INFO1_BUF_LEN GENMASK(31, 16) + +struct hal_tx_msdu_ext_desc { +__le32 rsvd0[6 ]; +__le32 info0; +__le32 info1; +__le32 rsvd1[10 ]; +}; + +struct hal_tcl_gse_cmd { +__le32 ctrl_buf_addr_lo; +__le32 info0; +__le32 meta_data[2 ]; +__le32 rsvd0[2 ]; +__le32 info1; +} __packed; + +/* hal_tcl_gse_cmd +* +* ctrl_buf_addr_lo, ctrl_buf_addr_hi +* Address of a control buffer containing additional info needed +* for this command execution. +* +* meta_data +* Meta data to be returned in the status descriptor +*/ + +enum hal_tcl_cache_op_res { +HAL_TCL_CACHE_OP_RES_DONE , +HAL_TCL_CACHE_OP_RES_NOT_FOUND , +HAL_TCL_CACHE_OP_RES_TIMEOUT , +}; + +struct hal_tcl_status_ring { +__le32 info0; +__le32 msdu_byte_count; +__le32 msdu_timestamp; +__le32 meta_data[2 ]; +__le32 info1; +__le32 rsvd0; +__le32 info2; +} __packed; + +/* hal_tcl_status_ring +* +* msdu_cnt +* msdu_byte_count +* MSDU count of Entry and MSDU byte count for entry 1. +* +*/ + +#define HAL_CE_SRC_DESC_ADDR_INFO_ADDR_HI GENMASK(7, 0) +#define HAL_CE_SRC_DESC_ADDR_INFO_HASH_EN BIT(8) +#define HAL_CE_SRC_DESC_ADDR_INFO_BYTE_SWAP BIT(9) +#define HAL_CE_SRC_DESC_ADDR_INFO_DEST_SWAP BIT(10) +#define HAL_CE_SRC_DESC_ADDR_INFO_GATHER BIT(11) +#define HAL_CE_SRC_DESC_ADDR_INFO_LEN GENMASK(31, 16) + +#define HAL_CE_SRC_DESC_META_INFO_DATA GENMASK(15, 0) + +#define HAL_CE_SRC_DESC_FLAGS_RING_ID GENMASK(27, 20) +#define HAL_CE_SRC_DESC_FLAGS_LOOP_CNT HAL_SRNG_DESC_LOOP_CNT + +struct hal_ce_srng_src_desc { +__le32 buffer_addr_low; +__le32 buffer_addr_info;/* %HAL_CE_SRC_DESC_ADDR_INFO_ */ +__le32 meta_info;/* %HAL_CE_SRC_DESC_META_INFO_ */ +__le32 flags;/* %HAL_CE_SRC_DESC_FLAGS_ */ +} __packed; + +/* hal_ce_srng_src_desc +* +* buffer_addr_lo +* LSB 32 bits of the 40 Bit Pointer to the source buffer +* +* buffer_addr_hi +* MSB 8 bits of the 40 Bit Pointer to the source buffer +* +* toeplitz_en +* Enable generation of 32-bit Toeplitz-LFSR hash for +* data transfer. In case of gather field in first source +* ring entry of the gather copy cycle in taken into account. +* +* src_swap +* Treats source memory organization as big-endian. For +* each dword read (4 bytes), the byte 0 is swapped with byte 3 +* and byte 1 is swapped with byte 2. +* In case of gather field in first source ring entry of +* the gather copy cycle in taken into account. +* +* dest_swap +* Treats destination memory organization as big-endian. +* For each dword write (4 bytes), the byte 0 is swapped with +* byte 3 and byte 1 is swapped with byte 2. +* In case of gather field in first source ring entry of +* the gather copy cycle in taken into account. +* +* gather +* Enables gather of multiple copy engine source +* descriptors to one destination. +* +* ce_res_0 +* Reserved +* +* +* length +* Length of the buffer in units of octets of the current +* descriptor +* +* fw_metadata +* Meta data used by FW. +* In case of gather field in first source ring entry of +* the gather copy cycle in taken into account. +* +* ce_res_1 +* Reserved +* +* ce_res_2 +* Reserved +* +* ring_id +* The buffer pointer ring ID. +* 0 refers to the IDLE ring +* 1 - N refers to other rings +* Helps with debugging when dumping ring contents. +* +* looping_count +* A count value that indicates the number of times the +* producer of entries into the Ring has looped around the +* ring. +* +* At initialization time, this value is set to 0. On the +* first loop, this value is set to 1. After the max value is +* reached allowed by the number of bits for this field, the +* count value continues with 0 again. +* +* In case SW is the consumer of the ring entries, it can +* use this field to figure out up to where the producer of +* entries has created new entries. This eliminates the need to +* check where the head pointer' of the ring is located once +* the SW starts processing an interrupt indicating that new +* entries have been put into this ring... +* +* Also note that SW if it wants only needs to look at the +* LSB bit of this count value. +*/ + +#define HAL_CE_DEST_DESC_ADDR_INFO_ADDR_HI GENMASK(7, 0) +#define HAL_CE_DEST_DESC_ADDR_INFO_RING_ID GENMASK(27, 20) +#define HAL_CE_DEST_DESC_ADDR_INFO_LOOP_CNT HAL_SRNG_DESC_LOOP_CNT + +struct hal_ce_srng_dest_desc { +__le32 buffer_addr_low; +__le32 buffer_addr_info;/* %HAL_CE_DEST_DESC_ADDR_INFO_ */ +} __packed; + +/* hal_ce_srng_dest_desc +* +* dst_buffer_low +* LSB 32 bits of the 40 Bit Pointer to the Destination +* buffer +* +* dst_buffer_high +* MSB 8 bits of the 40 Bit Pointer to the Destination +* buffer +* +* ce_res_4 +* Reserved +* +* ring_id +* The buffer pointer ring ID. +* 0 refers to the IDLE ring +* 1 - N refers to other rings +* Helps with debugging when dumping ring contents. +* +* looping_count +* A count value that indicates the number of times the +* producer of entries into the Ring has looped around the +* ring. +* +* At initialization time, this value is set to 0. On the +* first loop, this value is set to 1. After the max value is +* reached allowed by the number of bits for this field, the +* count value continues with 0 again. +* +* In case SW is the consumer of the ring entries, it can +* use this field to figure out up to where the producer of +* entries has created new entries. This eliminates the need to +* check where the head pointer' of the ring is located once +* the SW starts processing an interrupt indicating that new +* entries have been put into this ring... +* +* Also note that SW if it wants only needs to look at the +* LSB bit of this count value. +*/ + +#define HAL_CE_DST_STATUS_DESC_FLAGS_HASH_EN BIT(8) +#define HAL_CE_DST_STATUS_DESC_FLAGS_BYTE_SWAP BIT(9) +#define HAL_CE_DST_STATUS_DESC_FLAGS_DEST_SWAP BIT(10) +#define HAL_CE_DST_STATUS_DESC_FLAGS_GATHER BIT(11) +#define HAL_CE_DST_STATUS_DESC_FLAGS_LEN GENMASK(31, 16) + +#define HAL_CE_DST_STATUS_DESC_META_INFO_DATA GENMASK(15, 0) +#define HAL_CE_DST_STATUS_DESC_META_INFO_RING_ID GENMASK(27, 20) +#define HAL_CE_DST_STATUS_DESC_META_INFO_LOOP_CNT HAL_SRNG_DESC_LOOP_CNT + +struct hal_ce_srng_dst_status_desc { +__le32 flags;/* %HAL_CE_DST_STATUS_DESC_FLAGS_ */ +__le32 toeplitz_hash0; +__le32 toeplitz_hash1; +__le32 meta_info;/* HAL_CE_DST_STATUS_DESC_META_INFO_ */ +} __packed; + +/* hal_ce_srng_dst_status_desc +* +* ce_res_5 +* Reserved +* +* toeplitz_en +* +* src_swap +* Source memory buffer swapped +* +* dest_swap +* Destination memory buffer swapped +* +* gather +* Gather of multiple copy engine source descriptors to one +* destination enabled +* +* ce_res_6 +* Reserved +* +* length +* Sum of all the Lengths of the source descriptor in the +* gather chain +* +* toeplitz_hash_0 +* 32 LS bits of 64 bit Toeplitz LFSR hash result +* +* toeplitz_hash_1 +* 32 MS bits of 64 bit Toeplitz LFSR hash result +* +* fw_metadata +* Meta data used by FW +* In case of gather field in first source ring entry of +* the gather copy cycle in taken into account. +* +* ce_res_7 +* Reserved +* +* ring_id +* The buffer pointer ring ID. +* 0 refers to the IDLE ring +* 1 - N refers to other rings +* Helps with debugging when dumping ring contents. +* +* looping_count +* A count value that indicates the number of times the +* producer of entries into the Ring has looped around the +* ring. +* +* At initialization time, this value is set to 0. On the +* first loop, this value is set to 1. After the max value is +* reached allowed by the number of bits for this field, the +* count value continues with 0 again. +* +* In case SW is the consumer of the ring entries, it can +* use this field to figure out up to where the producer of +* entries has created new entries. This eliminates the need to +* check where the head pointer' of the ring is located once +* the SW starts processing an interrupt indicating that new +* entries have been put into this ring... +* +* Also note that SW if it wants only needs to look at the +* LSB bit of this count value. +*/ + +#define HAL_TX_RATE_STATS_INFO0_VALID BIT(0) +#define HAL_TX_RATE_STATS_INFO0_BW GENMASK(3, 1) +#define HAL_TX_RATE_STATS_INFO0_PKT_TYPE GENMASK(7, 4) +#define HAL_TX_RATE_STATS_INFO0_STBC BIT(8) +#define HAL_TX_RATE_STATS_INFO0_LDPC BIT(9) +#define HAL_TX_RATE_STATS_INFO0_SGI GENMASK(11, 10) +#define HAL_TX_RATE_STATS_INFO0_MCS GENMASK(15, 12) +#define HAL_TX_RATE_STATS_INFO0_OFDMA_TX BIT(16) +#define HAL_TX_RATE_STATS_INFO0_TONES_IN_RU GENMASK(28, 17) + +enum hal_tx_rate_stats_bw { +HAL_TX_RATE_STATS_BW_20 , +HAL_TX_RATE_STATS_BW_40 , +HAL_TX_RATE_STATS_BW_80 , +HAL_TX_RATE_STATS_BW_160 , +}; + +enum hal_tx_rate_stats_pkt_type { +HAL_TX_RATE_STATS_PKT_TYPE_11A , +HAL_TX_RATE_STATS_PKT_TYPE_11B , +HAL_TX_RATE_STATS_PKT_TYPE_11N , +HAL_TX_RATE_STATS_PKT_TYPE_11AC , +HAL_TX_RATE_STATS_PKT_TYPE_11AX , +HAL_TX_RATE_STATS_PKT_TYPE_11BA , +HAL_TX_RATE_STATS_PKT_TYPE_11BE , +}; + +enum hal_tx_rate_stats_sgi { +HAL_TX_RATE_STATS_SGI_08US , +HAL_TX_RATE_STATS_SGI_04US , +HAL_TX_RATE_STATS_SGI_16US , +HAL_TX_RATE_STATS_SGI_32US , +}; + +struct hal_tx_rate_stats { +__le32 info0; +__le32 tsf; +} __packed; + +struct hal_wbm_link_desc { +struct ath12k_buffer_addr buf_addr_info; +} __packed; + +/* hal_wbm_link_desc +* +* Producer: WBM +* Consumer: WBM +* +* buf_addr_info +* Details of the physical address of a buffer or MSDU +* link descriptor. +*/ + +enum hal_wbm_rel_src_module { +HAL_WBM_REL_SRC_MODULE_TQM , +HAL_WBM_REL_SRC_MODULE_RXDMA , +HAL_WBM_REL_SRC_MODULE_REO , +HAL_WBM_REL_SRC_MODULE_FW , +HAL_WBM_REL_SRC_MODULE_SW , +}; + +enum hal_wbm_rel_desc_type { +HAL_WBM_REL_DESC_TYPE_REL_MSDU , +HAL_WBM_REL_DESC_TYPE_MSDU_LINK , +HAL_WBM_REL_DESC_TYPE_MPDU_LINK , +HAL_WBM_REL_DESC_TYPE_MSDU_EXT , +HAL_WBM_REL_DESC_TYPE_QUEUE_EXT , +}; + +/* hal_wbm_rel_desc_type +* +* msdu_buffer +* The address points to an MSDU buffer +* +* msdu_link_descriptor +* The address points to an Tx MSDU link descriptor +* +* mpdu_link_descriptor +* The address points to an MPDU link descriptor +* +* msdu_ext_descriptor +* The address points to an MSDU extension descriptor +* +* queue_ext_descriptor +* The address points to an TQM queue extension descriptor. WBM should +* treat this is the same way as a link descriptor. +*/ + +enum hal_wbm_rel_bm_act { +HAL_WBM_REL_BM_ACT_PUT_IN_IDLE , +HAL_WBM_REL_BM_ACT_REL_MSDU , +}; + +/* hal_wbm_rel_bm_act +* +* put_in_idle_list +* Put the buffer or descriptor back in the idle list. In case of MSDU or +* MDPU link descriptor, BM does not need to check to release any +* individual MSDU buffers. +* +* release_msdu_list +* This BM action can only be used in combination with desc_type being +* msdu_link_descriptor. Field first_msdu_index points out which MSDU +* pointer in the MSDU link descriptor is the first of an MPDU that is +* released. BM shall release all the MSDU buffers linked to this first +* MSDU buffer pointer. All related MSDU buffer pointer entries shall be +* set to value 0, which represents the 'NULL' pointer. When all MSDU +* buffer pointers in the MSDU link descriptor are 'NULL', the MSDU link +* descriptor itself shall also be released. +*/ +#define HAL_WBM_COMPL_RX_INFO0_REL_SRC_MODULE GENMASK(2, 0) +#define HAL_WBM_COMPL_RX_INFO0_BM_ACTION GENMASK(5, 3) +#define HAL_WBM_COMPL_RX_INFO0_DESC_TYPE GENMASK(8, 6) +#define HAL_WBM_COMPL_RX_INFO0_RBM GENMASK(12, 9) +#define HAL_WBM_COMPL_RX_INFO0_RXDMA_PUSH_REASON GENMASK(18, 17) +#define HAL_WBM_COMPL_RX_INFO0_RXDMA_ERROR_CODE GENMASK(23, 19) +#define HAL_WBM_COMPL_RX_INFO0_REO_PUSH_REASON GENMASK(25, 24) +#define HAL_WBM_COMPL_RX_INFO0_REO_ERROR_CODE GENMASK(30, 26) +#define HAL_WBM_COMPL_RX_INFO0_WBM_INTERNAL_ERROR BIT(31) + +#define HAL_WBM_COMPL_RX_INFO1_PHY_ADDR_HI GENMASK(7, 0) +#define HAL_WBM_COMPL_RX_INFO1_SW_COOKIE GENMASK(27, 8) +#define HAL_WBM_COMPL_RX_INFO1_LOOPING_COUNT GENMASK(31, 28) + +struct hal_wbm_completion_ring_rx { +__le32 addr_lo; +__le32 addr_hi; +__le32 info0; +struct rx_mpdu_desc rx_mpdu_info; +struct rx_msdu_desc rx_msdu_info; +__le32 phy_addr_lo; +__le32 info1; +} __packed; + +#define HAL_WBM_COMPL_TX_INFO0_REL_SRC_MODULE GENMASK(2, 0) +#define HAL_WBM_COMPL_TX_INFO0_DESC_TYPE GENMASK(8, 6) +#define HAL_WBM_COMPL_TX_INFO0_RBM GENMASK(12, 9) +#define HAL_WBM_COMPL_TX_INFO0_TQM_RELEASE_REASON GENMASK(16, 13) +#define HAL_WBM_COMPL_TX_INFO0_RBM_OVERRIDE_VLD BIT(17) +#define HAL_WBM_COMPL_TX_INFO0_SW_COOKIE_LO GENMASK(29, 18) +#define HAL_WBM_COMPL_TX_INFO0_CC_DONE BIT(30) +#define HAL_WBM_COMPL_TX_INFO0_WBM_INTERNAL_ERROR BIT(31) + +#define HAL_WBM_COMPL_TX_INFO1_TQM_STATUS_NUMBER GENMASK(23, 0) +#define HAL_WBM_COMPL_TX_INFO1_TRANSMIT_COUNT GENMASK(30, 24) +#define HAL_WBM_COMPL_TX_INFO1_SW_REL_DETAILS_VALID BIT(31) + +#define HAL_WBM_COMPL_TX_INFO2_ACK_FRAME_RSSI GENMASK(7, 0) +#define HAL_WBM_COMPL_TX_INFO2_FIRST_MSDU BIT(8) +#define HAL_WBM_COMPL_TX_INFO2_LAST_MSDU BIT(9) +#define HAL_WBM_COMPL_TX_INFO2_FW_TX_NOTIF_FRAME GENMASK(12, 10) +#define HAL_WBM_COMPL_TX_INFO2_BUFFER_TIMESTAMP GENMASK(31, 13) + +#define HAL_WBM_COMPL_TX_INFO3_PEER_ID GENMASK(15, 0) +#define HAL_WBM_COMPL_TX_INFO3_TID GENMASK(19, 16) +#define HAL_WBM_COMPL_TX_INFO3_SW_COOKIE_HI GENMASK(27, 20) +#define HAL_WBM_COMPL_TX_INFO3_LOOPING_COUNT GENMASK(31, 28) + +struct hal_wbm_completion_ring_tx { +__le32 buf_va_lo; +__le32 buf_va_hi; +__le32 info0; +__le32 info1; +__le32 info2; +struct hal_tx_rate_stats rate_stats; +__le32 info3; +} __packed; + +#define HAL_WBM_RELEASE_TX_INFO0_REL_SRC_MODULE GENMASK(2, 0) +#define HAL_WBM_RELEASE_TX_INFO0_BM_ACTION GENMASK(5, 3) +#define HAL_WBM_RELEASE_TX_INFO0_DESC_TYPE GENMASK(8, 6) +#define HAL_WBM_RELEASE_TX_INFO0_FIRST_MSDU_IDX GENMASK(12, 9) +#define HAL_WBM_RELEASE_TX_INFO0_TQM_RELEASE_REASON GENMASK(18, 13) +#define HAL_WBM_RELEASE_TX_INFO0_RBM_OVERRIDE_VLD BIT(17) +#define HAL_WBM_RELEASE_TX_INFO0_SW_BUFFER_COOKIE_11_0 GENMASK(29, 18) +#define HAL_WBM_RELEASE_TX_INFO0_WBM_INTERNAL_ERROR BIT(31) + +#define HAL_WBM_RELEASE_TX_INFO1_TQM_STATUS_NUMBER GENMASK(23, 0) +#define HAL_WBM_RELEASE_TX_INFO1_TRANSMIT_COUNT GENMASK(30, 24) +#define HAL_WBM_RELEASE_TX_INFO1_SW_REL_DETAILS_VALID BIT(31) + +#define HAL_WBM_RELEASE_TX_INFO2_ACK_FRAME_RSSI GENMASK(7, 0) +#define HAL_WBM_RELEASE_TX_INFO2_FIRST_MSDU BIT(8) +#define HAL_WBM_RELEASE_TX_INFO2_LAST_MSDU BIT(9) +#define HAL_WBM_RELEASE_TX_INFO2_FW_TX_NOTIF_FRAME GENMASK(12, 10) +#define HAL_WBM_RELEASE_TX_INFO2_BUFFER_TIMESTAMP GENMASK(31, 13) + +#define HAL_WBM_RELEASE_TX_INFO3_PEER_ID GENMASK(15, 0) +#define HAL_WBM_RELEASE_TX_INFO3_TID GENMASK(19, 16) +#define HAL_WBM_RELEASE_TX_INFO3_SW_BUFFER_COOKIE_19_12 GENMASK(27, 20) +#define HAL_WBM_RELEASE_TX_INFO3_LOOPING_COUNT GENMASK(31, 28) + +struct hal_wbm_release_ring_tx { +struct ath12k_buffer_addr buf_addr_info; +__le32 info0; +__le32 info1; +__le32 info2; +struct hal_tx_rate_stats rate_stats; +__le32 info3; +} __packed; + +#define HAL_WBM_RELEASE_RX_INFO0_REL_SRC_MODULE GENMASK(2, 0) +#define HAL_WBM_RELEASE_RX_INFO0_BM_ACTION GENMASK(5, 3) +#define HAL_WBM_RELEASE_RX_INFO0_DESC_TYPE GENMASK(8, 6) +#define HAL_WBM_RELEASE_RX_INFO0_FIRST_MSDU_IDX GENMASK(12, 9) +#define HAL_WBM_RELEASE_RX_INFO0_CC_STATUS BIT(16) +#define HAL_WBM_RELEASE_RX_INFO0_RXDMA_PUSH_REASON GENMASK(18, 17) +#define HAL_WBM_RELEASE_RX_INFO0_RXDMA_ERROR_CODE GENMASK(23, 19) +#define HAL_WBM_RELEASE_RX_INFO0_REO_PUSH_REASON GENMASK(25, 24) +#define HAL_WBM_RELEASE_RX_INFO0_REO_ERROR_CODE GENMASK(30, 26) +#define HAL_WBM_RELEASE_RX_INFO0_WBM_INTERNAL_ERROR BIT(31) + +#define HAL_WBM_RELEASE_RX_INFO2_RING_ID GENMASK(27, 20) +#define HAL_WBM_RELEASE_RX_INFO2_LOOPING_COUNT GENMASK(31, 28) + +struct hal_wbm_release_ring_rx { +struct ath12k_buffer_addr buf_addr_info; +__le32 info0; +struct rx_mpdu_desc rx_mpdu_info; +struct rx_msdu_desc rx_msdu_info; +__le32 info1; +__le32 info2; +} __packed; + +#define HAL_WBM_RELEASE_RX_CC_INFO0_RBM GENMASK(12, 9) +#define HAL_WBM_RELEASE_RX_CC_INFO1_COOKIE GENMASK(27, 8) +/* Used when hw cc is success */ +struct hal_wbm_release_ring_cc_rx { +__le32 buf_va_lo; +__le32 buf_va_hi; +__le32 info0; +struct rx_mpdu_desc rx_mpdu_info; +struct rx_msdu_desc rx_msdu_info; +__le32 buf_pa_lo; +__le32 info1; +} __packed; + +#define HAL_WBM_RELEASE_INFO0_REL_SRC_MODULE GENMASK(2, 0) +#define HAL_WBM_RELEASE_INFO0_BM_ACTION GENMASK(5, 3) +#define HAL_WBM_RELEASE_INFO0_DESC_TYPE GENMASK(8, 6) +#define HAL_WBM_RELEASE_INFO0_RXDMA_PUSH_REASON GENMASK(18, 17) +#define HAL_WBM_RELEASE_INFO0_RXDMA_ERROR_CODE GENMASK(23, 19) +#define HAL_WBM_RELEASE_INFO0_REO_PUSH_REASON GENMASK(25, 24) +#define HAL_WBM_RELEASE_INFO0_REO_ERROR_CODE GENMASK(30, 26) +#define HAL_WBM_RELEASE_INFO0_WBM_INTERNAL_ERROR BIT(31) + +#define HAL_WBM_RELEASE_INFO3_FIRST_MSDU BIT(0) +#define HAL_WBM_RELEASE_INFO3_LAST_MSDU BIT(1) +#define HAL_WBM_RELEASE_INFO3_CONTINUATION BIT(2) + +#define HAL_WBM_RELEASE_INFO5_LOOPING_COUNT GENMASK(31, 28) + +struct hal_wbm_release_ring { +struct ath12k_buffer_addr buf_addr_info; +__le32 info0; +__le32 info1; +__le32 info2; +__le32 info3; +__le32 info4; +__le32 info5; +} __packed; + +/* hal_wbm_release_ring +* +* Producer: SW/TQM/RXDMA/REO/SWITCH +* Consumer: WBM/SW/FW +* +* HTT tx status is overlayed on wbm_release ring on 4-byte words 2, 3, 4 and 5 +* for software based completions. +* +* buf_addr_info +* Details of the physical address of the buffer or link descriptor. +* +* release_source_module +* Indicates which module initiated the release of this buffer/descriptor. +* Values are defined in enum %HAL_WBM_REL_SRC_MODULE_. +* +* buffer_or_desc_type +* Field only valid when WBM is marked as the return_buffer_manager in +* the Released_Buffer_address_info. Indicates that type of buffer or +* descriptor is being released. Values are in enum %HAL_WBM_REL_DESC_TYPE. +* +* wbm_internal_error +* Is set when WBM got a buffer pointer but the action was to push it to +* the idle link descriptor ring or do link related activity OR +* Is set when WBM got a link buffer pointer but the action was to push it +* to the buffer descriptor ring. +* +* looping_count +* A count value that indicates the number of times the +* producer of entries into the Buffer Manager Ring has looped +* around the ring. +* +* At initialization time, this value is set to 0. On the +* first loop, this value is set to 1. After the max value is +* reached allowed by the number of bits for this field, the +* count value continues with 0 again. +* +* In case SW is the consumer of the ring entries, it can +* use this field to figure out up to where the producer of +* entries has created new entries. This eliminates the need to +* check where the head pointer' of the ring is located once +* the SW starts processing an interrupt indicating that new +* entries have been put into this ring... +* +* Also note that SW if it wants only needs to look at the +* LSB bit of this count value. +*/ + +/** +* enum hal_wbm_tqm_rel_reason - TQM release reason code +* @HAL_WBM_TQM_REL_REASON_FRAME_ACKED: ACK or BACK received for the frame +* @HAL_WBM_TQM_REL_REASON_CMD_REMOVE_MPDU: Command remove_mpdus initiated by SW +* @HAL_WBM_TQM_REL_REASON_CMD_REMOVE_TX: Command remove transmitted_mpdus +* initiated by sw. +* @HAL_WBM_TQM_REL_REASON_CMD_REMOVE_NOTX: Command remove untransmitted_mpdus +* initiated by sw. +* @HAL_WBM_TQM_REL_REASON_CMD_REMOVE_AGED_FRAMES: Command remove aged msdus or +* mpdus. +* @HAL_WBM_TQM_REL_REASON_CMD_REMOVE_RESEAON1: Remove command initiated by +* fw with fw_reason1. +* @HAL_WBM_TQM_REL_REASON_CMD_REMOVE_RESEAON2: Remove command initiated by +* fw with fw_reason2. +* @HAL_WBM_TQM_REL_REASON_CMD_REMOVE_RESEAON3: Remove command initiated by +* fw with fw_reason3. +*/ +enum hal_wbm_tqm_rel_reason { +HAL_WBM_TQM_REL_REASON_FRAME_ACKED , +HAL_WBM_TQM_REL_REASON_CMD_REMOVE_MPDU , +HAL_WBM_TQM_REL_REASON_CMD_REMOVE_TX , +HAL_WBM_TQM_REL_REASON_CMD_REMOVE_NOTX , +HAL_WBM_TQM_REL_REASON_CMD_REMOVE_AGED_FRAMES , +HAL_WBM_TQM_REL_REASON_CMD_REMOVE_RESEAON1 , +HAL_WBM_TQM_REL_REASON_CMD_REMOVE_RESEAON2 , +HAL_WBM_TQM_REL_REASON_CMD_REMOVE_RESEAON3 , +}; + +struct hal_wbm_buffer_ring { +struct ath12k_buffer_addr buf_addr_info; +}; + +enum hal_mon_end_reason { +HAL_MON_STATUS_BUFFER_FULL , +HAL_MON_FLUSH_DETECTED , +HAL_MON_END_OF_PPDU , +HAL_MON_PPDU_TRUNCATED , +}; + +#define HAL_SW_MONITOR_RING_INFO0_RXDMA_PUSH_REASON GENMASK(1, 0) +#define HAL_SW_MONITOR_RING_INFO0_RXDMA_ERROR_CODE GENMASK(6, 2) +#define HAL_SW_MONITOR_RING_INFO0_MPDU_FRAGMENT_NUMBER GENMASK(10, 7) +#define HAL_SW_MONITOR_RING_INFO0_FRAMELESS_BAR BIT(11) +#define HAL_SW_MONITOR_RING_INFO0_STATUS_BUF_COUNT GENMASK(15, 12) +#define HAL_SW_MONITOR_RING_INFO0_END_OF_PPDU BIT(16) + +#define HAL_SW_MONITOR_RING_INFO1_PHY_PPDU_ID GENMASK(15, 0) +#define HAL_SW_MONITOR_RING_INFO1_RING_ID GENMASK(27, 20) +#define HAL_SW_MONITOR_RING_INFO1_LOOPING_COUNT GENMASK(31, 28) + +struct hal_sw_monitor_ring { +struct ath12k_buffer_addr buf_addr_info; +struct rx_mpdu_desc rx_mpdu_info; +struct ath12k_buffer_addr status_buff_addr_info; +__le32 info0;/* %HAL_SW_MONITOR_RING_INFO0 */ +__le32 info1;/* %HAL_SW_MONITOR_RING_INFO1 */ +} __packed; + +/* hal_sw_monitor_ring +* +* Producer: RXDMA +* Consumer: REO/SW/FW +* buf_addr_info +* Details of the physical address of a buffer or MSDU +* link descriptor. +* +* rx_mpdu_info +* Details related to the MPDU being pushed to SW, valid +* only if end_of_ppdu is set to 0. +* +* status_buff_addr_info +* Details of the physical address of the first status +* buffer used for the PPDU (either the PPDU that included the +* MPDU being pushed to SW if end_of_ppdu = 0, or the PPDU +* whose end is indicated through end_of_ppdu = 1) +* +* rxdma_push_reason +* Indicates why RXDMA pushed the frame to this ring +* +* <enum 0 rxdma_error_detected> RXDMA detected an error an +* pushed this frame to this queue +* +* <enum 1 rxdma_routing_instruction> RXDMA pushed the +* frame to this queue per received routing instructions. No +* error within RXDMA was detected +* +* <enum 2 rxdma_rx_flush> RXDMA received an RX_FLUSH. As a +* result the MSDU link descriptor might not have the +* last_msdu_in_mpdu_flag set, but instead WBM might just see a +* NULL pointer in the MSDU link descriptor. This is to be +* considered a normal condition for this scenario. +* +* rxdma_error_code +* Field only valid when rxdma_push_reason is set to +* 'rxdma_error_detected.' +* +* <enum 0 rxdma_overflow_err>MPDU frame is not complete +* due to a FIFO overflow error in RXPCU. +* +* <enum 1 rxdma_mpdu_length_err>MPDU frame is not complete +* due to receiving incomplete MPDU from the PHY +* +* <enum 3 rxdma_decrypt_err>CRYPTO reported a decryption +* error or CRYPTO received an encrypted frame, but did not get +* a valid corresponding key id in the peer entry. +* +* <enum 4 rxdma_tkip_mic_err>CRYPTO reported a TKIP MIC +* error +* +* <enum 5 rxdma_unecrypted_err>CRYPTO reported an +* unencrypted frame error when encrypted was expected +* +* <enum 6 rxdma_msdu_len_err>RX OLE reported an MSDU +* length error +* +* <enum 7 rxdma_msdu_limit_err>RX OLE reported that max +* number of MSDUs allowed in an MPDU got exceeded +* +* <enum 8 rxdma_wifi_parse_err>RX OLE reported a parsing +* error +* +* <enum 9 rxdma_amsdu_parse_err>RX OLE reported an A-MSDU +* parsing error +* +* <enum 10 rxdma_sa_timeout_err>RX OLE reported a timeout +* during SA search +* +* <enum 11 rxdma_da_timeout_err>RX OLE reported a timeout +* during DA search +* +* <enum 12 rxdma_flow_timeout_err>RX OLE reported a +* timeout during flow search +* +* <enum 13 rxdma_flush_request>RXDMA received a flush +* request +* +* <enum 14 rxdma_amsdu_fragment_err>Rx PCU reported A-MSDU +* present as well as a fragmented MPDU. +* +* mpdu_fragment_number +* Field only valid when Reo_level_mpdu_frame_info. +* Rx_mpdu_desc_info_details.Fragment_flag is set and +* end_of_ppdu is set to 0. +* +* The fragment number from the 802.11 header. +* +* Note that the sequence number is embedded in the field: +* Reo_level_mpdu_frame_info. Rx_mpdu_desc_info_details. +* Mpdu_sequence_number +* +* frameless_bar +* When set, this SW monitor ring struct contains BAR info +* from a multi TID BAR frame. The original multi TID BAR frame +* itself contained all the REO info for the first TID, but all +* the subsequent TID info and their linkage to the REO +* descriptors is passed down as 'frameless' BAR info. +* +* The only fields valid in this descriptor when this bit +* is within the +* +* Reo_level_mpdu_frame_info: +* Within Rx_mpdu_desc_info_details: +* Mpdu_Sequence_number +* BAR_frame +* Peer_meta_data +* All other fields shall be set to 0. +* +* status_buf_count +* A count of status buffers used so far for the PPDU +* (either the PPDU that included the MPDU being pushed to SW +* if end_of_ppdu = 0, or the PPDU whose end is indicated +* through end_of_ppdu = 1) +* +* end_of_ppdu +* Some hw RXDMA can be configured to generate a separate +* 'SW_MONITOR_RING' descriptor at the end of a PPDU (either +* through an 'RX_PPDU_END' TLV or through an 'RX_FLUSH') to +* demarcate PPDUs. +* +* For such a descriptor, this bit is set to 1 and fields +* Reo_level_mpdu_frame_info, mpdu_fragment_number and +* Frameless_bar are all set to 0. +* +* Otherwise this bit is set to 0. +* +* phy_ppdu_id +* A PPDU counter value that PHY increments for every PPDU +* received +* +* The counter value wraps around. Some hw RXDMA can be +* configured to copy this from the RX_PPDU_START TLV for every +* output descriptor. +* +* ring_id +* For debugging. +* This field is filled in by the SRNG module. +* It help to identify the ring that is being looked +* +* looping_count +* For debugging. +* This field is filled in by the SRNG module. +* +* A count value that indicates the number of times the +* producer of entries into this Ring has looped around the +* ring. +* At initialization time, this value is set to 0. On the +* first loop, this value is set to 1. After the max value is +* reached allowed by the number of bits for this field, the +* count value continues with 0 again. +* +* In case SW is the consumer of the ring entries, it can +* use this field to figure out up to where the producer of +* entries has created new entries. This eliminates the need to +* check where the head pointer' of the ring is located once +* the SW starts processing an interrupt indicating that new +* entries have been put into this ring... +*/ + +enum hal_desc_owner { +HAL_DESC_OWNER_WBM , +HAL_DESC_OWNER_SW , +HAL_DESC_OWNER_TQM , +HAL_DESC_OWNER_RXDMA , +HAL_DESC_OWNER_REO , +HAL_DESC_OWNER_SWITCH , +}; + +enum hal_desc_buf_type { +HAL_DESC_BUF_TYPE_TX_MSDU_LINK , +HAL_DESC_BUF_TYPE_TX_MPDU_LINK , +HAL_DESC_BUF_TYPE_TX_MPDU_QUEUE_HEAD , +HAL_DESC_BUF_TYPE_TX_MPDU_QUEUE_EXT , +HAL_DESC_BUF_TYPE_TX_FLOW , +HAL_DESC_BUF_TYPE_TX_BUFFER , +HAL_DESC_BUF_TYPE_RX_MSDU_LINK , +HAL_DESC_BUF_TYPE_RX_MPDU_LINK , +HAL_DESC_BUF_TYPE_RX_REO_QUEUE , +HAL_DESC_BUF_TYPE_RX_REO_QUEUE_EXT , +HAL_DESC_BUF_TYPE_RX_BUFFER , +HAL_DESC_BUF_TYPE_IDLE_LINK , +}; + +#define HAL_DESC_REO_OWNED 4 +#define HAL_DESC_REO_QUEUE_DESC 8 +#define HAL_DESC_REO_QUEUE_EXT_DESC 9 +#define HAL_DESC_REO_NON_QOS_TID 16 + +#define HAL_DESC_HDR_INFO0_OWNER GENMASK(3, 0) +#define HAL_DESC_HDR_INFO0_BUF_TYPE GENMASK(7, 4) +#define HAL_DESC_HDR_INFO0_DBG_RESERVED GENMASK(31, 8) + +struct hal_desc_header { +__le32 info0; +} __packed; + +struct hal_rx_mpdu_link_ptr { +struct ath12k_buffer_addr addr_info; +} __packed; + +struct hal_rx_msdu_details { +struct ath12k_buffer_addr buf_addr_info; +struct rx_msdu_desc rx_msdu_info; +struct rx_msdu_ext_desc rx_msdu_ext_info; +} __packed; + +#define HAL_RX_MSDU_LNK_INFO0_RX_QUEUE_NUMBER GENMASK(15, 0) +#define HAL_RX_MSDU_LNK_INFO0_FIRST_MSDU_LNK BIT(16) + +struct hal_rx_msdu_link { +struct hal_desc_header desc_hdr; +struct ath12k_buffer_addr buf_addr_info; +__le32 info0; +__le32 pn[4 ]; +struct hal_rx_msdu_details msdu_link[6 ]; +} __packed; + +struct hal_rx_reo_queue_ext { +struct hal_desc_header desc_hdr; +__le32 rsvd; +struct hal_rx_mpdu_link_ptr mpdu_link[15 ]; +} __packed; + +/* hal_rx_reo_queue_ext +* Consumer: REO +* Producer: REO +* +* descriptor_header +* Details about which module owns this struct. +* +* mpdu_link +* Pointer to the next MPDU_link descriptor in the MPDU queue. +*/ + +enum hal_rx_reo_queue_pn_size { +HAL_RX_REO_QUEUE_PN_SIZE_24 , +HAL_RX_REO_QUEUE_PN_SIZE_48 , +HAL_RX_REO_QUEUE_PN_SIZE_128 , +}; + +#define HAL_RX_REO_QUEUE_RX_QUEUE_NUMBER GENMASK(15, 0) + +#define HAL_RX_REO_QUEUE_INFO0_VLD BIT(0) +#define HAL_RX_REO_QUEUE_INFO0_ASSOC_LNK_DESC_COUNTER GENMASK(2, 1) +#define HAL_RX_REO_QUEUE_INFO0_DIS_DUP_DETECTION BIT(3) +#define HAL_RX_REO_QUEUE_INFO0_SOFT_REORDER_EN BIT(4) +#define HAL_RX_REO_QUEUE_INFO0_AC GENMASK(6, 5) +#define HAL_RX_REO_QUEUE_INFO0_BAR BIT(7) +#define HAL_RX_REO_QUEUE_INFO0_RETRY BIT(8) +#define HAL_RX_REO_QUEUE_INFO0_CHECK_2K_MODE BIT(9) +#define HAL_RX_REO_QUEUE_INFO0_OOR_MODE BIT(10) +#define HAL_RX_REO_QUEUE_INFO0_BA_WINDOW_SIZE GENMASK(20, 11) +#define HAL_RX_REO_QUEUE_INFO0_PN_CHECK BIT(21) +#define HAL_RX_REO_QUEUE_INFO0_EVEN_PN BIT(22) +#define HAL_RX_REO_QUEUE_INFO0_UNEVEN_PN BIT(23) +#define HAL_RX_REO_QUEUE_INFO0_PN_HANDLE_ENABLE BIT(24) +#define HAL_RX_REO_QUEUE_INFO0_PN_SIZE GENMASK(26, 25) +#define HAL_RX_REO_QUEUE_INFO0_IGNORE_AMPDU_FLG BIT(27) + +#define HAL_RX_REO_QUEUE_INFO1_SVLD BIT(0) +#define HAL_RX_REO_QUEUE_INFO1_SSN GENMASK(12, 1) +#define HAL_RX_REO_QUEUE_INFO1_CURRENT_IDX GENMASK(22, 13) +#define HAL_RX_REO_QUEUE_INFO1_SEQ_2K_ERR BIT(23) +#define HAL_RX_REO_QUEUE_INFO1_PN_ERR BIT(24) +#define HAL_RX_REO_QUEUE_INFO1_PN_VALID BIT(31) + +#define HAL_RX_REO_QUEUE_INFO2_MPDU_COUNT GENMASK(6, 0) +#define HAL_RX_REO_QUEUE_INFO2_MSDU_COUNT (31, 7) + +#define HAL_RX_REO_QUEUE_INFO3_TIMEOUT_COUNT GENMASK(9, 4) +#define HAL_RX_REO_QUEUE_INFO3_FWD_DUE_TO_BAR_CNT GENMASK(15, 10) +#define HAL_RX_REO_QUEUE_INFO3_DUPLICATE_COUNT GENMASK(31, 16) + +#define HAL_RX_REO_QUEUE_INFO4_FRAME_IN_ORD_COUNT GENMASK(23, 0) +#define HAL_RX_REO_QUEUE_INFO4_BAR_RECVD_COUNT GENMASK(31, 24) + +#define HAL_RX_REO_QUEUE_INFO5_LATE_RX_MPDU_COUNT GENMASK(11, 0) +#define HAL_RX_REO_QUEUE_INFO5_WINDOW_JUMP_2K GENMASK(15, 12) +#define HAL_RX_REO_QUEUE_INFO5_HOLE_COUNT GENMASK(31, 16) + +struct hal_rx_reo_queue { +struct hal_desc_header desc_hdr; +__le32 rx_queue_num; +__le32 info0; +__le32 info1; +__le32 pn[4 ]; +__le32 last_rx_enqueue_timestamp; +__le32 last_rx_dequeue_timestamp; +__le32 next_aging_queue[2 ]; +__le32 prev_aging_queue[2 ]; +__le32 rx_bitmap[9 ]; +__le32 info2; +__le32 info3; +__le32 info4; +__le32 processed_mpdus; +__le32 processed_msdus; +__le32 processed_total_bytes; +__le32 info5; +__le32 rsvd[2 ]; +struct hal_rx_reo_queue_ext ext_desc[]; +} __packed; + +/* hal_rx_reo_queue +* +* descriptor_header +* Details about which module owns this struct. Note that sub field +* Buffer_type shall be set to receive_reo_queue_descriptor. +* +* receive_queue_number +* Indicates the MPDU queue ID to which this MPDU link descriptor belongs. +* +* vld +* Valid bit indicating a session is established and the queue descriptor +* is valid. +* associated_link_descriptor_counter +* Indicates which of the 3 link descriptor counters shall be incremented +* or decremented when link descriptors are added or removed from this +* flow queue. +* disable_duplicate_detection +* When set, do not perform any duplicate detection. +* soft_reorder_enable +* When set, REO has been instructed to not perform the actual re-ordering +* of frames for this queue, but just to insert the reorder opcodes. +* ac +* Indicates the access category of the queue descriptor. +* bar +* Indicates if BAR has been received. +* retry +* Retry bit is checked if this bit is set. +* chk_2k_mode +* Indicates what type of operation is expected from Reo when the received +* frame SN falls within the 2K window. +* oor_mode +* Indicates what type of operation is expected when the received frame +* falls within the OOR window. +* ba_window_size +* Indicates the negotiated (window size + 1). Max of 256 bits. +* +* A value 255 means 256 bitmap, 63 means 64 bitmap, 0 (means non-BA +* session, with window size of 0). The 3 values here are the main values +* validated, but other values should work as well. +* +* A BA window size of 0 (=> one frame entry bitmat), means that there is +* no additional rx_reo_queue_ext desc. following rx_reo_queue in memory. +* A BA window size of 1 - 105, means that there is 1 rx_reo_queue_ext. +* A BA window size of 106 - 210, means that there are 2 rx_reo_queue_ext. +* A BA window size of 211 - 256, means that there are 3 rx_reo_queue_ext. +* pn_check_needed, pn_shall_be_even, pn_shall_be_uneven, pn_handling_enable, +* pn_size +* REO shall perform the PN increment check, even number check, uneven +* number check, PN error check and size of the PN field check. +* ignore_ampdu_flag +* REO shall ignore the ampdu_flag on entrance descriptor for this queue. +* +* svld +* Sequence number in next field is valid one. +* ssn +* Starting Sequence number of the session. +* current_index +* Points to last forwarded packet +* seq_2k_error_detected_flag +* REO has detected a 2k error jump in the sequence number and from that +* moment forward, all new frames are forwarded directly to FW, without +* duplicate detect, reordering, etc. +* pn_error_detected_flag +* REO has detected a PN error. +*/ + +#define HAL_REO_UPD_RX_QUEUE_INFO0_QUEUE_ADDR_HI GENMASK(7, 0) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_RX_QUEUE_NUM BIT(8) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_VLD BIT(9) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_ASSOC_LNK_DESC_CNT BIT(10) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_DIS_DUP_DETECTION BIT(11) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_SOFT_REORDER_EN BIT(12) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_AC BIT(13) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_BAR BIT(14) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_RETRY BIT(15) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_CHECK_2K_MODE BIT(16) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_OOR_MODE BIT(17) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_BA_WINDOW_SIZE BIT(18) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN_CHECK BIT(19) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_EVEN_PN BIT(20) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_UNEVEN_PN BIT(21) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN_HANDLE_ENABLE BIT(22) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN_SIZE BIT(23) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_IGNORE_AMPDU_FLG BIT(24) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_SVLD BIT(25) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_SSN BIT(26) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_SEQ_2K_ERR BIT(27) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN_ERR BIT(28) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN_VALID BIT(29) +#define HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN BIT(30) + +#define HAL_REO_UPD_RX_QUEUE_INFO1_RX_QUEUE_NUMBER GENMASK(15, 0) +#define HAL_REO_UPD_RX_QUEUE_INFO1_VLD BIT(16) +#define HAL_REO_UPD_RX_QUEUE_INFO1_ASSOC_LNK_DESC_COUNTER GENMASK(18, 17) +#define HAL_REO_UPD_RX_QUEUE_INFO1_DIS_DUP_DETECTION BIT(19) +#define HAL_REO_UPD_RX_QUEUE_INFO1_SOFT_REORDER_EN BIT(20) +#define HAL_REO_UPD_RX_QUEUE_INFO1_AC GENMASK(22, 21) +#define HAL_REO_UPD_RX_QUEUE_INFO1_BAR BIT(23) +#define HAL_REO_UPD_RX_QUEUE_INFO1_RETRY BIT(24) +#define HAL_REO_UPD_RX_QUEUE_INFO1_CHECK_2K_MODE BIT(25) +#define HAL_REO_UPD_RX_QUEUE_INFO1_OOR_MODE BIT(26) +#define HAL_REO_UPD_RX_QUEUE_INFO1_PN_CHECK BIT(27) +#define HAL_REO_UPD_RX_QUEUE_INFO1_EVEN_PN BIT(28) +#define HAL_REO_UPD_RX_QUEUE_INFO1_UNEVEN_PN BIT(29) +#define HAL_REO_UPD_RX_QUEUE_INFO1_PN_HANDLE_ENABLE BIT(30) +#define HAL_REO_UPD_RX_QUEUE_INFO1_IGNORE_AMPDU_FLG BIT(31) + +#define HAL_REO_UPD_RX_QUEUE_INFO2_BA_WINDOW_SIZE GENMASK(7, 0) +#define HAL_REO_UPD_RX_QUEUE_INFO2_PN_SIZE GENMASK(9, 8) +#define HAL_REO_UPD_RX_QUEUE_INFO2_SVLD BIT(10) +#define HAL_REO_UPD_RX_QUEUE_INFO2_SSN GENMASK(22, 11) +#define HAL_REO_UPD_RX_QUEUE_INFO2_SEQ_2K_ERR BIT(23) +#define HAL_REO_UPD_RX_QUEUE_INFO2_PN_ERR BIT(24) +#define HAL_REO_UPD_RX_QUEUE_INFO2_PN_VALID BIT(25) + +struct hal_reo_update_rx_queue { +struct hal_reo_cmd_hdr cmd; +__le32 queue_addr_lo; +__le32 info0; +__le32 info1; +__le32 info2; +__le32 pn[4 ]; +} __packed; + +#define HAL_REO_UNBLOCK_CACHE_INFO0_UNBLK_CACHE BIT(0) +#define HAL_REO_UNBLOCK_CACHE_INFO0_RESOURCE_IDX GENMASK(2, 1) + +struct hal_reo_unblock_cache { +struct hal_reo_cmd_hdr cmd; +__le32 info0; +__le32 rsvd[7 ]; +} __packed; + +enum hal_reo_exec_status { +HAL_REO_EXEC_STATUS_SUCCESS , +HAL_REO_EXEC_STATUS_BLOCKED , +HAL_REO_EXEC_STATUS_FAILED , +HAL_REO_EXEC_STATUS_RESOURCE_BLOCKED , +}; + +#define HAL_REO_STATUS_HDR_INFO0_STATUS_NUM GENMASK(15, 0) +#define HAL_REO_STATUS_HDR_INFO0_EXEC_TIME GENMASK(25, 16) +#define HAL_REO_STATUS_HDR_INFO0_EXEC_STATUS GENMASK(27, 26) + +struct hal_reo_status_hdr { +__le32 info0; +__le32 timestamp; +} __packed; + +/* hal_reo_status_hdr +* Producer: REO +* Consumer: SW +* +* status_num +* The value in this field is equal to value of the reo command +* number. This field helps to correlate the statuses with the REO +* commands. +* +* execution_time (in us) +* The amount of time REO took to excecute the command. Note that +* this time does not include the duration of the command waiting +* in the command ring, before the execution started. +* +* execution_status +* Execution status of the command. Values are defined in +* enum %HAL_REO_EXEC_STATUS_. +*/ +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO0_SSN GENMASK(11, 0) +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO0_CUR_IDX GENMASK(21, 12) + +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO1_MPDU_COUNT GENMASK(6, 0) +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO1_MSDU_COUNT GENMASK(31, 7) + +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO2_WINDOW_JMP2K GENMASK(3, 0) +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO2_TIMEOUT_COUNT GENMASK(9, 4) +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO2_FDTB_COUNT GENMASK(15, 10) +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO2_DUPLICATE_COUNT GENMASK(31, 16) + +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO3_FIO_COUNT GENMASK(23, 0) +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO3_BAR_RCVD_CNT GENMASK(31, 24) + +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO4_LATE_RX_MPDU GENMASK(11, 0) +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO4_HOLE_COUNT GENMASK(27, 12) + +#define HAL_REO_GET_QUEUE_STATS_STATUS_INFO5_LOOPING_CNT GENMASK(31, 28) + +struct hal_reo_get_queue_stats_status { +struct hal_reo_status_hdr hdr; +__le32 info0; +__le32 pn[4 ]; +__le32 last_rx_enqueue_timestamp; +__le32 last_rx_dequeue_timestamp; +__le32 rx_bitmap[9 ]; +__le32 info1; +__le32 info2; +__le32 info3; +__le32 num_mpdu_frames; +__le32 num_msdu_frames; +__le32 total_bytes; +__le32 info4; +__le32 info5; +} __packed; + +/* hal_reo_get_queue_stats_status +* Producer: REO +* Consumer: SW +* +* status_hdr +* Details that can link this status with the original command. It +* also contains info on how long REO took to execute this command. +* +* ssn +* Starting Sequence number of the session, this changes whenever +* window moves (can be filled by SW then maintained by REO). +* +* current_index +* Points to last forwarded packet. +* +* pn +* Bits of the PN number. +* +* last_rx_enqueue_timestamp +* last_rx_dequeue_timestamp +* Timestamp of arrival of the last MPDU for this queue and +* Timestamp of forwarding an MPDU accordingly. +* +* rx_bitmap +* When a bit is set, the corresponding frame is currently held +* in the re-order queue. The bitmap is Fully managed by HW. +* +* current_mpdu_count +* current_msdu_count +* The number of MPDUs and MSDUs in the queue. +* +* timeout_count +* The number of times REO started forwarding frames even though +* there is a hole in the bitmap. Forwarding reason is timeout. +* +* forward_due_to_bar_count +* The number of times REO started forwarding frames even though +* there is a hole in the bitmap. Fwd reason is reception of BAR. +* +* duplicate_count +* The number of duplicate frames that have been detected. +* +* frames_in_order_count +* The number of frames that have been received in order (without +* a hole that prevented them from being forwarded immediately). +* +* bar_received_count +* The number of times a BAR frame is received. +* +* mpdu_frames_processed_count +* msdu_frames_processed_count +* The total number of MPDU/MSDU frames that have been processed. +* +* total_bytes +* An approximation of the number of bytes received for this queue. +* +* late_receive_mpdu_count +* The number of MPDUs received after the window had already moved +* on. The 'late' sequence window is defined as +* (Window SSN - 256) - (Window SSN - 1). +* +* window_jump_2k +* The number of times the window moved more than 2K +* +* hole_count +* The number of times a hole was created in the receive bitmap. +* +* looping_count +* A count value that indicates the number of times the producer of +* entries into this Ring has looped around the ring. +*/ + +#define HAL_REO_STATUS_LOOP_CNT GENMASK(31, 28) + +#define HAL_REO_FLUSH_QUEUE_INFO0_ERR_DETECTED BIT(0) +#define HAL_REO_FLUSH_QUEUE_INFO0_RSVD GENMASK(31, 1) +#define HAL_REO_FLUSH_QUEUE_INFO1_RSVD GENMASK(27, 0) + +struct hal_reo_flush_queue_status { +struct hal_reo_status_hdr hdr; +__le32 info0; +__le32 rsvd0[21 ]; +__le32 info1; +} __packed; + +/* hal_reo_flush_queue_status +* Producer: REO +* Consumer: SW +* +* status_hdr +* Details that can link this status with the original command. It +* also contains info on how long REO took to execute this command. +* +* error_detected +* Status of blocking resource +* +* 0 - No error has been detected while executing this command +* 1 - Error detected. The resource to be used for blocking was +* already in use. +* +* looping_count +* A count value that indicates the number of times the producer of +* entries into this Ring has looped around the ring. +*/ + +#define HAL_REO_FLUSH_CACHE_STATUS_INFO0_IS_ERR BIT(0) +#define HAL_REO_FLUSH_CACHE_STATUS_INFO0_BLOCK_ERR_CODE GENMASK(2, 1) +#define HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_STATUS_HIT BIT(8) +#define HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_DESC_TYPE GENMASK(11, 9) +#define HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_CLIENT_ID GENMASK(15, 12) +#define HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_ERR GENMASK(17, 16) +#define HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_COUNT GENMASK(25, 18) + +struct hal_reo_flush_cache_status { +struct hal_reo_status_hdr hdr; +__le32 info0; +__le32 rsvd0[21 ]; +__le32 info1; +} __packed; + +/* hal_reo_flush_cache_status +* Producer: REO +* Consumer: SW +* +* status_hdr +* Details that can link this status with the original command. It +* also contains info on how long REO took to execute this command. +* +* error_detected +* Status for blocking resource handling +* +* 0 - No error has been detected while executing this command +* 1 - An error in the blocking resource management was detected +* +* block_error_details +* only valid when error_detected is set +* +* 0 - No blocking related errors found +* 1 - Blocking resource is already in use +* 2 - Resource requested to be unblocked, was not blocked +* +* cache_controller_flush_status_hit +* The status that the cache controller returned on executing the +* flush command. +* +* 0 - miss; 1 - hit +* +* cache_controller_flush_status_desc_type +* Flush descriptor type +* +* cache_controller_flush_status_client_id +* Module who made the flush request +* +* In REO, this is always 0 +* +* cache_controller_flush_status_error +* Error condition +* +* 0 - No error found +* 1 - HW interface is still busy +* 2 - Line currently locked. Used for one line flush command +* 3 - At least one line is still locked. +* Used for cache flush command. +* +* cache_controller_flush_count +* The number of lines that were actually flushed out +* +* looping_count +* A count value that indicates the number of times the producer of +* entries into this Ring has looped around the ring. +*/ + +#define HAL_REO_UNBLOCK_CACHE_STATUS_INFO0_IS_ERR BIT(0) +#define HAL_REO_UNBLOCK_CACHE_STATUS_INFO0_TYPE BIT(1) + +struct hal_reo_unblock_cache_status { +struct hal_reo_status_hdr hdr; +__le32 info0; +__le32 rsvd0[21 ]; +__le32 info1; +} __packed; + +/* hal_reo_unblock_cache_status +* Producer: REO +* Consumer: SW +* +* status_hdr +* Details that can link this status with the original command. It +* also contains info on how long REO took to execute this command. +* +* error_detected +* 0 - No error has been detected while executing this command +* 1 - The blocking resource was not in use, and therefore it could +* not be unblocked. +* +* unblock_type +* Reference to the type of unblock command +* 0 - Unblock a blocking resource +* 1 - The entire cache usage is unblock +* +* looping_count +* A count value that indicates the number of times the producer of +* entries into this Ring has looped around the ring. +*/ + +#define HAL_REO_FLUSH_TIMEOUT_STATUS_INFO0_IS_ERR BIT(0) +#define HAL_REO_FLUSH_TIMEOUT_STATUS_INFO0_LIST_EMPTY BIT(1) + +#define HAL_REO_FLUSH_TIMEOUT_STATUS_INFO1_REL_DESC_COUNT GENMASK(15, 0) +#define HAL_REO_FLUSH_TIMEOUT_STATUS_INFO1_FWD_BUF_COUNT GENMASK(31, 16) + +struct hal_reo_flush_timeout_list_status { +struct hal_reo_status_hdr hdr; +__le32 info0; +__le32 info1; +__le32 rsvd0[20 ]; +__le32 info2; +} __packed; + +/* hal_reo_flush_timeout_list_status +* Producer: REO +* Consumer: SW +* +* status_hdr +* Details that can link this status with the original command. It +* also contains info on how long REO took to execute this command. +* +* error_detected +* 0 - No error has been detected while executing this command +* 1 - Command not properly executed and returned with error +* +* timeout_list_empty +* When set, REO has depleted the timeout list and all entries are +* gone. +* +* release_desc_count +* Producer: SW; Consumer: REO +* The number of link descriptor released +* +* forward_buf_count +* Producer: SW; Consumer: REO +* The number of buffers forwarded to the REO destination rings +* +* looping_count +* A count value that indicates the number of times the producer of +* entries into this Ring has looped around the ring. +*/ + +#define HAL_REO_DESC_THRESH_STATUS_INFO0_THRESH_INDEX GENMASK(1, 0) +#define HAL_REO_DESC_THRESH_STATUS_INFO1_LINK_DESC_COUNTER0 GENMASK(23, 0) +#define HAL_REO_DESC_THRESH_STATUS_INFO2_LINK_DESC_COUNTER1 GENMASK(23, 0) +#define HAL_REO_DESC_THRESH_STATUS_INFO3_LINK_DESC_COUNTER2 GENMASK(23, 0) +#define HAL_REO_DESC_THRESH_STATUS_INFO4_LINK_DESC_COUNTER_SUM GENMASK(25, 0) + +struct hal_reo_desc_thresh_reached_status { +struct hal_reo_status_hdr hdr; +__le32 info0; +__le32 info1; +__le32 info2; +__le32 info3; +__le32 info4; +__le32 rsvd0[17 ]; +__le32 info5; +} __packed; + +/* hal_reo_desc_thresh_reached_status +* Producer: REO +* Consumer: SW +* +* status_hdr +* Details that can link this status with the original command. It +* also contains info on how long REO took to execute this command. +* +* threshold_index +* The index of the threshold register whose value got reached +* +* link_descriptor_counter0 +* link_descriptor_counter1 +* link_descriptor_counter2 +* link_descriptor_counter_sum +* Value of the respective counters at generation of this message +* +* looping_count +* A count value that indicates the number of times the producer of +* entries into this Ring has looped around the ring. +*/ + +#define HAL_TCL_ENTRANCE_FROM_PPE_RING_INFO0_DATA_LENGTH GENMASK(13, 0) +#define HAL_TCL_ENTRANCE_FROM_PPE_RING_INFO0_L4_CSUM_STATUS BIT(14) +#define HAL_TCL_ENTRANCE_FROM_PPE_RING_INFO0_L3_CSUM_STATUS BIT(15) +#define HAL_TCL_ENTRANCE_FROM_PPE_RING_INFO0_PID GENMASK(27, 24) +#define HAL_TCL_ENTRANCE_FROM_PPE_RING_INFO0_QDISC BIT(28) +#define HAL_TCL_ENTRANCE_FROM_PPE_RING_INFO0_MULTICAST BIT(29) +#define HAL_TCL_ENTRANCE_FROM_PPE_RING_INFO0_MORE BIT(30) +#define HAL_TCL_ENTRANCE_FROM_PPE_RING_INFO0_VALID_TOGGLE BIT(31) + +struct hal_tcl_entrance_from_ppe_ring { +__le32 buffer_addr; +__le32 info0; +} __packed; + +struct hal_mon_buf_ring { +__le32 paddr_lo; +__le32 paddr_hi; +__le64 cookie; +}; + +/* hal_mon_buf_ring +* Producer : SW +* Consumer : Monitor +* +* paddr_lo +* Lower 32-bit physical address of the buffer pointer from the source ring. +* paddr_hi +* bit range 7-0 : upper 8 bit of the physical address. +* bit range 31-8 : reserved. +* cookie +* Consumer: RxMon/TxMon 64 bit cookie of the buffers. +*/ + +#define HAL_MON_DEST_COOKIE_BUF_ID GENMASK(17, 0) + +#define HAL_MON_DEST_INFO0_END_OFFSET GENMASK(15, 0) +#define HAL_MON_DEST_INFO0_FLUSH_DETECTED BIT(16) +#define HAL_MON_DEST_INFO0_END_OF_PPDU BIT(17) +#define HAL_MON_DEST_INFO0_INITIATOR BIT(18) +#define HAL_MON_DEST_INFO0_EMPTY_DESC BIT(19) +#define HAL_MON_DEST_INFO0_RING_ID GENMASK(27, 20) +#define HAL_MON_DEST_INFO0_LOOPING_COUNT GENMASK(31, 28) + +struct hal_mon_dest_desc { +__le32 cookie; +__le32 reserved; +__le32 ppdu_id; +__le32 info0; +}; + +/* hal_mon_dest_ring +* Producer : TxMon/RxMon +* Consumer : SW +* cookie +* bit 0 -17 buf_id to track the skb's vaddr. +* ppdu_id +* Phy ppdu_id +* end_offset +* The offset into status buffer where DMA ended, ie., offset to the last +* TLV + last TLV size. +* flush_detected +* Indicates whether 'tx_flush' or 'rx_flush' occurred. +* end_of_ppdu +* Indicates end of ppdu. +* pmac_id +* Indicates PMAC that received from frame. +* empty_descriptor +* This descriptor is written on flush or end of ppdu or end of status +* buffer. +* ring_id +* updated by SRNG. +* looping_count +* updated by SRNG. +*/ + +#endif /* ATH12K_HAL_DESC_H */
PATCH v2 22/50 wifi: ath12k: add hal_rx.c
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hal_rx.c | 853 +++++++++++++++++++++++++++++++ 1 file changed, 853 insertions(+)
drivers/net/wireless/ath/ath12k/hal_rx.c new file +853 -0
@@ -0,0 +1,853 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#include "debug.h" +#include "hal.h" +#include "hal_tx.h" +#include "hal_rx.h" +#include "hal_desc.h" +#include "hif.h" + +static void ath12k_hal_reo_set_desc_hdr (struct hal_desc_header *hdr, +u8 owner,u8 buffer_type,u32 magic) +{ + hdr->info0 =le32_encode_bits (owner,HAL_DESC_HDR_INFO0_OWNER ) | +le32_encode_bits (buffer_type,HAL_DESC_HDR_INFO0_BUF_TYPE ); + +/* Magic pattern in reserved bits for debugging */ + hdr->info0 |=le32_encode_bits (magic,HAL_DESC_HDR_INFO0_DBG_RESERVED ); +} + +static int ath12k_hal_reo_cmd_queue_stats (struct hal_tlv_64_hdr *tlv, +struct ath12k_hal_reo_cmd *cmd) +{ +struct hal_reo_get_queue_stats *desc; + + tlv->tl =u32_encode_bits (HAL_REO_GET_QUEUE_STATS ,HAL_TLV_HDR_TAG ) | +u32_encode_bits (sizeof (*desc),HAL_TLV_HDR_LEN ); + + desc = (struct hal_reo_get_queue_stats *)tlv->value; +memset (&desc->queue_addr_lo,0 , + (sizeof (*desc) -sizeof (struct hal_reo_cmd_hdr ))); + + desc->cmd.info0 &= ~cpu_to_le32 (HAL_REO_CMD_HDR_INFO0_STATUS_REQUIRED ); +if (cmd->flag &HAL_REO_CMD_FLG_NEED_STATUS ) + desc->cmd.info0 |=cpu_to_le32 (HAL_REO_CMD_HDR_INFO0_STATUS_REQUIRED ); + + desc->queue_addr_lo =cpu_to_le32 (cmd->addr_lo); + desc->info0 =le32_encode_bits (cmd->addr_hi, +HAL_REO_GET_QUEUE_STATS_INFO0_QUEUE_ADDR_HI ); +if (cmd->flag &HAL_REO_CMD_FLG_STATS_CLEAR ) + desc->info0 |=cpu_to_le32 (HAL_REO_GET_QUEUE_STATS_INFO0_CLEAR_STATS ); + +return le32_get_bits (desc->cmd.info0,HAL_REO_CMD_HDR_INFO0_CMD_NUMBER ); +} + +static int ath12k_hal_reo_cmd_flush_cache (struct ath12k_hal *hal, +struct hal_tlv_64_hdr *tlv, +struct ath12k_hal_reo_cmd *cmd) +{ +struct hal_reo_flush_cache *desc; +u8 avail_slot =ffz (hal->avail_blk_resource); + +if (cmd->flag &HAL_REO_CMD_FLG_FLUSH_BLOCK_LATER ) { +if (avail_slot >=HAL_MAX_AVAIL_BLK_RES ) +return -ENOSPC ; + + hal->current_blk_index = avail_slot; + } + + tlv->tl =u32_encode_bits (HAL_REO_FLUSH_CACHE ,HAL_TLV_HDR_TAG ) | +u32_encode_bits (sizeof (*desc),HAL_TLV_HDR_LEN ); + + desc = (struct hal_reo_flush_cache *)tlv->value; +memset (&desc->cache_addr_lo,0 , + (sizeof (*desc) -sizeof (struct hal_reo_cmd_hdr ))); + + desc->cmd.info0 &= ~cpu_to_le32 (HAL_REO_CMD_HDR_INFO0_STATUS_REQUIRED ); +if (cmd->flag &HAL_REO_CMD_FLG_NEED_STATUS ) + desc->cmd.info0 |=cpu_to_le32 (HAL_REO_CMD_HDR_INFO0_STATUS_REQUIRED ); + + desc->cache_addr_lo =cpu_to_le32 (cmd->addr_lo); + desc->info0 =le32_encode_bits (cmd->addr_hi, +HAL_REO_FLUSH_CACHE_INFO0_CACHE_ADDR_HI ); + +if (cmd->flag &HAL_REO_CMD_FLG_FLUSH_FWD_ALL_MPDUS ) + desc->info0 |=cpu_to_le32 (HAL_REO_FLUSH_CACHE_INFO0_FWD_ALL_MPDUS ); + +if (cmd->flag &HAL_REO_CMD_FLG_FLUSH_BLOCK_LATER ) { + desc->info0 |=cpu_to_le32 (HAL_REO_FLUSH_CACHE_INFO0_BLOCK_CACHE_USAGE ); + desc->info0 |= +le32_encode_bits (avail_slot, +HAL_REO_FLUSH_CACHE_INFO0_BLOCK_RESRC_IDX ); + } + +if (cmd->flag &HAL_REO_CMD_FLG_FLUSH_NO_INVAL ) + desc->info0 |=cpu_to_le32 (HAL_REO_FLUSH_CACHE_INFO0_FLUSH_WO_INVALIDATE ); + +if (cmd->flag &HAL_REO_CMD_FLG_FLUSH_ALL ) + desc->info0 |=cpu_to_le32 (HAL_REO_FLUSH_CACHE_INFO0_FLUSH_ALL ); + +return le32_get_bits (desc->cmd.info0,HAL_REO_CMD_HDR_INFO0_CMD_NUMBER ); +} + +static int ath12k_hal_reo_cmd_update_rx_queue (struct hal_tlv_64_hdr *tlv, +struct ath12k_hal_reo_cmd *cmd) +{ +struct hal_reo_update_rx_queue *desc; + + tlv->tl =u32_encode_bits (HAL_REO_UPDATE_RX_REO_QUEUE ,HAL_TLV_HDR_TAG ) | +u32_encode_bits (sizeof (*desc),HAL_TLV_HDR_LEN ); + + desc = (struct hal_reo_update_rx_queue *)tlv->value; +memset (&desc->queue_addr_lo,0 , + (sizeof (*desc) -sizeof (struct hal_reo_cmd_hdr ))); + + desc->cmd.info0 &= ~cpu_to_le32 (HAL_REO_CMD_HDR_INFO0_STATUS_REQUIRED ); +if (cmd->flag &HAL_REO_CMD_FLG_NEED_STATUS ) + desc->cmd.info0 |=cpu_to_le32 (HAL_REO_CMD_HDR_INFO0_STATUS_REQUIRED ); + + desc->queue_addr_lo =cpu_to_le32 (cmd->addr_lo); + desc->info0 = +le32_encode_bits (cmd->addr_hi, +HAL_REO_UPD_RX_QUEUE_INFO0_QUEUE_ADDR_HI ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_RX_QUEUE_NUM ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_RX_QUEUE_NUM ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_VLD ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_VLD ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_ALDC ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_ASSOC_LNK_DESC_CNT ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_DIS_DUP_DETECTION ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_DIS_DUP_DETECTION ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_SOFT_REORDER_EN ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_SOFT_REORDER_EN ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_AC ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_AC ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_BAR ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_BAR ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_RETRY ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_RETRY ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_CHECK_2K_MODE ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_CHECK_2K_MODE ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_OOR_MODE ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_OOR_MODE ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_BA_WINDOW_SIZE ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_BA_WINDOW_SIZE ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_PN_CHECK ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN_CHECK ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_EVEN_PN ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_EVEN_PN ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_UNEVEN_PN ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_UNEVEN_PN ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_PN_HANDLE_ENABLE ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN_HANDLE_ENABLE ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_PN_SIZE ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN_SIZE ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_IGNORE_AMPDU_FLG ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_IGNORE_AMPDU_FLG ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_SVLD ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_SVLD ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_SSN ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_SSN ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_SEQ_2K_ERR ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_SEQ_2K_ERR ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_PN_VALID ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN_VALID ) | +le32_encode_bits (!!(cmd->upd0 &HAL_REO_CMD_UPD0_PN ), +HAL_REO_UPD_RX_QUEUE_INFO0_UPD_PN ); + + desc->info1 = +le32_encode_bits (cmd->rx_queue_num, +HAL_REO_UPD_RX_QUEUE_INFO1_RX_QUEUE_NUMBER ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_VLD ), +HAL_REO_UPD_RX_QUEUE_INFO1_VLD ) | +le32_encode_bits (u32_get_bits (cmd->upd1,HAL_REO_CMD_UPD1_ALDC ), +HAL_REO_UPD_RX_QUEUE_INFO1_ASSOC_LNK_DESC_COUNTER ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_DIS_DUP_DETECTION ), +HAL_REO_UPD_RX_QUEUE_INFO1_DIS_DUP_DETECTION ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_SOFT_REORDER_EN ), +HAL_REO_UPD_RX_QUEUE_INFO1_SOFT_REORDER_EN ) | +le32_encode_bits (u32_get_bits (cmd->upd1,HAL_REO_CMD_UPD1_AC ), +HAL_REO_UPD_RX_QUEUE_INFO1_AC ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_BAR ), +HAL_REO_UPD_RX_QUEUE_INFO1_BAR ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_CHECK_2K_MODE ), +HAL_REO_UPD_RX_QUEUE_INFO1_CHECK_2K_MODE ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_RETRY ), +HAL_REO_UPD_RX_QUEUE_INFO1_RETRY ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_OOR_MODE ), +HAL_REO_UPD_RX_QUEUE_INFO1_OOR_MODE ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_PN_CHECK ), +HAL_REO_UPD_RX_QUEUE_INFO1_PN_CHECK ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_EVEN_PN ), +HAL_REO_UPD_RX_QUEUE_INFO1_EVEN_PN ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_UNEVEN_PN ), +HAL_REO_UPD_RX_QUEUE_INFO1_UNEVEN_PN ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_PN_HANDLE_ENABLE ), +HAL_REO_UPD_RX_QUEUE_INFO1_PN_HANDLE_ENABLE ) | +le32_encode_bits (!!(cmd->upd1 &HAL_REO_CMD_UPD1_IGNORE_AMPDU_FLG ), +HAL_REO_UPD_RX_QUEUE_INFO1_IGNORE_AMPDU_FLG ); + +if (cmd->pn_size ==24 ) + cmd->pn_size =HAL_RX_REO_QUEUE_PN_SIZE_24 ; +else if (cmd->pn_size ==48 ) + cmd->pn_size =HAL_RX_REO_QUEUE_PN_SIZE_48 ; +else if (cmd->pn_size ==128 ) + cmd->pn_size =HAL_RX_REO_QUEUE_PN_SIZE_128 ; + +if (cmd->ba_window_size <1 ) + cmd->ba_window_size =1 ; + +if (cmd->ba_window_size ==1 ) + cmd->ba_window_size++; + + desc->info2 = +le32_encode_bits (cmd->ba_window_size -1 , +HAL_REO_UPD_RX_QUEUE_INFO2_BA_WINDOW_SIZE ) | +le32_encode_bits (cmd->pn_size,HAL_REO_UPD_RX_QUEUE_INFO2_PN_SIZE ) | +le32_encode_bits (!!(cmd->upd2 &HAL_REO_CMD_UPD2_SVLD ), +HAL_REO_UPD_RX_QUEUE_INFO2_SVLD ) | +le32_encode_bits (u32_get_bits (cmd->upd2,HAL_REO_CMD_UPD2_SSN ), +HAL_REO_UPD_RX_QUEUE_INFO2_SSN ) | +le32_encode_bits (!!(cmd->upd2 &HAL_REO_CMD_UPD2_SEQ_2K_ERR ), +HAL_REO_UPD_RX_QUEUE_INFO2_SEQ_2K_ERR ) | +le32_encode_bits (!!(cmd->upd2 &HAL_REO_CMD_UPD2_PN_ERR ), +HAL_REO_UPD_RX_QUEUE_INFO2_PN_ERR ); + +return le32_get_bits (desc->cmd.info0,HAL_REO_CMD_HDR_INFO0_CMD_NUMBER ); +} + +int ath12k_hal_reo_cmd_send (struct ath12k_base *ab,struct hal_srng *srng, +enum hal_reo_cmd_type type, +struct ath12k_hal_reo_cmd *cmd) +{ +struct hal_tlv_64_hdr *reo_desc; +int ret; + +spin_lock_bh (&srng->lock); + +ath12k_hal_srng_access_begin (ab, srng); + reo_desc =ath12k_hal_srng_src_get_next_entry (ab, srng); +if (!reo_desc) { + ret = -ENOBUFS ; + goto out; + } + +switch (type) { +case HAL_REO_CMD_GET_QUEUE_STATS : + ret =ath12k_hal_reo_cmd_queue_stats (reo_desc, cmd); +break ; +case HAL_REO_CMD_FLUSH_CACHE : + ret =ath12k_hal_reo_cmd_flush_cache (&ab->hal, reo_desc, cmd); +break ; +case HAL_REO_CMD_UPDATE_RX_QUEUE : + ret =ath12k_hal_reo_cmd_update_rx_queue (reo_desc, cmd); +break ; +case HAL_REO_CMD_FLUSH_QUEUE : +case HAL_REO_CMD_UNBLOCK_CACHE : +case HAL_REO_CMD_FLUSH_TIMEOUT_LIST : +ath12k_warn (ab,"Unsupported reo command %d\n" , type); + ret = -ENOTSUPP ; +break ; +default : +ath12k_warn (ab,"Unknown reo command %d\n" , type); + ret = -EINVAL ; +break ; + } + +out: +ath12k_hal_srng_access_end (ab, srng); +spin_unlock_bh (&srng->lock); + +return ret; +} + +void ath12k_hal_rx_buf_addr_info_set (struct ath12k_buffer_addr *binfo, +dma_addr_t paddr,u32 cookie,u8 manager) +{ +u32 paddr_lo, paddr_hi; + + paddr_lo =lower_32_bits (paddr); + paddr_hi =upper_32_bits (paddr); + binfo->info0 =le32_encode_bits (paddr_lo,BUFFER_ADDR_INFO0_ADDR ); + binfo->info1 =le32_encode_bits (paddr_hi,BUFFER_ADDR_INFO1_ADDR ) | +le32_encode_bits (cookie,BUFFER_ADDR_INFO1_SW_COOKIE ) | +le32_encode_bits (manager,BUFFER_ADDR_INFO1_RET_BUF_MGR ); +} + +void ath12k_hal_rx_buf_addr_info_get (struct ath12k_buffer_addr *binfo, +dma_addr_t *paddr, +u32 *cookie,u8 *rbm) +{ + *paddr = (((u64 )le32_get_bits (binfo->info1,BUFFER_ADDR_INFO1_ADDR )) <<32 ) | +le32_get_bits (binfo->info0,BUFFER_ADDR_INFO0_ADDR ); + *cookie =le32_get_bits (binfo->info1,BUFFER_ADDR_INFO1_SW_COOKIE ); + *rbm =le32_get_bits (binfo->info1,BUFFER_ADDR_INFO1_RET_BUF_MGR ); +} + +void ath12k_hal_rx_msdu_link_info_get (struct hal_rx_msdu_link *link,u32 *num_msdus, +u32 *msdu_cookies, +enum hal_rx_buf_return_buf_manager *rbm) +{ +struct hal_rx_msdu_details *msdu; +u32 val; +int i; + + *num_msdus =HAL_NUM_RX_MSDUS_PER_LINK_DESC ; + + msdu = &link->msdu_link[0 ]; + *rbm =le32_get_bits (msdu->buf_addr_info.info1, +BUFFER_ADDR_INFO1_RET_BUF_MGR ); + +for (i =0 ; i < *num_msdus; i++) { + msdu = &link->msdu_link[i]; + + val =le32_get_bits (msdu->buf_addr_info.info0, +BUFFER_ADDR_INFO0_ADDR ); +if (val ==0 ) { + *num_msdus = i; +break ; + } + *msdu_cookies =le32_get_bits (msdu->buf_addr_info.info1, +BUFFER_ADDR_INFO1_SW_COOKIE ); + msdu_cookies++; + } +} + +int ath12k_hal_desc_reo_parse_err (struct ath12k_base *ab, +struct hal_reo_dest_ring *desc, +dma_addr_t *paddr,u32 *desc_bank) +{ +enum hal_reo_dest_ring_push_reason push_reason; +enum hal_reo_dest_ring_error_code err_code; +u32 cookie, val; + + push_reason =le32_get_bits (desc->info0, +HAL_REO_DEST_RING_INFO0_PUSH_REASON ); + err_code =le32_get_bits (desc->info0, +HAL_REO_DEST_RING_INFO0_ERROR_CODE ); + ab->soc_stats.reo_error[err_code]++; + +if (push_reason !=HAL_REO_DEST_RING_PUSH_REASON_ERR_DETECTED && + push_reason !=HAL_REO_DEST_RING_PUSH_REASON_ROUTING_INSTRUCTION ) { +ath12k_warn (ab,"expected error push reason code, received %d\n" , + push_reason); +return -EINVAL ; + } + + val =le32_get_bits (desc->info0,HAL_REO_DEST_RING_INFO0_BUFFER_TYPE ); +if (val !=HAL_REO_DEST_RING_BUFFER_TYPE_LINK_DESC ) { +ath12k_warn (ab,"expected buffer type link_desc" ); +return -EINVAL ; + } + +ath12k_hal_rx_reo_ent_paddr_get (ab, &desc->buf_addr_info, paddr, &cookie); + *desc_bank =u32_get_bits (cookie,DP_LINK_DESC_BANK_MASK ); + +return 0 ; +} + +int ath12k_hal_wbm_desc_parse_err (struct ath12k_base *ab,void *desc, +struct hal_rx_wbm_rel_info *rel_info) +{ +struct hal_wbm_release_ring *wbm_desc = desc; +struct hal_wbm_release_ring_cc_rx *wbm_cc_desc = desc; +enum hal_wbm_rel_desc_type type; +enum hal_wbm_rel_src_module rel_src; +bool hw_cc_done; +u64 desc_va; +u32 val; + + type =le32_get_bits (wbm_desc->info0,HAL_WBM_RELEASE_INFO0_DESC_TYPE ); +/* We expect only WBM_REL buffer type */ +if (type !=HAL_WBM_REL_DESC_TYPE_REL_MSDU ) { +WARN_ON (1 ); +return -EINVAL ; + } + + rel_src =le32_get_bits (wbm_desc->info0, +HAL_WBM_RELEASE_INFO0_REL_SRC_MODULE ); +if (rel_src !=HAL_WBM_REL_SRC_MODULE_RXDMA && + rel_src !=HAL_WBM_REL_SRC_MODULE_REO ) +return -EINVAL ; + +/* The format of wbm rel ring desc changes based on the +* hw cookie conversion status +*/ + hw_cc_done =le32_get_bits (wbm_desc->info0, +HAL_WBM_RELEASE_RX_INFO0_CC_STATUS ); + +if (!hw_cc_done) { + val =le32_get_bits (wbm_desc->buf_addr_info.info1, +BUFFER_ADDR_INFO1_RET_BUF_MGR ); +if (val !=HAL_RX_BUF_RBM_SW3_BM ) { + ab->soc_stats.invalid_rbm++; +return -EINVAL ; + } + + rel_info->cookie =le32_get_bits (wbm_desc->buf_addr_info.info1, +BUFFER_ADDR_INFO1_SW_COOKIE ); + + rel_info->rx_desc =NULL ; + }else { + val =le32_get_bits (wbm_cc_desc->info0, +HAL_WBM_RELEASE_RX_CC_INFO0_RBM ); +if (val !=HAL_RX_BUF_RBM_SW3_BM ) { + ab->soc_stats.invalid_rbm++; +return -EINVAL ; + } + + rel_info->cookie =le32_get_bits (wbm_cc_desc->info1, +HAL_WBM_RELEASE_RX_CC_INFO1_COOKIE ); + + desc_va = ((u64 )le32_to_cpu (wbm_cc_desc->buf_va_hi) <<32 | +le32_to_cpu (wbm_cc_desc->buf_va_lo)); + rel_info->rx_desc = + (struct ath12k_rx_desc_info *)((unsigned long )desc_va); + } + + rel_info->err_rel_src = rel_src; + rel_info->hw_cc_done = hw_cc_done; + + rel_info->first_msdu =le32_get_bits (wbm_desc->info3, +HAL_WBM_RELEASE_INFO3_FIRST_MSDU ); + rel_info->last_msdu =le32_get_bits (wbm_desc->info3, +HAL_WBM_RELEASE_INFO3_LAST_MSDU ); + rel_info->continuation =le32_get_bits (wbm_desc->info3, +HAL_WBM_RELEASE_INFO3_CONTINUATION ); + +if (rel_info->err_rel_src ==HAL_WBM_REL_SRC_MODULE_REO ) { + rel_info->push_reason = +le32_get_bits (wbm_desc->info0, +HAL_WBM_RELEASE_INFO0_REO_PUSH_REASON ); + rel_info->err_code = +le32_get_bits (wbm_desc->info0, +HAL_WBM_RELEASE_INFO0_REO_ERROR_CODE ); + }else { + rel_info->push_reason = +le32_get_bits (wbm_desc->info0, +HAL_WBM_RELEASE_INFO0_RXDMA_PUSH_REASON ); + rel_info->err_code = +le32_get_bits (wbm_desc->info0, +HAL_WBM_RELEASE_INFO0_RXDMA_ERROR_CODE ); + } + +return 0 ; +} + +void ath12k_hal_rx_reo_ent_paddr_get (struct ath12k_base *ab, +struct ath12k_buffer_addr *buff_addr, +dma_addr_t *paddr,u32 *cookie) +{ + *paddr = ((u64)(le32_get_bits (buff_addr->info1, +BUFFER_ADDR_INFO1_ADDR )) <<32 ) | +le32_get_bits (buff_addr->info0,BUFFER_ADDR_INFO0_ADDR ); + + *cookie =le32_get_bits (buff_addr->info1,BUFFER_ADDR_INFO1_SW_COOKIE ); +} + +void ath12k_hal_rx_msdu_link_desc_set (struct ath12k_base *ab, +struct hal_wbm_release_ring *dst_desc, +struct hal_wbm_release_ring *src_desc, +enum hal_wbm_rel_bm_act action) +{ + dst_desc->buf_addr_info = src_desc->buf_addr_info; + dst_desc->info0 |=le32_encode_bits (HAL_WBM_REL_SRC_MODULE_SW , +HAL_WBM_RELEASE_INFO0_REL_SRC_MODULE ) | +le32_encode_bits (action,HAL_WBM_RELEASE_INFO0_BM_ACTION ) | +le32_encode_bits (HAL_WBM_REL_DESC_TYPE_MSDU_LINK , +HAL_WBM_RELEASE_INFO0_DESC_TYPE ); +} + +void ath12k_hal_reo_status_queue_stats (struct ath12k_base *ab,struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status) +{ +struct hal_reo_get_queue_stats_status *desc = + (struct hal_reo_get_queue_stats_status *)tlv->value; + + status->uniform_hdr.cmd_num = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_STATUS_NUM ); + status->uniform_hdr.cmd_status = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_EXEC_STATUS ); + +ath12k_dbg (ab,ATH12K_DBG_HAL ,"Queue stats status:\n" ); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"header: cmd_num %d status %d\n" , + status->uniform_hdr.cmd_num, + status->uniform_hdr.cmd_status); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"ssn %u cur_idx %u\n" , +le32_get_bits (desc->info0, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO0_SSN ), +le32_get_bits (desc->info0, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO0_CUR_IDX )); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"pn = [%08x, %08x, %08x, %08x]\n" , + desc->pn[0 ], desc->pn[1 ], desc->pn[2 ], desc->pn[3 ]); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"last_rx: enqueue_tstamp %08x dequeue_tstamp %08x\n" , + desc->last_rx_enqueue_timestamp, + desc->last_rx_dequeue_timestamp); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"rx_bitmap [%08x %08x %08x %08x %08x %08x %08x %08x]\n" , + desc->rx_bitmap[0 ], desc->rx_bitmap[1 ], desc->rx_bitmap[2 ], + desc->rx_bitmap[3 ], desc->rx_bitmap[4 ], desc->rx_bitmap[5 ], + desc->rx_bitmap[6 ], desc->rx_bitmap[7 ]); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"count: cur_mpdu %u cur_msdu %u\n" , +le32_get_bits (desc->info1, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO1_MPDU_COUNT ), +le32_get_bits (desc->info1, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO1_MSDU_COUNT )); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"fwd_timeout %u fwd_bar %u dup_count %u\n" , +le32_get_bits (desc->info2, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO2_TIMEOUT_COUNT ), +le32_get_bits (desc->info2, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO2_FDTB_COUNT ), +le32_get_bits (desc->info2, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO2_DUPLICATE_COUNT )); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"frames_in_order %u bar_rcvd %u\n" , +le32_get_bits (desc->info3, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO3_FIO_COUNT ), +le32_get_bits (desc->info3, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO3_BAR_RCVD_CNT )); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"num_mpdus %d num_msdus %d total_bytes %d\n" , + desc->num_mpdu_frames, desc->num_msdu_frames, + desc->total_bytes); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"late_rcvd %u win_jump_2k %u hole_cnt %u\n" , +le32_get_bits (desc->info4, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO4_LATE_RX_MPDU ), +le32_get_bits (desc->info2, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO2_WINDOW_JMP2K ), +le32_get_bits (desc->info4, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO4_HOLE_COUNT )); +ath12k_dbg (ab,ATH12K_DBG_HAL ,"looping count %u\n" , +le32_get_bits (desc->info5, +HAL_REO_GET_QUEUE_STATS_STATUS_INFO5_LOOPING_CNT )); +} + +void ath12k_hal_reo_flush_queue_status (struct ath12k_base *ab,struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status) +{ +struct hal_reo_flush_queue_status *desc = + (struct hal_reo_flush_queue_status *)tlv->value; + + status->uniform_hdr.cmd_num = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_STATUS_NUM ); + status->uniform_hdr.cmd_status = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_EXEC_STATUS ); + status->u.flush_queue.err_detected = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_QUEUE_INFO0_ERR_DETECTED ); +} + +void ath12k_hal_reo_flush_cache_status (struct ath12k_base *ab,struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status) +{ +struct ath12k_hal *hal = &ab->hal; +struct hal_reo_flush_cache_status *desc = + (struct hal_reo_flush_cache_status *)tlv->value; + + status->uniform_hdr.cmd_num = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_STATUS_NUM ); + status->uniform_hdr.cmd_status = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_EXEC_STATUS ); + + status->u.flush_cache.err_detected = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_CACHE_STATUS_INFO0_IS_ERR ); + status->u.flush_cache.err_code = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_CACHE_STATUS_INFO0_BLOCK_ERR_CODE ); +if (!status->u.flush_cache.err_code) + hal->avail_blk_resource |=BIT (hal->current_blk_index); + + status->u.flush_cache.cache_controller_flush_status_hit = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_STATUS_HIT ); + + status->u.flush_cache.cache_controller_flush_status_desc_type = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_DESC_TYPE ); + status->u.flush_cache.cache_controller_flush_status_client_id = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_CLIENT_ID ); + status->u.flush_cache.cache_controller_flush_status_err = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_ERR ); + status->u.flush_cache.cache_controller_flush_status_cnt = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_CACHE_STATUS_INFO0_FLUSH_COUNT ); +} + +void ath12k_hal_reo_unblk_cache_status (struct ath12k_base *ab,struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status) +{ +struct ath12k_hal *hal = &ab->hal; +struct hal_reo_unblock_cache_status *desc = + (struct hal_reo_unblock_cache_status *)tlv->value; + + status->uniform_hdr.cmd_num = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_STATUS_NUM ); + status->uniform_hdr.cmd_status = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_EXEC_STATUS ); + + status->u.unblock_cache.err_detected = +le32_get_bits (desc->info0, +HAL_REO_UNBLOCK_CACHE_STATUS_INFO0_IS_ERR ); + status->u.unblock_cache.unblock_type = +le32_get_bits (desc->info0, +HAL_REO_UNBLOCK_CACHE_STATUS_INFO0_TYPE ); + +if (!status->u.unblock_cache.err_detected && + status->u.unblock_cache.unblock_type == +HAL_REO_STATUS_UNBLOCK_BLOCKING_RESOURCE ) + hal->avail_blk_resource &= ~BIT (hal->current_blk_index); +} + +void ath12k_hal_reo_flush_timeout_list_status (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status) +{ +struct hal_reo_flush_timeout_list_status *desc = + (struct hal_reo_flush_timeout_list_status *)tlv->value; + + status->uniform_hdr.cmd_num = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_STATUS_NUM ); + status->uniform_hdr.cmd_status = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_EXEC_STATUS ); + + status->u.timeout_list.err_detected = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_TIMEOUT_STATUS_INFO0_IS_ERR ); + status->u.timeout_list.list_empty = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_TIMEOUT_STATUS_INFO0_LIST_EMPTY ); + + status->u.timeout_list.release_desc_cnt = +le32_get_bits (desc->info1, +HAL_REO_FLUSH_TIMEOUT_STATUS_INFO1_REL_DESC_COUNT ); + status->u.timeout_list.fwd_buf_cnt = +le32_get_bits (desc->info0, +HAL_REO_FLUSH_TIMEOUT_STATUS_INFO1_FWD_BUF_COUNT ); +} + +void ath12k_hal_reo_desc_thresh_reached_status (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status) +{ +struct hal_reo_desc_thresh_reached_status *desc = + (struct hal_reo_desc_thresh_reached_status *)tlv->value; + + status->uniform_hdr.cmd_num = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_STATUS_NUM ); + status->uniform_hdr.cmd_status = +le32_get_bits (desc->hdr.info0, +HAL_REO_STATUS_HDR_INFO0_EXEC_STATUS ); + + status->u.desc_thresh_reached.threshold_idx = +le32_get_bits (desc->info0, +HAL_REO_DESC_THRESH_STATUS_INFO0_THRESH_INDEX ); + + status->u.desc_thresh_reached.link_desc_counter0 = +le32_get_bits (desc->info1, +HAL_REO_DESC_THRESH_STATUS_INFO1_LINK_DESC_COUNTER0 ); + + status->u.desc_thresh_reached.link_desc_counter1 = +le32_get_bits (desc->info2, +HAL_REO_DESC_THRESH_STATUS_INFO2_LINK_DESC_COUNTER1 ); + + status->u.desc_thresh_reached.link_desc_counter2 = +le32_get_bits (desc->info3, +HAL_REO_DESC_THRESH_STATUS_INFO3_LINK_DESC_COUNTER2 ); + + status->u.desc_thresh_reached.link_desc_counter_sum = +le32_get_bits (desc->info4, +HAL_REO_DESC_THRESH_STATUS_INFO4_LINK_DESC_COUNTER_SUM ); +} + +void ath12k_hal_reo_update_rx_reo_queue_status (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status) +{ +struct hal_reo_status_hdr *desc = + (struct hal_reo_status_hdr *)tlv->value; + + status->uniform_hdr.cmd_num = +le32_get_bits (desc->info0, +HAL_REO_STATUS_HDR_INFO0_STATUS_NUM ); + status->uniform_hdr.cmd_status = +le32_get_bits (desc->info0, +HAL_REO_STATUS_HDR_INFO0_EXEC_STATUS ); +} + +u32 ath12k_hal_reo_qdesc_size (u32 ba_window_size,u8 tid) +{ +u32 num_ext_desc; + +if (ba_window_size <=1 ) { +if (tid !=HAL_DESC_REO_NON_QOS_TID ) + num_ext_desc =1 ; +else + num_ext_desc =0 ; + }else if (ba_window_size <=105 ) { + num_ext_desc =1 ; + }else if (ba_window_size <=210 ) { + num_ext_desc =2 ; + }else { + num_ext_desc =3 ; + } + +return sizeof (struct hal_rx_reo_queue ) + + (num_ext_desc *sizeof (struct hal_rx_reo_queue_ext )); +} + +void ath12k_hal_reo_qdesc_setup (struct hal_rx_reo_queue *qdesc, +int tid,u32 ba_window_size, +u32 start_seq,enum hal_pn_type type) +{ +struct hal_rx_reo_queue_ext *ext_desc; + +memset (qdesc,0 ,sizeof (*qdesc)); + +ath12k_hal_reo_set_desc_hdr (&qdesc->desc_hdr,HAL_DESC_REO_OWNED , +HAL_DESC_REO_QUEUE_DESC , +REO_QUEUE_DESC_MAGIC_DEBUG_PATTERN_0 ); + + qdesc->rx_queue_num =le32_encode_bits (tid,HAL_RX_REO_QUEUE_RX_QUEUE_NUMBER ); + + qdesc->info0 = +le32_encode_bits (1 ,HAL_RX_REO_QUEUE_INFO0_VLD ) | +le32_encode_bits (1 ,HAL_RX_REO_QUEUE_INFO0_ASSOC_LNK_DESC_COUNTER ) | +le32_encode_bits (ath12k_tid_to_ac (tid),HAL_RX_REO_QUEUE_INFO0_AC ); + +if (ba_window_size <1 ) + ba_window_size =1 ; + +if (ba_window_size ==1 && tid !=HAL_DESC_REO_NON_QOS_TID ) + ba_window_size++; + +if (ba_window_size ==1 ) + qdesc->info0 |=le32_encode_bits (1 ,HAL_RX_REO_QUEUE_INFO0_RETRY ); + + qdesc->info0 |=le32_encode_bits (ba_window_size -1 , +HAL_RX_REO_QUEUE_INFO0_BA_WINDOW_SIZE ); +switch (type) { +case HAL_PN_TYPE_NONE : +case HAL_PN_TYPE_WAPI_EVEN : +case HAL_PN_TYPE_WAPI_UNEVEN : +break ; +case HAL_PN_TYPE_WPA : + qdesc->info0 |= +le32_encode_bits (1 ,HAL_RX_REO_QUEUE_INFO0_PN_CHECK ) | +le32_encode_bits (HAL_RX_REO_QUEUE_PN_SIZE_48 , +HAL_RX_REO_QUEUE_INFO0_PN_SIZE ); +break ; + } + +/* TODO: Set Ignore ampdu flags based on BA window size and/or +* AMPDU capabilities +*/ + qdesc->info0 |=le32_encode_bits (1 ,HAL_RX_REO_QUEUE_INFO0_IGNORE_AMPDU_FLG ); + + qdesc->info1 |=le32_encode_bits (0 ,HAL_RX_REO_QUEUE_INFO1_SVLD ); + +if (start_seq <=0xfff ) + qdesc->info1 =le32_encode_bits (start_seq, +HAL_RX_REO_QUEUE_INFO1_SSN ); + +if (tid ==HAL_DESC_REO_NON_QOS_TID ) +return ; + + ext_desc = qdesc->ext_desc; + +/* TODO: HW queue descriptors are currently allocated for max BA +* window size for all QOS TIDs so that same descriptor can be used +* later when ADDBA request is received. This should be changed to +* allocate HW queue descriptors based on BA window size being +* negotiated (0 for non BA cases), and reallocate when BA window +* size changes and also send WMI message to FW to change the REO +* queue descriptor in Rx peer entry as part of dp_rx_tid_update. +*/ +memset (ext_desc,0 ,3 *sizeof (*ext_desc)); +ath12k_hal_reo_set_desc_hdr (&ext_desc->desc_hdr,HAL_DESC_REO_OWNED , +HAL_DESC_REO_QUEUE_EXT_DESC , +REO_QUEUE_DESC_MAGIC_DEBUG_PATTERN_1 ); + ext_desc++; +ath12k_hal_reo_set_desc_hdr (&ext_desc->desc_hdr,HAL_DESC_REO_OWNED , +HAL_DESC_REO_QUEUE_EXT_DESC , +REO_QUEUE_DESC_MAGIC_DEBUG_PATTERN_2 ); + ext_desc++; +ath12k_hal_reo_set_desc_hdr (&ext_desc->desc_hdr,HAL_DESC_REO_OWNED , +HAL_DESC_REO_QUEUE_EXT_DESC , +REO_QUEUE_DESC_MAGIC_DEBUG_PATTERN_3 ); +} + +void ath12k_hal_reo_init_cmd_ring (struct ath12k_base *ab, +struct hal_srng *srng) +{ +struct hal_srng_params params; +struct hal_tlv_64_hdr *tlv; +struct hal_reo_get_queue_stats *desc; +int i, cmd_num =1 ; +int entry_size; +u8 *entry; + +memset (¶ms,0 ,sizeof (params)); + + entry_size =ath12k_hal_srng_get_entrysize (ab,HAL_REO_CMD ); +ath12k_hal_srng_get_params (ab, srng, ¶ms); + entry = (u8 *)params.ring_base_vaddr; + +for (i =0 ; i < params.num_entries; i++) { + tlv = (struct hal_tlv_64_hdr *)entry; + desc = (struct hal_reo_get_queue_stats *)tlv->value; + desc->cmd.info0 =le32_encode_bits (cmd_num++, +HAL_REO_CMD_HDR_INFO0_CMD_NUMBER ); + entry += entry_size; + } +} + +void ath12k_hal_reo_hw_setup (struct ath12k_base *ab,u32 ring_hash_map) +{ +u32 reo_base =HAL_SEQ_WCSS_UMAC_REO_REG ; +u32 val; + + val =ath12k_hif_read32 (ab, reo_base +HAL_REO1_GEN_ENABLE ); + + val |=u32_encode_bits (1 ,HAL_REO1_GEN_ENABLE_AGING_LIST_ENABLE ) | +u32_encode_bits (1 ,HAL_REO1_GEN_ENABLE_AGING_FLUSH_ENABLE ); +ath12k_hif_write32 (ab, reo_base +HAL_REO1_GEN_ENABLE , val); + + val =ath12k_hif_read32 (ab, reo_base +HAL_REO1_MISC_CTRL_ADDR (ab)); + + val &= ~(HAL_REO1_MISC_CTL_FRAG_DST_RING | +HAL_REO1_MISC_CTL_BAR_DST_RING ); + val |=u32_encode_bits (HAL_SRNG_RING_ID_REO2SW0 , +HAL_REO1_MISC_CTL_FRAG_DST_RING ); + val |=u32_encode_bits (HAL_SRNG_RING_ID_REO2SW0 , +HAL_REO1_MISC_CTL_BAR_DST_RING ); +ath12k_hif_write32 (ab, reo_base +HAL_REO1_MISC_CTRL_ADDR (ab), val); + +ath12k_hif_write32 (ab, reo_base +HAL_REO1_AGING_THRESH_IX_0 (ab), +HAL_DEFAULT_BE_BK_VI_REO_TIMEOUT_USEC ); +ath12k_hif_write32 (ab, reo_base +HAL_REO1_AGING_THRESH_IX_1 (ab), +HAL_DEFAULT_BE_BK_VI_REO_TIMEOUT_USEC ); +ath12k_hif_write32 (ab, reo_base +HAL_REO1_AGING_THRESH_IX_2 (ab), +HAL_DEFAULT_BE_BK_VI_REO_TIMEOUT_USEC ); +ath12k_hif_write32 (ab, reo_base +HAL_REO1_AGING_THRESH_IX_3 (ab), +HAL_DEFAULT_VO_REO_TIMEOUT_USEC ); + +ath12k_hif_write32 (ab, reo_base +HAL_REO1_DEST_RING_CTRL_IX_2 , + ring_hash_map); +ath12k_hif_write32 (ab, reo_base +HAL_REO1_DEST_RING_CTRL_IX_3 , + ring_hash_map); +}
PATCH v2 23/50 wifi: ath12k: add hal_rx.h
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hal_rx.h | 704 +++++++++++++++++++++++++++++++ 1 file changed, 704 insertions(+)
drivers/net/wireless/ath/ath12k/hal_rx.h new file +704 -0
@@ -0,0 +1,704 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#ifndef ATH12K_HAL_RX_H +#define ATH12K_HAL_RX_H + +struct hal_rx_wbm_rel_info { +u32 cookie; +enum hal_wbm_rel_src_module err_rel_src; +enum hal_reo_dest_ring_push_reason push_reason; +u32 err_code; +bool first_msdu; +bool last_msdu; +bool continuation; +void *rx_desc; +bool hw_cc_done; +}; + +#define HAL_INVALID_PEERID 0xffff +#define VHT_SIG_SU_NSS_MASK 0x7 + +#define HAL_RX_MAX_MCS 12 +#define HAL_RX_MAX_NSS 8 + +#define HAL_RX_MPDU_INFO_PN_GET_BYTE1 (__val) \ + le32_get_bits((__val), GENMASK(7, 0)) + +#define HAL_RX_MPDU_INFO_PN_GET_BYTE2 (__val) \ + le32_get_bits((__val), GENMASK(15, 8)) + +#define HAL_RX_MPDU_INFO_PN_GET_BYTE3 (__val) \ + le32_get_bits((__val), GENMASK(23, 16)) + +#define HAL_RX_MPDU_INFO_PN_GET_BYTE4 (__val) \ + le32_get_bits((__val), GENMASK(31, 24)) + +struct hal_rx_mon_status_tlv_hdr { +u32 hdr; +u8 value[]; +}; + +enum hal_rx_su_mu_coding { +HAL_RX_SU_MU_CODING_BCC , +HAL_RX_SU_MU_CODING_LDPC , +HAL_RX_SU_MU_CODING_MAX , +}; + +enum hal_rx_gi { +HAL_RX_GI_0_8_US , +HAL_RX_GI_0_4_US , +HAL_RX_GI_1_6_US , +HAL_RX_GI_3_2_US , +HAL_RX_GI_MAX , +}; + +enum hal_rx_bw { +HAL_RX_BW_20MHZ , +HAL_RX_BW_40MHZ , +HAL_RX_BW_80MHZ , +HAL_RX_BW_160MHZ , +HAL_RX_BW_MAX , +}; + +enum hal_rx_preamble { +HAL_RX_PREAMBLE_11A , +HAL_RX_PREAMBLE_11B , +HAL_RX_PREAMBLE_11N , +HAL_RX_PREAMBLE_11AC , +HAL_RX_PREAMBLE_11AX , +HAL_RX_PREAMBLE_MAX , +}; + +enum hal_rx_reception_type { +HAL_RX_RECEPTION_TYPE_SU , +HAL_RX_RECEPTION_TYPE_MU_MIMO , +HAL_RX_RECEPTION_TYPE_MU_OFDMA , +HAL_RX_RECEPTION_TYPE_MU_OFDMA_MIMO , +HAL_RX_RECEPTION_TYPE_MAX , +}; + +enum hal_rx_legacy_rate { +HAL_RX_LEGACY_RATE_1_MBPS , +HAL_RX_LEGACY_RATE_2_MBPS , +HAL_RX_LEGACY_RATE_5_5_MBPS , +HAL_RX_LEGACY_RATE_6_MBPS , +HAL_RX_LEGACY_RATE_9_MBPS , +HAL_RX_LEGACY_RATE_11_MBPS , +HAL_RX_LEGACY_RATE_12_MBPS , +HAL_RX_LEGACY_RATE_18_MBPS , +HAL_RX_LEGACY_RATE_24_MBPS , +HAL_RX_LEGACY_RATE_36_MBPS , +HAL_RX_LEGACY_RATE_48_MBPS , +HAL_RX_LEGACY_RATE_54_MBPS , +HAL_RX_LEGACY_RATE_INVALID , +}; + +#define HAL_TLV_STATUS_PPDU_NOT_DONE 0 +#define HAL_TLV_STATUS_PPDU_DONE 1 +#define HAL_TLV_STATUS_BUF_DONE 2 +#define HAL_TLV_STATUS_PPDU_NON_STD_DONE 3 +#define HAL_RX_FCS_LEN 4 + +enum hal_rx_mon_status { +HAL_RX_MON_STATUS_PPDU_NOT_DONE , +HAL_RX_MON_STATUS_PPDU_DONE , +HAL_RX_MON_STATUS_BUF_DONE , +}; + +#define HAL_RX_MAX_MPDU 256 +#define HAL_RX_NUM_WORDS_PER_PPDU_BITMAP (HAL_RX_MAX_MPDU >> 5) + +struct hal_rx_user_status { +u32 mcs:4 , + nss:3 , + ofdma_info_valid:1 , + ul_ofdma_ru_start_index:7 , + ul_ofdma_ru_width:7 , + ul_ofdma_ru_size:8 ; +u32 ul_ofdma_user_v0_word0; +u32 ul_ofdma_user_v0_word1; +u32 ast_index; +u32 tid; +u16 tcp_msdu_count; +u16 tcp_ack_msdu_count; +u16 udp_msdu_count; +u16 other_msdu_count; +u16 frame_control; +u8 frame_control_info_valid; +u8 data_sequence_control_info_valid; +u16 first_data_seq_ctrl; +u32 preamble_type; +u16 ht_flags; +u16 vht_flags; +u16 he_flags; +u8 rs_flags; +u8 ldpc; +u32 mpdu_cnt_fcs_ok; +u32 mpdu_cnt_fcs_err; +u32 mpdu_fcs_ok_bitmap[HAL_RX_NUM_WORDS_PER_PPDU_BITMAP ]; +u32 mpdu_ok_byte_count; +u32 mpdu_err_byte_count; +}; + +#define HAL_MAX_UL_MU_USERS 37 + +struct hal_rx_mon_ppdu_info { +u32 ppdu_id; +u32 last_ppdu_id; +u64 ppdu_ts; +u32 num_mpdu_fcs_ok; +u32 num_mpdu_fcs_err; +u32 preamble_type; +u32 mpdu_len; +u16 chan_num; +u16 tcp_msdu_count; +u16 tcp_ack_msdu_count; +u16 udp_msdu_count; +u16 other_msdu_count; +u16 peer_id; +u8 rate; +u8 mcs; +u8 nss; +u8 bw; +u8 vht_flag_values1; +u8 vht_flag_values2; +u8 vht_flag_values3[4 ]; +u8 vht_flag_values4; +u8 vht_flag_values5; +u16 vht_flag_values6; +u8 is_stbc; +u8 gi; +u8 sgi; +u8 ldpc; +u8 beamformed; +u8 rssi_comb; +u16 tid; +u8 fc_valid; +u16 ht_flags; +u16 vht_flags; +u16 he_flags; +u16 he_mu_flags; +u8 dcm; +u8 ru_alloc; +u8 reception_type; +u64 tsft; +u64 rx_duration; +u16 frame_control; +u32 ast_index; +u8 rs_fcs_err; +u8 rs_flags; +u8 cck_flag; +u8 ofdm_flag; +u8 ulofdma_flag; +u8 frame_control_info_valid; +u16 he_per_user_1; +u16 he_per_user_2; +u8 he_per_user_position; +u8 he_per_user_known; +u16 he_flags1; +u16 he_flags2; +u8 he_RU[4 ]; +u16 he_data1; +u16 he_data2; +u16 he_data3; +u16 he_data4; +u16 he_data5; +u16 he_data6; +u32 ppdu_len; +u32 prev_ppdu_id; +u32 device_id; +u16 first_data_seq_ctrl; +u8 monitor_direct_used; +u8 data_sequence_control_info_valid; +u8 ltf_size; +u8 rxpcu_filter_pass; +s8 rssi_chain[8 ][8 ]; +u32 num_users; +u32 mpdu_fcs_ok_bitmap[HAL_RX_NUM_WORDS_PER_PPDU_BITMAP ]; +u8 addr1[ETH_ALEN ]; +u8 addr2[ETH_ALEN ]; +u8 addr3[ETH_ALEN ]; +u8 addr4[ETH_ALEN ]; +struct hal_rx_user_status userstats[HAL_MAX_UL_MU_USERS ]; +u8 userid; +u16 ampdu_id[HAL_MAX_UL_MU_USERS ]; +bool first_msdu_in_mpdu; +bool is_ampdu; +u8 medium_prot_type; +}; + +#define HAL_RX_PPDU_START_INFO0_PPDU_ID GENMASK(15, 0) + +struct hal_rx_ppdu_start { +__le32 info0; +__le32 chan_num; +__le32 ppdu_start_ts; +} __packed; + +#define HAL_RX_PPDU_END_USER_STATS_INFO0_MPDU_CNT_FCS_ERR GENMASK(25, 16) + +#define HAL_RX_PPDU_END_USER_STATS_INFO1_MPDU_CNT_FCS_OK GENMASK(8, 0) +#define HAL_RX_PPDU_END_USER_STATS_INFO1_FC_VALID BIT(9) +#define HAL_RX_PPDU_END_USER_STATS_INFO1_QOS_CTRL_VALID BIT(10) +#define HAL_RX_PPDU_END_USER_STATS_INFO1_HT_CTRL_VALID BIT(11) +#define HAL_RX_PPDU_END_USER_STATS_INFO1_PKT_TYPE GENMASK(23, 20) + +#define HAL_RX_PPDU_END_USER_STATS_INFO2_AST_INDEX GENMASK(15, 0) +#define HAL_RX_PPDU_END_USER_STATS_INFO2_FRAME_CTRL GENMASK(31, 16) + +#define HAL_RX_PPDU_END_USER_STATS_INFO3_QOS_CTRL GENMASK(31, 16) + +#define HAL_RX_PPDU_END_USER_STATS_INFO4_UDP_MSDU_CNT GENMASK(15, 0) +#define HAL_RX_PPDU_END_USER_STATS_INFO4_TCP_MSDU_CNT GENMASK(31, 16) + +#define HAL_RX_PPDU_END_USER_STATS_INFO5_OTHER_MSDU_CNT GENMASK(15, 0) +#define HAL_RX_PPDU_END_USER_STATS_INFO5_TCP_ACK_MSDU_CNT GENMASK(31, 16) + +#define HAL_RX_PPDU_END_USER_STATS_INFO6_TID_BITMAP GENMASK(15, 0) +#define HAL_RX_PPDU_END_USER_STATS_INFO6_TID_EOSP_BITMAP GENMASK(31, 16) + +#define HAL_RX_PPDU_END_USER_STATS_MPDU_DELIM_OK_BYTE_COUNT GENMASK(24, 0) +#define HAL_RX_PPDU_END_USER_STATS_MPDU_DELIM_ERR_BYTE_COUNT GENMASK(24, 0) + +struct hal_rx_ppdu_end_user_stats { +__le32 rsvd0[2 ]; +__le32 info0; +__le32 info1; +__le32 info2; +__le32 info3; +__le32 ht_ctrl; +__le32 rsvd1[2 ]; +__le32 info4; +__le32 info5; +__le32 usr_resp_ref; +__le32 info6; +__le32 rsvd3[4 ]; +__le32 mpdu_ok_cnt; +__le32 rsvd4; +__le32 mpdu_err_cnt; +__le32 rsvd5[2 ]; +__le32 usr_resp_ref_ext; +__le32 rsvd6; +} __packed; + +struct hal_rx_ppdu_end_user_stats_ext { +__le32 info0; +__le32 info1; +__le32 info2; +__le32 info3; +__le32 info4; +__le32 info5; +__le32 info6; +} __packed; + +#define HAL_RX_HT_SIG_INFO_INFO0_MCS GENMASK(6, 0) +#define HAL_RX_HT_SIG_INFO_INFO0_BW BIT(7) + +#define HAL_RX_HT_SIG_INFO_INFO1_STBC GENMASK(5, 4) +#define HAL_RX_HT_SIG_INFO_INFO1_FEC_CODING BIT(6) +#define HAL_RX_HT_SIG_INFO_INFO1_GI BIT(7) + +struct hal_rx_ht_sig_info { +__le32 info0; +__le32 info1; +} __packed; + +#define HAL_RX_LSIG_B_INFO_INFO0_RATE GENMASK(3, 0) +#define HAL_RX_LSIG_B_INFO_INFO0_LEN GENMASK(15, 4) + +struct hal_rx_lsig_b_info { +__le32 info0; +} __packed; + +#define HAL_RX_LSIG_A_INFO_INFO0_RATE GENMASK(3, 0) +#define HAL_RX_LSIG_A_INFO_INFO0_LEN GENMASK(16, 5) +#define HAL_RX_LSIG_A_INFO_INFO0_PKT_TYPE GENMASK(27, 24) + +struct hal_rx_lsig_a_info { +__le32 info0; +} __packed; + +#define HAL_RX_VHT_SIG_A_INFO_INFO0_BW GENMASK(1, 0) +#define HAL_RX_VHT_SIG_A_INFO_INFO0_STBC BIT(3) +#define HAL_RX_VHT_SIG_A_INFO_INFO0_GROUP_ID GENMASK(9, 4) +#define HAL_RX_VHT_SIG_A_INFO_INFO0_NSTS GENMASK(21, 10) + +#define HAL_RX_VHT_SIG_A_INFO_INFO1_GI_SETTING GENMASK(1, 0) +#define HAL_RX_VHT_SIG_A_INFO_INFO1_SU_MU_CODING BIT(2) +#define HAL_RX_VHT_SIG_A_INFO_INFO1_MCS GENMASK(7, 4) +#define HAL_RX_VHT_SIG_A_INFO_INFO1_BEAMFORMED BIT(8) + +struct hal_rx_vht_sig_a_info { +__le32 info0; +__le32 info1; +} __packed; + +enum hal_rx_vht_sig_a_gi_setting { +HAL_RX_VHT_SIG_A_NORMAL_GI =0 , +HAL_RX_VHT_SIG_A_SHORT_GI =1 , +HAL_RX_VHT_SIG_A_SHORT_GI_AMBIGUITY =3 , +}; + +#define HE_GI_0_8 0 +#define HE_GI_0_4 1 +#define HE_GI_1_6 2 +#define HE_GI_3_2 3 + +#define HE_LTF_1_X 0 +#define HE_LTF_2_X 1 +#define HE_LTF_4_X 2 + +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_MCS GENMASK(6, 3) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_DCM BIT(7) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_TRANSMIT_BW GENMASK(20, 19) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_CP_LTF_SIZE GENMASK(22, 21) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_NSTS GENMASK(25, 23) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_BSS_COLOR GENMASK(13, 8) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_SPATIAL_REUSE GENMASK(18, 15) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_FORMAT_IND BIT(0) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_BEAM_CHANGE BIT(1) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO0_DL_UL_FLAG BIT(2) + +#define HAL_RX_HE_SIG_A_SU_INFO_INFO1_TXOP_DURATION GENMASK(6, 0) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO1_CODING BIT(7) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO1_LDPC_EXTRA BIT(8) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO1_STBC BIT(9) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO1_TXBF BIT(10) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO1_PKT_EXT_FACTOR GENMASK(12, 11) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO1_PKT_EXT_PE_DISAM BIT(13) +#define HAL_RX_HE_SIG_A_SU_INFO_INFO1_DOPPLER_IND BIT(15) + +struct hal_rx_he_sig_a_su_info { +__le32 info0; +__le32 info1; +} __packed; + +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_UL_FLAG BIT(1) +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_MCS_OF_SIGB GENMASK(3, 1) +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_DCM_OF_SIGB BIT(4) +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_BSS_COLOR GENMASK(10, 5) +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_SPATIAL_REUSE GENMASK(14, 11) +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_TRANSMIT_BW GENMASK(17, 15) +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_NUM_SIGB_SYMB GENMASK(21, 18) +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_COMP_MODE_SIGB BIT(22) +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_CP_LTF_SIZE GENMASK(24, 23) +#define HAL_RX_HE_SIG_A_MU_DL_INFO0_DOPPLER_INDICATION BIT(25) + +#define HAL_RX_HE_SIG_A_MU_DL_INFO1_TXOP_DURATION GENMASK(6, 0) +#define HAL_RX_HE_SIG_A_MU_DL_INFO1_CODING BIT(7) +#define HAL_RX_HE_SIG_A_MU_DL_INFO1_NUM_LTF_SYMB GENMASK(10, 8) +#define HAL_RX_HE_SIG_A_MU_DL_INFO1_LDPC_EXTRA BIT(11) +#define HAL_RX_HE_SIG_A_MU_DL_INFO1_STBC BIT(12) +#define HAL_RX_HE_SIG_A_MU_DL_INFO1_TXBF BIT(10) +#define HAL_RX_HE_SIG_A_MU_DL_INFO1_PKT_EXT_FACTOR GENMASK(14, 13) +#define HAL_RX_HE_SIG_A_MU_DL_INFO1_PKT_EXT_PE_DISAM BIT(15) + +struct hal_rx_he_sig_a_mu_dl_info { +__le32 info0; +__le32 info1; +} __packed; + +#define HAL_RX_HE_SIG_B1_MU_INFO_INFO0_RU_ALLOCATION GENMASK(7, 0) + +struct hal_rx_he_sig_b1_mu_info { +__le32 info0; +} __packed; + +#define HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_ID GENMASK(10, 0) +#define HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_MCS GENMASK(18, 15) +#define HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_CODING BIT(20) +#define HAL_RX_HE_SIG_B2_MU_INFO_INFO0_STA_NSTS GENMASK(31, 29) + +struct hal_rx_he_sig_b2_mu_info { +__le32 info0; +} __packed; + +#define HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_ID GENMASK(10, 0) +#define HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_NSTS GENMASK(13, 11) +#define HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_TXBF BIT(19) +#define HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_MCS GENMASK(18, 15) +#define HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_DCM BIT(19) +#define HAL_RX_HE_SIG_B2_OFDMA_INFO_INFO0_STA_CODING BIT(20) + +struct hal_rx_he_sig_b2_ofdma_info { +__le32 info0; +} __packed; + +enum hal_rx_ul_reception_type { +HAL_RECEPTION_TYPE_ULOFMDA , +HAL_RECEPTION_TYPE_ULMIMO , +HAL_RECEPTION_TYPE_OTHER , +HAL_RECEPTION_TYPE_FRAMELESS +}; + +#define HAL_RX_PHYRX_RSSI_LEGACY_INFO_INFO0_RSSI_COMB GENMASK(15, 8) +#define HAL_RX_PHYRX_RSSI_LEGACY_INFO_RSVD1_RECEPTION GENMASK(3, 0) + +struct hal_rx_phyrx_rssi_legacy_info { +__le32 rsvd[35 ]; +__le32 info0; +} __packed; + +#define HAL_RX_MPDU_START_INFO0_PPDU_ID GENMASK(31, 16) +#define HAL_RX_MPDU_START_INFO1_PEERID GENMASK(31, 16) +#define HAL_RX_MPDU_START_INFO2_MPDU_LEN GENMASK(13, 0) +struct hal_rx_mpdu_start { +__le32 info0; +__le32 info1; +__le32 rsvd1[11 ]; +__le32 info2; +__le32 rsvd2[9 ]; +} __packed; + +#define HAL_RX_PPDU_END_DURATION GENMASK(23, 0) +struct hal_rx_ppdu_end_duration { +__le32 rsvd0[9 ]; +__le32 info0; +__le32 rsvd1[4 ]; +} __packed; + +struct hal_rx_rxpcu_classification_overview { +u32 rsvd0; +} __packed; + +struct hal_rx_msdu_desc_info { +u32 msdu_flags; +u16 msdu_len;/* 14 bits for length */ +}; + +#define HAL_RX_NUM_MSDU_DESC 6 +struct hal_rx_msdu_list { +struct hal_rx_msdu_desc_info msdu_info[HAL_RX_NUM_MSDU_DESC ]; +u32 sw_cookie[HAL_RX_NUM_MSDU_DESC ]; +u8 rbm[HAL_RX_NUM_MSDU_DESC ]; +}; + +#define HAL_RX_FBM_ACK_INFO0_ADDR1_31_0 GENMASK(31, 0) +#define HAL_RX_FBM_ACK_INFO1_ADDR1_47_32 GENMASK(15, 0) +#define HAL_RX_FBM_ACK_INFO1_ADDR2_15_0 GENMASK(31, 16) +#define HAL_RX_FBM_ACK_INFO2_ADDR2_47_16 GENMASK(31, 0) + +struct hal_rx_frame_bitmap_ack { +__le32 reserved; +__le32 info0; +__le32 info1; +__le32 info2; +__le32 reserved1[10 ]; +} __packed; + +#define HAL_RX_RESP_REQ_INFO0_PPDU_ID GENMASK(15, 0) +#define HAL_RX_RESP_REQ_INFO0_RECEPTION_TYPE BIT(16) +#define HAL_RX_RESP_REQ_INFO1_DURATION GENMASK(15, 0) +#define HAL_RX_RESP_REQ_INFO1_RATE_MCS GENMASK(24, 21) +#define HAL_RX_RESP_REQ_INFO1_SGI GENMASK(26, 25) +#define HAL_RX_RESP_REQ_INFO1_STBC BIT(27) +#define HAL_RX_RESP_REQ_INFO1_LDPC BIT(28) +#define HAL_RX_RESP_REQ_INFO1_IS_AMPDU BIT(29) +#define HAL_RX_RESP_REQ_INFO2_NUM_USER GENMASK(6, 0) +#define HAL_RX_RESP_REQ_INFO3_ADDR1_31_0 GENMASK(31, 0) +#define HAL_RX_RESP_REQ_INFO4_ADDR1_47_32 GENMASK(15, 0) +#define HAL_RX_RESP_REQ_INFO4_ADDR1_15_0 GENMASK(31, 16) +#define HAL_RX_RESP_REQ_INFO5_ADDR1_47_16 GENMASK(31, 0) + +struct hal_rx_resp_req_info { +__le32 info0; +__le32 reserved[1 ]; +__le32 info1; +__le32 info2; +__le32 reserved1[2 ]; +__le32 info3; +__le32 info4; +__le32 info5; +__le32 reserved2[5 ]; +} __packed; + +#define REO_QUEUE_DESC_MAGIC_DEBUG_PATTERN_0 0xDDBEEF +#define REO_QUEUE_DESC_MAGIC_DEBUG_PATTERN_1 0xADBEEF +#define REO_QUEUE_DESC_MAGIC_DEBUG_PATTERN_2 0xBDBEEF +#define REO_QUEUE_DESC_MAGIC_DEBUG_PATTERN_3 0xCDBEEF + +#define HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VALID BIT(30) +#define HAL_RX_UL_OFDMA_USER_INFO_V0_W0_VER BIT(31) +#define HAL_RX_UL_OFDMA_USER_INFO_V0_W1_NSS GENMASK(2, 0) +#define HAL_RX_UL_OFDMA_USER_INFO_V0_W1_MCS GENMASK(6, 3) +#define HAL_RX_UL_OFDMA_USER_INFO_V0_W1_LDPC BIT(7) +#define HAL_RX_UL_OFDMA_USER_INFO_V0_W1_DCM BIT(8) +#define HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_START GENMASK(15, 9) +#define HAL_RX_UL_OFDMA_USER_INFO_V0_W1_RU_SIZE GENMASK(18, 16) + +/* HE Radiotap data1 Mask */ +#define HE_SU_FORMAT_TYPE 0x0000 +#define HE_EXT_SU_FORMAT_TYPE 0x0001 +#define HE_MU_FORMAT_TYPE 0x0002 +#define HE_TRIG_FORMAT_TYPE 0x0003 +#define HE_BEAM_CHANGE_KNOWN 0x0008 +#define HE_DL_UL_KNOWN 0x0010 +#define HE_MCS_KNOWN 0x0020 +#define HE_DCM_KNOWN 0x0040 +#define HE_CODING_KNOWN 0x0080 +#define HE_LDPC_EXTRA_SYMBOL_KNOWN 0x0100 +#define HE_STBC_KNOWN 0x0200 +#define HE_DATA_BW_RU_KNOWN 0x4000 +#define HE_DOPPLER_KNOWN 0x8000 +#define HE_BSS_COLOR_KNOWN 0x0004 + +/* HE Radiotap data2 Mask */ +#define HE_GI_KNOWN 0x0002 +#define HE_TXBF_KNOWN 0x0010 +#define HE_PE_DISAMBIGUITY_KNOWN 0x0020 +#define HE_TXOP_KNOWN 0x0040 +#define HE_LTF_SYMBOLS_KNOWN 0x0004 +#define HE_PRE_FEC_PADDING_KNOWN 0x0008 +#define HE_MIDABLE_PERIODICITY_KNOWN 0x0080 + +/* HE radiotap data3 shift values */ +#define HE_BEAM_CHANGE_SHIFT 6 +#define HE_DL_UL_SHIFT 7 +#define HE_TRANSMIT_MCS_SHIFT 8 +#define HE_DCM_SHIFT 12 +#define HE_CODING_SHIFT 13 +#define HE_LDPC_EXTRA_SYMBOL_SHIFT 14 +#define HE_STBC_SHIFT 15 + +/* HE radiotap data4 shift values */ +#define HE_STA_ID_SHIFT 4 + +/* HE radiotap data5 */ +#define HE_GI_SHIFT 4 +#define HE_LTF_SIZE_SHIFT 6 +#define HE_LTF_SYM_SHIFT 8 +#define HE_TXBF_SHIFT 14 +#define HE_PE_DISAMBIGUITY_SHIFT 15 +#define HE_PRE_FEC_PAD_SHIFT 12 + +/* HE radiotap data6 */ +#define HE_DOPPLER_SHIFT 4 +#define HE_TXOP_SHIFT 8 + +/* HE radiotap HE-MU flags1 */ +#define HE_SIG_B_MCS_KNOWN 0x0010 +#define HE_SIG_B_DCM_KNOWN 0x0040 +#define HE_SIG_B_SYM_NUM_KNOWN 0x8000 +#define HE_RU_0_KNOWN 0x0100 +#define HE_RU_1_KNOWN 0x0200 +#define HE_RU_2_KNOWN 0x0400 +#define HE_RU_3_KNOWN 0x0800 +#define HE_DCM_FLAG_1_SHIFT 5 +#define HE_SPATIAL_REUSE_MU_KNOWN 0x0100 +#define HE_SIG_B_COMPRESSION_FLAG_1_KNOWN 0x4000 + +/* HE radiotap HE-MU flags2 */ +#define HE_SIG_B_COMPRESSION_FLAG_2_SHIFT 3 +#define HE_BW_KNOWN 0x0004 +#define HE_NUM_SIG_B_SYMBOLS_SHIFT 4 +#define HE_SIG_B_COMPRESSION_FLAG_2_KNOWN 0x0100 +#define HE_NUM_SIG_B_FLAG_2_SHIFT 9 +#define HE_LTF_FLAG_2_SYMBOLS_SHIFT 12 +#define HE_LTF_KNOWN 0x8000 + +/* HE radiotap per_user_1 */ +#define HE_STA_SPATIAL_SHIFT 11 +#define HE_TXBF_SHIFT 14 +#define HE_RESERVED_SET_TO_1_SHIFT 19 +#define HE_STA_CODING_SHIFT 20 + +/* HE radiotap per_user_2 */ +#define HE_STA_MCS_SHIFT 4 +#define HE_STA_DCM_SHIFT 5 + +/* HE radiotap per user known */ +#define HE_USER_FIELD_POSITION_KNOWN 0x01 +#define HE_STA_ID_PER_USER_KNOWN 0x02 +#define HE_STA_NSTS_KNOWN 0x04 +#define HE_STA_TX_BF_KNOWN 0x08 +#define HE_STA_SPATIAL_CONFIG_KNOWN 0x10 +#define HE_STA_MCS_KNOWN 0x20 +#define HE_STA_DCM_KNOWN 0x40 +#define HE_STA_CODING_KNOWN 0x80 + +#define HAL_RX_MPDU_ERR_FCS BIT(0) +#define HAL_RX_MPDU_ERR_DECRYPT BIT(1) +#define HAL_RX_MPDU_ERR_TKIP_MIC BIT(2) +#define HAL_RX_MPDU_ERR_AMSDU_ERR BIT(3) +#define HAL_RX_MPDU_ERR_OVERFLOW BIT(4) +#define HAL_RX_MPDU_ERR_MSDU_LEN BIT(5) +#define HAL_RX_MPDU_ERR_MPDU_LEN BIT(6) +#define HAL_RX_MPDU_ERR_UNENCRYPTED_FRAME BIT(7) + +static inline +enum nl80211_he_ru_alloc ath12k_he_ru_tones_to_nl80211_he_ru_alloc (u16 ru_tones) +{ +enum nl80211_he_ru_alloc ret; + +switch (ru_tones) { +case RU_52 : + ret =NL80211_RATE_INFO_HE_RU_ALLOC_52 ; +break ; +case RU_106 : + ret =NL80211_RATE_INFO_HE_RU_ALLOC_106 ; +break ; +case RU_242 : + ret =NL80211_RATE_INFO_HE_RU_ALLOC_242 ; +break ; +case RU_484 : + ret =NL80211_RATE_INFO_HE_RU_ALLOC_484 ; +break ; +case RU_996 : + ret =NL80211_RATE_INFO_HE_RU_ALLOC_996 ; +break ; +case RU_26 : + fallthrough; +default : + ret =NL80211_RATE_INFO_HE_RU_ALLOC_26 ; +break ; + } +return ret; +} + +void ath12k_hal_reo_status_queue_stats (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status); +void ath12k_hal_reo_flush_queue_status (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status); +void ath12k_hal_reo_flush_cache_status (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status); +void ath12k_hal_reo_unblk_cache_status (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status); +void ath12k_hal_reo_flush_timeout_list_status (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status); +void ath12k_hal_reo_desc_thresh_reached_status (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status); +void ath12k_hal_reo_update_rx_reo_queue_status (struct ath12k_base *ab, +struct hal_tlv_64_hdr *tlv, +struct hal_reo_status *status); +void ath12k_hal_rx_msdu_link_info_get (struct hal_rx_msdu_link *link,u32 *num_msdus, +u32 *msdu_cookies, +enum hal_rx_buf_return_buf_manager *rbm); +void ath12k_hal_rx_msdu_link_desc_set (struct ath12k_base *ab, +struct hal_wbm_release_ring *dst_desc, +struct hal_wbm_release_ring *src_desc, +enum hal_wbm_rel_bm_act action); +void ath12k_hal_rx_buf_addr_info_set (struct ath12k_buffer_addr *binfo, +dma_addr_t paddr,u32 cookie,u8 manager); +void ath12k_hal_rx_buf_addr_info_get (struct ath12k_buffer_addr *binfo, +dma_addr_t *paddr, +u32 *cookie,u8 *rbm); +int ath12k_hal_desc_reo_parse_err (struct ath12k_base *ab, +struct hal_reo_dest_ring *desc, +dma_addr_t *paddr,u32 *desc_bank); +int ath12k_hal_wbm_desc_parse_err (struct ath12k_base *ab,void *desc, +struct hal_rx_wbm_rel_info *rel_info); +void ath12k_hal_rx_reo_ent_paddr_get (struct ath12k_base *ab, +struct ath12k_buffer_addr *buff_addr, +dma_addr_t *paddr,u32 *cookie); + +#endif
PATCH v2 24/50 wifi: ath12k: add hal_tx.c
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hal_tx.c | 145 +++++++++++++++++++++++++++++++ 1 file changed, 145 insertions(+)
drivers/net/wireless/ath/ath12k/hal_tx.c new file +145 -0
@@ -0,0 +1,145 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#include "hal_desc.h" +#include "hal.h" +#include "hal_tx.h" +#include "hif.h" + +#define DSCP_TID_MAP_TBL_ENTRY_SIZE 64 + +/* dscp_tid_map - Default DSCP-TID mapping +*================= +* DSCP TID +*================= +* 000xxx 0 +* 001xxx 1 +* 010xxx 2 +* 011xxx 3 +* 100xxx 4 +* 101xxx 5 +* 110xxx 6 +* 111xxx 7 +*/ +static inline u8 dscp2tid (u8 dscp) +{ +return dscp >>3 ; +} + +void ath12k_hal_tx_cmd_desc_setup (struct ath12k_base *ab, +struct hal_tcl_data_cmd *tcl_cmd, +struct hal_tx_info *ti) +{ + tcl_cmd->buf_addr_info.info0 = +le32_encode_bits (ti->paddr,BUFFER_ADDR_INFO0_ADDR ); + tcl_cmd->buf_addr_info.info1 = +le32_encode_bits (((uint64_t )ti->paddr >>HAL_ADDR_MSB_REG_SHIFT ), +BUFFER_ADDR_INFO1_ADDR ); + tcl_cmd->buf_addr_info.info1 |= +le32_encode_bits ((ti->rbm_id),BUFFER_ADDR_INFO1_RET_BUF_MGR ) | +le32_encode_bits (ti->desc_id,BUFFER_ADDR_INFO1_SW_COOKIE ); + + tcl_cmd->info0 = +le32_encode_bits (ti->type,HAL_TCL_DATA_CMD_INFO0_DESC_TYPE ) | +le32_encode_bits (ti->bank_id,HAL_TCL_DATA_CMD_INFO0_BANK_ID ); + + tcl_cmd->info1 = +le32_encode_bits (ti->meta_data_flags, +HAL_TCL_DATA_CMD_INFO1_CMD_NUM ); + + tcl_cmd->info2 =cpu_to_le32 (ti->flags0) | +le32_encode_bits (ti->data_len,HAL_TCL_DATA_CMD_INFO2_DATA_LEN ) | +le32_encode_bits (ti->pkt_offset,HAL_TCL_DATA_CMD_INFO2_PKT_OFFSET ); + + tcl_cmd->info3 =cpu_to_le32 (ti->flags1) | +le32_encode_bits (ti->tid,HAL_TCL_DATA_CMD_INFO3_TID ) | +le32_encode_bits (ti->lmac_id,HAL_TCL_DATA_CMD_INFO3_PMAC_ID ) | +le32_encode_bits (ti->vdev_id,HAL_TCL_DATA_CMD_INFO3_VDEV_ID ); + + tcl_cmd->info4 =le32_encode_bits (ti->bss_ast_idx, +HAL_TCL_DATA_CMD_INFO4_SEARCH_INDEX ) | +le32_encode_bits (ti->bss_ast_hash, +HAL_TCL_DATA_CMD_INFO4_CACHE_SET_NUM ); + tcl_cmd->info5 =0 ; +} + +void ath12k_hal_tx_set_dscp_tid_map (struct ath12k_base *ab,int id) +{ +u32 ctrl_reg_val; +u32 addr; +u8 hw_map_val[HAL_DSCP_TID_TBL_SIZE ], dscp, tid; +int i; +u32 value; + + ctrl_reg_val =ath12k_hif_read32 (ab,HAL_SEQ_WCSS_UMAC_TCL_REG + +HAL_TCL1_RING_CMN_CTRL_REG ); +/* Enable read/write access */ + ctrl_reg_val |=HAL_TCL1_RING_CMN_CTRL_DSCP_TID_MAP_PROG_EN ; +ath12k_hif_write32 (ab,HAL_SEQ_WCSS_UMAC_TCL_REG + +HAL_TCL1_RING_CMN_CTRL_REG , ctrl_reg_val); + + addr =HAL_SEQ_WCSS_UMAC_TCL_REG +HAL_TCL1_RING_DSCP_TID_MAP + + (4 * id * (HAL_DSCP_TID_TBL_SIZE /4 )); + +/* Configure each DSCP-TID mapping in three bits there by configure +* three bytes in an iteration. +*/ +for (i =0 , dscp =0 ; i <HAL_DSCP_TID_TBL_SIZE ; i +=3 ) { + tid =dscp2tid (dscp); + value =u32_encode_bits (tid,HAL_TCL1_RING_FIELD_DSCP_TID_MAP0 ); + dscp++; + + tid =dscp2tid (dscp); + value |=u32_encode_bits (tid,HAL_TCL1_RING_FIELD_DSCP_TID_MAP1 ); + dscp++; + + tid =dscp2tid (dscp); + value |=u32_encode_bits (tid,HAL_TCL1_RING_FIELD_DSCP_TID_MAP2 ); + dscp++; + + tid =dscp2tid (dscp); + value |=u32_encode_bits (tid,HAL_TCL1_RING_FIELD_DSCP_TID_MAP3 ); + dscp++; + + tid =dscp2tid (dscp); + value |=u32_encode_bits (tid,HAL_TCL1_RING_FIELD_DSCP_TID_MAP4 ); + dscp++; + + tid =dscp2tid (dscp); + value |=u32_encode_bits (tid,HAL_TCL1_RING_FIELD_DSCP_TID_MAP5 ); + dscp++; + + tid =dscp2tid (dscp); + value |=u32_encode_bits (tid,HAL_TCL1_RING_FIELD_DSCP_TID_MAP6 ); + dscp++; + + tid =dscp2tid (dscp); + value |=u32_encode_bits (tid,HAL_TCL1_RING_FIELD_DSCP_TID_MAP7 ); + dscp++; + +memcpy (&hw_map_val[i], &value,3 ); + } + +for (i =0 ; i <HAL_DSCP_TID_TBL_SIZE ; i +=4 ) { +ath12k_hif_write32 (ab, addr, *(u32 *)&hw_map_val[i]); + addr +=4 ; + } + +/* Disable read/write access */ + ctrl_reg_val =ath12k_hif_read32 (ab,HAL_SEQ_WCSS_UMAC_TCL_REG + +HAL_TCL1_RING_CMN_CTRL_REG ); + ctrl_reg_val &= ~HAL_TCL1_RING_CMN_CTRL_DSCP_TID_MAP_PROG_EN ; +ath12k_hif_write32 (ab,HAL_SEQ_WCSS_UMAC_TCL_REG + +HAL_TCL1_RING_CMN_CTRL_REG , + ctrl_reg_val); +} + +void ath12k_hal_tx_configure_bank_register (struct ath12k_base *ab,u32 bank_config, +u8 bank_id) +{ +ath12k_hif_write32 (ab,HAL_TCL_SW_CONFIG_BANK_ADDR +4 * bank_id, + bank_config); +}
PATCH v2 25/50 wifi: ath12k: add hal_tx.h
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hal_tx.h | 194 +++++++++++++++++++++++++++++++ 1 file changed, 194 insertions(+)
drivers/net/wireless/ath/ath12k/hal_tx.h new file +194 -0
@@ -0,0 +1,194 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#ifndef ATH12K_HAL_TX_H +#define ATH12K_HAL_TX_H + +#include "hal_desc.h" +#include "core.h" + +#define HAL_TX_ADDRX_EN 1 +#define HAL_TX_ADDRY_EN 2 + +#define HAL_TX_ADDR_SEARCH_DEFAULT 0 +#define HAL_TX_ADDR_SEARCH_INDEX 1 + +/* TODO: check all these data can be managed with struct ath12k_tx_desc_info for perf */ +struct hal_tx_info { +u16 meta_data_flags;/* %HAL_TCL_DATA_CMD_INFO0_META_ */ +u8 ring_id; +u8 rbm_id; +u32 desc_id; +enum hal_tcl_desc_type type; +enum hal_tcl_encap_type encap_type; +dma_addr_t paddr; +u32 data_len; +u32 pkt_offset; +enum hal_encrypt_type encrypt_type; +u32 flags0;/* %HAL_TCL_DATA_CMD_INFO1_ */ +u32 flags1;/* %HAL_TCL_DATA_CMD_INFO2_ */ +u16 addr_search_flags;/* %HAL_TCL_DATA_CMD_INFO0_ADDR(X/Y)_ */ +u16 bss_ast_hash; +u16 bss_ast_idx; +u8 tid; +u8 search_type;/* %HAL_TX_ADDR_SEARCH_ */ +u8 lmac_id; +u8 vdev_id; +u8 dscp_tid_tbl_idx; +bool enable_mesh; +int bank_id; +}; + +/* TODO: Check if the actual desc macros can be used instead */ +#define HAL_TX_STATUS_FLAGS_FIRST_MSDU BIT(0) +#define HAL_TX_STATUS_FLAGS_LAST_MSDU BIT(1) +#define HAL_TX_STATUS_FLAGS_MSDU_IN_AMSDU BIT(2) +#define HAL_TX_STATUS_FLAGS_RATE_STATS_VALID BIT(3) +#define HAL_TX_STATUS_FLAGS_RATE_LDPC BIT(4) +#define HAL_TX_STATUS_FLAGS_RATE_STBC BIT(5) +#define HAL_TX_STATUS_FLAGS_OFDMA BIT(6) + +#define HAL_TX_STATUS_DESC_LEN sizeof(struct hal_wbm_release_ring) + +/* Tx status parsed from srng desc */ +struct hal_tx_status { +enum hal_wbm_rel_src_module buf_rel_source; +enum hal_wbm_tqm_rel_reason status; +u8 ack_rssi; +u32 flags;/* %HAL_TX_STATUS_FLAGS_ */ +u32 ppdu_id; +u8 try_cnt; +u8 tid; +u16 peer_id; +u32 rate_stats; +}; + +#define HAL_TX_PHY_DESC_INFO0_BF_TYPE GENMASK(17, 16) +#define HAL_TX_PHY_DESC_INFO0_PREAMBLE_11B BIT(20) +#define HAL_TX_PHY_DESC_INFO0_PKT_TYPE GENMASK(24, 21) +#define HAL_TX_PHY_DESC_INFO0_BANDWIDTH GENMASK(30, 28) +#define HAL_TX_PHY_DESC_INFO1_MCS GENMASK(3, 0) +#define HAL_TX_PHY_DESC_INFO1_STBC BIT(6) +#define HAL_TX_PHY_DESC_INFO2_NSS GENMASK(23, 21) +#define HAL_TX_PHY_DESC_INFO3_AP_PKT_BW GENMASK(6, 4) +#define HAL_TX_PHY_DESC_INFO3_LTF_SIZE GENMASK(20, 19) +#define HAL_TX_PHY_DESC_INFO3_ACTIVE_CHANNEL GENMASK(17, 15) + +struct hal_tx_phy_desc { +__le32 info0; +__le32 info1; +__le32 info2; +__le32 info3; +} __packed; + +#define HAL_TX_FES_STAT_PROT_INFO0_STRT_FRM_TS_15_0 GENMASK(15, 0) +#define HAL_TX_FES_STAT_PROT_INFO0_STRT_FRM_TS_31_16 GENMASK(31, 16) +#define HAL_TX_FES_STAT_PROT_INFO1_END_FRM_TS_15_0 GENMASK(15, 0) +#define HAL_TX_FES_STAT_PROT_INFO1_END_FRM_TS_31_16 GENMASK(31, 16) + +struct hal_tx_fes_status_prot { +__le64 reserved; +__le32 info0; +__le32 info1; +__le32 reserved1[11 ]; +} __packed; + +#define HAL_TX_FES_STAT_USR_PPDU_INFO0_DURATION GENMASK(15, 0) + +struct hal_tx_fes_status_user_ppdu { +__le64 reserved; +__le32 info0; +__le32 reserved1[3 ]; +} __packed; + +#define HAL_TX_FES_STAT_STRT_INFO0_PROT_TS_LOWER_32 GENMASK(31, 0) +#define HAL_TX_FES_STAT_STRT_INFO1_PROT_TS_UPPER_32 GENMASK(31, 0) + +struct hal_tx_fes_status_start_prot { +__le32 info0; +__le32 info1; +__le64 reserved; +} __packed; + +#define HAL_TX_FES_STATUS_START_INFO0_MEDIUM_PROT_TYPE GENMASK(29, 27) + +struct hal_tx_fes_status_start { +__le32 reserved; +__le32 info0; +__le64 reserved1; +} __packed; + +#define HAL_TX_Q_EXT_INFO0_FRAME_CTRL GENMASK(15, 0) +#define HAL_TX_Q_EXT_INFO0_QOS_CTRL GENMASK(31, 16) +#define HAL_TX_Q_EXT_INFO1_AMPDU_FLAG BIT(0) + +struct hal_tx_queue_exten { +__le32 info0; +__le32 info1; +} __packed; + +#define HAL_TX_FES_SETUP_INFO0_NUM_OF_USERS GENMASK(28, 23) + +struct hal_tx_fes_setup { +__le32 schedule_id; +__le32 info0; +__le64 reserved; +} __packed; + +#define HAL_TX_PPDU_SETUP_INFO0_MEDIUM_PROT_TYPE GENMASK(2, 0) +#define HAL_TX_PPDU_SETUP_INFO1_PROT_FRAME_ADDR1_31_0 GENMASK(31, 0) +#define HAL_TX_PPDU_SETUP_INFO2_PROT_FRAME_ADDR1_47_32 GENMASK(15, 0) +#define HAL_TX_PPDU_SETUP_INFO2_PROT_FRAME_ADDR2_15_0 GENMASK(31, 16) +#define HAL_TX_PPDU_SETUP_INFO3_PROT_FRAME_ADDR2_47_16 GENMASK(31, 0) +#define HAL_TX_PPDU_SETUP_INFO4_PROT_FRAME_ADDR3_31_0 GENMASK(31, 0) +#define HAL_TX_PPDU_SETUP_INFO5_PROT_FRAME_ADDR3_47_32 GENMASK(15, 0) +#define HAL_TX_PPDU_SETUP_INFO5_PROT_FRAME_ADDR4_15_0 GENMASK(31, 16) +#define HAL_TX_PPDU_SETUP_INFO6_PROT_FRAME_ADDR4_47_16 GENMASK(31, 0) + +struct hal_tx_pcu_ppdu_setup_init { +__le32 info0; +__le32 info1; +__le32 info2; +__le32 info3; +__le32 reserved; +__le32 info4; +__le32 info5; +__le32 info6; +} __packed; + +#define HAL_TX_FES_STATUS_END_INFO0_START_TIMESTAMP_15_0 GENMASK(15, 0) +#define HAL_TX_FES_STATUS_END_INFO0_START_TIMESTAMP_31_16 GENMASK(31, 16) + +struct hal_tx_fes_status_end { +__le32 reserved[2 ]; +__le32 info0; +__le32 reserved1[19 ]; +} __packed; + +#define HAL_TX_BANK_CONFIG_EPD BIT(0) +#define HAL_TX_BANK_CONFIG_ENCAP_TYPE GENMASK(2, 1) +#define HAL_TX_BANK_CONFIG_ENCRYPT_TYPE GENMASK(6, 3) +#define HAL_TX_BANK_CONFIG_SRC_BUFFER_SWAP BIT(7) +#define HAL_TX_BANK_CONFIG_LINK_META_SWAP BIT(8) +#define HAL_TX_BANK_CONFIG_INDEX_LOOKUP_EN BIT(9) +#define HAL_TX_BANK_CONFIG_ADDRX_EN BIT(10) +#define HAL_TX_BANK_CONFIG_ADDRY_EN BIT(11) +#define HAL_TX_BANK_CONFIG_MESH_EN GENMASK(13, 12) +#define HAL_TX_BANK_CONFIG_VDEV_ID_CHECK_EN BIT(14) +#define HAL_TX_BANK_CONFIG_PMAC_ID GENMASK(16, 15) +/* STA mode will have MCAST_PKT_CTRL instead of DSCP_TID_MAP bitfield */ +#define HAL_TX_BANK_CONFIG_DSCP_TIP_MAP_ID GENMASK(22, 17) + +void ath12k_hal_tx_cmd_desc_setup (struct ath12k_base *ab, +struct hal_tcl_data_cmd *tcl_cmd, +struct hal_tx_info *ti); +void ath12k_hal_tx_set_dscp_tid_map (struct ath12k_base *ab,int id); +int ath12k_hal_reo_cmd_send (struct ath12k_base *ab,struct hal_srng *srng, +enum hal_reo_cmd_type type, +struct ath12k_hal_reo_cmd *cmd); +void ath12k_hal_tx_configure_bank_register (struct ath12k_base *ab,u32 bank_config, +u8 bank_id); +#endif
PATCH v2 26/50 wifi: ath12k: add hif.h
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hif.h | 144 ++++++++++++++++++++++++++++++++++ 1 file changed, 144 insertions(+)
drivers/net/wireless/ath/ath12k/hif.h new file +144 -0
@@ -0,0 +1,144 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2019-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#ifndef ATH12K_HIF_H +#define ATH12K_HIF_H + +#include "core.h" + +struct ath12k_hif_ops { +u32 (*read32)(struct ath12k_base *sc,u32 address); +void (*write32)(struct ath12k_base *sc,u32 address,u32 data); +void (*irq_enable)(struct ath12k_base *sc); +void (*irq_disable)(struct ath12k_base *sc); +int (*start)(struct ath12k_base *sc); +void (*stop)(struct ath12k_base *sc); +int (*power_up)(struct ath12k_base *sc); +void (*power_down)(struct ath12k_base *sc); +int (*suspend)(struct ath12k_base *ab); +int (*resume)(struct ath12k_base *ab); +int (*map_service_to_pipe)(struct ath12k_base *sc,u16 service_id, +u8 *ul_pipe,u8 *dl_pipe); +int (*get_user_msi_vector)(struct ath12k_base *ab,char *user_name, +int *num_vectors,u32 *user_base_data, +u32 *base_vector); +void (*get_msi_address)(struct ath12k_base *ab,u32 *msi_addr_lo, +u32 *msi_addr_hi); +void (*ce_irq_enable)(struct ath12k_base *ab); +void (*ce_irq_disable)(struct ath12k_base *ab); +void (*get_ce_msi_idx)(struct ath12k_base *ab,u32 ce_id,u32 *msi_idx); +}; + +static inline int ath12k_hif_map_service_to_pipe (struct ath12k_base *ab,u16 service_id, +u8 *ul_pipe,u8 *dl_pipe) +{ +return ab->hif.ops->map_service_to_pipe (ab, service_id, + ul_pipe, dl_pipe); +} + +static inline int ath12k_hif_get_user_msi_vector (struct ath12k_base *ab, +char *user_name, +int *num_vectors, +u32 *user_base_data, +u32 *base_vector) +{ +if (!ab->hif.ops->get_user_msi_vector) +return -EOPNOTSUPP ; + +return ab->hif.ops->get_user_msi_vector (ab, user_name, num_vectors, + user_base_data, + base_vector); +} + +static inline void ath12k_hif_get_msi_address (struct ath12k_base *ab, +u32 *msi_addr_lo, +u32 *msi_addr_hi) +{ +if (!ab->hif.ops->get_msi_address) +return ; + + ab->hif.ops->get_msi_address (ab, msi_addr_lo, msi_addr_hi); +} + +static inline void ath12k_hif_get_ce_msi_idx (struct ath12k_base *ab,u32 ce_id, +u32 *msi_data_idx) +{ +if (ab->hif.ops->get_ce_msi_idx) + ab->hif.ops->get_ce_msi_idx (ab, ce_id, msi_data_idx); +else + *msi_data_idx = ce_id; +} + +static inline void ath12k_hif_ce_irq_enable (struct ath12k_base *ab) +{ +if (ab->hif.ops->ce_irq_enable) + ab->hif.ops->ce_irq_enable (ab); +} + +static inline void ath12k_hif_ce_irq_disable (struct ath12k_base *ab) +{ +if (ab->hif.ops->ce_irq_disable) + ab->hif.ops->ce_irq_disable (ab); +} + +static inline void ath12k_hif_irq_enable (struct ath12k_base *ab) +{ + ab->hif.ops->irq_enable (ab); +} + +static inline void ath12k_hif_irq_disable (struct ath12k_base *ab) +{ + ab->hif.ops->irq_disable (ab); +} + +static inline int ath12k_hif_suspend (struct ath12k_base *ab) +{ +if (ab->hif.ops->suspend) +return ab->hif.ops->suspend (ab); + +return 0 ; +} + +static inline int ath12k_hif_resume (struct ath12k_base *ab) +{ +if (ab->hif.ops->resume) +return ab->hif.ops->resume (ab); + +return 0 ; +} + +static inline int ath12k_hif_start (struct ath12k_base *ab) +{ +return ab->hif.ops->start (ab); +} + +static inline void ath12k_hif_stop (struct ath12k_base *ab) +{ + ab->hif.ops->stop (ab); +} + +static inline u32 ath12k_hif_read32 (struct ath12k_base *ab,u32 address) +{ +return ab->hif.ops->read32 (ab, address); +} + +static inline void ath12k_hif_write32 (struct ath12k_base *ab,u32 address, +u32 data) +{ + ab->hif.ops->write32 (ab, address, data); +} + +static inline int ath12k_hif_power_up (struct ath12k_base *ab) +{ +return ab->hif.ops->power_up (ab); +} + +static inline void ath12k_hif_power_down (struct ath12k_base *ab) +{ + ab->hif.ops->power_down (ab); +} + +#endif /* ATH12K_HIF_H */
PATCH v2 27/50 wifi: ath12k: add htc.c
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/htc.c | 789 ++++++++++++++++++++++++++++++++++ 1 file changed, 789 insertions(+)
drivers/net/wireless/ath/ath12k/htc.c new file +789 -0
@@ -0,0 +1,789 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ +#include <linux/skbuff.h> +#include <linux/ctype.h> + +#include "debug.h" +#include "hif.h" + +struct sk_buff *ath12k_htc_alloc_skb (struct ath12k_base *ab,int size) +{ +struct sk_buff *skb; + + skb =dev_alloc_skb (size +sizeof (struct ath12k_htc_hdr )); +if (!skb) +return NULL ; + +skb_reserve (skb,sizeof (struct ath12k_htc_hdr )); + +/* FW/HTC requires 4-byte aligned streams */ +if (!IS_ALIGNED ((unsigned long )skb->data,4 )) +ath12k_warn (ab,"Unaligned HTC tx skb\n" ); + +return skb; +} + +static void ath12k_htc_control_tx_complete (struct ath12k_base *ab, +struct sk_buff *skb) +{ +kfree_skb (skb); +} + +static struct sk_buff *ath12k_htc_build_tx_ctrl_skb (void ) +{ +struct sk_buff *skb; +struct ath12k_skb_cb *skb_cb; + + skb =dev_alloc_skb (ATH12K_HTC_CONTROL_BUFFER_SIZE ); +if (!skb) +return NULL ; + +skb_reserve (skb,sizeof (struct ath12k_htc_hdr )); +WARN_ON_ONCE (!IS_ALIGNED ((unsigned long )skb->data,4 )); + + skb_cb =ATH12K_SKB_CB (skb); +memset (skb_cb,0 ,sizeof (*skb_cb)); + +return skb; +} + +static void ath12k_htc_prepare_tx_skb (struct ath12k_htc_ep *ep, +struct sk_buff *skb) +{ +struct ath12k_htc_hdr *hdr; + + hdr = (struct ath12k_htc_hdr *)skb->data; + +memset (hdr,0 ,sizeof (*hdr)); + hdr->htc_info =le32_encode_bits (ep->eid,HTC_HDR_ENDPOINTID ) | +le32_encode_bits ((skb->len -sizeof (*hdr)), +HTC_HDR_PAYLOADLEN ); + +if (ep->tx_credit_flow_enabled) + hdr->htc_info |=le32_encode_bits (ATH12K_HTC_FLAG_NEED_CREDIT_UPDATE , +HTC_HDR_FLAGS ); + +spin_lock_bh (&ep->htc->tx_lock); + hdr->ctrl_info =le32_encode_bits (ep->seq_no++,HTC_HDR_CONTROLBYTES1 ); +spin_unlock_bh (&ep->htc->tx_lock); +} + +int ath12k_htc_send (struct ath12k_htc *htc, +enum ath12k_htc_ep_id eid, +struct sk_buff *skb) +{ +struct ath12k_htc_ep *ep = &htc->endpoint[eid]; +struct ath12k_skb_cb *skb_cb =ATH12K_SKB_CB (skb); +struct device *dev = htc->ab->dev; +struct ath12k_base *ab = htc->ab; +int credits =0 ; +int ret; + +if (eid >=ATH12K_HTC_EP_COUNT ) { +ath12k_warn (ab,"Invalid endpoint id: %d\n" , eid); +return -ENOENT ; + } + +skb_push (skb,sizeof (struct ath12k_htc_hdr )); + +if (ep->tx_credit_flow_enabled) { + credits =DIV_ROUND_UP (skb->len, htc->target_credit_size); +spin_lock_bh (&htc->tx_lock); +if (ep->tx_credits < credits) { +ath12k_dbg (ab,ATH12K_DBG_HTC , +"htc insufficient credits ep %d required %d available %d\n" , + eid, credits, ep->tx_credits); +spin_unlock_bh (&htc->tx_lock); + ret = -EAGAIN ; + goto err_pull; + } + ep->tx_credits -= credits; +ath12k_dbg (ab,ATH12K_DBG_HTC , +"htc ep %d consumed %d credits (total %d)\n" , + eid, credits, ep->tx_credits); +spin_unlock_bh (&htc->tx_lock); + } + +ath12k_htc_prepare_tx_skb (ep, skb); + + skb_cb->paddr =dma_map_single (dev, skb->data, skb->len,DMA_TO_DEVICE ); + ret =dma_mapping_error (dev, skb_cb->paddr); +if (ret) { + ret = -EIO ; + goto err_credits; + } + + ret =ath12k_ce_send (htc->ab, skb, ep->ul_pipe_id, ep->eid); +if (ret) + goto err_unmap; + +return 0 ; + +err_unmap: +dma_unmap_single (dev, skb_cb->paddr, skb->len,DMA_TO_DEVICE ); +err_credits: +if (ep->tx_credit_flow_enabled) { +spin_lock_bh (&htc->tx_lock); + ep->tx_credits += credits; +ath12k_dbg (ab,ATH12K_DBG_HTC , +"htc ep %d reverted %d credits back (total %d)\n" , + eid, credits, ep->tx_credits); +spin_unlock_bh (&htc->tx_lock); + +if (ep->ep_ops.ep_tx_credits) + ep->ep_ops.ep_tx_credits (htc->ab); + } +err_pull: +skb_pull (skb,sizeof (struct ath12k_htc_hdr )); +return ret; +} + +static void +ath12k_htc_process_credit_report (struct ath12k_htc *htc, +const struct ath12k_htc_credit_report *report, +int len, +enum ath12k_htc_ep_id eid) +{ +struct ath12k_base *ab = htc->ab; +struct ath12k_htc_ep *ep; +int i, n_reports; + +if (len %sizeof (*report)) +ath12k_warn (ab,"Uneven credit report len %d" , len); + + n_reports = len /sizeof (*report); + +spin_lock_bh (&htc->tx_lock); +for (i =0 ; i < n_reports; i++, report++) { +if (report->eid >=ATH12K_HTC_EP_COUNT ) +break ; + + ep = &htc->endpoint[report->eid]; + ep->tx_credits += report->credits; + +ath12k_dbg (ab,ATH12K_DBG_HTC ,"htc ep %d got %d credits (total %d)\n" , + report->eid, report->credits, ep->tx_credits); + +if (ep->ep_ops.ep_tx_credits) { +spin_unlock_bh (&htc->tx_lock); + ep->ep_ops.ep_tx_credits (htc->ab); +spin_lock_bh (&htc->tx_lock); + } + } +spin_unlock_bh (&htc->tx_lock); +} + +static int ath12k_htc_process_trailer (struct ath12k_htc *htc, +u8 *buffer, +int length, +enum ath12k_htc_ep_id src_eid) +{ +struct ath12k_base *ab = htc->ab; +int status =0 ; +struct ath12k_htc_record *record; +size_t len; + +while (length >0 ) { + record = (struct ath12k_htc_record *)buffer; + +if (length <sizeof (record->hdr)) { + status = -EINVAL ; +break ; + } + +if (record->hdr.len > length) { +/* no room left in buffer for record */ +ath12k_warn (ab,"Invalid record length: %d\n" , + record->hdr.len); + status = -EINVAL ; +break ; + } + +switch (record->hdr.id) { +case ATH12K_HTC_RECORD_CREDITS : + len =sizeof (struct ath12k_htc_credit_report ); +if (record->hdr.len < len) { +ath12k_warn (ab,"Credit report too long\n" ); + status = -EINVAL ; +break ; + } +ath12k_htc_process_credit_report (htc, + record->credit_report, + record->hdr.len, + src_eid); +break ; +default : +ath12k_warn (ab,"Unhandled record: id:%d length:%d\n" , + record->hdr.id, record->hdr.len); +break ; + } + +if (status) +break ; + +/* multiple records may be present in a trailer */ + buffer +=sizeof (record->hdr) + record->hdr.len; + length -=sizeof (record->hdr) + record->hdr.len; + } + +return status; +} + +static void ath12k_htc_suspend_complete (struct ath12k_base *ab,bool ack) +{ +ath12k_dbg (ab,ATH12K_DBG_BOOT ,"boot suspend complete %d\n" , ack); + +if (ack) +set_bit (ATH12K_FLAG_HTC_SUSPEND_COMPLETE , &ab->dev_flags); +else +clear_bit (ATH12K_FLAG_HTC_SUSPEND_COMPLETE , &ab->dev_flags); + +complete (&ab->htc_suspend); +} + +void ath12k_htc_rx_completion_handler (struct ath12k_base *ab, +struct sk_buff *skb) +{ +int status =0 ; +struct ath12k_htc *htc = &ab->htc; +struct ath12k_htc_hdr *hdr; +struct ath12k_htc_ep *ep; +u16 payload_len; +u32 trailer_len =0 ; +size_t min_len; +u8 eid; +bool trailer_present; + + hdr = (struct ath12k_htc_hdr *)skb->data; +skb_pull (skb,sizeof (*hdr)); + + eid =le32_get_bits (hdr->htc_info,HTC_HDR_ENDPOINTID ); + +if (eid >=ATH12K_HTC_EP_COUNT ) { +ath12k_warn (ab,"HTC Rx: invalid eid %d\n" , eid); + goto out; + } + + ep = &htc->endpoint[eid]; + + payload_len =le32_get_bits (hdr->htc_info,HTC_HDR_PAYLOADLEN ); + +if (payload_len +sizeof (*hdr) >ATH12K_HTC_MAX_LEN ) { +ath12k_warn (ab,"HTC rx frame too long, len: %zu\n" , + payload_len +sizeof (*hdr)); + goto out; + } + +if (skb->len < payload_len) { +ath12k_warn (ab,"HTC Rx: insufficient length, got %d, expected %d\n" , + skb->len, payload_len); + goto out; + } + +/* get flags to check for trailer */ + trailer_present =le32_get_bits (hdr->htc_info,HTC_HDR_FLAGS ) & +ATH12K_HTC_FLAG_TRAILER_PRESENT ; + +if (trailer_present) { +u8 *trailer; + + trailer_len =le32_get_bits (hdr->ctrl_info, +HTC_HDR_CONTROLBYTES0 ); + min_len =sizeof (struct ath12k_htc_record_hdr ); + +if ((trailer_len < min_len) || + (trailer_len > payload_len)) { +ath12k_warn (ab,"Invalid trailer length: %d\n" , + trailer_len); + goto out; + } + + trailer = (u8 *)hdr; + trailer +=sizeof (*hdr); + trailer += payload_len; + trailer -= trailer_len; + status =ath12k_htc_process_trailer (htc, trailer, + trailer_len, eid); +if (status) + goto out; + +skb_trim (skb, skb->len - trailer_len); + } + +if (trailer_len >= payload_len) +/* zero length packet with trailer data, just drop these */ + goto out; + +if (eid ==ATH12K_HTC_EP_0 ) { +struct ath12k_htc_msg *msg = (struct ath12k_htc_msg *)skb->data; + +switch (le32_get_bits (msg->msg_svc_id,HTC_MSG_MESSAGEID )) { +case ATH12K_HTC_MSG_READY_ID : +case ATH12K_HTC_MSG_CONNECT_SERVICE_RESP_ID : +/* handle HTC control message */ +if (completion_done (&htc->ctl_resp)) { +/* this is a fatal error, target should not be +* sending unsolicited messages on the ep 0 +*/ +ath12k_warn (ab,"HTC rx ctrl still processing\n" ); +complete (&htc->ctl_resp); + goto out; + } + + htc->control_resp_len = +min_t (int, skb->len, +ATH12K_HTC_MAX_CTRL_MSG_LEN ); + +memcpy (htc->control_resp_buffer, skb->data, + htc->control_resp_len); + +complete (&htc->ctl_resp); +break ; +case ATH12K_HTC_MSG_SEND_SUSPEND_COMPLETE : +ath12k_htc_suspend_complete (ab, true); +break ; +case ATH12K_HTC_MSG_NACK_SUSPEND : +ath12k_htc_suspend_complete (ab, false); +break ; +case ATH12K_HTC_MSG_WAKEUP_FROM_SUSPEND_ID : +break ; +default : +ath12k_warn (ab,"ignoring unsolicited htc ep0 event %u\n" , +le32_get_bits (msg->msg_svc_id,HTC_MSG_MESSAGEID )); +break ; + } + goto out; + } + +ath12k_dbg (ab,ATH12K_DBG_HTC ,"htc rx completion ep %d skb %pK\n" , + eid, skb); + ep->ep_ops.ep_rx_complete (ab, skb); + +/* poll tx completion for interrupt disabled CE's */ +ath12k_ce_poll_send_completed (ab, ep->ul_pipe_id); + +/* skb is now owned by the rx completion handler */ + skb =NULL ; +out: +kfree_skb (skb); +} + +static void ath12k_htc_control_rx_complete (struct ath12k_base *ab, +struct sk_buff *skb) +{ +/* This is unexpected. FW is not supposed to send regular rx on this +* endpoint. +*/ +ath12k_warn (ab,"unexpected htc rx\n" ); +kfree_skb (skb); +} + +static const char *htc_service_name (enum ath12k_htc_svc_id id) +{ +switch (id) { +case ATH12K_HTC_SVC_ID_RESERVED : +return "Reserved" ; +case ATH12K_HTC_SVC_ID_RSVD_CTRL : +return "Control" ; +case ATH12K_HTC_SVC_ID_WMI_CONTROL : +return "WMI" ; +case ATH12K_HTC_SVC_ID_WMI_DATA_BE : +return "DATA BE" ; +case ATH12K_HTC_SVC_ID_WMI_DATA_BK : +return "DATA BK" ; +case ATH12K_HTC_SVC_ID_WMI_DATA_VI : +return "DATA VI" ; +case ATH12K_HTC_SVC_ID_WMI_DATA_VO : +return "DATA VO" ; +case ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC1 : +return "WMI MAC1" ; +case ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC2 : +return "WMI MAC2" ; +case ATH12K_HTC_SVC_ID_NMI_CONTROL : +return "NMI Control" ; +case ATH12K_HTC_SVC_ID_NMI_DATA : +return "NMI Data" ; +case ATH12K_HTC_SVC_ID_HTT_DATA_MSG : +return "HTT Data" ; +case ATH12K_HTC_SVC_ID_TEST_RAW_STREAMS : +return "RAW" ; +case ATH12K_HTC_SVC_ID_IPA_TX : +return "IPA TX" ; +case ATH12K_HTC_SVC_ID_PKT_LOG : +return "PKT LOG" ; +case ATH12K_HTC_SVC_ID_WMI_CONTROL_DIAG : +return "WMI DIAG" ; + } + +return "Unknown" ; +} + +static void ath12k_htc_reset_endpoint_states (struct ath12k_htc *htc) +{ +struct ath12k_htc_ep *ep; +int i; + +for (i =ATH12K_HTC_EP_0 ; i <ATH12K_HTC_EP_COUNT ; i++) { + ep = &htc->endpoint[i]; + ep->service_id =ATH12K_HTC_SVC_ID_UNUSED ; + ep->max_ep_message_len =0 ; + ep->max_tx_queue_depth =0 ; + ep->eid = i; + ep->htc = htc; + ep->tx_credit_flow_enabled = true; + } +} + +static u8 ath12k_htc_get_credit_allocation (struct ath12k_htc *htc, +u16 service_id) +{ +struct ath12k_htc_svc_tx_credits *serv_entry; +u8 i, allocation =0 ; + + serv_entry = htc->service_alloc_table; + +for (i =0 ; i <ATH12K_HTC_MAX_SERVICE_ALLOC_ENTRIES ; i++) { +if (serv_entry[i].service_id == service_id) { + allocation = serv_entry[i].credit_allocation; +break ; + } + } + +return allocation; +} + +static int ath12k_htc_setup_target_buffer_assignments (struct ath12k_htc *htc) +{ +struct ath12k_htc_svc_tx_credits *serv_entry; +static const u32 svc_id[] = { +ATH12K_HTC_SVC_ID_WMI_CONTROL , +ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC1 , +ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC2 , + }; +int i, credits; + + credits = htc->total_transmit_credits; + serv_entry = htc->service_alloc_table; + +if ((htc->wmi_ep_count ==0 ) || + (htc->wmi_ep_count >ARRAY_SIZE (svc_id))) +return -EINVAL ; + +/* Divide credits among number of endpoints for WMI */ + credits = credits / htc->wmi_ep_count; +for (i =0 ; i < htc->wmi_ep_count; i++) { + serv_entry[i].service_id = svc_id[i]; + serv_entry[i].credit_allocation = credits; + } + +return 0 ; +} + +int ath12k_htc_wait_target (struct ath12k_htc *htc) +{ +int i, status =0 ; +struct ath12k_base *ab = htc->ab; +unsigned long time_left; +struct ath12k_htc_ready *ready; +u16 message_id; +u16 credit_count; +u16 credit_size; + + time_left =wait_for_completion_timeout (&htc->ctl_resp, +ATH12K_HTC_WAIT_TIMEOUT_HZ ); +if (!time_left) { +ath12k_warn (ab,"failed to receive control response completion, polling..\n" ); + +for (i =0 ; i < ab->hw_params->ce_count; i++) +ath12k_ce_per_engine_service (htc->ab, i); + + time_left = +wait_for_completion_timeout (&htc->ctl_resp, +ATH12K_HTC_WAIT_TIMEOUT_HZ ); + +if (!time_left) + status = -ETIMEDOUT ; + } + +if (status <0 ) { +ath12k_warn (ab,"ctl_resp never came in (%d)\n" , status); +return status; + } + +if (htc->control_resp_len <sizeof (*ready)) { +ath12k_warn (ab,"Invalid HTC ready msg len:%d\n" , + htc->control_resp_len); +return -ECOMM ; + } + + ready = (struct ath12k_htc_ready *)htc->control_resp_buffer; + message_id =le32_get_bits (ready->id_credit_count,HTC_MSG_MESSAGEID ); + credit_count =le32_get_bits (ready->id_credit_count, +HTC_READY_MSG_CREDITCOUNT ); + credit_size =le32_get_bits (ready->size_ep,HTC_READY_MSG_CREDITSIZE ); + +if (message_id !=ATH12K_HTC_MSG_READY_ID ) { +ath12k_warn (ab,"Invalid HTC ready msg: 0x%x\n" , message_id); +return -ECOMM ; + } + + htc->total_transmit_credits = credit_count; + htc->target_credit_size = credit_size; + +ath12k_dbg (ab,ATH12K_DBG_HTC , +"Target ready! transmit resources: %d size:%d\n" , + htc->total_transmit_credits, htc->target_credit_size); + +if ((htc->total_transmit_credits ==0 ) || + (htc->target_credit_size ==0 )) { +ath12k_warn (ab,"Invalid credit size received\n" ); +return -ECOMM ; + } + +ath12k_htc_setup_target_buffer_assignments (htc); + +return 0 ; +} + +int ath12k_htc_connect_service (struct ath12k_htc *htc, +struct ath12k_htc_svc_conn_req *conn_req, +struct ath12k_htc_svc_conn_resp *conn_resp) +{ +struct ath12k_base *ab = htc->ab; +struct ath12k_htc_conn_svc *req_msg; +struct ath12k_htc_conn_svc_resp resp_msg_dummy; +struct ath12k_htc_conn_svc_resp *resp_msg = &resp_msg_dummy; +enum ath12k_htc_ep_id assigned_eid =ATH12K_HTC_EP_COUNT ; +struct ath12k_htc_ep *ep; +struct sk_buff *skb; +unsigned int max_msg_size =0 ; +int length, status; +unsigned long time_left; +bool disable_credit_flow_ctrl = false; +u16 message_id, service_id, flags =0 ; +u8 tx_alloc =0 ; + +/* special case for HTC pseudo control service */ +if (conn_req->service_id ==ATH12K_HTC_SVC_ID_RSVD_CTRL ) { + disable_credit_flow_ctrl = true; + assigned_eid =ATH12K_HTC_EP_0 ; + max_msg_size =ATH12K_HTC_MAX_CTRL_MSG_LEN ; +memset (&resp_msg_dummy,0 ,sizeof (resp_msg_dummy)); + goto setup; + } + + tx_alloc =ath12k_htc_get_credit_allocation (htc, + conn_req->service_id); +if (!tx_alloc) +ath12k_dbg (ab,ATH12K_DBG_BOOT , +"boot htc service %s does not allocate target credits\n" , +htc_service_name (conn_req->service_id)); + + skb =ath12k_htc_build_tx_ctrl_skb (); +if (!skb) { +ath12k_warn (ab,"Failed to allocate HTC packet\n" ); +return -ENOMEM ; + } + + length =sizeof (*req_msg); +skb_put (skb, length); +memset (skb->data,0 , length); + + req_msg = (struct ath12k_htc_conn_svc *)skb->data; + req_msg->msg_svc_id =le32_encode_bits (ATH12K_HTC_MSG_CONNECT_SERVICE_ID , +HTC_MSG_MESSAGEID ); + + flags |=u32_encode_bits (tx_alloc,ATH12K_HTC_CONN_FLAGS_RECV_ALLOC ); + +/* Only enable credit flow control for WMI ctrl service */ +if (!(conn_req->service_id ==ATH12K_HTC_SVC_ID_WMI_CONTROL || + conn_req->service_id ==ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC1 || + conn_req->service_id ==ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC2 )) { + flags |=ATH12K_HTC_CONN_FLAGS_DISABLE_CREDIT_FLOW_CTRL ; + disable_credit_flow_ctrl = true; + } + + req_msg->flags_len =le32_encode_bits (flags,HTC_SVC_MSG_CONNECTIONFLAGS ); + req_msg->msg_svc_id |=le32_encode_bits (conn_req->service_id, +HTC_SVC_MSG_SERVICE_ID ); + +reinit_completion (&htc->ctl_resp); + + status =ath12k_htc_send (htc,ATH12K_HTC_EP_0 , skb); +if (status) { +kfree_skb (skb); +return status; + } + +/* wait for response */ + time_left =wait_for_completion_timeout (&htc->ctl_resp, +ATH12K_HTC_CONN_SVC_TIMEOUT_HZ ); +if (!time_left) { +ath12k_err (ab,"Service connect timeout\n" ); +return -ETIMEDOUT ; + } + +/* we controlled the buffer creation, it's aligned */ + resp_msg = (struct ath12k_htc_conn_svc_resp *)htc->control_resp_buffer; + message_id =le32_get_bits (resp_msg->msg_svc_id,HTC_MSG_MESSAGEID ); + service_id =le32_get_bits (resp_msg->msg_svc_id, +HTC_SVC_RESP_MSG_SERVICEID ); + +if ((message_id !=ATH12K_HTC_MSG_CONNECT_SERVICE_RESP_ID ) || + (htc->control_resp_len <sizeof (*resp_msg))) { +ath12k_err (ab,"Invalid resp message ID 0x%x" , message_id); +return -EPROTO ; + } + +ath12k_dbg (ab,ATH12K_DBG_HTC , +"HTC Service %s connect response: status: %u, assigned ep: %u\n" , +htc_service_name (service_id), +le32_get_bits (resp_msg->flags_len,HTC_SVC_RESP_MSG_STATUS ), +le32_get_bits (resp_msg->flags_len,HTC_SVC_RESP_MSG_ENDPOINTID )); + + conn_resp->connect_resp_code =le32_get_bits (resp_msg->flags_len, +HTC_SVC_RESP_MSG_STATUS ); + +/* check response status */ +if (conn_resp->connect_resp_code !=ATH12K_HTC_CONN_SVC_STATUS_SUCCESS ) { +ath12k_err (ab,"HTC Service %s connect request failed: 0x%x)\n" , +htc_service_name (service_id), + conn_resp->connect_resp_code); +return -EPROTO ; + } + + assigned_eid =le32_get_bits (resp_msg->flags_len, +HTC_SVC_RESP_MSG_ENDPOINTID ); + + max_msg_size =le32_get_bits (resp_msg->flags_len, +HTC_SVC_RESP_MSG_MAXMSGSIZE ); + +setup: + +if (assigned_eid >=ATH12K_HTC_EP_COUNT ) +return -EPROTO ; + +if (max_msg_size ==0 ) +return -EPROTO ; + + ep = &htc->endpoint[assigned_eid]; + ep->eid = assigned_eid; + +if (ep->service_id !=ATH12K_HTC_SVC_ID_UNUSED ) +return -EPROTO ; + +/* return assigned endpoint to caller */ + conn_resp->eid = assigned_eid; + conn_resp->max_msg_len =le32_get_bits (resp_msg->flags_len, +HTC_SVC_RESP_MSG_MAXMSGSIZE ); + +/* setup the endpoint */ + ep->service_id = conn_req->service_id; + ep->max_tx_queue_depth = conn_req->max_send_queue_depth; + ep->max_ep_message_len =le32_get_bits (resp_msg->flags_len, +HTC_SVC_RESP_MSG_MAXMSGSIZE ); + ep->tx_credits = tx_alloc; + +/* copy all the callbacks */ + ep->ep_ops = conn_req->ep_ops; + + status =ath12k_hif_map_service_to_pipe (htc->ab, + ep->service_id, + &ep->ul_pipe_id, + &ep->dl_pipe_id); +if (status) +return status; + +ath12k_dbg (ab,ATH12K_DBG_BOOT , +"boot htc service '%s' ul pipe %d dl pipe %d eid %d ready\n" , +htc_service_name (ep->service_id), ep->ul_pipe_id, + ep->dl_pipe_id, ep->eid); + +if (disable_credit_flow_ctrl && ep->tx_credit_flow_enabled) { + ep->tx_credit_flow_enabled = false; +ath12k_dbg (ab,ATH12K_DBG_BOOT , +"boot htc service '%s' eid %d TX flow control disabled\n" , +htc_service_name (ep->service_id), assigned_eid); + } + +return status; +} + +int ath12k_htc_start (struct ath12k_htc *htc) +{ +struct sk_buff *skb; +int status; +struct ath12k_base *ab = htc->ab; +struct ath12k_htc_setup_complete_extended *msg; + + skb =ath12k_htc_build_tx_ctrl_skb (); +if (!skb) +return -ENOMEM ; + +skb_put (skb,sizeof (*msg)); +memset (skb->data,0 , skb->len); + + msg = (struct ath12k_htc_setup_complete_extended *)skb->data; + msg->msg_id =le32_encode_bits (ATH12K_HTC_MSG_SETUP_COMPLETE_EX_ID , +HTC_MSG_MESSAGEID ); + +ath12k_dbg (ab,ATH12K_DBG_HTC ,"HTC is using TX credit flow control\n" ); + + status =ath12k_htc_send (htc,ATH12K_HTC_EP_0 , skb); +if (status) { +kfree_skb (skb); +return status; + } + +return 0 ; +} + +int ath12k_htc_init (struct ath12k_base *ab) +{ +struct ath12k_htc *htc = &ab->htc; +struct ath12k_htc_svc_conn_req conn_req = { }; +struct ath12k_htc_svc_conn_resp conn_resp = { }; +int ret; + +spin_lock_init (&htc->tx_lock); + +ath12k_htc_reset_endpoint_states (htc); + + htc->ab = ab; + +switch (ab->wmi_ab.preferred_hw_mode) { +case WMI_HOST_HW_MODE_SINGLE : + htc->wmi_ep_count =1 ; +break ; +case WMI_HOST_HW_MODE_DBS : +case WMI_HOST_HW_MODE_DBS_OR_SBS : + htc->wmi_ep_count =2 ; +break ; +case WMI_HOST_HW_MODE_DBS_SBS : + htc->wmi_ep_count =3 ; +break ; +default : + htc->wmi_ep_count = ab->hw_params->max_radios; +break ; + } + +/* setup our pseudo HTC control endpoint connection */ + conn_req.ep_ops.ep_tx_complete = ath12k_htc_control_tx_complete; + conn_req.ep_ops.ep_rx_complete = ath12k_htc_control_rx_complete; + conn_req.max_send_queue_depth =ATH12K_NUM_CONTROL_TX_BUFFERS ; + conn_req.service_id =ATH12K_HTC_SVC_ID_RSVD_CTRL ; + +/* connect fake service */ + ret =ath12k_htc_connect_service (htc, &conn_req, &conn_resp); +if (ret) { +ath12k_err (ab,"could not connect to htc service (%d)\n" , ret); +return ret; + } + +init_completion (&htc->ctl_resp); + +return 0 ; +}
PATCH v2 28/50 wifi: ath12k: add htc.h
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/htc.h | 316 ++++++++++++++++++++++++++++++++++ 1 file changed, 316 insertions(+)
drivers/net/wireless/ath/ath12k/htc.h new file +316 -0
@@ -0,0 +1,316 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#ifndef ATH12K_HTC_H +#define ATH12K_HTC_H + +#include <linux/kernel.h> +#include <linux/list.h> +#include <linux/bug.h> +#include <linux/skbuff.h> +#include <linux/timer.h> + +struct ath12k_base ; + +#define HTC_HDR_ENDPOINTID GENMASK(7, 0) +#define HTC_HDR_FLAGS GENMASK(15, 8) +#define HTC_HDR_PAYLOADLEN GENMASK(31, 16) +#define HTC_HDR_CONTROLBYTES0 GENMASK(7, 0) +#define HTC_HDR_CONTROLBYTES1 GENMASK(15, 8) +#define HTC_HDR_RESERVED GENMASK(31, 16) + +#define HTC_SVC_MSG_SERVICE_ID GENMASK(31, 16) +#define HTC_SVC_MSG_CONNECTIONFLAGS GENMASK(15, 0) +#define HTC_SVC_MSG_SERVICEMETALENGTH GENMASK(23, 16) +#define HTC_READY_MSG_CREDITCOUNT GENMASK(31, 16) +#define HTC_READY_MSG_CREDITSIZE GENMASK(15, 0) +#define HTC_READY_MSG_MAXENDPOINTS GENMASK(23, 16) + +#define HTC_READY_EX_MSG_HTCVERSION GENMASK(7, 0) +#define HTC_READY_EX_MSG_MAXMSGSPERHTCBUNDLE GENMASK(15, 8) + +#define HTC_SVC_RESP_MSG_SERVICEID GENMASK(31, 16) +#define HTC_SVC_RESP_MSG_STATUS GENMASK(7, 0) +#define HTC_SVC_RESP_MSG_ENDPOINTID GENMASK(15, 8) +#define HTC_SVC_RESP_MSG_MAXMSGSIZE GENMASK(31, 16) +#define HTC_SVC_RESP_MSG_SERVICEMETALENGTH GENMASK(7, 0) + +#define HTC_MSG_MESSAGEID GENMASK(15, 0) +#define HTC_SETUP_COMPLETE_EX_MSG_SETUPFLAGS GENMASK(31, 0) +#define HTC_SETUP_COMPLETE_EX_MSG_MAXMSGSPERBUNDLEDRECV GENMASK(7, 0) +#define HTC_SETUP_COMPLETE_EX_MSG_RSVD0 GENMASK(15, 8) +#define HTC_SETUP_COMPLETE_EX_MSG_RSVD1 GENMASK(23, 16) +#define HTC_SETUP_COMPLETE_EX_MSG_RSVD2 GENMASK(31, 24) + +enum ath12k_htc_tx_flags { +ATH12K_HTC_FLAG_NEED_CREDIT_UPDATE =0x01 , +ATH12K_HTC_FLAG_SEND_BUNDLE =0x02 +}; + +enum ath12k_htc_rx_flags { +ATH12K_HTC_FLAG_TRAILER_PRESENT =0x02 , +ATH12K_HTC_FLAG_BUNDLE_MASK =0xF0 +}; + +struct ath12k_htc_hdr { +__le32 htc_info; +__le32 ctrl_info; +} __packed__aligned(4) ; + +enum ath12k_htc_msg_id { +ATH12K_HTC_MSG_READY_ID =1 , +ATH12K_HTC_MSG_CONNECT_SERVICE_ID =2 , +ATH12K_HTC_MSG_CONNECT_SERVICE_RESP_ID =3 , +ATH12K_HTC_MSG_SETUP_COMPLETE_ID =4 , +ATH12K_HTC_MSG_SETUP_COMPLETE_EX_ID =5 , +ATH12K_HTC_MSG_SEND_SUSPEND_COMPLETE =6 , +ATH12K_HTC_MSG_NACK_SUSPEND =7 , +ATH12K_HTC_MSG_WAKEUP_FROM_SUSPEND_ID =8 , +}; + +enum ath12k_htc_version { +ATH12K_HTC_VERSION_2P0 =0x00 ,/* 2.0 */ +ATH12K_HTC_VERSION_2P1 =0x01 ,/* 2.1 */ +}; + +enum ath12k_htc_conn_flag_threshold_level { +ATH12K_HTC_CONN_FLAGS_THRESHOLD_LEVEL_ONE_FOURTH , +ATH12K_HTC_CONN_FLAGS_THRESHOLD_LEVEL_ONE_HALF , +ATH12K_HTC_CONN_FLAGS_THRESHOLD_LEVEL_THREE_FOURTHS , +ATH12K_HTC_CONN_FLAGS_THRESHOLD_LEVEL_UNITY , +}; + +#define ATH12K_HTC_CONN_FLAGS_THRESHOLD_LEVEL_MASK GENMASK(1, 0) +#define ATH12K_HTC_CONN_FLAGS_REDUCE_CREDIT_DRIBBLE BIT(2) +#define ATH12K_HTC_CONN_FLAGS_DISABLE_CREDIT_FLOW_CTRL BIT(3) +#define ATH12K_HTC_CONN_FLAGS_RECV_ALLOC GENMASK(15, 8) + +enum ath12k_htc_conn_svc_status { +ATH12K_HTC_CONN_SVC_STATUS_SUCCESS =0 , +ATH12K_HTC_CONN_SVC_STATUS_NOT_FOUND =1 , +ATH12K_HTC_CONN_SVC_STATUS_FAILED =2 , +ATH12K_HTC_CONN_SVC_STATUS_NO_RESOURCES =3 , +ATH12K_HTC_CONN_SVC_STATUS_NO_MORE_EP =4 +}; + +struct ath12k_htc_ready { +__le32 id_credit_count; +__le32 size_ep; +} __packed; + +struct ath12k_htc_ready_extended { +struct ath12k_htc_ready base; +__le32 ver_bundle; +} __packed; + +struct ath12k_htc_conn_svc { +__le32 msg_svc_id; +__le32 flags_len; +} __packed; + +struct ath12k_htc_conn_svc_resp { +__le32 msg_svc_id; +__le32 flags_len; +__le32 svc_meta_pad; +} __packed; + +struct ath12k_htc_setup_complete_extended { +__le32 msg_id; +__le32 flags; +__le32 max_msgs_per_bundled_recv; +} __packed; + +struct ath12k_htc_msg { +__le32 msg_svc_id; +__le32 flags_len; +} __packed__aligned(4) ; + +enum ath12k_htc_record_id { +ATH12K_HTC_RECORD_NULL =0 , +ATH12K_HTC_RECORD_CREDITS =1 +}; + +struct ath12k_htc_record_hdr { +u8 id;/* @enum ath12k_htc_record_id */ +u8 len; +u8 pad0; +u8 pad1; +} __packed; + +struct ath12k_htc_credit_report { +u8 eid;/* @enum ath12k_htc_ep_id */ +u8 credits; +u8 pad0; +u8 pad1; +} __packed; + +struct ath12k_htc_record { +struct ath12k_htc_record_hdr hdr; +struct ath12k_htc_credit_report credit_report[]; +} __packed__aligned(4) ; + +/* HTC FRAME structure layout draft +* +* note: the trailer offset is dynamic depending +* on payload length. this is only a struct layout draft +* +*======================================================= +* +* HTC HEADER +* +*======================================================= +* | +* HTC message | payload +* (variable length) | (variable length) +*======================================================= +* +* HTC Record +* +*======================================================= +*/ + +enum ath12k_htc_svc_gid { +ATH12K_HTC_SVC_GRP_RSVD =0 , +ATH12K_HTC_SVC_GRP_WMI =1 , +ATH12K_HTC_SVC_GRP_NMI =2 , +ATH12K_HTC_SVC_GRP_HTT =3 , +ATH12K_HTC_SVC_GRP_CFG =4 , +ATH12K_HTC_SVC_GRP_IPA =5 , +ATH12K_HTC_SVC_GRP_PKTLOG =6 , + +ATH12K_HTC_SVC_GRP_TEST =254 , +ATH12K_HTC_SVC_GRP_LAST =255 , +}; + +#define SVC (group, idx) \ + (int)(((int)(group) << 8) | (int)(idx)) + +enum ath12k_htc_svc_id { +/* NOTE: service ID of 0x0000 is reserved and should never be used */ +ATH12K_HTC_SVC_ID_RESERVED =0x0000 , +ATH12K_HTC_SVC_ID_UNUSED =ATH12K_HTC_SVC_ID_RESERVED , + +ATH12K_HTC_SVC_ID_RSVD_CTRL =SVC (ATH12K_HTC_SVC_GRP_RSVD ,1 ), +ATH12K_HTC_SVC_ID_WMI_CONTROL =SVC (ATH12K_HTC_SVC_GRP_WMI ,0 ), +ATH12K_HTC_SVC_ID_WMI_DATA_BE =SVC (ATH12K_HTC_SVC_GRP_WMI ,1 ), +ATH12K_HTC_SVC_ID_WMI_DATA_BK =SVC (ATH12K_HTC_SVC_GRP_WMI ,2 ), +ATH12K_HTC_SVC_ID_WMI_DATA_VI =SVC (ATH12K_HTC_SVC_GRP_WMI ,3 ), +ATH12K_HTC_SVC_ID_WMI_DATA_VO =SVC (ATH12K_HTC_SVC_GRP_WMI ,4 ), +ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC1 =SVC (ATH12K_HTC_SVC_GRP_WMI ,5 ), +ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC2 =SVC (ATH12K_HTC_SVC_GRP_WMI ,6 ), +ATH12K_HTC_SVC_ID_WMI_CONTROL_DIAG =SVC (ATH12K_HTC_SVC_GRP_WMI ,7 ), + +ATH12K_HTC_SVC_ID_NMI_CONTROL =SVC (ATH12K_HTC_SVC_GRP_NMI ,0 ), +ATH12K_HTC_SVC_ID_NMI_DATA =SVC (ATH12K_HTC_SVC_GRP_NMI ,1 ), + +ATH12K_HTC_SVC_ID_HTT_DATA_MSG =SVC (ATH12K_HTC_SVC_GRP_HTT ,0 ), + +/* raw stream service (i.e. flash, tcmd, calibration apps) */ +ATH12K_HTC_SVC_ID_TEST_RAW_STREAMS =SVC (ATH12K_HTC_SVC_GRP_TEST ,0 ), +ATH12K_HTC_SVC_ID_IPA_TX =SVC (ATH12K_HTC_SVC_GRP_IPA ,0 ), +ATH12K_HTC_SVC_ID_PKT_LOG =SVC (ATH12K_HTC_SVC_GRP_PKTLOG ,0 ), +}; + +#undef SVC + +enum ath12k_htc_ep_id { +ATH12K_HTC_EP_UNUSED =-1 , +ATH12K_HTC_EP_0 =0 , +ATH12K_HTC_EP_1 =1 , +ATH12K_HTC_EP_2 , +ATH12K_HTC_EP_3 , +ATH12K_HTC_EP_4 , +ATH12K_HTC_EP_5 , +ATH12K_HTC_EP_6 , +ATH12K_HTC_EP_7 , +ATH12K_HTC_EP_8 , +ATH12K_HTC_EP_COUNT , +}; + +struct ath12k_htc_ep_ops { +void (*ep_tx_complete)(struct ath12k_base *ab,struct sk_buff *skb); +void (*ep_rx_complete)(struct ath12k_base *ab,struct sk_buff *skb); +void (*ep_tx_credits)(struct ath12k_base *ab); +}; + +/* service connection information */ +struct ath12k_htc_svc_conn_req { +u16 service_id; +struct ath12k_htc_ep_ops ep_ops; +int max_send_queue_depth; +}; + +/* service connection response information */ +struct ath12k_htc_svc_conn_resp { +u8 buffer_len; +u8 actual_len; +enum ath12k_htc_ep_id eid; +unsigned int max_msg_len; +u8 connect_resp_code; +}; + +#define ATH12K_NUM_CONTROL_TX_BUFFERS 2 +#define ATH12K_HTC_MAX_LEN 4096 +#define ATH12K_HTC_MAX_CTRL_MSG_LEN 256 +#define ATH12K_HTC_WAIT_TIMEOUT_HZ (1 * HZ) +#define ATH12K_HTC_CONTROL_BUFFER_SIZE (ATH12K_HTC_MAX_CTRL_MSG_LEN + \ + sizeof(struct ath12k_htc_hdr)) +#define ATH12K_HTC_CONN_SVC_TIMEOUT_HZ (1 * HZ) +#define ATH12K_HTC_MAX_SERVICE_ALLOC_ENTRIES 8 + +struct ath12k_htc_ep { +struct ath12k_htc *htc; +enum ath12k_htc_ep_id eid; +enum ath12k_htc_svc_id service_id; +struct ath12k_htc_ep_ops ep_ops; + +int max_tx_queue_depth; +int max_ep_message_len; +u8 ul_pipe_id; +u8 dl_pipe_id; + +u8 seq_no;/* for debugging */ +int tx_credits; +bool tx_credit_flow_enabled; +}; + +struct ath12k_htc_svc_tx_credits { +u16 service_id; +u8 credit_allocation; +}; + +struct ath12k_htc { +struct ath12k_base *ab; +struct ath12k_htc_ep endpoint[ATH12K_HTC_EP_COUNT ]; + +/* protects endpoints */ +spinlock_t tx_lock; + +u8 control_resp_buffer[ATH12K_HTC_MAX_CTRL_MSG_LEN ]; +int control_resp_len; + +struct completion ctl_resp; + +int total_transmit_credits; +struct ath12k_htc_svc_tx_credits + service_alloc_table[ATH12K_HTC_MAX_SERVICE_ALLOC_ENTRIES ]; +int target_credit_size; +u8 wmi_ep_count; +}; + +int ath12k_htc_init (struct ath12k_base *ar); +int ath12k_htc_wait_target (struct ath12k_htc *htc); +int ath12k_htc_start (struct ath12k_htc *htc); +int ath12k_htc_connect_service (struct ath12k_htc *htc, +struct ath12k_htc_svc_conn_req *conn_req, +struct ath12k_htc_svc_conn_resp *conn_resp); +int ath12k_htc_send (struct ath12k_htc *htc,enum ath12k_htc_ep_id eid, +struct sk_buff *packet); +struct sk_buff *ath12k_htc_alloc_skb (struct ath12k_base *ar,int size); +void ath12k_htc_rx_completion_handler (struct ath12k_base *ar, +struct sk_buff *skb); + +#endif
PATCH v2 29/50 wifi: ath12k: add hw.c
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hw.c | 1041 ++++++++++++++++++++++++++++++++++ 1 file changed, 1041 insertions(+)
drivers/net/wireless/ath/ath12k/hw.c new file +1041 -0
@@ -0,0 +1,1041 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#include <linux/types.h> +#include <linux/bitops.h> +#include <linux/bitfield.h> + +#include "debug.h" +#include "core.h" +#include "ce.h" +#include "hw.h" +#include "mhi.h" +#include "dp_rx.h" + +static u8 ath12k_hw_qcn9274_mac_from_pdev_id (int pdev_idx) +{ +return pdev_idx; +} + +static int ath12k_hw_mac_id_to_pdev_id_qcn9274 (const struct ath12k_hw_params *hw, +int mac_id) +{ +return mac_id; +} + +static int ath12k_hw_mac_id_to_srng_id_qcn9274 (const struct ath12k_hw_params *hw, +int mac_id) +{ +return 0 ; +} + +static u8 ath12k_hw_get_ring_selector_qcn9274 (struct sk_buff *skb) +{ +return smp_processor_id (); +} + +static bool ath12k_dp_srng_is_comp_ring_qcn9274 (int ring_num) +{ +if (ring_num <3 || ring_num ==4 ) +return true; + +return false; +} + +static int ath12k_hw_mac_id_to_pdev_id_wcn7850 (const struct ath12k_hw_params *hw, +int mac_id) +{ +return 0 ; +} + +static int ath12k_hw_mac_id_to_srng_id_wcn7850 (const struct ath12k_hw_params *hw, +int mac_id) +{ +return mac_id; +} + +static u8 ath12k_hw_get_ring_selector_wcn7850 (struct sk_buff *skb) +{ +return skb_get_queue_mapping (skb); +} + +static bool ath12k_dp_srng_is_comp_ring_wcn7850 (int ring_num) +{ +if (ring_num ==0 || ring_num ==2 || ring_num ==4 ) +return true; + +return false; +} + +static const struct ath12k_hw_ops qcn9274_ops = { + .get_hw_mac_from_pdev_id = ath12k_hw_qcn9274_mac_from_pdev_id, + .mac_id_to_pdev_id = ath12k_hw_mac_id_to_pdev_id_qcn9274, + .mac_id_to_srng_id = ath12k_hw_mac_id_to_srng_id_qcn9274, + .rxdma_ring_sel_config = ath12k_dp_rxdma_ring_sel_config_qcn9274, + .get_ring_selector = ath12k_hw_get_ring_selector_qcn9274, + .dp_srng_is_tx_comp_ring = ath12k_dp_srng_is_comp_ring_qcn9274, +}; + +static const struct ath12k_hw_ops wcn7850_ops = { + .get_hw_mac_from_pdev_id = ath12k_hw_qcn9274_mac_from_pdev_id, + .mac_id_to_pdev_id = ath12k_hw_mac_id_to_pdev_id_wcn7850, + .mac_id_to_srng_id = ath12k_hw_mac_id_to_srng_id_wcn7850, + .rxdma_ring_sel_config = ath12k_dp_rxdma_ring_sel_config_wcn7850, + .get_ring_selector = ath12k_hw_get_ring_selector_wcn7850, + .dp_srng_is_tx_comp_ring = ath12k_dp_srng_is_comp_ring_wcn7850, +}; + +#define ATH12K_TX_RING_MASK_0 0x1 +#define ATH12K_TX_RING_MASK_1 0x2 +#define ATH12K_TX_RING_MASK_2 0x4 +#define ATH12K_TX_RING_MASK_3 0x8 +#define ATH12K_TX_RING_MASK_4 0x10 + +#define ATH12K_RX_RING_MASK_0 0x1 +#define ATH12K_RX_RING_MASK_1 0x2 +#define ATH12K_RX_RING_MASK_2 0x4 +#define ATH12K_RX_RING_MASK_3 0x8 + +#define ATH12K_RX_ERR_RING_MASK_0 0x1 + +#define ATH12K_RX_WBM_REL_RING_MASK_0 0x1 + +#define ATH12K_REO_STATUS_RING_MASK_0 0x1 + +#define ATH12K_HOST2RXDMA_RING_MASK_0 0x1 + +#define ATH12K_RX_MON_RING_MASK_0 0x1 +#define ATH12K_RX_MON_RING_MASK_1 0x2 +#define ATH12K_RX_MON_RING_MASK_2 0x4 + +#define ATH12K_TX_MON_RING_MASK_0 0x1 +#define ATH12K_TX_MON_RING_MASK_1 0x2 + +/* Target firmware's Copy Engine configuration. */ +static const struct ce_pipe_config ath12k_target_ce_config_wlan_qcn9274[] = { +/* CE0: host->target HTC control and raw streams */ + { + .pipenum =__cpu_to_le32 (0 ), + .pipedir =__cpu_to_le32 (PIPEDIR_OUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE1: target->host HTT + HTC control */ + { + .pipenum =__cpu_to_le32 (1 ), + .pipedir =__cpu_to_le32 (PIPEDIR_IN ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE2: target->host WMI */ + { + .pipenum =__cpu_to_le32 (2 ), + .pipedir =__cpu_to_le32 (PIPEDIR_IN ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE3: host->target WMI (mac0) */ + { + .pipenum =__cpu_to_le32 (3 ), + .pipedir =__cpu_to_le32 (PIPEDIR_OUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE4: host->target HTT */ + { + .pipenum =__cpu_to_le32 (4 ), + .pipedir =__cpu_to_le32 (PIPEDIR_OUT ), + .nentries =__cpu_to_le32 (256 ), + .nbytes_max =__cpu_to_le32 (256 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS |CE_ATTR_DIS_INTR ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE5: target->host Pktlog */ + { + .pipenum =__cpu_to_le32 (5 ), + .pipedir =__cpu_to_le32 (PIPEDIR_IN ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE6: Reserved for target autonomous hif_memcpy */ + { + .pipenum =__cpu_to_le32 (6 ), + .pipedir =__cpu_to_le32 (PIPEDIR_INOUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (16384 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE7: host->target WMI (mac1) */ + { + .pipenum =__cpu_to_le32 (7 ), + .pipedir =__cpu_to_le32 (PIPEDIR_OUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE8: Reserved for target autonomous hif_memcpy */ + { + .pipenum =__cpu_to_le32 (8 ), + .pipedir =__cpu_to_le32 (PIPEDIR_INOUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (16384 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE9, 10 and 11: Reserved for MHI */ + +/* CE12: Target CV prefetch */ + { + .pipenum =__cpu_to_le32 (12 ), + .pipedir =__cpu_to_le32 (PIPEDIR_OUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE13: Target CV prefetch */ + { + .pipenum =__cpu_to_le32 (13 ), + .pipedir =__cpu_to_le32 (PIPEDIR_OUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE14: WMI logging/CFR/Spectral/Radar */ + { + .pipenum =__cpu_to_le32 (14 ), + .pipedir =__cpu_to_le32 (PIPEDIR_IN ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE15: Reserved */ +}; + +/* Target firmware's Copy Engine configuration. */ +static const struct ce_pipe_config ath12k_target_ce_config_wlan_wcn7850[] = { +/* CE0: host->target HTC control and raw streams */ + { + .pipenum =__cpu_to_le32 (0 ), + .pipedir =__cpu_to_le32 (PIPEDIR_OUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE1: target->host HTT + HTC control */ + { + .pipenum =__cpu_to_le32 (1 ), + .pipedir =__cpu_to_le32 (PIPEDIR_IN ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE2: target->host WMI */ + { + .pipenum =__cpu_to_le32 (2 ), + .pipedir =__cpu_to_le32 (PIPEDIR_IN ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE3: host->target WMI */ + { + .pipenum =__cpu_to_le32 (3 ), + .pipedir =__cpu_to_le32 (PIPEDIR_OUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE4: host->target HTT */ + { + .pipenum =__cpu_to_le32 (4 ), + .pipedir =__cpu_to_le32 (PIPEDIR_OUT ), + .nentries =__cpu_to_le32 (256 ), + .nbytes_max =__cpu_to_le32 (256 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS |CE_ATTR_DIS_INTR ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE5: target->host Pktlog */ + { + .pipenum =__cpu_to_le32 (5 ), + .pipedir =__cpu_to_le32 (PIPEDIR_IN ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (2048 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE6: Reserved for target autonomous hif_memcpy */ + { + .pipenum =__cpu_to_le32 (6 ), + .pipedir =__cpu_to_le32 (PIPEDIR_INOUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (16384 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE7 used only by Host */ + { + .pipenum =__cpu_to_le32 (7 ), + .pipedir =__cpu_to_le32 (PIPEDIR_INOUT_H2H ), + .nentries =__cpu_to_le32 (0 ), + .nbytes_max =__cpu_to_le32 (0 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS |CE_ATTR_DIS_INTR ), + .reserved =__cpu_to_le32 (0 ), + }, + +/* CE8 target->host used only by IPA */ + { + .pipenum =__cpu_to_le32 (8 ), + .pipedir =__cpu_to_le32 (PIPEDIR_INOUT ), + .nentries =__cpu_to_le32 (32 ), + .nbytes_max =__cpu_to_le32 (16384 ), + .flags =__cpu_to_le32 (CE_ATTR_FLAGS ), + .reserved =__cpu_to_le32 (0 ), + }, +/* CE 9, 10, 11 are used by MHI driver */ +}; + +/* Map from service/endpoint to Copy Engine. +* This table is derived from the CE_PCI TABLE, above. +* It is passed to the Target at startup for use by firmware. +*/ +static const struct service_to_pipe ath12k_target_service_to_ce_map_wlan_qcn9274[] = { + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_VO ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_VO ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_BK ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_BK ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_BE ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_BE ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_VI ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_VI ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_CONTROL ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_CONTROL ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_RSVD_CTRL ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (0 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_RSVD_CTRL ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (1 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_TEST_RAW_STREAMS ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (0 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_TEST_RAW_STREAMS ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (1 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_HTT_DATA_MSG ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (4 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_HTT_DATA_MSG ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (1 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC1 ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (7 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_CONTROL_MAC1 ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_PKT_LOG ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (5 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_CONTROL_DIAG ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (14 ), + }, + +/* (Additions here) */ + + {/* must be last */ +__cpu_to_le32 (0 ), +__cpu_to_le32 (0 ), +__cpu_to_le32 (0 ), + }, +}; + +static const struct service_to_pipe ath12k_target_service_to_ce_map_wlan_wcn7850[] = { + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_VO ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_VO ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_BK ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_BK ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_BE ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_BE ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_VI ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_DATA_VI ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_CONTROL ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (3 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_WMI_CONTROL ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_RSVD_CTRL ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (0 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_RSVD_CTRL ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (2 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_HTT_DATA_MSG ), +__cpu_to_le32 (PIPEDIR_OUT ),/* out = UL = host -> target */ +__cpu_to_le32 (4 ), + }, + { +__cpu_to_le32 (ATH12K_HTC_SVC_ID_HTT_DATA_MSG ), +__cpu_to_le32 (PIPEDIR_IN ),/* in = DL = target -> host */ +__cpu_to_le32 (1 ), + }, + +/* (Additions here) */ + + {/* must be last */ +__cpu_to_le32 (0 ), +__cpu_to_le32 (0 ), +__cpu_to_le32 (0 ), + }, +}; + +static const struct ath12k_hw_ring_mask ath12k_hw_ring_mask_qcn9274 = { + .tx = { +ATH12K_TX_RING_MASK_0 , +ATH12K_TX_RING_MASK_1 , +ATH12K_TX_RING_MASK_2 , +ATH12K_TX_RING_MASK_3 , + }, + .rx_mon_dest = { +0 ,0 ,0 , +ATH12K_RX_MON_RING_MASK_0 , +ATH12K_RX_MON_RING_MASK_1 , +ATH12K_RX_MON_RING_MASK_2 , + }, + .rx = { +0 ,0 ,0 ,0 , +ATH12K_RX_RING_MASK_0 , +ATH12K_RX_RING_MASK_1 , +ATH12K_RX_RING_MASK_2 , +ATH12K_RX_RING_MASK_3 , + }, + .rx_err = { +0 ,0 ,0 , +ATH12K_RX_ERR_RING_MASK_0 , + }, + .rx_wbm_rel = { +0 ,0 ,0 , +ATH12K_RX_WBM_REL_RING_MASK_0 , + }, + .reo_status = { +0 ,0 ,0 , +ATH12K_REO_STATUS_RING_MASK_0 , + }, + .host2rxdma = { +0 ,0 ,0 , +ATH12K_HOST2RXDMA_RING_MASK_0 , + }, + .tx_mon_dest = { +ATH12K_TX_MON_RING_MASK_0 , +ATH12K_TX_MON_RING_MASK_1 , + }, +}; + +static const struct ath12k_hw_ring_mask ath12k_hw_ring_mask_wcn7850 = { + .tx = { +ATH12K_TX_RING_MASK_0 , +ATH12K_TX_RING_MASK_2 , +ATH12K_TX_RING_MASK_4 , + }, + .rx_mon_dest = { + }, + .rx = { +0 ,0 ,0 , +ATH12K_RX_RING_MASK_0 , +ATH12K_RX_RING_MASK_1 , +ATH12K_RX_RING_MASK_2 , +ATH12K_RX_RING_MASK_3 , + }, + .rx_err = { +ATH12K_RX_ERR_RING_MASK_0 , + }, + .rx_wbm_rel = { +ATH12K_RX_WBM_REL_RING_MASK_0 , + }, + .reo_status = { +ATH12K_REO_STATUS_RING_MASK_0 , + }, + .host2rxdma = { + }, + .tx_mon_dest = { + }, +}; + +static const struct ath12k_hw_regs qcn9274_v1_regs = { +/* SW2TCL(x) R0 ring configuration address */ + .hal_tcl1_ring_id =0x00000908 , + .hal_tcl1_ring_misc =0x00000910 , + .hal_tcl1_ring_tp_addr_lsb =0x0000091c , + .hal_tcl1_ring_tp_addr_msb =0x00000920 , + .hal_tcl1_ring_consumer_int_setup_ix0 =0x00000930 , + .hal_tcl1_ring_consumer_int_setup_ix1 =0x00000934 , + .hal_tcl1_ring_msi1_base_lsb =0x00000948 , + .hal_tcl1_ring_msi1_base_msb =0x0000094c , + .hal_tcl1_ring_msi1_data =0x00000950 , + .hal_tcl_ring_base_lsb =0x00000b58 , + +/* TCL STATUS ring address */ + .hal_tcl_status_ring_base_lsb =0x00000d38 , + + .hal_wbm_idle_ring_base_lsb =0x00000d0c , + .hal_wbm_idle_ring_misc_addr =0x00000d1c , + .hal_wbm_r0_idle_list_cntl_addr =0x00000210 , + .hal_wbm_r0_idle_list_size_addr =0x00000214 , + .hal_wbm_scattered_ring_base_lsb =0x00000220 , + .hal_wbm_scattered_ring_base_msb =0x00000224 , + .hal_wbm_scattered_desc_head_info_ix0 =0x00000230 , + .hal_wbm_scattered_desc_head_info_ix1 =0x00000234 , + .hal_wbm_scattered_desc_tail_info_ix0 =0x00000240 , + .hal_wbm_scattered_desc_tail_info_ix1 =0x00000244 , + .hal_wbm_scattered_desc_ptr_hp_addr =0x0000024c , + + .hal_wbm_sw_release_ring_base_lsb =0x0000034c , + .hal_wbm_sw1_release_ring_base_lsb =0x000003c4 , + .hal_wbm0_release_ring_base_lsb =0x00000dd8 , + .hal_wbm1_release_ring_base_lsb =0x00000e50 , + +/* PCIe base address */ + .pcie_qserdes_sysclk_en_sel =0x01e0c0a8 , + .pcie_pcs_osc_dtct_config_base =0x01e0d45c , + +/* PPE release ring address */ + .hal_ppe_rel_ring_base =0x0000043c , + +/* REO DEST ring address */ + .hal_reo2_ring_base =0x0000055c , + .hal_reo1_misc_ctrl_addr =0x00000b7c , + .hal_reo1_sw_cookie_cfg0 =0x00000050 , + .hal_reo1_sw_cookie_cfg1 =0x00000054 , + .hal_reo1_qdesc_lut_base0 =0x00000058 , + .hal_reo1_qdesc_lut_base1 =0x0000005c , + .hal_reo1_ring_base_lsb =0x000004e4 , + .hal_reo1_ring_base_msb =0x000004e8 , + .hal_reo1_ring_id =0x000004ec , + .hal_reo1_ring_misc =0x000004f4 , + .hal_reo1_ring_hp_addr_lsb =0x000004f8 , + .hal_reo1_ring_hp_addr_msb =0x000004fc , + .hal_reo1_ring_producer_int_setup =0x00000508 , + .hal_reo1_ring_msi1_base_lsb =0x0000052C , + .hal_reo1_ring_msi1_base_msb =0x00000530 , + .hal_reo1_ring_msi1_data =0x00000534 , + .hal_reo1_aging_thres_ix0 =0x00000b08 , + .hal_reo1_aging_thres_ix1 =0x00000b0c , + .hal_reo1_aging_thres_ix2 =0x00000b10 , + .hal_reo1_aging_thres_ix3 =0x00000b14 , + +/* REO Exception ring address */ + .hal_reo2_sw0_ring_base =0x000008a4 , + +/* REO Reinject ring address */ + .hal_sw2reo_ring_base =0x00000304 , + .hal_sw2reo1_ring_base =0x0000037c , + +/* REO cmd ring address */ + .hal_reo_cmd_ring_base =0x0000028c , + +/* REO status ring address */ + .hal_reo_status_ring_base =0x00000a84 , +}; + +static const struct ath12k_hw_regs qcn9274_v2_regs = { +/* SW2TCL(x) R0 ring configuration address */ + .hal_tcl1_ring_id =0x00000908 , + .hal_tcl1_ring_misc =0x00000910 , + .hal_tcl1_ring_tp_addr_lsb =0x0000091c , + .hal_tcl1_ring_tp_addr_msb =0x00000920 , + .hal_tcl1_ring_consumer_int_setup_ix0 =0x00000930 , + .hal_tcl1_ring_consumer_int_setup_ix1 =0x00000934 , + .hal_tcl1_ring_msi1_base_lsb =0x00000948 , + .hal_tcl1_ring_msi1_base_msb =0x0000094c , + .hal_tcl1_ring_msi1_data =0x00000950 , + .hal_tcl_ring_base_lsb =0x00000b58 , + +/* TCL STATUS ring address */ + .hal_tcl_status_ring_base_lsb =0x00000d38 , + +/* WBM idle link ring address */ + .hal_wbm_idle_ring_base_lsb =0x00000d3c , + .hal_wbm_idle_ring_misc_addr =0x00000d4c , + .hal_wbm_r0_idle_list_cntl_addr =0x00000240 , + .hal_wbm_r0_idle_list_size_addr =0x00000244 , + .hal_wbm_scattered_ring_base_lsb =0x00000250 , + .hal_wbm_scattered_ring_base_msb =0x00000254 , + .hal_wbm_scattered_desc_head_info_ix0 =0x00000260 , + .hal_wbm_scattered_desc_head_info_ix1 =0x00000264 , + .hal_wbm_scattered_desc_tail_info_ix0 =0x00000270 , + .hal_wbm_scattered_desc_tail_info_ix1 =0x00000274 , + .hal_wbm_scattered_desc_ptr_hp_addr =0x0000027c , + +/* SW2WBM release ring address */ + .hal_wbm_sw_release_ring_base_lsb =0x0000037c , + .hal_wbm_sw1_release_ring_base_lsb =0x000003f4 , + +/* WBM2SW release ring address */ + .hal_wbm0_release_ring_base_lsb =0x00000e08 , + .hal_wbm1_release_ring_base_lsb =0x00000e80 , + +/* PCIe base address */ + .pcie_qserdes_sysclk_en_sel =0x01e0c0a8 , + .pcie_pcs_osc_dtct_config_base =0x01e0d45c , + +/* PPE release ring address */ + .hal_ppe_rel_ring_base =0x0000046c , + +/* REO DEST ring address */ + .hal_reo2_ring_base =0x00000578 , + .hal_reo1_misc_ctrl_addr =0x00000b9c , + .hal_reo1_sw_cookie_cfg0 =0x0000006c , + .hal_reo1_sw_cookie_cfg1 =0x00000070 , + .hal_reo1_qdesc_lut_base0 =0x00000074 , + .hal_reo1_qdesc_lut_base1 =0x00000078 , + .hal_reo1_ring_base_lsb =0x00000500 , + .hal_reo1_ring_base_msb =0x00000504 , + .hal_reo1_ring_id =0x00000508 , + .hal_reo1_ring_misc =0x00000510 , + .hal_reo1_ring_hp_addr_lsb =0x00000514 , + .hal_reo1_ring_hp_addr_msb =0x00000518 , + .hal_reo1_ring_producer_int_setup =0x00000524 , + .hal_reo1_ring_msi1_base_lsb =0x00000548 , + .hal_reo1_ring_msi1_base_msb =0x0000054C , + .hal_reo1_ring_msi1_data =0x00000550 , + .hal_reo1_aging_thres_ix0 =0x00000B28 , + .hal_reo1_aging_thres_ix1 =0x00000B2C , + .hal_reo1_aging_thres_ix2 =0x00000B30 , + .hal_reo1_aging_thres_ix3 =0x00000B34 , + +/* REO Exception ring address */ + .hal_reo2_sw0_ring_base =0x000008c0 , + +/* REO Reinject ring address */ + .hal_sw2reo_ring_base =0x00000320 , + .hal_sw2reo1_ring_base =0x00000398 , + +/* REO cmd ring address */ + .hal_reo_cmd_ring_base =0x000002A8 , + +/* REO status ring address */ + .hal_reo_status_ring_base =0x00000aa0 , +}; + +static const struct ath12k_hw_regs wcn7850_regs = { +/* SW2TCL(x) R0 ring configuration address */ + .hal_tcl1_ring_id =0x00000908 , + .hal_tcl1_ring_misc =0x00000910 , + .hal_tcl1_ring_tp_addr_lsb =0x0000091c , + .hal_tcl1_ring_tp_addr_msb =0x00000920 , + .hal_tcl1_ring_consumer_int_setup_ix0 =0x00000930 , + .hal_tcl1_ring_consumer_int_setup_ix1 =0x00000934 , + .hal_tcl1_ring_msi1_base_lsb =0x00000948 , + .hal_tcl1_ring_msi1_base_msb =0x0000094c , + .hal_tcl1_ring_msi1_data =0x00000950 , + .hal_tcl_ring_base_lsb =0x00000b58 , + +/* TCL STATUS ring address */ + .hal_tcl_status_ring_base_lsb =0x00000d38 , + + .hal_wbm_idle_ring_base_lsb =0x00000d3c , + .hal_wbm_idle_ring_misc_addr =0x00000d4c , + .hal_wbm_r0_idle_list_cntl_addr =0x00000240 , + .hal_wbm_r0_idle_list_size_addr =0x00000244 , + .hal_wbm_scattered_ring_base_lsb =0x00000250 , + .hal_wbm_scattered_ring_base_msb =0x00000254 , + .hal_wbm_scattered_desc_head_info_ix0 =0x00000260 , + .hal_wbm_scattered_desc_head_info_ix1 =0x00000264 , + .hal_wbm_scattered_desc_tail_info_ix0 =0x00000270 , + .hal_wbm_scattered_desc_tail_info_ix1 =0x00000274 , + .hal_wbm_scattered_desc_ptr_hp_addr =0x00000027c , + + .hal_wbm_sw_release_ring_base_lsb =0x0000037c , + .hal_wbm_sw1_release_ring_base_lsb =0x00000284 , + .hal_wbm0_release_ring_base_lsb =0x00000e08 , + .hal_wbm1_release_ring_base_lsb =0x00000e80 , + +/* PCIe base address */ + .pcie_qserdes_sysclk_en_sel =0x01e0e0a8 , + .pcie_pcs_osc_dtct_config_base =0x01e0f45c , + +/* PPE release ring address */ + .hal_ppe_rel_ring_base =0x0000043c , + +/* REO DEST ring address */ + .hal_reo2_ring_base =0x0000055c , + .hal_reo1_misc_ctrl_addr =0x00000b7c , + .hal_reo1_sw_cookie_cfg0 =0x00000050 , + .hal_reo1_sw_cookie_cfg1 =0x00000054 , + .hal_reo1_qdesc_lut_base0 =0x00000058 , + .hal_reo1_qdesc_lut_base1 =0x0000005c , + .hal_reo1_ring_base_lsb =0x000004e4 , + .hal_reo1_ring_base_msb =0x000004e8 , + .hal_reo1_ring_id =0x000004ec , + .hal_reo1_ring_misc =0x000004f4 , + .hal_reo1_ring_hp_addr_lsb =0x000004f8 , + .hal_reo1_ring_hp_addr_msb =0x000004fc , + .hal_reo1_ring_producer_int_setup =0x00000508 , + .hal_reo1_ring_msi1_base_lsb =0x0000052C , + .hal_reo1_ring_msi1_base_msb =0x00000530 , + .hal_reo1_ring_msi1_data =0x00000534 , + .hal_reo1_aging_thres_ix0 =0x00000b08 , + .hal_reo1_aging_thres_ix1 =0x00000b0c , + .hal_reo1_aging_thres_ix2 =0x00000b10 , + .hal_reo1_aging_thres_ix3 =0x00000b14 , + +/* REO Exception ring address */ + .hal_reo2_sw0_ring_base =0x000008a4 , + +/* REO Reinject ring address */ + .hal_sw2reo_ring_base =0x00000304 , + .hal_sw2reo1_ring_base =0x0000037c , + +/* REO cmd ring address */ + .hal_reo_cmd_ring_base =0x0000028c , + +/* REO status ring address */ + .hal_reo_status_ring_base =0x00000a84 , +}; + +static const struct ath12k_hw_hal_params ath12k_hw_hal_params_qcn9274 = { + .rx_buf_rbm =HAL_RX_BUF_RBM_SW3_BM , + .wbm2sw_cc_enable =HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW0_EN | +HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW1_EN | +HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW2_EN | +HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW3_EN | +HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW4_EN , +}; + +static const struct ath12k_hw_hal_params ath12k_hw_hal_params_wcn7850 = { + .rx_buf_rbm =HAL_RX_BUF_RBM_SW1_BM , + .wbm2sw_cc_enable =HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW0_EN | +HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW2_EN | +HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW3_EN | +HAL_WBM_SW_COOKIE_CONV_CFG_WBM2SW4_EN , +}; + +static const struct ath12k_hw_params ath12k_hw_params[] = { + { + .name ="qcn9274 hw1.0" , + .hw_rev =ATH12K_HW_QCN9274_HW10 , + .fw = { + .dir ="QCN9274/hw1.0" , + .board_size =256 *1024 , + .cal_offset =128 *1024 , + }, + .max_radios =1 , + .single_pdev_only = false, + .qmi_service_ins_id =ATH12K_QMI_WLFW_SERVICE_INS_ID_V01_QCN9274 , + .internal_sleep_clock = false, + + .hw_ops = &qcn9274_ops, + .ring_mask = &ath12k_hw_ring_mask_qcn9274, + .regs = &qcn9274_v1_regs, + + .host_ce_config = ath12k_host_ce_config_qcn9274, + .ce_count =16 , + .target_ce_config = ath12k_target_ce_config_wlan_qcn9274, + .target_ce_count =12 , + .svc_to_ce_map = ath12k_target_service_to_ce_map_wlan_qcn9274, + .svc_to_ce_map_len =18 , + + .hal_params = &ath12k_hw_hal_params_qcn9274, + + .rxdma1_enable = false, + .num_rxmda_per_pdev =1 , + .num_rxdma_dst_ring =0 , + .rx_mac_buf_ring = false, + .vdev_start_delay = false, + + .interface_modes =BIT (NL80211_IFTYPE_STATION ) | +BIT (NL80211_IFTYPE_AP ), + .supports_monitor = false, + + .idle_ps = false, + .download_calib = true, + .supports_suspend = false, + .tcl_ring_retry = true, + .reoq_lut_support = false, + .supports_shadow_regs = false, + + .hal_desc_sz =sizeof (struct hal_rx_desc_qcn9274 ), + .num_tcl_banks =48 , + .max_tx_ring =4 , + + .mhi_config = &ath12k_mhi_config_qcn9274, + + .wmi_init = ath12k_wmi_init_qcn9274, + + .hal_ops = &hal_qcn9274_ops, + + }, + { + .name ="wcn7850 hw2.0" , + .hw_rev =ATH12K_HW_WCN7850_HW20 , + + .fw = { + .dir ="WCN7850/hw2.0" , + .board_size =256 *1024 , + .cal_offset =256 *1024 , + }, + + .max_radios =1 , + .single_pdev_only = true, + .qmi_service_ins_id =ATH12K_QMI_WLFW_SERVICE_INS_ID_V01_WCN7850 , + .internal_sleep_clock = true, + + .hw_ops = &wcn7850_ops, + .ring_mask = &ath12k_hw_ring_mask_wcn7850, + .regs = &wcn7850_regs, + + .host_ce_config = ath12k_host_ce_config_wcn7850, + .ce_count =9 , + .target_ce_config = ath12k_target_ce_config_wlan_wcn7850, + .target_ce_count =9 , + .svc_to_ce_map = ath12k_target_service_to_ce_map_wlan_wcn7850, + .svc_to_ce_map_len =14 , + + .hal_params = &ath12k_hw_hal_params_wcn7850, + + .rxdma1_enable = false, + .num_rxmda_per_pdev =2 , + .num_rxdma_dst_ring =1 , + .rx_mac_buf_ring = true, + .vdev_start_delay = true, + + .interface_modes =BIT (NL80211_IFTYPE_STATION ), + .supports_monitor = false, + + .idle_ps = false, + .download_calib = false, + .supports_suspend = false, + .tcl_ring_retry = false, + .reoq_lut_support = false, + .supports_shadow_regs = true, + + .hal_desc_sz =sizeof (struct hal_rx_desc_wcn7850 ), + .num_tcl_banks =7 , + .max_tx_ring =3 , + + .mhi_config = &ath12k_mhi_config_wcn7850, + + .wmi_init = ath12k_wmi_init_wcn7850, + + .hal_ops = &hal_wcn7850_ops, + }, + { + .name ="qcn9274 hw2.0" , + .hw_rev =ATH12K_HW_QCN9274_HW20 , + .fw = { + .dir ="QCN9274/hw2.0" , + .board_size =256 *1024 , + .cal_offset =128 *1024 , + }, + .max_radios =1 , + .single_pdev_only = false, + .qmi_service_ins_id =ATH12K_QMI_WLFW_SERVICE_INS_ID_V01_QCN9274 , + .internal_sleep_clock = false, + + .hw_ops = &qcn9274_ops, + .ring_mask = &ath12k_hw_ring_mask_qcn9274, + .regs = &qcn9274_v2_regs, + + .host_ce_config = ath12k_host_ce_config_qcn9274, + .ce_count =16 , + .target_ce_config = ath12k_target_ce_config_wlan_qcn9274, + .target_ce_count =12 , + .svc_to_ce_map = ath12k_target_service_to_ce_map_wlan_qcn9274, + .svc_to_ce_map_len =18 , + + .hal_params = &ath12k_hw_hal_params_qcn9274, + + .rxdma1_enable = false, + .num_rxmda_per_pdev =1 , + .num_rxdma_dst_ring =0 , + .rx_mac_buf_ring = false, + .vdev_start_delay = false, + + .interface_modes =BIT (NL80211_IFTYPE_STATION ) | +BIT (NL80211_IFTYPE_AP ), + .supports_monitor = false, + + .idle_ps = false, + .download_calib = true, + .supports_suspend = false, + .tcl_ring_retry = true, + .reoq_lut_support = false, + .supports_shadow_regs = false, + + .hal_desc_sz =sizeof (struct hal_rx_desc_qcn9274 ), + .num_tcl_banks =48 , + .max_tx_ring =4 , + + .mhi_config = &ath12k_mhi_config_qcn9274, + + .wmi_init = ath12k_wmi_init_qcn9274, + + .hal_ops = &hal_qcn9274_ops, + }, +}; + +int ath12k_hw_init (struct ath12k_base *ab) +{ +const struct ath12k_hw_params *hw_params =NULL ; +int i; + +for (i =0 ; i <ARRAY_SIZE (ath12k_hw_params); i++) { + hw_params = &ath12k_hw_params[i]; + +if (hw_params->hw_rev == ab->hw_rev) +break ; + } + +if (i ==ARRAY_SIZE (ath12k_hw_params)) { +ath12k_err (ab,"Unsupported hardware version: 0x%x\n" , ab->hw_rev); +return -EINVAL ; + } + + ab->hw_params = hw_params; + +ath12k_info (ab,"Hardware name: %s\n" , ab->hw_params->name); + +return 0 ; +}
Signature · 3 lines
ath12k mailing list [email protected] https://lists.infradead.org/mailman/listinfo/ath12k
PATCH v2 30/50 wifi: ath12k: add hw.h
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/hw.h | 312 +++++++++++++++++++++++++++++++++++ 1 file changed, 312 insertions(+)
drivers/net/wireless/ath/ath12k/hw.h new file +312 -0
@@ -0,0 +1,312 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#ifndef ATH12K_HW_H +#define ATH12K_HW_H + +#include <linux/mhi.h> + +#include "wmi.h" +#include "hal.h" + +/* Target configuration defines */ + +/* Num VDEVS per radio */ +#define TARGET_NUM_VDEVS (16 + 1) + +#define TARGET_NUM_PEERS_PDEV (512 + TARGET_NUM_VDEVS) + +/* Num of peers for Single Radio mode */ +#define TARGET_NUM_PEERS_SINGLE (TARGET_NUM_PEERS_PDEV) + +/* Num of peers for DBS */ +#define TARGET_NUM_PEERS_DBS (2 * TARGET_NUM_PEERS_PDEV) + +/* Num of peers for DBS_SBS */ +#define TARGET_NUM_PEERS_DBS_SBS (3 * TARGET_NUM_PEERS_PDEV) + +/* Max num of stations (per radio) */ +#define TARGET_NUM_STATIONS 512 + +#define TARGET_NUM_PEERS (x) TARGET_NUM_PEERS_##x +#define TARGET_NUM_PEER_KEYS 2 +#define TARGET_NUM_TIDS (x) (2 * TARGET_NUM_PEERS(x) + \ + 4 * TARGET_NUM_VDEVS + 8) + +#define TARGET_AST_SKID_LIMIT 16 +#define TARGET_NUM_OFFLD_PEERS 4 +#define TARGET_NUM_OFFLD_REORDER_BUFFS 4 + +#define TARGET_TX_CHAIN_MASK (BIT(0) | BIT(1) | BIT(2) | BIT(4)) +#define TARGET_RX_CHAIN_MASK (BIT(0) | BIT(1) | BIT(2) | BIT(4)) +#define TARGET_RX_TIMEOUT_LO_PRI 100 +#define TARGET_RX_TIMEOUT_HI_PRI 40 + +#define TARGET_DECAP_MODE_RAW 0 +#define TARGET_DECAP_MODE_NATIVE_WIFI 1 +#define TARGET_DECAP_MODE_ETH 2 + +#define TARGET_SCAN_MAX_PENDING_REQS 4 +#define TARGET_BMISS_OFFLOAD_MAX_VDEV 3 +#define TARGET_ROAM_OFFLOAD_MAX_VDEV 3 +#define TARGET_ROAM_OFFLOAD_MAX_AP_PROFILES 8 +#define TARGET_GTK_OFFLOAD_MAX_VDEV 3 +#define TARGET_NUM_MCAST_GROUPS 12 +#define TARGET_NUM_MCAST_TABLE_ELEMS 64 +#define TARGET_MCAST2UCAST_MODE 2 +#define TARGET_TX_DBG_LOG_SIZE 1024 +#define TARGET_RX_SKIP_DEFRAG_TIMEOUT_DUP_DETECTION_CHECK 1 +#define TARGET_VOW_CONFIG 0 +#define TARGET_NUM_MSDU_DESC (2500) +#define TARGET_MAX_FRAG_ENTRIES 6 +#define TARGET_MAX_BCN_OFFLD 16 +#define TARGET_NUM_WDS_ENTRIES 32 +#define TARGET_DMA_BURST_SIZE 1 +#define TARGET_RX_BATCHMODE 1 + +#define ATH12K_HW_MAX_QUEUES 4 +#define ATH12K_QUEUE_LEN 4096 + +#define ATH12K_HW_RATECODE_CCK_SHORT_PREAM_MASK 0x4 + +#define ATH12K_FW_DIR "ath12k" + +#define ATH12K_BOARD_MAGIC "QCA-ATH12K-BOARD" +#define ATH12K_BOARD_API2_FILE "board-2.bin" +#define ATH12K_DEFAULT_BOARD_FILE "board.bin" +#define ATH12K_DEFAULT_CAL_FILE "caldata.bin" +#define ATH12K_AMSS_FILE "amss.bin" +#define ATH12K_M3_FILE "m3.bin" +#define ATH12K_REGDB_FILE_NAME "regdb.bin" + +enum ath12k_hw_rate_cck { +ATH12K_HW_RATE_CCK_LP_11M =0 , +ATH12K_HW_RATE_CCK_LP_5_5M , +ATH12K_HW_RATE_CCK_LP_2M , +ATH12K_HW_RATE_CCK_LP_1M , +ATH12K_HW_RATE_CCK_SP_11M , +ATH12K_HW_RATE_CCK_SP_5_5M , +ATH12K_HW_RATE_CCK_SP_2M , +}; + +enum ath12k_hw_rate_ofdm { +ATH12K_HW_RATE_OFDM_48M =0 , +ATH12K_HW_RATE_OFDM_24M , +ATH12K_HW_RATE_OFDM_12M , +ATH12K_HW_RATE_OFDM_6M , +ATH12K_HW_RATE_OFDM_54M , +ATH12K_HW_RATE_OFDM_36M , +ATH12K_HW_RATE_OFDM_18M , +ATH12K_HW_RATE_OFDM_9M , +}; + +enum ath12k_bus { +ATH12K_BUS_PCI , +}; + +#define ATH12K_EXT_IRQ_GRP_NUM_MAX 11 + +struct hal_rx_desc ; +struct hal_tcl_data_cmd ; +struct htt_rx_ring_tlv_filter ; +enum hal_encrypt_type ; + +struct ath12k_hw_ring_mask { +u8 tx[ATH12K_EXT_IRQ_GRP_NUM_MAX ]; +u8 rx_mon_dest[ATH12K_EXT_IRQ_GRP_NUM_MAX ]; +u8 rx[ATH12K_EXT_IRQ_GRP_NUM_MAX ]; +u8 rx_err[ATH12K_EXT_IRQ_GRP_NUM_MAX ]; +u8 rx_wbm_rel[ATH12K_EXT_IRQ_GRP_NUM_MAX ]; +u8 reo_status[ATH12K_EXT_IRQ_GRP_NUM_MAX ]; +u8 host2rxdma[ATH12K_EXT_IRQ_GRP_NUM_MAX ]; +u8 tx_mon_dest[ATH12K_EXT_IRQ_GRP_NUM_MAX ]; +}; + +struct ath12k_hw_hal_params { +enum hal_rx_buf_return_buf_manager rx_buf_rbm; +u32 wbm2sw_cc_enable; +}; + +struct ath12k_hw_params { +const char *name; +u16 hw_rev; + +struct { +const char *dir; +size_t board_size; +size_t cal_offset; + } fw; + +u8 max_radios; +bool single_pdev_only:1 ; +u32 qmi_service_ins_id; +bool internal_sleep_clock:1 ; + +const struct ath12k_hw_ops *hw_ops; +const struct ath12k_hw_ring_mask *ring_mask; +const struct ath12k_hw_regs *regs; + +const struct ce_attr *host_ce_config; +u32 ce_count; +const struct ce_pipe_config *target_ce_config; +u32 target_ce_count; +const struct service_to_pipe *svc_to_ce_map; +u32 svc_to_ce_map_len; + +const struct ath12k_hw_hal_params *hal_params; + +bool rxdma1_enable:1 ; +int num_rxmda_per_pdev; +int num_rxdma_dst_ring; +bool rx_mac_buf_ring:1 ; +bool vdev_start_delay:1 ; + +u16 interface_modes; +bool supports_monitor:1 ; + +bool idle_ps:1 ; +bool download_calib:1 ; +bool supports_suspend:1 ; +bool tcl_ring_retry:1 ; +bool reoq_lut_support:1 ; +bool supports_shadow_regs:1 ; + +u32 hal_desc_sz; +u32 num_tcl_banks; +u32 max_tx_ring; + +const struct mhi_controller_config *mhi_config; + +void (*wmi_init)(struct ath12k_base *ab, +struct ath12k_wmi_resource_config_arg *config); + +const struct hal_ops *hal_ops; +}; + +struct ath12k_hw_ops { +u8 (*get_hw_mac_from_pdev_id)(int pdev_id); +int (*mac_id_to_pdev_id)(const struct ath12k_hw_params *hw,int mac_id); +int (*mac_id_to_srng_id)(const struct ath12k_hw_params *hw,int mac_id); +int (*rxdma_ring_sel_config)(struct ath12k_base *ab); +u8 (*get_ring_selector)(struct sk_buff *skb); +bool (*dp_srng_is_tx_comp_ring)(int ring_num); +}; + +static inline +int ath12k_hw_get_mac_from_pdev_id (const struct ath12k_hw_params *hw, +int pdev_idx) +{ +if (hw->hw_ops->get_hw_mac_from_pdev_id) +return hw->hw_ops->get_hw_mac_from_pdev_id (pdev_idx); + +return 0 ; +} + +static inline int ath12k_hw_mac_id_to_pdev_id (const struct ath12k_hw_params *hw, +int mac_id) +{ +if (hw->hw_ops->mac_id_to_pdev_id) +return hw->hw_ops->mac_id_to_pdev_id (hw, mac_id); + +return 0 ; +} + +static inline int ath12k_hw_mac_id_to_srng_id (const struct ath12k_hw_params *hw, +int mac_id) +{ +if (hw->hw_ops->mac_id_to_srng_id) +return hw->hw_ops->mac_id_to_srng_id (hw, mac_id); + +return 0 ; +} + +struct ath12k_fw_ie { +__le32 id; +__le32 len; +u8 data[]; +}; + +enum ath12k_bd_ie_board_type { +ATH12K_BD_IE_BOARD_NAME =0 , +ATH12K_BD_IE_BOARD_DATA =1 , +}; + +enum ath12k_bd_ie_type { +/* contains sub IEs of enum ath12k_bd_ie_board_type */ +ATH12K_BD_IE_BOARD =0 , +ATH12K_BD_IE_BOARD_EXT =1 , +}; + +struct ath12k_hw_regs { +u32 hal_tcl1_ring_id; +u32 hal_tcl1_ring_misc; +u32 hal_tcl1_ring_tp_addr_lsb; +u32 hal_tcl1_ring_tp_addr_msb; +u32 hal_tcl1_ring_consumer_int_setup_ix0; +u32 hal_tcl1_ring_consumer_int_setup_ix1; +u32 hal_tcl1_ring_msi1_base_lsb; +u32 hal_tcl1_ring_msi1_base_msb; +u32 hal_tcl1_ring_msi1_data; +u32 hal_tcl_ring_base_lsb; + +u32 hal_tcl_status_ring_base_lsb; + +u32 hal_wbm_idle_ring_base_lsb; +u32 hal_wbm_idle_ring_misc_addr; +u32 hal_wbm_r0_idle_list_cntl_addr; +u32 hal_wbm_r0_idle_list_size_addr; +u32 hal_wbm_scattered_ring_base_lsb; +u32 hal_wbm_scattered_ring_base_msb; +u32 hal_wbm_scattered_desc_head_info_ix0; +u32 hal_wbm_scattered_desc_head_info_ix1; +u32 hal_wbm_scattered_desc_tail_info_ix0; +u32 hal_wbm_scattered_desc_tail_info_ix1; +u32 hal_wbm_scattered_desc_ptr_hp_addr; + +u32 hal_wbm_sw_release_ring_base_lsb; +u32 hal_wbm_sw1_release_ring_base_lsb; +u32 hal_wbm0_release_ring_base_lsb; +u32 hal_wbm1_release_ring_base_lsb; + +u32 pcie_qserdes_sysclk_en_sel; +u32 pcie_pcs_osc_dtct_config_base; + +u32 hal_ppe_rel_ring_base; + +u32 hal_reo2_ring_base; +u32 hal_reo1_misc_ctrl_addr; +u32 hal_reo1_sw_cookie_cfg0; +u32 hal_reo1_sw_cookie_cfg1; +u32 hal_reo1_qdesc_lut_base0; +u32 hal_reo1_qdesc_lut_base1; +u32 hal_reo1_ring_base_lsb; +u32 hal_reo1_ring_base_msb; +u32 hal_reo1_ring_id; +u32 hal_reo1_ring_misc; +u32 hal_reo1_ring_hp_addr_lsb; +u32 hal_reo1_ring_hp_addr_msb; +u32 hal_reo1_ring_producer_int_setup; +u32 hal_reo1_ring_msi1_base_lsb; +u32 hal_reo1_ring_msi1_base_msb; +u32 hal_reo1_ring_msi1_data; +u32 hal_reo1_aging_thres_ix0; +u32 hal_reo1_aging_thres_ix1; +u32 hal_reo1_aging_thres_ix2; +u32 hal_reo1_aging_thres_ix3; + +u32 hal_reo2_sw0_ring_base; + +u32 hal_sw2reo_ring_base; +u32 hal_sw2reo1_ring_base; + +u32 hal_reo_cmd_ring_base; + +u32 hal_reo_status_ring_base; +}; + +int ath12k_hw_init (struct ath12k_base *ab); + +#endif
PATCH v2 31/50 wifi: ath12k: add mac.c
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/mac.c | 7038 +++++++++++++++++++++++++++++++++ 1 file changed, 7038 insertions(+)
drivers/net/wireless/ath/ath12k/mac.c new file +7038 -0
@@ -0,0 +1,7038 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#include <net/mac80211.h> +#include <linux/etherdevice.h> +#include "mac.h" +#include "core.h" +#include "debug.h" +#include "wmi.h" +#include "hw.h" +#include "dp_tx.h" +#include "dp_rx.h" +#include "peer.h" + +#define CHAN2G (_channel, _freq, _flags) { \ + .band = NL80211_BAND_2GHZ, \ + .hw_value = (_channel), \ + .center_freq = (_freq), \ + .flags = (_flags), \ + .max_antenna_gain = 0, \ + .max_power = 30, \ +} + +#define CHAN5G (_channel, _freq, _flags) { \ + .band = NL80211_BAND_5GHZ, \ + .hw_value = (_channel), \ + .center_freq = (_freq), \ + .flags = (_flags), \ + .max_antenna_gain = 0, \ + .max_power = 30, \ +} + +#define CHAN6G (_channel, _freq, _flags) { \ + .band = NL80211_BAND_6GHZ, \ + .hw_value = (_channel), \ + .center_freq = (_freq), \ + .flags = (_flags), \ + .max_antenna_gain = 0, \ + .max_power = 30, \ +} + +static const struct ieee80211_channel ath12k_2ghz_channels[] = { +CHAN2G (1 ,2412 ,0 ), +CHAN2G (2 ,2417 ,0 ), +CHAN2G (3 ,2422 ,0 ), +CHAN2G (4 ,2427 ,0 ), +CHAN2G (5 ,2432 ,0 ), +CHAN2G (6 ,2437 ,0 ), +CHAN2G (7 ,2442 ,0 ), +CHAN2G (8 ,2447 ,0 ), +CHAN2G (9 ,2452 ,0 ), +CHAN2G (10 ,2457 ,0 ), +CHAN2G (11 ,2462 ,0 ), +CHAN2G (12 ,2467 ,0 ), +CHAN2G (13 ,2472 ,0 ), +CHAN2G (14 ,2484 ,0 ), +}; + +static const struct ieee80211_channel ath12k_5ghz_channels[] = { +CHAN5G (36 ,5180 ,0 ), +CHAN5G (40 ,5200 ,0 ), +CHAN5G (44 ,5220 ,0 ), +CHAN5G (48 ,5240 ,0 ), +CHAN5G (52 ,5260 ,0 ), +CHAN5G (56 ,5280 ,0 ), +CHAN5G (60 ,5300 ,0 ), +CHAN5G (64 ,5320 ,0 ), +CHAN5G (100 ,5500 ,0 ), +CHAN5G (104 ,5520 ,0 ), +CHAN5G (108 ,5540 ,0 ), +CHAN5G (112 ,5560 ,0 ), +CHAN5G (116 ,5580 ,0 ), +CHAN5G (120 ,5600 ,0 ), +CHAN5G (124 ,5620 ,0 ), +CHAN5G (128 ,5640 ,0 ), +CHAN5G (132 ,5660 ,0 ), +CHAN5G (136 ,5680 ,0 ), +CHAN5G (140 ,5700 ,0 ), +CHAN5G (144 ,5720 ,0 ), +CHAN5G (149 ,5745 ,0 ), +CHAN5G (153 ,5765 ,0 ), +CHAN5G (157 ,5785 ,0 ), +CHAN5G (161 ,5805 ,0 ), +CHAN5G (165 ,5825 ,0 ), +CHAN5G (169 ,5845 ,0 ), +CHAN5G (173 ,5865 ,0 ), +}; + +static const struct ieee80211_channel ath12k_6ghz_channels[] = { +CHAN6G (1 ,5955 ,0 ), +CHAN6G (5 ,5975 ,0 ), +CHAN6G (9 ,5995 ,0 ), +CHAN6G (13 ,6015 ,0 ), +CHAN6G (17 ,6035 ,0 ), +CHAN6G (21 ,6055 ,0 ), +CHAN6G (25 ,6075 ,0 ), +CHAN6G (29 ,6095 ,0 ), +CHAN6G (33 ,6115 ,0 ), +CHAN6G (37 ,6135 ,0 ), +CHAN6G (41 ,6155 ,0 ), +CHAN6G (45 ,6175 ,0 ), +CHAN6G (49 ,6195 ,0 ), +CHAN6G (53 ,6215 ,0 ), +CHAN6G (57 ,6235 ,0 ), +CHAN6G (61 ,6255 ,0 ), +CHAN6G (65 ,6275 ,0 ), +CHAN6G (69 ,6295 ,0 ), +CHAN6G (73 ,6315 ,0 ), +CHAN6G (77 ,6335 ,0 ), +CHAN6G (81 ,6355 ,0 ), +CHAN6G (85 ,6375 ,0 ), +CHAN6G (89 ,6395 ,0 ), +CHAN6G (93 ,6415 ,0 ), +CHAN6G (97 ,6435 ,0 ), +CHAN6G (101 ,6455 ,0 ), +CHAN6G (105 ,6475 ,0 ), +CHAN6G (109 ,6495 ,0 ), +CHAN6G (113 ,6515 ,0 ), +CHAN6G (117 ,6535 ,0 ), +CHAN6G (121 ,6555 ,0 ), +CHAN6G (125 ,6575 ,0 ), +CHAN6G (129 ,6595 ,0 ), +CHAN6G (133 ,6615 ,0 ), +CHAN6G (137 ,6635 ,0 ), +CHAN6G (141 ,6655 ,0 ), +CHAN6G (145 ,6675 ,0 ), +CHAN6G (149 ,6695 ,0 ), +CHAN6G (153 ,6715 ,0 ), +CHAN6G (157 ,6735 ,0 ), +CHAN6G (161 ,6755 ,0 ), +CHAN6G (165 ,6775 ,0 ), +CHAN6G (169 ,6795 ,0 ), +CHAN6G (173 ,6815 ,0 ), +CHAN6G (177 ,6835 ,0 ), +CHAN6G (181 ,6855 ,0 ), +CHAN6G (185 ,6875 ,0 ), +CHAN6G (189 ,6895 ,0 ), +CHAN6G (193 ,6915 ,0 ), +CHAN6G (197 ,6935 ,0 ), +CHAN6G (201 ,6955 ,0 ), +CHAN6G (205 ,6975 ,0 ), +CHAN6G (209 ,6995 ,0 ), +CHAN6G (213 ,7015 ,0 ), +CHAN6G (217 ,7035 ,0 ), +CHAN6G (221 ,7055 ,0 ), +CHAN6G (225 ,7075 ,0 ), +CHAN6G (229 ,7095 ,0 ), +CHAN6G (233 ,7115 ,0 ), +}; + +static struct ieee80211_rate ath12k_legacy_rates[] = { + { .bitrate =10 , + .hw_value =ATH12K_HW_RATE_CCK_LP_1M }, + { .bitrate =20 , + .hw_value =ATH12K_HW_RATE_CCK_LP_2M , + .hw_value_short =ATH12K_HW_RATE_CCK_SP_2M , + .flags =IEEE80211_RATE_SHORT_PREAMBLE }, + { .bitrate =55 , + .hw_value =ATH12K_HW_RATE_CCK_LP_5_5M , + .hw_value_short =ATH12K_HW_RATE_CCK_SP_5_5M , + .flags =IEEE80211_RATE_SHORT_PREAMBLE }, + { .bitrate =110 , + .hw_value =ATH12K_HW_RATE_CCK_LP_11M , + .hw_value_short =ATH12K_HW_RATE_CCK_SP_11M , + .flags =IEEE80211_RATE_SHORT_PREAMBLE }, + + { .bitrate =60 , .hw_value =ATH12K_HW_RATE_OFDM_6M }, + { .bitrate =90 , .hw_value =ATH12K_HW_RATE_OFDM_9M }, + { .bitrate =120 , .hw_value =ATH12K_HW_RATE_OFDM_12M }, + { .bitrate =180 , .hw_value =ATH12K_HW_RATE_OFDM_18M }, + { .bitrate =240 , .hw_value =ATH12K_HW_RATE_OFDM_24M }, + { .bitrate =360 , .hw_value =ATH12K_HW_RATE_OFDM_36M }, + { .bitrate =480 , .hw_value =ATH12K_HW_RATE_OFDM_48M }, + { .bitrate =540 , .hw_value =ATH12K_HW_RATE_OFDM_54M }, +}; + +static const int +ath12k_phymodes[NUM_NL80211_BANDS ][ATH12K_CHAN_WIDTH_NUM ] = { + [NL80211_BAND_2GHZ ] = { + [NL80211_CHAN_WIDTH_5 ] =MODE_UNKNOWN , + [NL80211_CHAN_WIDTH_10 ] =MODE_UNKNOWN , + [NL80211_CHAN_WIDTH_20_NOHT ] =MODE_11AX_HE20_2G , + [NL80211_CHAN_WIDTH_20 ] =MODE_11AX_HE20_2G , + [NL80211_CHAN_WIDTH_40 ] =MODE_11AX_HE40_2G , + [NL80211_CHAN_WIDTH_80 ] =MODE_11AX_HE80_2G , + [NL80211_CHAN_WIDTH_80P80 ] =MODE_UNKNOWN , + [NL80211_CHAN_WIDTH_160 ] =MODE_UNKNOWN , + }, + [NL80211_BAND_5GHZ ] = { + [NL80211_CHAN_WIDTH_5 ] =MODE_UNKNOWN , + [NL80211_CHAN_WIDTH_10 ] =MODE_UNKNOWN , + [NL80211_CHAN_WIDTH_20_NOHT ] =MODE_11AX_HE20 , + [NL80211_CHAN_WIDTH_20 ] =MODE_11AX_HE20 , + [NL80211_CHAN_WIDTH_40 ] =MODE_11AX_HE40 , + [NL80211_CHAN_WIDTH_80 ] =MODE_11AX_HE80 , + [NL80211_CHAN_WIDTH_160 ] =MODE_11AX_HE160 , + [NL80211_CHAN_WIDTH_80P80 ] =MODE_11AX_HE80_80 , + }, + [NL80211_BAND_6GHZ ] = { + [NL80211_CHAN_WIDTH_5 ] =MODE_UNKNOWN , + [NL80211_CHAN_WIDTH_10 ] =MODE_UNKNOWN , + [NL80211_CHAN_WIDTH_20_NOHT ] =MODE_11AX_HE20 , + [NL80211_CHAN_WIDTH_20 ] =MODE_11AX_HE20 , + [NL80211_CHAN_WIDTH_40 ] =MODE_11AX_HE40 , + [NL80211_CHAN_WIDTH_80 ] =MODE_11AX_HE80 , + [NL80211_CHAN_WIDTH_160 ] =MODE_11AX_HE160 , + [NL80211_CHAN_WIDTH_80P80 ] =MODE_11AX_HE80_80 , + }, + +}; + +const struct htt_rx_ring_tlv_filter ath12k_mac_mon_status_filter_default = { + .rx_filter =HTT_RX_FILTER_TLV_FLAGS_MPDU_START | +HTT_RX_FILTER_TLV_FLAGS_PPDU_END | +HTT_RX_FILTER_TLV_FLAGS_PPDU_END_STATUS_DONE , + .pkt_filter_flags0 =HTT_RX_FP_MGMT_FILTER_FLAGS0 , + .pkt_filter_flags1 =HTT_RX_FP_MGMT_FILTER_FLAGS1 , + .pkt_filter_flags2 =HTT_RX_FP_CTRL_FILTER_FLASG2 , + .pkt_filter_flags3 =HTT_RX_FP_DATA_FILTER_FLASG3 | +HTT_RX_FP_CTRL_FILTER_FLASG3 +}; + +#define ATH12K_MAC_FIRST_OFDM_RATE_IDX 4 +#define ath12k_g_rates ath12k_legacy_rates +#define ath12k_g_rates_size (ARRAY_SIZE(ath12k_legacy_rates)) +#define ath12k_a_rates (ath12k_legacy_rates + 4) +#define ath12k_a_rates_size (ARRAY_SIZE(ath12k_legacy_rates) - 4) + +#define ATH12K_MAC_SCAN_TIMEOUT_MSECS 200/* in msecs */ + +static const u32 ath12k_smps_map[] = { + [WLAN_HT_CAP_SM_PS_STATIC ] =WMI_PEER_SMPS_STATIC , + [WLAN_HT_CAP_SM_PS_DYNAMIC ] =WMI_PEER_SMPS_DYNAMIC , + [WLAN_HT_CAP_SM_PS_INVALID ] =WMI_PEER_SMPS_PS_NONE , + [WLAN_HT_CAP_SM_PS_DISABLED ] =WMI_PEER_SMPS_PS_NONE , +}; + +static int ath12k_start_vdev_delay (struct ieee80211_hw *hw, +struct ieee80211_vif *vif); + +static const char *ath12k_mac_phymode_str (enum wmi_phy_mode mode) +{ +switch (mode) { +case MODE_11A : +return "11a" ; +case MODE_11G : +return "11g" ; +case MODE_11B : +return "11b" ; +case MODE_11GONLY : +return "11gonly" ; +case MODE_11NA_HT20 : +return "11na-ht20" ; +case MODE_11NG_HT20 : +return "11ng-ht20" ; +case MODE_11NA_HT40 : +return "11na-ht40" ; +case MODE_11NG_HT40 : +return "11ng-ht40" ; +case MODE_11AC_VHT20 : +return "11ac-vht20" ; +case MODE_11AC_VHT40 : +return "11ac-vht40" ; +case MODE_11AC_VHT80 : +return "11ac-vht80" ; +case MODE_11AC_VHT160 : +return "11ac-vht160" ; +case MODE_11AC_VHT80_80 : +return "11ac-vht80+80" ; +case MODE_11AC_VHT20_2G : +return "11ac-vht20-2g" ; +case MODE_11AC_VHT40_2G : +return "11ac-vht40-2g" ; +case MODE_11AC_VHT80_2G : +return "11ac-vht80-2g" ; +case MODE_11AX_HE20 : +return "11ax-he20" ; +case MODE_11AX_HE40 : +return "11ax-he40" ; +case MODE_11AX_HE80 : +return "11ax-he80" ; +case MODE_11AX_HE80_80 : +return "11ax-he80+80" ; +case MODE_11AX_HE160 : +return "11ax-he160" ; +case MODE_11AX_HE20_2G : +return "11ax-he20-2g" ; +case MODE_11AX_HE40_2G : +return "11ax-he40-2g" ; +case MODE_11AX_HE80_2G : +return "11ax-he80-2g" ; +case MODE_UNKNOWN : +/* skip */ +break ; + +/* no default handler to allow compiler to check that the +* enum is fully handled +*/ + } + +return "<unknown>" ; +} + +enum rate_info_bw +ath12k_mac_bw_to_mac80211_bw (enum ath12k_supported_bw bw) +{ +u8 ret =RATE_INFO_BW_20 ; + +switch (bw) { +case ATH12K_BW_20 : + ret =RATE_INFO_BW_20 ; +break ; +case ATH12K_BW_40 : + ret =RATE_INFO_BW_40 ; +break ; +case ATH12K_BW_80 : + ret =RATE_INFO_BW_80 ; +break ; +case ATH12K_BW_160 : + ret =RATE_INFO_BW_160 ; +break ; + } + +return ret; +} + +enum ath12k_supported_bw ath12k_mac_mac80211_bw_to_ath12k_bw (enum rate_info_bw bw) +{ +switch (bw) { +case RATE_INFO_BW_20 : +return ATH12K_BW_20 ; +case RATE_INFO_BW_40 : +return ATH12K_BW_40 ; +case RATE_INFO_BW_80 : +return ATH12K_BW_80 ; +case RATE_INFO_BW_160 : +return ATH12K_BW_160 ; +default : +return ATH12K_BW_20 ; + } +} + +int ath12k_mac_hw_ratecode_to_legacy_rate (u8 hw_rc,u8 preamble,u8 *rateidx, +u16 *rate) +{ +/* As default, it is OFDM rates */ +int i =ATH12K_MAC_FIRST_OFDM_RATE_IDX ; +int max_rates_idx = ath12k_g_rates_size; + +if (preamble ==WMI_RATE_PREAMBLE_CCK ) { + hw_rc &= ~ATH12K_HW_RATECODE_CCK_SHORT_PREAM_MASK ; + i =0 ; + max_rates_idx =ATH12K_MAC_FIRST_OFDM_RATE_IDX ; + } + +while (i < max_rates_idx) { +if (hw_rc == ath12k_legacy_rates[i].hw_value) { + *rateidx = i; + *rate = ath12k_legacy_rates[i].bitrate; +return 0 ; + } + i++; + } + +return -EINVAL ; +} + +u8 ath12k_mac_bitrate_to_idx (const struct ieee80211_supported_band *sband, +u32 bitrate) +{ +int i; + +for (i =0 ; i < sband->n_bitrates; i++) +if (sband->bitrates[i].bitrate == bitrate) +return i; + +return 0 ; +} + +static u32 +ath12k_mac_max_ht_nss (const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN ]) +{ +int nss; + +for (nss =IEEE80211_HT_MCS_MASK_LEN -1 ; nss >=0 ; nss--) +if (ht_mcs_mask[nss]) +return nss +1 ; + +return 1 ; +} + +static u32 +ath12k_mac_max_vht_nss (const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX ]) +{ +int nss; + +for (nss =NL80211_VHT_NSS_MAX -1 ; nss >=0 ; nss--) +if (vht_mcs_mask[nss]) +return nss +1 ; + +return 1 ; +} + +static u8 ath12k_parse_mpdudensity (u8 mpdudensity) +{ +/* From IEEE Std 802.11-2020 defined values for "Minimum MPDU Start Spacing": +* 0 for no restriction +* 1 for 1/4 us +* 2 for 1/2 us +* 3 for 1 us +* 4 for 2 us +* 5 for 4 us +* 6 for 8 us +* 7 for 16 us +*/ +switch (mpdudensity) { +case 0 : +return 0 ; +case 1 : +case 2 : +case 3 : +/* Our lower layer calculations limit our precision to +* 1 microsecond +*/ +return 1 ; +case 4 : +return 2 ; +case 5 : +return 4 ; +case 6 : +return 8 ; +case 7 : +return 16 ; +default : +return 0 ; + } +} + +static int ath12k_mac_vif_chan (struct ieee80211_vif *vif, +struct cfg80211_chan_def *def) +{ +struct ieee80211_chanctx_conf *conf; + +rcu_read_lock (); + conf =rcu_dereference (vif->bss_conf.chanctx_conf); +if (!conf) { +rcu_read_unlock (); +return -ENOENT ; + } + + *def = conf->def; +rcu_read_unlock (); + +return 0 ; +} + +static bool ath12k_mac_bitrate_is_cck (int bitrate) +{ +switch (bitrate) { +case 10 : +case 20 : +case 55 : +case 110 : +return true; + } + +return false; +} + +u8 ath12k_mac_hw_rate_to_idx (const struct ieee80211_supported_band *sband, +u8 hw_rate,bool cck) +{ +const struct ieee80211_rate *rate; +int i; + +for (i =0 ; i < sband->n_bitrates; i++) { + rate = &sband->bitrates[i]; + +if (ath12k_mac_bitrate_is_cck (rate->bitrate) != cck) +continue ; + +if (rate->hw_value == hw_rate) +return i; +else if (rate->flags &IEEE80211_RATE_SHORT_PREAMBLE && + rate->hw_value_short == hw_rate) +return i; + } + +return 0 ; +} + +static u8 ath12k_mac_bitrate_to_rate (int bitrate) +{ +return DIV_ROUND_UP (bitrate,5 ) | + (ath12k_mac_bitrate_is_cck (bitrate) ?BIT (7 ) :0 ); +} + +static void ath12k_get_arvif_iter (void *data,u8 *mac, +struct ieee80211_vif *vif) +{ +struct ath12k_vif_iter *arvif_iter = data; +struct ath12k_vif *arvif = (void *)vif->drv_priv; + +if (arvif->vdev_id == arvif_iter->vdev_id) + arvif_iter->arvif = arvif; +} + +struct ath12k_vif *ath12k_mac_get_arvif (struct ath12k *ar,u32 vdev_id) +{ +struct ath12k_vif_iter arvif_iter = {}; +u32 flags; + + arvif_iter.vdev_id = vdev_id; + + flags =IEEE80211_IFACE_ITER_RESUME_ALL ; +ieee80211_iterate_active_interfaces_atomic (ar->hw, + flags, + ath12k_get_arvif_iter, + &arvif_iter); +if (!arvif_iter.arvif) { +ath12k_warn (ar->ab,"No VIF found for vdev %d\n" , vdev_id); +return NULL ; + } + +return arvif_iter.arvif; +} + +struct ath12k_vif *ath12k_mac_get_arvif_by_vdev_id (struct ath12k_base *ab, +u32 vdev_id) +{ +int i; +struct ath12k_pdev *pdev; +struct ath12k_vif *arvif; + +for (i =0 ; i < ab->num_radios; i++) { + pdev =rcu_dereference (ab->pdevs_active[i]); +if (pdev && pdev->ar) { + arvif =ath12k_mac_get_arvif (pdev->ar, vdev_id); +if (arvif) +return arvif; + } + } + +return NULL ; +} + +struct ath12k *ath12k_mac_get_ar_by_vdev_id (struct ath12k_base *ab,u32 vdev_id) +{ +int i; +struct ath12k_pdev *pdev; + +for (i =0 ; i < ab->num_radios; i++) { + pdev =rcu_dereference (ab->pdevs_active[i]); +if (pdev && pdev->ar) { +if (pdev->ar->allocated_vdev_map & (1LL << vdev_id)) +return pdev->ar; + } + } + +return NULL ; +} + +struct ath12k *ath12k_mac_get_ar_by_pdev_id (struct ath12k_base *ab,u32 pdev_id) +{ +int i; +struct ath12k_pdev *pdev; + +if (ab->hw_params->single_pdev_only) { + pdev =rcu_dereference (ab->pdevs_active[0 ]); +return pdev ? pdev->ar :NULL ; + } + +if (WARN_ON (pdev_id > ab->num_radios)) +return NULL ; + +for (i =0 ; i < ab->num_radios; i++) { + pdev =rcu_dereference (ab->pdevs_active[i]); + +if (pdev && pdev->pdev_id == pdev_id) +return (pdev->ar ? pdev->ar :NULL ); + } + +return NULL ; +} + +static void ath12k_pdev_caps_update (struct ath12k *ar) +{ +struct ath12k_base *ab = ar->ab; + + ar->max_tx_power = ab->target_caps.hw_max_tx_power; + +/* FIXME: Set min_tx_power to ab->target_caps.hw_min_tx_power. +* But since the received value in svcrdy is same as hw_max_tx_power, +* we can set ar->min_tx_power to 0 currently until +* this is fixed in firmware +*/ + ar->min_tx_power =0 ; + + ar->txpower_limit_2g = ar->max_tx_power; + ar->txpower_limit_5g = ar->max_tx_power; + ar->txpower_scale =WMI_HOST_TP_SCALE_MAX ; +} + +static int ath12k_mac_txpower_recalc (struct ath12k *ar) +{ +struct ath12k_pdev *pdev = ar->pdev; +struct ath12k_vif *arvif; +int ret, txpower =-1 ; +u32 param; + +lockdep_assert_held (&ar->conf_mutex); + +list_for_each_entry (arvif, &ar->arvifs, list) { +if (arvif->txpower <=0 ) +continue ; + +if (txpower ==-1 ) + txpower = arvif->txpower; +else + txpower =min (txpower, arvif->txpower); + } + +if (txpower ==-1 ) +return 0 ; + +/* txpwr is set as 2 units per dBm in FW*/ + txpower =min_t (u32,max_t (u32, ar->min_tx_power, txpower), + ar->max_tx_power) *2 ; + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"txpower to set in hw %d\n" , + txpower /2 ); + +if ((pdev->cap.supported_bands &WMI_HOST_WLAN_2G_CAP ) && + ar->txpower_limit_2g != txpower) { + param =WMI_PDEV_PARAM_TXPOWER_LIMIT2G ; + ret =ath12k_wmi_pdev_set_param (ar, param, + txpower, ar->pdev->pdev_id); +if (ret) + goto fail; + ar->txpower_limit_2g = txpower; + } + +if ((pdev->cap.supported_bands &WMI_HOST_WLAN_5G_CAP ) && + ar->txpower_limit_5g != txpower) { + param =WMI_PDEV_PARAM_TXPOWER_LIMIT5G ; + ret =ath12k_wmi_pdev_set_param (ar, param, + txpower, ar->pdev->pdev_id); +if (ret) + goto fail; + ar->txpower_limit_5g = txpower; + } + +return 0 ; + +fail: +ath12k_warn (ar->ab,"failed to recalc txpower limit %d using pdev param %d: %d\n" , + txpower /2 , param, ret); +return ret; +} + +static int ath12k_recalc_rtscts_prot (struct ath12k_vif *arvif) +{ +struct ath12k *ar = arvif->ar; +u32 vdev_param, rts_cts; +int ret; + +lockdep_assert_held (&ar->conf_mutex); + + vdev_param =WMI_VDEV_PARAM_ENABLE_RTSCTS ; + +/* Enable RTS/CTS protection for sw retries (when legacy stations +* are in BSS) or by default only for second rate series. +* TODO: Check if we need to enable CTS 2 Self in any case +*/ + rts_cts =WMI_USE_RTS_CTS ; + +if (arvif->num_legacy_stations >0 ) + rts_cts |=WMI_RTSCTS_ACROSS_SW_RETRIES <<4 ; +else + rts_cts |=WMI_RTSCTS_FOR_SECOND_RATESERIES <<4 ; + +/* Need not send duplicate param value to firmware */ +if (arvif->rtscts_prot_mode == rts_cts) +return 0 ; + + arvif->rtscts_prot_mode = rts_cts; + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac vdev %d recalc rts/cts prot %d\n" , + arvif->vdev_id, rts_cts); + + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, + vdev_param, rts_cts); +if (ret) +ath12k_warn (ar->ab,"failed to recalculate rts/cts prot for vdev %d: %d\n" , + arvif->vdev_id, ret); + +return ret; +} + +static int ath12k_mac_set_kickout (struct ath12k_vif *arvif) +{ +struct ath12k *ar = arvif->ar; +u32 param; +int ret; + + ret =ath12k_wmi_pdev_set_param (ar,WMI_PDEV_PARAM_STA_KICKOUT_TH , +ATH12K_KICKOUT_THRESHOLD , + ar->pdev->pdev_id); +if (ret) { +ath12k_warn (ar->ab,"failed to set kickout threshold on vdev %i: %d\n" , + arvif->vdev_id, ret); +return ret; + } + + param =WMI_VDEV_PARAM_AP_KEEPALIVE_MIN_IDLE_INACTIVE_TIME_SECS ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, param, +ATH12K_KEEPALIVE_MIN_IDLE ); +if (ret) { +ath12k_warn (ar->ab,"failed to set keepalive minimum idle time on vdev %i: %d\n" , + arvif->vdev_id, ret); +return ret; + } + + param =WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_IDLE_INACTIVE_TIME_SECS ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, param, +ATH12K_KEEPALIVE_MAX_IDLE ); +if (ret) { +ath12k_warn (ar->ab,"failed to set keepalive maximum idle time on vdev %i: %d\n" , + arvif->vdev_id, ret); +return ret; + } + + param =WMI_VDEV_PARAM_AP_KEEPALIVE_MAX_UNRESPONSIVE_TIME_SECS ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, param, +ATH12K_KEEPALIVE_MAX_UNRESPONSIVE ); +if (ret) { +ath12k_warn (ar->ab,"failed to set keepalive maximum unresponsive time on vdev %i: %d\n" , + arvif->vdev_id, ret); +return ret; + } + +return 0 ; +} + +void ath12k_mac_peer_cleanup_all (struct ath12k *ar) +{ +struct ath12k_peer *peer, *tmp; +struct ath12k_base *ab = ar->ab; + +lockdep_assert_held (&ar->conf_mutex); + +spin_lock_bh (&ab->base_lock); +list_for_each_entry_safe (peer, tmp, &ab->peers, list) { +ath12k_dp_rx_peer_tid_cleanup (ar, peer); +list_del (&peer->list); +kfree (peer); + } +spin_unlock_bh (&ab->base_lock); + + ar->num_peers =0 ; + ar->num_stations =0 ; +} + +static int ath12k_mac_vdev_setup_sync (struct ath12k *ar) +{ +lockdep_assert_held (&ar->conf_mutex); + +if (test_bit (ATH12K_FLAG_CRASH_FLUSH , &ar->ab->dev_flags)) +return -ESHUTDOWN ; + +if (!wait_for_completion_timeout (&ar->vdev_setup_done, +ATH12K_VDEV_SETUP_TIMEOUT_HZ )) +return -ETIMEDOUT ; + +return ar->last_wmi_vdev_start_status ? -EINVAL :0 ; +} + +static int ath12k_monitor_vdev_up (struct ath12k *ar,int vdev_id) +{ +int ret; + + ret =ath12k_wmi_vdev_up (ar, vdev_id,0 , ar->mac_addr); +if (ret) { +ath12k_warn (ar->ab,"failed to put up monitor vdev %i: %d\n" , + vdev_id, ret); +return ret; + } + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac monitor vdev %i started\n" , + vdev_id); +return 0 ; +} + +static int ath12k_mac_monitor_vdev_start (struct ath12k *ar,int vdev_id, +struct cfg80211_chan_def *chandef) +{ +struct ieee80211_channel *channel; +struct wmi_vdev_start_req_arg arg = {}; +int ret; + +lockdep_assert_held (&ar->conf_mutex); + + channel = chandef->chan; + arg.vdev_id = vdev_id; + arg.freq = channel->center_freq; + arg.band_center_freq1 = chandef->center_freq1; + arg.band_center_freq2 = chandef->center_freq2; + arg.mode = ath12k_phymodes[chandef->chan->band][chandef->width]; + arg.chan_radar = !!(channel->flags &IEEE80211_CHAN_RADAR ); + + arg.min_power =0 ; + arg.max_power = channel->max_power; + arg.max_reg_power = channel->max_reg_power; + arg.max_antenna_gain = channel->max_antenna_gain; + + arg.pref_tx_streams = ar->num_tx_chains; + arg.pref_rx_streams = ar->num_rx_chains; + + arg.passive |= !!(chandef->chan->flags &IEEE80211_CHAN_NO_IR ); + +reinit_completion (&ar->vdev_setup_done); +reinit_completion (&ar->vdev_delete_done); + + ret =ath12k_wmi_vdev_start (ar, &arg, false); +if (ret) { +ath12k_warn (ar->ab,"failed to request monitor vdev %i start: %d\n" , + vdev_id, ret); +return ret; + } + + ret =ath12k_mac_vdev_setup_sync (ar); +if (ret) { +ath12k_warn (ar->ab,"failed to synchronize setup for monitor vdev %i start: %d\n" , + vdev_id, ret); +return ret; + } + + ret =ath12k_wmi_vdev_up (ar, vdev_id,0 , ar->mac_addr); +if (ret) { +ath12k_warn (ar->ab,"failed to put up monitor vdev %i: %d\n" , + vdev_id, ret); + goto vdev_stop; + } + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac monitor vdev %i started\n" , + vdev_id); +return 0 ; + +vdev_stop: + ret =ath12k_wmi_vdev_stop (ar, vdev_id); +if (ret) +ath12k_warn (ar->ab,"failed to stop monitor vdev %i after start failure: %d\n" , + vdev_id, ret); +return ret; +} + +static int ath12k_mac_monitor_vdev_stop (struct ath12k *ar) +{ +int ret; + +lockdep_assert_held (&ar->conf_mutex); + +reinit_completion (&ar->vdev_setup_done); + + ret =ath12k_wmi_vdev_stop (ar, ar->monitor_vdev_id); +if (ret) +ath12k_warn (ar->ab,"failed to request monitor vdev %i stop: %d\n" , + ar->monitor_vdev_id, ret); + + ret =ath12k_mac_vdev_setup_sync (ar); +if (ret) +ath12k_warn (ar->ab,"failed to synchronize monitor vdev %i stop: %d\n" , + ar->monitor_vdev_id, ret); + + ret =ath12k_wmi_vdev_down (ar, ar->monitor_vdev_id); +if (ret) +ath12k_warn (ar->ab,"failed to put down monitor vdev %i: %d\n" , + ar->monitor_vdev_id, ret); + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac monitor vdev %i stopped\n" , + ar->monitor_vdev_id); +return ret; +} + +static int ath12k_mac_monitor_vdev_create (struct ath12k *ar) +{ +struct ath12k_pdev *pdev = ar->pdev; +struct ath12k_wmi_vdev_create_arg arg = {}; +int bit, ret; +u8 tmp_addr[6 ]; +u16 nss; + +lockdep_assert_held (&ar->conf_mutex); + +if (ar->monitor_vdev_created) +return 0 ; + +if (ar->ab->free_vdev_map ==0 ) { +ath12k_warn (ar->ab,"failed to find free vdev id for monitor vdev\n" ); +return -ENOMEM ; + } + + bit =__ffs64 (ar->ab->free_vdev_map); + + ar->monitor_vdev_id = bit; + + arg.if_id = ar->monitor_vdev_id; + arg.type =WMI_VDEV_TYPE_MONITOR ; + arg.subtype =WMI_VDEV_SUBTYPE_NONE ; + arg.pdev_id = pdev->pdev_id; + arg.if_stats_id =ATH12K_INVAL_VDEV_STATS_ID ; + +if (pdev->cap.supported_bands &WMI_HOST_WLAN_2G_CAP ) { + arg.chains[NL80211_BAND_2GHZ ].tx = ar->num_tx_chains; + arg.chains[NL80211_BAND_2GHZ ].rx = ar->num_rx_chains; + } + +if (pdev->cap.supported_bands &WMI_HOST_WLAN_5G_CAP ) { + arg.chains[NL80211_BAND_5GHZ ].tx = ar->num_tx_chains; + arg.chains[NL80211_BAND_5GHZ ].rx = ar->num_rx_chains; + } + + ret =ath12k_wmi_vdev_create (ar, tmp_addr, &arg); +if (ret) { +ath12k_warn (ar->ab,"failed to request monitor vdev %i creation: %d\n" , + ar->monitor_vdev_id, ret); + ar->monitor_vdev_id =-1 ; +return ret; + } + + nss =hweight32 (ar->cfg_tx_chainmask) ? :1 ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, ar->monitor_vdev_id, +WMI_VDEV_PARAM_NSS , nss); +if (ret) { +ath12k_warn (ar->ab,"failed to set vdev %d chainmask 0x%x, nss %d :%d\n" , + ar->monitor_vdev_id, ar->cfg_tx_chainmask, nss, ret); +return ret; + } + + ret =ath12k_mac_txpower_recalc (ar); +if (ret) +return ret; + + ar->allocated_vdev_map |=1LL << ar->monitor_vdev_id; + ar->ab->free_vdev_map &= ~(1LL << ar->monitor_vdev_id); + ar->num_created_vdevs++; + ar->monitor_vdev_created = true; +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac monitor vdev %d created\n" , + ar->monitor_vdev_id); + +return 0 ; +} + +static int ath12k_mac_monitor_vdev_delete (struct ath12k *ar) +{ +int ret; +unsigned long time_left; + +lockdep_assert_held (&ar->conf_mutex); + +if (!ar->monitor_vdev_created) +return 0 ; + +reinit_completion (&ar->vdev_delete_done); + + ret =ath12k_wmi_vdev_delete (ar, ar->monitor_vdev_id); +if (ret) { +ath12k_warn (ar->ab,"failed to request wmi monitor vdev %i removal: %d\n" , + ar->monitor_vdev_id, ret); +return ret; + } + + time_left =wait_for_completion_timeout (&ar->vdev_delete_done, +ATH12K_VDEV_DELETE_TIMEOUT_HZ ); +if (time_left ==0 ) { +ath12k_warn (ar->ab,"Timeout in receiving vdev delete response\n" ); + }else { + ar->allocated_vdev_map &= ~(1LL << ar->monitor_vdev_id); + ar->ab->free_vdev_map |=1LL << (ar->monitor_vdev_id); +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac monitor vdev %d deleted\n" , + ar->monitor_vdev_id); + ar->num_created_vdevs--; + ar->monitor_vdev_id =-1 ; + ar->monitor_vdev_created = false; + } + +return ret; +} + +static void +ath12k_mac_get_any_chandef_iter (struct ieee80211_hw *hw, +struct ieee80211_chanctx_conf *conf, +void *data) +{ +struct cfg80211_chan_def **def = data; + + *def = &conf->def; +} + +static int ath12k_mac_monitor_start (struct ath12k *ar) +{ +struct cfg80211_chan_def *chandef =NULL ; +int ret; + +lockdep_assert_held (&ar->conf_mutex); + +if (ar->monitor_started) +return 0 ; + +ieee80211_iter_chan_contexts_atomic (ar->hw, + ath12k_mac_get_any_chandef_iter, + &chandef); +if (!chandef) +return 0 ; + + ret =ath12k_mac_monitor_vdev_start (ar, ar->monitor_vdev_id, chandef); +if (ret) { +ath12k_warn (ar->ab,"failed to start monitor vdev: %d\n" , ret); +ath12k_mac_monitor_vdev_delete (ar); +return ret; + } + + ar->monitor_started = true; + ar->num_started_vdevs++; + ret =ath12k_dp_tx_htt_monitor_mode_ring_config (ar, false); +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac monitor started ret %d\n" , ret); + +return ret; +} + +static int ath12k_mac_monitor_stop (struct ath12k *ar) +{ +int ret; + +lockdep_assert_held (&ar->conf_mutex); + +if (!ar->monitor_started) +return 0 ; + + ret =ath12k_mac_monitor_vdev_stop (ar); +if (ret) { +ath12k_warn (ar->ab,"failed to stop monitor vdev: %d\n" , ret); +return ret; + } + + ar->monitor_started = false; + ar->num_started_vdevs--; + ret =ath12k_dp_tx_htt_monitor_mode_ring_config (ar, true); +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac monitor stopped ret %d\n" , ret); +return ret; +} + +static int ath12k_mac_op_config (struct ieee80211_hw *hw,u32 changed) +{ +struct ath12k *ar = hw->priv; +struct ieee80211_conf *conf = &hw->conf; +int ret; + +mutex_lock (&ar->conf_mutex); + +if (changed &IEEE80211_CONF_CHANGE_MONITOR ) { + ar->monitor_conf_enabled = conf->flags &IEEE80211_CONF_MONITOR ; +if (ar->monitor_conf_enabled) { +if (ar->monitor_vdev_created) + goto exit; + ret =ath12k_mac_monitor_vdev_create (ar); +if (ret) + goto exit; + ret =ath12k_mac_monitor_start (ar); +if (ret) + goto err_mon_del; + }else { +if (!ar->monitor_vdev_created) + goto exit; + ret =ath12k_mac_monitor_stop (ar); +if (ret) + goto exit; +ath12k_mac_monitor_vdev_delete (ar); + } + } + +exit: +mutex_unlock (&ar->conf_mutex); +return ret; + +err_mon_del: +ath12k_mac_monitor_vdev_delete (ar); +mutex_unlock (&ar->conf_mutex); +return 0 ; +} + +static int ath12k_mac_setup_bcn_tmpl (struct ath12k_vif *arvif) +{ +struct ath12k *ar = arvif->ar; +struct ath12k_base *ab = ar->ab; +struct ieee80211_hw *hw = ar->hw; +struct ieee80211_vif *vif = arvif->vif; +struct ieee80211_mutable_offsets offs = {}; +struct sk_buff *bcn; +struct ieee80211_mgmt *mgmt; +u8 *ies; +int ret; + +if (arvif->vdev_type !=WMI_VDEV_TYPE_AP ) +return 0 ; + + bcn =ieee80211_beacon_get_template (hw, vif, &offs,0 ); +if (!bcn) { +ath12k_warn (ab,"failed to get beacon template from mac80211\n" ); +return -EPERM ; + } + + ies = bcn->data +ieee80211_get_hdrlen_from_skb (bcn); + ies +=sizeof (mgmt->u.beacon); + +if (cfg80211_find_ie (WLAN_EID_RSN , ies, (skb_tail_pointer (bcn) - ies))) + arvif->rsnie_present = true; + +if (cfg80211_find_vendor_ie (WLAN_OUI_MICROSOFT , +WLAN_OUI_TYPE_MICROSOFT_WPA , + ies, (skb_tail_pointer (bcn) - ies))) + arvif->wpaie_present = true; + + ret =ath12k_wmi_bcn_tmpl (ar, arvif->vdev_id, &offs, bcn); + +kfree_skb (bcn); + +if (ret) +ath12k_warn (ab,"failed to submit beacon template command: %d\n" , + ret); + +return ret; +} + +static void ath12k_control_beaconing (struct ath12k_vif *arvif, +struct ieee80211_bss_conf *info) +{ +struct ath12k *ar = arvif->ar; +int ret; + +lockdep_assert_held (&arvif->ar->conf_mutex); + +if (!info->enable_beacon) { + ret =ath12k_wmi_vdev_down (ar, arvif->vdev_id); +if (ret) +ath12k_warn (ar->ab,"failed to down vdev_id %i: %d\n" , + arvif->vdev_id, ret); + + arvif->is_up = false; +return ; + } + +/* Install the beacon template to the FW */ + ret =ath12k_mac_setup_bcn_tmpl (arvif); +if (ret) { +ath12k_warn (ar->ab,"failed to update bcn tmpl during vdev up: %d\n" , + ret); +return ; + } + + arvif->aid =0 ; + +ether_addr_copy (arvif->bssid, info->bssid); + + ret =ath12k_wmi_vdev_up (arvif->ar, arvif->vdev_id, arvif->aid, + arvif->bssid); +if (ret) { +ath12k_warn (ar->ab,"failed to bring up vdev %d: %i\n" , + arvif->vdev_id, ret); +return ; + } + + arvif->is_up = true; + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac vdev %d up\n" , arvif->vdev_id); +} + +static void ath12k_peer_assoc_h_basic (struct ath12k *ar, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg) +{ +struct ath12k_vif *arvif = (void *)vif->drv_priv; +u32 aid; + +lockdep_assert_held (&ar->conf_mutex); + +if (vif->type ==NL80211_IFTYPE_STATION ) + aid = vif->cfg.aid; +else + aid = sta->aid; + +ether_addr_copy (arg->peer_mac, sta->addr); + arg->vdev_id = arvif->vdev_id; + arg->peer_associd = aid; + arg->auth_flag = true; +/* TODO: STA WAR in ath10k for listen interval required? */ + arg->peer_listen_intval = ar->hw->conf.listen_interval; + arg->peer_nss =1 ; + arg->peer_caps = vif->bss_conf.assoc_capability; +} + +static void ath12k_peer_assoc_h_crypto (struct ath12k *ar, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg) +{ +struct ieee80211_bss_conf *info = &vif->bss_conf; +struct cfg80211_chan_def def; +struct cfg80211_bss *bss; +struct ath12k_vif *arvif = (struct ath12k_vif *)vif->drv_priv; +const u8 *rsnie =NULL ; +const u8 *wpaie =NULL ; + +lockdep_assert_held (&ar->conf_mutex); + +if (WARN_ON (ath12k_mac_vif_chan (vif, &def))) +return ; + + bss =cfg80211_get_bss (ar->hw->wiphy, def.chan, info->bssid,NULL ,0 , +IEEE80211_BSS_TYPE_ANY ,IEEE80211_PRIVACY_ANY ); + +if (arvif->rsnie_present || arvif->wpaie_present) { + arg->need_ptk_4_way = true; +if (arvif->wpaie_present) + arg->need_gtk_2_way = true; + }else if (bss) { +const struct cfg80211_bss_ies *ies; + +rcu_read_lock (); + rsnie =ieee80211_bss_get_ie (bss,WLAN_EID_RSN ); + + ies =rcu_dereference (bss->ies); + + wpaie =cfg80211_find_vendor_ie (WLAN_OUI_MICROSOFT , +WLAN_OUI_TYPE_MICROSOFT_WPA , + ies->data, + ies->len); +rcu_read_unlock (); +cfg80211_put_bss (ar->hw->wiphy, bss); + } + +/* FIXME: base on RSN IE/WPA IE is a correct idea? */ +if (rsnie || wpaie) { +ath12k_dbg (ar->ab,ATH12K_DBG_WMI , +"%s: rsn ie found\n" , __func__); + arg->need_ptk_4_way = true; + } + +if (wpaie) { +ath12k_dbg (ar->ab,ATH12K_DBG_WMI , +"%s: wpa ie found\n" , __func__); + arg->need_gtk_2_way = true; + } + +if (sta->mfp) { +/* TODO: Need to check if FW supports PMF? */ + arg->is_pmf_enabled = true; + } + +/* TODO: safe_mode_enabled (bypass 4-way handshake) flag req? */ +} + +static void ath12k_peer_assoc_h_rates (struct ath12k *ar, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg) +{ +struct ath12k_vif *arvif = (void *)vif->drv_priv; +struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates; +struct cfg80211_chan_def def; +const struct ieee80211_supported_band *sband; +const struct ieee80211_rate *rates; +enum nl80211_band band; +u32 ratemask; +u8 rate; +int i; + +lockdep_assert_held (&ar->conf_mutex); + +if (WARN_ON (ath12k_mac_vif_chan (vif, &def))) +return ; + + band = def.chan->band; + sband = ar->hw->wiphy->bands[band]; + ratemask = sta->deflink.supp_rates[band]; + ratemask &= arvif->bitrate_mask.control[band].legacy; + rates = sband->bitrates; + + rateset->num_rates =0 ; + +for (i =0 ; i <32 ; i++, ratemask >>=1 , rates++) { +if (!(ratemask &1 )) +continue ; + + rate =ath12k_mac_bitrate_to_rate (rates->bitrate); + rateset->rates[rateset->num_rates] = rate; + rateset->num_rates++; + } +} + +static bool +ath12k_peer_assoc_h_ht_masked (const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN ]) +{ +int nss; + +for (nss =0 ; nss <IEEE80211_HT_MCS_MASK_LEN ; nss++) +if (ht_mcs_mask[nss]) +return false; + +return true; +} + +static bool +ath12k_peer_assoc_h_vht_masked (const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX ]) +{ +int nss; + +for (nss =0 ; nss <NL80211_VHT_NSS_MAX ; nss++) +if (vht_mcs_mask[nss]) +return false; + +return true; +} + +static void ath12k_peer_assoc_h_ht (struct ath12k *ar, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg) +{ +const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap; +struct ath12k_vif *arvif = (void *)vif->drv_priv; +struct cfg80211_chan_def def; +enum nl80211_band band; +const u8 *ht_mcs_mask; +int i, n; +u8 max_nss; +u32 stbc; + +lockdep_assert_held (&ar->conf_mutex); + +if (WARN_ON (ath12k_mac_vif_chan (vif, &def))) +return ; + +if (!ht_cap->ht_supported) +return ; + + band = def.chan->band; + ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; + +if (ath12k_peer_assoc_h_ht_masked (ht_mcs_mask)) +return ; + + arg->ht_flag = true; + + arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR + + ht_cap->ampdu_factor)) -1 ; + + arg->peer_mpdu_density = +ath12k_parse_mpdudensity (ht_cap->ampdu_density); + + arg->peer_ht_caps = ht_cap->cap; + arg->peer_rate_caps |=WMI_HOST_RC_HT_FLAG ; + +if (ht_cap->cap &IEEE80211_HT_CAP_LDPC_CODING ) + arg->ldpc_flag = true; + +if (sta->deflink.bandwidth >=IEEE80211_STA_RX_BW_40 ) { + arg->bw_40 = true; + arg->peer_rate_caps |=WMI_HOST_RC_CW40_FLAG ; + } + +if (arvif->bitrate_mask.control[band].gi !=NL80211_TXRATE_FORCE_LGI ) { +if (ht_cap->cap & (IEEE80211_HT_CAP_SGI_20 | +IEEE80211_HT_CAP_SGI_40 )) + arg->peer_rate_caps |=WMI_HOST_RC_SGI_FLAG ; + } + +if (ht_cap->cap &IEEE80211_HT_CAP_TX_STBC ) { + arg->peer_rate_caps |=WMI_HOST_RC_TX_STBC_FLAG ; + arg->stbc_flag = true; + } + +if (ht_cap->cap &IEEE80211_HT_CAP_RX_STBC ) { + stbc = ht_cap->cap &IEEE80211_HT_CAP_RX_STBC ; + stbc = stbc >>IEEE80211_HT_CAP_RX_STBC_SHIFT ; + stbc = stbc <<WMI_HOST_RC_RX_STBC_FLAG_S ; + arg->peer_rate_caps |= stbc; + arg->stbc_flag = true; + } + +if (ht_cap->mcs.rx_mask[1 ] && ht_cap->mcs.rx_mask[2 ]) + arg->peer_rate_caps |=WMI_HOST_RC_TS_FLAG ; +else if (ht_cap->mcs.rx_mask[1 ]) + arg->peer_rate_caps |=WMI_HOST_RC_DS_FLAG ; + +for (i =0 , n =0 , max_nss =0 ; i <IEEE80211_HT_MCS_MASK_LEN *8 ; i++) +if ((ht_cap->mcs.rx_mask[i /8 ] &BIT (i %8 )) && + (ht_mcs_mask[i /8 ] &BIT (i %8 ))) { + max_nss = (i /8 ) +1 ; + arg->peer_ht_rates.rates[n++] = i; + } + +/* This is a workaround for HT-enabled STAs which break the spec +* and have no HT capabilities RX mask (no HT RX MCS map). +* +* As per spec, in section 20.3.5 Modulation and coding scheme (MCS), +* MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs. +* +* Firmware asserts if such situation occurs. +*/ +if (n ==0 ) { + arg->peer_ht_rates.num_rates =8 ; +for (i =0 ; i < arg->peer_ht_rates.num_rates; i++) + arg->peer_ht_rates.rates[i] = i; + }else { + arg->peer_ht_rates.num_rates = n; + arg->peer_nss =min (sta->deflink.rx_nss, max_nss); + } + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac ht peer %pM mcs cnt %d nss %d\n" , + arg->peer_mac, + arg->peer_ht_rates.num_rates, + arg->peer_nss); +} + +static int ath12k_mac_get_max_vht_mcs_map (u16 mcs_map,int nss) +{ +switch ((mcs_map >> (2 * nss)) &0x3 ) { +case IEEE80211_VHT_MCS_SUPPORT_0_7 :return BIT (8 ) -1 ; +case IEEE80211_VHT_MCS_SUPPORT_0_8 :return BIT (9 ) -1 ; +case IEEE80211_VHT_MCS_SUPPORT_0_9 :return BIT (10 ) -1 ; + } +return 0 ; +} + +static u16 +ath12k_peer_assoc_h_vht_limit (u16 tx_mcs_set, +const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX ]) +{ +int idx_limit; +int nss; +u16 mcs_map; +u16 mcs; + +for (nss =0 ; nss <NL80211_VHT_NSS_MAX ; nss++) { + mcs_map =ath12k_mac_get_max_vht_mcs_map (tx_mcs_set, nss) & + vht_mcs_limit[nss]; + +if (mcs_map) + idx_limit =fls (mcs_map) -1 ; +else + idx_limit =-1 ; + +switch (idx_limit) { +case 0 : +case 1 : +case 2 : +case 3 : +case 4 : +case 5 : +case 6 : +case 7 : + mcs =IEEE80211_VHT_MCS_SUPPORT_0_7 ; +break ; +case 8 : + mcs =IEEE80211_VHT_MCS_SUPPORT_0_8 ; +break ; +case 9 : + mcs =IEEE80211_VHT_MCS_SUPPORT_0_9 ; +break ; +default : +WARN_ON (1 ); + fallthrough; +case -1 : + mcs =IEEE80211_VHT_MCS_NOT_SUPPORTED ; +break ; + } + + tx_mcs_set &= ~(0x3 << (nss *2 )); + tx_mcs_set |= mcs << (nss *2 ); + } + +return tx_mcs_set; +} + +static void ath12k_peer_assoc_h_vht (struct ath12k *ar, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg) +{ +const struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap; +struct ath12k_vif *arvif = (void *)vif->drv_priv; +struct cfg80211_chan_def def; +enum nl80211_band band; +const u16 *vht_mcs_mask; +u16 tx_mcs_map; +u8 ampdu_factor; +u8 max_nss, vht_mcs; +int i; + +if (WARN_ON (ath12k_mac_vif_chan (vif, &def))) +return ; + +if (!vht_cap->vht_supported) +return ; + + band = def.chan->band; + vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; + +if (ath12k_peer_assoc_h_vht_masked (vht_mcs_mask)) +return ; + + arg->vht_flag = true; + +/* TODO: similar flags required? */ + arg->vht_capable = true; + +if (def.chan->band ==NL80211_BAND_2GHZ ) + arg->vht_ng_flag = true; + + arg->peer_vht_caps = vht_cap->cap; + + ampdu_factor = (vht_cap->cap & +IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK ) >> +IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT ; + +/* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to +* zero in VHT IE. Using it would result in degraded throughput. +* arg->peer_max_mpdu at this point contains HT max_mpdu so keep +* it if VHT max_mpdu is smaller. +*/ + arg->peer_max_mpdu =max (arg->peer_max_mpdu, + (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR + + ampdu_factor)) -1 ); + +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_80 ) + arg->bw_80 = true; + +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_160 ) + arg->bw_160 = true; + +/* Calculate peer NSS capability from VHT capabilities if STA +* supports VHT. +*/ +for (i =0 , max_nss =0 , vht_mcs =0 ; i <NL80211_VHT_NSS_MAX ; i++) { + vht_mcs =__le16_to_cpu (vht_cap->vht_mcs.rx_mcs_map) >> + (2 * i) &3 ; + +if (vht_mcs !=IEEE80211_VHT_MCS_NOT_SUPPORTED && + vht_mcs_mask[i]) + max_nss = i +1 ; + } + arg->peer_nss =min (sta->deflink.rx_nss, max_nss); + arg->rx_max_rate =__le16_to_cpu (vht_cap->vht_mcs.rx_highest); + arg->rx_mcs_set =__le16_to_cpu (vht_cap->vht_mcs.rx_mcs_map); + arg->tx_max_rate =__le16_to_cpu (vht_cap->vht_mcs.tx_highest); + + tx_mcs_map =__le16_to_cpu (vht_cap->vht_mcs.tx_mcs_map); + arg->tx_mcs_set =ath12k_peer_assoc_h_vht_limit (tx_mcs_map, vht_mcs_mask); + +/* In QCN9274 platform, VHT MCS rate 10 and 11 is enabled by default. +* VHT MCS rate 10 and 11 is not supported in 11ac standard. +* so explicitly disable the VHT MCS rate 10 and 11 in 11ac mode. +*/ + arg->tx_mcs_set &= ~IEEE80211_VHT_MCS_SUPPORT_0_11_MASK ; + arg->tx_mcs_set |=IEEE80211_DISABLE_VHT_MCS_SUPPORT_0_11 ; + +if ((arg->tx_mcs_set &IEEE80211_VHT_MCS_NOT_SUPPORTED ) == +IEEE80211_VHT_MCS_NOT_SUPPORTED ) + arg->peer_vht_caps &= ~IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE ; + +/* TODO: Check */ + arg->tx_max_mcs_nss =0xFF ; + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac vht peer %pM max_mpdu %d flags 0x%x\n" , + sta->addr, arg->peer_max_mpdu, arg->peer_flags); + +/* TODO: rxnss_override */ +} + +static void ath12k_peer_assoc_h_he (struct ath12k *ar, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg) +{ +const struct ieee80211_sta_he_cap *he_cap = &sta->deflink.he_cap; +int i; +u8 ampdu_factor, rx_mcs_80, rx_mcs_160, max_nss; +u16 mcs_160_map, mcs_80_map; +bool support_160; +u16 v; + +if (!he_cap->has_he) +return ; + + arg->he_flag = true; + + support_160 = !!(he_cap->he_cap_elem.phy_cap_info[0 ] & +IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G ); + +/* Supported HE-MCS and NSS Set of peer he_cap is intersection with self he_cp */ + mcs_160_map =le16_to_cpu (he_cap->he_mcs_nss_supp.rx_mcs_160); + mcs_80_map =le16_to_cpu (he_cap->he_mcs_nss_supp.rx_mcs_80); + +if (support_160) { +for (i =7 ; i >=0 ; i--) { +u8 mcs_160 = (mcs_160_map >> (2 * i)) &3 ; + +if (mcs_160 !=IEEE80211_HE_MCS_NOT_SUPPORTED ) { + rx_mcs_160 = i +1 ; +break ; + } + } + } + +for (i =7 ; i >=0 ; i--) { +u8 mcs_80 = (mcs_80_map >> (2 * i)) &3 ; + +if (mcs_80 !=IEEE80211_HE_MCS_NOT_SUPPORTED ) { + rx_mcs_80 = i +1 ; +break ; + } + } + +if (support_160) + max_nss =min (rx_mcs_80, rx_mcs_160); +else + max_nss = rx_mcs_80; + + arg->peer_nss =min (sta->deflink.rx_nss, max_nss); + +memcpy (&arg->peer_he_cap_macinfo, he_cap->he_cap_elem.mac_cap_info, +sizeof (arg->peer_he_cap_macinfo)); +memcpy (&arg->peer_he_cap_phyinfo, he_cap->he_cap_elem.phy_cap_info, +sizeof (arg->peer_he_cap_phyinfo)); + arg->peer_he_ops = vif->bss_conf.he_oper.params; + +/* the top most byte is used to indicate BSS color info */ + arg->peer_he_ops &=0xffffff ; + +/* As per section 26.6.1 IEEE Std 802.11ax‐2022, if the Max AMPDU +* Exponent Extension in HE cap is zero, use the arg->peer_max_mpdu +* as calculated while parsing VHT caps(if VHT caps is present) +* or HT caps (if VHT caps is not present). +* +* For non-zero value of Max AMPDU Exponent Extension in HE MAC caps, +* if a HE STA sends VHT cap and HE cap IE in assoc request then, use +* MAX_AMPDU_LEN_FACTOR as 20 to calculate max_ampdu length. +* If a HE STA that does not send VHT cap, but HE and HT cap in assoc +* request, then use MAX_AMPDU_LEN_FACTOR as 16 to calculate max_ampdu +* length. +*/ + ampdu_factor = (he_cap->he_cap_elem.mac_cap_info[3 ] & +IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK ) >> +IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK ; + +if (ampdu_factor) { +if (sta->deflink.vht_cap.vht_supported) + arg->peer_max_mpdu = (1 << (IEEE80211_HE_VHT_MAX_AMPDU_FACTOR + + ampdu_factor)) -1 ; +else if (sta->deflink.ht_cap.ht_supported) + arg->peer_max_mpdu = (1 << (IEEE80211_HE_HT_MAX_AMPDU_FACTOR + + ampdu_factor)) -1 ; + } + +if (he_cap->he_cap_elem.phy_cap_info[6 ] & +IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT ) { +int bit =7 ; +int nss, ru; + + arg->peer_ppet.numss_m1 = he_cap->ppe_thres[0 ] & +IEEE80211_PPE_THRES_NSS_MASK ; + arg->peer_ppet.ru_bit_mask = + (he_cap->ppe_thres[0 ] & +IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK ) >> +IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS ; + +for (nss =0 ; nss <= arg->peer_ppet.numss_m1; nss++) { +for (ru =0 ; ru <4 ; ru++) { +u32 val =0 ; +int i; + +if ((arg->peer_ppet.ru_bit_mask &BIT (ru)) ==0 ) +continue ; +for (i =0 ; i <6 ; i++) { + val >>=1 ; + val |= ((he_cap->ppe_thres[bit /8 ] >> + (bit %8 )) &0x1 ) <<5 ; + bit++; + } + arg->peer_ppet.ppet16_ppet8_ru3_ru0[nss] |= + val << (ru *6 ); + } + } + } + +if (he_cap->he_cap_elem.mac_cap_info[0 ] &IEEE80211_HE_MAC_CAP0_TWT_RES ) + arg->twt_responder = true; +if (he_cap->he_cap_elem.mac_cap_info[0 ] &IEEE80211_HE_MAC_CAP0_TWT_REQ ) + arg->twt_requester = true; + +switch (sta->deflink.bandwidth) { +case IEEE80211_STA_RX_BW_160 : +if (he_cap->he_cap_elem.phy_cap_info[0 ] & +IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G ) { + v =le16_to_cpu (he_cap->he_mcs_nss_supp.rx_mcs_80p80); + arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80 ] = v; + + v =le16_to_cpu (he_cap->he_mcs_nss_supp.tx_mcs_80p80); + arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80_80 ] = v; + + arg->peer_he_mcs_count++; + } + v =le16_to_cpu (he_cap->he_mcs_nss_supp.rx_mcs_160); + arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160 ] = v; + + v =le16_to_cpu (he_cap->he_mcs_nss_supp.tx_mcs_160); + arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_160 ] = v; + + arg->peer_he_mcs_count++; + fallthrough; + +default : + v =le16_to_cpu (he_cap->he_mcs_nss_supp.rx_mcs_80); + arg->peer_he_rx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80 ] = v; + + v =le16_to_cpu (he_cap->he_mcs_nss_supp.tx_mcs_80); + arg->peer_he_tx_mcs_set[WMI_HECAP_TXRX_MCS_NSS_IDX_80 ] = v; + + arg->peer_he_mcs_count++; +break ; + } +} + +static void ath12k_peer_assoc_h_smps (struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg) +{ +const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap; +int smps; + +if (!ht_cap->ht_supported) +return ; + + smps = ht_cap->cap &IEEE80211_HT_CAP_SM_PS ; + smps >>=IEEE80211_HT_CAP_SM_PS_SHIFT ; + +switch (smps) { +case WLAN_HT_CAP_SM_PS_STATIC : + arg->static_mimops_flag = true; +break ; +case WLAN_HT_CAP_SM_PS_DYNAMIC : + arg->dynamic_mimops_flag = true; +break ; +case WLAN_HT_CAP_SM_PS_DISABLED : + arg->spatial_mux_flag = true; +break ; +default : +break ; + } +} + +static void ath12k_peer_assoc_h_qos (struct ath12k *ar, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg) +{ +struct ath12k_vif *arvif = (void *)vif->drv_priv; + +switch (arvif->vdev_type) { +case WMI_VDEV_TYPE_AP : +if (sta->wme) { +/* TODO: Check WME vs QoS */ + arg->is_wme_set = true; + arg->qos_flag = true; + } + +if (sta->wme && sta->uapsd_queues) { +/* TODO: Check WME vs QoS */ + arg->is_wme_set = true; + arg->apsd_flag = true; + arg->peer_rate_caps |=WMI_HOST_RC_UAPSD_FLAG ; + } +break ; +case WMI_VDEV_TYPE_STA : +if (sta->wme) { + arg->is_wme_set = true; + arg->qos_flag = true; + } +break ; +default : +break ; + } + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac peer %pM qos %d\n" , + sta->addr, arg->qos_flag); +} + +static int ath12k_peer_assoc_qos_ap (struct ath12k *ar, +struct ath12k_vif *arvif, +struct ieee80211_sta *sta) +{ +struct ath12k_wmi_ap_ps_arg arg; +u32 max_sp; +u32 uapsd; +int ret; + +lockdep_assert_held (&ar->conf_mutex); + + arg.vdev_id = arvif->vdev_id; + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac uapsd_queues 0x%x max_sp %d\n" , + sta->uapsd_queues, sta->max_sp); + + uapsd =0 ; +if (sta->uapsd_queues &IEEE80211_WMM_IE_STA_QOSINFO_AC_VO ) + uapsd |=WMI_AP_PS_UAPSD_AC3_DELIVERY_EN | +WMI_AP_PS_UAPSD_AC3_TRIGGER_EN ; +if (sta->uapsd_queues &IEEE80211_WMM_IE_STA_QOSINFO_AC_VI ) + uapsd |=WMI_AP_PS_UAPSD_AC2_DELIVERY_EN | +WMI_AP_PS_UAPSD_AC2_TRIGGER_EN ; +if (sta->uapsd_queues &IEEE80211_WMM_IE_STA_QOSINFO_AC_BK ) + uapsd |=WMI_AP_PS_UAPSD_AC1_DELIVERY_EN | +WMI_AP_PS_UAPSD_AC1_TRIGGER_EN ; +if (sta->uapsd_queues &IEEE80211_WMM_IE_STA_QOSINFO_AC_BE ) + uapsd |=WMI_AP_PS_UAPSD_AC0_DELIVERY_EN | +WMI_AP_PS_UAPSD_AC0_TRIGGER_EN ; + + max_sp =0 ; +if (sta->max_sp <MAX_WMI_AP_PS_PEER_PARAM_MAX_SP ) + max_sp = sta->max_sp; + + arg.param =WMI_AP_PS_PEER_PARAM_UAPSD ; + arg.value = uapsd; + ret =ath12k_wmi_send_set_ap_ps_param_cmd (ar, sta->addr, &arg); +if (ret) + goto err; + + arg.param =WMI_AP_PS_PEER_PARAM_MAX_SP ; + arg.value = max_sp; + ret =ath12k_wmi_send_set_ap_ps_param_cmd (ar, sta->addr, &arg); +if (ret) + goto err; + +/* TODO: revisit during testing */ + arg.param =WMI_AP_PS_PEER_PARAM_SIFS_RESP_FRMTYPE ; + arg.value =DISABLE_SIFS_RESPONSE_TRIGGER ; + ret =ath12k_wmi_send_set_ap_ps_param_cmd (ar, sta->addr, &arg); +if (ret) + goto err; + + arg.param =WMI_AP_PS_PEER_PARAM_SIFS_RESP_UAPSD ; + arg.value =DISABLE_SIFS_RESPONSE_TRIGGER ; + ret =ath12k_wmi_send_set_ap_ps_param_cmd (ar, sta->addr, &arg); +if (ret) + goto err; + +return 0 ; + +err: +ath12k_warn (ar->ab,"failed to set ap ps peer param %d for vdev %i: %d\n" , + arg.param, arvif->vdev_id, ret); +return ret; +} + +static bool ath12k_mac_sta_has_ofdm_only (struct ieee80211_sta *sta) +{ +return sta->deflink.supp_rates[NL80211_BAND_2GHZ ] >> +ATH12K_MAC_FIRST_OFDM_RATE_IDX ; +} + +static enum wmi_phy_mode ath12k_mac_get_phymode_vht (struct ath12k *ar, +struct ieee80211_sta *sta) +{ +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_160 ) { +switch (sta->deflink.vht_cap.cap & +IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK ) { +case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ : +return MODE_11AC_VHT160 ; +case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ : +return MODE_11AC_VHT80_80 ; +default : +/* not sure if this is a valid case? */ +return MODE_11AC_VHT160 ; + } + } + +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_80 ) +return MODE_11AC_VHT80 ; + +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_40 ) +return MODE_11AC_VHT40 ; + +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_20 ) +return MODE_11AC_VHT20 ; + +return MODE_UNKNOWN ; +} + +static enum wmi_phy_mode ath12k_mac_get_phymode_he (struct ath12k *ar, +struct ieee80211_sta *sta) +{ +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_160 ) { +if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0 ] & +IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G ) +return MODE_11AX_HE160 ; +else if (sta->deflink.he_cap.he_cap_elem.phy_cap_info[0 ] & +IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G ) +return MODE_11AX_HE80_80 ; +/* not sure if this is a valid case? */ +return MODE_11AX_HE160 ; + } + +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_80 ) +return MODE_11AX_HE80 ; + +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_40 ) +return MODE_11AX_HE40 ; + +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_20 ) +return MODE_11AX_HE20 ; + +return MODE_UNKNOWN ; +} + +static void ath12k_peer_assoc_h_phymode (struct ath12k *ar, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg) +{ +struct ath12k_vif *arvif = (void *)vif->drv_priv; +struct cfg80211_chan_def def; +enum nl80211_band band; +const u8 *ht_mcs_mask; +const u16 *vht_mcs_mask; +enum wmi_phy_mode phymode =MODE_UNKNOWN ; + +if (WARN_ON (ath12k_mac_vif_chan (vif, &def))) +return ; + + band = def.chan->band; + ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs; + vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs; + +switch (band) { +case NL80211_BAND_2GHZ : +if (sta->deflink.he_cap.has_he) { +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_80 ) + phymode =MODE_11AX_HE80_2G ; +else if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_40 ) + phymode =MODE_11AX_HE40_2G ; +else + phymode =MODE_11AX_HE20_2G ; + }else if (sta->deflink.vht_cap.vht_supported && + !ath12k_peer_assoc_h_vht_masked (vht_mcs_mask)) { +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_40 ) + phymode =MODE_11AC_VHT40 ; +else + phymode =MODE_11AC_VHT20 ; + }else if (sta->deflink.ht_cap.ht_supported && + !ath12k_peer_assoc_h_ht_masked (ht_mcs_mask)) { +if (sta->deflink.bandwidth ==IEEE80211_STA_RX_BW_40 ) + phymode =MODE_11NG_HT40 ; +else + phymode =MODE_11NG_HT20 ; + }else if (ath12k_mac_sta_has_ofdm_only (sta)) { + phymode =MODE_11G ; + }else { + phymode =MODE_11B ; + } +break ; +case NL80211_BAND_5GHZ : +case NL80211_BAND_6GHZ : +/* Check HE first */ +if (sta->deflink.he_cap.has_he) { + phymode =ath12k_mac_get_phymode_he (ar, sta); + }else if (sta->deflink.vht_cap.vht_supported && + !ath12k_peer_assoc_h_vht_masked (vht_mcs_mask)) { + phymode =ath12k_mac_get_phymode_vht (ar, sta); + }else if (sta->deflink.ht_cap.ht_supported && + !ath12k_peer_assoc_h_ht_masked (ht_mcs_mask)) { +if (sta->deflink.bandwidth >=IEEE80211_STA_RX_BW_40 ) + phymode =MODE_11NA_HT40 ; +else + phymode =MODE_11NA_HT20 ; + }else { + phymode =MODE_11A ; + } +break ; +default : +break ; + } + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac peer %pM phymode %s\n" , + sta->addr,ath12k_mac_phymode_str (phymode)); + + arg->peer_phymode = phymode; +WARN_ON (phymode ==MODE_UNKNOWN ); +} + +static void ath12k_peer_assoc_prepare (struct ath12k *ar, +struct ieee80211_vif *vif, +struct ieee80211_sta *sta, +struct ath12k_wmi_peer_assoc_arg *arg, +bool reassoc) +{ +lockdep_assert_held (&ar->conf_mutex); + +memset (arg,0 ,sizeof (*arg)); + +reinit_completion (&ar->peer_assoc_done); + + arg->peer_new_assoc = !reassoc; +ath12k_peer_assoc_h_basic (ar, vif, sta, arg); +ath12k_peer_assoc_h_crypto (ar, vif, sta, arg); +ath12k_peer_assoc_h_rates (ar, vif, sta, arg); +ath12k_peer_assoc_h_ht (ar, vif, sta, arg); +ath12k_peer_assoc_h_vht (ar, vif, sta, arg); +ath12k_peer_assoc_h_he (ar, vif, sta, arg); +ath12k_peer_assoc_h_qos (ar, vif, sta, arg); +ath12k_peer_assoc_h_phymode (ar, vif, sta, arg); +ath12k_peer_assoc_h_smps (sta, arg); + +/* TODO: amsdu_disable req? */ +} + +static int ath12k_setup_peer_smps (struct ath12k *ar,struct ath12k_vif *arvif, +const u8 *addr, +const struct ieee80211_sta_ht_cap *ht_cap) +{ +int smps; + +if (!ht_cap->ht_supported) +return 0 ; + + smps = ht_cap->cap &IEEE80211_HT_CAP_SM_PS ; + smps >>=IEEE80211_HT_CAP_SM_PS_SHIFT ; + +if (smps >=ARRAY_SIZE (ath12k_smps_map)) +return -EINVAL ; + +return ath12k_wmi_set_peer_param (ar, addr, arvif->vdev_id, +WMI_PEER_MIMO_PS_STATE , + ath12k_smps_map[smps]); +} + +static void ath12k_bss_assoc (struct ieee80211_hw *hw, +struct ieee80211_vif *vif, +struct ieee80211_bss_conf *bss_conf) +{ +struct ath12k *ar = hw->priv; +struct ath12k_vif *arvif = (void *)vif->drv_priv; +struct ath12k_wmi_peer_assoc_arg peer_arg; +struct ieee80211_sta *ap_sta; +struct ath12k_peer *peer; +bool is_auth = false; +int ret; + +lockdep_assert_held (&ar->conf_mutex); + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac vdev %i assoc bssid %pM aid %d\n" , + arvif->vdev_id, arvif->bssid, arvif->aid); + +rcu_read_lock (); + + ap_sta =ieee80211_find_sta (vif, bss_conf->bssid); +if (!ap_sta) { +ath12k_warn (ar->ab,"failed to find station entry for bss %pM vdev %i\n" , + bss_conf->bssid, arvif->vdev_id); +rcu_read_unlock (); +return ; + } + +ath12k_peer_assoc_prepare (ar, vif, ap_sta, &peer_arg, false); + +rcu_read_unlock (); + + ret =ath12k_wmi_send_peer_assoc_cmd (ar, &peer_arg); +if (ret) { +ath12k_warn (ar->ab,"failed to run peer assoc for %pM vdev %i: %d\n" , + bss_conf->bssid, arvif->vdev_id, ret); +return ; + } + +if (!wait_for_completion_timeout (&ar->peer_assoc_done,1 *HZ )) { +ath12k_warn (ar->ab,"failed to get peer assoc conf event for %pM vdev %i\n" , + bss_conf->bssid, arvif->vdev_id); +return ; + } + + ret =ath12k_setup_peer_smps (ar, arvif, bss_conf->bssid, + &ap_sta->deflink.ht_cap); +if (ret) { +ath12k_warn (ar->ab,"failed to setup peer SMPS for vdev %d: %d\n" , + arvif->vdev_id, ret); +return ; + } + +WARN_ON (arvif->is_up); + + arvif->aid = vif->cfg.aid; +ether_addr_copy (arvif->bssid, bss_conf->bssid); + + ret =ath12k_wmi_vdev_up (ar, arvif->vdev_id, arvif->aid, arvif->bssid); +if (ret) { +ath12k_warn (ar->ab,"failed to set vdev %d up: %d\n" , + arvif->vdev_id, ret); +return ; + } + + arvif->is_up = true; + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC , +"mac vdev %d up (associated) bssid %pM aid %d\n" , + arvif->vdev_id, bss_conf->bssid, vif->cfg.aid); + +spin_lock_bh (&ar->ab->base_lock); + + peer =ath12k_peer_find (ar->ab, arvif->vdev_id, arvif->bssid); +if (peer && peer->is_authorized) + is_auth = true; + +spin_unlock_bh (&ar->ab->base_lock); + +/* Authorize BSS Peer */ +if (is_auth) { + ret =ath12k_wmi_set_peer_param (ar, arvif->bssid, + arvif->vdev_id, +WMI_PEER_AUTHORIZE , +1 ); +if (ret) +ath12k_warn (ar->ab,"Unable to authorize BSS peer: %d\n" , ret); + } + + ret =ath12k_wmi_send_obss_spr_cmd (ar, arvif->vdev_id, + &bss_conf->he_obss_pd); +if (ret) +ath12k_warn (ar->ab,"failed to set vdev %i OBSS PD parameters: %d\n" , + arvif->vdev_id, ret); +} + +static void ath12k_bss_disassoc (struct ieee80211_hw *hw, +struct ieee80211_vif *vif) +{ +struct ath12k *ar = hw->priv; +struct ath12k_vif *arvif = (void *)vif->drv_priv; +int ret; + +lockdep_assert_held (&ar->conf_mutex); + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac vdev %i disassoc bssid %pM\n" , + arvif->vdev_id, arvif->bssid); + + ret =ath12k_wmi_vdev_down (ar, arvif->vdev_id); +if (ret) +ath12k_warn (ar->ab,"failed to down vdev %i: %d\n" , + arvif->vdev_id, ret); + + arvif->is_up = false; + +/* TODO: cancel connection_loss_work */ +} + +static u32 ath12k_mac_get_rate_hw_value (int bitrate) +{ +u32 preamble; +u16 hw_value; +int rate; +size_t i; + +if (ath12k_mac_bitrate_is_cck (bitrate)) + preamble =WMI_RATE_PREAMBLE_CCK ; +else + preamble =WMI_RATE_PREAMBLE_OFDM ; + +for (i =0 ; i <ARRAY_SIZE (ath12k_legacy_rates); i++) { +if (ath12k_legacy_rates[i].bitrate != bitrate) +continue ; + + hw_value = ath12k_legacy_rates[i].hw_value; + rate =ATH12K_HW_RATE_CODE (hw_value,0 , preamble); + +return rate; + } + +return -EINVAL ; +} + +static void ath12k_recalculate_mgmt_rate (struct ath12k *ar, +struct ieee80211_vif *vif, +struct cfg80211_chan_def *def) +{ +struct ath12k_vif *arvif = (void *)vif->drv_priv; +const struct ieee80211_supported_band *sband; +u8 basic_rate_idx; +int hw_rate_code; +u32 vdev_param; +u16 bitrate; +int ret; + +lockdep_assert_held (&ar->conf_mutex); + + sband = ar->hw->wiphy->bands[def->chan->band]; + basic_rate_idx =ffs (vif->bss_conf.basic_rates) -1 ; + bitrate = sband->bitrates[basic_rate_idx].bitrate; + + hw_rate_code =ath12k_mac_get_rate_hw_value (bitrate); +if (hw_rate_code <0 ) { +ath12k_warn (ar->ab,"bitrate not supported %d\n" , bitrate); +return ; + } + + vdev_param =WMI_VDEV_PARAM_MGMT_RATE ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, vdev_param, + hw_rate_code); +if (ret) +ath12k_warn (ar->ab,"failed to set mgmt tx rate %d\n" , ret); + + vdev_param =WMI_VDEV_PARAM_BEACON_RATE ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, vdev_param, + hw_rate_code); +if (ret) +ath12k_warn (ar->ab,"failed to set beacon tx rate %d\n" , ret); +} + +static int ath12k_mac_fils_discovery (struct ath12k_vif *arvif, +struct ieee80211_bss_conf *info) +{ +struct ath12k *ar = arvif->ar; +struct sk_buff *tmpl; +int ret; +u32 interval; +bool unsol_bcast_probe_resp_enabled = false; + +if (info->fils_discovery.max_interval) { + interval = info->fils_discovery.max_interval; + + tmpl =ieee80211_get_fils_discovery_tmpl (ar->hw, arvif->vif); +if (tmpl) + ret =ath12k_wmi_fils_discovery_tmpl (ar, arvif->vdev_id, + tmpl); + }else if (info->unsol_bcast_probe_resp_interval) { + unsol_bcast_probe_resp_enabled =1 ; + interval = info->unsol_bcast_probe_resp_interval; + + tmpl =ieee80211_get_unsol_bcast_probe_resp_tmpl (ar->hw, + arvif->vif); +if (tmpl) + ret =ath12k_wmi_probe_resp_tmpl (ar, arvif->vdev_id, + tmpl); + }else {/* Disable */ +return ath12k_wmi_fils_discovery (ar, arvif->vdev_id,0 , false); + } + +if (!tmpl) { +ath12k_warn (ar->ab, +"mac vdev %i failed to retrieve %s template\n" , + arvif->vdev_id, (unsol_bcast_probe_resp_enabled ? +"unsolicited broadcast probe response" : +"FILS discovery" )); +return -EPERM ; + } +kfree_skb (tmpl); + +if (!ret) + ret =ath12k_wmi_fils_discovery (ar, arvif->vdev_id, interval, + unsol_bcast_probe_resp_enabled); + +return ret; +} + +static void ath12k_mac_op_bss_info_changed (struct ieee80211_hw *hw, +struct ieee80211_vif *vif, +struct ieee80211_bss_conf *info, +u64 changed) +{ +struct ath12k *ar = hw->priv; +struct ath12k_vif *arvif =ath12k_vif_to_arvif (vif); +struct cfg80211_chan_def def; +u32 param_id, param_value; +enum nl80211_band band; +u32 vdev_param; +int mcast_rate; +u32 preamble; +u16 hw_value; +u16 bitrate; +int ret; +u8 rateidx; +u32 rate; + +mutex_lock (&ar->conf_mutex); + +if (changed &BSS_CHANGED_BEACON_INT ) { + arvif->beacon_interval = info->beacon_int; + + param_id =WMI_VDEV_PARAM_BEACON_INTERVAL ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, + param_id, + arvif->beacon_interval); +if (ret) +ath12k_warn (ar->ab,"Failed to set beacon interval for VDEV: %d\n" , + arvif->vdev_id); +else +ath12k_dbg (ar->ab,ATH12K_DBG_MAC , +"Beacon interval: %d set for VDEV: %d\n" , + arvif->beacon_interval, arvif->vdev_id); + } + +if (changed &BSS_CHANGED_BEACON ) { + param_id =WMI_PDEV_PARAM_BEACON_TX_MODE ; + param_value =WMI_BEACON_STAGGERED_MODE ; + ret =ath12k_wmi_pdev_set_param (ar, param_id, + param_value, ar->pdev->pdev_id); +if (ret) +ath12k_warn (ar->ab,"Failed to set beacon mode for VDEV: %d\n" , + arvif->vdev_id); +else +ath12k_dbg (ar->ab,ATH12K_DBG_MAC , +"Set staggered beacon mode for VDEV: %d\n" , + arvif->vdev_id); + + ret =ath12k_mac_setup_bcn_tmpl (arvif); +if (ret) +ath12k_warn (ar->ab,"failed to update bcn template: %d\n" , + ret); + } + +if (changed & (BSS_CHANGED_BEACON_INFO |BSS_CHANGED_BEACON )) { + arvif->dtim_period = info->dtim_period; + + param_id =WMI_VDEV_PARAM_DTIM_PERIOD ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, + param_id, + arvif->dtim_period); + +if (ret) +ath12k_warn (ar->ab,"Failed to set dtim period for VDEV %d: %i\n" , + arvif->vdev_id, ret); +else +ath12k_dbg (ar->ab,ATH12K_DBG_MAC , +"DTIM period: %d set for VDEV: %d\n" , + arvif->dtim_period, arvif->vdev_id); + } + +if (changed &BSS_CHANGED_SSID && + vif->type ==NL80211_IFTYPE_AP ) { + arvif->u.ap.ssid_len = vif->cfg.ssid_len; +if (vif->cfg.ssid_len) +memcpy (arvif->u.ap.ssid, vif->cfg.ssid, vif->cfg.ssid_len); + arvif->u.ap.hidden_ssid = info->hidden_ssid; + } + +if (changed &BSS_CHANGED_BSSID && !is_zero_ether_addr (info->bssid)) +ether_addr_copy (arvif->bssid, info->bssid); + +if (changed &BSS_CHANGED_BEACON_ENABLED ) { +ath12k_control_beaconing (arvif, info); + +if (arvif->is_up && vif->bss_conf.he_support && + vif->bss_conf.he_oper.params) { +/* TODO: Extend to support 1024 BA Bitmap size */ + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, +WMI_VDEV_PARAM_BA_MODE , +WMI_BA_MODE_BUFFER_SIZE_256 ); +if (ret) +ath12k_warn (ar->ab, +"failed to set BA BUFFER SIZE 256 for vdev: %d\n" , + arvif->vdev_id); + + param_id =WMI_VDEV_PARAM_HEOPS_0_31 ; + param_value = vif->bss_conf.he_oper.params; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, + param_id, param_value); +ath12k_dbg (ar->ab,ATH12K_DBG_MAC , +"he oper param: %x set for VDEV: %d\n" , + param_value, arvif->vdev_id); + +if (ret) +ath12k_warn (ar->ab,"Failed to set he oper params %x for VDEV %d: %i\n" , + param_value, arvif->vdev_id, ret); + } + } + +if (changed &BSS_CHANGED_ERP_CTS_PROT ) { +u32 cts_prot; + + cts_prot = !!(info->use_cts_prot); + param_id =WMI_VDEV_PARAM_PROTECTION_MODE ; + +if (arvif->is_started) { + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, + param_id, cts_prot); +if (ret) +ath12k_warn (ar->ab,"Failed to set CTS prot for VDEV: %d\n" , + arvif->vdev_id); +else +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"Set CTS prot: %d for VDEV: %d\n" , + cts_prot, arvif->vdev_id); + }else { +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"defer protection mode setup, vdev is not ready yet\n" ); + } + } + +if (changed &BSS_CHANGED_ERP_SLOT ) { +u32 slottime; + +if (info->use_short_slot) + slottime =WMI_VDEV_SLOT_TIME_SHORT ;/* 9us */ + +else + slottime =WMI_VDEV_SLOT_TIME_LONG ;/* 20us */ + + param_id =WMI_VDEV_PARAM_SLOT_TIME ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, + param_id, slottime); +if (ret) +ath12k_warn (ar->ab,"Failed to set erp slot for VDEV: %d\n" , + arvif->vdev_id); +else +ath12k_dbg (ar->ab,ATH12K_DBG_MAC , +"Set slottime: %d for VDEV: %d\n" , + slottime, arvif->vdev_id); + } + +if (changed &BSS_CHANGED_ERP_PREAMBLE ) { +u32 preamble; + +if (info->use_short_preamble) + preamble =WMI_VDEV_PREAMBLE_SHORT ; +else + preamble =WMI_VDEV_PREAMBLE_LONG ; + + param_id =WMI_VDEV_PARAM_PREAMBLE ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, + param_id, preamble); +if (ret) +ath12k_warn (ar->ab,"Failed to set preamble for VDEV: %d\n" , + arvif->vdev_id); +else +ath12k_dbg (ar->ab,ATH12K_DBG_MAC , +"Set preamble: %d for VDEV: %d\n" , + preamble, arvif->vdev_id); + } + +if (changed &BSS_CHANGED_ASSOC ) { +if (vif->cfg.assoc) +ath12k_bss_assoc (hw, vif, info); +else +ath12k_bss_disassoc (hw, vif); + } + +if (changed &BSS_CHANGED_TXPOWER ) { +ath12k_dbg (ar->ab,ATH12K_DBG_MAC ,"mac vdev_id %i txpower %d\n" , + arvif->vdev_id, info->txpower); + + arvif->txpower = info->txpower; +ath12k_mac_txpower_recalc (ar); + } + +if (changed &BSS_CHANGED_MCAST_RATE && + !ath12k_mac_vif_chan (arvif->vif, &def)) { + band = def.chan->band; + mcast_rate = vif->bss_conf.mcast_rate[band]; + +if (mcast_rate >0 ) + rateidx = mcast_rate -1 ; +else + rateidx =ffs (vif->bss_conf.basic_rates) -1 ; + +if (ar->pdev->cap.supported_bands &WMI_HOST_WLAN_5G_CAP ) + rateidx +=ATH12K_MAC_FIRST_OFDM_RATE_IDX ; + + bitrate = ath12k_legacy_rates[rateidx].bitrate; + hw_value = ath12k_legacy_rates[rateidx].hw_value; + +if (ath12k_mac_bitrate_is_cck (bitrate)) + preamble =WMI_RATE_PREAMBLE_CCK ; +else + preamble =WMI_RATE_PREAMBLE_OFDM ; + + rate =ATH12K_HW_RATE_CODE (hw_value,0 , preamble); + +ath12k_dbg (ar->ab,ATH12K_DBG_MAC , +"mac vdev %d mcast_rate %x\n" , + arvif->vdev_id, rate); + + vdev_param =WMI_VDEV_PARAM_MCAST_DATA_RATE ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, + vdev_param, rate); +if (ret) +ath12k_warn (ar->ab, +"failed to set mcast rate on vdev %i: %d\n" , + arvif->vdev_id, ret); + + vdev_param =WMI_VDEV_PARAM_BCAST_DATA_RATE ; + ret =ath12k_wmi_vdev_set_param_cmd (ar, arvif->vdev_id, + vdev_param, rate); +if (ret) +ath12k_warn (ar->ab, +"failed to set bcast rate on vdev %i: %d\n" , + arvif->vdev_id, ret); + } + +if (changed &BSS_CHANGED_BASIC_RATES && + !ath12k_mac_vif_chan (arvif->vif, &def)) +ath12k_recalculate_mgmt_rate (ar, vif, &def); + +if (changed &BSS_CHANGED_TWT ) { +if (info->twt_requester || info->twt_responder) +ath12k_wmi_send_twt_enable_cmd (ar, ar->pdev->pdev_id); +else +ath12k_wmi_send_twt_disable_cmd (ar, ar->pdev->pdev_id); + } + +if (changed &BSS_CHANGED_HE_OBSS_PD ) +ath12k_wmi_send_obss_spr_cmd (ar, arvif->vdev_id, + &info->he_obss_pd); + +if (changed &BSS_CHANGED_HE_BSS_COLOR ) { +if (vif->type ==NL80211_IFTYPE_AP ) { + ret =ath12k_wmi_obss_color_cfg_cmd (ar, + arvif->vdev_id, + info->he_bss_color.color, +ATH12K_BSS_COLOR_AP_PERIODS , + info->he_bss_color.enabled); +if (ret) +ath12k_warn (ar->ab,"failed to set bss color collision on vdev %i: %d\n" , + arvif->vdev_id, ret); + }else if (vif->type ==NL80211_IFTYPE_STATION ) { + ret =ath12k_wmi_send_bss_color_change_enable_cmd (ar, + arvif->vdev_id, +1 ); +if (ret) +ath12k_warn (ar->ab,"failed to enable bss color change on vdev %i: %d\n" , + arvif->vdev_id, ret); + ret =ath12k_wmi_obss_color_cfg_cmd (ar, + arvif->vdev_id, +0 , +ATH12K_BSS_COLOR_STA_PERIODS , +1 ); +if (ret) +ath12k_warn (ar->ab,"failed to set bss color collision on vdev %i: %d\n" , + arvif->vdev_id, ret); + } + } + +if (changed &BSS_CHANGED_FILS_DISCOVERY || + changed &BSS_CHANGED_UNSOL_BCAST_PROBE_RESP ) +ath12k_mac_fils_discovery (arvif, info); + +mutex_unlock (&ar->conf_mutex); +} + +void __ath12k_mac_scan_finish (struct ath12k *ar) +{ +lockdep_assert_held (&ar->data_lock); + +switch (ar->scan.state) { +case ATH12K_SCAN_IDLE : +break ; +case ATH12K_SCAN_RUNNING : +case ATH12K_SCAN_ABORTING : +if (!ar->scan.is_roc) { +struct cfg80211_scan_info info = { + .aborted = (ar->scan.state == +ATH12K_SCAN_ABORTING ), + }; + +ieee80211_scan_completed (ar->hw, &info); + }else if (ar->scan.roc_notify) { +ieee80211_remain_on_channel_expired (ar->hw); + } + fallthrough; +case ATH12K_SCAN_STARTING : + ar->scan.state =ATH12K_SCAN_IDLE ; + ar->scan_channel =NULL ; + ar->scan.roc_freq =0 ; +cancel_delayed_work (&ar->scan.timeout); +complete (&ar->scan.completed); +break ; + } +} + +void ath12k_mac_scan_finish (struct ath12k *ar) +{ +spin_lock_bh (&ar->data_lock); +__ath12k_mac_scan_finish (ar); +spin_unlock_bh (&ar->data_lock); +} + +static int ath12k_scan_stop (struct ath12k *ar) +{ +struct ath12k_wmi_scan_cancel_arg arg = { + .req_type =WLAN_SCAN_CANCEL_SINGLE , + .scan_id =ATH12K_SCAN_ID , + }; +int ret; + +lockdep_assert_held (&ar->conf_mutex); + +/* TODO: Fill other STOP Params */ + arg.pdev_id = ar->pdev->pdev_id; + + ret =ath12k_wmi_send_scan_stop_cmd (ar, &arg); +if (ret) { +ath12k_warn (ar->ab,"failed to stop wmi scan: %d\n" , ret); + goto out; + } + + ret =wait_for_completion_timeout (&ar->scan.completed,3 *HZ ); +if (ret ==0 ) { +ath12k_warn (ar->ab, +"failed to receive scan abort comple: timed out\n" ); + ret = -ETIMEDOUT ; + }else if (ret >0 ) { + ret =0 ; + } + +out: +/* Scan state should be updated upon scan completion but in case +* firmware fails to deliver the event (for whatever reason) it is +* desired to clean up scan state anyway. Firmware may have just +* dropped the scan completion event delivery due to transport pipe +* being overflown with data and/or it can recover on its own before +* next scan request is submitted. +*/ +spin_lock_bh (&ar->data_lock); +if (ar->scan.state !=ATH12K_SCAN_IDLE ) +__ath12k_mac_scan_finish (ar); +spin_unlock_bh (&ar->data_lock); + +return ret; +} + +static void ath12k_scan_abort (struct ath12k *ar) +{ +int ret; + +lockdep_assert_held (&ar->conf_mutex); + +spin_lock_bh (&ar->data_lock); + +switch (ar->scan.state) { +case ATH12K_SCAN_IDLE : +/* This can happen if timeout worker kicked in and called +* abortion while scan completion was being processed. +*/ +break ; +case ATH12K_SCAN_STARTING : +case ATH12K_SCAN_ABORTING : +ath12k_warn (ar->ab,"refusing scan abortion due to invalid scan state: %d\n" , + ar->scan.state); +break ; +case ATH12K_SCAN_RUNNING : + ar->scan.state =ATH12K_SCAN_ABORTING ; +spin_unlock_bh (&ar->data_lock); + + ret =ath12k_scan_stop (ar); +if (ret) +ath12k_warn (ar->ab,"failed to abort scan: %d\n" , ret); + +spin_lock_bh (&ar->data_lock); +break ; + } + +spin_unlock_bh (&ar->data_lock); +} + +static void ath12k_scan_timeout_work (struct work_struct *work) +{ + struct ath12k *ar = container_of(work, struct ath12k, + scan.timeout.work); + +mutex_lock (&ar->conf_mutex); +ath12k_scan_abort (ar); +mutex_unlock (&ar->conf_mutex); +} + +static int ath12k_start_scan (struct ath12k *ar, +struct ath12k_wmi_scan_req_arg *arg) +{ +int ret; + +lockdep_assert_held (&ar->conf_mutex); + + ret =ath12k_wmi_send_scan_start_cmd (ar, arg); +if (ret) +return ret; + + ret =wait_for_completion_timeout (&ar->scan.started,1 *HZ ); +if (ret ==0 ) { + ret =ath12k_scan_stop (ar); +if (ret) +ath12k_warn (ar->ab,"failed to stop scan: %d\n" , ret); + +return -ETIMEDOUT ; + } + +/* If we failed to start the scan, return error code at +* this point. This is probably due to some issue in the +* firmware, but no need to wedge the driver due to that... +*/ +spin_lock_bh (&ar->data_lock); +if (ar->scan.state ==ATH12K_SCAN_IDLE ) { +spin_unlock_bh (&ar->data_lock); +return -EINVAL ; + } +spin_unlock_bh (&ar->data_lock); + +return 0 ; +} + +static int ath12k_mac_op_hw_scan (struct ieee80211_hw *hw, +struct ieee80211_vif *vif, +struct ieee80211_scan_request *hw_req) +{ +struct ath12k *ar = hw->priv; +struct ath12k_vif *arvif =ath12k_vif_to_arvif (vif); +struct cfg80211_scan_request *req = &hw_req->req; +struct ath12k_wmi_scan_req_arg arg = {}; +int ret; +int i; + +mutex_lock (&ar->conf_mutex); + +spin_lock_bh (&ar->data_lock); +switch (ar->scan.state) { +case ATH12K_SCAN_IDLE : +reinit_completion (&ar->scan.started); +reinit_completion (&ar->scan.completed); + ar->scan.state =ATH12K_SCAN_STARTING ; + ar->scan.is_roc = false; + ar->scan.vdev_id = arvif->vdev_id; + ret =0 ; +break ; +case ATH12K_SCAN_STARTING : +case ATH12K_SCAN_RUNNING : +case ATH12K_SCAN_ABORTING : + ret = -EBUSY ; +break ; + } +spin_unlock_bh (&ar->data_lock); + +if (ret) + goto exit; + +ath12k_wmi_start_scan_init (ar, &arg); + arg.vdev_id = arvif->vdev_id; + arg.scan_id =ATH12K_SCAN_ID ; + +if (req->ie_len) { + arg.extraie.len = req->ie_len; + arg.extraie.ptr =kzalloc (req->ie_len,GFP_KERNEL ); +memcpy (arg.extraie.ptr, req->ie, req->ie_len); + } + +if (req->n_ssids) { + arg.num_ssids = req->n_ssids; +for (i =0 ; i < arg.num_ssids; i++) + arg.ssid[i] = req->ssids[i]; + }else { + arg.scan_flags |=WMI_SCAN_FLAG_PASSIVE ; + } + +if (req->n_channels) { + arg.num_chan = req->n_channels; +for (i =0 ; i < arg.num_chan; i++) + arg.chan_list[i] = req->channels[i]->center_freq; + } + + ret =ath12k_start_scan (ar, &arg); +if (ret) { +ath12k_warn (ar->ab,"failed to start hw scan: %d\n" , ret); +spin_lock_bh (&ar->data_lock); + ar->scan.state =ATH12K_SCAN_IDLE ; +spin_unlock_bh (&ar->data_lock); + } + +/* Add a margin to account for event/command processing */ +ieee80211_queue_delayed_work (ar->hw, &ar->scan.timeout, +msecs_to_jiffies (arg.max_scan_time + +ATH12K_MAC_SCAN_TIMEOUT_MSECS )); + +exit: +if (req->ie_len) +kfree (arg.extraie.ptr); + +mutex_unlock (&ar->conf_mutex); +return ret; +} + +static void ath12k_mac_op_cancel_hw_scan (struct ieee80211_hw *hw, +struct ieee80211_vif *vif) +{ +struct ath12k *ar = hw->priv; + +mutex_lock (&ar->conf_mutex); +ath12k_scan_abort (ar); +mutex_unlock (&ar->conf_mutex); + +cancel_delayed_work_sync (&ar->scan.timeout); +} + +static int ath12k_install_key (struct ath12k_vif *arvif, +struct ieee80211_key_conf *key, +enum set_key_cmd cmd, +const u8 *macaddr,u32 flags) +{ +int ret; +struct ath12k *ar = arvif->ar; +struct wmi_vdev_install_key_arg arg = { + .vdev_id = arvif->vdev_id, + .key_idx = key->keyidx, + .key_len = key->keylen, + .key_data = key->key, + .key_flags = flags, + .macaddr = macaddr, + }; + +lockdep_assert_held (&arvif->ar->conf_mutex); + +reinit_completion (&ar->install_key_done); + +if (test_bit (ATH12K_FLAG_HW_CRYPTO_DISABLED , &ar->ab->dev_flags)) +return 0 ; + +if (cmd ==DISABLE_KEY ) { +/* TODO: Check if FW expects value other than NONE for del */ +/* arg.key_cipher = WMI_CIPHER_NONE; */ + arg.key_len =0 ; + arg.key_data =NULL ; + goto install; + } + +switch (key->cipher) { +case WLAN_CIPHER_SUITE_CCMP : + arg.key_cipher =WMI_CIPHER_AES_CCM ; +/* TODO: Re-check if flag is valid */ + key->flags |=IEEE80211_KEY_FLAG_GENERATE_IV_MGMT ; +break ; +case WLAN_CIPHER_SUITE_TKIP : + arg.key_cipher =WMI_CIPHER_TKIP ; + arg.key_txmic_len =8 ; + arg.key_rxmic_len =8 ; +break ; +case WLAN_CIPHER_SUITE_CCMP_256 : + arg.key_cipher =WMI_CIPHER_AES_CCM ; +break ; +case WLAN_CIPHER_SUITE_GCMP : +case WLAN_CIPHER_SUITE_GCMP_256 : + arg.key_cipher =WMI_CIPHER_AES_GCM ; +break ; +default : +ath12k_warn (ar->ab,"cipher %d is not supported\n" , key->cipher); +return -EOPNOTSUPP ; + } + +if (test_bit (ATH12K_FLAG_RAW_MODE , &ar->ab->dev_flags)) + key->flags |=IEEE80211_KEY_FLAG_GENERATE_IV | +IEEE80211_KEY_FLAG_RESERVE_TAILROOM ; + +install: + ret =ath12k_wmi_vdev_install_key (arvif->ar, &arg); + +if (ret) +return ret; + +if (!wait_for_completion_timeout (&ar->install_key_done,1 *HZ )) +return -ETIMEDOUT ; + +if (ether_addr_equal (macaddr, arvif->vif->addr)) + arvif->key_cipher = key->cipher; + +return ar->install_key_status ? -EINVAL :0 ; +} + +static int ath12k_clear_peer_keys (struct ath12k_vif *arvif, +const u8 *addr) +{ +struct ath12k *ar = arvif->ar; +struct ath12k_base *ab = ar->ab; +struct ath12k_peer *peer; +int first_errno =0 ; +int ret; +int i; +u32 flags =0 ; + +lockdep_assert_held (&ar->conf_mutex); + +spin_lock_bh (&ab->base_lock); + peer =ath12k_peer_find (ab, arvif->vdev_id, addr); +spin_unlock_bh (&ab->base_lock); + +if (!peer) +return -ENOENT ; + +for (i =0 ; i <ARRAY_SIZE (peer->keys); i++) { +if (!peer->keys[i]) +continue ; + +/* key flags are not required to delete the key */ + ret =ath12k_install_key (arvif, peer->keys[i], +DISABLE_KEY , addr, flags); +if (ret <0 && first_errno ==0 ) + first_errno = ret; + +if (ret <0 ) +ath12k_warn (ab,"failed to remove peer key %d: %d\n" , + i, ret); + +spin_lock_bh (&ab->base_lock); + peer->keys[i] =NULL ; +spin_unlock_bh (&ab->base_lock); + } + +return first_errno; +} + +static int ath12k_mac_op_set_key (struct ieee80211_hw *hw,enum set_key_cmd cmd, +struct ieee80211_vif *vif,struct ieee80211_sta *sta, +struct ieee80211_key_conf *key) +{ +struct ath12k *ar = hw->priv; +struct ath12k_base *ab = ar->ab; +struct ath12k_vif *arvif =ath12k_vif_to_arvif (vif); +struct ath12k_peer *peer; +struct ath12k_sta *arsta; +const u8 *peer_addr; +int ret =0 ; +u32 flags =0 ; + +/* BIP needs to be done in software */ +if (key->cipher ==WLAN_CIPHER_SUITE_AES_CMAC || + key->cipher ==WLAN_CIPHER_SUITE_BIP_GMAC_128 || + key->cipher ==WLAN_CIPHER_SUITE_BIP_GMAC_256 || + key->cipher ==WLAN_CIPHER_SUITE_BIP_CMAC_256 ) +return 1 ; + +if (test_bit (ATH12K_FLAG_HW_CRYPTO_DISABLED , &ar->ab->dev_flags)) +return 1 ; + +if (key->keyidx >WMI_MAX_KEY_INDEX ) +return -ENOSPC ; + +mutex_lock (&ar->conf_mutex); + +if (sta) + peer_addr = sta->addr; +else if (arvif->vdev_type ==WMI_VDEV_TYPE_STA ) + peer_addr = vif->bss_conf.bssid; +else + peer_addr = vif->addr; + + key->hw_key_idx = key->keyidx; + +/* the peer should not disappear in mid-way (unless FW goes awry) since +* we already hold conf_mutex. we just make sure its there now. +*/ +spin_lock_bh (&ab->base_lock); + peer =ath12k_peer_find (ab, arvif->vdev_id, peer_addr); +spin_unlock_bh (&ab->base_lock); + +if (!peer) { +if (cmd ==SET_KEY ) { +ath12k_warn (ab,"cannot install key for non-existent peer %pM\n" , + peer_addr); + ret = -EOPNOTSUPP ; + goto exit; + }else { +/* if the peer doesn't exist there is no key to disable +* anymore +*/ + goto exit; + } + } + +if (key->flags &IEEE80211_KEY_FLAG_PAIRWISE ) + flags |=WMI_KEY_PAIRWISE ; +else + flags |=WMI_KEY_GROUP ; + + ret =ath12k_install_key (arvif, key, cmd, peer_addr, flags); +if (ret) { +ath12k_warn (ab,"ath12k_install_key failed (%d)\n" , ret); + goto exit; + } + + ret =ath12k_dp_rx_peer_pn_replay_config (arvif, peer_addr, cmd, key); +if (ret) { +ath12k_warn (ab,"failed to offload PN replay detection %d\n" , ret); + goto exit; + } + +spin_lock_bh (&ab->base_lock); + peer =ath12k_peer_find (ab, arvif->vdev_id, peer_addr); +if (peer && cmd ==SET_KEY ) { + peer->keys[key->keyidx] = key;
Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Signature · 3 lines
ath12k mailing list [email protected] https://lists.infradead.org/mailman/listinfo/ath12k
Part of the diff is not shown here. View the raw message.
PATCH v2 32/50 wifi: ath12k: add mac.h
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/mac.h | 76 +++++++++++++++++++++++++++++++++++ 1 file changed, 76 insertions(+)
drivers/net/wireless/ath/ath12k/mac.h new file +76 -0
@@ -0,0 +1,76 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2018-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#ifndef ATH12K_MAC_H +#define ATH12K_MAC_H + +#include <net/mac80211.h> +#include <net/cfg80211.h> + +struct ath12k ; +struct ath12k_base ; + +struct ath12k_generic_iter { +struct ath12k *ar; +int ret; +}; + +/* number of failed packets (20 packets with 16 sw reties each) */ +#define ATH12K_KICKOUT_THRESHOLD (20 * 16) + +/* Use insanely high numbers to make sure that the firmware implementation +* won't start, we have the same functionality already in hostapd. Unit +* is seconds. +*/ +#define ATH12K_KEEPALIVE_MIN_IDLE 3747 +#define ATH12K_KEEPALIVE_MAX_IDLE 3895 +#define ATH12K_KEEPALIVE_MAX_UNRESPONSIVE 3900 + +/* FIXME: should these be in ieee80211.h? */ +#define IEEE80211_VHT_MCS_SUPPORT_0_11_MASK GENMASK(23, 16) +#define IEEE80211_DISABLE_VHT_MCS_SUPPORT_0_11 BIT(24) + +#define ATH12K_CHAN_WIDTH_NUM 8 + +#define ATH12K_TX_POWER_MAX_VAL 70 +#define ATH12K_TX_POWER_MIN_VAL 0 + +enum ath12k_supported_bw { +ATH12K_BW_20 =0 , +ATH12K_BW_40 =1 , +ATH12K_BW_80 =2 , +ATH12K_BW_160 =3 , +}; + +extern const struct htt_rx_ring_tlv_filter ath12k_mac_mon_status_filter_default; + +void ath12k_mac_destroy (struct ath12k_base *ab); +void ath12k_mac_unregister (struct ath12k_base *ab); +int ath12k_mac_register (struct ath12k_base *ab); +int ath12k_mac_allocate (struct ath12k_base *ab); +int ath12k_mac_hw_ratecode_to_legacy_rate (u8 hw_rc,u8 preamble,u8 *rateidx, +u16 *rate); +u8 ath12k_mac_bitrate_to_idx (const struct ieee80211_supported_band *sband, +u32 bitrate); +u8 ath12k_mac_hw_rate_to_idx (const struct ieee80211_supported_band *sband, +u8 hw_rate,bool cck); + +void __ath12k_mac_scan_finish (struct ath12k *ar); +void ath12k_mac_scan_finish (struct ath12k *ar); + +struct ath12k_vif *ath12k_mac_get_arvif (struct ath12k *ar,u32 vdev_id); +struct ath12k_vif *ath12k_mac_get_arvif_by_vdev_id (struct ath12k_base *ab, +u32 vdev_id); +struct ath12k *ath12k_mac_get_ar_by_vdev_id (struct ath12k_base *ab,u32 vdev_id); +struct ath12k *ath12k_mac_get_ar_by_pdev_id (struct ath12k_base *ab,u32 pdev_id); + +void ath12k_mac_drain_tx (struct ath12k *ar); +void ath12k_mac_peer_cleanup_all (struct ath12k *ar); +int ath12k_mac_tx_mgmt_pending_free (int buf_id,void *skb,void *ctx); +enum rate_info_bw ath12k_mac_bw_to_mac80211_bw (enum ath12k_supported_bw bw); +enum ath12k_supported_bw ath12k_mac_mac80211_bw_to_ath12k_bw (enum rate_info_bw bw); +enum hal_encrypt_type ath12k_dp_tx_get_encrypt_type (u32 cipher); +#endif
Signature · 3 lines
ath12k mailing list [email protected] https://lists.infradead.org/mailman/listinfo/ath12k
PATCH v2 33/50 wifi: ath12k: add mhi.c
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/mhi.c | 616 ++++++++++++++++++++++++++++++++++ 1 file changed, 616 insertions(+)
drivers/net/wireless/ath/ath12k/mhi.c new file +616 -0
@@ -0,0 +1,616 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2020-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#include <linux/msi.h> +#include <linux/pci.h> + +#include "core.h" +#include "debug.h" +#include "mhi.h" +#include "pci.h" + +#define MHI_TIMEOUT_DEFAULT_MS 90000 + +static const struct mhi_channel_config ath12k_mhi_channels_qcn9274[] = { + { + .num =0 , + .name ="LOOPBACK" , + .num_elements =32 , + .event_ring =1 , + .dir =DMA_TO_DEVICE , + .ee_mask =0x4 , + .pollcfg =0 , + .doorbell =MHI_DB_BRST_DISABLE , + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = false, + }, + { + .num =1 , + .name ="LOOPBACK" , + .num_elements =32 , + .event_ring =1 , + .dir =DMA_FROM_DEVICE , + .ee_mask =0x4 , + .pollcfg =0 , + .doorbell =MHI_DB_BRST_DISABLE , + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = false, + }, + { + .num =20 , + .name ="IPCR" , + .num_elements =32 , + .event_ring =1 , + .dir =DMA_TO_DEVICE , + .ee_mask =0x4 , + .pollcfg =0 , + .doorbell =MHI_DB_BRST_DISABLE , + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = false, + }, + { + .num =21 , + .name ="IPCR" , + .num_elements =32 , + .event_ring =1 , + .dir =DMA_FROM_DEVICE , + .ee_mask =0x4 , + .pollcfg =0 , + .doorbell =MHI_DB_BRST_DISABLE , + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = true, + }, +}; + +static struct mhi_event_config ath12k_mhi_events_qcn9274[] = { + { + .num_elements =32 , + .irq_moderation_ms =0 , + .irq =1 , + .data_type =MHI_ER_CTRL , + .mode =MHI_DB_BRST_DISABLE , + .hardware_event = false, + .client_managed = false, + .offload_channel = false, + }, + { + .num_elements =256 , + .irq_moderation_ms =1 , + .irq =2 , + .mode =MHI_DB_BRST_DISABLE , + .priority =1 , + .hardware_event = false, + .client_managed = false, + .offload_channel = false, + }, +}; + +const struct mhi_controller_config ath12k_mhi_config_qcn9274 = { + .max_channels =30 , + .timeout_ms =10000 , + .use_bounce_buf = false, + .buf_len =0 , + .num_channels =ARRAY_SIZE (ath12k_mhi_channels_qcn9274), + .ch_cfg = ath12k_mhi_channels_qcn9274, + .num_events =ARRAY_SIZE (ath12k_mhi_events_qcn9274), + .event_cfg = ath12k_mhi_events_qcn9274, +}; + +static const struct mhi_channel_config ath12k_mhi_channels_wcn7850[] = { + { + .num =0 , + .name ="LOOPBACK" , + .num_elements =32 , + .event_ring =0 , + .dir =DMA_TO_DEVICE , + .ee_mask =0x4 , + .pollcfg =0 , + .doorbell =MHI_DB_BRST_DISABLE , + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = false, + }, + { + .num =1 , + .name ="LOOPBACK" , + .num_elements =32 , + .event_ring =0 , + .dir =DMA_FROM_DEVICE , + .ee_mask =0x4 , + .pollcfg =0 , + .doorbell =MHI_DB_BRST_DISABLE , + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = false, + }, + { + .num =20 , + .name ="IPCR" , + .num_elements =64 , + .event_ring =1 , + .dir =DMA_TO_DEVICE , + .ee_mask =0x4 , + .pollcfg =0 , + .doorbell =MHI_DB_BRST_DISABLE , + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = false, + }, + { + .num =21 , + .name ="IPCR" , + .num_elements =64 , + .event_ring =1 , + .dir =DMA_FROM_DEVICE , + .ee_mask =0x4 , + .pollcfg =0 , + .doorbell =MHI_DB_BRST_DISABLE , + .lpm_notify = false, + .offload_channel = false, + .doorbell_mode_switch = false, + .auto_queue = true, + }, +}; + +static struct mhi_event_config ath12k_mhi_events_wcn7850[] = { + { + .num_elements =32 , + .irq_moderation_ms =0 , + .irq =1 , + .mode =MHI_DB_BRST_DISABLE , + .data_type =MHI_ER_CTRL , + .hardware_event = false, + .client_managed = false, + .offload_channel = false, + }, + { + .num_elements =256 , + .irq_moderation_ms =1 , + .irq =2 , + .mode =MHI_DB_BRST_DISABLE , + .priority =1 , + .hardware_event = false, + .client_managed = false, + .offload_channel = false, + }, +}; + +const struct mhi_controller_config ath12k_mhi_config_wcn7850 = { + .max_channels =128 , + .timeout_ms =2000 , + .use_bounce_buf = false, + .buf_len =0 , + .num_channels =ARRAY_SIZE (ath12k_mhi_channels_wcn7850), + .ch_cfg = ath12k_mhi_channels_wcn7850, + .num_events =ARRAY_SIZE (ath12k_mhi_events_wcn7850), + .event_cfg = ath12k_mhi_events_wcn7850, +}; + +void ath12k_mhi_set_mhictrl_reset (struct ath12k_base *ab) +{ +u32 val; + + val =ath12k_pci_read32 (ab,MHISTATUS ); + +ath12k_dbg (ab,ATH12K_DBG_PCI ,"MHISTATUS 0x%x\n" , val); + +/* Observed on some targets that after SOC_GLOBAL_RESET, MHISTATUS +* has SYSERR bit set and thus need to set MHICTRL_RESET +* to clear SYSERR. +*/ +ath12k_pci_write32 (ab,MHICTRL ,MHICTRL_RESET_MASK ); + +mdelay (10 ); +} + +static void ath12k_mhi_reset_txvecdb (struct ath12k_base *ab) +{ +ath12k_pci_write32 (ab,PCIE_TXVECDB ,0 ); +} + +static void ath12k_mhi_reset_txvecstatus (struct ath12k_base *ab) +{ +ath12k_pci_write32 (ab,PCIE_TXVECSTATUS ,0 ); +} + +static void ath12k_mhi_reset_rxvecdb (struct ath12k_base *ab) +{ +ath12k_pci_write32 (ab,PCIE_RXVECDB ,0 ); +} + +static void ath12k_mhi_reset_rxvecstatus (struct ath12k_base *ab) +{ +ath12k_pci_write32 (ab,PCIE_RXVECSTATUS ,0 ); +} + +void ath12k_mhi_clear_vector (struct ath12k_base *ab) +{ +ath12k_mhi_reset_txvecdb (ab); +ath12k_mhi_reset_txvecstatus (ab); +ath12k_mhi_reset_rxvecdb (ab); +ath12k_mhi_reset_rxvecstatus (ab); +} + +static int ath12k_mhi_get_msi (struct ath12k_pci *ab_pci) +{ +struct ath12k_base *ab = ab_pci->ab; +u32 user_base_data, base_vector; +int ret, num_vectors, i; +int *irq; + + ret =ath12k_pci_get_user_msi_assignment (ab, +"MHI" , &num_vectors, + &user_base_data, &base_vector); +if (ret) +return ret; + +ath12k_dbg (ab,ATH12K_DBG_PCI ,"Number of assigned MSI for MHI is %d, base vector is %d\n" , + num_vectors, base_vector); + + irq =kcalloc (num_vectors,sizeof (*irq),GFP_KERNEL ); +if (!irq) +return -ENOMEM ; + +for (i =0 ; i < num_vectors; i++) + irq[i] =ath12k_pci_get_msi_irq (ab->dev, + base_vector + i); + + ab_pci->mhi_ctrl->irq = irq; + ab_pci->mhi_ctrl->nr_irqs = num_vectors; + +return 0 ; +} + +static int ath12k_mhi_op_runtime_get (struct mhi_controller *mhi_cntrl) +{ +return 0 ; +} + +static void ath12k_mhi_op_runtime_put (struct mhi_controller *mhi_cntrl) +{ +} + +static char *ath12k_mhi_op_callback_to_str (enum mhi_callback reason) +{ +switch (reason) { +case MHI_CB_IDLE : +return "MHI_CB_IDLE" ; +case MHI_CB_PENDING_DATA : +return "MHI_CB_PENDING_DATA" ; +case MHI_CB_LPM_ENTER : +return "MHI_CB_LPM_ENTER" ; +case MHI_CB_LPM_EXIT : +return "MHI_CB_LPM_EXIT" ; +case MHI_CB_EE_RDDM : +return "MHI_CB_EE_RDDM" ; +case MHI_CB_EE_MISSION_MODE : +return "MHI_CB_EE_MISSION_MODE" ; +case MHI_CB_SYS_ERROR : +return "MHI_CB_SYS_ERROR" ; +case MHI_CB_FATAL_ERROR : +return "MHI_CB_FATAL_ERROR" ; +case MHI_CB_BW_REQ : +return "MHI_CB_BW_REQ" ; +default : +return "UNKNOWN" ; + } +} + +static void ath12k_mhi_op_status_cb (struct mhi_controller *mhi_cntrl, +enum mhi_callback cb) +{ +struct ath12k_base *ab =dev_get_drvdata (mhi_cntrl->cntrl_dev); + +ath12k_dbg (ab,ATH12K_DBG_BOOT ,"mhi notify status reason %s\n" , +ath12k_mhi_op_callback_to_str (cb)); + +switch (cb) { +case MHI_CB_SYS_ERROR : +ath12k_warn (ab,"firmware crashed: MHI_CB_SYS_ERROR\n" ); +break ; +case MHI_CB_EE_RDDM : +if (!(test_bit (ATH12K_FLAG_UNREGISTERING , &ab->dev_flags))) +queue_work (ab->workqueue_aux, &ab->reset_work); +break ; +default : +break ; + } +} + +static int ath12k_mhi_op_read_reg (struct mhi_controller *mhi_cntrl, +void __iomem *addr, +u32 *out) +{ + *out =readl (addr); + +return 0 ; +} + +static void ath12k_mhi_op_write_reg (struct mhi_controller *mhi_cntrl, +void __iomem *addr, +u32 val) +{ +writel (val, addr); +} + +int ath12k_mhi_register (struct ath12k_pci *ab_pci) +{ +struct ath12k_base *ab = ab_pci->ab; +struct mhi_controller *mhi_ctrl; +int ret; + + mhi_ctrl =mhi_alloc_controller (); +if (!mhi_ctrl) +return -ENOMEM ; + +ath12k_core_create_firmware_path (ab,ATH12K_AMSS_FILE , + ab_pci->amss_path, +sizeof (ab_pci->amss_path)); + + ab_pci->mhi_ctrl = mhi_ctrl; + mhi_ctrl->cntrl_dev = ab->dev; + mhi_ctrl->fw_image = ab_pci->amss_path; + mhi_ctrl->regs = ab->mem; + mhi_ctrl->reg_len = ab->mem_len; + + ret =ath12k_mhi_get_msi (ab_pci); +if (ret) { +ath12k_err (ab,"failed to get msi for mhi\n" ); +mhi_free_controller (mhi_ctrl); +return ret; + } + + mhi_ctrl->iova_start =0 ; + mhi_ctrl->iova_stop =0xffffffff ; + mhi_ctrl->sbl_size =SZ_512K ; + mhi_ctrl->seg_len =SZ_512K ; + mhi_ctrl->fbc_download = true; + mhi_ctrl->runtime_get = ath12k_mhi_op_runtime_get; + mhi_ctrl->runtime_put = ath12k_mhi_op_runtime_put; + mhi_ctrl->status_cb = ath12k_mhi_op_status_cb; + mhi_ctrl->read_reg = ath12k_mhi_op_read_reg; + mhi_ctrl->write_reg = ath12k_mhi_op_write_reg; + + ret =mhi_register_controller (mhi_ctrl, ab->hw_params->mhi_config); +if (ret) { +ath12k_err (ab,"failed to register to mhi bus, err = %d\n" , ret); +mhi_free_controller (mhi_ctrl); +return ret; + } + +return 0 ; +} + +void ath12k_mhi_unregister (struct ath12k_pci *ab_pci) +{ +struct mhi_controller *mhi_ctrl = ab_pci->mhi_ctrl; + +mhi_unregister_controller (mhi_ctrl); +kfree (mhi_ctrl->irq); +mhi_free_controller (mhi_ctrl); + ab_pci->mhi_ctrl =NULL ; +} + +static char *ath12k_mhi_state_to_str (enum ath12k_mhi_state mhi_state) +{ +switch (mhi_state) { +case ATH12K_MHI_INIT : +return "INIT" ; +case ATH12K_MHI_DEINIT : +return "DEINIT" ; +case ATH12K_MHI_POWER_ON : +return "POWER_ON" ; +case ATH12K_MHI_POWER_OFF : +return "POWER_OFF" ; +case ATH12K_MHI_FORCE_POWER_OFF : +return "FORCE_POWER_OFF" ; +case ATH12K_MHI_SUSPEND : +return "SUSPEND" ; +case ATH12K_MHI_RESUME : +return "RESUME" ; +case ATH12K_MHI_TRIGGER_RDDM : +return "TRIGGER_RDDM" ; +case ATH12K_MHI_RDDM_DONE : +return "RDDM_DONE" ; +default : +return "UNKNOWN" ; + } +}; + +static void ath12k_mhi_set_state_bit (struct ath12k_pci *ab_pci, +enum ath12k_mhi_state mhi_state) +{ +struct ath12k_base *ab = ab_pci->ab; + +switch (mhi_state) { +case ATH12K_MHI_INIT : +set_bit (ATH12K_MHI_INIT , &ab_pci->mhi_state); +break ; +case ATH12K_MHI_DEINIT : +clear_bit (ATH12K_MHI_INIT , &ab_pci->mhi_state); +break ; +case ATH12K_MHI_POWER_ON : +set_bit (ATH12K_MHI_POWER_ON , &ab_pci->mhi_state); +break ; +case ATH12K_MHI_POWER_OFF : +case ATH12K_MHI_FORCE_POWER_OFF : +clear_bit (ATH12K_MHI_POWER_ON , &ab_pci->mhi_state); +clear_bit (ATH12K_MHI_TRIGGER_RDDM , &ab_pci->mhi_state); +clear_bit (ATH12K_MHI_RDDM_DONE , &ab_pci->mhi_state); +break ; +case ATH12K_MHI_SUSPEND : +set_bit (ATH12K_MHI_SUSPEND , &ab_pci->mhi_state); +break ; +case ATH12K_MHI_RESUME : +clear_bit (ATH12K_MHI_SUSPEND , &ab_pci->mhi_state); +break ; +case ATH12K_MHI_TRIGGER_RDDM : +set_bit (ATH12K_MHI_TRIGGER_RDDM , &ab_pci->mhi_state); +break ; +case ATH12K_MHI_RDDM_DONE : +set_bit (ATH12K_MHI_RDDM_DONE , &ab_pci->mhi_state); +break ; +default : +ath12k_err (ab,"unhandled mhi state (%d)\n" , mhi_state); + } +} + +static int ath12k_mhi_check_state_bit (struct ath12k_pci *ab_pci, +enum ath12k_mhi_state mhi_state) +{ +struct ath12k_base *ab = ab_pci->ab; + +switch (mhi_state) { +case ATH12K_MHI_INIT : +if (!test_bit (ATH12K_MHI_INIT , &ab_pci->mhi_state)) +return 0 ; +break ; +case ATH12K_MHI_DEINIT : +case ATH12K_MHI_POWER_ON : +if (test_bit (ATH12K_MHI_INIT , &ab_pci->mhi_state) && + !test_bit (ATH12K_MHI_POWER_ON , &ab_pci->mhi_state)) +return 0 ; +break ; +case ATH12K_MHI_FORCE_POWER_OFF : +if (test_bit (ATH12K_MHI_POWER_ON , &ab_pci->mhi_state)) +return 0 ; +break ; +case ATH12K_MHI_POWER_OFF : +case ATH12K_MHI_SUSPEND : +if (test_bit (ATH12K_MHI_POWER_ON , &ab_pci->mhi_state) && + !test_bit (ATH12K_MHI_SUSPEND , &ab_pci->mhi_state)) +return 0 ; +break ; +case ATH12K_MHI_RESUME : +if (test_bit (ATH12K_MHI_SUSPEND , &ab_pci->mhi_state)) +return 0 ; +break ; +case ATH12K_MHI_TRIGGER_RDDM : +if (test_bit (ATH12K_MHI_POWER_ON , &ab_pci->mhi_state) && + !test_bit (ATH12K_MHI_TRIGGER_RDDM , &ab_pci->mhi_state)) +return 0 ; +break ; +case ATH12K_MHI_RDDM_DONE : +return 0 ; +default : +ath12k_err (ab,"unhandled mhi state: %s(%d)\n" , +ath12k_mhi_state_to_str (mhi_state), mhi_state); + } + +ath12k_err (ab,"failed to set mhi state %s(%d) in current mhi state (0x%lx)\n" , +ath12k_mhi_state_to_str (mhi_state), mhi_state, + ab_pci->mhi_state); + +return -EINVAL ; +} + +static int ath12k_mhi_set_state (struct ath12k_pci *ab_pci, +enum ath12k_mhi_state mhi_state) +{ +struct ath12k_base *ab = ab_pci->ab; +int ret; + + ret =ath12k_mhi_check_state_bit (ab_pci, mhi_state); +if (ret) + goto out; + +ath12k_dbg (ab,ATH12K_DBG_PCI ,"setting mhi state: %s(%d)\n" , +ath12k_mhi_state_to_str (mhi_state), mhi_state); + +switch (mhi_state) { +case ATH12K_MHI_INIT : + ret =mhi_prepare_for_power_up (ab_pci->mhi_ctrl); +break ; +case ATH12K_MHI_DEINIT : +mhi_unprepare_after_power_down (ab_pci->mhi_ctrl); + ret =0 ; +break ; +case ATH12K_MHI_POWER_ON : + ret =mhi_async_power_up (ab_pci->mhi_ctrl); +break ; +case ATH12K_MHI_POWER_OFF : +mhi_power_down (ab_pci->mhi_ctrl, true); + ret =0 ; +break ; +case ATH12K_MHI_FORCE_POWER_OFF : +mhi_power_down (ab_pci->mhi_ctrl, false); + ret =0 ; +break ; +case ATH12K_MHI_SUSPEND : + ret =mhi_pm_suspend (ab_pci->mhi_ctrl); +break ; +case ATH12K_MHI_RESUME : + ret =mhi_pm_resume (ab_pci->mhi_ctrl); +break ; +case ATH12K_MHI_TRIGGER_RDDM : + ret =mhi_force_rddm_mode (ab_pci->mhi_ctrl); +break ; +case ATH12K_MHI_RDDM_DONE : +break ; +default : +ath12k_err (ab,"unhandled MHI state (%d)\n" , mhi_state); + ret = -EINVAL ; + } + +if (ret) + goto out; + +ath12k_mhi_set_state_bit (ab_pci, mhi_state); + +return 0 ; + +out: +ath12k_err (ab,"failed to set mhi state: %s(%d)\n" , +ath12k_mhi_state_to_str (mhi_state), mhi_state); +return ret; +} + +int ath12k_mhi_start (struct ath12k_pci *ab_pci) +{ +int ret; + + ab_pci->mhi_ctrl->timeout_ms =MHI_TIMEOUT_DEFAULT_MS ; + + ret =ath12k_mhi_set_state (ab_pci,ATH12K_MHI_INIT ); +if (ret) + goto out; + + ret =ath12k_mhi_set_state (ab_pci,ATH12K_MHI_POWER_ON ); +if (ret) + goto out; + +return 0 ; + +out: +return ret; +} + +void ath12k_mhi_stop (struct ath12k_pci *ab_pci) +{ +ath12k_mhi_set_state (ab_pci,ATH12K_MHI_POWER_OFF ); +ath12k_mhi_set_state (ab_pci,ATH12K_MHI_DEINIT ); +} + +void ath12k_mhi_suspend (struct ath12k_pci *ab_pci) +{ +ath12k_mhi_set_state (ab_pci,ATH12K_MHI_SUSPEND ); +} + +void ath12k_mhi_resume (struct ath12k_pci *ab_pci) +{ +ath12k_mhi_set_state (ab_pci,ATH12K_MHI_RESUME ); +}
Signature · 3 lines
ath12k mailing list [email protected] https://lists.infradead.org/mailman/listinfo/ath12k
PATCH v2 34/50 wifi: ath12k: add mhi.h
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/mhi.h | 46 +++++++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+)
drivers/net/wireless/ath/ath12k/mhi.h new file +46 -0
@@ -0,0 +1,46 @@ +/* SPDX-License-Identifier: BSD-3-Clause-Clear */ +/* +* Copyright (c) 2020-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ +#ifndef _ATH12K_MHI_H +#define _ATH12K_MHI_H + +#include "pci.h" + +#define PCIE_TXVECDB 0x360 +#define PCIE_TXVECSTATUS 0x368 +#define PCIE_RXVECDB 0x394 +#define PCIE_RXVECSTATUS 0x39C + +#define MHISTATUS 0x48 +#define MHICTRL 0x38 +#define MHICTRL_RESET_MASK 0x2 + +enum ath12k_mhi_state { +ATH12K_MHI_INIT , +ATH12K_MHI_DEINIT , +ATH12K_MHI_POWER_ON , +ATH12K_MHI_POWER_OFF , +ATH12K_MHI_FORCE_POWER_OFF , +ATH12K_MHI_SUSPEND , +ATH12K_MHI_RESUME , +ATH12K_MHI_TRIGGER_RDDM , +ATH12K_MHI_RDDM , +ATH12K_MHI_RDDM_DONE , +}; + +extern const struct mhi_controller_config ath12k_mhi_config_qcn9274; +extern const struct mhi_controller_config ath12k_mhi_config_wcn7850; + +int ath12k_mhi_start (struct ath12k_pci *ar_pci); +void ath12k_mhi_stop (struct ath12k_pci *ar_pci); +int ath12k_mhi_register (struct ath12k_pci *ar_pci); +void ath12k_mhi_unregister (struct ath12k_pci *ar_pci); +void ath12k_mhi_set_mhictrl_reset (struct ath12k_base *ab); +void ath12k_mhi_clear_vector (struct ath12k_base *ab); + +void ath12k_mhi_suspend (struct ath12k_pci *ar_pci); +void ath12k_mhi_resume (struct ath12k_pci *ar_pci); + +#endif
Signature · 3 lines
ath12k mailing list [email protected] https://lists.infradead.org/mailman/listinfo/ath12k
PATCH v2 35/50 wifi: ath12k: add pci.c
In reply to Kalle ValoFrom: Kalle Valo <[email protected]>
(Patches split into one patch per file for easier review, but the final commit will be one big patch. See the cover letter for more info.)
--- drivers/net/wireless/ath/ath12k/pci.c | 1374 +++++++++++++++++++++++++++++++++ 1 file changed, 1374 insertions(+)
drivers/net/wireless/ath/ath12k/pci.c new file +1374 -0
@@ -0,0 +1,1374 @@ +// SPDX-License-Identifier: BSD-3-Clause-Clear +/* +* Copyright (c) 2019-2021 The Linux Foundation. All rights reserved. +* Copyright (c) 2021-2022 Qualcomm Innovation Center, Inc. All rights reserved. +*/ + +#include <linux/module.h> +#include <linux/msi.h> +#include <linux/pci.h> + +#include "pci.h" +#include "core.h" +#include "hif.h" +#include "mhi.h" +#include "debug.h" + +#define ATH12K_PCI_BAR_NUM 0 +#define ATH12K_PCI_DMA_MASK 32 + +#define ATH12K_PCI_IRQ_CE0_OFFSET 3 + +#define WINDOW_ENABLE_BIT 0x40000000 +#define WINDOW_REG_ADDRESS 0x310c +#define WINDOW_VALUE_MASK GENMASK(24, 19) +#define WINDOW_START 0x80000 +#define WINDOW_RANGE_MASK GENMASK(18, 0) +#define WINDOW_STATIC_MASK GENMASK(31, 6) + +#define TCSR_SOC_HW_VERSION 0x1B00000 +#define TCSR_SOC_HW_VERSION_MAJOR_MASK GENMASK(11, 8) +#define TCSR_SOC_HW_VERSION_MINOR_MASK GENMASK(7, 4) + +/* BAR0 + 4k is always accessible, and no +* need to force wakeup. +* 4K - 32 = 0xFE0 +*/ +#define ACCESS_ALWAYS_OFF 0xFE0 + +#define QCN9274_DEVICE_ID 0x1109 +#define WCN7850_DEVICE_ID 0x1107 + +static const struct pci_device_id ath12k_pci_id_table[] = { + {PCI_VDEVICE (QCOM ,QCN9274_DEVICE_ID ) }, + {PCI_VDEVICE (QCOM ,WCN7850_DEVICE_ID ) }, + {0 } +}; + +MODULE_DEVICE_TABLE (pci, ath12k_pci_id_table); + +/* TODO: revisit IRQ mapping for new SRNG's */ +static const struct ath12k_msi_config ath12k_msi_config[] = { + { + .total_vectors =16 , + .total_users =3 , + .users = (struct ath12k_msi_user []) { + { .name ="MHI" , .num_vectors =3 , .base_vector =0 }, + { .name ="CE" , .num_vectors =5 , .base_vector =3 }, + { .name ="DP" , .num_vectors =8 , .base_vector =8 }, + }, + }, +}; + +static const char *irq_name[ATH12K_IRQ_NUM_MAX ] = { +"bhi" , +"mhi-er0" , +"mhi-er1" , +"ce0" , +"ce1" , +"ce2" , +"ce3" , +"ce4" , +"ce5" , +"ce6" , +"ce7" , +"ce8" , +"ce9" , +"ce10" , +"ce11" , +"ce12" , +"ce13" , +"ce14" , +"ce15" , +"host2wbm-desc-feed" , +"host2reo-re-injection" , +"host2reo-command" , +"host2rxdma-monitor-ring3" , +"host2rxdma-monitor-ring2" , +"host2rxdma-monitor-ring1" , +"reo2ost-exception" , +"wbm2host-rx-release" , +"reo2host-status" , +"reo2host-destination-ring4" , +"reo2host-destination-ring3" , +"reo2host-destination-ring2" , +"reo2host-destination-ring1" , +"rxdma2host-monitor-destination-mac3" , +"rxdma2host-monitor-destination-mac2" , +"rxdma2host-monitor-destination-mac1" , +"ppdu-end-interrupts-mac3" , +"ppdu-end-interrupts-mac2" , +"ppdu-end-interrupts-mac1" , +"rxdma2host-monitor-status-ring-mac3" , +"rxdma2host-monitor-status-ring-mac2" , +"rxdma2host-monitor-status-ring-mac1" , +"host2rxdma-host-buf-ring-mac3" , +"host2rxdma-host-buf-ring-mac2" , +"host2rxdma-host-buf-ring-mac1" , +"rxdma2host-destination-ring-mac3" , +"rxdma2host-destination-ring-mac2" , +"rxdma2host-destination-ring-mac1" , +"host2tcl-input-ring4" , +"host2tcl-input-ring3" , +"host2tcl-input-ring2" , +"host2tcl-input-ring1" , +"wbm2host-tx-completions-ring4" , +"wbm2host-tx-completions-ring3" , +"wbm2host-tx-completions-ring2" , +"wbm2host-tx-completions-ring1" , +"tcl2host-status-ring" , +}; + +static void ath12k_pci_select_window (struct ath12k_pci *ab_pci,u32 offset) +{ +struct ath12k_base *ab = ab_pci->ab; + +u32 window =u32_get_bits (offset,WINDOW_VALUE_MASK ); +u32 static_window; + +lockdep_assert_held (&ab_pci->window_lock); + +/* Preserve the static window configuration and reset only dynamic window */ + static_window = ab_pci->register_window &WINDOW_STATIC_MASK ; + window |= static_window; + +if (window != ab_pci->register_window) { +iowrite32 (WINDOW_ENABLE_BIT | window, + ab->mem +WINDOW_REG_ADDRESS ); +ioread32 (ab->mem +WINDOW_REG_ADDRESS ); + ab_pci->register_window = window; + } +} + +static void ath12k_pci_select_static_window (struct ath12k_pci *ab_pci) +{ +u32 umac_window =u32_get_bits (HAL_SEQ_WCSS_UMAC_OFFSET ,WINDOW_VALUE_MASK ); +u32 ce_window =u32_get_bits (HAL_CE_WFSS_CE_REG_BASE ,WINDOW_VALUE_MASK ); +u32 window; + + window = (umac_window <<12 ) | (ce_window <<6 ); + +spin_lock_bh (&ab_pci->window_lock); + ab_pci->register_window = window; +spin_unlock_bh (&ab_pci->window_lock); + +iowrite32 (WINDOW_ENABLE_BIT | window, ab_pci->ab->mem +WINDOW_REG_ADDRESS ); +} + +static u32 ath12k_pci_get_window_start (struct ath12k_base *ab, +u32 offset) +{ +u32 window_start; + +/* If offset lies within DP register range, use 3rd window */ +if ((offset ^HAL_SEQ_WCSS_UMAC_OFFSET ) <WINDOW_RANGE_MASK ) + window_start =3 *WINDOW_START ; +/* If offset lies within CE register range, use 2nd window */ +else if ((offset ^HAL_CE_WFSS_CE_REG_BASE ) <WINDOW_RANGE_MASK ) + window_start =2 *WINDOW_START ; +/* If offset lies within PCI_BAR_WINDOW0_BASE and within PCI_SOC_PCI_REG_BASE +* use 0th window +*/ +else if (((offset ^PCI_BAR_WINDOW0_BASE ) <WINDOW_RANGE_MASK ) && + !((offset ^PCI_SOC_PCI_REG_BASE ) <PCI_SOC_RANGE_MASK )) + window_start =0 ; +else + window_start =WINDOW_START ; + +return window_start; +} + +static void ath12k_pci_soc_global_reset (struct ath12k_base *ab) +{ +u32 val, delay; + + val =ath12k_pci_read32 (ab,PCIE_SOC_GLOBAL_RESET ); + + val |=PCIE_SOC_GLOBAL_RESET_V ; + +ath12k_pci_write32 (ab,PCIE_SOC_GLOBAL_RESET , val); + +/* TODO: exact time to sleep is uncertain */ + delay =10 ; +mdelay (delay); + +/* Need to toggle V bit back otherwise stuck in reset status */ + val &= ~PCIE_SOC_GLOBAL_RESET_V ; + +ath12k_pci_write32 (ab,PCIE_SOC_GLOBAL_RESET , val); + +mdelay (delay); + + val =ath12k_pci_read32 (ab,PCIE_SOC_GLOBAL_RESET ); +if (val ==0xffffffff ) +ath12k_warn (ab,"link down error during global reset\n" ); +} + +static void ath12k_pci_clear_dbg_registers (struct ath12k_base *ab) +{ +u32 val; + +/* read cookie */ + val =ath12k_pci_read32 (ab,PCIE_Q6_COOKIE_ADDR ); +ath12k_dbg (ab,ATH12K_DBG_PCI ,"cookie:0x%x\n" , val); + + val =ath12k_pci_read32 (ab,WLAON_WARM_SW_ENTRY ); +ath12k_dbg (ab,ATH12K_DBG_PCI ,"WLAON_WARM_SW_ENTRY 0x%x\n" , val); + +/* TODO: exact time to sleep is uncertain */ +mdelay (10 ); + +/* write 0 to WLAON_WARM_SW_ENTRY to prevent Q6 from +* continuing warm path and entering dead loop. +*/ +ath12k_pci_write32 (ab,WLAON_WARM_SW_ENTRY ,0 ); +mdelay (10 ); + + val =ath12k_pci_read32 (ab,WLAON_WARM_SW_ENTRY ); +ath12k_dbg (ab,ATH12K_DBG_PCI ,"WLAON_WARM_SW_ENTRY 0x%x\n" , val); + +/* A read clear register. clear the register to prevent +* Q6 from entering wrong code path. +*/ + val =ath12k_pci_read32 (ab,WLAON_SOC_RESET_CAUSE_REG ); +ath12k_dbg (ab,ATH12K_DBG_PCI ,"soc reset cause:%d\n" , val); +} + +static void ath12k_pci_enable_ltssm (struct ath12k_base *ab) +{ +u32 val; +int i; + + val =ath12k_pci_read32 (ab,PCIE_PCIE_PARF_LTSSM ); + +/* PCIE link seems very unstable after the Hot Reset*/ +for (i =0 ; val !=PARM_LTSSM_VALUE && i <5 ; i++) { +if (val ==0xffffffff ) +mdelay (5 ); + +ath12k_pci_write32 (ab,PCIE_PCIE_PARF_LTSSM ,PARM_LTSSM_VALUE ); + val =ath12k_pci_read32 (ab,PCIE_PCIE_PARF_LTSSM ); + } + +ath12k_dbg (ab,ATH12K_DBG_PCI ,"pci ltssm 0x%x\n" , val); + + val =ath12k_pci_read32 (ab,GCC_GCC_PCIE_HOT_RST ); + val |=GCC_GCC_PCIE_HOT_RST_VAL ; +ath12k_pci_write32 (ab,GCC_GCC_PCIE_HOT_RST , val); + val =ath12k_pci_read32 (ab,GCC_GCC_PCIE_HOT_RST ); + +ath12k_dbg (ab,ATH12K_DBG_PCI ,"pci pcie_hot_rst 0x%x\n" , val); + +mdelay (5 ); +} + +static void ath12k_pci_clear_all_intrs (struct ath12k_base *ab) +{ +/* This is a WAR for PCIE Hotreset. +* When target receive Hotreset, but will set the interrupt. +* So when download SBL again, SBL will open Interrupt and +* receive it, and crash immediately. +*/ +ath12k_pci_write32 (ab,PCIE_PCIE_INT_ALL_CLEAR ,PCIE_INT_CLEAR_ALL ); +} + +static void ath12k_pci_set_wlaon_pwr_ctrl (struct ath12k_base *ab) +{ +u32 val; + + val =ath12k_pci_read32 (ab,WLAON_QFPROM_PWR_CTRL_REG ); + val &= ~QFPROM_PWR_CTRL_VDD4BLOW_MASK ; +ath12k_pci_write32 (ab,WLAON_QFPROM_PWR_CTRL_REG , val); +} + +static void ath12k_pci_force_wake (struct ath12k_base *ab) +{ +ath12k_pci_write32 (ab,PCIE_SOC_WAKE_PCIE_LOCAL_REG ,1 ); +mdelay (5 ); +} + +static void ath12k_pci_sw_reset (struct ath12k_base *ab,bool power_on) +{ +if (power_on) { +ath12k_pci_enable_ltssm (ab); +ath12k_pci_clear_all_intrs (ab); +ath12k_pci_set_wlaon_pwr_ctrl (ab); + } + +ath12k_mhi_clear_vector (ab); +ath12k_pci_clear_dbg_registers (ab); +ath12k_pci_soc_global_reset (ab); +ath12k_mhi_set_mhictrl_reset (ab); +} + +static void ath12k_pci_free_ext_irq (struct ath12k_base *ab) +{ +int i, j; + +for (i =0 ; i <ATH12K_EXT_IRQ_GRP_NUM_MAX ; i++) { +struct ath12k_ext_irq_grp *irq_grp = &ab->ext_irq_grp[i]; + +for (j =0 ; j < irq_grp->num_irq; j++) +free_irq (ab->irq_num[irq_grp->irqs[j]], irq_grp); + +netif_napi_del (&irq_grp->napi); + } +} + +static void ath12k_pci_free_irq (struct ath12k_base *ab) +{ +int i, irq_idx; + +for (i =0 ; i < ab->hw_params->ce_count; i++) { +if (ath12k_ce_get_attr_flags (ab, i) &CE_ATTR_DIS_INTR ) +continue ; + irq_idx =ATH12K_PCI_IRQ_CE0_OFFSET + i; +free_irq (ab->irq_num[irq_idx], &ab->ce.ce_pipe[i]); + } + +ath12k_pci_free_ext_irq (ab); +} + +static void ath12k_pci_ce_irq_enable (struct ath12k_base *ab,u16 ce_id) +{ +u32 irq_idx; + + irq_idx =ATH12K_PCI_IRQ_CE0_OFFSET + ce_id; +enable_irq (ab->irq_num[irq_idx]); +} + +static void ath12k_pci_ce_irq_disable (struct ath12k_base *ab,u16 ce_id) +{ +u32 irq_idx; + + irq_idx =ATH12K_PCI_IRQ_CE0_OFFSET + ce_id; +disable_irq_nosync (ab->irq_num[irq_idx]); +} + +static void ath12k_pci_ce_irqs_disable (struct ath12k_base *ab) +{ +int i; + +for (i =0 ; i < ab->hw_params->ce_count; i++) { +if (ath12k_ce_get_attr_flags (ab, i) &CE_ATTR_DIS_INTR ) +continue ; +ath12k_pci_ce_irq_disable (ab, i); + } +} + +static void ath12k_pci_sync_ce_irqs (struct ath12k_base *ab) +{ +int i; +int irq_idx; + +for (i =0 ; i < ab->hw_params->ce_count; i++) { +if (ath12k_ce_get_attr_flags (ab, i) &CE_ATTR_DIS_INTR ) +continue ; + + irq_idx =ATH12K_PCI_IRQ_CE0_OFFSET + i; +synchronize_irq (ab->irq_num[irq_idx]); + } +} + +static void ath12k_pci_ce_tasklet (struct tasklet_struct *t) +{ +struct ath12k_ce_pipe *ce_pipe =from_tasklet (ce_pipe, t, intr_tq); + +ath12k_ce_per_engine_service (ce_pipe->ab, ce_pipe->pipe_num); + +ath12k_pci_ce_irq_enable (ce_pipe->ab, ce_pipe->pipe_num); +} + +static irqreturn_t ath12k_pci_ce_interrupt_handler (int irq,void *arg) +{ +struct ath12k_ce_pipe *ce_pipe = arg; + +/* last interrupt received for this CE */ + ce_pipe->timestamp = jiffies; + +ath12k_pci_ce_irq_disable (ce_pipe->ab, ce_pipe->pipe_num); +tasklet_schedule (&ce_pipe->intr_tq); + +return IRQ_HANDLED ; +} + +static void ath12k_pci_ext_grp_disable (struct ath12k_ext_irq_grp *irq_grp) +{ +int i; + +for (i =0 ; i < irq_grp->num_irq; i++) +disable_irq_nosync (irq_grp->ab->irq_num[irq_grp->irqs[i]]); +} + +static void __ath12k_pci_ext_irq_disable (struct ath12k_base *sc) +{ +int i; + +for (i =0 ; i <ATH12K_EXT_IRQ_GRP_NUM_MAX ; i++) { +struct ath12k_ext_irq_grp *irq_grp = &sc->ext_irq_grp[i]; + +ath12k_pci_ext_grp_disable (irq_grp); + +napi_synchronize (&irq_grp->napi); +napi_disable (&irq_grp->napi); + } +} + +static void ath12k_pci_ext_grp_enable (struct ath12k_ext_irq_grp *irq_grp) +{ +int i; + +for (i =0 ; i < irq_grp->num_irq; i++) +enable_irq (irq_grp->ab->irq_num[irq_grp->irqs[i]]); +} + +static void ath12k_pci_sync_ext_irqs (struct ath12k_base *ab) +{ +int i, j, irq_idx; + +for (i =0 ; i <ATH12K_EXT_IRQ_GRP_NUM_MAX ; i++) { +struct ath12k_ext_irq_grp *irq_grp = &ab->ext_irq_grp[i]; + +for (j =0 ; j < irq_grp->num_irq; j++) { + irq_idx = irq_grp->irqs[j]; +synchronize_irq (ab->irq_num[irq_idx]); + } + } +} + +static int ath12k_pci_ext_grp_napi_poll (struct napi_struct *napi,int budget) +{ +struct ath12k_ext_irq_grp *irq_grp =container_of (napi, + struct ath12k_ext_irq_grp, + napi); +struct ath12k_base *ab = irq_grp->ab; +int work_done; + + work_done =ath12k_dp_service_srng (ab, irq_grp, budget); +if (work_done < budget) { +napi_complete_done (napi, work_done); +ath12k_pci_ext_grp_enable (irq_grp); + } + +if (work_done > budget) + work_done = budget; + +return work_done; +} + +static irqreturn_t ath12k_pci_ext_interrupt_handler (int irq,void *arg) +{ +struct ath12k_ext_irq_grp *irq_grp = arg; + +ath12k_dbg (irq_grp->ab,ATH12K_DBG_PCI ,"ext irq:%d\n" , irq); + +/* last interrupt received for this group */ + irq_grp->timestamp = jiffies; + +ath12k_pci_ext_grp_disable (irq_grp); + +napi_schedule (&irq_grp->napi); + +return IRQ_HANDLED ; +} + +static int ath12k_pci_ext_irq_config (struct ath12k_base *ab) +{ +int i, j, ret, num_vectors =0 ; +u32 user_base_data =0 , base_vector =0 , base_idx; + + base_idx =ATH12K_PCI_IRQ_CE0_OFFSET +CE_COUNT_MAX ; + ret =ath12k_pci_get_user_msi_assignment (ab,"DP" , + &num_vectors, + &user_base_data, + &base_vector); +if (ret <0 ) +return ret; + +for (i =0 ; i <ATH12K_EXT_IRQ_GRP_NUM_MAX ; i++) { +struct ath12k_ext_irq_grp *irq_grp = &ab->ext_irq_grp[i]; +u32 num_irq =0 ; + + irq_grp->ab = ab; + irq_grp->grp_id = i; +init_dummy_netdev (&irq_grp->napi_ndev); +netif_napi_add (&irq_grp->napi_ndev, &irq_grp->napi, + ath12k_pci_ext_grp_napi_poll); + +if (ab->hw_params->ring_mask->tx[i] || + ab->hw_params->ring_mask->rx[i] || + ab->hw_params->ring_mask->rx_err[i] || + ab->hw_params->ring_mask->rx_wbm_rel[i] || + ab->hw_params->ring_mask->reo_status[i] || + ab->hw_params->ring_mask->host2rxdma[i] || + ab->hw_params->ring_mask->rx_mon_dest[i]) { + num_irq =1 ; + } + + irq_grp->num_irq = num_irq; + irq_grp->irqs[0 ] = base_idx + i; + +for (j =0 ; j < irq_grp->num_irq; j++) { +int irq_idx = irq_grp->irqs[j]; +int vector = (i % num_vectors) + base_vector; +int irq =ath12k_pci_get_msi_irq (ab->dev, vector); + + ab->irq_num[irq_idx] = irq; + +ath12k_dbg (ab,ATH12K_DBG_PCI , +"irq:%d group:%d\n" , irq, i); + +irq_set_status_flags (irq,IRQ_DISABLE_UNLAZY ); + ret =request_irq (irq, ath12k_pci_ext_interrupt_handler, +IRQF_SHARED , +"DP_EXT_IRQ" , irq_grp); +if (ret) { +ath12k_err (ab,"failed request irq %d: %d\n" , + vector, ret); +return ret; + } + +disable_irq_nosync (ab->irq_num[irq_idx]); + } + } + +return 0 ; +} + +static int ath12k_pci_config_irq (struct ath12k_base *ab) +{ +struct ath12k_ce_pipe *ce_pipe; +u32 msi_data_start; +u32 msi_data_count, msi_data_idx; +u32 msi_irq_start; +unsigned int msi_data; +int irq, i, ret, irq_idx; + + ret =ath12k_pci_get_user_msi_assignment (ab, +"CE" , &msi_data_count, + &msi_data_start, &msi_irq_start); +if (ret) +return ret; + +/* Configure CE irqs */ + +for (i =0 , msi_data_idx =0 ; i < ab->hw_params->ce_count; i++) { +if (ath12k_ce_get_attr_flags (ab, i) &CE_ATTR_DIS_INTR ) +continue ; + + msi_data = (msi_data_idx % msi_data_count) + msi_irq_start; + irq =ath12k_pci_get_msi_irq (ab->dev, msi_data); + ce_pipe = &ab->ce.ce_pipe[i]; + + irq_idx =ATH12K_PCI_IRQ_CE0_OFFSET + i; + +tasklet_setup (&ce_pipe->intr_tq, ath12k_pci_ce_tasklet); + + ret =request_irq (irq, ath12k_pci_ce_interrupt_handler, +IRQF_SHARED , irq_name[irq_idx], + ce_pipe); +if (ret) { +ath12k_err (ab,"failed to request irq %d: %d\n" , + irq_idx, ret); +return ret; + } + + ab->irq_num[irq_idx] = irq; + msi_data_idx++; + +ath12k_pci_ce_irq_disable (ab, i); + } + + ret =ath12k_pci_ext_irq_config (ab); +if (ret) +return ret; + +return 0 ; +} + +static void ath12k_pci_init_qmi_ce_config (struct ath12k_base *ab) +{ +struct ath12k_qmi_ce_cfg *cfg = &ab->qmi.ce_cfg; + + cfg->tgt_ce = ab->hw_params->target_ce_config; + cfg->tgt_ce_len = ab->hw_params->target_ce_count; + + cfg->svc_to_ce_map = ab->hw_params->svc_to_ce_map; + cfg->svc_to_ce_map_len = ab->hw_params->svc_to_ce_map_len; + ab->qmi.service_ins_id = ab->hw_params->qmi_service_ins_id; +} + +static void ath12k_pci_ce_irqs_enable (struct ath12k_base *ab) +{ +int i; + +for (i =0 ; i < ab->hw_params->ce_count; i++) { +if (ath12k_ce_get_attr_flags (ab, i) &CE_ATTR_DIS_INTR ) +continue ; +ath12k_pci_ce_irq_enable (ab, i); + } +} + +static void ath12k_pci_msi_config (struct ath12k_pci *ab_pci,bool enable) +{ +struct pci_dev *dev = ab_pci->pdev; +u16 control; + +pci_read_config_word (dev, dev->msi_cap +PCI_MSI_FLAGS , &control); + +if (enable) + control |=PCI_MSI_FLAGS_ENABLE ; +else + control &= ~PCI_MSI_FLAGS_ENABLE ; + +pci_write_config_word (dev, dev->msi_cap +PCI_MSI_FLAGS , control); +} + +static void ath12k_pci_msi_enable (struct ath12k_pci *ab_pci) +{ +ath12k_pci_msi_config (ab_pci, true); +} + +static void ath12k_pci_msi_disable (struct ath12k_pci *ab_pci) +{ +ath12k_pci_msi_config (ab_pci, false); +} + +static int ath12k_pci_msi_alloc (struct ath12k_pci *ab_pci) +{ +struct ath12k_base *ab = ab_pci->ab; +const struct ath12k_msi_config *msi_config = ab_pci->msi_config; +struct msi_desc *msi_desc; +int num_vectors; +int ret; + + num_vectors =pci_alloc_irq_vectors (ab_pci->pdev, + msi_config->total_vectors, + msi_config->total_vectors, +PCI_IRQ_MSI ); +if (num_vectors != msi_config->total_vectors) { +ath12k_err (ab,"failed to get %d MSI vectors, only %d available" , + msi_config->total_vectors, num_vectors); + +if (num_vectors >=0 ) +return -EINVAL ; +else +return num_vectors; + } + +ath12k_pci_msi_disable (ab_pci); + + msi_desc =irq_get_msi_desc (ab_pci->pdev->irq); +if (!msi_desc) { +ath12k_err (ab,"msi_desc is NULL!\n" ); + ret = -EINVAL ; + goto free_msi_vector; + } + + ab_pci->msi_ep_base_data = msi_desc->msg.data; +if (msi_desc->pci.msi_attrib.is_64) +set_bit (ATH12K_PCI_FLAG_IS_MSI_64 , &ab_pci->flags); + +ath12k_dbg (ab,ATH12K_DBG_PCI ,"msi base data is %d\n" , ab_pci->msi_ep_base_data); + +return 0 ; + +free_msi_vector: +pci_free_irq_vectors (ab_pci->pdev); + +return ret; +} + +static void ath12k_pci_msi_free (struct ath12k_pci *ab_pci) +{ +pci_free_irq_vectors (ab_pci->pdev); +} + +static int ath12k_pci_claim (struct ath12k_pci *ab_pci,struct pci_dev *pdev) +{ +struct ath12k_base *ab = ab_pci->ab; +u16 device_id; +int ret =0 ; + +pci_read_config_word (pdev,PCI_DEVICE_ID , &device_id); +if (device_id != ab_pci->dev_id) { +ath12k_err (ab,"pci device id mismatch: 0x%x 0x%x\n" , + device_id, ab_pci->dev_id); + ret = -EIO ; + goto out; + } + + ret =pci_assign_resource (pdev,ATH12K_PCI_BAR_NUM ); +if (ret) { +ath12k_err (ab,"failed to assign pci resource: %d\n" , ret); + goto out; + } + + ret =pci_enable_device (pdev); +if (ret) { +ath12k_err (ab,"failed to enable pci device: %d\n" , ret); + goto out; + } + + ret =pci_request_region (pdev,ATH12K_PCI_BAR_NUM ,"ath12k_pci" ); +if (ret) { +ath12k_err (ab,"failed to request pci region: %d\n" , ret); + goto disable_device; + } + + ret =dma_set_mask_and_coherent (&pdev->dev, +DMA_BIT_MASK (ATH12K_PCI_DMA_MASK )); +if (ret) { +ath12k_err (ab,"failed to set pci dma mask to %d: %d\n" , +ATH12K_PCI_DMA_MASK , ret); + goto release_region; + } + +pci_set_master (pdev); + + ab->mem_len =pci_resource_len (pdev,ATH12K_PCI_BAR_NUM ); + ab->mem =pci_iomap (pdev,ATH12K_PCI_BAR_NUM ,0 ); +if (!ab->mem) { +ath12k_err (ab,"failed to map pci bar %d\n" ,ATH12K_PCI_BAR_NUM ); + ret = -EIO ; + goto clear_master; + } + +ath12k_dbg (ab,ATH12K_DBG_BOOT ,"boot pci_mem 0x%pK\n" , ab->mem); +return 0 ; + +clear_master: +pci_clear_master (pdev); +release_region: +pci_release_region (pdev,ATH12K_PCI_BAR_NUM ); +disable_device: +pci_disable_device (pdev); +out: +return ret; +} + +static void ath12k_pci_free_region (struct ath12k_pci *ab_pci) +{ +struct ath12k_base *ab = ab_pci->ab; +struct pci_dev *pci_dev = ab_pci->pdev; + +pci_iounmap (pci_dev, ab->mem); + ab->mem =NULL ; +pci_clear_master (pci_dev); +pci_release_region (pci_dev,ATH12K_PCI_BAR_NUM ); +if (pci_is_enabled (pci_dev)) +pci_disable_device (pci_dev); +} + +static void ath12k_pci_aspm_disable (struct ath12k_pci *ab_pci) +{ +struct ath12k_base *ab = ab_pci->ab; + +pcie_capability_read_word (ab_pci->pdev,PCI_EXP_LNKCTL , + &ab_pci->link_ctl); + +ath12k_dbg (ab,ATH12K_DBG_PCI ,"pci link_ctl 0x%04x L0s %d L1 %d\n" , + ab_pci->link_ctl, +u16_get_bits (ab_pci->link_ctl,PCI_EXP_LNKCTL_ASPM_L0S ), +u16_get_bits (ab_pci->link_ctl,PCI_EXP_LNKCTL_ASPM_L1 )); + +/* disable L0s and L1 */ +pcie_capability_write_word (ab_pci->pdev,PCI_EXP_LNKCTL , + ab_pci->link_ctl & ~PCI_EXP_LNKCTL_ASPMC ); + +set_bit (ATH12K_PCI_ASPM_RESTORE , &ab_pci->flags); +} + +static void ath12k_pci_aspm_restore (struct ath12k_pci *ab_pci) +{ +if (test_and_clear_bit (ATH12K_PCI_ASPM_RESTORE , &ab_pci->flags)) +pcie_capability_write_word (ab_pci->pdev,PCI_EXP_LNKCTL , + ab_pci->link_ctl); +} + +static void ath12k_pci_kill_tasklets (struct ath12k_base *ab) +{ +int i; + +for (i =0 ; i < ab->hw_params->ce_count; i++) { +struct ath12k_ce_pipe *ce_pipe = &ab->ce.ce_pipe[i]; + +if (ath12k_ce_get_attr_flags (ab, i) &CE_ATTR_DIS_INTR ) +continue ; + +tasklet_kill (&ce_pipe->intr_tq); + } +} + +static void ath12k_pci_ce_irq_disable_sync (struct ath12k_base *ab) +{ +ath12k_pci_ce_irqs_disable (ab); +ath12k_pci_sync_ce_irqs (ab); +ath12k_pci_kill_tasklets (ab); +} + +int ath12k_pci_map_service_to_pipe (struct ath12k_base *ab,u16 service_id, +u8 *ul_pipe,u8 *dl_pipe) +{ +const struct service_to_pipe *entry; +bool ul_set = false, dl_set = false; +int i; + +for (i =0 ; i < ab->hw_params->svc_to_ce_map_len; i++) { + entry = &ab->hw_params->svc_to_ce_map[i]; + +if (__le32_to_cpu (entry->service_id) != service_id) +continue ; + +switch (__le32_to_cpu (entry->pipedir)) { +case PIPEDIR_NONE : +break ; +case PIPEDIR_IN : +WARN_ON (dl_set); + *dl_pipe =__le32_to_cpu (entry->pipenum); + dl_set = true; +break ; +case PIPEDIR_OUT : +WARN_ON (ul_set); + *ul_pipe =__le32_to_cpu (entry->pipenum); + ul_set = true; +break ; +case PIPEDIR_INOUT : +WARN_ON (dl_set); +WARN_ON (ul_set); + *dl_pipe =__le32_to_cpu (entry->pipenum); + *ul_pipe =__le32_to_cpu (entry->pipenum); + dl_set = true; + ul_set = true; +break ; + } + } + +if (WARN_ON (!ul_set || !dl_set)) +return -ENOENT ; + +return 0 ; +} + +int ath12k_pci_get_msi_irq (struct device *dev,unsigned int vector) +{ +struct pci_dev *pci_dev =to_pci_dev (dev); + +return pci_irq_vector (pci_dev, vector); +} + +int ath12k_pci_get_user_msi_assignment (struct ath12k_base *ab,char *user_name, +int *num_vectors,u32 *user_base_data, +u32 *base_vector) +{ +struct ath12k_pci *ab_pci =ath12k_pci_priv (ab); +const struct ath12k_msi_config *msi_config = ab_pci->msi_config; +int idx; + +for (idx =0 ; idx < msi_config->total_users; idx++) { +if (strcmp (user_name, msi_config->users[idx].name) ==0 ) { + *num_vectors = msi_config->users[idx].num_vectors; + *user_base_data = msi_config->users[idx].base_vector + + ab_pci->msi_ep_base_data; + *base_vector = msi_config->users[idx].base_vector; + +ath12k_dbg (ab,ATH12K_DBG_PCI ,"Assign MSI to user: %s, num_vectors: %d, user_base_data: %u, base_vector: %u\n" , + user_name, *num_vectors, *user_base_data, + *base_vector); + +return 0 ; + } + } + +ath12k_err (ab,"Failed to find MSI assignment for %s!\n" , user_name); + +return -EINVAL ; +} + +void ath12k_pci_get_msi_address (struct ath12k_base *ab,u32 *msi_addr_lo, +u32 *msi_addr_hi) +{ +struct ath12k_pci *ab_pci =ath12k_pci_priv (ab); +struct pci_dev *pci_dev =to_pci_dev (ab->dev); + +pci_read_config_dword (pci_dev, pci_dev->msi_cap +PCI_MSI_ADDRESS_LO , + msi_addr_lo); + +if (test_bit (ATH12K_PCI_FLAG_IS_MSI_64 , &ab_pci->flags)) { +pci_read_config_dword (pci_dev, pci_dev->msi_cap +PCI_MSI_ADDRESS_HI , + msi_addr_hi); + }else { + *msi_addr_hi =0 ; + } +} + +void ath12k_pci_get_ce_msi_idx (struct ath12k_base *ab,u32 ce_id, +u32 *msi_idx) +{ +u32 i, msi_data_idx; + +for (i =0 , msi_data_idx =0 ; i < ab->hw_params->ce_count; i++) { +if (ath12k_ce_get_attr_flags (ab, i) &CE_ATTR_DIS_INTR ) +continue ; + +if (ce_id == i) +break ; + + msi_data_idx++; + } + *msi_idx = msi_data_idx; +} + +void ath12k_pci_hif_ce_irq_enable (struct ath12k_base *ab) +{ +ath12k_pci_ce_irqs_enable (ab); +} + +void ath12k_pci_hif_ce_irq_disable (struct ath12k_base *ab) +{ +ath12k_pci_ce_irq_disable_sync (ab); +} + +void ath12k_pci_ext_irq_enable (struct ath12k_base *ab) +{ +int i; + +for (i =0 ; i <ATH12K_EXT_IRQ_GRP_NUM_MAX ; i++) { +struct ath12k_ext_irq_grp *irq_grp = &ab->ext_irq_grp[i]; + +napi_enable (&irq_grp->napi); +ath12k_pci_ext_grp_enable (irq_grp); + } +} + +void ath12k_pci_ext_irq_disable (struct ath12k_base *ab) +{ +__ath12k_pci_ext_irq_disable (ab); +ath12k_pci_sync_ext_irqs (ab); +} + +int ath12k_pci_hif_suspend (struct ath12k_base *ab) +{ +struct ath12k_pci *ar_pci =ath12k_pci_priv (ab); + +ath12k_mhi_suspend (ar_pci); + +return 0 ; +} + +int ath12k_pci_hif_resume (struct ath12k_base *ab) +{ +struct ath12k_pci *ar_pci =ath12k_pci_priv (ab); + +ath12k_mhi_resume (ar_pci); + +return 0 ; +} + +void ath12k_pci_stop (struct ath12k_base *ab) +{ +ath12k_pci_ce_irq_disable_sync (ab); +ath12k_ce_cleanup_pipes (ab); +} + +int ath12k_pci_start (struct ath12k_base *ab) +{ +struct ath12k_pci *ab_pci =ath12k_pci_priv (ab); + +set_bit (ATH12K_PCI_FLAG_INIT_DONE , &ab_pci->flags); + +ath12k_pci_aspm_restore (ab_pci); + +ath12k_pci_ce_irqs_enable (ab); +ath12k_ce_rx_post_buf (ab); + +return 0 ; +} + +u32 ath12k_pci_read32 (struct ath12k_base *ab,u32 offset) +{ +struct ath12k_pci *ab_pci =ath12k_pci_priv (ab); +u32 val, window_start; + +/* for offset beyond BAR + 4K - 32, may +* need to wakeup MHI to access. +*/ +if (test_bit (ATH12K_PCI_FLAG_INIT_DONE , &ab_pci->flags) && + offset >=ACCESS_ALWAYS_OFF ) +mhi_device_get_sync (ab_pci->mhi_ctrl->mhi_dev); + +if (offset <WINDOW_START ) { + val =ioread32 (ab->mem + offset); + }else { +if (ab->static_window_map) + window_start =ath12k_pci_get_window_start (ab, offset); +else + window_start =WINDOW_START ; + +if (window_start ==WINDOW_START ) { +spin_lock_bh (&ab_pci->window_lock); +ath12k_pci_select_window (ab_pci, offset); + val =ioread32 (ab->mem + window_start + + (offset &WINDOW_RANGE_MASK )); +spin_unlock_bh (&ab_pci->window_lock); + }else { +if ((!window_start) && + (offset >=PCI_MHIREGLEN_REG && + offset <=PCI_MHI_REGION_END )) + offset = offset -PCI_MHIREGLEN_REG ; + + val =ioread32 (ab->mem + window_start + + (offset &WINDOW_RANGE_MASK )); + } + } + +if (test_bit (ATH12K_PCI_FLAG_INIT_DONE , &ab_pci->flags) && + offset >=ACCESS_ALWAYS_OFF ) +mhi_device_put (ab_pci->mhi_ctrl->mhi_dev); + +return val; +} + +void ath12k_pci_write32 (struct ath12k_base *ab,u32 offset,u32 value) +{ +struct ath12k_pci *ab_pci =ath12k_pci_priv (ab); +u32 window_start; + +/* for offset beyond BAR + 4K - 32, may +* need to wakeup MHI to access. +*/ +if (test_bit (ATH12K_PCI_FLAG_INIT_DONE , &ab_pci->flags) && + offset >=ACCESS_ALWAYS_OFF ) +mhi_device_get_sync (ab_pci->mhi_ctrl->mhi_dev); + +if (offset <WINDOW_START ) { +iowrite32 (value, ab->mem + offset); + }else { +if (ab->static_window_map) + window_start =ath12k_pci_get_window_start (ab, offset); +else + window_start =WINDOW_START ; + +if (window_start ==WINDOW_START ) { +spin_lock_bh (&ab_pci->window_lock); +ath12k_pci_select_window (ab_pci, offset); +iowrite32 (value, ab->mem + window_start + + (offset &WINDOW_RANGE_MASK )); +spin_unlock_bh (&ab_pci->window_lock); + }else { +if ((!window_start) && + (offset >=PCI_MHIREGLEN_REG && + offset <=PCI_MHI_REGION_END )) + offset = offset -PCI_MHIREGLEN_REG ; + +iowrite32 (value, ab->mem + window_start + + (offset &WINDOW_RANGE_MASK )); + } + } + +if (test_bit (ATH12K_PCI_FLAG_INIT_DONE , &ab_pci->flags) && + offset >=ACCESS_ALWAYS_OFF ) +mhi_device_put (ab_pci->mhi_ctrl->mhi_dev); +} + +int ath12k_pci_power_up (struct ath12k_base *ab) +{ +struct ath12k_pci *ab_pci =ath12k_pci_priv (ab); +int ret; + + ab_pci->register_window =0 ; +clear_bit (ATH12K_PCI_FLAG_INIT_DONE , &ab_pci->flags); +ath12k_pci_sw_reset (ab_pci->ab, true); + +/* Disable ASPM during firmware download due to problems switching +* to AMSS state. +*/ +ath12k_pci_aspm_disable (ab_pci); + +ath12k_pci_msi_enable (ab_pci); + + ret =ath12k_mhi_start (ab_pci); +if (ret) { +ath12k_err (ab,"failed to start mhi: %d\n" , ret); +return ret; + } + +if (ab->static_window_map) +ath12k_pci_select_static_window (ab_pci); + +return 0 ; +} + +void ath12k_pci_power_down (struct ath12k_base *ab) +{ +struct ath12k_pci *ab_pci =ath12k_pci_priv (ab); + +/* restore aspm in case firmware bootup fails */ +ath12k_pci_aspm_restore (ab_pci); + +ath12k_pci_force_wake (ab_pci->ab); +ath12k_pci_msi_disable (ab_pci); +ath12k_mhi_stop (ab_pci); +clear_bit (ATH12K_PCI_FLAG_INIT_DONE , &ab_pci->flags); +ath12k_pci_sw_reset (ab_pci->ab, false); +} + +static const struct ath12k_hif_ops ath12k_pci_hif_ops = { + .start = ath12k_pci_start, + .stop = ath12k_pci_stop, + .read32 = ath12k_pci_read32, + .write32 = ath12k_pci_write32, + .power_down = ath12k_pci_power_down, + .power_up = ath12k_pci_power_up, + .suspend = ath12k_pci_hif_suspend, + .resume = ath12k_pci_hif_resume, + .irq_enable = ath12k_pci_ext_irq_enable, + .irq_disable = ath12k_pci_ext_irq_disable, + .get_msi_address = ath12k_pci_get_msi_address, + .get_user_msi_vector = ath12k_pci_get_user_msi_assignment, + .map_service_to_pipe = ath12k_pci_map_service_to_pipe, + .ce_irq_enable = ath12k_pci_hif_ce_irq_enable, + .ce_irq_disable = ath12k_pci_hif_ce_irq_disable, + .get_ce_msi_idx = ath12k_pci_get_ce_msi_idx, +}; + +static +void ath12k_pci_read_hw_version (struct ath12k_base *ab,u32 *major,u32 *minor) +{ +u32 soc_hw_version; + + soc_hw_version =ath12k_pci_read32 (ab,TCSR_SOC_HW_VERSION ); + *major =FIELD_GET (TCSR_SOC_HW_VERSION_MAJOR_MASK , + soc_hw_version); + *minor =FIELD_GET (TCSR_SOC_HW_VERSION_MINOR_MASK , + soc_hw_version); + +ath12k_dbg (ab,ATH12K_DBG_PCI , +"pci tcsr_soc_hw_version major %d minor %d\n" , + *major, *minor); +} + +static int ath12k_pci_probe (struct pci_dev *pdev, +const struct pci_device_id *pci_dev) +{ +struct ath12k_base *ab; +struct ath12k_pci *ab_pci; +u32 soc_hw_version_major, soc_hw_version_minor; +int ret; + + ab =ath12k_core_alloc (&pdev->dev,sizeof (*ab_pci),ATH12K_BUS_PCI ); +if (!ab) { +dev_err (&pdev->dev,"failed to allocate ath12k base\n" ); +return -ENOMEM ; + } + + ab->dev = &pdev->dev; +pci_set_drvdata (pdev, ab); + ab_pci =ath12k_pci_priv (ab); + ab_pci->dev_id = pci_dev->device; + ab_pci->ab = ab; + ab_pci->pdev = pdev; + ab->hif.ops = &ath12k_pci_hif_ops; +pci_set_drvdata (pdev, ab); +spin_lock_init (&ab_pci->window_lock); + + ret =ath12k_pci_claim (ab_pci, pdev); +if (ret) { +ath12k_err (ab,"failed to claim device: %d\n" , ret); + goto err_free_core; + } + +switch (pci_dev->device) { +case QCN9274_DEVICE_ID : + ab_pci->msi_config = &ath12k_msi_config[0 ]; + ab->static_window_map = true; +ath12k_pci_read_hw_version (ab, &soc_hw_version_major, + &soc_hw_version_minor); +switch (soc_hw_version_major) { +case ATH12K_PCI_SOC_HW_VERSION_2 : + ab->hw_rev =ATH12K_HW_QCN9274_HW20 ; +break ; +case ATH12K_PCI_SOC_HW_VERSION_1 : + ab->hw_rev =ATH12K_HW_QCN9274_HW10 ; +break ; +default : +dev_err (&pdev->dev, +"Unknown hardware version found for QCN9274: 0x%x\n" , + soc_hw_version_major); +return -EOPNOTSUPP ; + } +break ; +case WCN7850_DEVICE_ID : + ab_pci->msi_config = &ath12k_msi_config[0 ]; + ab->static_window_map = false; + ab->hw_rev =ATH12K_HW_WCN7850_HW20 ; +break ; + +default : +dev_err (&pdev->dev,"Unknown PCI device found: 0x%x\n" , + pci_dev->device); + ret = -EOPNOTSUPP ; + goto err_pci_free_region; + } + + ret =ath12k_pci_msi_alloc (ab_pci); +if (ret) { +ath12k_err (ab,"failed to alloc msi: %d\n" , ret); + goto err_pci_free_region; + } + + ret =ath12k_core_pre_init (ab); +if (ret) + goto err_pci_msi_free; + + ret =ath12k_mhi_register (ab_pci); +if (ret) { +ath12k_err (ab,"failed to register mhi: %d\n" , ret); + goto err_pci_msi_free; + } + + ret =ath12k_hal_srng_init (ab); +if (ret) + goto err_mhi_unregister; + + ret =ath12k_ce_alloc_pipes (ab); +if (ret) { +ath12k_err (ab,"failed to allocate ce pipes: %d\n" , ret); + goto err_hal_srng_deinit; + } + +ath12k_pci_init_qmi_ce_config (ab); + + ret =ath12k_pci_config_irq (ab); +if (ret) { +ath12k_err (ab,"failed to config irq: %d\n" , ret); + goto err_ce_free; + } + + ret =ath12k_core_init (ab); +if (ret) { +ath12k_err (ab,"failed to init core: %d\n" , ret); + goto err_free_irq; + } +return 0 ; + +err_free_irq: +ath12k_pci_free_irq (ab); + +err_ce_free: +ath12k_ce_free_pipes (ab); + +err_hal_srng_deinit: +ath12k_hal_srng_deinit (ab); + +err_mhi_unregister: +ath12k_mhi_unregister (ab_pci); + +err_pci_msi_free: +ath12k_pci_msi_free (ab_pci); + +err_pci_free_region: +ath12k_pci_free_region (ab_pci); + +err_free_core: +ath12k_core_free (ab); + +return ret; +} + +static void ath12k_pci_remove (struct pci_dev *pdev) +{ +struct ath12k_base *ab =pci_get_drvdata (pdev); +struct ath12k_pci *ab_pci =ath12k_pci_priv (ab); + +if (test_bit (ATH12K_FLAG_QMI_FAIL , &ab->dev_flags)) { +ath12k_pci_power_down (ab); +ath12k_qmi_deinit_service (ab); + goto qmi_fail; + } + +set_bit (ATH12K_FLAG_UNREGISTERING , &ab->dev_flags); + +cancel_work_sync (&ab->reset_work); +ath12k_core_deinit (ab); + +qmi_fail: +ath12k_mhi_unregister (ab_pci); + +ath12k_pci_free_irq (ab); +ath12k_pci_msi_free (ab_pci); +ath12k_pci_free_region (ab_pci); + +ath12k_hal_srng_deinit (ab); +ath12k_ce_free_pipes (ab); +ath12k_core_free (ab); +} + +static void ath12k_pci_shutdown (struct pci_dev *pdev) +{ +struct ath12k_base *ab =pci_get_drvdata (pdev); + +ath12k_pci_power_down (ab); +} + +static __maybe_unused int ath12k_pci_pm_suspend (struct device *dev) +{ +struct ath12k_base *ab =dev_get_drvdata (dev); +int ret; + + ret =ath12k_core_suspend (ab); +if (ret) +ath12k_warn (ab,"failed to suspend core: %d\n" , ret); + +return ret; +} + +static __maybe_unused int ath12k_pci_pm_resume (struct device *dev) +{ +struct ath12k_base *ab =dev_get_drvdata (dev); +int ret; + + ret =ath12k_core_resume (ab); +if (ret) +ath12k_warn (ab,"failed to resume core: %d\n" , ret); + +return ret; +} + +static SIMPLE_DEV_PM_OPS(ath12k_pci_pm_ops, + ath12k_pci_pm_suspend, + ath12k_pci_pm_resume); + +static struct pci_driver ath12k_pci_driver = { + .name ="ath12k_pci" , + .id_table = ath12k_pci_id_table, + .probe = ath12k_pci_probe, + .remove = ath12k_pci_remove, + .shutdown = ath12k_pci_shutdown, + .driver.pm = &ath12k_pci_pm_ops, +}; + +static int ath12k_pci_init (void ) +{ +int ret; + + ret =pci_register_driver (&ath12k_pci_driver); +if (ret) { +pr_err ("failed to register ath12k pci driver: %d\n" , + ret); +return ret; + } + +return 0 ; +} +module_init (ath12k_pci_init); + +static void ath12k_pci_exit (void ) +{ +pci_unregister_driver (&ath12k_pci_driver); +} + +module_exit (ath12k_pci_exit); + +MODULE_DESCRIPTION ("Driver support for Qualcomm Technologies 802.11be WLAN PCIe devices" ); +MODULE_LICENSE ("Dual BSD/GPL" );
Signature · 3 lines
ath12k mailing list [email protected] https://lists.infradead.org/mailman/listinfo/ath12k