Merge "soc: qcom: secure_buffer: Remove deprecated functions" (a1c247b5) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/soc/qcom/secure_buffer.c

+0 −162

Original line number	Diff line number	Diff line
		@@ -25,29 +25,12 @@

		DEFINE_MUTEX(secure_buffer_mutex);

		struct cp2_mem_chunks {
		u32 chunk_list;
		u32 chunk_list_size;
		u32 chunk_size;
		} __attribute__ ((__packed__));

		struct cp2_lock_req {
		struct cp2_mem_chunks chunks;
		u32 mem_usage;
		u32 lock;
		} __attribute__ ((__packed__));


		struct mem_prot_info {
		phys_addr_t addr;
		u64 size;
		};

		#define MEM_PROT_ASSIGN_ID 0x16
		#define MEM_PROTECT_LOCK_ID2 0x0A
		#define MEM_PROTECT_LOCK_ID2_FLAT 0x11
		#define V2_CHUNK_SIZE SZ_1M
		#define FEATURE_ID_CP 12

		struct dest_vm_and_perm_info {
		u32 vm;
		@@ -59,137 +42,6 @@ struct dest_vm_and_perm_info {
		static void *qcom_secure_mem;
		#define QCOM_SECURE_MEM_SIZE (512*1024)

		static int secure_buffer_change_chunk(u32 chunks,
		u32 nchunks,
		u32 chunk_size,
		int lock)
		{
		struct cp2_lock_req request;
		u32 resp;
		int ret;
		struct scm_desc desc = {0};

		desc.args[0] = request.chunks.chunk_list = chunks;
		desc.args[1] = request.chunks.chunk_list_size = nchunks;
		desc.args[2] = request.chunks.chunk_size = chunk_size;
		/* Usage is now always 0 */
		desc.args[3] = request.mem_usage = 0;
		desc.args[4] = request.lock = lock;
		desc.args[5] = 0;
		desc.arginfo = SCM_ARGS(6, SCM_RW, SCM_VAL, SCM_VAL, SCM_VAL, SCM_VAL,
		SCM_VAL);

		kmap_flush_unused();
		kmap_atomic_flush_unused();

		if (!is_scm_armv8()) {
		ret = scm_call(SCM_SVC_MP, MEM_PROTECT_LOCK_ID2,
		&request, sizeof(request), &resp, sizeof(resp));
		} else {
		ret = scm_call2(SCM_SIP_FNID(SCM_SVC_MP,
		MEM_PROTECT_LOCK_ID2_FLAT), &desc);
		resp = desc.ret[0];
		}

		return ret;
		}



		static int secure_buffer_change_table(struct sg_table *table, int lock)
		{
		int i, j;
		int ret = -EINVAL;
		u32 *chunk_list;
		struct scatterlist *sg;

		for_each_sg(table->sgl, sg, table->nents, i) {
		int nchunks;
		int size = sg->length;
		int chunk_list_len;
		phys_addr_t chunk_list_phys;

		/*
		* This should theoretically be a phys_addr_t but the protocol
		* indicates this should be a u32.
		*/
		u32 base;
		u64 tmp = sg_dma_address(sg);

		WARN((tmp >> 32) & 0xffffffff,
		"%s: there are ones in the upper 32 bits of the sg at %p! They will be truncated! Address: 0x%llx\n",
		__func__, sg, tmp);
		if (unlikely(!size \|\| (size % V2_CHUNK_SIZE))) {
		WARN(1,
		"%s: chunk %d has invalid size: 0x%x. Must be a multiple of 0x%x\n",
		__func__, i, size, V2_CHUNK_SIZE);
		return -EINVAL;
		}

		base = (u32)tmp;

		nchunks = size / V2_CHUNK_SIZE;
		chunk_list_len = sizeof(u32)*nchunks;

		chunk_list = kzalloc(chunk_list_len, GFP_KERNEL);

		if (!chunk_list)
		return -ENOMEM;

		chunk_list_phys = virt_to_phys(chunk_list);
		for (j = 0; j < nchunks; j++)
		chunk_list[j] = base + j * V2_CHUNK_SIZE;

		/*
		* Flush the chunk list before sending the memory to the
		* secure environment to ensure the data is actually present
		* in RAM
		*/
		dmac_flush_range(chunk_list, chunk_list + chunk_list_len);

		ret = secure_buffer_change_chunk(virt_to_phys(chunk_list),
		nchunks, V2_CHUNK_SIZE, lock);

		if (!ret) {
		/*
		* Set or clear the private page flag to communicate the
		* status of the chunk to other entities
		*/
		if (lock)
		SetPagePrivate(sg_page(sg));
		else
		ClearPagePrivate(sg_page(sg));
		}

		kfree(chunk_list);
		}

		return ret;
		}

		int msm_secure_table(struct sg_table *table)
		{
		int ret;

		mutex_lock(&secure_buffer_mutex);
		ret = secure_buffer_change_table(table, 1);
		mutex_unlock(&secure_buffer_mutex);

		return ret;

		}

		int msm_unsecure_table(struct sg_table *table)
		{
		int ret;

		mutex_lock(&secure_buffer_mutex);
		ret = secure_buffer_change_table(table, 0);
		mutex_unlock(&secure_buffer_mutex);
		return ret;

		}

		static struct dest_vm_and_perm_info *
		populate_dest_info(int dest_vmids, int nelements, int dest_perms,
		size_t *size_in_bytes)
		@@ -426,20 +278,6 @@ const char *msm_secure_vmid_to_string(int secure_vmid)
		}
		}

		#define MAKE_CP_VERSION(major, minor, patch) \
		(((major & 0x3FF) << 22) \| ((minor & 0x3FF) << 12) \| (patch & 0xFFF))

		bool msm_secure_v2_is_supported(void)
		{
		int version = scm_get_feat_version(FEATURE_ID_CP);

		/*
		* if the version is < 1.1.0 then dynamic buffer allocation is
		* not supported
		*/
		return version >= MAKE_CP_VERSION(1, 1, 0);
		}

		static int __init alloc_secure_shared_memory(void)
		{
		int ret = 0;

include/soc/qcom/secure_buffer.h

+0 −15

Original line number	Diff line number	Diff line
		@@ -50,8 +50,6 @@ enum vmid {
		#define PERM_EXEC 0x1

		#ifdef CONFIG_QCOM_SECURE_BUFFER
		int msm_secure_table(struct sg_table *table);
		int msm_unsecure_table(struct sg_table *table);
		int hyp_assign_table(struct sg_table *table,
		u32 *source_vm_list, int source_nelems,
		int dest_vmids, int dest_perms,
		@@ -59,17 +57,8 @@ int hyp_assign_table(struct sg_table *table,
		extern int hyp_assign_phys(phys_addr_t addr, u64 size,
		u32 *source_vmlist, int source_nelems,
		int dest_vmids, int dest_perms, int dest_nelems);
		bool msm_secure_v2_is_supported(void);
		const char *msm_secure_vmid_to_string(int secure_vmid);
		#else
		static inline int msm_secure_table(struct sg_table *table)
		{
		return -EINVAL;
		}
		static inline int msm_unsecure_table(struct sg_table *table)
		{
		return -EINVAL;
		}
		static inline int hyp_assign_table(struct sg_table *table,
		u32 *source_vm_list, int source_nelems,
		int dest_vmids, int dest_perms,
		@@ -85,10 +74,6 @@ static inline int hyp_assign_phys(phys_addr_t addr, u64 size,
		return -EINVAL;
		}

		static inline bool msm_secure_v2_is_supported(void)
		{
		return false;
		}
		static inline const char *msm_secure_vmid_to_string(int secure_vmid)
		{
		return "N/A";