msm: camera: custom: Add support for custom HW

This change provides a template to add any custom HW
block.

CRs-Fixed: 2515662
Change-Id: Ie707c27950a330658cdaa4b64b7e304f4d62a5b2
Signed-off-by: Karthik Anantha Ram <[email protected]>

drivers/Makefile

@@ -11,3 +11,4 @@ obj-$(CONFIG_SPECTRA_CAMERA) += cam_icp/
 obj-$(CONFIG_SPECTRA_CAMERA) += cam_jpeg/
 obj-$(CONFIG_SPECTRA_CAMERA) += cam_fd/
 obj-$(CONFIG_SPECTRA_CAMERA) += cam_lrme/
+obj-$(CONFIG_SPECTRA_CAMERA) += cam_cust/

drivers/cam_cust/Makefile

@@ -0,0 +1,19 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_core
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/hw_utils/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/hw_utils/irq_controller
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/isp_hw/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/cam_custom_csid/
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_req_mgr
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_smmu/
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_sync
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_utils
+
+obj-$(CONFIG_SPECTRA_CAMERA) += cam_custom_hw_mgr/
+obj-$(CONFIG_SPECTRA_CAMERA) += cam_custom_dev.o cam_custom_context.o

drivers/cam_cust/cam_custom_context.c

@@ -0,0 +1,945 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/debugfs.h>
+#include <linux/videodev2.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/ratelimit.h>
+
+#include "cam_mem_mgr.h"
+#include "cam_sync_api.h"
+#include "cam_req_mgr_dev.h"
+#include "cam_trace.h"
+#include "cam_debug_util.h"
+#include "cam_packet_util.h"
+#include "cam_context_utils.h"
+#include "cam_custom_context.h"
+#include "cam_common_util.h"
+
+static const char custom_dev_name[] = "custom hw";
+
+static int __cam_custom_ctx_handle_irq_in_activated(
+	void *context, uint32_t evt_id, void *evt_data);
+
+static int __cam_custom_ctx_enqueue_request_in_order(
+	struct cam_context *ctx, struct cam_ctx_request *req)
+{
+	struct cam_ctx_request           *req_current;
+	struct cam_ctx_request           *req_prev;
+	struct list_head                  temp_list;
+
+	INIT_LIST_HEAD(&temp_list);
+	spin_lock_bh(&ctx->lock);
+	if (list_empty(&ctx->pending_req_list)) {
+		list_add_tail(&req->list, &ctx->pending_req_list);
+	} else {
+		list_for_each_entry_safe_reverse(
+			req_current, req_prev, &ctx->pending_req_list, list) {
+			if (req->request_id < req_current->request_id) {
+				list_del_init(&req_current->list);
+				list_add(&req_current->list, &temp_list);
+				continue;
+			} else if (req->request_id == req_current->request_id) {
+				CAM_WARN(CAM_CUSTOM,
+					"Received duplicated request %lld",
+					req->request_id);
+			}
+			break;
+		}
+		list_add_tail(&req->list, &ctx->pending_req_list);
+
+		if (!list_empty(&temp_list)) {
+			list_for_each_entry_safe(
+				req_current, req_prev, &temp_list, list) {
+				list_del_init(&req_current->list);
+				list_add_tail(&req_current->list,
+					&ctx->pending_req_list);
+			}
+		}
+	}
+	spin_unlock_bh(&ctx->lock);
+	return 0;
+}
+
+static int __cam_custom_ctx_flush_req(struct cam_context *ctx,
+	struct list_head *req_list, struct cam_req_mgr_flush_request *flush_req)
+{
+	int i, rc;
+	uint32_t cancel_req_id_found = 0;
+	struct cam_ctx_request           *req;
+	struct cam_ctx_request           *req_temp;
+	struct cam_custom_dev_ctx_req    *req_custom;
+	struct list_head                  flush_list;
+
+	INIT_LIST_HEAD(&flush_list);
+	if (list_empty(req_list)) {
+		CAM_DBG(CAM_CUSTOM, "request list is empty");
+		if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ) {
+			CAM_ERR(CAM_CUSTOM, "no request to cancel");
+			return -EINVAL;
+		} else {
+			return 0;
+		}
+	}
+
+	CAM_DBG(CAM_CUSTOM, "Flush [%u] in progress for req_id %llu",
+		flush_req->type, flush_req->req_id);
+	list_for_each_entry_safe(req, req_temp, req_list, list) {
+		if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ) {
+			if (req->request_id != flush_req->req_id) {
+				continue;
+			} else {
+				list_del_init(&req->list);
+				list_add_tail(&req->list, &flush_list);
+				cancel_req_id_found = 1;
+				break;
+			}
+		}
+		list_del_init(&req->list);
+		list_add_tail(&req->list, &flush_list);
+	}
+
+	list_for_each_entry_safe(req, req_temp, &flush_list, list) {
+		req_custom = (struct cam_custom_dev_ctx_req *) req->req_priv;
+		for (i = 0; i < req_custom->num_fence_map_out; i++) {
+			if (req_custom->fence_map_out[i].sync_id != -1) {
+				CAM_DBG(CAM_CUSTOM,
+					"Flush req 0x%llx, fence %d",
+					 req->request_id,
+					req_custom->fence_map_out[i].sync_id);
+				rc = cam_sync_signal(
+					req_custom->fence_map_out[i].sync_id,
+					CAM_SYNC_STATE_SIGNALED_ERROR);
+				if (rc)
+					CAM_ERR_RATE_LIMIT(CAM_CUSTOM,
+						"signal fence failed\n");
+				req_custom->fence_map_out[i].sync_id = -1;
+			}
+		}
+		list_add_tail(&req->list, &ctx->free_req_list);
+	}
+
+	if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_CANCEL_REQ &&
+		!cancel_req_id_found)
+		CAM_DBG(CAM_CUSTOM,
+			"Flush request id:%lld is not found in the list",
+			flush_req->req_id);
+
+	return 0;
+}
+
+static int __cam_custom_ctx_flush_req_in_top_state(
+	struct cam_context *ctx,
+	struct cam_req_mgr_flush_request *flush_req)
+{
+	int rc = 0;
+
+	if (flush_req->type == CAM_REQ_MGR_FLUSH_TYPE_ALL) {
+		CAM_INFO(CAM_CUSTOM, "Last request id to flush is %lld",
+			flush_req->req_id);
+		ctx->last_flush_req = flush_req->req_id;
+	}
+
+	spin_lock_bh(&ctx->lock);
+	rc = __cam_custom_ctx_flush_req(ctx, &ctx->pending_req_list, flush_req);
+	spin_unlock_bh(&ctx->lock);
+
+	return rc;
+}
+
+static int __cam_custom_ctx_flush_req_in_ready(
+	struct cam_context *ctx,
+	struct cam_req_mgr_flush_request *flush_req)
+{
+	int rc = 0;
+
+	CAM_DBG(CAM_CUSTOM, "try to flush pending list");
+	spin_lock_bh(&ctx->lock);
+	rc = __cam_custom_ctx_flush_req(ctx, &ctx->pending_req_list, flush_req);
+
+	/* if nothing is in pending req list, change state to acquire */
+	if (list_empty(&ctx->pending_req_list))
+		ctx->state = CAM_CTX_ACQUIRED;
+	spin_unlock_bh(&ctx->lock);
+
+	CAM_DBG(CAM_CUSTOM, "Flush request in ready state. next state %d",
+		 ctx->state);
+	return rc;
+}
+
+static int __cam_custom_ctx_unlink_in_ready(struct cam_context *ctx,
+	struct cam_req_mgr_core_dev_link_setup *unlink)
+{
+	ctx->link_hdl = -1;
+	ctx->ctx_crm_intf = NULL;
+	ctx->state = CAM_CTX_ACQUIRED;
+
+	return 0;
+}
+
+static int __cam_custom_stop_dev_core(
+	struct cam_context *ctx, struct cam_start_stop_dev_cmd *stop_cmd)
+{
+	int rc = 0;
+	uint32_t i;
+	struct cam_custom_context          *ctx_custom =
+		(struct cam_custom_context *) ctx->ctx_priv;
+	struct cam_ctx_request          *req;
+	struct cam_custom_dev_ctx_req       *req_custom;
+	struct cam_hw_stop_args          stop;
+
+	if (ctx_custom->hw_ctx) {
+		stop.ctxt_to_hw_map = ctx_custom->hw_ctx;
+
+		stop.args = NULL;
+		if (ctx->hw_mgr_intf->hw_stop)
+			ctx->hw_mgr_intf->hw_stop(ctx->hw_mgr_intf->hw_mgr_priv,
+			&stop);
+	}
+
+	while (!list_empty(&ctx->pending_req_list)) {
+		req = list_first_entry(&ctx->pending_req_list,
+				struct cam_ctx_request, list);
+		list_del_init(&req->list);
+		req_custom = (struct cam_custom_dev_ctx_req *) req->req_priv;
+		CAM_DBG(CAM_CUSTOM,
+			"signal fence in pending list. fence num %d",
+			 req_custom->num_fence_map_out);
+		for (i = 0; i < req_custom->num_fence_map_out; i++)
+			if (req_custom->fence_map_out[i].sync_id != -1) {
+				cam_sync_signal(
+					req_custom->fence_map_out[i].sync_id,
+					CAM_SYNC_STATE_SIGNALED_ERROR);
+			}
+		list_add_tail(&req->list, &ctx->free_req_list);
+	}
+
+	while (!list_empty(&ctx->wait_req_list)) {
+		req = list_first_entry(&ctx->wait_req_list,
+				struct cam_ctx_request, list);
+		list_del_init(&req->list);
+		req_custom = (struct cam_custom_dev_ctx_req *) req->req_priv;
+		CAM_DBG(CAM_CUSTOM, "signal fence in wait list. fence num %d",
+			 req_custom->num_fence_map_out);
+		for (i = 0; i < req_custom->num_fence_map_out; i++)
+			if (req_custom->fence_map_out[i].sync_id != -1) {
+				cam_sync_signal(
+					req_custom->fence_map_out[i].sync_id,
+					CAM_SYNC_STATE_SIGNALED_ERROR);
+			}
+		list_add_tail(&req->list, &ctx->free_req_list);
+	}
+
+	while (!list_empty(&ctx->active_req_list)) {
+		req = list_first_entry(&ctx->active_req_list,
+				struct cam_ctx_request, list);
+		list_del_init(&req->list);
+		req_custom = (struct cam_custom_dev_ctx_req *) req->req_priv;
+		CAM_DBG(CAM_CUSTOM, "signal fence in active list. fence num %d",
+			 req_custom->num_fence_map_out);
+		for (i = 0; i < req_custom->num_fence_map_out; i++)
+			if (req_custom->fence_map_out[i].sync_id != -1) {
+				cam_sync_signal(
+					req_custom->fence_map_out[i].sync_id,
+					CAM_SYNC_STATE_SIGNALED_ERROR);
+			}
+		list_add_tail(&req->list, &ctx->free_req_list);
+	}
+	ctx_custom->frame_id = 0;
+	ctx_custom->active_req_cnt = 0;
+
+	CAM_DBG(CAM_CUSTOM, "Stop device success next state %d on ctx %u",
+		ctx->state, ctx->ctx_id);
+
+	if (!stop_cmd) {
+		rc = __cam_custom_ctx_unlink_in_ready(ctx, NULL);
+		if (rc)
+			CAM_ERR(CAM_CUSTOM, "Unlink failed rc=%d", rc);
+	}
+	return rc;
+}
+
+static int __cam_custom_stop_dev_in_activated(struct cam_context *ctx,
+	struct cam_start_stop_dev_cmd *cmd)
+{
+	struct cam_custom_context *ctx_custom =
+		(struct cam_custom_context *)ctx->ctx_priv;
+
+	__cam_custom_stop_dev_core(ctx, cmd);
+	ctx_custom->init_received = false;
+	ctx->state = CAM_CTX_ACQUIRED;
+
+	return 0;
+}
+
+static int __cam_custom_release_dev_in_acquired(struct cam_context *ctx,
+	struct cam_release_dev_cmd *cmd)
+{
+	int rc;
+	struct cam_custom_context *ctx_custom =
+		(struct cam_custom_context *) ctx->ctx_priv;
+	struct cam_req_mgr_flush_request flush_req;
+
+	rc = cam_context_release_dev_to_hw(ctx, cmd);
+	if (rc)
+		CAM_ERR(CAM_CUSTOM, "Unable to release device");
+
+	ctx->ctx_crm_intf = NULL;
+	ctx->last_flush_req = 0;
+	ctx_custom->frame_id = 0;
+	ctx_custom->active_req_cnt = 0;
+	ctx_custom->init_received = false;
+
+	if (!list_empty(&ctx->active_req_list))
+		CAM_ERR(CAM_CUSTOM, "Active list is not empty");
+
+	/* Flush all the pending request list  */
+	flush_req.type = CAM_REQ_MGR_FLUSH_TYPE_ALL;
+	flush_req.link_hdl = ctx->link_hdl;
+	flush_req.dev_hdl = ctx->dev_hdl;
+
+	CAM_DBG(CAM_CUSTOM, "try to flush pending list");
+	spin_lock_bh(&ctx->lock);
+	rc = __cam_custom_ctx_flush_req(ctx, &ctx->pending_req_list,
+		&flush_req);
+	spin_unlock_bh(&ctx->lock);
+	ctx->state = CAM_CTX_AVAILABLE;
+
+	CAM_DBG(CAM_CUSTOM, "Release device success[%u] next state %d",
+		ctx->ctx_id, ctx->state);
+
+	return rc;
+}
+
+static int __cam_custom_ctx_apply_req_in_activated_state(
+	struct cam_context *ctx, struct cam_req_mgr_apply_request *apply)
+{
+	int rc = 0;
+	struct cam_ctx_request          *req;
+	struct cam_custom_dev_ctx_req   *req_custom;
+	struct cam_custom_context       *custom_ctx = NULL;
+	struct cam_hw_config_args        cfg;
+
+	if (list_empty(&ctx->pending_req_list)) {
+		CAM_ERR(CAM_CUSTOM, "No available request for Apply id %lld",
+			apply->request_id);
+		rc = -EFAULT;
+		goto end;
+	}
+
+	custom_ctx = (struct cam_custom_context *) ctx->ctx_priv;
+	spin_lock_bh(&ctx->lock);
+	req = list_first_entry(&ctx->pending_req_list, struct cam_ctx_request,
+		list);
+	spin_unlock_bh(&ctx->lock);
+
+	/*
+	 * Check whether the request id is matching the tip
+	 */
+	if (req->request_id != apply->request_id) {
+		CAM_ERR_RATE_LIMIT(CAM_CUSTOM,
+			"Invalid Request Id asking %llu existing %llu",
+			apply->request_id, req->request_id);
+		rc = -EFAULT;
+		goto end;
+	}
+
+	req_custom = (struct cam_custom_dev_ctx_req *) req->req_priv;
+
+	cfg.ctxt_to_hw_map = custom_ctx->hw_ctx;
+	cfg.request_id = req->request_id;
+	cfg.hw_update_entries = req_custom->cfg;
+	cfg.num_hw_update_entries = req_custom->num_cfg;
+	cfg.priv  = &req_custom->hw_update_data;
+	cfg.init_packet = 0;
+
+	rc = ctx->hw_mgr_intf->hw_config(ctx->hw_mgr_intf->hw_mgr_priv, &cfg);
+	if (rc) {
+		CAM_ERR_RATE_LIMIT(CAM_CUSTOM,
+			"Can not apply the configuration");
+	} else {
+		spin_lock_bh(&ctx->lock);
+		list_del_init(&req->list);
+		if (!req->num_out_map_entries) {
+			list_add_tail(&req->list, &ctx->free_req_list);
+			spin_unlock_bh(&ctx->lock);
+		} else {
+			list_add_tail(&req->list, &ctx->active_req_list);
+			spin_unlock_bh(&ctx->lock);
+			/*
+			 * for test purposes only-this should be
+			 * triggered based on irq
+			 */
+			 __cam_custom_ctx_handle_irq_in_activated(ctx, 0, NULL);
+		}
+	}
+
+end:
+	return rc;
+}
+
+static int __cam_custom_ctx_acquire_dev_in_available(struct cam_context *ctx,
+	struct cam_acquire_dev_cmd *cmd)
+{
+	int rc;
+	struct cam_custom_context *custom_ctx;
+
+	custom_ctx = (struct cam_custom_context *) ctx->ctx_priv;
+
+	if (cmd->num_resources > CAM_CUSTOM_DEV_CTX_RES_MAX) {
+		CAM_ERR(CAM_CUSTOM, "Too much resources in the acquire");
+		rc = -ENOMEM;
+		return rc;
+	}
+
+	if (cmd->handle_type != 1)	{
+		CAM_ERR(CAM_CUSTOM, "Only user pointer is supported");
+		rc = -EINVAL;
+		return rc;
+	}
+
+	rc = cam_context_acquire_dev_to_hw(ctx, cmd);
+	if (!rc) {
+		ctx->state = CAM_CTX_ACQUIRED;
+		custom_ctx->hw_ctx = ctx->ctxt_to_hw_map;
+	}
+
+	CAM_DBG(CAM_CUSTOM, "Acquire done %d", ctx->ctx_id);
+	return rc;
+}
+
+static int __cam_custom_ctx_enqueue_init_request(
+	struct cam_context *ctx, struct cam_ctx_request *req)
+{
+	int rc = 0;
+	struct cam_ctx_request           *req_old;
+	struct cam_custom_dev_ctx_req    *req_custom_old;
+	struct cam_custom_dev_ctx_req    *req_custom_new;
+
+	spin_lock_bh(&ctx->lock);
+	if (list_empty(&ctx->pending_req_list)) {
+		list_add_tail(&req->list, &ctx->pending_req_list);
+		goto end;
+	}
+
+	req_old = list_first_entry(&ctx->pending_req_list,
+		struct cam_ctx_request, list);
+	req_custom_old = (struct cam_custom_dev_ctx_req *) req_old->req_priv;
+	req_custom_new = (struct cam_custom_dev_ctx_req *) req->req_priv;
+	if (req_custom_old->hw_update_data.packet_opcode_type ==
+		CAM_CUSTOM_PACKET_INIT_DEV) {
+		if ((req_custom_old->num_cfg + req_custom_new->num_cfg) >=
+			CAM_CUSTOM_CTX_CFG_MAX) {
+			CAM_WARN(CAM_CUSTOM, "Can not merge INIT pkt");
+			rc = -ENOMEM;
+		}
+
+		if (req_custom_old->num_fence_map_out != 0 ||
+			req_custom_old->num_fence_map_in != 0) {
+			CAM_WARN(CAM_CUSTOM, "Invalid INIT pkt sequence");
+			rc = -EINVAL;
+		}
+
+		if (!rc) {
+			memcpy(req_custom_old->fence_map_out,
+				req_custom_new->fence_map_out,
+				sizeof(req_custom_new->fence_map_out[0])*
+				req_custom_new->num_fence_map_out);
+			req_custom_old->num_fence_map_out =
+				req_custom_new->num_fence_map_out;
+
+			memcpy(req_custom_old->fence_map_in,
+				req_custom_new->fence_map_in,
+				sizeof(req_custom_new->fence_map_in[0])*
+				req_custom_new->num_fence_map_in);
+			req_custom_old->num_fence_map_in =
+				req_custom_new->num_fence_map_in;
+
+			memcpy(&req_custom_old->cfg[req_custom_old->num_cfg],
+				req_custom_new->cfg,
+				sizeof(req_custom_new->cfg[0])*
+				req_custom_new->num_cfg);
+			req_custom_old->num_cfg += req_custom_new->num_cfg;
+
+			req_old->request_id = req->request_id;
+
+			list_add_tail(&req->list, &ctx->free_req_list);
+		}
+	} else {
+		CAM_WARN(CAM_CUSTOM,
+			"Received Update pkt before INIT pkt. req_id= %lld",
+			req->request_id);
+		rc = -EINVAL;
+	}
+end:
+	spin_unlock_bh(&ctx->lock);
+	return rc;
+}
+
+static int __cam_custom_ctx_config_dev(struct cam_context *ctx,
+	struct cam_config_dev_cmd *cmd)
+{
+	int rc = 0, i;
+	struct cam_ctx_request           *req = NULL;
+	struct cam_custom_dev_ctx_req    *req_custom;
+	uintptr_t                         packet_addr;
+	struct cam_packet                *packet;
+	size_t                            len = 0;
+	struct cam_hw_prepare_update_args cfg;
+	struct cam_req_mgr_add_request    add_req;
+	struct cam_custom_context        *ctx_custom =
+		(struct cam_custom_context *) ctx->ctx_priv;
+
+	/* get free request */
+	spin_lock_bh(&ctx->lock);
+	if (!list_empty(&ctx->free_req_list)) {
+		req = list_first_entry(&ctx->free_req_list,
+				struct cam_ctx_request, list);
+		list_del_init(&req->list);
+	}
+	spin_unlock_bh(&ctx->lock);
+
+	if (!req) {
+		CAM_ERR(CAM_CUSTOM, "No more request obj free");
+		return -ENOMEM;
+	}
+
+	req_custom = (struct cam_custom_dev_ctx_req *) req->req_priv;
+
+	/* for config dev, only memory handle is supported */
+	/* map packet from the memhandle */
+	rc = cam_mem_get_cpu_buf((int32_t) cmd->packet_handle,
+		&packet_addr, &len);
+	if (rc != 0) {
+		CAM_ERR(CAM_CUSTOM, "Can not get packet address");
+		rc = -EINVAL;
+		goto free_req;
+	}
+
+	packet = (struct cam_packet *)(packet_addr + (uint32_t)cmd->offset);
+	CAM_DBG(CAM_CUSTOM, "pack_handle %llx", cmd->packet_handle);
+	CAM_DBG(CAM_CUSTOM, "packet address is 0x%zx", packet_addr);
+	CAM_DBG(CAM_CUSTOM, "packet with length %zu, offset 0x%llx",
+		len, cmd->offset);
+	CAM_DBG(CAM_CUSTOM, "Packet request id %lld",
+		packet->header.request_id);
+	CAM_DBG(CAM_CUSTOM, "Packet size 0x%x", packet->header.size);
+	CAM_DBG(CAM_CUSTOM, "packet op %d", packet->header.op_code);
+
+	if ((((packet->header.op_code) & 0xF) ==
+		CAM_CUSTOM_PACKET_UPDATE_DEV)
+		&& (packet->header.request_id <= ctx->last_flush_req)) {
+		CAM_DBG(CAM_CUSTOM,
+			"request %lld has been flushed, reject packet",
+			packet->header.request_id);
+		rc = -EINVAL;
+		goto free_req;
+	}
+
+	/* preprocess the configuration */
+	memset(&cfg, 0, sizeof(cfg));
+	cfg.packet = packet;
+	cfg.ctxt_to_hw_map = ctx_custom->hw_ctx;
+	cfg.out_map_entries = req_custom->fence_map_out;
+	cfg.in_map_entries = req_custom->fence_map_in;
+	cfg.priv  = &req_custom->hw_update_data;
+	cfg.pf_data = &(req->pf_data);
+
+	rc = ctx->hw_mgr_intf->hw_prepare_update(
+		ctx->hw_mgr_intf->hw_mgr_priv, &cfg);
+	if (rc != 0) {
+		CAM_ERR(CAM_CUSTOM, "Prepare config packet failed in HW layer");
+		rc = -EFAULT;
+		goto free_req;
+	}
+
+	req_custom->num_cfg = cfg.num_hw_update_entries;
+	req_custom->num_fence_map_out = cfg.num_out_map_entries;
+	req_custom->num_fence_map_in = cfg.num_in_map_entries;
+	req_custom->num_acked = 0;
+
+	for (i = 0; i < req_custom->num_fence_map_out; i++) {
+		rc = cam_sync_get_obj_ref(req_custom->fence_map_out[i].sync_id);
+		if (rc) {
+			CAM_ERR(CAM_CUSTOM, "Can't get ref for fence %d",
+				req_custom->fence_map_out[i].sync_id);
+			goto put_ref;
+		}
+	}
+
+	CAM_DBG(CAM_CUSTOM,
+		"num_entry: %d, num fence out: %d, num fence in: %d",
+		req_custom->num_cfg, req_custom->num_fence_map_out,
+		req_custom->num_fence_map_in);
+
+	req->request_id = packet->header.request_id;
+	req->status = 1;
+
+	CAM_DBG(CAM_CUSTOM, "Packet request id %lld packet opcode:%d",
+		packet->header.request_id,
+		req_custom->hw_update_data.packet_opcode_type);
+
+	if (req_custom->hw_update_data.packet_opcode_type ==
+		CAM_CUSTOM_PACKET_INIT_DEV) {
+		if (ctx->state < CAM_CTX_ACTIVATED) {
+			rc = __cam_custom_ctx_enqueue_init_request(ctx, req);
+			if (rc)
+				CAM_ERR(CAM_CUSTOM, "Enqueue INIT pkt failed");
+			ctx_custom->init_received = true;
+		} else {
+			rc = -EINVAL;
+			CAM_ERR(CAM_CUSTOM, "Recevied INIT pkt in wrong state");
+		}
+	} else {
+		if (ctx->state >= CAM_CTX_READY && ctx->ctx_crm_intf->add_req) {
+			add_req.link_hdl = ctx->link_hdl;
+			add_req.dev_hdl  = ctx->dev_hdl;
+			add_req.req_id   = req->request_id;
+			add_req.skip_before_applying = 0;
+			rc = ctx->ctx_crm_intf->add_req(&add_req);
+			if (rc) {
+				CAM_ERR(CAM_CUSTOM,
+					"Add req failed: req id=%llu",
+					req->request_id);
+			} else {
+				__cam_custom_ctx_enqueue_request_in_order(
+					ctx, req);
+			}
+		} else {
+			rc = -EINVAL;
+			CAM_ERR(CAM_CUSTOM, "Recevied Update in wrong state");
+		}
+	}
+
+	if (rc)
+		goto put_ref;
+
+	CAM_DBG(CAM_CUSTOM,
+		"Preprocessing Config req_id %lld successful on ctx %u",
+		req->request_id, ctx->ctx_id);
+
+	return rc;
+
+put_ref:
+	for (--i; i >= 0; i--) {
+		if (cam_sync_put_obj_ref(req_custom->fence_map_out[i].sync_id))
+			CAM_ERR(CAM_CUSTOM, "Failed to put ref of fence %d",
+				req_custom->fence_map_out[i].sync_id);
+	}
+free_req:
+	spin_lock_bh(&ctx->lock);
+	list_add_tail(&req->list, &ctx->free_req_list);
+	spin_unlock_bh(&ctx->lock);
+
+	return rc;
+
+}
+
+static int __cam_custom_ctx_config_dev_in_acquired(struct cam_context *ctx,
+	struct cam_config_dev_cmd *cmd)
+{
+	int rc = 0;
+
+	rc = __cam_custom_ctx_config_dev(ctx, cmd);
+
+	if (!rc && (ctx->link_hdl >= 0))
+		ctx->state = CAM_CTX_READY;
+
+	return rc;
+}
+
+static int __cam_custom_ctx_link_in_acquired(struct cam_context *ctx,
+	struct cam_req_mgr_core_dev_link_setup *link)
+{
+	struct cam_custom_context *ctx_custom =
+		(struct cam_custom_context *) ctx->ctx_priv;
+
+	ctx->link_hdl = link->link_hdl;
+	ctx->ctx_crm_intf = link->crm_cb;
+	ctx_custom->subscribe_event = link->subscribe_event;
+
+	/* change state only if we had the init config */
+	if (ctx_custom->init_received)
+		ctx->state = CAM_CTX_READY;
+
+	CAM_DBG(CAM_CUSTOM, "next state %d", ctx->state);
+
+	return 0;
+}
+
+static int __cam_custom_ctx_unlink_in_acquired(struct cam_context *ctx,
+	struct cam_req_mgr_core_dev_link_setup *unlink)
+{
+	ctx->link_hdl = -1;
+	ctx->ctx_crm_intf = NULL;
+
+	return 0;
+}
+
+static int __cam_custom_ctx_get_dev_info_in_acquired(struct cam_context *ctx,
+	struct cam_req_mgr_device_info *dev_info)
+{
+	dev_info->dev_hdl = ctx->dev_hdl;
+	strlcpy(dev_info->name, CAM_CUSTOM_DEV_NAME, sizeof(dev_info->name));
+	dev_info->dev_id = CAM_REQ_MGR_DEVICE_CUSTOM_HW;
+	dev_info->p_delay = 1;
+	dev_info->trigger = CAM_TRIGGER_POINT_SOF;
+
+	return 0;
+}
+
+static int __cam_custom_ctx_start_dev_in_ready(struct cam_context *ctx,
+	struct cam_start_stop_dev_cmd *cmd)
+{
+	int rc = 0;
+	struct cam_hw_config_args        hw_config;
+	struct cam_ctx_request          *req;
+	struct cam_custom_dev_ctx_req   *req_custom;
+	struct cam_custom_context       *ctx_custom =
+		(struct cam_custom_context *) ctx->ctx_priv;
+
+	if (cmd->session_handle != ctx->session_hdl ||
+		cmd->dev_handle != ctx->dev_hdl) {
+		rc = -EPERM;
+		goto end;
+	}
+
+	if (list_empty(&ctx->pending_req_list)) {
+		/* should never happen */
+		CAM_ERR(CAM_CUSTOM, "Start device with empty configuration");
+		rc = -EFAULT;
+		goto end;
+	} else {
+		req = list_first_entry(&ctx->pending_req_list,
+			struct cam_ctx_request, list);
+	}
+	req_custom = (struct cam_custom_dev_ctx_req *) req->req_priv;
+
+	if (!ctx_custom->hw_ctx) {
+		CAM_ERR(CAM_CUSTOM, "Wrong hw context pointer.");
+		rc = -EFAULT;
+		goto end;
+	}
+
+	hw_config.ctxt_to_hw_map = ctx_custom->hw_ctx;
+	hw_config.request_id = req->request_id;
+	hw_config.hw_update_entries = req_custom->cfg;
+	hw_config.num_hw_update_entries = req_custom->num_cfg;
+	hw_config.priv  = &req_custom->hw_update_data;
+	hw_config.init_packet = 1;
+
+	ctx->state = CAM_CTX_ACTIVATED;
+	rc = ctx->hw_mgr_intf->hw_start(ctx->hw_mgr_intf->hw_mgr_priv,
+		&hw_config);
+	if (rc) {
+		/* HW failure. User need to clean up the resource */
+		CAM_ERR(CAM_CUSTOM, "Start HW failed");
+		ctx->state = CAM_CTX_READY;
+		goto end;
+	}
+
+	CAM_DBG(CAM_CUSTOM, "start device success ctx %u",
+		ctx->ctx_id);
+
+	spin_lock_bh(&ctx->lock);
+	list_del_init(&req->list);
+	if (req_custom->num_fence_map_out)
+		list_add_tail(&req->list, &ctx->active_req_list);
+	else
+		list_add_tail(&req->list, &ctx->free_req_list);
+	spin_unlock_bh(&ctx->lock);
+
+end:
+	return rc;
+}
+
+static int __cam_custom_ctx_release_dev_in_activated(struct cam_context *ctx,
+	struct cam_release_dev_cmd *cmd)
+{
+	int rc = 0;
+
+	rc = __cam_custom_stop_dev_core(ctx, NULL);
+	if (rc)
+		CAM_ERR(CAM_CUSTOM, "Stop device failed rc=%d", rc);
+
+	rc = __cam_custom_release_dev_in_acquired(ctx, cmd);
+	if (rc)
+		CAM_ERR(CAM_CUSTOM, "Release device failed rc=%d", rc);
+
+	return rc;
+}
+
+static int __cam_custom_ctx_unlink_in_activated(struct cam_context *ctx,
+	struct cam_req_mgr_core_dev_link_setup *unlink)
+{
+	int rc = 0;
+
+	CAM_WARN(CAM_CUSTOM,
+		"Received unlink in activated state. It's unexpected");
+
+	rc = __cam_custom_stop_dev_in_activated(ctx, NULL);
+	if (rc)
+		CAM_WARN(CAM_CUSTOM, "Stop device failed rc=%d", rc);
+
+	rc = __cam_custom_ctx_unlink_in_ready(ctx, unlink);
+	if (rc)
+		CAM_ERR(CAM_CUSTOM, "Unlink failed rc=%d", rc);
+
+	return rc;
+}
+
+static int __cam_custom_ctx_process_evt(struct cam_context *ctx,
+	struct cam_req_mgr_link_evt_data *link_evt_data)
+{
+	switch (link_evt_data->evt_type) {
+	case CAM_REQ_MGR_LINK_EVT_ERR:
+		/* Handle error/bubble related issues */
+		break;
+	default:
+		CAM_WARN(CAM_CUSTOM, "Unknown event from CRM");
+		break;
+	}
+
+	return 0;
+}
+
+static int __cam_custom_ctx_handle_irq_in_activated(void *context,
+	uint32_t evt_id, void *evt_data)
+{
+	int rc;
+	struct cam_context *ctx =
+		(struct cam_context *)context;
+
+	CAM_DBG(CAM_CUSTOM, "Enter %d", ctx->ctx_id);
+
+	/*
+	 * handle based on different irq's currently
+	 * triggering only buf done if there are fences
+	 */
+	rc = cam_context_buf_done_from_hw(ctx, evt_data, 0);
+	if (rc)
+		CAM_ERR(CAM_CUSTOM, "Failed in buf done, rc=%d", rc);
+
+	return rc;
+}
+
+/* top state machine */
+static struct cam_ctx_ops
+	cam_custom_dev_ctx_top_state_machine[CAM_CTX_STATE_MAX] = {
+	/* Uninit */
+	{
+		.ioctl_ops = {},
+		.crm_ops = {},
+		.irq_ops = NULL,
+	},
+	/* Available */
+	{
+		.ioctl_ops = {
+			.acquire_dev =
+				__cam_custom_ctx_acquire_dev_in_available,
+		},
+		.crm_ops = {},
+		.irq_ops = NULL,
+	},
+	/* Acquired */
+	{
+		.ioctl_ops = {
+			.release_dev = __cam_custom_release_dev_in_acquired,
+			.config_dev = __cam_custom_ctx_config_dev_in_acquired,
+		},
+		.crm_ops = {
+			.link = __cam_custom_ctx_link_in_acquired,
+			.unlink = __cam_custom_ctx_unlink_in_acquired,
+			.get_dev_info =
+				__cam_custom_ctx_get_dev_info_in_acquired,
+			.flush_req = __cam_custom_ctx_flush_req_in_top_state,
+		},
+		.irq_ops = NULL,
+		.pagefault_ops = NULL,
+	},
+	/* Ready */
+	{
+		.ioctl_ops = {
+			.start_dev = __cam_custom_ctx_start_dev_in_ready,
+			.release_dev = __cam_custom_release_dev_in_acquired,
+			.config_dev = __cam_custom_ctx_config_dev,
+		},
+		.crm_ops = {
+			.unlink = __cam_custom_ctx_unlink_in_ready,
+			.flush_req = __cam_custom_ctx_flush_req_in_ready,
+		},
+		.irq_ops = NULL,
+		.pagefault_ops = NULL,
+	},
+	/* Activated */
+	{
+		.ioctl_ops = {
+			.stop_dev = __cam_custom_stop_dev_in_activated,
+			.release_dev =
+				__cam_custom_ctx_release_dev_in_activated,
+			.config_dev = __cam_custom_ctx_config_dev,
+		},
+		.crm_ops = {
+			.unlink = __cam_custom_ctx_unlink_in_activated,
+			.apply_req =
+				__cam_custom_ctx_apply_req_in_activated_state,
+			.flush_req = __cam_custom_ctx_flush_req_in_top_state,
+			.process_evt = __cam_custom_ctx_process_evt,
+		},
+		.irq_ops = __cam_custom_ctx_handle_irq_in_activated,
+		.pagefault_ops = NULL,
+	},
+};
+
+int cam_custom_dev_context_init(struct cam_custom_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)
+{
+	int rc = -1, i = 0;
+
+	if (!ctx || !ctx_base) {
+		CAM_ERR(CAM_CUSTOM, "Invalid Context");
+		return -EINVAL;
+	}
+
+	/* Custom HW context setup */
+	memset(ctx, 0, sizeof(*ctx));
+
+	ctx->base = ctx_base;
+	ctx->frame_id = 0;
+	ctx->active_req_cnt = 0;
+	ctx->hw_ctx = NULL;
+
+	for (i = 0; i < CAM_CTX_REQ_MAX; i++) {
+		ctx->req_base[i].req_priv = &ctx->req_custom[i];
+		ctx->req_custom[i].base = &ctx->req_base[i];
+	}
+
+	/* camera context setup */
+	rc = cam_context_init(ctx_base, custom_dev_name, CAM_CUSTOM, ctx_id,
+		crm_node_intf, hw_intf, ctx->req_base, CAM_CTX_REQ_MAX);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "Camera Context Base init failed");
+		return rc;
+	}
+
+	/* link camera context with custom HW context */
+	ctx_base->state_machine = cam_custom_dev_ctx_top_state_machine;
+	ctx_base->ctx_priv = ctx;
+
+	return rc;
+}
+
+int cam_custom_dev_context_deinit(struct cam_custom_context *ctx)
+{
+	if (ctx->base)
+		cam_context_deinit(ctx->base);
+
+	memset(ctx, 0, sizeof(*ctx));
+	return 0;
+}

drivers/cam_cust/cam_custom_context.h

@@ -0,0 +1,115 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_CUSTOM_CONTEXT_H_
+#define _CAM_CUSTOM_CONTEXT_H_
+
+#include <linux/spinlock.h>
+#include <uapi/media/cam_custom.h>
+#include <uapi/media/cam_defs.h>
+
+#include "cam_context.h"
+#include "cam_custom_hw_mgr_intf.h"
+
+/*
+ * Maximum hw resource - This number is based on the maximum
+ * output port resource. The current maximum resource number
+ * is 2.
+ */
+#define CAM_CUSTOM_DEV_CTX_RES_MAX                     2
+
+#define CAM_CUSTOM_CTX_CFG_MAX                         8
+
+/* forward declaration */
+struct cam_custom_context;
+
+/**
+ * struct cam_custom_dev_ctx_req - Custom context request object
+ *
+ * @base:                  Common request object pointer
+ * @cfg:                   Custom hardware configuration array
+ * @num_cfg:               Number of custom hardware configuration entries
+ * @fence_map_out:         Output fence mapping array
+ * @num_fence_map_out:     Number of the output fence map
+ * @fence_map_in:          Input fence mapping array
+ * @num_fence_map_in:      Number of input fence map
+ * @num_acked:             Count to track acked entried for output.
+ *                         If count equals the number of fence out, it means
+ *                         the request has been completed.
+ * @hw_update_data:        HW update data for this request
+ *
+ */
+struct cam_custom_dev_ctx_req {
+	struct cam_ctx_request                  *base;
+	struct cam_hw_update_entry               cfg
+						[CAM_CUSTOM_CTX_CFG_MAX];
+	uint32_t                                 num_cfg;
+	struct cam_hw_fence_map_entry            fence_map_out
+						[CAM_CUSTOM_DEV_CTX_RES_MAX];
+	uint32_t                                 num_fence_map_out;
+	struct cam_hw_fence_map_entry            fence_map_in
+						[CAM_CUSTOM_DEV_CTX_RES_MAX];
+	uint32_t                                 num_fence_map_in;
+	uint32_t                                 num_acked;
+	struct cam_custom_prepare_hw_update_data hw_update_data;
+};
+
+/**
+ * struct cam_custom_context - Custom device context
+ * @base: custom device context object
+ * @state_machine: state machine for Custom device context
+ * @state: Common context state
+ * @hw_ctx: HW object returned by the acquire device command
+ * @init_received: Indicate whether init config packet is received
+ * @subscribe_event: The irq event mask that CRM subscribes to,
+ *                   custom HW will invoke CRM cb at those event.
+ * @active_req_cnt: Counter for the active request
+ * @frame_id: Frame id tracking for the custom context
+ * @req_base: common request structure
+ * @req_custom: custom request structure
+ *
+ */
+struct cam_custom_context {
+	struct cam_context           *base;
+	struct cam_ctx_ops           *state_machine;
+	uint32_t                      state;
+	void                         *hw_ctx;
+	bool                          init_received;
+	uint32_t                      subscribe_event;
+	uint32_t                      active_req_cnt;
+	int64_t                       frame_id;
+	struct cam_ctx_request        req_base[CAM_CTX_REQ_MAX];
+	struct cam_custom_dev_ctx_req req_custom[CAM_CTX_REQ_MAX];
+};
+
+
+/**
+ * cam_custom_dev_context_init()
+ *
+ * @brief:              Initialization function for the custom context
+ *
+ * @ctx:                Custom context obj to be initialized
+ * @bridge_ops:         Bridge call back funciton
+ * @hw_intf:            Cust hw manager interface
+ * @ctx_id:             ID for this context
+ *
+ */
+int cam_custom_dev_context_init(struct cam_custom_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);
+
+/**
+ * cam_custom_dev_context_deinit()
+ *
+ * @brief:               Deinitialize function for the Custom context
+ *
+ * @ctx:                 Custom context obj to be deinitialized
+ *
+ */
+int cam_custom_dev_context_deinit(struct cam_custom_context *ctx);
+
+#endif  /* _CAM_CUSTOM_CONTEXT_H_ */

drivers/cam_cust/cam_custom_dev.c

@@ -0,0 +1,198 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/of.h>
+#include <linux/module.h>
+#include <linux/ion.h>
+#include <linux/iommu.h>
+#include <linux/timer.h>
+#include <linux/kernel.h>
+
+#include <uapi/media/cam_req_mgr.h>
+#include "cam_custom_dev.h"
+#include "cam_hw_mgr_intf.h"
+#include "cam_custom_hw_mgr_intf.h"
+#include "cam_node.h"
+#include "cam_debug_util.h"
+#include "cam_smmu_api.h"
+
+static struct cam_custom_dev g_custom_dev;
+
+static void cam_custom_dev_iommu_fault_handler(
+	struct iommu_domain *domain, struct device *dev, unsigned long iova,
+	int flags, void *token, uint32_t buf_info)
+{
+	int i = 0;
+	struct cam_node *node = NULL;
+
+	if (!token) {
+		CAM_ERR(CAM_CUSTOM, "invalid token in page handler cb");
+		return;
+	}
+
+	node = (struct cam_node *)token;
+
+	for (i = 0; i < node->ctx_size; i++)
+		cam_context_dump_pf_info(&(node->ctx_list[i]), iova,
+			buf_info);
+}
+
+static const struct of_device_id cam_custom_dt_match[] = {
+	{
+		.compatible = "qcom,cam-custom"
+	},
+	{}
+};
+
+static int cam_custom_subdev_open(struct v4l2_subdev *sd,
+	struct v4l2_subdev_fh *fh)
+{
+	mutex_lock(&g_custom_dev.custom_dev_mutex);
+	g_custom_dev.open_cnt++;
+	mutex_unlock(&g_custom_dev.custom_dev_mutex);
+
+	return 0;
+}
+
+static int cam_custom_subdev_close(struct v4l2_subdev *sd,
+	struct v4l2_subdev_fh *fh)
+{
+	int rc = 0;
+	struct cam_node *node = v4l2_get_subdevdata(sd);
+
+	mutex_lock(&g_custom_dev.custom_dev_mutex);
+	if (g_custom_dev.open_cnt <= 0) {
+		CAM_DBG(CAM_CUSTOM, "Custom subdev is already closed");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	g_custom_dev.open_cnt--;
+	if (!node) {
+		CAM_ERR(CAM_CUSTOM, "Node ptr is NULL");
+		rc = -EINVAL;
+		goto end;
+	}
+
+	if (g_custom_dev.open_cnt == 0)
+		cam_node_shutdown(node);
+
+end:
+	mutex_unlock(&g_custom_dev.custom_dev_mutex);
+	return rc;
+}
+
+static const struct v4l2_subdev_internal_ops cam_custom_subdev_internal_ops = {
+	.close = cam_custom_subdev_close,
+	.open = cam_custom_subdev_open,
+};
+
+static int cam_custom_dev_remove(struct platform_device *pdev)
+{
+	int rc = 0;
+	int i;
+
+	/* clean up resources */
+	for (i = 0; i < CAM_CUSTOM_HW_MAX_INSTANCES; i++) {
+		rc = cam_custom_dev_context_deinit(&g_custom_dev.ctx_custom[i]);
+		if (rc)
+			CAM_ERR(CAM_CUSTOM,
+				"Custom context %d deinit failed", i);
+	}
+
+	rc = cam_subdev_remove(&g_custom_dev.sd);
+	if (rc)
+		CAM_ERR(CAM_CUSTOM, "Unregister failed");
+
+	memset(&g_custom_dev, 0, sizeof(g_custom_dev));
+	return 0;
+}
+
+static int cam_custom_dev_probe(struct platform_device *pdev)
+{
+	int rc = -EINVAL;
+	int i;
+	struct cam_hw_mgr_intf         hw_mgr_intf;
+	struct cam_node               *node;
+	int iommu_hdl = -1;
+
+	g_custom_dev.sd.internal_ops = &cam_custom_subdev_internal_ops;
+
+	rc = cam_subdev_probe(&g_custom_dev.sd, pdev, CAM_CUSTOM_DEV_NAME,
+		CAM_CUSTOM_DEVICE_TYPE);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "Custom device cam_subdev_probe failed!");
+		goto err;
+	}
+	node = (struct cam_node *) g_custom_dev.sd.token;
+
+	memset(&hw_mgr_intf, 0, sizeof(hw_mgr_intf));
+	rc = cam_custom_hw_mgr_init(pdev->dev.of_node,
+		&hw_mgr_intf, &iommu_hdl);
+	if (rc != 0) {
+		CAM_ERR(CAM_CUSTOM, "Can not initialized Custom HW manager!");
+		goto unregister;
+	}
+
+	for (i = 0; i < CAM_CUSTOM_HW_MAX_INSTANCES; i++) {
+		rc = cam_custom_dev_context_init(&g_custom_dev.ctx_custom[i],
+			&g_custom_dev.ctx[i],
+			&node->crm_node_intf,
+			&node->hw_mgr_intf,
+			i);
+		if (rc) {
+			CAM_ERR(CAM_CUSTOM, "Custom context init failed!");
+			goto unregister;
+		}
+	}
+
+	rc = cam_node_init(node, &hw_mgr_intf, g_custom_dev.ctx,
+		CAM_CUSTOM_HW_MAX_INSTANCES, CAM_CUSTOM_DEV_NAME);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "Custom HW node init failed!");
+		goto unregister;
+	}
+
+	cam_smmu_set_client_page_fault_handler(iommu_hdl,
+		cam_custom_dev_iommu_fault_handler, node);
+
+	mutex_init(&g_custom_dev.custom_dev_mutex);
+
+	CAM_DBG(CAM_CUSTOM, "Camera custom HW probe complete");
+
+	return 0;
+unregister:
+	rc = cam_subdev_remove(&g_custom_dev.sd);
+err:
+	return rc;
+}
+
+
+static struct platform_driver custom_driver = {
+	.probe = cam_custom_dev_probe,
+	.remove = cam_custom_dev_remove,
+	.driver = {
+		.name = "cam_custom",
+		.of_match_table = cam_custom_dt_match,
+		.suppress_bind_attrs = true,
+	},
+};
+
+static int __init cam_custom_dev_init_module(void)
+{
+	return platform_driver_register(&custom_driver);
+}
+
+static void __exit cam_custom_dev_exit_module(void)
+{
+	platform_driver_unregister(&custom_driver);
+}
+
+module_init(cam_custom_dev_init_module);
+module_exit(cam_custom_dev_exit_module);
+MODULE_DESCRIPTION("MSM CUSTOM driver");
+MODULE_LICENSE("GPL v2");

drivers/cam_cust/cam_custom_dev.h

@@ -0,0 +1,34 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_CUSTOM_DEV_H_
+#define _CAM_CUSTOM_DEV_H_
+
+#include "cam_subdev.h"
+#include "cam_hw_mgr_intf.h"
+#include "cam_custom_hw_mgr.h"
+#include "cam_context.h"
+#include "cam_custom_context.h"
+
+#define CAM_CUSTOM_HW_MAX_INSTANCES 3
+
+/**
+ * struct cam_custom_dev - Camera Custom V4l2 device node
+ *
+ * @sd:                    Common camera subdevice node
+ * @ctx:                   Custom base context storage
+ * @ctx_custom:            Custom private context storage
+ * @custom_dev_mutex:      Custom dev mutex
+ * @open_cnt:              Open device count
+ */
+struct cam_custom_dev {
+	struct cam_subdev          sd;
+	struct cam_context         ctx[CAM_CUSTOM_HW_MAX_INSTANCES];
+	struct cam_custom_context  ctx_custom[CAM_CUSTOM_HW_MAX_INSTANCES];
+	struct mutex               custom_dev_mutex;
+	int32_t                    open_cnt;
+};
+
+#endif /* _CAM_CUSTOM_DEV_H_ */

drivers/cam_cust/cam_custom_hw_mgr/Makefile

@@ -0,0 +1,20 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_req_mgr
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_utils
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_core
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_smmu/
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/hw_utils/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/hw_utils/irq_controller
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/isp_hw/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_sync
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cpas/include
+
+obj-$(CONFIG_SPECTRA_CAMERA) += cam_custom_hw1/
+obj-$(CONFIG_SPECTRA_CAMERA) += cam_custom_hw1/ cam_custom_csid/
+obj-$(CONFIG_SPECTRA_CAMERA) += cam_custom_hw_mgr.o
+

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_csid/Makefile

@@ -0,0 +1,16 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_utils
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_core
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cpas/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/hw_utils/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/hw_utils/irq_controller
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/isp_hw/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_isp/isp_hw_mgr/isp_hw/ife_csid_hw
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_smmu/
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_req_mgr/
+
+obj-$(CONFIG_SPECTRA_CAMERA) += cam_custom_csid_dev.o

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_csid/cam_custom_csid480.h

@@ -0,0 +1,272 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_CUSTOM_CSID_480_H_
+#define _CAM_CUSTOM_CSID_480_H_
+
+#include "cam_ife_csid_core.h"
+
+#define CAM_CSID_VERSION_V480                 0x40080000
+
+static struct cam_ife_csid_udi_reg_offset
+	cam_custom_csid_480_udi_0_reg_offset = {
+	.csid_udi_irq_status_addr                 = 0x30,
+	.csid_udi_irq_mask_addr                   = 0x34,
+	.csid_udi_irq_clear_addr                  = 0x38,
+	.csid_udi_irq_set_addr                    = 0x3c,
+	.csid_udi_cfg0_addr                       = 0x200,
+	.csid_udi_cfg1_addr                       = 0x204,
+	.csid_udi_ctrl_addr                       = 0x208,
+	.csid_udi_frm_drop_pattern_addr           = 0x20c,
+	.csid_udi_frm_drop_period_addr            = 0x210,
+	.csid_udi_irq_subsample_pattern_addr      = 0x214,
+	.csid_udi_irq_subsample_period_addr       = 0x218,
+	.csid_udi_rpp_hcrop_addr                  = 0x21c,
+	.csid_udi_rpp_vcrop_addr                  = 0x220,
+	.csid_udi_rpp_pix_drop_pattern_addr       = 0x224,
+	.csid_udi_rpp_pix_drop_period_addr        = 0x228,
+	.csid_udi_rpp_line_drop_pattern_addr      = 0x22c,
+	.csid_udi_rpp_line_drop_period_addr       = 0x230,
+	.csid_udi_rst_strobes_addr                = 0x240,
+	.csid_udi_status_addr                     = 0x250,
+	.csid_udi_misr_val0_addr                  = 0x254,
+	.csid_udi_misr_val1_addr                  = 0x258,
+	.csid_udi_misr_val2_addr                  = 0x25c,
+	.csid_udi_misr_val3_addr                  = 0x260,
+	.csid_udi_format_measure_cfg0_addr        = 0x270,
+	.csid_udi_format_measure_cfg1_addr        = 0x274,
+	.csid_udi_format_measure0_addr            = 0x278,
+	.csid_udi_format_measure1_addr            = 0x27c,
+	.csid_udi_format_measure2_addr            = 0x280,
+	.csid_udi_timestamp_curr0_sof_addr        = 0x290,
+	.csid_udi_timestamp_curr1_sof_addr        = 0x294,
+	.csid_udi_timestamp_prev0_sof_addr        = 0x298,
+	.csid_udi_timestamp_prev1_sof_addr        = 0x29c,
+	.csid_udi_timestamp_curr0_eof_addr        = 0x2a0,
+	.csid_udi_timestamp_curr1_eof_addr        = 0x2a4,
+	.csid_udi_timestamp_prev0_eof_addr        = 0x2a8,
+	.csid_udi_timestamp_prev1_eof_addr        = 0x2ac,
+	.csid_udi_err_recovery_cfg0_addr          = 0x2b0,
+	.csid_udi_err_recovery_cfg1_addr          = 0x2b4,
+	.csid_udi_err_recovery_cfg2_addr          = 0x2b8,
+	.csid_udi_multi_vcdt_cfg0_addr            = 0x2bc,
+	.csid_udi_byte_cntr_ping_addr             = 0x2e0,
+	.csid_udi_byte_cntr_pong_addr             = 0x2e4,
+	/* configurations */
+	.ccif_violation_en                        = 1,
+	.overflow_ctrl_en                         = 1,
+};
+
+static struct cam_ife_csid_udi_reg_offset
+	cam_custom_csid_480_udi_1_reg_offset = {
+	.csid_udi_irq_status_addr                 = 0x40,
+	.csid_udi_irq_mask_addr                   = 0x44,
+	.csid_udi_irq_clear_addr                  = 0x48,
+	.csid_udi_irq_set_addr                    = 0x4c,
+	.csid_udi_cfg0_addr                       = 0x300,
+	.csid_udi_cfg1_addr                       = 0x304,
+	.csid_udi_ctrl_addr                       = 0x308,
+	.csid_udi_frm_drop_pattern_addr           = 0x30c,
+	.csid_udi_frm_drop_period_addr            = 0x310,
+	.csid_udi_irq_subsample_pattern_addr      = 0x314,
+	.csid_udi_irq_subsample_period_addr       = 0x318,
+	.csid_udi_rpp_hcrop_addr                  = 0x31c,
+	.csid_udi_rpp_vcrop_addr                  = 0x320,
+	.csid_udi_rpp_pix_drop_pattern_addr       = 0x324,
+	.csid_udi_rpp_pix_drop_period_addr        = 0x328,
+	.csid_udi_rpp_line_drop_pattern_addr      = 0x32c,
+	.csid_udi_rpp_line_drop_period_addr       = 0x330,
+	.csid_udi_rst_strobes_addr                = 0x340,
+	.csid_udi_status_addr                     = 0x350,
+	.csid_udi_misr_val0_addr                  = 0x354,
+	.csid_udi_misr_val1_addr                  = 0x358,
+	.csid_udi_misr_val2_addr                  = 0x35c,
+	.csid_udi_misr_val3_addr                  = 0x360,
+	.csid_udi_format_measure_cfg0_addr        = 0x370,
+	.csid_udi_format_measure_cfg1_addr        = 0x374,
+	.csid_udi_format_measure0_addr            = 0x378,
+	.csid_udi_format_measure1_addr            = 0x37c,
+	.csid_udi_format_measure2_addr            = 0x380,
+	.csid_udi_timestamp_curr0_sof_addr        = 0x390,
+	.csid_udi_timestamp_curr1_sof_addr        = 0x394,
+	.csid_udi_timestamp_prev0_sof_addr        = 0x398,
+	.csid_udi_timestamp_prev1_sof_addr        = 0x39c,
+	.csid_udi_timestamp_curr0_eof_addr        = 0x3a0,
+	.csid_udi_timestamp_curr1_eof_addr        = 0x3a4,
+	.csid_udi_timestamp_prev0_eof_addr        = 0x3a8,
+	.csid_udi_timestamp_prev1_eof_addr        = 0x3ac,
+	.csid_udi_err_recovery_cfg0_addr          = 0x3b0,
+	.csid_udi_err_recovery_cfg1_addr          = 0x3b4,
+	.csid_udi_err_recovery_cfg2_addr          = 0x3b8,
+	.csid_udi_multi_vcdt_cfg0_addr            = 0x3bc,
+	.csid_udi_byte_cntr_ping_addr             = 0x3e0,
+	.csid_udi_byte_cntr_pong_addr             = 0x3e4,
+	/* configurations */
+	.ccif_violation_en                        = 1,
+	.overflow_ctrl_en                         = 1,
+};
+
+static struct cam_ife_csid_udi_reg_offset
+	cam_custom_csid_480_udi_2_reg_offset = {
+	.csid_udi_irq_status_addr                 = 0x50,
+	.csid_udi_irq_mask_addr                   = 0x54,
+	.csid_udi_irq_clear_addr                  = 0x58,
+	.csid_udi_irq_set_addr                    = 0x5c,
+	.csid_udi_cfg0_addr                       = 0x400,
+	.csid_udi_cfg1_addr                       = 0x404,
+	.csid_udi_ctrl_addr                       = 0x408,
+	.csid_udi_frm_drop_pattern_addr           = 0x40c,
+	.csid_udi_frm_drop_period_addr            = 0x410,
+	.csid_udi_irq_subsample_pattern_addr      = 0x414,
+	.csid_udi_irq_subsample_period_addr       = 0x418,
+	.csid_udi_rpp_hcrop_addr                  = 0x41c,
+	.csid_udi_rpp_vcrop_addr                  = 0x420,
+	.csid_udi_rpp_pix_drop_pattern_addr       = 0x424,
+	.csid_udi_rpp_pix_drop_period_addr        = 0x428,
+	.csid_udi_rpp_line_drop_pattern_addr      = 0x42c,
+	.csid_udi_rpp_line_drop_period_addr       = 0x430,
+	.csid_udi_yuv_chroma_conversion_addr      = 0x434,
+	.csid_udi_rst_strobes_addr                = 0x440,
+	.csid_udi_status_addr                     = 0x450,
+	.csid_udi_misr_val0_addr                  = 0x454,
+	.csid_udi_misr_val1_addr                  = 0x458,
+	.csid_udi_misr_val2_addr                  = 0x45c,
+	.csid_udi_misr_val3_addr                  = 0x460,
+	.csid_udi_format_measure_cfg0_addr        = 0x470,
+	.csid_udi_format_measure_cfg1_addr        = 0x474,
+	.csid_udi_format_measure0_addr            = 0x478,
+	.csid_udi_format_measure1_addr            = 0x47c,
+	.csid_udi_format_measure2_addr            = 0x480,
+	.csid_udi_timestamp_curr0_sof_addr        = 0x490,
+	.csid_udi_timestamp_curr1_sof_addr        = 0x494,
+	.csid_udi_timestamp_prev0_sof_addr        = 0x498,
+	.csid_udi_timestamp_prev1_sof_addr        = 0x49c,
+	.csid_udi_timestamp_curr0_eof_addr        = 0x4a0,
+	.csid_udi_timestamp_curr1_eof_addr        = 0x4a4,
+	.csid_udi_timestamp_prev0_eof_addr        = 0x4a8,
+	.csid_udi_timestamp_prev1_eof_addr        = 0x4ac,
+	.csid_udi_err_recovery_cfg0_addr          = 0x4b0,
+	.csid_udi_err_recovery_cfg1_addr          = 0x4b4,
+	.csid_udi_err_recovery_cfg2_addr          = 0x4b8,
+	.csid_udi_multi_vcdt_cfg0_addr            = 0x4bc,
+	.csid_udi_byte_cntr_ping_addr             = 0x4e0,
+	.csid_udi_byte_cntr_pong_addr             = 0x4e4,
+	/* configurations */
+	.ccif_violation_en                        = 1,
+	.overflow_ctrl_en                         = 1,
+};
+
+static struct cam_ife_csid_csi2_rx_reg_offset
+			cam_custom_csid_480_csi2_reg_offset = {
+	.csid_csi2_rx_irq_status_addr                 = 0x20,
+	.csid_csi2_rx_irq_mask_addr                   = 0x24,
+	.csid_csi2_rx_irq_clear_addr                  = 0x28,
+	.csid_csi2_rx_irq_set_addr                    = 0x2c,
+
+	/*CSI2 rx control */
+	.csid_csi2_rx_cfg0_addr                       = 0x100,
+	.csid_csi2_rx_cfg1_addr                       = 0x104,
+	.csid_csi2_rx_capture_ctrl_addr               = 0x108,
+	.csid_csi2_rx_rst_strobes_addr                = 0x110,
+	.csid_csi2_rx_de_scramble_cfg0_addr           = 0x114,
+	.csid_csi2_rx_de_scramble_cfg1_addr           = 0x118,
+	.csid_csi2_rx_cap_unmap_long_pkt_hdr_0_addr   = 0x120,
+	.csid_csi2_rx_cap_unmap_long_pkt_hdr_1_addr   = 0x124,
+	.csid_csi2_rx_captured_short_pkt_0_addr       = 0x128,
+	.csid_csi2_rx_captured_short_pkt_1_addr       = 0x12c,
+	.csid_csi2_rx_captured_long_pkt_0_addr        = 0x130,
+	.csid_csi2_rx_captured_long_pkt_1_addr        = 0x134,
+	.csid_csi2_rx_captured_long_pkt_ftr_addr      = 0x138,
+	.csid_csi2_rx_captured_cphy_pkt_hdr_addr      = 0x13c,
+	.csid_csi2_rx_lane0_misr_addr                 = 0x150,
+	.csid_csi2_rx_lane1_misr_addr                 = 0x154,
+	.csid_csi2_rx_lane2_misr_addr                 = 0x158,
+	.csid_csi2_rx_lane3_misr_addr                 = 0x15c,
+	.csid_csi2_rx_total_pkts_rcvd_addr            = 0x160,
+	.csid_csi2_rx_stats_ecc_addr                  = 0x164,
+	.csid_csi2_rx_total_crc_err_addr              = 0x168,
+
+	.csi2_rst_srb_all                             = 0x3FFF,
+	.csi2_rst_done_shift_val                      = 27,
+	.csi2_irq_mask_all                            = 0xFFFFFFF,
+	.csi2_misr_enable_shift_val                   = 6,
+	.csi2_vc_mode_shift_val                       = 2,
+	.csi2_capture_long_pkt_en_shift               = 0,
+	.csi2_capture_short_pkt_en_shift              = 1,
+	.csi2_capture_cphy_pkt_en_shift               = 2,
+	.csi2_capture_long_pkt_dt_shift               = 4,
+	.csi2_capture_long_pkt_vc_shift               = 10,
+	.csi2_capture_short_pkt_vc_shift              = 15,
+	.csi2_capture_cphy_pkt_dt_shift               = 20,
+	.csi2_capture_cphy_pkt_vc_shift               = 26,
+	.csi2_rx_phy_num_mask                         = 0x3,
+};
+
+static struct cam_ife_csid_common_reg_offset
+			cam_custom_csid_480_cmn_reg_offset = {
+	.csid_hw_version_addr                         = 0x0,
+	.csid_cfg0_addr                               = 0x4,
+	.csid_ctrl_addr                               = 0x8,
+	.csid_reset_addr                              = 0xc,
+	.csid_rst_strobes_addr                        = 0x10,
+
+	.csid_test_bus_ctrl_addr                      = 0x14,
+	.csid_top_irq_status_addr                     = 0x70,
+	.csid_top_irq_mask_addr                       = 0x74,
+	.csid_top_irq_clear_addr                      = 0x78,
+	.csid_top_irq_set_addr                        = 0x7c,
+	.csid_irq_cmd_addr                            = 0x80,
+
+	/*configurations */
+	.major_version                                = 1,
+	.minor_version                                = 7,
+	.version_incr                                 = 0,
+	.num_udis                                     = 3,
+	.num_rdis                                     = 0,
+	.num_pix                                      = 0,
+	.num_ppp                                      = 0,
+	.csid_reg_rst_stb                             = 1,
+	.csid_rst_stb                                 = 0x1e,
+	.csid_rst_stb_sw_all                          = 0x1f,
+	.path_rst_stb_all                             = 0x7f,
+	.path_rst_done_shift_val                      = 1,
+	.path_en_shift_val                            = 31,
+	.dt_id_shift_val                              = 27,
+	.vc_shift_val                                 = 22,
+	.dt_shift_val                                 = 16,
+	.fmt_shift_val                                = 12,
+	.plain_fmt_shit_val                           = 10,
+	.crop_v_en_shift_val                          = 6,
+	.crop_h_en_shift_val                          = 5,
+	.crop_shift                                   = 16,
+	.ipp_irq_mask_all                             = 0,
+	.rdi_irq_mask_all                             = 0,
+	.ppp_irq_mask_all                             = 0,
+	.udi_irq_mask_all                             = 0x7FFF,
+	.measure_en_hbi_vbi_cnt_mask                  = 0xC,
+	.format_measure_en_val                        = 1,
+	.num_bytes_out_shift_val                      = 3,
+};
+
+static struct cam_ife_csid_reg_offset cam_custom_csid_480_reg_offset = {
+	.cmn_reg          = &cam_custom_csid_480_cmn_reg_offset,
+	.csi2_reg         = &cam_custom_csid_480_csi2_reg_offset,
+	.ipp_reg          = NULL,
+	.ppp_reg          = NULL,
+	.rdi_reg = {
+		NULL,
+		NULL,
+		NULL,
+		NULL,
+	},
+	.udi_reg = {
+		&cam_custom_csid_480_udi_0_reg_offset,
+		&cam_custom_csid_480_udi_1_reg_offset,
+		&cam_custom_csid_480_udi_2_reg_offset,
+	},
+	.tpg_reg = NULL,
+};
+
+#endif /*_CAM_IFE_CSID_480_H_ */

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_csid/cam_custom_csid_dev.c

@@ -0,0 +1,190 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/slab.h>
+#include <linux/mod_devicetable.h>
+#include <linux/of.h>
+#include <linux/of_device.h>
+#include "linux/module.h"
+#include "cam_custom_csid_dev.h"
+#include "cam_ife_csid_core.h"
+#include "cam_hw.h"
+#include "cam_hw_intf.h"
+#include "cam_custom_csid480.h"
+#include "cam_debug_util.h"
+
+#define CAM_CUSTOM_CSID_DRV_NAME  "custom_csid"
+
+static struct cam_hw_intf *cam_custom_csid_hw_list[CAM_IFE_CSID_HW_NUM_MAX] = {
+	0, 0, 0, 0};
+
+static char csid_dev_name[16];
+
+static struct cam_ife_csid_hw_info cam_custom_csid480_hw_info = {
+	.csid_reg = &cam_custom_csid_480_reg_offset,
+	.hw_dts_version = CAM_CSID_VERSION_V480,
+};
+
+static int cam_custom_csid_probe(struct platform_device *pdev)
+{
+
+	struct cam_hw_intf             *csid_hw_intf;
+	struct cam_hw_info             *csid_hw_info;
+	struct cam_ife_csid_hw         *csid_dev = NULL;
+	const struct of_device_id      *match_dev = NULL;
+	struct cam_ife_csid_hw_info    *csid_hw_data = NULL;
+	uint32_t                        csid_dev_idx;
+	int                             rc = 0;
+
+	csid_hw_intf = kzalloc(sizeof(*csid_hw_intf), GFP_KERNEL);
+	if (!csid_hw_intf) {
+		rc = -ENOMEM;
+		goto err;
+	}
+
+	csid_hw_info = kzalloc(sizeof(struct cam_hw_info), GFP_KERNEL);
+	if (!csid_hw_info) {
+		rc = -ENOMEM;
+		goto free_hw_intf;
+	}
+
+	csid_dev = kzalloc(sizeof(struct cam_ife_csid_hw), GFP_KERNEL);
+	if (!csid_dev) {
+		rc = -ENOMEM;
+		goto free_hw_info;
+	}
+
+	/* get custom csid hw index */
+	of_property_read_u32(pdev->dev.of_node, "cell-index", &csid_dev_idx);
+	/* get custom csid hw information */
+	match_dev = of_match_device(pdev->dev.driver->of_match_table,
+		&pdev->dev);
+	if (!match_dev) {
+		CAM_ERR(CAM_CUSTOM,
+			"No matching table for the CUSTOM CSID HW!");
+		rc = -EINVAL;
+		goto free_dev;
+	}
+
+	memset(csid_dev_name, 0, sizeof(csid_dev_name));
+	snprintf(csid_dev_name, sizeof(csid_dev_name),
+		"csid-custom%1u", csid_dev_idx);
+
+	csid_hw_intf->hw_idx = csid_dev_idx;
+	csid_hw_intf->hw_type = CAM_ISP_HW_TYPE_IFE_CSID;
+	csid_hw_intf->hw_priv = csid_hw_info;
+
+	csid_hw_info->core_info = csid_dev;
+	csid_hw_info->soc_info.pdev = pdev;
+	csid_hw_info->soc_info.dev = &pdev->dev;
+	csid_hw_info->soc_info.dev_name = csid_dev_name;
+	csid_hw_info->soc_info.index = csid_dev_idx;
+
+	csid_hw_data = (struct cam_ife_csid_hw_info  *)match_dev->data;
+	csid_dev->csid_info = csid_hw_data;
+
+	rc = cam_ife_csid_hw_probe_init(csid_hw_intf, csid_dev_idx, true);
+	if (rc)
+		goto free_dev;
+
+	platform_set_drvdata(pdev, csid_dev);
+	CAM_DBG(CAM_CUSTOM, "CSID:%d probe successful for dev %s",
+		csid_hw_intf->hw_idx, csid_dev_name);
+
+	if (csid_hw_intf->hw_idx < CAM_IFE_CSID_HW_NUM_MAX)
+		cam_custom_csid_hw_list[csid_hw_intf->hw_idx] = csid_hw_intf;
+	else
+		goto free_dev;
+
+	return 0;
+
+free_dev:
+	kfree(csid_dev);
+free_hw_info:
+	kfree(csid_hw_info);
+free_hw_intf:
+	kfree(csid_hw_intf);
+err:
+	return rc;
+}
+
+static int cam_custom_csid_remove(struct platform_device *pdev)
+{
+	struct cam_ife_csid_hw         *csid_dev = NULL;
+	struct cam_hw_intf             *csid_hw_intf;
+	struct cam_hw_info             *csid_hw_info;
+
+	csid_dev = (struct cam_ife_csid_hw *)platform_get_drvdata(pdev);
+	csid_hw_intf = csid_dev->hw_intf;
+	csid_hw_info = csid_dev->hw_info;
+
+	CAM_DBG(CAM_CUSTOM, "CSID:%d remove",
+		csid_dev->hw_intf->hw_idx);
+
+	cam_ife_csid_hw_deinit(csid_dev);
+
+	/*release the csid device memory */
+	kfree(csid_dev);
+	kfree(csid_hw_info);
+	kfree(csid_hw_intf);
+	return 0;
+}
+
+static const struct of_device_id cam_custom_csid_dt_match[] = {
+	{
+		.compatible = "qcom,csid-custom480",
+		.data = &cam_custom_csid480_hw_info
+	},
+	{}
+};
+
+MODULE_DEVICE_TABLE(of, cam_custom_csid_dt_match);
+
+static struct platform_driver cam_custom_csid_driver = {
+	.probe = cam_custom_csid_probe,
+	.driver = {
+		.name = "qcom,custom-csid",
+		.of_match_table = cam_custom_csid_dt_match,
+		.suppress_bind_attrs = true,
+	},
+	.remove = cam_custom_csid_remove,
+};
+
+static int __init cam_custom_csid_driver_init(void)
+{
+	int32_t rc = 0;
+
+	rc = platform_driver_register(&cam_custom_csid_driver);
+	if (rc < 0)
+		CAM_ERR(CAM_CUSTOM, "platform_driver_register Failed: rc = %d",
+			rc);
+
+	return rc;
+}
+
+int cam_custom_csid_hw_init(struct cam_hw_intf **custom_csid_hw,
+	uint32_t hw_idx)
+{
+	int rc = 0;
+
+	if (cam_custom_csid_hw_list[hw_idx]) {
+		*custom_csid_hw = cam_custom_csid_hw_list[hw_idx];
+	} else {
+		*custom_csid_hw = NULL;
+		rc = -1;
+	}
+
+	return rc;
+}
+
+static void __exit cam_custom_csid_driver_exit(void)
+{
+	platform_driver_unregister(&cam_custom_csid_driver);
+}
+
+module_init(cam_custom_csid_driver_init);
+module_exit(cam_custom_csid_driver_exit);
+MODULE_DESCRIPTION("cam_custom_csid_driver");
+MODULE_LICENSE("GPL v2");

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_csid/cam_custom_csid_dev.h

@@ -0,0 +1,12 @@
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_IFE_CSID_DEV_H_
+#define _CAM_IFE_CSID_DEV_H_
+
+#include "cam_debug_util.h"
+#include "cam_custom_hw_mgr_intf.h"
+
+#endif /*_CAM_IFE_CSID_DEV_H_ */

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/Makefile

@@ -0,0 +1,10 @@
+# SPDX-License-Identifier: GPL-2.0-only
+
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_utils
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_core
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cpas/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/include
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/
+ccflags-y += -I$(srctree)/techpack/camera/drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1
+
+obj-$(CONFIG_SPECTRA_CAMERA) += cam_custom_sub_mod_soc.o cam_custom_sub_mod_dev.o cam_custom_sub_mod_core.o

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/cam_custom_sub_mod_core.c

@@ -0,0 +1,337 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/list.h>
+#include <linux/timer.h>
+#include <linux/ratelimit.h>
+#include "cam_custom_sub_mod_core.h"
+
+int cam_custom_hw_sub_mod_get_hw_caps(void *hw_priv,
+	void *get_hw_cap_args, uint32_t arg_size)
+{
+	int rc = 0;
+
+	if (!hw_priv) {
+		CAM_ERR(CAM_CUSTOM, "Invalid arguments");
+		return -EINVAL;
+	}
+	/* Add HW Capabilities to be published */
+	return rc;
+}
+
+int cam_custom_hw_sub_mod_init_hw(void *hw_priv,
+	void *init_hw_args, uint32_t arg_size)
+{
+	struct cam_hw_info                *custom_hw = hw_priv;
+	struct cam_hw_soc_info            *soc_info = NULL;
+	struct cam_custom_resource_node   *custom_res = NULL;
+	int rc = 0;
+
+	if (!hw_priv) {
+		CAM_ERR(CAM_CUSTOM, "Invalid arguments");
+		return -EINVAL;
+	}
+
+	mutex_lock(&custom_hw->hw_mutex);
+	custom_hw->open_count++;
+	if (custom_hw->open_count > 1) {
+		mutex_unlock(&custom_hw->hw_mutex);
+		CAM_DBG(CAM_CUSTOM,
+			"Cam Custom has already been initialized cnt %d",
+			custom_hw->open_count);
+		return 0;
+	}
+	mutex_unlock(&custom_hw->hw_mutex);
+
+	soc_info = &custom_hw->soc_info;
+
+	/* Turn ON Regulators, Clocks and other SOC resources */
+	rc = cam_custom_hw_sub_mod_enable_soc_resources(soc_info);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "Enable SOC failed");
+		rc = -EFAULT;
+		goto decrement_open_cnt;
+	}
+
+	custom_res   = (struct cam_custom_resource_node *)init_hw_args;
+	if (custom_res && custom_res->init) {
+		rc = custom_res->init(custom_res, NULL, 0);
+		if (rc) {
+			CAM_ERR(CAM_CUSTOM, "init Failed rc=%d", rc);
+			goto decrement_open_cnt;
+		}
+	}
+
+	rc = cam_custom_hw_sub_mod_reset(hw_priv, NULL, 0);
+	if (rc < 0) {
+		CAM_ERR(CAM_CUSTOM, "Custom HW reset failed : %d", rc);
+		goto decrement_open_cnt;
+	}
+	/* Initialize all resources here */
+	custom_hw->hw_state = CAM_HW_STATE_POWER_UP;
+	return rc;
+
+decrement_open_cnt:
+	mutex_lock(&custom_hw->hw_mutex);
+	custom_hw->open_count--;
+	mutex_unlock(&custom_hw->hw_mutex);
+	return rc;
+}
+
+int cam_custom_hw_sub_mod_deinit_hw(void *hw_priv,
+	void *deinit_hw_args, uint32_t arg_size)
+{
+	struct cam_hw_info                *custom_hw = hw_priv;
+	struct cam_hw_soc_info            *soc_info = NULL;
+	struct cam_custom_resource_node   *custom_res = NULL;
+	int rc = 0;
+
+	if (!hw_priv) {
+		CAM_ERR(CAM_CUSTOM, "Invalid arguments");
+		return -EINVAL;
+	}
+
+	mutex_lock(&custom_hw->hw_mutex);
+	if (!custom_hw->open_count) {
+		mutex_unlock(&custom_hw->hw_mutex);
+		CAM_ERR(CAM_CUSTOM, "Error! Unbalanced deinit");
+		return -EFAULT;
+	}
+	custom_hw->open_count--;
+	if (custom_hw->open_count) {
+		mutex_unlock(&custom_hw->hw_mutex);
+		CAM_DBG(CAM_CUSTOM,
+			"open_cnt non-zero =%d", custom_hw->open_count);
+		return 0;
+	}
+	mutex_unlock(&custom_hw->hw_mutex);
+
+	soc_info = &custom_hw->soc_info;
+
+	custom_res   = (struct cam_custom_resource_node *)deinit_hw_args;
+	if (custom_res && custom_res->deinit) {
+		rc = custom_res->deinit(custom_res, NULL, 0);
+		if (rc)
+			CAM_ERR(CAM_CUSTOM, "deinit failed");
+	}
+
+	rc = cam_custom_hw_sub_mod_reset(hw_priv, NULL, 0);
+
+	/* Turn OFF Regulators, Clocks and other SOC resources */
+	CAM_DBG(CAM_CUSTOM, "Disable SOC resource");
+	rc = cam_custom_hw_sub_mod_disable_soc_resources(soc_info);
+	if (rc)
+		CAM_ERR(CAM_CUSTOM, "Disable SOC failed");
+
+	custom_hw->hw_state = CAM_HW_STATE_POWER_DOWN;
+
+	return rc;
+}
+
+int cam_custom_hw_sub_mod_reset(void *hw_priv,
+	void *reserve_args, uint32_t arg_size)
+{
+	struct cam_hw_info                *custom_hw  = hw_priv;
+	struct cam_hw_soc_info            *soc_info = NULL;
+	int rc = 0;
+
+	if (!hw_priv) {
+		CAM_ERR(CAM_CUSTOM, "Invalid input arguments");
+		return -EINVAL;
+	}
+
+	soc_info = &custom_hw->soc_info;
+	/* Do Reset of HW */
+	return rc;
+}
+
+int cam_custom_hw_sub_mod_reserve(void *hw_priv,
+	void *reserve_args, uint32_t arg_size)
+{
+	int rc = 0;
+
+	if (!hw_priv || !reserve_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid input arguments");
+		return -EINVAL;
+	}
+
+	/*Reserve Args */
+	return rc;
+}
+
+
+int cam_custom_hw_sub_mod_release(void *hw_priv,
+	void *release_args, uint32_t arg_size)
+{
+	struct cam_hw_info                *custom_hw  = hw_priv;
+	int rc = 0;
+
+	if (!hw_priv || !release_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid input arguments");
+		return -EINVAL;
+	}
+
+	mutex_lock(&custom_hw->hw_mutex);
+	/* Release Resources */
+	mutex_unlock(&custom_hw->hw_mutex);
+
+	return rc;
+}
+
+
+int cam_custom_hw_sub_mod_start(void *hw_priv,
+	void *start_args, uint32_t arg_size)
+{
+	struct cam_hw_info                *custom_hw  = hw_priv;
+	int rc = 0;
+
+	if (!hw_priv || !start_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid input arguments");
+		return -EINVAL;
+	}
+
+	mutex_lock(&custom_hw->hw_mutex);
+	/* Start HW -- Stream On*/
+	mutex_unlock(&custom_hw->hw_mutex);
+
+	return rc;
+}
+
+int cam_custom_hw_sub_mod_stop(void *hw_priv,
+	void *stop_args, uint32_t arg_size)
+{
+	struct cam_hw_info                *custom_hw  = hw_priv;
+	int rc = 0;
+
+	if (!hw_priv || !stop_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid input arguments");
+		return -EINVAL;
+	}
+
+	mutex_lock(&custom_hw->hw_mutex);
+	/* Stop HW */
+	mutex_unlock(&custom_hw->hw_mutex);
+
+	return rc;
+}
+
+int cam_custom_hw_sub_mod_read(void *hw_priv,
+	void *read_args, uint32_t arg_size)
+{
+	return -EPERM;
+}
+
+int cam_custom_hw_sub_mod_write(void *hw_priv,
+	void *write_args, uint32_t arg_size)
+{
+	return -EPERM;
+}
+
+int cam_custom_hw_submit_req(void *hw_priv, void *hw_submit_args,
+	uint32_t arg_size)
+{
+	struct cam_hw_info			         *custom_dev = hw_priv;
+	struct cam_custom_sub_mod_req_to_dev *submit_req =
+		(struct cam_custom_sub_mod_req_to_dev *)hw_submit_args;
+	struct cam_custom_sub_mod_core_info  *core_info = NULL;
+
+	core_info =
+		(struct cam_custom_sub_mod_core_info *)custom_dev->core_info;
+
+	spin_lock(&custom_dev->hw_lock);
+	if (core_info->curr_req) {
+		CAM_WARN(CAM_CUSTOM, "Req %lld still processed by %s",
+			core_info->curr_req->req_id,
+			custom_dev->soc_info.dev_name);
+		spin_unlock(&custom_dev->hw_lock);
+		return -EAGAIN;
+	}
+
+	core_info->curr_req = submit_req;
+	spin_unlock(&custom_dev->hw_lock);
+
+	/* Do other submit procedures */
+	return 0;
+}
+
+irqreturn_t cam_custom_hw_sub_mod_irq(int irq_num, void *data)
+{
+	struct cam_hw_info *custom_dev = data;
+	struct cam_hw_soc_info *soc_info = NULL;
+	struct cam_custom_hw_cb_args cb_args;
+	struct cam_custom_sub_mod_core_info *core_info = NULL;
+	uint32_t irq_status = 0;
+
+	if (!data) {
+		CAM_ERR(CAM_CUSTOM, "Invalid custom_dev_info");
+		return IRQ_HANDLED;
+	}
+
+	soc_info = &custom_dev->soc_info;
+	core_info =
+		(struct cam_custom_sub_mod_core_info *)custom_dev->core_info;
+
+	irq_status = cam_io_r_mb(soc_info->reg_map[0].mem_base +
+				core_info->device_hw_info->irq_status);
+
+	cam_io_w_mb(irq_status,
+			soc_info->reg_map[0].mem_base +
+			core_info->device_hw_info->irq_clear);
+
+	spin_lock(&custom_dev->hw_lock);
+	cb_args.irq_status = irq_status;
+	cb_args.req_info = core_info->curr_req;
+	core_info->curr_req = NULL;
+	if (core_info->irq_cb.custom_hw_mgr_cb)
+		core_info->irq_cb.custom_hw_mgr_cb(
+			core_info->irq_cb.data, &cb_args);
+	spin_unlock(&custom_dev->hw_lock);
+
+	return IRQ_HANDLED;
+}
+
+int cam_custom_hw_sub_mod_process_cmd(void *hw_priv, uint32_t cmd_type,
+	void *cmd_args, uint32_t arg_size)
+{
+	struct cam_hw_info                  *hw = hw_priv;
+	struct cam_hw_soc_info              *soc_info = NULL;
+	struct cam_custom_sub_mod_core_info *core_info = NULL;
+	unsigned long flag = 0;
+	int rc = 0;
+
+	if (!hw_priv || !cmd_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid arguments");
+		return -EINVAL;
+	}
+
+	soc_info = &hw->soc_info;
+	core_info = hw->core_info;
+	/* Handle any custom process cmds */
+
+	switch (cmd_type) {
+	case CAM_CUSTOM_SET_IRQ_CB: {
+		struct cam_custom_sub_mod_set_irq_cb *irq_cb = cmd_args;
+
+		CAM_DBG(CAM_CUSTOM, "Setting irq cb");
+		spin_lock_irqsave(&hw->hw_lock, flag);
+		core_info->irq_cb.custom_hw_mgr_cb = irq_cb->custom_hw_mgr_cb;
+		core_info->irq_cb.data = irq_cb->data;
+		spin_unlock_irqrestore(&hw->hw_lock, flag);
+		break;
+	}
+	case CAM_CUSTOM_SUBMIT_REQ: {
+		rc = cam_custom_hw_submit_req(hw_priv, cmd_args, arg_size);
+		break;
+	}
+	default:
+		break;
+	}
+
+	return rc;
+}
+
+

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/cam_custom_sub_mod_core.h

@@ -0,0 +1,79 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_CUSTOM_SUB_MOD_CORE_H_
+#define _CAM_CUSTOM_SUB_MOD_CORE_H_
+
+#include "cam_debug_util.h"
+#include "cam_custom_hw.h"
+#include "cam_custom_sub_mod_soc.h"
+#include "cam_custom_hw_mgr_intf.h"
+
+struct cam_custom_sub_mod_set_irq_cb {
+	int32_t (*custom_hw_mgr_cb)(void *data,
+		struct cam_custom_hw_cb_args *cb_args);
+	void *data;
+};
+
+struct cam_custom_sub_mod_req_to_dev {
+	uint64_t req_id;
+	uint32_t ctx_idx;
+	uint32_t dev_idx;
+};
+
+struct cam_custom_device_hw_info {
+	uint32_t hw_ver;
+	uint32_t irq_status;
+	uint32_t irq_mask;
+	uint32_t irq_clear;
+};
+
+struct cam_custom_sub_mod_core_info {
+	uint32_t cpas_handle;
+	bool cpas_start;
+	bool clk_enable;
+	struct cam_custom_sub_mod_set_irq_cb irq_cb;
+	struct cam_custom_sub_mod_req_to_dev *curr_req;
+	struct cam_custom_device_hw_info *device_hw_info;
+	struct cam_hw_info *custom_hw_info;
+};
+
+enum cam_custom_hw_resource_type {
+	CAM_CUSTOM_HW_RESOURCE_UNINT,
+	CAM_CUSTOM_HW_RESOURCE_SRC,
+	CAM_CUSTOM_HW_RESOURCE_MAX,
+};
+
+struct cam_custom_sub_mod_acq {
+	enum cam_custom_hw_resource_type   rsrc_type;
+	int32_t                            acq;
+	struct cam_custom_resource_node   *rsrc_node;
+};
+
+int cam_custom_hw_sub_mod_get_hw_caps(void *hw_priv,
+	void *get_hw_cap_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_init_hw(void *hw_priv,
+	void *init_hw_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_deinit_hw(void *hw_priv,
+	void *deinit_hw_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_reset(void *hw_priv,
+	void *deinit_hw_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_reserve(void *hw_priv,
+	void *reserve_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_release(void *hw_priv,
+	void *release_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_start(void *hw_priv,
+	void *start_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_stop(void *hw_priv,
+	void *stop_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_read(void *hw_priv,
+	void *read_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_write(void *hw_priv,
+	void *write_args, uint32_t arg_size);
+int cam_custom_hw_sub_mod_process_cmd(void *hw_priv, uint32_t cmd_type,
+	void *cmd_args, uint32_t arg_size);
+irqreturn_t cam_custom_hw_sub_mod_irq(int irq_num, void *data);
+
+#endif /* _CAM_CUSTOM_SUB_MOD_CORE_H_ */

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/cam_custom_sub_mod_dev.c

@@ -0,0 +1,162 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/slab.h>
+#include <linux/mod_devicetable.h>
+#include <linux/module.h>
+#include <linux/of_device.h>
+#include "cam_custom_sub_mod_dev.h"
+#include "cam_custom_sub_mod_core.h"
+#include "cam_custom_sub_mod_soc.h"
+#include "cam_debug_util.h"
+
+static struct cam_hw_intf *cam_custom_hw_sub_mod_list
+	[CAM_CUSTOM_SUB_MOD_MAX_INSTANCES] = {0, 0};
+
+static char cam_custom_hw_sub_mod_name[8];
+
+struct cam_custom_device_hw_info cam_custom_hw_info = {
+	.hw_ver = 0x0,
+	.irq_status = 0x0,
+	.irq_mask = 0x0,
+	.irq_clear = 0x0,
+};
+EXPORT_SYMBOL(cam_custom_hw_info);
+
+int cam_custom_hw_sub_mod_init(struct cam_hw_intf **custom_hw, uint32_t hw_idx)
+{
+	int rc = 0;
+
+	if (cam_custom_hw_sub_mod_list[hw_idx]) {
+		*custom_hw = cam_custom_hw_sub_mod_list[hw_idx];
+		rc = 0;
+	} else {
+		*custom_hw = NULL;
+		rc = -ENODEV;
+	}
+	return 0;
+}
+
+int cam_custom_hw_sub_mod_probe(struct platform_device *pdev)
+{
+	struct cam_hw_info                  *hw = NULL;
+	struct cam_hw_intf                  *hw_intf = NULL;
+	struct cam_custom_sub_mod_core_info *core_info = NULL;
+	int                                rc = 0;
+
+	hw_intf = kzalloc(sizeof(struct cam_hw_intf), GFP_KERNEL);
+	if (!hw_intf)
+		return -ENOMEM;
+
+	of_property_read_u32(pdev->dev.of_node,
+		"cell-index", &hw_intf->hw_idx);
+
+	hw = kzalloc(sizeof(struct cam_hw_info), GFP_KERNEL);
+	if (!hw) {
+		rc = -ENOMEM;
+		goto free_hw_intf;
+	}
+
+	memset(cam_custom_hw_sub_mod_name, 0,
+		sizeof(cam_custom_hw_sub_mod_name));
+	snprintf(cam_custom_hw_sub_mod_name, sizeof(cam_custom_hw_sub_mod_name),
+		"custom_hw%1u", hw_intf->hw_idx);
+
+	hw->soc_info.pdev = pdev;
+	hw->soc_info.dev = &pdev->dev;
+	hw->soc_info.dev_name = cam_custom_hw_sub_mod_name;
+	hw_intf->hw_priv = hw;
+	hw_intf->hw_ops.get_hw_caps = cam_custom_hw_sub_mod_get_hw_caps;
+	hw_intf->hw_ops.init = cam_custom_hw_sub_mod_init_hw;
+	hw_intf->hw_ops.deinit = cam_custom_hw_sub_mod_deinit_hw;
+	hw_intf->hw_ops.reset = cam_custom_hw_sub_mod_reset;
+	hw_intf->hw_ops.reserve = cam_custom_hw_sub_mod_reserve;
+	hw_intf->hw_ops.release = cam_custom_hw_sub_mod_release;
+	hw_intf->hw_ops.start = cam_custom_hw_sub_mod_start;
+	hw_intf->hw_ops.stop = cam_custom_hw_sub_mod_stop;
+	hw_intf->hw_ops.read = cam_custom_hw_sub_mod_read;
+	hw_intf->hw_ops.write = cam_custom_hw_sub_mod_write;
+	hw_intf->hw_ops.process_cmd = cam_custom_hw_sub_mod_process_cmd;
+	hw_intf->hw_type = CAM_CUSTOM_HW_TYPE_1;
+
+	platform_set_drvdata(pdev, hw_intf);
+
+	hw->core_info = kzalloc(sizeof(struct cam_custom_sub_mod_core_info),
+		GFP_KERNEL);
+	if (!hw->core_info) {
+		CAM_DBG(CAM_CUSTOM, "Failed to alloc for core");
+		rc = -ENOMEM;
+		goto free_hw;
+	}
+	core_info = (struct cam_custom_sub_mod_core_info *)hw->core_info;
+
+	core_info->custom_hw_info = hw;
+
+	rc = cam_custom_hw_sub_mod_init_soc_resources(&hw->soc_info,
+		cam_custom_hw_sub_mod_irq, hw);
+	if (rc < 0) {
+		CAM_ERR(CAM_CUSTOM, "Failed to init soc rc=%d", rc);
+		goto free_core_info;
+	}
+
+	/* Initialize HW */
+
+	hw->hw_state = CAM_HW_STATE_POWER_DOWN;
+	mutex_init(&hw->hw_mutex);
+	spin_lock_init(&hw->hw_lock);
+	init_completion(&hw->hw_complete);
+
+	if (hw_intf->hw_idx < CAM_CUSTOM_HW_SUB_MOD_MAX)
+		cam_custom_hw_sub_mod_list[hw_intf->hw_idx] = hw_intf;
+
+	/* needs to be invoked when custom hw is in place */
+	//cam_custom_hw_sub_mod_init_hw(hw, NULL, 0);
+
+	CAM_DBG(CAM_CUSTOM, "Custom hw_idx[%d] probe successful",
+		hw_intf->hw_idx);
+	return rc;
+
+free_core_info:
+	kfree(hw->core_info);
+free_hw:
+	kfree(hw);
+free_hw_intf:
+	kfree(hw_intf);
+	return rc;
+}
+
+static const struct of_device_id cam_custom_hw_sub_mod_dt_match[] = {
+	{
+		.compatible = "qcom,cam_custom_hw_sub_mod",
+		.data = &cam_custom_hw_info,
+	},
+	{}
+};
+
+MODULE_DEVICE_TABLE(of, cam_custom_hw_sub_mod_dt_match);
+
+static struct platform_driver cam_custom_hw_sub_mod_driver = {
+	.probe = cam_custom_hw_sub_mod_probe,
+	.driver = {
+		.name = CAM_CUSTOM_SUB_MOD_NAME,
+		.of_match_table = cam_custom_hw_sub_mod_dt_match,
+		.suppress_bind_attrs = true,
+	},
+};
+
+static int __init cam_custom_hw_sub_module_init(void)
+{
+	return platform_driver_register(&cam_custom_hw_sub_mod_driver);
+}
+
+static void __exit cam_custom_hw_sub_module_exit(void)
+{
+	platform_driver_unregister(&cam_custom_hw_sub_mod_driver);
+}
+
+module_init(cam_custom_hw_sub_module_init);
+module_exit(cam_custom_hw_sub_module_exit);
+MODULE_DESCRIPTION("CAM CUSTOM HW SUB MODULE driver");
+MODULE_LICENSE("GPL v2");

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/cam_custom_sub_mod_dev.h

@@ -0,0 +1,15 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_CUSTOM_SUB_MOD_DEV_H_
+#define _CAM_CUSTOM_SUB_MOD_DEV_H_
+
+#include "cam_custom_hw_mgr_intf.h"
+
+#define CAM_CUSTOM_SUB_MOD_NAME "cam_custom_sub_mod"
+
+#define CAM_CUSTOM_SUB_MOD_MAX_INSTANCES                   2
+
+#endif /* _CAM_CUSTOM_SUB_MOD_DEV_H_ */

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/cam_custom_sub_mod_soc.c

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/slab.h>
+#include "cam_cpas_api.h"
+#include "cam_custom_sub_mod_soc.h"
+#include "cam_debug_util.h"
+
+int cam_custom_hw_sub_mod_init_soc_resources(struct cam_hw_soc_info *soc_info,
+	irq_handler_t irq_handler, void *irq_data)
+{
+	int                               rc = 0;
+	struct cam_custom_hw_soc_private *soc_private = NULL;
+	struct cam_cpas_register_params   cpas_register_param;
+
+	rc = cam_soc_util_get_dt_properties(soc_info);
+	if (rc < 0) {
+		CAM_ERR(CAM_CUSTOM,
+			"Error! Get DT properties failed rc=%d", rc);
+		/* For Test Purposes */
+		return 0;
+	}
+
+	soc_private = kzalloc(sizeof(struct cam_custom_hw_soc_private),
+		GFP_KERNEL);
+	if (!soc_private) {
+		CAM_DBG(CAM_CUSTOM, "Error! soc_private Alloc Failed");
+		return -ENOMEM;
+	}
+	soc_info->soc_private = soc_private;
+
+	rc = cam_soc_util_request_platform_resource(soc_info, irq_handler,
+		irq_data);
+	if (rc < 0) {
+		CAM_ERR(CAM_CUSTOM,
+			"Error! Request platform resources failed rc=%d", rc);
+		return rc;
+	}
+
+	memset(&cpas_register_param, 0, sizeof(cpas_register_param));
+
+	cpas_register_param.cell_index = soc_info->index;
+	cpas_register_param.dev = soc_info->dev;
+	cpas_register_param.cam_cpas_client_cb = NULL;
+	cpas_register_param.userdata = soc_info;
+	soc_private->cpas_handle =
+		cpas_register_param.client_handle;
+
+	rc = cam_cpas_register_client(&cpas_register_param);
+	if (rc < 0)
+		goto release_soc;
+
+	return rc;
+
+release_soc:
+	cam_soc_util_release_platform_resource(soc_info);
+	return rc;
+}
+
+int cam_custom_hw_sub_mod_deinit_soc_resources(struct cam_hw_soc_info *soc_info)
+{
+	int                               rc = 0;
+	struct cam_custom_hw_soc_private *soc_private = NULL;
+
+	if (!soc_info) {
+		CAM_ERR(CAM_CUSTOM, "Error! soc_info NULL");
+		return -ENODEV;
+	}
+
+	soc_private = soc_info->soc_private;
+	if (!soc_private) {
+		CAM_ERR(CAM_CUSTOM, "Error! soc_private NULL");
+		return -ENODEV;
+	}
+	rc = cam_cpas_unregister_client(soc_private->cpas_handle);
+	if (rc)
+		CAM_ERR(CAM_CUSTOM, "CPAS0 unregistration failed rc=%d", rc);
+
+	rc = cam_soc_util_release_platform_resource(soc_info);
+	if (rc < 0)
+		CAM_ERR(CAM_CUSTOM,
+			"Error! Release platform resources failed rc=%d", rc);
+
+	kfree(soc_private);
+
+	return rc;
+}
+
+int cam_custom_hw_sub_mod_enable_soc_resources(struct cam_hw_soc_info *soc_info)
+{
+	int                               rc = 0;
+	struct cam_custom_hw_soc_private *soc_private = soc_info->soc_private;
+	struct cam_ahb_vote               ahb_vote;
+	struct cam_axi_vote axi_vote =    {0};
+
+	ahb_vote.type = CAM_VOTE_ABSOLUTE;
+	ahb_vote.vote.level = CAM_LOWSVS_VOTE;
+	axi_vote.num_paths = 2;
+	axi_vote.axi_path[0].path_data_type = CAM_AXI_PATH_DATA_ALL;
+	axi_vote.axi_path[0].transac_type = CAM_AXI_TRANSACTION_READ;
+	axi_vote.axi_path[0].camnoc_bw = 7200000;
+	axi_vote.axi_path[0].mnoc_ab_bw = 7200000;
+	axi_vote.axi_path[0].mnoc_ib_bw = 7200000;
+	axi_vote.axi_path[1].path_data_type = CAM_AXI_PATH_DATA_ALL;
+	axi_vote.axi_path[1].transac_type = CAM_AXI_TRANSACTION_WRITE;
+	axi_vote.axi_path[1].camnoc_bw = 512000000;
+	axi_vote.axi_path[1].mnoc_ab_bw = 512000000;
+	axi_vote.axi_path[1].mnoc_ib_bw = 512000000;
+
+	rc = cam_cpas_start(soc_private->cpas_handle, &ahb_vote, &axi_vote);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "Error! CPAS0 start failed rc=%d", rc);
+		rc = -EFAULT;
+		goto end;
+	}
+
+	rc = cam_soc_util_enable_platform_resource(soc_info, true,
+		CAM_TURBO_VOTE, true);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "Error! enable platform failed rc=%d", rc);
+		goto stop_cpas;
+	}
+
+	return 0;
+
+stop_cpas:
+	cam_cpas_stop(soc_private->cpas_handle);
+end:
+	return rc;
+}
+
+int cam_custom_hw_sub_mod_disable_soc_resources(
+	struct cam_hw_soc_info *soc_info)
+{
+	int rc = 0;
+	struct cam_custom_hw_soc_private       *soc_private;
+
+	if (!soc_info) {
+		CAM_ERR(CAM_CUSTOM, "Error! Invalid params");
+		rc = -EINVAL;
+		return rc;
+	}
+	soc_private = soc_info->soc_private;
+
+	rc = cam_soc_util_disable_platform_resource(soc_info, true, true);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "Disable platform failed rc=%d", rc);
+		return rc;
+	}
+
+	rc = cam_cpas_stop(soc_private->cpas_handle);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "Error! CPAS stop failed rc=%d", rc);
+		return rc;
+	}
+
+	return rc;
+}

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw1/cam_custom_sub_mod_soc.h

@@ -0,0 +1,35 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_CUSTOM_HW_SUB_MOD_SOC_H_
+#define _CAM_CUSTOM_HW_SUB_MOD_SOC_H_
+
+#include "cam_soc_util.h"
+/*
+ * struct cam_custom_hw_soc_private:
+ *
+ * @Brief:                   Private SOC data specific to Custom HW Driver
+ *
+ * @cpas_handle:             Handle returned on registering with CPAS driver.
+ *                           This handle is used for all further interface
+ *                           with CPAS.
+ */
+struct cam_custom_hw_soc_private {
+	uint32_t    cpas_handle;
+};
+
+int cam_custom_hw_sub_mod_init_soc_resources(struct cam_hw_soc_info *soc_info,
+	irq_handler_t irq_handler, void *irq_data);
+
+int cam_custom_hw_sub_mod_deinit_soc_resources(
+	struct cam_hw_soc_info *soc_info);
+
+int cam_custom_hw_sub_mod_enable_soc_resources(
+	struct cam_hw_soc_info *soc_info);
+
+int cam_custom_hw_sub_mod_disable_soc_resources(
+	struct cam_hw_soc_info *soc_info);
+
+#endif /* _CAM_CUSTOM_HW_SUB_MOD_SOC_H_ */

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw_mgr.c

@@ -0,0 +1,1329 @@
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/uaccess.h>
+#include <linux/debugfs.h>
+#include <soc/qcom/scm.h>
+#include <uapi/media/cam_custom.h>
+#include <media/cam_sync.h>
+#include "cam_sync_api.h"
+#include "cam_smmu_api.h"
+#include "cam_req_mgr_workq.h"
+#include "cam_custom_hw_mgr.h"
+#include "cam_packet_util.h"
+#include "cam_debug_util.h"
+#include "cam_cpas_api.h"
+#include "cam_mem_mgr_api.h"
+#include "cam_common_util.h"
+#include "cam_hw.h"
+
+static struct cam_custom_hw_mgr g_custom_hw_mgr;
+
+static int cam_custom_mgr_get_hw_caps(void *hw_mgr_priv,
+	void *hw_caps_args)
+{
+	int rc = 0;
+	struct cam_custom_hw_mgr          *hw_mgr = hw_mgr_priv;
+	struct cam_query_cap_cmd          *query = hw_caps_args;
+	struct cam_custom_query_cap_cmd    custom_hw_cap;
+	struct cam_hw_info                *cam_custom_hw;
+	struct cam_hw_soc_info            *soc_info_hw;
+
+	cam_custom_hw = (struct cam_hw_info *)
+		g_custom_hw_mgr.custom_hw[0]->hw_priv;
+	if (cam_custom_hw)
+		soc_info_hw = &cam_custom_hw->soc_info;
+
+	CAM_DBG(CAM_CUSTOM, "enter");
+
+	if (query->handle_type != CAM_HANDLE_USER_POINTER)
+		CAM_ERR(CAM_CUSTOM, "Wrong Args");
+
+	if (copy_from_user(&custom_hw_cap,
+		u64_to_user_ptr(query->caps_handle),
+		sizeof(struct cam_custom_query_cap_cmd))) {
+		rc = -EFAULT;
+		return rc;
+	}
+
+	custom_hw_cap.device_iommu.non_secure = hw_mgr->img_iommu_hdl;
+	custom_hw_cap.device_iommu.secure = -1;
+
+	/* Initializing cdm handles to -1 */
+	custom_hw_cap.cdm_iommu.non_secure = -1;
+	custom_hw_cap.cdm_iommu.secure = -1;
+
+	custom_hw_cap.num_dev = 1;
+	custom_hw_cap.dev_caps[0].hw_type = 0;
+	custom_hw_cap.dev_caps[0].hw_version = 0;
+
+	if (copy_to_user(u64_to_user_ptr(query->caps_handle),
+		&custom_hw_cap, sizeof(struct cam_custom_query_cap_cmd)))
+		rc = -EFAULT;
+
+	CAM_DBG(CAM_CUSTOM, "exit rc :%d", rc);
+	return rc;
+}
+
+enum cam_custom_hw_resource_state
+	cam_custom_hw_mgr_get_custom_res_state(
+	uint32_t						in_rsrc_state)
+{
+	enum cam_custom_hw_resource_state     rsrc_state;
+
+	CAM_DBG(CAM_CUSTOM, "rsrc_state %x", in_rsrc_state);
+
+	switch (in_rsrc_state) {
+	case CAM_ISP_RESOURCE_STATE_UNAVAILABLE:
+		rsrc_state = CAM_CUSTOM_HW_RESOURCE_STATE_UNAVAILABLE;
+		break;
+	case CAM_ISP_RESOURCE_STATE_AVAILABLE:
+		rsrc_state = CAM_CUSTOM_HW_RESOURCE_STATE_AVAILABLE;
+		break;
+	case CAM_ISP_RESOURCE_STATE_RESERVED:
+		rsrc_state = CAM_CUSTOM_HW_RESOURCE_STATE_RESERVED;
+		break;
+	case CAM_ISP_RESOURCE_STATE_INIT_HW:
+		rsrc_state = CAM_CUSTOM_HW_RESOURCE_STATE_INIT_HW;
+		break;
+	case CAM_ISP_RESOURCE_STATE_STREAMING:
+		rsrc_state = CAM_CUSTOM_HW_RESOURCE_STATE_STREAMING;
+		break;
+	default:
+		rsrc_state = CAM_CUSTOM_HW_RESOURCE_STATE_UNAVAILABLE;
+		CAM_DBG(CAM_CUSTOM, "invalid rsrc type");
+		break;
+	}
+
+	return rsrc_state;
+}
+
+enum cam_isp_resource_state
+	cam_custom_hw_mgr_get_isp_res_state(
+	uint32_t						in_rsrc_state)
+{
+	enum cam_isp_resource_state     rsrc_state;
+
+	CAM_DBG(CAM_CUSTOM, "rsrc_state %x", in_rsrc_state);
+
+	switch (in_rsrc_state) {
+	case CAM_CUSTOM_HW_RESOURCE_STATE_UNAVAILABLE:
+		rsrc_state = CAM_ISP_RESOURCE_STATE_UNAVAILABLE;
+		break;
+	case CAM_CUSTOM_HW_RESOURCE_STATE_AVAILABLE:
+		rsrc_state = CAM_ISP_RESOURCE_STATE_AVAILABLE;
+		break;
+	case CAM_CUSTOM_HW_RESOURCE_STATE_RESERVED:
+		rsrc_state = CAM_ISP_RESOURCE_STATE_RESERVED;
+		break;
+	case CAM_CUSTOM_HW_RESOURCE_STATE_INIT_HW:
+		rsrc_state = CAM_ISP_RESOURCE_STATE_INIT_HW;
+		break;
+	case CAM_CUSTOM_HW_RESOURCE_STATE_STREAMING:
+		rsrc_state = CAM_ISP_RESOURCE_STATE_STREAMING;
+		break;
+	default:
+		rsrc_state = CAM_ISP_RESOURCE_STATE_UNAVAILABLE;
+		CAM_DBG(CAM_CUSTOM, "invalid rsrc type");
+		break;
+	}
+
+	return rsrc_state;
+}
+
+enum cam_isp_resource_type
+	cam_custom_hw_mgr_get_isp_res_type(
+	enum cam_custom_hw_mgr_res_type res_type)
+{
+	switch (res_type) {
+	case CAM_CUSTOM_CID_HW:
+		return CAM_ISP_RESOURCE_CID;
+	case CAM_CUSTOM_CSID_HW:
+		return CAM_ISP_RESOURCE_PIX_PATH;
+	default:
+		return CAM_ISP_RESOURCE_MAX;
+	}
+}
+
+static int cam_custom_hw_mgr_deinit_hw_res(
+	struct cam_custom_hw_mgr_res *hw_mgr_res)
+{
+	int rc = -1;
+	struct cam_isp_resource_node *isp_rsrc_node = NULL;
+	struct cam_hw_intf			 *hw_intf = NULL;
+
+	isp_rsrc_node =
+		(struct cam_isp_resource_node *)hw_mgr_res->rsrc_node;
+	if (!isp_rsrc_node) {
+		CAM_ERR(CAM_CUSTOM, "Invalid args");
+		return -EINVAL;
+	}
+
+	hw_intf = isp_rsrc_node->hw_intf;
+	if (hw_intf->hw_ops.deinit) {
+		CAM_DBG(CAM_CUSTOM, "DEINIT HW for res_id:%u",
+			hw_mgr_res->res_id);
+		rc = hw_intf->hw_ops.deinit(hw_intf->hw_priv,
+			isp_rsrc_node, sizeof(struct cam_isp_resource_node));
+		if (rc)
+			goto err;
+	}
+
+	return 0;
+
+err:
+	CAM_DBG(CAM_CUSTOM, "DEINIT HW failed for res_id:%u",
+		hw_mgr_res->res_id);
+	return rc;
+}
+
+static int cam_custom_hw_mgr_stop_hw_res(
+	struct cam_custom_hw_mgr_res *hw_mgr_res)
+{
+	int rc = -1;
+	struct cam_csid_hw_stop_args  stop_cmd;
+	struct cam_isp_resource_node *isp_rsrc_node = NULL;
+	struct cam_hw_intf			 *hw_intf = NULL;
+
+	isp_rsrc_node =
+		(struct cam_isp_resource_node *)hw_mgr_res->rsrc_node;
+	if (!isp_rsrc_node) {
+		CAM_ERR(CAM_CUSTOM, "Invalid args");
+		return -EINVAL;
+	}
+
+	hw_intf = isp_rsrc_node->hw_intf;
+	if (hw_intf->hw_ops.stop) {
+		CAM_DBG(CAM_CUSTOM, "STOP HW for res_id:%u",
+			hw_mgr_res->res_id);
+		stop_cmd.num_res = 1;
+		stop_cmd.node_res = &isp_rsrc_node;
+		stop_cmd.stop_cmd = CAM_CSID_HALT_AT_FRAME_BOUNDARY;
+		rc = hw_intf->hw_ops.stop(hw_intf->hw_priv,
+			&stop_cmd, sizeof(struct cam_csid_hw_stop_args));
+		if (rc)
+			goto err;
+	}
+
+	return 0;
+
+err:
+	CAM_DBG(CAM_CUSTOM, "STOP HW failed for res_id:%u",
+		hw_mgr_res->res_id);
+	return rc;
+}
+
+static int cam_custom_mgr_stop_hw(void *hw_mgr_priv, void *stop_hw_args)
+{
+	int                               rc        = 0;
+	struct cam_hw_stop_args          *stop_args = stop_hw_args;
+	struct cam_custom_hw_mgr_res     *hw_mgr_res;
+	struct cam_custom_hw_mgr_ctx     *ctx;
+
+	if (!hw_mgr_priv || !stop_hw_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid arguments");
+		return -EINVAL;
+	}
+
+	ctx = (struct cam_custom_hw_mgr_ctx *)
+		stop_args->ctxt_to_hw_map;
+
+	if (!ctx || !ctx->ctx_in_use) {
+		CAM_ERR(CAM_CUSTOM, "Invalid context is used");
+		return -EPERM;
+	}
+
+	CAM_DBG(CAM_CUSTOM, " Enter...ctx id:%d", ctx->ctx_index);
+
+	/* Stop custom cid here */
+	list_for_each_entry(hw_mgr_res,
+		&ctx->res_list_custom_cid, list) {
+		rc = cam_custom_hw_mgr_stop_hw_res(hw_mgr_res);
+		if (rc)
+			CAM_ERR(CAM_CUSTOM, "failed to stop hw %d",
+				hw_mgr_res->res_id);
+	}
+
+	/* Stop custom csid here */
+	list_for_each_entry(hw_mgr_res,
+		&ctx->res_list_custom_csid, list) {
+		rc = cam_custom_hw_mgr_stop_hw_res(hw_mgr_res);
+		if (rc) {
+			CAM_ERR(CAM_CUSTOM, "failed to stop hw %d",
+				hw_mgr_res->res_id);
+		}
+	}
+
+
+	/* stop custom hw here */
+
+	/* Deinit custom cid here */
+	list_for_each_entry(hw_mgr_res,
+		&ctx->res_list_custom_cid, list) {
+		rc = cam_custom_hw_mgr_deinit_hw_res(hw_mgr_res);
+		if (rc)
+			CAM_ERR(CAM_CUSTOM, "failed to stop hw %d",
+			hw_mgr_res->res_id);
+	}
+
+	/* Deinit custom csid here */
+	list_for_each_entry(hw_mgr_res,
+		&ctx->res_list_custom_csid, list) {
+		rc = cam_custom_hw_mgr_deinit_hw_res(hw_mgr_res);
+		if (rc) {
+			CAM_ERR(CAM_CUSTOM, "failed to stop hw %d",
+				hw_mgr_res->res_id);
+		}
+	}
+
+	/* deinit custom rsrc */
+
+	return rc;
+}
+
+static int cam_custom_hw_mgr_init_hw_res(
+	struct cam_custom_hw_mgr_res *hw_mgr_res)
+{
+	int rc = -1;
+	struct cam_isp_resource_node *isp_rsrc_node = NULL;
+	struct cam_hw_intf			 *hw_intf = NULL;
+
+	isp_rsrc_node =
+		(struct cam_isp_resource_node *)hw_mgr_res->rsrc_node;
+	if (!isp_rsrc_node) {
+		CAM_ERR(CAM_CUSTOM, "Invalid args");
+		return -EINVAL;
+	}
+
+	hw_intf = isp_rsrc_node->hw_intf;
+	if (hw_intf->hw_ops.init) {
+		CAM_DBG(CAM_CUSTOM, "INIT HW for res_id:%u",
+			hw_mgr_res->res_id);
+		rc = hw_intf->hw_ops.init(hw_intf->hw_priv,
+			isp_rsrc_node, sizeof(struct cam_isp_resource_node));
+		if (rc)
+			goto err;
+	}
+
+	return 0;
+
+err:
+	CAM_DBG(CAM_CUSTOM, "INIT HW failed for res_id:%u",
+		hw_mgr_res->res_id);
+	return rc;
+}
+
+static int cam_custom_hw_mgr_start_hw_res(
+	struct cam_custom_hw_mgr_res *hw_mgr_res)
+{
+	int rc = -1;
+	struct cam_isp_resource_node *isp_rsrc_node = NULL;
+	struct cam_hw_intf			 *hw_intf = NULL;
+
+	isp_rsrc_node =
+		(struct cam_isp_resource_node *)hw_mgr_res->rsrc_node;
+	if (!isp_rsrc_node) {
+		CAM_ERR(CAM_CUSTOM, "Invalid args");
+		return -EINVAL;
+	}
+
+	hw_intf = isp_rsrc_node->hw_intf;
+	if (hw_intf->hw_ops.start) {
+		CAM_DBG(CAM_CUSTOM, "Start HW for res_id:%u",
+			hw_mgr_res->res_id);
+		rc = hw_intf->hw_ops.start(hw_intf->hw_priv,
+			isp_rsrc_node, sizeof(struct cam_isp_resource_node));
+		if (rc)
+			goto err;
+	}
+
+	return 0;
+
+err:
+	CAM_DBG(CAM_CUSTOM, "START HW failed for res_id:%u",
+		hw_mgr_res->res_id);
+	return rc;
+}
+
+static int cam_custom_mgr_start_hw(void *hw_mgr_priv,
+	void *start_hw_args)
+{
+	int                                      rc = 0;
+	struct cam_hw_config_args               *hw_config;
+	struct cam_hw_stop_args                  stop_args;
+	struct cam_custom_hw_mgr_res            *hw_mgr_res;
+	struct cam_custom_hw_mgr_ctx            *ctx;
+
+	if (!hw_mgr_priv || !start_hw_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid arguments");
+		return -EINVAL;
+	}
+
+	hw_config = (struct cam_hw_config_args *)start_hw_args;
+
+	ctx = (struct cam_custom_hw_mgr_ctx *)
+		hw_config->ctxt_to_hw_map;
+	if (!ctx || !ctx->ctx_in_use) {
+		CAM_ERR(CAM_CUSTOM, "Invalid context is used");
+		return -EPERM;
+	}
+
+	CAM_DBG(CAM_CUSTOM, "Enter... ctx id:%d",
+		ctx->ctx_index);
+
+	/* Init custom cid */
+	list_for_each_entry(hw_mgr_res,
+		&ctx->res_list_custom_cid, list) {
+		rc = cam_custom_hw_mgr_init_hw_res(hw_mgr_res);
+		if (rc) {
+			CAM_ERR(CAM_ISP, "Can not INIT CID(id :%d)",
+				hw_mgr_res->res_id);
+			goto deinit_hw;
+		}
+	}
+
+	/* Init custom csid */
+	list_for_each_entry(hw_mgr_res,
+		&ctx->res_list_custom_csid, list) {
+		rc = cam_custom_hw_mgr_init_hw_res(hw_mgr_res);
+		if (rc) {
+			CAM_ERR(CAM_ISP, "Can not INIT CSID(id :%d)",
+				hw_mgr_res->res_id);
+			goto deinit_hw;
+		}
+	}
+
+
+	/* Init custom hw here */
+
+	/* Apply init config */
+
+	/* Start custom HW first */
+	if (rc < 0)
+		goto err;
+
+	/* Start custom csid */
+	list_for_each_entry(hw_mgr_res,
+		&ctx->res_list_custom_csid, list) {
+		rc = cam_custom_hw_mgr_start_hw_res(hw_mgr_res);
+		if (rc) {
+			CAM_ERR(CAM_ISP, "Can not START CSID(id :%d)",
+				hw_mgr_res->res_id);
+			goto err;
+		}
+	}
+
+	/* Start custom cid */
+	list_for_each_entry(hw_mgr_res,
+		&ctx->res_list_custom_cid, list) {
+		rc = cam_custom_hw_mgr_start_hw_res(hw_mgr_res);
+		if (rc) {
+			CAM_ERR(CAM_ISP, "Can not START CID(id :%d)",
+				hw_mgr_res->res_id);
+			goto err;
+		}
+	}
+
+	CAM_DBG(CAM_CUSTOM, "Start success for ctx id:%d", ctx->ctx_index);
+	return 0;
+
+err:
+	stop_args.ctxt_to_hw_map = hw_config->ctxt_to_hw_map;
+	cam_custom_mgr_stop_hw(hw_mgr_priv, &stop_args);
+deinit_hw:
+	/* deinit the hw previously initialized */
+	CAM_DBG(CAM_CUSTOM, "Exit...(rc=%d)", rc);
+	return rc;
+}
+
+static int cam_custom_mgr_read(void *hw_mgr_priv, void *read_args)
+{
+	return -EPERM;
+}
+
+static int cam_custom_mgr_write(void *hw_mgr_priv, void *write_args)
+{
+	return -EPERM;
+}
+
+static int cam_custom_hw_mgr_put_ctx(
+	struct list_head                 *src_list,
+	struct cam_custom_hw_mgr_ctx    **custom_ctx)
+{
+	struct cam_custom_hw_mgr_ctx *ctx_ptr  = NULL;
+
+	ctx_ptr = *custom_ctx;
+	if (ctx_ptr)
+		list_add_tail(&ctx_ptr->list, src_list);
+	*custom_ctx = NULL;
+	return 0;
+}
+
+static int cam_custom_hw_mgr_get_ctx(
+	struct list_head                *src_list,
+	struct cam_custom_hw_mgr_ctx       **custom_ctx)
+{
+	struct cam_custom_hw_mgr_ctx *ctx_ptr  = NULL;
+
+	if (!list_empty(src_list)) {
+		ctx_ptr = list_first_entry(src_list,
+			struct cam_custom_hw_mgr_ctx, list);
+		list_del_init(&ctx_ptr->list);
+	} else {
+		CAM_ERR(CAM_CUSTOM, "No more free custom hw mgr ctx");
+		return -EINVAL;
+	}
+	*custom_ctx = ctx_ptr;
+	memset(ctx_ptr->sub_hw_list, 0,
+		sizeof(struct cam_custom_hw_mgr_res) *
+		CAM_CUSTOM_HW_RES_MAX);
+
+	return 0;
+}
+
+static int cam_custom_hw_mgr_put_res(
+	struct list_head                *src_list,
+	struct cam_custom_hw_mgr_res   **res)
+{
+	struct cam_custom_hw_mgr_res *res_ptr = NULL;
+
+	res_ptr = *res;
+	if (res_ptr)
+		list_add_tail(&res_ptr->list, src_list);
+
+	return 0;
+}
+
+static int cam_custom_hw_mgr_get_res(
+	struct list_head                *src_list,
+	struct cam_custom_hw_mgr_res   **res)
+{
+	int rc = 0;
+	struct cam_custom_hw_mgr_res *res_ptr = NULL;
+
+	if (!list_empty(src_list)) {
+		res_ptr = list_first_entry(src_list,
+			struct cam_custom_hw_mgr_res, list);
+		list_del_init(&res_ptr->list);
+	} else {
+		CAM_ERR(CAM_CUSTOM, "No more free custom ctx rsrc");
+		rc = -1;
+	}
+	*res = res_ptr;
+
+	return rc;
+}
+
+static enum cam_ife_pix_path_res_id
+	cam_custom_hw_mgr_get_csid_res_type(
+	uint32_t						out_port_type)
+{
+	enum cam_ife_pix_path_res_id path_id;
+
+	CAM_DBG(CAM_CUSTOM, "out_port_type %x", out_port_type);
+
+	switch (out_port_type) {
+	case CAM_CUSTOM_OUT_RES_UDI_0:
+		path_id = CAM_IFE_PIX_PATH_RES_UDI_0;
+		break;
+	case CAM_CUSTOM_OUT_RES_UDI_1:
+		path_id = CAM_IFE_PIX_PATH_RES_UDI_1;
+		break;
+	case CAM_CUSTOM_OUT_RES_UDI_2:
+		path_id = CAM_IFE_PIX_PATH_RES_UDI_2;
+		break;
+	default:
+		path_id = CAM_IFE_PIX_PATH_RES_MAX;
+		CAM_DBG(CAM_CUSTOM, "maximum rdi output type exceeded");
+		break;
+	}
+
+	CAM_DBG(CAM_CUSTOM, "out_port %x path_id %d", out_port_type, path_id);
+
+	return path_id;
+}
+
+static int cam_custom_hw_mgr_acquire_cid_res(
+	struct cam_custom_hw_mgr_ctx           *custom_ctx,
+	struct cam_isp_in_port_generic_info    *in_port,
+	struct cam_custom_hw_mgr_res          **cid_res,
+	enum cam_ife_pix_path_res_id            path_res_id,
+	struct cam_isp_resource_node          **cid_rsrc_node)
+{
+	int rc = -1;
+	int i;
+	struct cam_custom_hw_mgr             *custom_hw_mgr;
+	struct cam_hw_intf                   *hw_intf;
+	struct cam_custom_hw_mgr_res         *cid_res_temp;
+	struct cam_csid_hw_reserve_resource_args  csid_acquire;
+	struct cam_isp_resource_node          *isp_rsrc_node;
+	struct cam_isp_out_port_generic_info *out_port = NULL;
+
+	custom_hw_mgr = custom_ctx->hw_mgr;
+	*cid_res = NULL;
+
+	rc = cam_custom_hw_mgr_get_res(
+		&custom_ctx->free_res_list, cid_res);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "No more free hw mgr resource");
+		goto end;
+	}
+
+	memset(&csid_acquire, 0, sizeof(csid_acquire));
+	cid_res_temp = *cid_res;
+	csid_acquire.res_type = CAM_ISP_RESOURCE_CID;
+	csid_acquire.in_port = in_port;
+	csid_acquire.res_id =  path_res_id;
+	csid_acquire.node_res = NULL;
+	CAM_DBG(CAM_CUSTOM, "path_res_id %d", path_res_id);
+
+	if (in_port->num_out_res)
+		out_port = &(in_port->data[0]);
+
+	for (i = 0; i < CAM_CUSTOM_CSID_HW_MAX; i++) {
+		if (!custom_hw_mgr->csid_devices[i])
+			continue;
+
+		hw_intf = custom_hw_mgr->csid_devices[i];
+		rc = hw_intf->hw_ops.reserve(hw_intf->hw_priv,
+				&csid_acquire, sizeof(csid_acquire));
+		/* since there is a need of 1 cid at this stage */
+			if (rc)
+				continue;
+			else
+				break;
+
+	}
+
+	if (!csid_acquire.node_res) {
+		CAM_ERR(CAM_CUSTOM,
+			"Can not acquire custom cid resource for path %d",
+			path_res_id);
+		rc = -EAGAIN;
+		goto put_res;
+	}
+
+	*cid_rsrc_node = csid_acquire.node_res;
+	isp_rsrc_node = csid_acquire.node_res;
+	cid_res_temp->rsrc_node = isp_rsrc_node;
+	cid_res_temp->res_type = CAM_CUSTOM_CID_HW;
+	cid_res_temp->res_id = isp_rsrc_node->res_id;
+	cam_custom_hw_mgr_put_res(&custom_ctx->res_list_custom_cid,
+		&cid_res_temp);
+
+	CAM_DBG(CAM_CUSTOM, "CID acquired successfully %u",
+		isp_rsrc_node->res_id);
+
+	return 0;
+
+put_res:
+	cam_custom_hw_mgr_put_res(&custom_ctx->free_res_list, cid_res);
+end:
+	return rc;
+
+}
+
+static int cam_custom_hw_mgr_acquire_csid_res(
+	struct cam_custom_hw_mgr_ctx        *custom_ctx,
+	struct cam_isp_in_port_generic_info *in_port_info)
+{
+	int rc = 0, i = 0;
+	struct cam_custom_hw_mgr                *custom_hw_mgr;
+	struct cam_isp_out_port_generic_info    *out_port;
+	struct cam_custom_hw_mgr_res            *custom_csid_res;
+	struct cam_custom_hw_mgr_res            *custom_cid_res;
+	struct cam_hw_intf                      *hw_intf;
+	struct cam_csid_hw_reserve_resource_args custom_csid_acquire;
+	enum cam_ife_pix_path_res_id             path_res_id;
+	struct cam_isp_resource_node            *isp_rsrc_node;
+	struct cam_isp_resource_node            *cid_rsrc_node = NULL;
+
+	custom_hw_mgr = custom_ctx->hw_mgr;
+
+	for (i = 0; i < in_port_info->num_out_res; i++) {
+		out_port = &in_port_info->data[i];
+		path_res_id = cam_custom_hw_mgr_get_csid_res_type(
+			out_port->res_type);
+
+		if (path_res_id == CAM_IFE_PIX_PATH_RES_MAX) {
+			CAM_WARN(CAM_CUSTOM, "Invalid out port res_type %u",
+				out_port->res_type);
+			continue;
+		}
+
+		rc = cam_custom_hw_mgr_acquire_cid_res(custom_ctx, in_port_info,
+			&custom_cid_res, path_res_id, &cid_rsrc_node);
+		if (rc) {
+			CAM_ERR(CAM_CUSTOM, "No free cid rsrc %d", rc);
+			goto end;
+		}
+
+		rc = cam_custom_hw_mgr_get_res(&custom_ctx->free_res_list,
+			&custom_csid_res);
+		if (rc) {
+			CAM_ERR(CAM_CUSTOM, "No more free hw mgr rsrc");
+			goto end;
+		}
+
+		memset(&custom_csid_acquire, 0, sizeof(custom_csid_acquire));
+		custom_csid_acquire.res_id = path_res_id;
+		custom_csid_acquire.res_type = CAM_ISP_RESOURCE_PIX_PATH;
+		custom_csid_acquire.cid = cid_rsrc_node->res_id;
+		custom_csid_acquire.in_port = in_port_info;
+		custom_csid_acquire.out_port = out_port;
+		custom_csid_acquire.sync_mode = 0;
+		custom_csid_acquire.node_res = NULL;
+
+		hw_intf = cid_rsrc_node->hw_intf;
+		rc = hw_intf->hw_ops.reserve(hw_intf->hw_priv,
+			&custom_csid_acquire, sizeof(custom_csid_acquire));
+		if (rc) {
+			CAM_ERR(CAM_CUSTOM,
+				"Custom csid acquire failed for hw_idx %u rc %d",
+				hw_intf->hw_idx, rc);
+			goto put_res;
+		}
+
+		if (custom_csid_acquire.node_res == NULL) {
+			CAM_ERR(CAM_CUSTOM, "Acquire custom csid failed");
+			rc = -EAGAIN;
+			goto put_res;
+		}
+
+		isp_rsrc_node = custom_csid_acquire.node_res;
+		custom_csid_res->rsrc_node = isp_rsrc_node;
+		custom_csid_res->res_type = CAM_CUSTOM_CSID_HW;
+		custom_csid_res->res_id = custom_csid_acquire.res_id;
+		cam_custom_hw_mgr_put_res(
+			&custom_ctx->res_list_custom_csid,
+			&custom_csid_res);
+		CAM_DBG(CAM_CUSTOM, "Custom CSID acquired for path %d",
+			path_res_id);
+	}
+
+	return 0;
+
+put_res:
+	cam_custom_hw_mgr_put_res(&custom_ctx->free_res_list,
+		&custom_csid_res);
+end:
+	return rc;
+}
+
+static int cam_custom_hw_mgr_free_hw_res(
+	struct cam_custom_hw_mgr_res   *hw_mgr_res)
+{
+	int rc = 0;
+	struct cam_isp_resource_node *isp_rsrc_node = NULL;
+	struct cam_hw_intf			 *hw_intf = NULL;
+
+	isp_rsrc_node =
+		(struct cam_isp_resource_node *)hw_mgr_res->rsrc_node;
+	if (!isp_rsrc_node) {
+		CAM_ERR(CAM_CUSTOM, "Invalid args");
+		return -EINVAL;
+	}
+
+	hw_intf = isp_rsrc_node->hw_intf;
+	if (hw_intf->hw_ops.release) {
+		CAM_DBG(CAM_CUSTOM, "RELEASE HW for res_id:%u",
+			hw_mgr_res->res_id);
+		rc = hw_intf->hw_ops.release(hw_intf->hw_priv,
+			isp_rsrc_node, sizeof(struct cam_isp_resource_node));
+		if (rc)
+			CAM_ERR(CAM_CUSTOM,
+				"Release HW failed for hw_idx %d",
+				hw_intf->hw_idx);
+	}
+
+	/* caller should make sure the resource is in a list */
+	list_del_init(&hw_mgr_res->list);
+	memset(hw_mgr_res, 0, sizeof(*hw_mgr_res));
+	INIT_LIST_HEAD(&hw_mgr_res->list);
+
+	return 0;
+}
+
+static int cam_custom_hw_mgr_release_hw_for_ctx(
+	struct cam_custom_hw_mgr_ctx *custom_ctx)
+{
+	int rc = -1;
+	struct cam_custom_hw_mgr_res     *hw_mgr_res;
+	struct cam_custom_hw_mgr_res	 *hw_mgr_res_temp;
+
+	/* Release custom cid */
+	list_for_each_entry_safe(hw_mgr_res, hw_mgr_res_temp,
+		&custom_ctx->res_list_custom_cid, list) {
+		rc = cam_custom_hw_mgr_free_hw_res(hw_mgr_res);
+		if (rc)
+			CAM_ERR(CAM_ISP, "Can not release CID(id :%d)",
+				hw_mgr_res->res_id);
+		cam_custom_hw_mgr_put_res(
+			&custom_ctx->free_res_list, &hw_mgr_res);
+	}
+
+	/* Release custom csid */
+	list_for_each_entry_safe(hw_mgr_res, hw_mgr_res_temp,
+		&custom_ctx->res_list_custom_csid, list) {
+		rc = cam_custom_hw_mgr_free_hw_res(hw_mgr_res);
+		if (rc)
+			CAM_ERR(CAM_ISP, "Can not release CSID(id :%d)",
+				hw_mgr_res->res_id);
+		cam_custom_hw_mgr_put_res(
+			&custom_ctx->free_res_list, &hw_mgr_res);
+	}
+
+	/* Release custom HW Here */
+
+	return 0;
+}
+static int cam_custom_mgr_release_hw(void *hw_mgr_priv,
+	void *release_hw_args)
+{
+	int                               rc           = 0;
+	struct cam_hw_release_args       *release_args = release_hw_args;
+	struct cam_custom_hw_mgr_ctx     *custom_ctx;
+
+	if (!hw_mgr_priv || !release_hw_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid arguments");
+		return -EINVAL;
+	}
+
+	custom_ctx =
+		(struct cam_custom_hw_mgr_ctx *)release_args->ctxt_to_hw_map;
+	if (!custom_ctx || !custom_ctx->ctx_in_use) {
+		CAM_ERR(CAM_CUSTOM, "Invalid context is used");
+		return -EPERM;
+	}
+
+	CAM_DBG(CAM_CUSTOM, "Enter...ctx id:%d",
+		custom_ctx->ctx_index);
+
+	cam_custom_hw_mgr_release_hw_for_ctx(custom_ctx);
+	list_del_init(&custom_ctx->list);
+	custom_ctx->ctx_in_use = 0;
+	cam_custom_hw_mgr_put_ctx(&g_custom_hw_mgr.free_ctx_list, &custom_ctx);
+	CAM_DBG(CAM_CUSTOM, "Release Exit..");
+	return rc;
+}
+
+static void cam_custom_hw_mgr_acquire_get_unified_dev_str(
+	struct cam_custom_in_port_info *in,
+	struct cam_isp_in_port_generic_info *gen_port_info)
+{
+	int i;
+
+	gen_port_info->res_type        =  in->res_type +
+		CAM_ISP_IFE_IN_RES_BASE - CAM_CUSTOM_IN_RES_BASE;
+	gen_port_info->lane_type       =  in->lane_type;
+	gen_port_info->lane_num        =  in->lane_num;
+	gen_port_info->lane_cfg        =  in->lane_cfg;
+	gen_port_info->vc[0]           =  in->vc[0];
+	gen_port_info->dt[0]           =  in->dt[0];
+	gen_port_info->num_valid_vc_dt =  in->num_valid_vc_dt;
+	gen_port_info->format          =  in->format;
+	gen_port_info->test_pattern    =  in->test_pattern;
+	gen_port_info->usage_type      =  in->usage_type;
+	gen_port_info->left_start      =  in->left_start;
+	gen_port_info->left_stop       =  in->left_stop;
+	gen_port_info->left_width      =  in->left_width;
+	gen_port_info->right_start     =  in->right_start;
+	gen_port_info->right_stop      =  in->right_stop;
+	gen_port_info->right_width     =  in->right_width;
+	gen_port_info->line_start      =  in->line_start;
+	gen_port_info->line_stop       =  in->line_stop;
+	gen_port_info->height          =  in->height;
+	gen_port_info->pixel_clk       =  in->pixel_clk;
+	gen_port_info->cust_node       =  1;
+	gen_port_info->num_out_res     =  in->num_out_res;
+	gen_port_info->num_bytes_out   =  in->num_bytes_out;
+
+	for (i = 0; i < in->num_out_res; i++) {
+		gen_port_info->data[i].res_type     = in->data[i].res_type;
+		gen_port_info->data[i].format       = in->data[i].format;
+	}
+}
+
+static int cam_custom_mgr_acquire_hw_for_ctx(
+	struct cam_custom_hw_mgr_ctx           *custom_ctx,
+	struct cam_isp_in_port_generic_info    *in_port_info,
+	uint32_t *acquired_hw_id, uint32_t *acquired_hw_path)
+{
+	int rc = 0, i = 0;
+	struct cam_hw_intf            *hw_intf;
+	struct cam_custom_hw_mgr      *custom_hw_mgr;
+	struct cam_custom_sub_mod_acq acq;
+
+	custom_hw_mgr = custom_ctx->hw_mgr;
+
+	/* Acquire custom csid */
+	rc = cam_custom_hw_mgr_acquire_csid_res(custom_ctx, in_port_info);
+	if (rc) {
+		CAM_ERR(CAM_CUSTOM, "Custom csid acquire failed rc %d");
+		goto err;
+	}
+
+	/* Acquire custom hw */
+	for (i = 0; i < CAM_CUSTOM_HW_SUB_MOD_MAX; i++) {
+		hw_intf = custom_hw_mgr->custom_hw[i];
+		if (!hw_intf)
+			continue;
+
+		rc = hw_intf->hw_ops.reserve(hw_intf->hw_priv,
+			&acq, sizeof(acq));
+		if (rc) {
+			CAM_DBG(CAM_CUSTOM,
+				"No custom resource from hw %d",
+				hw_intf->hw_idx);
+			continue;
+		}
+		/* need to be set in reserve based on HW being acquired */
+		//custom_ctx->sub_hw_list[i].hw_res = acq.rsrc_node;
+		//custom_ctx->sub_hw_list[i].res_type = <res_type>
+		//custom_ctx->sub_hw_list[i].res_id = <res_id>;
+		break;
+	}
+
+err:
+	return rc;
+}
+
+static int cam_custom_mgr_acquire_hw(
+	void *hw_mgr_priv,
+	void *acquire_hw_args)
+{
+	int rc = -1;
+	int32_t i;
+	uint32_t                             in_port_length;
+	struct cam_custom_hw_mgr_ctx        *custom_ctx;
+	struct cam_custom_hw_mgr            *custom_hw_mgr;
+	struct cam_hw_acquire_args          *acquire_args =
+		(struct cam_hw_acquire_args *)  acquire_hw_args;
+	struct cam_custom_in_port_info      *in_port_info;
+	struct cam_custom_resource          *custom_rsrc;
+	struct cam_isp_in_port_generic_info *gen_port_info = NULL;
+
+	if (!hw_mgr_priv || !acquire_args || (acquire_args->num_acq <= 0)) {
+		CAM_ERR(CAM_CUSTOM, "Invalid params");
+		return -EINVAL;
+	}
+
+	custom_hw_mgr = (struct cam_custom_hw_mgr *) hw_mgr_priv;
+	mutex_lock(&g_custom_hw_mgr.ctx_mutex);
+	rc = cam_custom_hw_mgr_get_ctx(
+		&custom_hw_mgr->free_ctx_list, &custom_ctx);
+	if (rc || !custom_ctx) {
+		CAM_ERR(CAM_CUSTOM, "Get custom hw context failed");
+		mutex_unlock(&g_custom_hw_mgr.ctx_mutex);
+		goto err;
+	}
+	mutex_unlock(&g_custom_hw_mgr.ctx_mutex);
+
+	/* Handle Acquire Here */
+	custom_ctx->hw_mgr = custom_hw_mgr;
+	custom_ctx->cb_priv = acquire_args->context_data;
+	custom_ctx->event_cb = acquire_args->event_cb;
+
+	custom_rsrc = kcalloc(acquire_args->num_acq,
+		sizeof(*custom_rsrc), GFP_KERNEL);
+	if (!custom_rsrc) {
+		rc = -ENOMEM;
+		goto free_ctx;
+	}
+
+	CAM_DBG(CAM_CUSTOM, "start copy %d resources from user",
+		acquire_args->num_acq);
+
+	if (copy_from_user(custom_rsrc,
+		(void __user *)acquire_args->acquire_info,
+		((sizeof(*custom_rsrc)) * acquire_args->num_acq))) {
+		rc = -EFAULT;
+		goto free_ctx;
+	}
+
+	for (i = 0; i < acquire_args->num_acq; i++) {
+		if (custom_rsrc[i].resource_id != CAM_CUSTOM_RES_ID_PORT)
+			continue;
+
+		CAM_DBG(CAM_CUSTOM, "acquire no = %d total = %d", i,
+			acquire_args->num_acq);
+
+		CAM_DBG(CAM_CUSTOM,
+			"start copy from user handle %lld with len = %d",
+			custom_rsrc[i].res_hdl,
+			custom_rsrc[i].length);
+
+		in_port_length = sizeof(struct cam_custom_in_port_info);
+		if (in_port_length > custom_rsrc[i].length) {
+			CAM_ERR(CAM_CUSTOM, "buffer size is not enough");
+			rc = -EINVAL;
+			goto free_res;
+		}
+
+		in_port_info = memdup_user(
+			u64_to_user_ptr(custom_rsrc[i].res_hdl),
+			custom_rsrc[i].length);
+
+		if (!IS_ERR(in_port_info)) {
+			if (in_port_info->num_out_res >
+				CAM_CUSTOM_HW_OUT_RES_MAX) {
+				CAM_ERR(CAM_CUSTOM, "too many output res %d",
+					in_port_info->num_out_res);
+				rc = -EINVAL;
+				kfree(in_port_info);
+				goto free_res;
+			}
+
+			in_port_length =
+				sizeof(struct cam_custom_in_port_info) +
+				(in_port_info->num_out_res - 1) *
+				sizeof(struct cam_custom_out_port_info);
+
+			if (in_port_length > custom_rsrc[i].length) {
+				CAM_ERR(CAM_CUSTOM,
+					"buffer size is not enough");
+				rc = -EINVAL;
+				kfree(in_port_info);
+				goto free_res;
+			}
+
+			gen_port_info = kzalloc(
+				sizeof(struct cam_isp_in_port_generic_info),
+				GFP_KERNEL);
+			if (gen_port_info == NULL) {
+				rc = -ENOMEM;
+				goto free_res;
+			}
+
+			gen_port_info->data = kcalloc(
+				sizeof(struct cam_isp_out_port_generic_info),
+				in_port_info->num_out_res, GFP_KERNEL);
+			if (gen_port_info->data == NULL) {
+				kfree(gen_port_info);
+				gen_port_info = NULL;
+				rc = -ENOMEM;
+				goto free_res;
+			}
+
+			cam_custom_hw_mgr_acquire_get_unified_dev_str(
+				in_port_info, gen_port_info);
+
+			rc = cam_custom_mgr_acquire_hw_for_ctx(custom_ctx,
+				gen_port_info, &acquire_args->acquired_hw_id[i],
+				acquire_args->acquired_hw_path[i]);
+
+			kfree(in_port_info);
+			if (gen_port_info != NULL) {
+				kfree(gen_port_info->data);
+				kfree(gen_port_info);
+				gen_port_info = NULL;
+			}
+
+			if (rc) {
+				CAM_ERR(CAM_CUSTOM, "can not acquire resource");
+				goto free_res;
+			}
+	} else {
+		CAM_ERR(CAM_CUSTOM,
+			"Copy from user failed with in_port = %pK",
+			in_port_info);
+			rc = -EFAULT;
+			goto free_res;
+		}
+	}
+
+	custom_ctx->ctx_in_use = 1;
+	acquire_args->ctxt_to_hw_map = custom_ctx;
+	CAM_DBG(CAM_CUSTOM, "Exit...(success)");
+	return 0;
+
+free_res:
+	cam_custom_hw_mgr_release_hw_for_ctx(custom_ctx);
+free_ctx:
+	cam_custom_hw_mgr_put_ctx(&custom_hw_mgr->free_ctx_list, &custom_ctx);
+err:
+	CAM_DBG(CAM_CUSTOM, "Exit...(rc=%d)", rc);
+	return rc;
+}
+
+static int cam_custom_add_io_buffers(
+	int                                   iommu_hdl,
+	struct cam_hw_prepare_update_args    *prepare)
+{
+	int rc = 0, i = 0;
+	int32_t                             hdl;
+	uint32_t                            plane_id;
+	struct cam_buf_io_cfg              *io_cfg;
+
+	io_cfg = (struct cam_buf_io_cfg *)((uint8_t *)
+			&prepare->packet->payload +
+			prepare->packet->io_configs_offset);
+
+	/* Validate hw update entries */
+
+	for (i = 0; i < prepare->packet->num_io_configs; i++) {
+		CAM_DBG(CAM_CUSTOM, "======= io config idx %d ============", i);
+		CAM_DBG(CAM_CUSTOM,
+			"i %d req_id %llu resource_type:%d fence:%d direction %d",
+			i, prepare->packet->header.request_id,
+			io_cfg[i].resource_type, io_cfg[i].fence,
+			io_cfg[i].direction);
+
+		CAM_DBG(CAM_CUSTOM, "format: %d", io_cfg[i].format);
+
+		if (io_cfg[i].direction == CAM_BUF_OUTPUT) {
+			CAM_DBG(CAM_CUSTOM,
+				"output fence 0x%x", io_cfg[i].fence);
+		} else if (io_cfg[i].direction == CAM_BUF_INPUT) {
+			CAM_DBG(CAM_CUSTOM,
+				"input fence 0x%x", io_cfg[i].fence);
+		} else {
+			CAM_ERR(CAM_CUSTOM, "Invalid io config direction :%d",
+				io_cfg[i].direction);
+			return -EINVAL;
+		}
+
+		for (plane_id = 0; plane_id < CAM_PACKET_MAX_PLANES;
+			plane_id++) {
+			if (!io_cfg[i].mem_handle[plane_id])
+				continue;
+
+			hdl = io_cfg[i].mem_handle[plane_id];
+			CAM_DBG(CAM_CUSTOM, "handle 0x%x for plane %d",
+				hdl, plane_id);
+			/* Use cam_mem_get_io_buf() to retrieve iova */
+		}
+
+		/* Do other I/O config operations */
+	}
+
+	return rc;
+}
+
+static int cam_custom_mgr_prepare_hw_update(void *hw_mgr_priv,
+	void *prepare_hw_update_args)
+{
+	int rc = 0;
+	struct cam_hw_prepare_update_args        *prepare;
+	struct cam_cmd_buf_desc                  *cmd_desc = NULL;
+	struct cam_custom_prepare_hw_update_data *prepare_hw_data;
+	struct cam_custom_hw_mgr                 *hw_mgr;
+	struct cam_custom_hw_mgr_ctx             *ctx = NULL;
+	uint32_t                                 *ptr;
+	size_t                                    len;
+	struct cam_custom_cmd_buf_type_1         *custom_buf_type1;
+
+	if (!hw_mgr_priv || !prepare_hw_update_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid args");
+		return -EINVAL;
+	}
+
+	hw_mgr = (struct cam_custom_hw_mgr *) hw_mgr_priv;
+	prepare =
+		(struct cam_hw_prepare_update_args *) prepare_hw_update_args;
+
+	CAM_DBG(CAM_CUSTOM, "Enter for req_id %lld",
+		prepare->packet->header.request_id);
+
+	/* Prepare packet */
+	prepare_hw_data =
+		(struct cam_custom_prepare_hw_update_data *)prepare->priv;
+	prepare_hw_data->packet_opcode_type =
+		(prepare->packet->header.op_code & 0xFFF);
+	ctx = (struct cam_custom_hw_mgr_ctx *) prepare->ctxt_to_hw_map;
+
+	/* Test purposes-check the data in cmd buffer */
+	cmd_desc = (struct cam_cmd_buf_desc *)
+		((uint8_t *)&prepare->packet->payload +
+		prepare->packet->cmd_buf_offset);
+	rc = cam_packet_util_get_cmd_mem_addr(
+			cmd_desc->mem_handle, &ptr, &len);
+	if (!rc) {
+		ptr += (cmd_desc->offset / 4);
+		custom_buf_type1 =
+			(struct cam_custom_cmd_buf_type_1 *)ptr;
+		CAM_DBG(CAM_CUSTOM, "frame num %u",
+			custom_buf_type1->custom_info);
+	}
+
+	cam_custom_add_io_buffers(hw_mgr->img_iommu_hdl, prepare);
+	return 0;
+}
+
+static int cam_custom_mgr_config_hw(void *hw_mgr_priv,
+	void *hw_config_args)
+{
+	int rc = 0;
+	int i = 0;
+	struct cam_custom_hw_mgr_ctx *custom_ctx;
+	struct cam_custom_hw_mgr_res *res;
+	struct cam_hw_config_args    *cfg;
+	struct cam_hw_intf           *hw_intf = NULL;
+
+	CAM_DBG(CAM_CUSTOM, "Enter");
+	if (!hw_mgr_priv || !hw_config_args) {
+		CAM_ERR(CAM_CUSTOM, "Invalid arguments");
+		return -EINVAL;
+	}
+
+	cfg =
+		(struct cam_hw_config_args *)hw_config_args;
+	custom_ctx = cfg->ctxt_to_hw_map;
+
+	if (!custom_ctx->ctx_in_use) {
+		CAM_ERR(CAM_CUSTOM, "Invalid context parameters");
+		return -EPERM;
+	}
+
+	for (i = 0; i < CAM_CUSTOM_HW_SUB_MOD_MAX; i++) {
+		res = &custom_ctx->sub_hw_list[i];
+		if (res->hw_res) {
+			hw_intf = res->hw_res->hw_intf;
+			if (hw_intf->hw_ops.process_cmd) {
+				struct cam_custom_sub_mod_req_to_dev req_to_dev;
+
+				req_to_dev.ctx_idx = custom_ctx->ctx_index;
+				req_to_dev.dev_idx = i;
+				req_to_dev.req_id = cfg->request_id;
+				rc = hw_intf->hw_ops.process_cmd(
+					hw_intf->hw_priv,
+					CAM_CUSTOM_SUBMIT_REQ,
+					&req_to_dev, sizeof(req_to_dev));
+			}
+		}
+	}
+
+	return rc;
+}
+
+static int cam_custom_hw_mgr_irq_cb(void *data,
+	struct cam_custom_hw_cb_args *cb_args)
+{
+	struct cam_custom_sub_mod_req_to_dev *proc_req;
+	struct cam_hw_done_event_data         evt_data;
+	struct cam_custom_hw_mgr_ctx         *custom_ctx;
+	uint32_t ctx_idx;
+
+	proc_req = cb_args->req_info;
+	ctx_idx = proc_req->ctx_idx;
+	custom_ctx = &g_custom_hw_mgr.ctx_pool[ctx_idx];
+
+	if (!custom_ctx->ctx_in_use) {
+		CAM_ERR(CAM_CUSTOM, "ctx %u not in use", ctx_idx);
+		return 0;
+	}
+
+	/* Based on irq status notify success/failure */
+
+	evt_data.request_id = proc_req->req_id;
+	custom_ctx->event_cb(custom_ctx->cb_priv,
+		CAM_CUSTOM_EVENT_BUF_DONE, &evt_data);
+
+	return 0;
+}
+
+int cam_custom_hw_mgr_init(struct device_node *of_node,
+	struct cam_hw_mgr_intf *hw_mgr_intf, int *iommu_hdl)
+{
+	int rc = 0;
+	int i, j;
+	struct cam_custom_hw_mgr_ctx *ctx_pool;
+	struct cam_custom_sub_mod_set_irq_cb irq_cb_args;
+	struct cam_hw_intf *hw_intf = NULL;
+
+	memset(&g_custom_hw_mgr, 0, sizeof(g_custom_hw_mgr));
+	mutex_init(&g_custom_hw_mgr.ctx_mutex);
+
+	/* fill custom hw intf information */
+	for (i = 0; i < CAM_CUSTOM_HW_SUB_MOD_MAX; i++) {
+		/* Initialize sub modules */
+		rc = cam_custom_hw_sub_mod_init(
+				&g_custom_hw_mgr.custom_hw[i], i);
+
+		/* handle in case init fails */
+		if (g_custom_hw_mgr.custom_hw[i]) {
+			hw_intf = g_custom_hw_mgr.custom_hw[i];
+			if (hw_intf->hw_ops.process_cmd) {
+				irq_cb_args.custom_hw_mgr_cb =
+					cam_custom_hw_mgr_irq_cb;
+				irq_cb_args.data =
+					g_custom_hw_mgr.custom_hw[i]->hw_priv;
+				hw_intf->hw_ops.process_cmd(hw_intf->hw_priv,
+					CAM_CUSTOM_SET_IRQ_CB, &irq_cb_args,
+					sizeof(irq_cb_args));
+			}
+		}
+	}
+
+	for (i = 0; i < CAM_CUSTOM_CSID_HW_MAX; i++) {
+		/* Initialize csid custom modules */
+		rc = cam_custom_csid_hw_init(
+			&g_custom_hw_mgr.csid_devices[i], i);
+	}
+
+	INIT_LIST_HEAD(&g_custom_hw_mgr.free_ctx_list);
+	INIT_LIST_HEAD(&g_custom_hw_mgr.used_ctx_list);
+
+	/*
+	 *  for now, we only support one iommu handle. later
+	 *  we will need to setup more iommu handle for other
+	 *  use cases.
+	 *  Also, we have to release them once we have the
+	 *  deinit support
+	 */
+	if (cam_smmu_get_handle("custom",
+		&g_custom_hw_mgr.img_iommu_hdl)) {
+		CAM_ERR(CAM_CUSTOM, "Can not get iommu handle");
+		return -EINVAL;
+	}
+
+	for (i = 0; i < CAM_CTX_MAX; i++) {
+		memset(&g_custom_hw_mgr.ctx_pool[i], 0,
+			sizeof(g_custom_hw_mgr.ctx_pool[i]));
+		INIT_LIST_HEAD(&g_custom_hw_mgr.ctx_pool[i].list);
+
+		ctx_pool = &g_custom_hw_mgr.ctx_pool[i];
+
+		/* init context pool */
+		INIT_LIST_HEAD(&g_custom_hw_mgr.ctx_pool[i].free_res_list);
+		INIT_LIST_HEAD(
+			&g_custom_hw_mgr.ctx_pool[i].res_list_custom_csid);
+		INIT_LIST_HEAD(
+			&g_custom_hw_mgr.ctx_pool[i].res_list_custom_cid);
+		for (j = 0; j < CAM_CUSTOM_HW_RES_MAX; j++) {
+			INIT_LIST_HEAD(
+				&g_custom_hw_mgr.ctx_pool[i].res_pool[j].list);
+			list_add_tail(
+				&g_custom_hw_mgr.ctx_pool[i].res_pool[j].list,
+				&g_custom_hw_mgr.ctx_pool[i].free_res_list);
+		}
+
+		g_custom_hw_mgr.ctx_pool[i].ctx_index = i;
+		g_custom_hw_mgr.ctx_pool[i].hw_mgr = &g_custom_hw_mgr;
+
+		list_add_tail(&g_custom_hw_mgr.ctx_pool[i].list,
+			&g_custom_hw_mgr.free_ctx_list);
+	}
+
+	/* fill return structure */
+	hw_mgr_intf->hw_mgr_priv = &g_custom_hw_mgr;
+	hw_mgr_intf->hw_get_caps = cam_custom_mgr_get_hw_caps;
+	hw_mgr_intf->hw_acquire = cam_custom_mgr_acquire_hw;
+	hw_mgr_intf->hw_start = cam_custom_mgr_start_hw;
+	hw_mgr_intf->hw_stop = cam_custom_mgr_stop_hw;
+	hw_mgr_intf->hw_read = cam_custom_mgr_read;
+	hw_mgr_intf->hw_write = cam_custom_mgr_write;
+	hw_mgr_intf->hw_release = cam_custom_mgr_release_hw;
+	hw_mgr_intf->hw_prepare_update = cam_custom_mgr_prepare_hw_update;
+	hw_mgr_intf->hw_config = cam_custom_mgr_config_hw;
+
+	if (iommu_hdl)
+		*iommu_hdl = g_custom_hw_mgr.img_iommu_hdl;
+
+	CAM_DBG(CAM_CUSTOM, "HW manager initialized");
+	return 0;
+}

drivers/cam_cust/cam_custom_hw_mgr/cam_custom_hw_mgr.h

@@ -0,0 +1,180 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_CUSTOM_HW_MGR_H_
+#define _CAM_CUSTOM_HW_MGR_H_
+
+#include <linux/completion.h>
+#include "cam_custom_hw_mgr_intf.h"
+#include "cam_custom_sub_mod_core.h"
+#include "cam_ife_csid_hw_intf.h"
+#include "cam_isp_hw.h"
+#include "cam_custom_hw.h"
+#include <uapi/media/cam_defs.h>
+#include <uapi/media/cam_custom.h>
+
+enum cam_custom_hw_mgr_res_type {
+	CAM_CUSTOM_HW_SUB_MODULE,
+	CAM_CUSTOM_CID_HW,
+	CAM_CUSTOM_CSID_HW,
+	CAM_CUSTOM_HW_MAX,
+};
+
+/* Needs to be suitably defined */
+#define CAM_CUSTOM_HW_OUT_RES_MAX 1
+
+/**
+ * struct cam_custom_hw_mgr_res - HW resources for the Custom manager
+ *
+ * @list:                used by the resource list
+ * @res_type:            Custom manager resource type
+ * @res_id:              resource id based on the resource type for root or
+ *                       leaf resource, it matches the KMD interface port id.
+ *                       For branch resource, it is defined by the Custom HW
+ *                       layer
+ * @rsrc_node:           isp hw layer resource for csid/cid
+ * @hw_res:              hw layer resource array.
+ */
+struct cam_custom_hw_mgr_res {
+	struct list_head                 list;
+	enum cam_custom_hw_mgr_res_type  res_type;
+	uint32_t                         res_id;
+	void                            *rsrc_node;
+	struct cam_custom_resource_node *hw_res;
+};
+
+
+/**
+ * struct ctx_base_info - Base hardware information for the context
+ *
+ * @idx:                  Base resource index
+ *
+ */
+struct ctx_base_info {
+	uint32_t                       idx;
+};
+
+
+/**
+ * struct cam_custom_hw_mgr_ctx - Custom HW manager ctx object
+ *
+ * @list:                   used by the ctx list.
+ * @ctx_index:              acquired context id.
+ * @hw_mgr:                 Custom hw mgr which owns this context
+ * @ctx_in_use:             flag to tell whether context is active
+ * @res_list_custom_csid:   custom csid modules for this context
+ * @res_list_custom_cid:    custom cid modules for this context
+ * @sub_hw_list:            HW submodules for this context
+ * @free_res_list:          Free resources list for the branch node
+ * @res_pool:               memory storage for the free resource list
+ * @base:                   device base index array contain the all
+ *                          Custom HW instance associated with this ctx.
+ * @num_base:               number of valid base data in the base array
+ * @init_done:              indicate whether init hw is done
+ * @event_cb:               event_cb to ctx
+ * @cb_priv:                data sent back with event_cb
+ *
+ */
+struct cam_custom_hw_mgr_ctx {
+	struct list_head                list;
+
+	uint32_t                        ctx_index;
+	struct cam_custom_hw_mgr       *hw_mgr;
+	uint32_t                        ctx_in_use;
+
+	struct list_head                res_list_custom_csid;
+	struct list_head                res_list_custom_cid;
+	struct cam_custom_hw_mgr_res    sub_hw_list[
+		CAM_CUSTOM_HW_RES_MAX];
+
+	struct list_head                free_res_list;
+	struct cam_custom_hw_mgr_res    res_pool[CAM_CUSTOM_HW_RES_MAX];
+	struct ctx_base_info            base[CAM_CUSTOM_HW_SUB_MOD_MAX];
+	uint32_t                        num_base;
+	bool                            init_done;
+	cam_hw_event_cb_func            event_cb;
+	void                           *cb_priv;
+};
+
+/**
+ * struct cam_custom_hw_mgr - Custom HW Manager
+ *
+ * @img_iommu_hdl:         iommu handle
+ * @custom_hw:             Custom device instances array. This will be filled by
+ *                         HW layer during initialization
+ * @csid_devices:          Custom csid device instance array
+ * @ctx_mutex:             mutex for the hw context pool
+ * @free_ctx_list:         free hw context list
+ * @used_ctx_list:         used hw context list
+ * @ctx_pool:              context storage
+ *
+ */
+struct cam_custom_hw_mgr {
+	int                            img_iommu_hdl;
+	struct cam_hw_intf            *custom_hw[CAM_CUSTOM_HW_SUB_MOD_MAX];
+	struct cam_hw_intf            *csid_devices[CAM_CUSTOM_CSID_HW_MAX];
+	struct mutex                   ctx_mutex;
+	struct list_head               free_ctx_list;
+	struct list_head               used_ctx_list;
+	struct cam_custom_hw_mgr_ctx   ctx_pool[CAM_CTX_MAX];
+};
+
+/**
+ * cam_custom_hw_mgr_init()
+ *
+ * @brief:              Initialize the Custom hardware manger. This is the
+ *                      etnry functinon for the Cust HW manager.
+ *
+ * @of_node:            Device node
+ * @hw_mgr_intf:        Custom hardware manager object returned
+ * @iommu_hdl:          Iommu handle to be returned
+ *
+ */
+int cam_custom_hw_mgr_init(struct device_node *of_node,
+	struct cam_hw_mgr_intf *hw_mgr_intf, int *iommu_hdl);
+
+
+/* Utility APIs */
+
+/**
+ * cam_custom_hw_mgr_get_custom_res_state()
+ *
+ * @brief:              Obtain equivalent custom rsrc state
+ *                      from isp rsrc state
+ *
+ * @in_rsrc_state:      isp rsrc state
+ *
+ */
+enum cam_custom_hw_resource_state
+	cam_custom_hw_mgr_get_custom_res_state(
+	uint32_t in_rsrc_state);
+
+/**
+ * cam_custom_hw_mgr_get_isp_res_state()
+ *
+ * @brief:              Obtain equivalent isp rsrc state
+ *                      from custom rsrc state
+ *
+ * @in_rsrc_state:      custom rsrc state
+ *
+ */
+enum cam_isp_resource_state
+	cam_custom_hw_mgr_get_isp_res_state(
+	uint32_t in_rsrc_state);
+
+/**
+ * cam_custom_hw_mgr_get_isp_res_type()
+ *
+ * @brief:         Obtain equivalent isp rsrc type
+ *                 from custom rsrc type
+ *
+ * @res_type:      custom rsrc type
+ *
+ */
+enum cam_isp_resource_type
+	cam_custom_hw_mgr_get_isp_res_type(
+	enum cam_custom_hw_mgr_res_type res_type);
+
+#endif /* _CAM_CUSTOM_HW_MGR_H_ */

drivers/cam_cust/cam_custom_hw_mgr/include/cam_custom_hw.h

@@ -0,0 +1,57 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_CUSTOM_HW_H_
+#define _CAM_CUSTOM_HW_H_
+
+#include <linux/of.h>
+#include <linux/time.h>
+#include <linux/list.h>
+#include <uapi/media/cam_custom.h>
+
+enum cam_custom_hw_resource_state {
+	CAM_CUSTOM_HW_RESOURCE_STATE_UNAVAILABLE   = 0,
+	CAM_CUSTOM_HW_RESOURCE_STATE_AVAILABLE     = 1,
+	CAM_CUSTOM_HW_RESOURCE_STATE_RESERVED      = 2,
+	CAM_CUSTOM_HW_RESOURCE_STATE_INIT_HW       = 3,
+	CAM_CUSTOM_HW_RESOURCE_STATE_STREAMING     = 4,
+};
+
+/*
+ * struct cam_custom_resource_node:
+ *
+ * @Brief:                        Structure representing HW resource object
+ *
+ * @res_id:                       Unique resource ID within res_type objects
+ *                                for a particular HW
+ * @res_state:                    State of the resource
+ * @hw_intf:                      HW Interface of HW to which this resource
+ *                                belongs
+ * @res_priv:                     Private data of the resource
+ * @irq_handle:                   handle returned on subscribing for IRQ event
+ * @init:                         function pointer to init the HW resource
+ * @deinit:                       function pointer to deinit the HW resource
+ * @start:                        function pointer to start the HW resource
+ * @stop:                         function pointer to stop the HW resource
+ * @process_cmd:                  function pointer for processing commands
+ *                                specific to the resource
+ */
+struct cam_custom_resource_node {
+	uint32_t                          res_id;
+	enum cam_custom_hw_resource_state res_state;
+	struct cam_hw_intf               *hw_intf;
+	void                             *res_priv;
+	int                               irq_handle;
+
+	int (*init)(struct cam_custom_resource_node *rsrc_node,
+		void *init_args, uint32_t arg_size);
+	int (*deinit)(struct cam_custom_resource_node *rsrc_node,
+		void *deinit_args, uint32_t arg_size);
+	int (*start)(struct cam_custom_resource_node *rsrc_node);
+	int (*stop)(struct cam_custom_resource_node *rsrc_node);
+	int (*process_cmd)(struct cam_custom_resource_node *rsrc_node,
+		uint32_t cmd_type, void *cmd_args, uint32_t arg_size);
+};
+#endif /* _CAM_CUSTOM_HW_H_ */

drivers/cam_cust/cam_custom_hw_mgr/include/cam_custom_hw_mgr_intf.h

@@ -0,0 +1,104 @@
+/* SPDX-License-Identifier: GPL-2.0-only
+ *
+ * Copyright (c) 2019, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _CAM_CUSTOM_HW_MGR_INTF_H_
+#define _CAM_CUSTOM_HW_MGR_INTF_H_
+
+#include <linux/of.h>
+#include <linux/time.h>
+#include <linux/list.h>
+#include <uapi/media/cam_custom.h>
+#include "cam_hw.h"
+#include "cam_hw_mgr_intf.h"
+#include "cam_hw_intf.h"
+
+#define CAM_CUSTOM_HW_TYPE_1   1
+
+#define CAM_CUSTOM_HW_RES_MAX 32
+
+#define CAM_CUSTOM_HW_SUB_MOD_MAX 1
+#define CAM_CUSTOM_CSID_HW_MAX    1
+
+enum cam_custom_hw_event_type {
+	CAM_CUSTOM_EVENT_TYPE_ERROR,
+	CAM_CUSTOM_EVENT_BUF_DONE,
+};
+
+enum cam_custom_cmd_types {
+	CAM_CUSTOM_CMD_NONE,
+	CAM_CUSTOM_SET_IRQ_CB,
+	CAM_CUSTOM_SUBMIT_REQ,
+};
+
+/**
+ * struct cam_custom_stop_args - hardware stop arguments
+ *
+ * @stop_only                  Send stop only to hw drivers. No Deinit to be
+ *                             done.
+ */
+struct cam_custom_stop_args {
+	bool                          stop_only;
+};
+
+/**
+ * struct cam_custom_start_args - custom hardware start arguments
+ *
+ * @hw_config:                 Hardware configuration commands.
+ * @start_only                 Send start only to hw drivers. No init to
+ *                             be done.
+ *
+ */
+struct cam_custom_start_args {
+	struct cam_hw_config_args     hw_config;
+	bool                          start_only;
+};
+
+/**
+ * struct cam_custom_prepare_hw_update_data - hw prepare data
+ *
+ * @packet_opcode_type:     Packet header opcode in the packet header
+ *                          this opcode defines, packet is init packet or
+ *                          update packet
+ *
+ */
+struct cam_custom_prepare_hw_update_data {
+	uint32_t                          packet_opcode_type;
+};
+
+/**
+ * struct cam_custom_hw_cb_args : HW manager callback args
+ *
+ * @irq_status : irq status
+ * @req_info   : Pointer to the request info associated with the cb
+ */
+struct cam_custom_hw_cb_args {
+	uint32_t                              irq_status;
+	struct cam_custom_sub_mod_req_to_dev *req_info;
+};
+
+/**
+ * cam_custom_hw_sub_mod_init()
+ *
+ * @Brief:                  Initialize Custom HW device
+ *
+ * @custom_hw:              cust_hw interface to fill in and return on
+ *                          successful initialization
+ * @hw_idx:                 Index of Custom HW
+ */
+int cam_custom_hw_sub_mod_init(struct cam_hw_intf **custom_hw, uint32_t hw_idx);
+
+/**
+ * cam_custom_csid_hw_init()
+ *
+ * @Brief:                  Initialize Custom HW device
+ *
+ * @custom_hw:              cust_hw interface to fill in and return on
+ *                          successful initialization
+ * @hw_idx:                 Index of Custom HW
+ */
+int cam_custom_csid_hw_init(
+	struct cam_hw_intf **custom_hw, uint32_t hw_idx);
+
+#endif /* _CAM_CUSTOM_HW_MGR_INTF_H_ */

drivers/cam_req_mgr/cam_req_mgr_interface.h

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
- * Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
+ * Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
  */
 
 #ifndef _CAM_REQ_MGR_INTERFACE_H
@@ -151,6 +151,7 @@ enum cam_req_mgr_device_error {
  * @FLASH       : LED flash or dual LED device
  * @ACTUATOR    : lens mover
  * @IFE         : Image processing device
+ * @CUSTOM      : Custom HW block
  * @EXTERNAL_1  : third party device
  * @EXTERNAL_2  : third party device
  * @EXTERNAL_3  : third party device
@@ -162,6 +163,7 @@ enum cam_req_mgr_device_id {
 	CAM_REQ_MGR_DEVICE_FLASH,
 	CAM_REQ_MGR_DEVICE_ACTUATOR,
 	CAM_REQ_MGR_DEVICE_IFE,
+	CAM_REQ_MGR_DEVICE_CUSTOM_HW,
 	CAM_REQ_MGR_DEVICE_EXTERNAL_1,
 	CAM_REQ_MGR_DEVICE_EXTERNAL_2,
 	CAM_REQ_MGR_DEVICE_EXTERNAL_3,

drivers/cam_utils/cam_debug_util.c

@@ -91,6 +91,9 @@ const char *cam_get_module_name(unsigned int module_id)
 	case CAM_REQ:
 		name = "CAM-REQ";
 		break;
+	case CAM_CUSTOM:
+		name = "CAM-CUSTOM";
+		break;
 	default:
 		name = "CAM";
 		break;

drivers/cam_utils/cam_debug_util.h

@@ -38,6 +38,7 @@
 
 /* CAM_PERF: Used for performance (clock, BW etc) logs */
 #define CAM_PERF       (1 << 25)
+#define CAM_CUSTOM     (1 << 26)
 
 #define STR_BUFFER_MAX_LENGTH  1024