path: root/target/linux/bcm27xx/patches-4.19/950-0598-staging-vcsm-cma-Rework-to-use-dma-APIs-not-CMA.patch

From e4cb138abe457a6ab9b98458660a1c8e548fab7f Mon Sep 17 00:00:00 2001
From: Dave Stevenson <dave.stevenson@raspberrypi.org>
Date: Mon, 1 Jul 2019 11:57:25 +0100
Subject: [PATCH] staging: vcsm-cma: Rework to use dma APIs, not CMA

Due to a misunderstanding of the DMA mapping APIs, I made
the wrong decision on how to implement this.

Rework to use dma_alloc_coherent instead of the CMA
API. This also allows it to be built as a module easily.

Signed-off-by: Dave Stevenson <dave.stevenson@raspberrypi.org>
---
 .../staging/vc04_services/vc-sm-cma/Kconfig   |   4 +-
 .../staging/vc04_services/vc-sm-cma/Makefile  |   2 +-
 .../staging/vc04_services/vc-sm-cma/vc_sm.c   | 291 ++++++++++--------
 .../staging/vc04_services/vc-sm-cma/vc_sm.h   |  13 +-
 .../vc04_services/vc-sm-cma/vc_sm_cma.c       |  98 ------
 .../vc04_services/vc-sm-cma/vc_sm_cma.h       |  39 ---
 6 files changed, 168 insertions(+), 279 deletions(-)
 delete mode 100644 drivers/staging/vc04_services/vc-sm-cma/vc_sm_cma.c
 delete mode 100644 drivers/staging/vc04_services/vc-sm-cma/vc_sm_cma.h

--- a/drivers/staging/vc04_services/vc-sm-cma/Kconfig
+++ b/drivers/staging/vc04_services/vc-sm-cma/Kconfig
@@ -1,6 +1,6 @@
 config BCM_VC_SM_CMA
-	bool "VideoCore Shared Memory (CMA) driver"
-	depends on BCM2835_VCHIQ && DMA_CMA
+	tristate "VideoCore Shared Memory (CMA) driver"
+	depends on BCM2835_VCHIQ
 	select RBTREE
 	select DMA_SHARED_BUFFER
 	help
--- a/drivers/staging/vc04_services/vc-sm-cma/Makefile
+++ b/drivers/staging/vc04_services/vc-sm-cma/Makefile
@@ -3,6 +3,6 @@ ccflags-y += -Idrivers/staging/vc04_serv
 ccflags-y += -D__VCCOREVER__=0
 
 vc-sm-cma-$(CONFIG_BCM_VC_SM_CMA) := \
-	vc_sm.o vc_sm_cma_vchi.o vc_sm_cma.o
+	vc_sm.o vc_sm_cma_vchi.o
 
 obj-$(CONFIG_BCM_VC_SM_CMA) += vc-sm-cma.o
--- a/drivers/staging/vc04_services/vc-sm-cma/vc_sm.c
+++ b/drivers/staging/vc04_services/vc-sm-cma/vc_sm.c
@@ -6,8 +6,8 @@
  * Dave Stevenson <dave.stevenson@raspberrypi.org>
  *
  * Based on vmcs_sm driver from Broadcom Corporation for some API,
- * and taking some code for CMA/dmabuf handling from the Android Ion
- * driver (Google/Linaro).
+ * and taking some code for buffer allocation and dmabuf handling from
+ * videobuf2.
  *
  *
  * This driver has 3 main uses:
@@ -52,7 +52,6 @@
 #include "vc_sm_cma_vchi.h"
 
 #include "vc_sm.h"
-#include "vc_sm_cma.h"
 #include "vc_sm_knl.h"
 #include <linux/broadcom/vc_sm_cma_ioctl.h>
 
@@ -89,7 +88,6 @@ struct sm_state_t {
 	struct miscdevice misc_dev;
 
 	struct sm_instance *sm_handle;	/* Handle for videocore service. */
-	struct cma *cma_heap;
 
 	spinlock_t kernelid_map_lock;	/* Spinlock protecting kernelid_map */
 	struct idr kernelid_map;
@@ -110,8 +108,9 @@ struct sm_state_t {
 
 struct vc_sm_dma_buf_attachment {
 	struct device *dev;
-	struct sg_table *table;
+	struct sg_table sg_table;
 	struct list_head list;
+	enum dma_data_direction	dma_dir;
 };
 
 /* ---- Private Variables ----------------------------------------------- */
@@ -202,9 +201,10 @@ static int vc_sm_cma_global_state_show(s
 					   resource->import.attach);
 				seq_printf(s, "           SGT          %p\n",
 					   resource->import.sgt);
+			} else {
+				seq_printf(s, "           SGT          %p\n",
+					   resource->alloc.sg_table);
 			}
-			seq_printf(s, "           SG_TABLE     %p\n",
-				   resource->sg_table);
 			seq_printf(s, "           DMA_ADDR     %pad\n",
 				   &resource->dma_addr);
 			seq_printf(s, "           VC_HANDLE     %08x\n",
@@ -296,8 +296,9 @@ static void vc_sm_vpu_free(struct vc_sm_
  */
 static void vc_sm_release_resource(struct vc_sm_buffer *buffer)
 {
-	pr_debug("[%s]: buffer %p (name %s, size %zu)\n",
-		 __func__, buffer, buffer->name, buffer->size);
+	pr_debug("[%s]: buffer %p (name %s, size %zu), imported %u\n",
+		 __func__, buffer, buffer->name, buffer->size,
+		 buffer->imported);
 
 	if (buffer->vc_handle) {
 		/* We've sent the unmap request but not had the response. */
@@ -313,8 +314,6 @@ static void vc_sm_release_resource(struc
 
 	/* Release the allocation (whether imported dmabuf or CMA allocation) */
 	if (buffer->imported) {
-		pr_debug("%s: Release imported dmabuf %p\n", __func__,
-			 buffer->import.dma_buf);
 		if (buffer->import.dma_buf)
 			dma_buf_put(buffer->import.dma_buf);
 		else
@@ -322,16 +321,8 @@ static void vc_sm_release_resource(struc
 			       __func__, buffer);
 		buffer->import.dma_buf = NULL;
 	} else {
-		if (buffer->sg_table) {
-			/* Our own allocation that we need to dma_unmap_sg */
-			dma_unmap_sg(&sm_state->pdev->dev,
-				     buffer->sg_table->sgl,
-				     buffer->sg_table->nents,
-				     DMA_BIDIRECTIONAL);
-		}
-		pr_debug("%s: Release our allocation\n", __func__);
-		vc_sm_cma_buffer_free(&buffer->alloc);
-		pr_debug("%s: Release our allocation - done\n", __func__);
+		dma_free_coherent(&sm_state->pdev->dev, buffer->size,
+				  buffer->cookie, buffer->dma_addr);
 	}
 
 
@@ -371,38 +362,6 @@ static struct vc_sm_privdata_t *vc_sm_cm
 	return file_data;
 }
 
-static struct sg_table *dup_sg_table(struct sg_table *table)
-{
-	struct sg_table *new_table;
-	int ret, i;
-	struct scatterlist *sg, *new_sg;
-
-	new_table = kzalloc(sizeof(*new_table), GFP_KERNEL);
-	if (!new_table)
-		return ERR_PTR(-ENOMEM);
-
-	ret = sg_alloc_table(new_table, table->nents, GFP_KERNEL);
-	if (ret) {
-		kfree(new_table);
-		return ERR_PTR(ret);
-	}
-
-	new_sg = new_table->sgl;
-	for_each_sg(table->sgl, sg, table->nents, i) {
-		memcpy(new_sg, sg, sizeof(*sg));
-		sg->dma_address = 0;
-		new_sg = sg_next(new_sg);
-	}
-
-	return new_table;
-}
-
-static void free_duped_table(struct sg_table *table)
-{
-	sg_free_table(table);
-	kfree(table);
-}
-
 /* Dma buf operations for use with our own allocations */
 
 static int vc_sm_dma_buf_attach(struct dma_buf *dmabuf,
@@ -410,28 +369,45 @@ static int vc_sm_dma_buf_attach(struct d
 
 {
 	struct vc_sm_dma_buf_attachment *a;
-	struct sg_table *table;
+	struct sg_table *sgt;
 	struct vc_sm_buffer *buf = dmabuf->priv;
+	struct scatterlist *rd, *wr;
+	int ret, i;
 
 	a = kzalloc(sizeof(*a), GFP_KERNEL);
 	if (!a)
 		return -ENOMEM;
 
-	table = dup_sg_table(buf->sg_table);
-	if (IS_ERR(table)) {
+	pr_debug("%s dmabuf %p attachment %p\n", __func__, dmabuf, attachment);
+
+	mutex_lock(&buf->lock);
+
+	INIT_LIST_HEAD(&a->list);
+
+	sgt = &a->sg_table;
+
+	/* Copy the buf->base_sgt scatter list to the attachment, as we can't
+	 * map the same scatter list to multiple attachments at the same time.
+	 */
+	ret = sg_alloc_table(sgt, buf->alloc.sg_table->orig_nents, GFP_KERNEL);
+	if (ret) {
 		kfree(a);
-		return PTR_ERR(table);
+		return -ENOMEM;
 	}
 
-	a->table = table;
-	INIT_LIST_HEAD(&a->list);
+	rd = buf->alloc.sg_table->sgl;
+	wr = sgt->sgl;
+	for (i = 0; i < sgt->orig_nents; ++i) {
+		sg_set_page(wr, sg_page(rd), rd->length, rd->offset);
+		rd = sg_next(rd);
+		wr = sg_next(wr);
+	}
 
+	a->dma_dir = DMA_NONE;
 	attachment->priv = a;
 
-	mutex_lock(&buf->lock);
 	list_add(&a->list, &buf->attachments);
 	mutex_unlock(&buf->lock);
-	pr_debug("%s dmabuf %p attachment %p\n", __func__, dmabuf, attachment);
 
 	return 0;
 }
@@ -441,9 +417,20 @@ static void vc_sm_dma_buf_detach(struct
 {
 	struct vc_sm_dma_buf_attachment *a = attachment->priv;
 	struct vc_sm_buffer *buf = dmabuf->priv;
+	struct sg_table *sgt;
 
 	pr_debug("%s dmabuf %p attachment %p\n", __func__, dmabuf, attachment);
-	free_duped_table(a->table);
+	if (!a)
+		return;
+
+	sgt = &a->sg_table;
+
+	/* release the scatterlist cache */
+	if (a->dma_dir != DMA_NONE)
+		dma_unmap_sg(attachment->dev, sgt->sgl, sgt->orig_nents,
+			     a->dma_dir);
+	sg_free_table(sgt);
+
 	mutex_lock(&buf->lock);
 	list_del(&a->list);
 	mutex_unlock(&buf->lock);
@@ -455,13 +442,38 @@ static struct sg_table *vc_sm_map_dma_bu
 					  enum dma_data_direction direction)
 {
 	struct vc_sm_dma_buf_attachment *a = attachment->priv;
+	/* stealing dmabuf mutex to serialize map/unmap operations */
+	struct mutex *lock = &attachment->dmabuf->lock;
 	struct sg_table *table;
 
-	table = a->table;
+	mutex_lock(lock);
+	pr_debug("%s attachment %p\n", __func__, attachment);
+	table = &a->sg_table;
+
+	/* return previously mapped sg table */
+	if (a->dma_dir == direction) {
+		mutex_unlock(lock);
+		return table;
+	}
+
+	/* release any previous cache */
+	if (a->dma_dir != DMA_NONE) {
+		dma_unmap_sg(attachment->dev, table->sgl, table->orig_nents,
+			     a->dma_dir);
+		a->dma_dir = DMA_NONE;
+	}
+
+	/* mapping to the client with new direction */
+	table->nents = dma_map_sg(attachment->dev, table->sgl,
+				  table->orig_nents, direction);
+	if (!table->nents) {
+		pr_err("failed to map scatterlist\n");
+		mutex_unlock(lock);
+		return ERR_PTR(-EIO);
+	}
 
-	if (!dma_map_sg(attachment->dev, table->sgl, table->nents,
-			direction))
-		return ERR_PTR(-ENOMEM);
+	a->dma_dir = direction;
+	mutex_unlock(lock);
 
 	pr_debug("%s attachment %p\n", __func__, attachment);
 	return table;
@@ -478,41 +490,26 @@ static void vc_sm_unmap_dma_buf(struct d
 static int vc_sm_dmabuf_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma)
 {
 	struct vc_sm_buffer *buf = dmabuf->priv;
-	struct sg_table *table = buf->sg_table;
-	unsigned long addr = vma->vm_start;
-	unsigned long offset = vma->vm_pgoff * PAGE_SIZE;
-	struct scatterlist *sg;
-	int i;
-	int ret = 0;
+	int ret;
 
 	pr_debug("%s dmabuf %p, buf %p, vm_start %08lX\n", __func__, dmabuf,
-		 buf, addr);
+		 buf, vma->vm_start);
 
 	mutex_lock(&buf->lock);
 
 	/* now map it to userspace */
-	for_each_sg(table->sgl, sg, table->nents, i) {
-		struct page *page = sg_page(sg);
-		unsigned long remainder = vma->vm_end - addr;
-		unsigned long len = sg->length;
+	vma->vm_pgoff = 0;
 
-		if (offset >= sg->length) {
-			offset -= sg->length;
-			continue;
-		} else if (offset) {
-			page += offset / PAGE_SIZE;
-			len = sg->length - offset;
-			offset = 0;
-		}
-		len = min(len, remainder);
-		ret = remap_pfn_range(vma, addr, page_to_pfn(page), len,
-				      vma->vm_page_prot);
-		if (ret)
-			break;
-		addr += len;
-		if (addr >= vma->vm_end)
-			break;
+	ret = dma_mmap_coherent(&sm_state->pdev->dev, vma, buf->cookie,
+				buf->dma_addr, buf->size);
+
+	if (ret) {
+		pr_err("Remapping memory failed, error: %d\n", ret);
+		return ret;
 	}
+
+	vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
+
 	mutex_unlock(&buf->lock);
 
 	if (ret)
@@ -570,8 +567,8 @@ static int vc_sm_dma_buf_begin_cpu_acces
 	mutex_lock(&buf->lock);
 
 	list_for_each_entry(a, &buf->attachments, list) {
-		dma_sync_sg_for_cpu(a->dev, a->table->sgl, a->table->nents,
-				    direction);
+		dma_sync_sg_for_cpu(a->dev, a->sg_table.sgl,
+				    a->sg_table.nents, direction);
 	}
 	mutex_unlock(&buf->lock);
 
@@ -593,8 +590,8 @@ static int vc_sm_dma_buf_end_cpu_access(
 	mutex_lock(&buf->lock);
 
 	list_for_each_entry(a, &buf->attachments, list) {
-		dma_sync_sg_for_device(a->dev, a->table->sgl, a->table->nents,
-				       direction);
+		dma_sync_sg_for_device(a->dev, a->sg_table.sgl,
+				       a->sg_table.nents, direction);
 	}
 	mutex_unlock(&buf->lock);
 
@@ -625,7 +622,9 @@ static const struct dma_buf_ops dma_buf_
 	.map = vc_sm_dma_buf_kmap,
 	.unmap = vc_sm_dma_buf_kunmap,
 };
+
 /* Dma_buf operations for chaining through to an imported dma_buf */
+
 static
 int vc_sm_import_dma_buf_attach(struct dma_buf *dmabuf,
 				struct dma_buf_attachment *attachment)
@@ -819,7 +818,7 @@ vc_sm_cma_import_dmabuf_internal(struct
 
 	import.type = VC_SM_ALLOC_NON_CACHED;
 	dma_addr = sg_dma_address(sgt->sgl);
-	import.addr = (uint32_t)dma_addr;
+	import.addr = (u32)dma_addr;
 	if ((import.addr & 0xC0000000) != 0xC0000000) {
 		pr_err("%s: Expecting an uncached alias for dma_addr %pad\n",
 		       __func__, &dma_addr);
@@ -911,11 +910,12 @@ error:
 	return ret;
 }
 
-static int vc_sm_cma_vpu_alloc(u32 size, uint32_t align, const char *name,
+static int vc_sm_cma_vpu_alloc(u32 size, u32 align, const char *name,
 			       u32 mem_handle, struct vc_sm_buffer **ret_buffer)
 {
 	DEFINE_DMA_BUF_EXPORT_INFO(exp_info);
 	struct vc_sm_buffer *buffer = NULL;
+	struct sg_table *sgt;
 	int aligned_size;
 	int ret = 0;
 
@@ -938,23 +938,34 @@ static int vc_sm_cma_vpu_alloc(u32 size,
 	 */
 	mutex_lock(&buffer->lock);
 
-	if (vc_sm_cma_buffer_allocate(sm_state->cma_heap, &buffer->alloc,
-				      aligned_size)) {
-		pr_err("[%s]: cma alloc of %d bytes failed\n",
+	buffer->cookie = dma_alloc_coherent(&sm_state->pdev->dev,
+					    aligned_size, &buffer->dma_addr,
+					    GFP_KERNEL);
+	if (!buffer->cookie) {
+		pr_err("[%s]: dma_alloc_coherent alloc of %d bytes failed\n",
 		       __func__, aligned_size);
 		ret = -ENOMEM;
 		goto error;
 	}
-	buffer->sg_table = buffer->alloc.sg_table;
 
-	pr_debug("[%s]: cma alloc of %d bytes success\n",
+	pr_debug("[%s]: alloc of %d bytes success\n",
 		 __func__, aligned_size);
 
-	if (dma_map_sg(&sm_state->pdev->dev, buffer->sg_table->sgl,
-		       buffer->sg_table->nents, DMA_BIDIRECTIONAL) <= 0) {
-		pr_err("[%s]: dma_map_sg failed\n", __func__);
+	sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
+	if (!sgt) {
+		ret = -ENOMEM;
+		goto error;
+	}
+
+	ret = dma_get_sgtable(&sm_state->pdev->dev, sgt, buffer->cookie,
+			      buffer->dma_addr, buffer->size);
+	if (ret < 0) {
+		pr_err("failed to get scatterlist from DMA API\n");
+		kfree(sgt);
+		ret = -ENOMEM;
 		goto error;
 	}
+	buffer->alloc.sg_table = sgt;
 
 	INIT_LIST_HEAD(&buffer->attachments);
 
@@ -971,10 +982,10 @@ static int vc_sm_cma_vpu_alloc(u32 size,
 		ret = PTR_ERR(buffer->dma_buf);
 		goto error;
 	}
-	buffer->dma_addr = (uint32_t)sg_dma_address(buffer->sg_table->sgl);
+	buffer->dma_addr = (u32)sg_dma_address(buffer->alloc.sg_table->sgl);
 	if ((buffer->dma_addr & 0xC0000000) != 0xC0000000) {
-		pr_err("%s: Expecting an uncached alias for dma_addr %pad\n",
-		       __func__, &buffer->dma_addr);
+		pr_warn_once("%s: Expecting an uncached alias for dma_addr %pad\n",
+			     __func__, &buffer->dma_addr);
 		buffer->dma_addr |= 0xC0000000;
 	}
 	buffer->private = sm_state->vpu_allocs;
@@ -1145,6 +1156,7 @@ int vc_sm_cma_ioctl_alloc(struct vc_sm_p
 	struct vc_sm_import import = { 0 };
 	struct vc_sm_import_result result = { 0 };
 	struct dma_buf *dmabuf = NULL;
+	struct sg_table *sgt;
 	int aligned_size;
 	int ret = 0;
 	int status;
@@ -1162,18 +1174,13 @@ int vc_sm_cma_ioctl_alloc(struct vc_sm_p
 		goto error;
 	}
 
-	if (vc_sm_cma_buffer_allocate(sm_state->cma_heap, &buffer->alloc,
-				      aligned_size)) {
-		pr_err("[%s]: cma alloc of %d bytes failed\n",
+	buffer->cookie = dma_alloc_coherent(&sm_state->pdev->dev,
+					    aligned_size,
+					    &buffer->dma_addr,
+					    GFP_KERNEL);
+	if (!buffer->cookie) {
+		pr_err("[%s]: dma_alloc_coherent alloc of %d bytes failed\n",
 		       __func__, aligned_size);
-		kfree(buffer);
-		return -ENOMEM;
-	}
-	buffer->sg_table = buffer->alloc.sg_table;
-
-	if (dma_map_sg(&sm_state->pdev->dev, buffer->sg_table->sgl,
-		       buffer->sg_table->nents, DMA_BIDIRECTIONAL) <= 0) {
-		pr_err("[%s]: dma_map_sg failed\n", __func__);
 		ret = -ENOMEM;
 		goto error;
 	}
@@ -1204,7 +1211,7 @@ int vc_sm_cma_ioctl_alloc(struct vc_sm_p
 	}
 	buffer->dma_buf = dmabuf;
 
-	import.addr = (uint32_t)sg_dma_address(buffer->sg_table->sgl);
+	import.addr = buffer->dma_addr;
 	import.size = aligned_size;
 	import.kernel_id = get_kernel_id(buffer);
 
@@ -1229,10 +1236,25 @@ int vc_sm_cma_ioctl_alloc(struct vc_sm_p
 	buffer->private = private;
 	buffer->vc_handle = result.res_handle;
 	buffer->size = import.size;
-	buffer->dma_addr = import.addr;
 	buffer->vpu_state = VPU_MAPPED;
 	buffer->kernel_id = import.kernel_id;
-	//buffer->res_cached = ioparam->cached;
+
+	sgt = kmalloc(sizeof(*sgt), GFP_KERNEL);
+	if (!sgt) {
+		ret = -ENOMEM;
+		goto error;
+	}
+
+	ret = dma_get_sgtable(&sm_state->pdev->dev, sgt, buffer->cookie,
+			      buffer->dma_addr, buffer->size);
+	if (ret < 0) {
+		/* FIXME: error handling */
+		pr_err("failed to get scatterlist from DMA API\n");
+		kfree(sgt);
+		ret = -ENOMEM;
+		goto error;
+	}
+	buffer->alloc.sg_table = sgt;
 
 	fd = dma_buf_fd(dmabuf, O_CLOEXEC);
 	if (fd < 0)
@@ -1250,11 +1272,19 @@ int vc_sm_cma_ioctl_alloc(struct vc_sm_p
 	return 0;
 
 error:
-	if (buffer) {
-		pr_err("[%s]: something failed - cleanup. ret %d\n", __func__,
-		       ret);
+	pr_err("[%s]: something failed - cleanup. ret %d\n", __func__, ret);
 
+	if (dmabuf) {
+		/* dmabuf has been exported, therefore allow dmabuf cleanup to
+		 * deal with this
+		 */
 		dma_buf_put(dmabuf);
+	} else {
+		/* No dmabuf, therefore just free the buffer here */
+		if (buffer->cookie)
+			dma_free_coherent(&sm_state->pdev->dev, buffer->size,
+					  buffer->cookie, buffer->dma_addr);
+		kfree(buffer);
 	}
 	return ret;
 }
@@ -1527,13 +1557,6 @@ static void vc_sm_connected_init(void)
 
 	pr_info("[%s]: start\n", __func__);
 
-	vc_sm_cma_add_heaps(&sm_state->cma_heap);
-	if (!sm_state->cma_heap) {
-		pr_err("[%s]: failed to initialise CMA heap\n",
-		       __func__);
-		return;
-	}
-
 	/*
 	 * Initialize and create a VCHI connection for the shared memory service
 	 * running on videocore.
--- a/drivers/staging/vc04_services/vc-sm-cma/vc_sm.h
+++ b/drivers/staging/vc04_services/vc-sm-cma/vc_sm.h
@@ -21,8 +21,6 @@
 #include <linux/types.h>
 #include <linux/miscdevice.h>
 
-#include "vc_sm_cma.h"
-
 #define VC_SM_MAX_NAME_LEN 32
 
 enum vc_sm_vpu_mapping_state {
@@ -31,6 +29,12 @@ enum vc_sm_vpu_mapping_state {
 	VPU_UNMAPPING
 };
 
+struct vc_sm_alloc_data {
+	unsigned long num_pages;
+	void *priv_virt;
+	struct sg_table *sg_table;
+};
+
 struct vc_sm_imported {
 	struct dma_buf *dma_buf;
 	struct dma_buf_attachment *attach;
@@ -56,8 +60,6 @@ struct vc_sm_buffer {
 	int in_use:1;	/* Kernel is still using this resource */
 	int imported:1;	/* Imported dmabuf */
 
-	struct sg_table *sg_table;
-
 	enum vc_sm_vpu_mapping_state vpu_state;
 	u32 vc_handle;	/* VideoCore handle for this buffer */
 	int vpu_allocated;	/*
@@ -69,11 +71,12 @@ struct vc_sm_buffer {
 	/* DMABUF related fields */
 	struct dma_buf *dma_buf;
 	dma_addr_t dma_addr;
+	void *cookie;
 
 	struct vc_sm_privdata_t *private;
 
 	union {
-		struct vc_sm_cma_alloc_data alloc;
+		struct vc_sm_alloc_data alloc;
 		struct vc_sm_imported import;
 	};
 };
--- a/drivers/staging/vc04_services/vc-sm-cma/vc_sm_cma.c
+++ /dev/null
@@ -1,98 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/*
- * VideoCore Shared Memory CMA allocator
- *
- * Copyright: 2018, Raspberry Pi (Trading) Ltd
- *
- * Based on the Android ION allocator
- * Copyright (C) Linaro 2012
- * Author: <benjamin.gaignard@linaro.org> for ST-Ericsson.
- *
- */
-
-#include <linux/slab.h>
-#include <linux/errno.h>
-#include <linux/err.h>
-#include <linux/cma.h>
-#include <linux/scatterlist.h>
-
-#include "vc_sm_cma.h"
-
-/* CMA heap operations functions */
-int vc_sm_cma_buffer_allocate(struct cma *cma_heap,
-			      struct vc_sm_cma_alloc_data *buffer,
-			      unsigned long len)
-{
-	/* len should already be page aligned */
-	unsigned long num_pages = len / PAGE_SIZE;
-	struct sg_table *table;
-	struct page *pages;
-	int ret;
-
-	pages = cma_alloc(cma_heap, num_pages, 0, GFP_KERNEL);
-	if (!pages)
-		return -ENOMEM;
-
-	table = kmalloc(sizeof(*table), GFP_KERNEL);
-	if (!table)
-		goto err;
-
-	ret = sg_alloc_table(table, 1, GFP_KERNEL);
-	if (ret)
-		goto free_mem;
-
-	sg_set_page(table->sgl, pages, len, 0);
-
-	buffer->priv_virt = pages;
-	buffer->sg_table = table;
-	buffer->cma_heap = cma_heap;
-	buffer->num_pages = num_pages;
-	return 0;
-
-free_mem:
-	kfree(table);
-err:
-	cma_release(cma_heap, pages, num_pages);
-	return -ENOMEM;
-}
-
-void vc_sm_cma_buffer_free(struct vc_sm_cma_alloc_data *buffer)
-{
-	struct cma *cma_heap = buffer->cma_heap;
-	struct page *pages = buffer->priv_virt;
-
-	/* release memory */
-	if (cma_heap)
-		cma_release(cma_heap, pages, buffer->num_pages);
-
-	/* release sg table */
-	if (buffer->sg_table) {
-		sg_free_table(buffer->sg_table);
-		kfree(buffer->sg_table);
-		buffer->sg_table = NULL;
-	}
-}
-
-int __vc_sm_cma_add_heaps(struct cma *cma, void *priv)
-{
-	struct cma **heap = (struct cma **)priv;
-	const char *name = cma_get_name(cma);
-
-	if (!(*heap)) {
-		phys_addr_t phys_addr = cma_get_base(cma);
-
-		pr_debug("%s: Adding cma heap %s (start %pap, size %lu) for use by vcsm\n",
-			 __func__, name, &phys_addr, cma_get_size(cma));
-		*heap = cma;
-	} else {
-		pr_err("%s: Ignoring heap %s as already set\n",
-		       __func__, name);
-	}
-
-	return 0;
-}
-
-void vc_sm_cma_add_heaps(struct cma **cma_heap)
-{
-	cma_for_each_area(__vc_sm_cma_add_heaps, cma_heap);
-}
--- a/drivers/staging/vc04_services/vc-sm-cma/vc_sm_cma.h
+++ /dev/null
@@ -1,39 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-
-/*
- * VideoCore Shared Memory CMA allocator
- *
- * Copyright: 2018, Raspberry Pi (Trading) Ltd
- *
- * Based on the Android ION allocator
- * Copyright (C) Linaro 2012
- * Author: <benjamin.gaignard@linaro.org> for ST-Ericsson.
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- */
-#ifndef VC_SM_CMA_H
-#define VC_SM_CMA_H
-
-struct vc_sm_cma_alloc_data {
-	struct cma *cma_heap;
-	unsigned long num_pages;
-	void *priv_virt;
-	struct sg_table *sg_table;
-};
-
-int vc_sm_cma_buffer_allocate(struct cma *cma_heap,
-			      struct vc_sm_cma_alloc_data *buffer,
-			      unsigned long len);
-void vc_sm_cma_buffer_free(struct vc_sm_cma_alloc_data *buffer);
-
-void vc_sm_cma_add_heaps(struct cma **cma_heap);
-
-#endif