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

Commit d4d36b5f authored by Charan Teja Reddy's avatar Charan Teja Reddy
Browse files

ion: add support for secure dma allocations 



Some targets need slave side secure buffers allocation using ION.
Add the support for the same.

Change-Id: I21489ea71fd7d2844c3bea1f4b701b3eb33cb355
Signed-off-by: default avatarCharan Teja Reddy <charante@codeaurora.org>
parent e15f923a

drivers/soc/qcom/secure_buffer.c

+153 −1
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2011 Google, Inc

 * Copyright (c) 2011-2017, The Linux Foundation. All rights reserved.

 * Copyright (c) 2011-2018, 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
@@ -25,12 +25,28 @@ 


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;
@@ -42,6 +58,129 @@ 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();



	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 %pK! 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(chunk_list_phys,

				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)
@@ -278,6 +417,19 @@ 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)

{

	/*

	 * if the version is < 1.1.0 then dynamic buffer allocation is

	 * not supported

	 */

	return (scm_get_feat_version(FEATURE_ID_CP) >=

			MAKE_CP_VERSION(1, 1, 0));

}



static int __init alloc_secure_shared_memory(void)

{

	int ret = 0;

drivers/staging/android/ion/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -3,4 +3,5 @@ obj-$(CONFIG_ION) += ion.o ion-ioctl.o ion_heap.o \ 
			ion_page_pool.o ion_system_heap.o \

			ion_carveout_heap.o ion_chunk_heap.o \

			ion_system_secure_heap.o ion_cma_heap.o \

			ion_secure_util.o msm/
 
			ion_secure_util.o ion_cma_secure_heap.o msm/

drivers/staging/android/ion/ion.h

+13 −0
Original line number Diff line number Diff line
@@ -43,6 +43,8 @@ 
#define ION_SECURE_DISPLAY_HEAP_NAME "secure_display"

#define ION_AUDIO_HEAP_NAME    "audio"



#define ION_IS_CACHED(__flags)  ((__flags) & ION_FLAG_CACHED)



/**

 * Debug feature. Make ION allocations DMA

 * ready to help identify clients who are wrongly
@@ -385,9 +387,20 @@ struct ion_heap *ion_chunk_heap_create(struct ion_platform_heap *heap_data); 
void ion_chunk_heap_destroy(struct ion_heap *heap);



#ifdef CONFIG_CMA

struct ion_heap *ion_secure_cma_heap_create(struct ion_platform_heap *data);

void ion_secure_cma_heap_destroy(struct ion_heap *heap);



struct ion_heap *ion_cma_heap_create(struct ion_platform_heap *data);

void ion_cma_heap_destroy(struct ion_heap *heap);

#else

static inline struct ion_heap

			*ion_secure_cma_heap_create(struct ion_platform_heap *h)

{

	return NULL;

}



static inline void ion_cma_heap_destroy(struct ion_heap *h) {}



static inline struct ion_heap *ion_cma_heap_create(struct ion_platform_heap *h)

{

	return NULL;

drivers/staging/android/ion/ion_cma_secure_heap.c

0 → 100644
+834 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/staging/android/ion/ion_heap.c

+6 −0
Original line number Diff line number Diff line
@@ -335,6 +335,9 @@ struct ion_heap *ion_heap_create(struct ion_platform_heap *heap_data) 
		heap = ion_chunk_heap_create(heap_data);

		break;

#ifdef CONFIG_CMA

	case (enum ion_heap_type)ION_HEAP_TYPE_SECURE_DMA:

		heap = ion_secure_cma_heap_create(heap_data);

		break;

	case ION_HEAP_TYPE_DMA:

		heap = ion_cma_heap_create(heap_data);

		break;
@@ -387,6 +390,9 @@ void ion_heap_destroy(struct ion_heap *heap) 
		ion_chunk_heap_destroy(heap);

		break;

#ifdef CONFIG_CMA

	case ION_HEAP_TYPE_SECURE_DMA:

		ion_secure_cma_heap_destroy(heap);

		break;

	case ION_HEAP_TYPE_DMA:

		ion_cma_heap_destroy(heap);

		break;