Merge "msm: camera: tfe: Add support to TFE driver" into camera-kernel.lnx.3.1 (977525b1) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/cam_isp/cam_isp_context.c

+61 −8

Original line number	Diff line number	Diff line
		@@ -376,6 +376,38 @@ static const char *__cam_isp_resource_handle_id_to_type(
		}
		}

		static const char *__cam_isp_tfe_resource_handle_id_to_type(
		uint32_t resource_handle)
		{

		switch (resource_handle) {
		case CAM_ISP_TFE_OUT_RES_FULL:
		return "FULL";
		case CAM_ISP_TFE_OUT_RES_RAW_DUMP:
		return "RAW_DUMP";
		case CAM_ISP_TFE_OUT_RES_PDAF:
		return "PDAF";
		case CAM_ISP_TFE_OUT_RES_RDI_0:
		return "RDI_0";
		case CAM_ISP_TFE_OUT_RES_RDI_1:
		return "RDI_1";
		case CAM_ISP_TFE_OUT_RES_RDI_2:
		return "RDI_2";
		case CAM_ISP_TFE_OUT_RES_STATS_HDR_BE:
		return "STATS_HDR_BE";
		case CAM_ISP_TFE_OUT_RES_STATS_HDR_BHIST:
		return "STATS_HDR_BHIST";
		case CAM_ISP_TFE_OUT_RES_STATS_TL_BG:
		return "STATS_TL_BG";
		case CAM_ISP_TFE_OUT_RES_STATS_BF:
		return "STATS_BF";
		case CAM_ISP_TFE_OUT_RES_STATS_AWB_BG:
		return "STATS_AWB_BG";
		default:
		return "CAM_ISP_Invalid_Resource_Type";
		}
		}

		static uint64_t __cam_isp_ctx_get_event_ts(uint32_t evt_id, void *evt_data)
		{
		uint64_t ts = 0;
		@@ -471,9 +503,11 @@ static void __cam_isp_ctx_send_sof_timestamp(
		}

		static void __cam_isp_ctx_handle_buf_done_fail_log(
		uint64_t request_id, struct cam_isp_ctx_req *req_isp)
		uint64_t request_id, struct cam_isp_ctx_req *req_isp,
		uint32_t isp_device_type)
		{
		int i;
		const char *handle_type;

		if (req_isp->num_fence_map_out >= CAM_ISP_CTX_RES_MAX) {
		CAM_ERR(CAM_ISP,
		@@ -490,10 +524,18 @@ static void __cam_isp_ctx_handle_buf_done_fail_log(
		"Resource Handles that fail to generate buf_done in prev frame");
		for (i = 0; i < req_isp->num_fence_map_out; i++) {
		if (req_isp->fence_map_out[i].sync_id != -1) {
		if (isp_device_type == CAM_IFE_DEVICE_TYPE)
		handle_type =
		__cam_isp_resource_handle_id_to_type(
		req_isp->fence_map_out[i].resource_handle);
		else
		handle_type =
		__cam_isp_tfe_resource_handle_id_to_type(
		req_isp->fence_map_out[i].resource_handle);

		CAM_WARN(CAM_ISP,
		"Resource_Handle: [%s][0x%x] Sync_ID: [0x%x]",
		__cam_isp_resource_handle_id_to_type(
		req_isp->fence_map_out[i].resource_handle),
		handle_type,
		req_isp->fence_map_out[i].resource_handle,
		req_isp->fence_map_out[i].sync_id);
		}
		@@ -512,6 +554,7 @@ static int __cam_isp_ctx_handle_buf_done_for_request(
		struct cam_isp_ctx_req *req_isp;
		struct cam_context *ctx = ctx_isp->base;
		uint64_t buf_done_req_id;
		const char *handle_type;

		trace_cam_buf_done("ISP", ctx, req);

		@@ -541,11 +584,18 @@ static int __cam_isp_ctx_handle_buf_done_for_request(
		}

		if (req_isp->fence_map_out[j].sync_id == -1) {
		if (ctx_isp->isp_device_type == CAM_IFE_DEVICE_TYPE)
		handle_type =
		__cam_isp_resource_handle_id_to_type(
		req_isp->fence_map_out[i].resource_handle);
		else
		handle_type =
		__cam_isp_tfe_resource_handle_id_to_type(
		req_isp->fence_map_out[i].resource_handle);

		CAM_WARN(CAM_ISP,
		"Duplicate BUF_DONE for req %lld : i=%d, j=%d, res=%s",
		req->request_id, i, j,
		__cam_isp_resource_handle_id_to_type(
		done->resource_handle[i]));
		req->request_id, i, j, handle_type);

		if (done_next_req) {
		done_next_req->resource_handle
		@@ -1967,7 +2017,8 @@ static int __cam_isp_ctx_apply_req_in_activated_state(
		active_req_isp =
		(struct cam_isp_ctx_req *) active_req->req_priv;
		__cam_isp_ctx_handle_buf_done_fail_log(
		active_req->request_id, active_req_isp);
		active_req->request_id, active_req_isp,
		ctx_isp->isp_device_type);
		}

		rc = -EFAULT;
		@@ -4345,7 +4396,8 @@ int cam_isp_context_init(struct cam_isp_context *ctx,
		struct cam_context *ctx_base,
		struct cam_req_mgr_kmd_ops *crm_node_intf,
		struct cam_hw_mgr_intf *hw_intf,
		uint32_t ctx_id)
		uint32_t ctx_id,
		uint32_t isp_device_type)

		{
		int rc = -1;
		@@ -4369,6 +4421,7 @@ int cam_isp_context_init(struct cam_isp_context *ctx,
		ctx->substate_machine = cam_isp_ctx_activated_state_machine;
		ctx->substate_machine_irq = cam_isp_ctx_activated_state_machine_irq;
		ctx->init_timestamp = jiffies_to_msecs(jiffies);
		ctx->isp_device_type = isp_device_type;

		for (i = 0; i < CAM_CTX_REQ_MAX; i++) {
		ctx->req_base[i].req_priv = &ctx->req_isp[i];

drivers/cam_isp/cam_isp_context.h

+6 −1

Original line number	Diff line number	Diff line
		@@ -10,6 +10,7 @@
		#include <linux/spinlock.h>
		#include <media/cam_isp.h>
		#include <media/cam_defs.h>
		#include <media/cam_tfe.h>

		#include "cam_context.h"
		#include "cam_isp_hw_mgr_intf.h"
		@@ -177,6 +178,7 @@ struct cam_isp_context_state_monitor {
		* @init_received: Indicate whether init config packet is received
		* @split_acquire: Indicate whether a separate acquire is expected
		* @init_timestamp: Timestamp at which this context is initialized
		* @isp_device_type ISP device type
		*
		*/
		struct cam_isp_context {
		@@ -207,6 +209,7 @@ struct cam_isp_context {
		bool init_received;
		bool split_acquire;
		unsigned int init_timestamp;
		uint32_t isp_device_type;
		};

		/**
		@@ -218,13 +221,15 @@ struct cam_isp_context {
		* @bridge_ops: Bridge call back funciton
		* @hw_intf: ISP hw manager interface
		* @ctx_id: ID for this context
		* @isp_device_type Isp device type
		*
		*/
		int cam_isp_context_init(struct cam_isp_context *ctx,
		struct cam_context *ctx_base,
		struct cam_req_mgr_kmd_ops *bridge_ops,
		struct cam_hw_mgr_intf *hw_intf,
		uint32_t ctx_id);
		uint32_t ctx_id,
		uint32_t isp_device_type);

		/**
		* cam_isp_context_deinit()

drivers/cam_isp/cam_isp_dev.c

+22 −3

Original line number	Diff line number	Diff line
		@@ -117,12 +117,30 @@ static int cam_isp_dev_probe(struct platform_device *pdev)
		int i;
		struct cam_hw_mgr_intf hw_mgr_intf;
		struct cam_node *node;
		const char *compat_str = NULL;
		uint32_t isp_device_type;

		int iommu_hdl = -1;

		rc = of_property_read_string_index(pdev->dev.of_node, "arch-compat", 0,
		(const char **)&compat_str);

		g_isp_dev.sd.internal_ops = &cam_isp_subdev_internal_ops;
		/* Initialize the v4l2 subdevice first. (create cam_node) */
		if (strnstr(compat_str, "ife", strlen(compat_str))) {
		rc = cam_subdev_probe(&g_isp_dev.sd, pdev, CAM_ISP_DEV_NAME,
		CAM_IFE_DEVICE_TYPE);
		isp_device_type = CAM_IFE_DEVICE_TYPE;
		} else if (strnstr(compat_str, "tfe", strlen(compat_str))) {
		rc = cam_subdev_probe(&g_isp_dev.sd, pdev, CAM_ISP_DEV_NAME,
		CAM_TFE_DEVICE_TYPE);
		isp_device_type = CAM_TFE_DEVICE_TYPE;
		} else {
		CAM_ERR(CAM_ISP, "Invalid ISP hw type %s", compat_str);
		rc = -EINVAL;
		goto err;
		}

		if (rc) {
		CAM_ERR(CAM_ISP, "ISP cam_subdev_probe failed!");
		goto err;
		@@ -130,7 +148,7 @@ static int cam_isp_dev_probe(struct platform_device *pdev)
		node = (struct cam_node *) g_isp_dev.sd.token;

		memset(&hw_mgr_intf, 0, sizeof(hw_mgr_intf));
		rc = cam_isp_hw_mgr_init(pdev->dev.of_node, &hw_mgr_intf, &iommu_hdl);
		rc = cam_isp_hw_mgr_init(compat_str, &hw_mgr_intf, &iommu_hdl);
		if (rc != 0) {
		CAM_ERR(CAM_ISP, "Can not initialized ISP HW manager!");
		goto unregister;
		@@ -141,7 +159,8 @@ static int cam_isp_dev_probe(struct platform_device *pdev)
		&g_isp_dev.ctx[i],
		&node->crm_node_intf,
		&node->hw_mgr_intf,
		i);
		i,
		isp_device_type);
		if (rc) {
		CAM_ERR(CAM_ISP, "ISP context init failed!");
		goto unregister;

drivers/cam_isp/isp_hw_mgr/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -14,4 +14,4 @@ ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cpas/include
		ccflags-y += -I$(src)

		obj-$(CONFIG_SPECTRA_CAMERA) += hw_utils/ isp_hw/
		obj-$(CONFIG_SPECTRA_CAMERA) += cam_isp_hw_mgr.o cam_ife_hw_mgr.o
		obj-$(CONFIG_SPECTRA_CAMERA) += cam_isp_hw_mgr.o cam_ife_hw_mgr.o cam_tfe_hw_mgr.o

drivers/cam_isp/isp_hw_mgr/cam_isp_hw_mgr.c

+7 −8

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/*
		* Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
		* Copyright (c) 2017-2019, The Linux Foundation. All rights reserved.
		*/

		#include "cam_isp_hw_mgr_intf.h"
		#include "cam_ife_hw_mgr.h"
		#include "cam_debug_util.h"
		#include "cam_tfe_hw_mgr.h"


		int cam_isp_hw_mgr_init(struct device_node *of_node,
		int cam_isp_hw_mgr_init(const char *device_name_str,
		struct cam_hw_mgr_intf hw_mgr, int iommu_hdl)
		{
		int rc = 0;
		const char *compat_str = NULL;

		rc = of_property_read_string_index(of_node, "arch-compat", 0,
		(const char **)&compat_str);

		if (strnstr(compat_str, "ife", strlen(compat_str)))
		if (strnstr(device_name_str, "ife", strlen(device_name_str)))
		rc = cam_ife_hw_mgr_init(hw_mgr, iommu_hdl);
		else if (strnstr(device_name_str, "tfe", strlen(device_name_str)))
		rc = cam_tfe_hw_mgr_init(hw_mgr, iommu_hdl);
		else {
		CAM_ERR(CAM_ISP, "Invalid ISP hw type");
		CAM_ERR(CAM_ISP, "Invalid ISP hw type :%s", device_name_str);
		rc = -EINVAL;
		}