wifi: ath12k: add support to allocate MLO global memory region

To enable Multi-Link Operation (MLO), QCN9274 firmware requests MLO global
memory (MLO_GLOBAL_MEM_REGION_TYPE). This memory region is shared across all
the firmware (SoC) that are participation in the MLO.

Hence, add support to allocate and free MLO global memory region.  Allocate one
MLO global memory per struct ath12k_hw_group and assign the same memory to all
firmware in the same struct ath12k_hw_group. WCN7850 firmware does not request
this memory type, therefore this change will have no impact on WCN7850 device.

Tested-on: QCN9274 hw2.0 PCI WLAN.WBE.1.1.1-00210-QCAHKSWPL_SILICONZ-1
Tested-on: WCN7850 hw2.0 PCI WLAN.HMT.1.0.c5-00481-QCAHMTSWPL_V1.0_V2.0_SILICONZ-3

Signed-off-by: Karthikeyan Periyasamy <quic_periyasa@quicinc.com>
Co-developed-by: Raj Kumar Bhagat <quic_rajkbhag@quicinc.com>
Signed-off-by: Raj Kumar Bhagat <quic_rajkbhag@quicinc.com>
Signed-off-by: Kalle Valo <quic_kvalo@quicinc.com>
Link: https://patch.msgid.link/20241211153432.775335-6-kvalo@kernel.org
Signed-off-by: Jeff Johnson <jeff.johnson@oss.qualcomm.com>

diff --git a/drivers/net/wireless/ath/ath12k/core.h b/drivers/net/wireless/ath/ath12k/core.h
index d0e4668190361a06da7a7e3c054e502db1963433..bf310df3d8f71c9f66dce25b106420669651911a 100644 (file)
--- a/drivers/net/wireless/ath/ath12k/core.h
+++ b/drivers/net/wireless/ath/ath12k/core.h
@@ -822,6 +822,12 @@ struct ath12k_soc_dp_stats {
        struct ath12k_soc_dp_tx_err_stats tx_err;
 };
 
+struct ath12k_mlo_memory {
+       struct target_mem_chunk chunk[ATH12K_QMI_WLANFW_MAX_NUM_MEM_SEG_V01];
+       int mlo_mem_size;
+       bool init_done;
+};
+
 /* Holds info on the group of devices that are registered as a single
  * wiphy, protected with struct ath12k_hw_group::mutex.
  */
@@ -847,6 +853,7 @@ struct ath12k_hw_group {
        u8 num_hw;
        bool mlo_capable;
        struct device_node *wsi_node[ATH12K_MAX_SOCS];
+       struct ath12k_mlo_memory mlo_mem;
 };
 
 /* Holds WSI info specific to each device, excluding WSI group info */

diff --git a/drivers/net/wireless/ath/ath12k/qmi.c b/drivers/net/wireless/ath/ath12k/qmi.c
index 7f3d5b269b9ec8b9776c22d217afe670fc777a9b..e7846aaca10a5ee22b9fe9fbbf2bd52a2186789e 100644 (file)
--- a/drivers/net/wireless/ath/ath12k/qmi.c
+++ b/drivers/net/wireless/ath/ath12k/qmi.c
@@ -2407,19 +2407,64 @@ out:
        return ret;
 }
 
+static void ath12k_qmi_free_mlo_mem_chunk(struct ath12k_base *ab,
+                                         struct target_mem_chunk *chunk,
+                                         int idx)
+{
+       struct ath12k_hw_group *ag = ab->ag;
+       struct target_mem_chunk *mlo_chunk;
+
+       lockdep_assert_held(&ag->mutex);
+
+       if (!ag->mlo_mem.init_done || ag->num_started)
+               return;
+
+       if (idx >= ARRAY_SIZE(ag->mlo_mem.chunk)) {
+               ath12k_warn(ab, "invalid index for MLO memory chunk free: %d\n", idx);
+               return;
+       }
+
+       mlo_chunk = &ag->mlo_mem.chunk[idx];
+       if (mlo_chunk->v.addr) {
+               dma_free_coherent(ab->dev,
+                                 mlo_chunk->size,
+                                 mlo_chunk->v.addr,
+                                 mlo_chunk->paddr);
+               mlo_chunk->v.addr = NULL;
+       }
+
+       mlo_chunk->paddr = 0;
+       mlo_chunk->size = 0;
+       chunk->v.addr = NULL;
+       chunk->paddr = 0;
+       chunk->size = 0;
+}
+
 static void ath12k_qmi_free_target_mem_chunk(struct ath12k_base *ab)
 {
-       int i;
+       struct ath12k_hw_group *ag = ab->ag;
+       int i, mlo_idx;
 
-       for (i = 0; i < ab->qmi.mem_seg_count; i++) {
+       for (i = 0, mlo_idx = 0; i < ab->qmi.mem_seg_count; i++) {
                if (!ab->qmi.target_mem[i].v.addr)
                        continue;
 
-               dma_free_coherent(ab->dev,
-                                 ab->qmi.target_mem[i].prev_size,
-                                 ab->qmi.target_mem[i].v.addr,
-                                 ab->qmi.target_mem[i].paddr);
-               ab->qmi.target_mem[i].v.addr = NULL;
+               if (ab->qmi.target_mem[i].type == MLO_GLOBAL_MEM_REGION_TYPE) {
+                       ath12k_qmi_free_mlo_mem_chunk(ab,
+                                                     &ab->qmi.target_mem[i],
+                                                     mlo_idx++);
+               } else {
+                       dma_free_coherent(ab->dev,
+                                         ab->qmi.target_mem[i].prev_size,
+                                         ab->qmi.target_mem[i].v.addr,
+                                         ab->qmi.target_mem[i].paddr);
+                       ab->qmi.target_mem[i].v.addr = NULL;
+               }
+       }
+
+       if (!ag->num_started && ag->mlo_mem.init_done) {
+               ag->mlo_mem.init_done = false;
+               ag->mlo_mem.mlo_mem_size = 0;
        }
 }
 
@@ -2466,12 +2511,21 @@ this_chunk_done:
 
 static int ath12k_qmi_alloc_target_mem_chunk(struct ath12k_base *ab)
 {
-       int i, ret = 0;
-       struct target_mem_chunk *chunk;
+       struct target_mem_chunk *chunk, *mlo_chunk;
+       struct ath12k_hw_group *ag = ab->ag;
+       int i, mlo_idx, ret;
+       int mlo_size = 0;
+
+       mutex_lock(&ag->mutex);
+
+       if (!ag->mlo_mem.init_done) {
+               memset(ag->mlo_mem.chunk, 0, sizeof(ag->mlo_mem.chunk));
+               ag->mlo_mem.init_done = true;
+       }
 
        ab->qmi.target_mem_delayed = false;
 
-       for (i = 0; i < ab->qmi.mem_seg_count; i++) {
+       for (i = 0, mlo_idx = 0; i < ab->qmi.mem_seg_count; i++) {
                chunk = &ab->qmi.target_mem[i];
 
                /* Allocate memory for the region and the functionality supported
@@ -2484,6 +2538,40 @@ static int ath12k_qmi_alloc_target_mem_chunk(struct ath12k_base *ab)
                case PAGEABLE_MEM_REGION_TYPE:
                case CALDB_MEM_REGION_TYPE:
                        ret = ath12k_qmi_alloc_chunk(ab, chunk);
+                       if (ret)
+                               goto err;
+                       break;
+               case MLO_GLOBAL_MEM_REGION_TYPE:
+                       mlo_size += chunk->size;
+                       if (ag->mlo_mem.mlo_mem_size &&
+                           mlo_size > ag->mlo_mem.mlo_mem_size) {
+                               ath12k_err(ab, "QMI MLO memory allocation failure, requested size %d is more than allocated size %d",
+                                          mlo_size, ag->mlo_mem.mlo_mem_size);
+                               ret = -EINVAL;
+                               goto err;
+                       }
+
+                       mlo_chunk = &ag->mlo_mem.chunk[mlo_idx];
+                       if (mlo_chunk->paddr) {
+                               if (chunk->size != mlo_chunk->size) {
+                                       ath12k_err(ab, "QMI MLO chunk memory allocation failure for index %d, requested size %d is more than allocated size %d",
+                                                  mlo_idx, chunk->size, mlo_chunk->size);
+                                       ret = -EINVAL;
+                                       goto err;
+                               }
+                       } else {
+                               mlo_chunk->size = chunk->size;
+                               mlo_chunk->type = chunk->type;
+                               ret = ath12k_qmi_alloc_chunk(ab, mlo_chunk);
+                               if (ret)
+                                       goto err;
+                               memset(mlo_chunk->v.addr, 0, mlo_chunk->size);
+                       }
+
+                       chunk->paddr = mlo_chunk->paddr;
+                       chunk->v.addr = mlo_chunk->v.addr;
+                       mlo_idx++;
+
                        break;
                default:
                        ath12k_warn(ab, "memory type %u not supported\n",
@@ -2493,6 +2581,25 @@ static int ath12k_qmi_alloc_target_mem_chunk(struct ath12k_base *ab)
                        break;
                }
        }
+
+       if (!ag->mlo_mem.mlo_mem_size) {
+               ag->mlo_mem.mlo_mem_size = mlo_size;
+       } else if (ag->mlo_mem.mlo_mem_size != mlo_size) {
+               ath12k_err(ab, "QMI MLO memory size error, expected size is %d but requestted size is %d",
+                          ag->mlo_mem.mlo_mem_size, mlo_size);
+               ret = -EINVAL;
+               goto err;
+       }
+
+       mutex_unlock(&ag->mutex);
+
+       return 0;
+
+err:
+       ath12k_qmi_free_target_mem_chunk(ab);
+
+       mutex_unlock(&ag->mutex);
+
        return ret;
 }
 

diff --git a/drivers/net/wireless/ath/ath12k/qmi.h b/drivers/net/wireless/ath/ath12k/qmi.h
index 98f6009ab21e3e817e0d5b5e0a6915fcdafb8d59..45d7c3fcafdd7a0afa3d193cf612d255ca5a5e2e 100644 (file)
--- a/drivers/net/wireless/ath/ath12k/qmi.h
+++ b/drivers/net/wireless/ath/ath12k/qmi.h
@@ -172,6 +172,7 @@ enum ath12k_qmi_target_mem {
        BDF_MEM_REGION_TYPE = 0x2,
        M3_DUMP_REGION_TYPE = 0x3,
        CALDB_MEM_REGION_TYPE = 0x4,
+       MLO_GLOBAL_MEM_REGION_TYPE = 0x8,
        PAGEABLE_MEM_REGION_TYPE = 0x9,
 };