Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 95229ad0 authored by Patrick Daly's avatar Patrick Daly Committed by Gerrit - the friendly Code Review server
Browse files

soc: qcom: secure_buffer: Remove deprecated functions 



There are no remaining users of these functions. Remove them.

Change-Id: Ifef302a591248f48b6d38e7c8c8fa4cd0d9e7b5b
Signed-off-by: default avatarPatrick Daly <pdaly@codeaurora.org>
parent ce2da9be

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";