msm: camera: memmgr: Add 4K padding for shared buffers

Due LX7 cache requirement, buffers need 4K padding at the
end. Allocate accordingly, this is hidden from user mode
driver and umd never uses this extra 4K memory.

CRs-Fixed: 2722486
Change-Id: I3b327ab3615eee30d17c95e23703024ff7446648
Signed-off-by: Pavan Kumar Chilamkurthi <[email protected]>
Signed-off-by: Karthik Anantha Ram <[email protected]>

drivers/cam_req_mgr/cam_mem_mgr.c

@@ -19,6 +19,8 @@
 #include "cam_trace.h"
 #include "cam_common_util.h"
 
+#define CAM_MEM_SHARED_BUFFER_PAD_4K (4 * 1024)
+
 static struct cam_mem_table tbl;
 static atomic_t cam_mem_mgr_state = ATOMIC_INIT(CAM_MEM_MGR_UNINITIALIZED);
 
@@ -177,6 +179,8 @@ int cam_mem_mgr_init(void)
 		return -EINVAL;
 	}
 
+	tbl.need_shared_buffer_padding = cam_smmu_need_shared_buffer_padding();
+
 #if IS_REACHABLE(CONFIG_DMABUF_HEAPS)
 	rc = cam_mem_mgr_get_dma_heaps();
 	if (rc) {
@@ -672,20 +676,18 @@ static int cam_mem_util_get_dma_buf(size_t len,
 }
 #endif
 
-static int cam_mem_util_buffer_alloc(struct cam_mem_mgr_alloc_cmd *cmd,
+static int cam_mem_util_buffer_alloc(size_t len, uint32_t flags,
 	struct dma_buf **dmabuf,
 	int *fd)
 {
 	int rc;
 	struct dma_buf *temp_dmabuf = NULL;
 
-	rc = cam_mem_util_get_dma_buf(cmd->len,
-		cmd->flags,
-		dmabuf);
+	rc = cam_mem_util_get_dma_buf(len, flags, dmabuf);
 	if (rc) {
 		CAM_ERR(CAM_MEM,
 			"Error allocating dma buf : len=%llu, flags=0x%x",
-			cmd->len, cmd->flags);
+			len, flags);
 		return rc;
 	}
 
@@ -697,7 +699,7 @@ static int cam_mem_util_buffer_alloc(struct cam_mem_mgr_alloc_cmd *cmd,
 	}
 
 	CAM_DBG(CAM_MEM, "Alloc success : len=%zu, *dmabuf=%pK, fd=%d",
-		cmd->len, *dmabuf, *fd);
+		len, *dmabuf, *fd);
 
 	/*
 	 * increment the ref count so that ref count becomes 2 here
@@ -860,8 +862,16 @@ int cam_mem_mgr_alloc_and_map(struct cam_mem_mgr_alloc_cmd *cmd)
 		CAM_ERR(CAM_MEM, " Invalid argument");
 		return -EINVAL;
 	}
+
 	len = cmd->len;
 
+	if (tbl.need_shared_buffer_padding &&
+		(cmd->flags & CAM_MEM_FLAG_HW_SHARED_ACCESS)) {
+		len += CAM_MEM_SHARED_BUFFER_PAD_4K;
+		CAM_DBG(CAM_MEM, "Pad 4k size, actual %llu, allocating %zu",
+			cmd->len, len);
+	}
+
 	rc = cam_mem_util_check_alloc_flags(cmd);
 	if (rc) {
 		CAM_ERR(CAM_MEM, "Invalid flags: flags = 0x%X, rc=%d",
@@ -869,13 +879,11 @@ int cam_mem_mgr_alloc_and_map(struct cam_mem_mgr_alloc_cmd *cmd)
 		return rc;
 	}
 
-	rc = cam_mem_util_buffer_alloc(cmd,
-		&dmabuf,
-		&fd);
+	rc = cam_mem_util_buffer_alloc(len, cmd->flags, &dmabuf, &fd);
 	if (rc) {
 		CAM_ERR(CAM_MEM,
 			"Ion Alloc failed, len=%llu, align=%llu, flags=0x%x, num_hdl=%d",
-			cmd->len, cmd->align, cmd->flags, cmd->num_hdl);
+			len, cmd->align, cmd->flags, cmd->num_hdl);
 		cam_mem_mgr_print_tbl();
 		return rc;
 	}
@@ -950,7 +958,7 @@ int cam_mem_mgr_alloc_and_map(struct cam_mem_mgr_alloc_cmd *cmd)
 	tbl.bufq[idx].kmdvaddr = kvaddr;
 	tbl.bufq[idx].vaddr = hw_vaddr;
 	tbl.bufq[idx].dma_buf = dmabuf;
-	tbl.bufq[idx].len = cmd->len;
+	tbl.bufq[idx].len = len;
 	tbl.bufq[idx].num_hdl = cmd->num_hdl;
 	memcpy(tbl.bufq[idx].hdls, cmd->mmu_hdls,
 		sizeof(int32_t) * cmd->num_hdl);

drivers/cam_req_mgr/cam_mem_mgr.h

@@ -74,6 +74,13 @@ struct cam_mem_buf_queue {
  * @alloc_profile_enable: Whether to enable alloc profiling
  * @dbg_buf_idx: debug buffer index to get usecases info
  * @force_cache_allocs: Force all internal buffer allocations with cache
+ * @need_shared_buffer_padding: Whether padding is needed for shared buffer
+ *                              allocations.
+ * @system_heap: Handle to system heap
+ * @system_uncached_heap: Handle to system uncached heap
+ * @camera_heap: Handle to camera heap
+ * @camera_uncached_heap: Handle to camera uncached heap
+ * @secure_display_heap: Handle to secure display heap
  */
 struct cam_mem_table {
 	struct mutex m_lock;
@@ -84,6 +91,7 @@ struct cam_mem_table {
 	bool alloc_profile_enable;
 	size_t dbg_buf_idx;
 	bool force_cache_allocs;
+	bool need_shared_buffer_padding;
 #if IS_REACHABLE(CONFIG_DMABUF_HEAPS)
 	struct dma_heap *system_heap;
 	struct dma_heap *system_uncached_heap;

drivers/cam_smmu/cam_smmu_api.c

@@ -183,6 +183,7 @@ struct cam_iommu_cb_set {
 	bool cb_dump_enable;
 	bool map_profile_enable;
 	bool force_cache_allocs;
+	bool need_shared_buffer_padding;
 };
 
 static const struct of_device_id msm_cam_smmu_dt_match[] = {
@@ -365,6 +366,11 @@ static void cam_smmu_dump_monitor_array(
 	}
 }
 
+bool cam_smmu_need_shared_buffer_padding(void)
+{
+	return iommu_cb_set.need_shared_buffer_padding;
+}
+
 int cam_smmu_need_force_alloc_cached(bool *force_alloc_cached)
 {
 	int idx;
@@ -4269,6 +4275,9 @@ static int cam_smmu_component_bind(struct device *dev,
 
 	iommu_cb_set.force_cache_allocs =
 		of_property_read_bool(dev->of_node, "force_cache_allocs");
+	iommu_cb_set.need_shared_buffer_padding =
+		of_property_read_bool(dev->of_node,
+		"need_shared_buffer_padding");
 
 	CAM_DBG(CAM_SMMU, "Main component bound successfully");
 	return 0;

drivers/cam_smmu/cam_smmu_api.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2014-2020, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2014-2021, The Linux Foundation. All rights reserved.
  */
 
 #ifndef _CAM_SMMU_API_H_
@@ -437,5 +437,10 @@ void cam_smmu_exit_module(void);
  */
 int cam_smmu_need_force_alloc_cached(bool *force_alloc_cached);
 
+/**
+ * @brief : API to determine whether padding is needed for shared buffers
+ */
+bool cam_smmu_need_shared_buffer_padding(void);
+
 
 #endif /* _CAM_SMMU_API_H_ */