Merge "msm: camera: CSID virtualization" (eb0dcd7c) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/media/platform/msm/camera_v2/common/msm_camera_tz_util.c

+535 −17

Original line number	Diff line number	Diff line
		/* Copyright (c) 2016-2018, The Linux Foundation. All rights reserved.
		/* Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		@@ -10,27 +10,58 @@
		* GNU General Public License for more details.
		*/

		#include <asm/cacheflush.h>
		#include <linux/delay.h>
		#include <linux/ktime.h>
		#include <linux/mutex.h>
		#include <soc/qcom/camera2.h>
		#include <soc/qcom/scm.h>
		#include "qseecom_kernel.h"
		#include "msm_camera_io_util.h"
		#include "msm_camera_tz_util.h"

		#define MSM_CAMERA_TZ_DEFERRED_SIZE 40
		#define EMPTY_QSEECOM_HANDLE NULL
		#define QSEECOM_SBUFF_SIZE SZ_128K
		#define QSEECOM_SBUFF_SIZE SZ_64K

		#define MSM_CAMERA_TZ_OK 0
		#define MSM_CAMERA_TZ_FAULT (-EFAULT)
		#define MSM_CAMERA_TZ_TRUE 1
		#define MSM_CAMERA_TZ_FALSE 0

		#define MSM_CAMERA_TZ_SVC_CAMERASS_CALL_ID 24
		#define MSM_CAMERA_TZ_SVC_CAMERASS_VER_SHIFT 28
		#define MSM_CAMERA_TZ_SVC_CAMERASS_CURRENT_VER 0x1
		#define MSM_CAMERA_TZ_SVC_CAMERASS_SECURITY_STATUS 0x1
		#define MSM_CAMERA_TZ_SVC_CAMERASS_REG_READ 0x2
		#define MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE 0x3
		#define MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE_BULK 0x4
		#define MSM_CAMERA_TZ_SVC_CAMERASS_RESET_HW_BLOCK 0x5
		#define MSM_CAMERA_TZ_SVC_CAMERASS_HW_BLOCK_SHIFT 21

		#undef MSM_CAMERA_TZ_UTIL_VERBOSE

		#define MSM_CAMERA_TZ_BOOT_PROTECTED (false)
		#define MSM_CAMERA_TZ_PROTECTION_LEVEL 1

		#if MSM_CAMERA_TZ_PROTECTION_LEVEL == 2
		#define MSM_CAMERA_TZ_SECURED_HW_BLOCKS \
		(MSM_CAMERA_TZ_HW_BLOCK_CSIDCORE)
		#elif MSM_CAMERA_TZ_PROTECTION_LEVEL == 1
		#define MSM_CAMERA_TZ_SECURED_HW_BLOCKS \
		(MSM_CAMERA_TZ_HW_BLOCK_CSIDCORE)
		#else
		#define MSM_CAMERA_TZ_SECURED_HW_BLOCKS (0)
		#endif

		/* Update version major number in case the HLOS-TA interface is changed*/
		#define TA_IF_VERSION_MAJ 1
		#define TA_IF_VERSION_MIN 2
		#define TA_IF_VERSION_MIN 4

		#undef CDBG
		#ifdef MSM_CAMERA_TZ_UTIL_VERBOSE
		#define CDBG(fmt, args...) \
		pr_info(CONFIG_MSM_SEC_CCI_TA_NAME "::%s:%d - " fmt,\
		__func__, __LINE__, ##args)
		pr_info("%s:%d - " fmt, __func__, __LINE__, ##args)
		#else /* MSM_CAMERA_TZ_UTIL_VERBOSE */
		#define CDBG(fmt, args...) \
		pr_debug("%s:%d - " fmt, __func__, __LINE__, ##args)
		@@ -39,14 +70,16 @@
		#pragma pack(push, msm_camera_tz_util, 1)

		/* MSM_CAMERA_TZ_CMD_GET_IF_VERSION */
		#define msm_camera_tz_i2c_get_if_version_req_t msm_camera_tz_generic_req_t
		#define msm_camera_tz_get_if_version_req_t msm_camera_tz_generic_req_t

		struct msm_camera_tz_i2c_get_if_version_rsp_t {
		struct msm_camera_tz_get_if_version_rsp_t {
		enum msm_camera_tz_status_t rc;
		uint32_t if_version_maj;
		uint32_t if_version_min;
		};

		#define msm_camera_tz_set_mode_rsp_t msm_camera_tz_generic_rsp_t

		/* MSM_CAMERA_TZ_CMD_SET_MODE */
		struct msm_camera_tz_set_mode_req_t {
		enum msm_camera_tz_cmd_id_t cmd_id;
		@@ -54,12 +87,17 @@ struct msm_camera_tz_set_mode_req_t {
		uint32_t hw_block;
		};

		#define msm_camera_tz_set_mode_rsp_t msm_camera_tz_generic_rsp_t

		#pragma pack(pop, msm_camera_tz_util)

		/* TA communication control structure */
		/* TEE communication control structure
		* TZBSP Status format:
		* bit 0-1 : reserved
		* bit 2-20 : corresponding SCM call status, 1 - supported
		* bit 21-27 : protected HW blocks
		* bit 28-31 : API version
		*/
		struct msm_camera_tz_ctrl_t {
		uint32_t tzbsp_status;
		uint32_t ta_enabled;
		struct qseecom_handle *ta_qseecom_handle;
		const char *ta_name;
		@@ -67,11 +105,144 @@ struct msm_camera_tz_ctrl_t {
		};

		static struct msm_camera_tz_ctrl_t msm_camera_tz_ctrl = {
		0, NULL, CONFIG_MSM_CAMERA_TZ_TA_NAME, 0
		0, 0, NULL, CONFIG_MSM_CAMERA_TZ_TA_NAME, 0
		};

		/* Register accsess relay */
		struct msm_camera_tz_register_t {
		uint32_t offset;
		uint32_t data;
		};

		struct msm_camera_tz_reg_ctrl_t {
		uint32_t num_of_deffered_registers;
		enum msm_camera_tz_io_region_t deferred_region;
		void __iomem *deferred_base_addr;
		struct msm_camera_tz_register_t
		deferred_registers[MSM_CAMERA_TZ_DEFERRED_SIZE];
		};

		static struct msm_camera_tz_reg_ctrl_t msm_camera_tz_reg_ctrl = {
		0,
		MSM_CAMERA_TZ_IO_REGION_LAST,
		NULL
		};

		static DEFINE_MUTEX(msm_camera_tz_util_lock);

		static int32_t msm_camera_tz_tzbsp_reg_write(uint32_t data, uint32_t offset,
		enum msm_camera_tz_io_region_t region);

		static const char *msm_camera_tz_scm_call_name(uint32_t call_id)
		{
		switch (call_id) {
		case MSM_CAMERA_TZ_SVC_CAMERASS_SECURITY_STATUS:
		return "STATUS";
		case MSM_CAMERA_TZ_SVC_CAMERASS_REG_READ:
		return "REG_READ";
		case MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE:
		return "REG_WRITE";
		case MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE_BULK:
		return "REG_WRITE_BULK";
		case MSM_CAMERA_TZ_SVC_CAMERASS_RESET_HW_BLOCK:
		return "RESET_HW_BLOCK";
		default:
		return "N/A";
		}
		};

		static const char *msm_camera_tz_region_name(
		enum msm_camera_tz_io_region_t region)
		{
		switch (region) {
		case MSM_CAMERA_TZ_IO_REGION_CSIDCORE0:
		return "CSIDCORE0";
		case MSM_CAMERA_TZ_IO_REGION_CSIDCORE1:
		return "CSIDCORE1";
		case MSM_CAMERA_TZ_IO_REGION_CSIDCORE2:
		return "CSIDCORE2";
		case MSM_CAMERA_TZ_IO_REGION_CSIDCORE3:
		return "CSIDCORE3";
		default:
		return "N/A";
		}
		};

		uint32_t msm_camera_tz_region_to_hw_block(
		enum msm_camera_tz_io_region_t region)
		{
		switch (region) {
		case MSM_CAMERA_TZ_IO_REGION_CSIDCORE0:
		case MSM_CAMERA_TZ_IO_REGION_CSIDCORE1:
		case MSM_CAMERA_TZ_IO_REGION_CSIDCORE2:
		case MSM_CAMERA_TZ_IO_REGION_CSIDCORE3:
		return MSM_CAMERA_TZ_HW_BLOCK_CSIDCORE;
		default:
		break;
		}

		return 0;
		}

		static uint32_t msm_camera_tz_get_tzbsp_status(uint32_t status_mask)
		{
		if (msm_camera_tz_ctrl.tzbsp_status == 0) {
		struct scm_desc desc = {
		.arginfo = SCM_ARGS(0),
		};
		ktime_t startTime = ktime_get();

		int32_t scmcall_status = scm_call2_atomic(
		SCM_SIP_FNID(
		MSM_CAMERA_TZ_SVC_CAMERASS_CALL_ID,
		MSM_CAMERA_TZ_SVC_CAMERASS_SECURITY_STATUS),
		&desc);
		if (scmcall_status) {
		CDBG("SCM call %s failed - %d\n",
		msm_camera_tz_scm_call_name(
		MSM_CAMERA_TZ_SVC_CAMERASS_SECURITY_STATUS),
		scmcall_status);
		msm_camera_tz_ctrl.tzbsp_status = 0xFFFFFFFF;
		} else {
		msm_camera_tz_ctrl.tzbsp_status = desc.ret[0];
		}
		CDBG("Done: status=0x%08X, - %lluus\n",
		msm_camera_tz_ctrl.tzbsp_status,
		ktime_us_delta(ktime_get(), startTime));
		}
		if ((msm_camera_tz_ctrl.tzbsp_status != 0xFFFFFFFF) &&
		(msm_camera_tz_ctrl.tzbsp_status & status_mask))
		return MSM_CAMERA_TZ_TRUE;

		/* TZBSP implementation is not available */
		return MSM_CAMERA_TZ_FALSE;
		}

		void msm_camera_tz_clear_tzbsp_status(void)
		{
		msm_camera_tz_ctrl.tzbsp_status = 0;
		}

		uint32_t msm_camera_tz_is_secured(
		enum msm_camera_tz_io_region_t region)
		{
		/* Check TZBSP API version */
		if (msm_camera_tz_get_tzbsp_status(
		MSM_CAMERA_TZ_SVC_CAMERASS_CURRENT_VER <<
		MSM_CAMERA_TZ_SVC_CAMERASS_VER_SHIFT) !=
		MSM_CAMERA_TZ_TRUE)
		return MSM_CAMERA_TZ_FALSE;

		/* Check if the region is boot protected */
		if (msm_camera_tz_get_tzbsp_status(
		(msm_camera_tz_region_to_hw_block(region) <<
		MSM_CAMERA_TZ_SVC_CAMERASS_HW_BLOCK_SHIFT)) ==
		MSM_CAMERA_TZ_TRUE)
		return MSM_CAMERA_TZ_TRUE;

		return MSM_CAMERA_TZ_FALSE;
		}

		struct qseecom_handle *msm_camera_tz_get_ta_handle(void)
		{
		return msm_camera_tz_ctrl.ta_qseecom_handle;
		@@ -118,14 +289,14 @@ int32_t get_cmd_rsp_buffers(
		return 0;
		}

		static int32_t msm_camera_tz_i2c_ta_get_if_version(
		static int32_t msm_camera_tz_ta_get_if_version(
		struct qseecom_handle *ta_qseecom_handle,
		uint32_t *if_version_maj,
		uint32_t *if_version_min)
		{
		int32_t cmd_len, rsp_len;
		struct msm_camera_tz_i2c_get_if_version_req_t *cmd;
		struct msm_camera_tz_i2c_get_if_version_rsp_t *rsp;
		struct msm_camera_tz_get_if_version_req_t *cmd;
		struct msm_camera_tz_get_if_version_rsp_t *rsp;
		int32_t rc = 0;

		CDBG("Enter\n");
		@@ -136,8 +307,8 @@ static int32_t msm_camera_tz_i2c_ta_get_if_version(
		return -EINVAL;
		}

		cmd_len = sizeof(struct msm_camera_tz_i2c_get_if_version_req_t);
		rsp_len = sizeof(struct msm_camera_tz_i2c_get_if_version_rsp_t);
		cmd_len = sizeof(struct msm_camera_tz_get_if_version_req_t);
		rsp_len = sizeof(struct msm_camera_tz_get_if_version_rsp_t);

		rc = get_cmd_rsp_buffers(ta_qseecom_handle,
		(void )&cmd, &cmd_len, (void )&rsp, &rsp_len);
		@@ -199,7 +370,7 @@ int32_t msm_camera_tz_load_ta(void)
		(char *)msm_camera_tz_ctrl.ta_name,
		QSEECOM_SBUFF_SIZE);
		if (!rc)
		rc = msm_camera_tz_i2c_ta_get_if_version(
		rc = msm_camera_tz_ta_get_if_version(
		msm_camera_tz_ctrl.ta_qseecom_handle,
		&if_version_maj, &if_version_min);

		@@ -349,3 +520,350 @@ uint32_t msm_camera_tz_set_mode(uint32_t mode,
		rc, mode);
		return rc;
		}

		static int32_t msm_camera_tz_tzbsp_reg_write_bulk(
		enum msm_camera_tz_io_region_t region)
		{
		int32_t rc = 0;
		struct scm_desc desc = {0};
		uint32_t *offsets = NULL;
		uint32_t *data = NULL;
		uint32_t index;
		uint32_t buffer_size = 0;
		ktime_t startTime = ktime_get();

		if (msm_camera_tz_reg_ctrl.num_of_deffered_registers == 0 \|\|
		msm_camera_tz_reg_ctrl.num_of_deffered_registers >
		MSM_CAMERA_TZ_DEFERRED_SIZE) {
		pr_err("%s:%d - Bad parameters\n",
		__func__, __LINE__);
		return -EINVAL;
		}

		buffer_size = sizeof(uint32_t) *
		msm_camera_tz_reg_ctrl.num_of_deffered_registers;
		offsets = kzalloc(buffer_size, GFP_KERNEL);
		if (!offsets)
		return -ENOMEM;

		data = kzalloc(buffer_size, GFP_KERNEL);
		if (!data) {
		kfree(offsets);
		return -ENOMEM;
		}

		for (index = 0;
		index < msm_camera_tz_reg_ctrl.num_of_deffered_registers;
		index++) {
		offsets[index] =
		msm_camera_tz_reg_ctrl.deferred_registers[index].offset;
		data[index] =
		msm_camera_tz_reg_ctrl.deferred_registers[index].data;
		}

		desc.arginfo = SCM_ARGS(6,
		SCM_VAL, SCM_VAL, SCM_RO, SCM_VAL, SCM_RO, SCM_VAL);
		desc.args[0] = region;
		desc.args[1] = msm_camera_tz_reg_ctrl.num_of_deffered_registers;
		desc.args[2] = SCM_BUFFER_PHYS(offsets);
		desc.args[3] = buffer_size;
		desc.args[4] = SCM_BUFFER_PHYS(data);
		desc.args[5] = buffer_size;

		dmac_flush_range(offsets, offsets +
		msm_camera_tz_reg_ctrl.num_of_deffered_registers);
		dmac_flush_range(data, data +
		msm_camera_tz_reg_ctrl.num_of_deffered_registers);
		rc = scm_call2(
		SCM_SIP_FNID(
		MSM_CAMERA_TZ_SVC_CAMERASS_CALL_ID,
		MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE_BULK),
		&desc);
		kfree(offsets);
		kfree(data);
		if (rc) {
		CDBG("SCM call %s failed - %d\n",
		msm_camera_tz_scm_call_name(
		MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE_BULK),
		rc);
		}

		CDBG("Done: rc=%d, region=%s, num_of=%d - %lluus\n", rc,
		msm_camera_tz_region_name(region),
		msm_camera_tz_reg_ctrl.num_of_deffered_registers,
		ktime_us_delta(ktime_get(), startTime));

		return rc;
		}

		static void msm_camera_tz_flush_deferred(void)
		{
		if (msm_camera_tz_reg_ctrl.num_of_deffered_registers) {
		int32_t rc = MSM_CAMERA_TZ_FAULT;
		uint32_t region = msm_camera_tz_reg_ctrl.deferred_region;
		uint32_t index;

		CDBG("Flush %d deffered registers for %s\n",
		msm_camera_tz_reg_ctrl.num_of_deffered_registers,
		msm_camera_tz_region_name(region));

		if (msm_camera_tz_is_secured(region) &&
		msm_camera_tz_get_tzbsp_status((1 <<
		MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE_BULK)))
		rc = msm_camera_tz_tzbsp_reg_write_bulk(region);
		if (rc && msm_camera_tz_is_secured(region) &&
		msm_camera_tz_get_tzbsp_status(
		(1 << MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE))) {
		for (index = 0; index <
		msm_camera_tz_reg_ctrl.num_of_deffered_registers;
		index++) {
		rc = msm_camera_tz_tzbsp_reg_write(
		msm_camera_tz_reg_ctrl.deferred_registers[
		index].data,
		msm_camera_tz_reg_ctrl.deferred_registers[
		index].offset,
		region);
		if (rc < MSM_CAMERA_TZ_OK) {
		CDBG("Failed to flush deffered ");
		CDBG("register: %08X, rc=%d\n",
		msm_camera_tz_reg_ctrl.deferred_registers[
		index].offset, rc);
		}
		}
		rc = MSM_CAMERA_TZ_OK;
		}
		msm_camera_tz_reg_ctrl.num_of_deffered_registers = 0;
		msm_camera_tz_reg_ctrl.deferred_region =
		MSM_CAMERA_TZ_IO_REGION_LAST;
		msm_camera_tz_reg_ctrl.deferred_base_addr = NULL;
		}
		}

		static int32_t msm_camera_tz_tzbsp_reg_read(uint32_t offset, uint32_t *data,
		enum msm_camera_tz_io_region_t region)
		{
		ktime_t startTime = ktime_get();
		struct scm_desc desc = {
		.args[0] = region,
		.args[1] = offset,
		.arginfo = SCM_ARGS(2),
		};

		int32_t rc = scm_call2(
		SCM_SIP_FNID(
		MSM_CAMERA_TZ_SVC_CAMERASS_CALL_ID,
		MSM_CAMERA_TZ_SVC_CAMERASS_REG_READ),
		&desc);
		if (rc)
		CDBG("SCM call %s failed - %d\n",
		msm_camera_tz_scm_call_name(
		MSM_CAMERA_TZ_SVC_CAMERASS_REG_READ),
		rc);
		else
		*data = desc.ret[0];

		CDBG("Done: rc=%d, region=%s, offset=0x%08X, data=0x%08X - %lluus\n",
		rc, msm_camera_tz_region_name(region),
		offset, *data,
		ktime_us_delta(ktime_get(), startTime));

		return rc;
		}

		uint32_t msm_camera_tz_r(void __iomem *base_addr, uint32_t offset,
		enum msm_camera_tz_io_region_t region)
		{
		uint32_t data = 0xDEADDEAD;

		if (msm_camera_tz_is_secured(region)) {
		int32_t rc = MSM_CAMERA_TZ_FAULT;

		msm_camera_tz_flush_deferred();
		if (msm_camera_tz_is_secured(region) &&
		msm_camera_tz_get_tzbsp_status(
		(1 << MSM_CAMERA_TZ_SVC_CAMERASS_REG_READ)))
		rc = msm_camera_tz_tzbsp_reg_read(offset, &data,
		region);
		return data;
		}
		data = msm_camera_io_r(base_addr + offset);

		return data;
		}

		static int32_t msm_camera_tz_tzbsp_reg_write(uint32_t data, uint32_t offset,
		enum msm_camera_tz_io_region_t region)
		{
		ktime_t startTime = ktime_get();
		struct scm_desc desc = {
		.args[0] = region,
		.args[1] = offset,
		.args[2] = data,
		.arginfo = SCM_ARGS(3),
		};

		int32_t rc = scm_call2(
		SCM_SIP_FNID(
		MSM_CAMERA_TZ_SVC_CAMERASS_CALL_ID,
		MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE),
		&desc);
		if (rc)
		CDBG("SCM call %s failed - %d\n",
		msm_camera_tz_scm_call_name(
		MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE),
		rc);

		CDBG("Done: rc=%d, region=%s, offset=0x%08X, data=0x%08X - %lluus\n",
		rc, msm_camera_tz_region_name(region),
		offset, data,
		ktime_us_delta(ktime_get(), startTime));

		return rc;
		}

		static void msm_camera_tz_write(uint32_t data,
		void __iomem *base_addr, uint32_t offset,
		enum msm_camera_tz_io_region_t region)
		{
		int32_t rc = MSM_CAMERA_TZ_FAULT;

		if (msm_camera_tz_reg_ctrl.num_of_deffered_registers > 0 &&
		msm_camera_tz_reg_ctrl.num_of_deffered_registers <
		MSM_CAMERA_TZ_DEFERRED_SIZE &&
		msm_camera_tz_reg_ctrl.deferred_region == region &&
		msm_camera_tz_reg_ctrl.deferred_region !=
		MSM_CAMERA_TZ_IO_REGION_LAST) {
		msm_camera_tz_w_deferred(data, base_addr, offset, region);
		msm_camera_tz_flush_deferred();
		} else {
		msm_camera_tz_flush_deferred();
		if (msm_camera_tz_is_secured(region) &&
		msm_camera_tz_get_tzbsp_status((1 <<
		MSM_CAMERA_TZ_SVC_CAMERASS_REG_WRITE)))
		rc = msm_camera_tz_tzbsp_reg_write(data, offset,
		region);
		}
		}

		void msm_camera_tz_w_mb(uint32_t data,
		void __iomem *base_addr, uint32_t offset,
		enum msm_camera_tz_io_region_t region)
		{
		if (msm_camera_tz_is_secured(region)) {
		CDBG("%s::W_MB(%d) - %pK + 0x%08X(0x%08X)\n",
		msm_camera_tz_region_name(region),
		msm_camera_tz_is_secured(region),
		base_addr, offset, data);

		msm_camera_tz_write(data, base_addr, offset, region);
		} else {
		msm_camera_io_w_mb(data, base_addr + offset);
		}
		}

		void msm_camera_tz_w(uint32_t data,
		void __iomem *base_addr, uint32_t offset,
		enum msm_camera_tz_io_region_t region)
		{
		if (msm_camera_tz_is_secured(region)) {
		CDBG("%s::W(%d) - %pK + 0x%08X(0x%08X)\n",
		msm_camera_tz_region_name(region),
		msm_camera_tz_is_secured(region),
		base_addr, offset, data);

		msm_camera_tz_write(data, base_addr, offset, region);
		} else {
		msm_camera_io_w(data, base_addr + offset);
		}
		}

		void msm_camera_tz_w_deferred(uint32_t data,
		void __iomem *base_addr, uint32_t offset,
		enum msm_camera_tz_io_region_t region)
		{
		if (msm_camera_tz_is_secured(region)) {
		CDBG("%s::W(%d) - %pK + 0x%08X(0x%08X)\n",
		msm_camera_tz_region_name(region),
		msm_camera_tz_is_secured(region),
		base_addr, offset, data);

		if ((msm_camera_tz_reg_ctrl.deferred_region != region &&
		msm_camera_tz_reg_ctrl.deferred_region !=
		MSM_CAMERA_TZ_IO_REGION_LAST) \|\|
		msm_camera_tz_reg_ctrl.num_of_deffered_registers >=
		MSM_CAMERA_TZ_DEFERRED_SIZE) {
		CDBG("Force flush deferred registers");
		msm_camera_tz_flush_deferred();
		}
		if (msm_camera_tz_reg_ctrl.num_of_deffered_registers == 0) {
		msm_camera_tz_reg_ctrl.deferred_region = region;
		msm_camera_tz_reg_ctrl.deferred_base_addr = base_addr;
		}
		msm_camera_tz_reg_ctrl.deferred_registers[
		msm_camera_tz_reg_ctrl.num_of_deffered_registers].offset =
		offset;
		msm_camera_tz_reg_ctrl.deferred_registers[
		msm_camera_tz_reg_ctrl.num_of_deffered_registers].data =
		data;
		msm_camera_tz_reg_ctrl.num_of_deffered_registers++;
		return;
		}
		msm_camera_io_w(data, base_addr + offset);
		}

		static int32_t msm_camera_tz_tzbsp_reset_hw_block(uint32_t mask,
		enum msm_camera_tz_io_region_t region)
		{
		uint32_t status = -1;
		ktime_t startTime = ktime_get();
		struct scm_desc desc = {
		.args[0] = region,
		.args[1] = mask,
		.arginfo = SCM_ARGS(2),
		};

		int32_t rc = scm_call2(
		SCM_SIP_FNID(
		MSM_CAMERA_TZ_SVC_CAMERASS_CALL_ID,
		MSM_CAMERA_TZ_SVC_CAMERASS_RESET_HW_BLOCK),
		&desc);
		if (rc) {
		CDBG("SCM call %s failed - %d\n",
		msm_camera_tz_scm_call_name(
		MSM_CAMERA_TZ_SVC_CAMERASS_RESET_HW_BLOCK),
		rc);
		status = rc;
		} else {
		status = desc.ret[0];
		CDBG("SCM call returned: %d\n", status);
		if (!status) {
		/* To emulate success by wait_for_completion_timeout
		* the return value should be > 0
		*/
		status = 1;
		}
		}

		CDBG("Done: staus=%d, region=%s - %lluus\n",
		status,
		msm_camera_tz_region_name(region),
		ktime_us_delta(ktime_get(), startTime));

		return status;
		}

		int32_t msm_camera_tz_reset_hw_block(
		uint32_t mask,
		enum msm_camera_tz_io_region_t region)
		{
		int32_t rc = MSM_CAMERA_TZ_FAULT;

		CDBG("%s\n", msm_camera_tz_region_name(region));

		if (msm_camera_tz_is_secured(region) && msm_camera_tz_get_tzbsp_status(
		(1 << MSM_CAMERA_TZ_SVC_CAMERASS_RESET_HW_BLOCK)))
		rc = msm_camera_tz_tzbsp_reset_hw_block(mask, region);

		/* 0 - timeout (error) */
		return rc;
		}

drivers/media/platform/msm/camera_v2/common/msm_camera_tz_util.h

+43 −2

Original line number	Diff line number	Diff line
		/* Copyright (c) 2016, 2018, The Linux Foundation. All rights reserved.
		/* Copyright (c) 2016, 2018-2019, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		@@ -28,6 +28,15 @@
		#define MSM_CAMERA_TZ_HW_BLOCK_ISP 0x0000000008
		#define MSM_CAMERA_TZ_HW_BLOCK_CPP 0x0000000010

		enum msm_camera_tz_io_region_t {
		MSM_CAMERA_TZ_IO_REGION_CSIDCORE0,
		MSM_CAMERA_TZ_IO_REGION_CSIDCORE1,
		MSM_CAMERA_TZ_IO_REGION_CSIDCORE2,
		MSM_CAMERA_TZ_IO_REGION_CSIDCORE3,

		MSM_CAMERA_TZ_IO_REGION_LAST
		};

		enum msm_camera_tz_cmd_id_t {
		MSM_CAMERA_TZ_CMD_NONE,
		MSM_CAMERA_TZ_CMD_GET_IF_VERSION,
		@@ -49,6 +58,10 @@ enum msm_camera_tz_cmd_id_t {
		MSM_CAMERA_TZ_CMD_CCI_UTIL,
		MSM_CAMERA_TZ_CMD_SET_MODE,
		MSM_CAMERA_TZ_CMD_FRAME_NOTIFICATION,
		MSM_CAMERA_TZ_CMD_REG_READ,
		MSM_CAMERA_TZ_CMD_REG_WRITE,
		MSM_CAMERA_TZ_CMD_REG_WRITE_BULK,
		MSM_CAMERA_TZ_CMD_RESET_HW_BLOCK,
		};

		enum msm_camera_tz_status_t {
		@@ -75,9 +88,37 @@ struct msm_camera_tz_generic_rsp_t {

		#pragma pack(pop, msm_camera_tz)

		/* Register IO virtualization IF */
		uint32_t msm_camera_tz_is_secured(
		enum msm_camera_tz_io_region_t region);
		uint32_t msm_camera_tz_secure(uint32_t is_secure);
		uint32_t msm_camera_tz_region_to_hw_block(
		enum msm_camera_tz_io_region_t region);

		int32_t msm_camera_tz_reset_hw_block(
		uint32_t mask,
		enum msm_camera_tz_io_region_t region);
		uint32_t msm_camera_tz_r(void __iomem *base_addr, uint32_t offset,
		enum msm_camera_tz_io_region_t region);
		void msm_camera_tz_w_mb(uint32_t data,
		void __iomem *base_addr, uint32_t offset,
		enum msm_camera_tz_io_region_t region);
		void msm_camera_tz_w(uint32_t data,
		void __iomem *base_addr, uint32_t offset,
		enum msm_camera_tz_io_region_t region);
		void msm_camera_tz_w_deferred(uint32_t data,
		void __iomem *base_addr, uint32_t offset,
		enum msm_camera_tz_io_region_t region);
		void msm_camera_tz_clear_tzbsp_status(void);

		void msm_camera_tz_dump(void __iomem *base_addr, int size, int enable,
		enum msm_camera_tz_io_region_t region);

		/* Security Mode IF */
		uint32_t msm_camera_tz_set_mode(
		uint32_t mode, uint32_t hw_block);

		/* Common TZ IF */
		struct qseecom_handle *msm_camera_tz_get_ta_handle(void);
		int32_t get_cmd_rsp_buffers(
		struct qseecom_handle *ta_qseecom_handle,
		@@ -88,4 +129,4 @@ int32_t msm_camera_tz_unload_ta(void);
		void msm_camera_tz_lock(void);
		void msm_camera_tz_unlock(void);

		#endif /* __MSM_CAMERA_TZ_UTIL_H */
		#endif

drivers/media/platform/msm/camera_v2/sensor/csid/msm_csid.c

+176 −60

File changed.

Preview size limit exceeded, changes collapsed.

include/media/msm_cam_sensor.h

+2 −1

Original line number	Diff line number	Diff line
		/* Copyright (c) 2018, The Linux Foundation. All rights reserved.
		/* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License version 2 and
		@@ -84,6 +84,7 @@ struct msm_camera_csid_params32 {
		uint32_t csi_clk;
		struct msm_camera_csid_lut_params32 lut_params;
		uint8_t csi_3p_sel;
		uint8_t is_secure;
		};

		struct msm_camera_csi2_params32 {

include/uapi/media/msm_camsensor_sdk.h

+3 −0

Original line number	Diff line number	Diff line
		@@ -52,6 +52,8 @@

		#define SENSOR_PROBE_WRITE

		#define SECURE_CAMERA

		enum msm_sensor_camera_id_t {
		CAMERA_0,
		CAMERA_1,
		@@ -352,6 +354,7 @@ struct msm_camera_csid_params {
		unsigned int csi_clk;
		struct msm_camera_csid_lut_params lut_params;
		unsigned char csi_3p_sel;
		unsigned char is_secure;
		};

		struct msm_camera_csid_testmode_parms {