From 661992dfdfd3b84768ed506ce43378993bd7495d Mon Sep 17 00:00:00 2001 From: Jason-jh Lin Date: Wed, 29 May 2024 11:55:27 +0800 Subject: [PATCH] mediatek: Allocate secure buffer by DMA_HEAP_IOCTL_ALLOC 1. Allocate secure buffer from DMA_HEAP_IOCTL_ALLOC ,then using FD to create a GEM handle and close this FD. 2. Since the secure buffer doesn't allocate via DRM_IOCTL_MTK_GEM_CREATE, the DRM_MTK_GEM_CREATE_FLAG_RESTRICTED flag can be removed. It should be added in the code that calls drmModeAddFB2(). 3. Add mediatek_private_drv_data to store the dma_heap_fd in drv->priv, and also add mediatek_close() to close dma_heap_fd and free drv->priv when backend driver is closing. BUG=b:248609774 TEST=emerge-geralt minigbm Change-Id: I96df25580efe04f2c9a739b2d68de8837df091df Signed-off-by: Jason-jh Lin Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/minigbm/+/5581571 Reviewed-by: Jeffrey Kardatzke Commit-Queue: Jeffrey Kardatzke --- mediatek.c | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 66 insertions(+), 2 deletions(-) diff --git a/mediatek.c b/mediatek.c index 0f19544..693af78 100644 --- a/mediatek.c +++ b/mediatek.c @@ -10,9 +10,13 @@ #include #include #include +#if !defined(ANDROID) || (ANDROID_API_LEVEL >= 31 && defined(HAS_DMABUF_SYSTEM_HEAP)) +#include +#endif #include #include #include +#include #include #include #include @@ -67,6 +71,10 @@ #define USE_EXTRA_PADDING_FOR_YVU420 #endif +struct mediatek_private_drv_data { + int dma_heap_fd; +}; + struct mediatek_private_map_data { void *cached_addr; void *gem_addr; @@ -120,6 +128,16 @@ static bool is_video_yuv_format(uint32_t format) static int mediatek_init(struct driver *drv) { struct format_metadata metadata; + struct mediatek_private_drv_data *priv; + + priv = calloc(1, sizeof(*priv)); + if (!priv) { + drv_loge("Failed calloc private data, errno=%d\n", -errno); + return -errno; + } + + priv->dma_heap_fd = -1; + drv->priv = priv; drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats), &LINEAR_METADATA, @@ -199,6 +217,17 @@ static int mediatek_init(struct driver *drv) return drv_modify_linear_combinations(drv); } +static void mediatek_close(struct driver *drv) +{ + struct mediatek_private_drv_data *priv = (struct mediatek_private_drv_data *)drv->priv; + + if (priv->dma_heap_fd >= 0) + close(priv->dma_heap_fd); + + free(priv); + drv->priv = NULL; +} + static int mediatek_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint32_t height, uint32_t format, const uint64_t *modifiers, uint32_t count) @@ -329,8 +358,16 @@ static int mediatek_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint #endif } - /* For protected data buffer needs to be allocated from GEM */ + /* For protected data buffer needs to allocate from DMA_HEAP directly */ if (is_protected) { +#if !defined(ANDROID) || (ANDROID_API_LEVEL >= 31 && defined(HAS_DMABUF_SYSTEM_HEAP)) + int ret; + struct mediatek_private_drv_data *priv = (struct mediatek_private_drv_data *)bo->drv->priv; + struct dma_heap_allocation_data heap_data = { + .len = bo->meta.total_size, + .fd_flags = O_RDWR | O_CLOEXEC, + }; + if (format == DRM_FORMAT_P010) { /* * Adjust the size so we don't waste tons of space. This was allocated @@ -344,7 +381,33 @@ static int mediatek_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint bo->meta.offsets[1] = bo->meta.sizes[0]; bo->meta.total_size = bo->meta.total_size * 10 / 16; } - gem_create.flags |= DRM_MTK_GEM_CREATE_FLAG_RESTRICTED; + + if (priv->dma_heap_fd < 0) { + priv->dma_heap_fd = open("/dev/dma_heap/restricted_mtk_cma", O_RDWR | O_CLOEXEC); + if (priv->dma_heap_fd < 0) { + drv_loge("Failed opening secure CMA heap errno=%d\n", -errno); + return -errno; + } + } + + ret = ioctl(priv->dma_heap_fd, DMA_HEAP_IOCTL_ALLOC, &heap_data); + if (ret < 0) { + drv_loge("Failed allocating CMA buffer ret=%d\n", ret); + return ret; + } + + /* Create GEM handle for secure CMA and close FD here */ + ret = drmPrimeFDToHandle(bo->drv->fd, heap_data.fd, &bo->handle.u32); + close(heap_data.fd); + if (ret) { + drv_loge("Failed drmPrimeFDToHandle(fd:%d) ret=%d\n", heap_data.fd, ret); + return ret; + } +#else + drv_loge("Protected allocation not supported\n"); + return -1; +#endif + return 0; } /* @@ -559,6 +622,7 @@ static void mediatek_resolve_format_and_use_flags(struct driver *drv, uint32_t f const struct backend backend_mediatek = { .name = "mediatek", .init = mediatek_init, + .close = mediatek_close, .bo_create = mediatek_bo_create, .bo_create_with_modifiers = mediatek_bo_create_with_modifiers, .bo_destroy = drv_gem_bo_destroy,