1/*
2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "display_gralloc_gbm.h"
17#include <cstdio>
18#include <unistd.h>
19#include <cerrno>
20#include <cinttypes>
21#include <climits>
22#include <cstring>
23#include <fcntl.h>
24#include <pthread.h>
25#include <sys/mman.h>
26#include <sys/ioctl.h>
27#include <xf86drm.h>
28#include <securec.h>
29#include <linux/dma-buf.h>
30#include "drm_fourcc.h"
31#include "hisilicon_drm.h"
32#include "hi_gbm.h"
33#include "hdf_dlist.h"
34#include "display_gralloc_private.h"
35#include "display_log.h"
36#include "v1_0/display_composer_type.h"
37
38namespace OHOS {
39namespace HDI {
40namespace DISPLAY {
41using namespace OHOS::HDI::Display::Composer::V1_0;
42using namespace OHOS::HDI::Display::Buffer::V1_0;
43
44const char *g_drmFileNode = "/dev/dri/renderD128";
45static GrallocManager *g_grallocManager = nullptr;
46static pthread_mutex_t g_lock;
47
48using PixelFormatConvertTbl = struct {
49    uint32_t drmFormat;
50    PixelFormat pixFormat;
51};
52
53using ValueStrMap = struct {
54    uint32_t value;
55    const char *str;
56};
57
58static GrallocManager *GetGrallocManager(void)
59{
60    if (g_grallocManager == nullptr) {
61        g_grallocManager = (GrallocManager *)malloc(sizeof(GrallocManager));
62        errno_t eok = memset_s(g_grallocManager, sizeof(GrallocManager), 0, sizeof(GrallocManager));
63        if (eok != EOK) {
64            DISPLAY_LOGE("memset_s failed");
65        }
66        if (g_grallocManager == nullptr) {
67            DISPLAY_LOGE("gralloc manager malloc failed");
68        }
69    }
70    return g_grallocManager;
71}
72
73const char *GetPixelFmtStr(PixelFormat format)
74{
75    static const ValueStrMap PIXEL_STR_MAPS[] = {
76        {PIXEL_FMT_CLUT8, "PIXEL_FMT_CLUT8"}, {PIXEL_FMT_CLUT1, "PIXEL_FMT_CLUT1"},
77        {PIXEL_FMT_CLUT4, "PIXEL_FMT_CLUT4"}, {PIXEL_FMT_RGB_565, "PIXEL_FMT_RGB_565"},
78        {PIXEL_FMT_RGBA_5658, "IXEL_FMT_RGBA_5658"}, {PIXEL_FMT_RGBX_4444, "PIXEL_FMT_RGBX_4444"},
79        {PIXEL_FMT_RGBA_4444, "PIXEL_FMT_RGBA_4444"}, {PIXEL_FMT_RGB_444, "PIXEL_FMT_RGB_444"},
80        {PIXEL_FMT_RGBX_5551, "PIXEL_FMT_RGBX_5551"}, {PIXEL_FMT_RGBA_5551, "PIXEL_FMT_RGBA_5551"},
81        {PIXEL_FMT_RGB_555, "PIXEL_FMT_RGB_555"}, {PIXEL_FMT_RGBX_8888, "PIXEL_FMT_RGBX_8888"},
82        {PIXEL_FMT_RGBA_8888, "PIXEL_FMT_RGBA_8888"}, {PIXEL_FMT_RGB_888, "PIXEL_FMT_RGB_888"},
83        {PIXEL_FMT_BGR_565, "PIXEL_FMT_BGR_565"}, {PIXEL_FMT_BGRX_4444, "PIXEL_FMT_BGRX_4444"},
84        {PIXEL_FMT_BGRA_4444, "PIXEL_FMT_BGRA_4444"}, {PIXEL_FMT_BGRX_5551, "PIXEL_FMT_BGRX_5551"},
85        {PIXEL_FMT_BGRA_5551, "PIXEL_FMT_BGRA_5551"}, {PIXEL_FMT_BGRX_8888, "PIXEL_FMT_BGRX_8888"},
86        {PIXEL_FMT_BGRA_8888, "PIXEL_FMT_BGRA_8888"}, {PIXEL_FMT_YUV_422_I, "PIXEL_FMT_YUV_422_I"},
87        {PIXEL_FMT_YUV_422_I, "PIXEL_FMT_YUV_422_I"}, {PIXEL_FMT_YCBCR_422_SP, "PIXEL_FMT_YCBCR_422_SP"},
88        {PIXEL_FMT_YCRCB_422_SP, "PIXEL_FMT_YCRCB_422_SP"}, {PIXEL_FMT_YCBCR_420_SP, "PIXEL_FMT_YCBCR_420_SP"},
89        {PIXEL_FMT_YCRCB_420_SP, "PIXEL_FMT_YCRCB_420_SP"}, {PIXEL_FMT_YCBCR_422_P, "PIXEL_FMT_YCBCR_422_P"},
90        {PIXEL_FMT_YCRCB_422_P, "PIXEL_FMT_YCRCB_422_P"}, {PIXEL_FMT_YCBCR_420_P, "PIXEL_FMT_YCBCR_420_P"},
91        {PIXEL_FMT_YCRCB_420_P, "PIXEL_FMT_YCRCB_420_P"}, {PIXEL_FMT_YUYV_422_PKG, "PIXEL_FMT_YUYV_422_PKG"},
92        {PIXEL_FMT_UYVY_422_PKG, "PIXEL_FMT_UYVY_422_PKG"}, {PIXEL_FMT_YVYU_422_PKG, "PIXEL_FMT_YVYU_422_PKG"},
93        {PIXEL_FMT_VYUY_422_PKG, "PIXEL_FMT_VYUY_422_PKG"}, {PIXEL_FMT_BUTT, "PIXEL_FMT_BUTT"},
94    };
95    static const char *unknown = "unknown format";
96    for (uint32_t i = 0; i < sizeof(PIXEL_STR_MAPS) / sizeof(PIXEL_STR_MAPS[0]); i++) {
97        if (PIXEL_STR_MAPS[i].value == static_cast<uint32_t>(format)) {
98            return PIXEL_STR_MAPS[i].str;
99        }
100    }
101    DISPLAY_LOGE("GetPixelFmtStr unknown format %{public}d", format);
102    return unknown;
103}
104
105const char *GetDrmFmtStr(uint32_t format)
106{
107    static const ValueStrMap FORMAT_STR_MAPS[] = {
108        {DRM_FORMAT_C8, "DRM_FORMAT_C8" }, {DRM_FORMAT_R8, "DRM_FORMAT_R8" },
109        {DRM_FORMAT_R16, "DRM_FORMAT_R16"}, {DRM_FORMAT_RG88, "DRM_FORMAT_RG88"},
110        {DRM_FORMAT_GR88, "DRM_FORMAT_GR88"}, {DRM_FORMAT_RG1616, "DRM_FORMAT_RG1616"},
111        {DRM_FORMAT_GR1616, "DRM_FORMAT_GR1616"}, {DRM_FORMAT_RGB332, "DRM_FORMAT_RGB332"},
112        {DRM_FORMAT_BGR233, "DRM_FORMAT_BGR233"}, {DRM_FORMAT_XRGB4444, "DRM_FORMAT_XRGB4444"},
113        {DRM_FORMAT_XBGR4444, "DRM_FORMAT_XBGR4444"}, {DRM_FORMAT_RGBX4444, "DRM_FORMAT_RGBX4444"},
114        {DRM_FORMAT_BGRX4444, "DRM_FORMAT_BGRX4444"}, {DRM_FORMAT_ARGB4444, "DRM_FORMAT_ARGB4444"},
115        {DRM_FORMAT_ABGR4444, "DRM_FORMAT_ABGR4444"}, {DRM_FORMAT_RGBA4444, "DRM_FORMAT_RGBA4444"},
116        {DRM_FORMAT_BGRA4444, "DRM_FORMAT_BGRA4444"}, {DRM_FORMAT_XRGB1555, "DRM_FORMAT_XRGB1555"},
117        {DRM_FORMAT_XBGR1555, "DRM_FORMAT_XBGR1555"}, {DRM_FORMAT_RGBX5551, "DRM_FORMAT_RGBX5551"},
118        {DRM_FORMAT_BGRX5551, "DRM_FORMAT_BGRX5551"}, {DRM_FORMAT_ARGB1555, "DRM_FORMAT_ARGB1555"},
119        {DRM_FORMAT_ABGR1555, "DRM_FORMAT_ABGR1555"}, {DRM_FORMAT_RGBA5551, "DRM_FORMAT_RGBA5551"},
120        {DRM_FORMAT_BGRA5551, "DRM_FORMAT_BGRA5551"}, {DRM_FORMAT_RGB565, "DRM_FORMAT_RGB565"},
121        {DRM_FORMAT_BGR565, "DRM_FORMAT_BGR565"}, {DRM_FORMAT_RGB888, "DRM_FORMAT_RGB888"},
122        {DRM_FORMAT_BGR888, "DRM_FORMAT_BGR888"}, {DRM_FORMAT_XRGB8888, "DRM_FORMAT_XRGB8888"},
123        {DRM_FORMAT_XBGR8888, "DRM_FORMAT_XBGR8888"}, {DRM_FORMAT_RGBX8888, "DRM_FORMAT_RGBX8888"},
124        {DRM_FORMAT_BGRX8888, "DRM_FORMAT_BGRX8888"}, {DRM_FORMAT_ARGB8888, "DRM_FORMAT_ARGB8888"},
125        {DRM_FORMAT_ABGR8888, "DRM_FORMAT_ABGR8888"}, {DRM_FORMAT_RGBA8888, "DRM_FORMAT_RGBA8888"},
126        {DRM_FORMAT_BGRA8888, "DRM_FORMAT_BGRA8888"}, {DRM_FORMAT_XRGB2101010, "DRM_FORMAT_XRGB2101010"},
127        {DRM_FORMAT_BGRX1010102, "DRM_FORMAT_BGRX1010102"}, {DRM_FORMAT_ARGB2101010, "DRM_FORMAT_ARGB2101010"},
128        {DRM_FORMAT_ABGR2101010, "DRM_FORMAT_ABGR2101010"}, {DRM_FORMAT_RGBA1010102, "DRM_FORMAT_RGBA1010102"},
129        {DRM_FORMAT_YVYU, "DRM_FORMAT_YVYU"}, {DRM_FORMAT_UYVY, "DRM_FORMAT_UYVY"},
130        {DRM_FORMAT_VYUY, "DRM_FORMAT_VYUY"}, {DRM_FORMAT_AYUV, "DRM_FORMAT_AYUV"},
131        {DRM_FORMAT_NV12, "DRM_FORMAT_NV12"}, {DRM_FORMAT_NV21, "DRM_FORMAT_NV21"},
132        {DRM_FORMAT_NV16, "DRM_FORMAT_NV16"}, {DRM_FORMAT_NV61, "DRM_FORMAT_NV61"},
133        {DRM_FORMAT_NV24, "DRM_FORMAT_NV24"}, {DRM_FORMAT_NV42, "DRM_FORMAT_NV42"},
134        {DRM_FORMAT_YUV410, "DRM_FORMAT_YUV410"}, {DRM_FORMAT_YVU410, "DRM_FORMAT_YVU410"},
135        {DRM_FORMAT_YUV411, "DRM_FORMAT_YUV411"}, {DRM_FORMAT_YVU411, "DRM_FORMAT_YVU411"},
136        {DRM_FORMAT_YUV420, "DRM_FORMAT_YUV420"}, {DRM_FORMAT_YVU420, "DRM_FORMAT_YVU420"},
137        {DRM_FORMAT_YUV422, "DRM_FORMAT_YUV422"}, {DRM_FORMAT_YVU422, "DRM_FORMAT_YVU422"},
138        {DRM_FORMAT_YUV444, "DRM_FORMAT_YUV444"}, {DRM_FORMAT_YVU444, "DRM_FORMAT_YVU444"},
139    };
140
141    static const char *unknown = "unknown drm format";
142    for (uint32_t i = 0; i < sizeof(FORMAT_STR_MAPS) / sizeof(FORMAT_STR_MAPS[0]); i++) {
143        if (FORMAT_STR_MAPS[i].value == format) {
144            return FORMAT_STR_MAPS[i].str;
145        }
146    }
147    DISPLAY_LOGE("GetDrmFmtStr unknown format %{public}d", format);
148    return unknown;
149}
150
151static uint32_t ConvertFormatToDrm(PixelFormat fmtIn)
152{
153    static const PixelFormatConvertTbl CONVERT_TABLE[] = {
154        {DRM_FORMAT_RGBX8888, PIXEL_FMT_RGBX_8888}, {DRM_FORMAT_RGBA8888, PIXEL_FMT_RGBA_8888},
155        {DRM_FORMAT_RGB888, PIXEL_FMT_RGB_888}, {DRM_FORMAT_RGB565, PIXEL_FMT_BGR_565},
156        {DRM_FORMAT_BGRX4444, PIXEL_FMT_BGRX_4444}, {DRM_FORMAT_BGRA4444, PIXEL_FMT_BGRA_4444},
157        {DRM_FORMAT_RGBA4444, PIXEL_FMT_RGBA_4444}, {DRM_FORMAT_RGBX4444, PIXEL_FMT_RGBX_4444},
158        {DRM_FORMAT_BGRX5551, PIXEL_FMT_BGRX_5551}, {DRM_FORMAT_BGRA5551, PIXEL_FMT_BGRA_5551},
159        {DRM_FORMAT_BGRX8888, PIXEL_FMT_BGRX_8888}, {DRM_FORMAT_BGRA8888, PIXEL_FMT_BGRA_8888},
160        {DRM_FORMAT_NV12, PIXEL_FMT_YCBCR_420_SP}, {DRM_FORMAT_NV21, PIXEL_FMT_YCRCB_420_SP},
161        {DRM_FORMAT_YUV420, PIXEL_FMT_YCBCR_420_P}, {DRM_FORMAT_YVU420, PIXEL_FMT_YCRCB_420_P},
162        {DRM_FORMAT_NV16, PIXEL_FMT_YCBCR_422_SP}, {DRM_FORMAT_NV61, PIXEL_FMT_YCRCB_422_SP},
163        {DRM_FORMAT_YUV422, PIXEL_FMT_YCBCR_422_P}, {DRM_FORMAT_YVU422, PIXEL_FMT_YCRCB_422_P},
164    };
165    uint32_t fmtOut = 0;
166    for (uint32_t i = 0; i < sizeof(CONVERT_TABLE) / sizeof(CONVERT_TABLE[0]); i++) {
167        if (CONVERT_TABLE[i].pixFormat == fmtIn) {
168            fmtOut = CONVERT_TABLE[i].drmFormat;
169        }
170    }
171    DISPLAY_LOGD("fmtIn %{public}d : %{public}s, outFmt %{public}d : %{public}s", fmtIn,
172        GetPixelFmtStr(fmtIn), fmtOut, GetDrmFmtStr(fmtOut));
173    return fmtOut;
174}
175
176static uint64_t ConvertUsageToGbm(uint64_t inUsage)
177{
178    uint64_t outUsage = GBM_BO_USE_TEXTURING;
179    if (inUsage & HBM_USE_CPU_READ) {
180        outUsage |= GBM_BO_USE_SW_READ_OFTEN;
181    }
182    if (inUsage & HBM_USE_CPU_WRITE) {
183        outUsage |= GBM_BO_USE_SW_WRITE_OFTEN;
184    }
185    DISPLAY_LOGD("outUsage 0x%{public}" PRIx64 "", outUsage);
186    return outUsage;
187}
188
189static int32_t InitGbmDevice(const char *drmFile, GrallocManager *grallocManager)
190{
191    DISPLAY_LOGD();
192    if (grallocManager->gbmDevice == nullptr) {
193	    char path[PATH_MAX] = {0};
194        if (realpath(drmFile, path) == nullptr) {
195            DISPLAY_LOGE(" drm File : %{public}s is not a realpath, errno: %{public}s", drmFile, strerror(errno));
196            return HDF_ERR_INVALID_PARAM;
197        }
198        int drmFd = open(path, O_RDWR);
199        if (drmFd < 0) {
200            DISPLAY_LOGE("drm file:%{public}s open failed %{public}s", drmFile, strerror(errno));
201            return HDF_ERR_BAD_FD;
202        }
203        drmDropMaster(drmFd);
204        struct gbm_device *gbmDevice = HdiGbmCreateDevice(drmFd);
205        grallocManager->drmFd = drmFd;
206        if (gbmDevice == nullptr) {
207            close(drmFd);
208            grallocManager->drmFd = -1;
209            DISPLAY_LOGE("gbm device create failed");
210            return HDF_FAILURE;
211        }
212        grallocManager->gbmDevice = gbmDevice;
213        grallocManager->drmFd = drmFd;
214        DListHeadInit(&grallocManager->gbmBoHead);
215    }
216    return HDF_SUCCESS;
217}
218
219static void DeInitGbmDevice(GrallocManager *grallocManager)
220{
221    DISPLAY_LOGD();
222    HdiGbmDeviceDestroy(grallocManager->gbmDevice);
223    if (grallocManager->drmFd > 0) {
224        close(grallocManager->drmFd);
225        grallocManager->drmFd = -1;
226    }
227    grallocManager->gbmDevice = nullptr;
228}
229
230static int32_t DmaBufferSync(const BufferHandle *handle, bool start)
231{
232    DISPLAY_LOGD();
233    struct dma_buf_sync syncPrm;
234    errno_t eok = memset_s(&syncPrm, sizeof(syncPrm), 0, sizeof(syncPrm));
235    DISPLAY_CHK_RETURN((eok != EOK), HDF_ERR_INVALID_PARAM, DISPLAY_LOGE("dma buffer sync memset_s failed"));
236
237    if (handle->usage & HBM_USE_CPU_WRITE) {
238        syncPrm.flags |= DMA_BUF_SYNC_WRITE;
239    }
240
241    if (handle->usage & HBM_USE_CPU_READ) {
242        syncPrm.flags |= DMA_BUF_SYNC_READ;
243    }
244
245    if (start) {
246        syncPrm.flags |= DMA_BUF_SYNC_START;
247    } else {
248        syncPrm.flags |= DMA_BUF_SYNC_END;
249    }
250    int retry = 6;
251    int ret;
252    do {
253        ret = ioctl(handle->fd, DMA_BUF_IOCTL_SYNC, &syncPrm);
254    } while ((retry--) && (ret != -EAGAIN) && (ret != -EINTR));
255
256    if (ret < 0) {
257        DISPLAY_LOGE("sync failed");
258        return HDF_ERR_DEVICE_BUSY;
259    }
260    return HDF_SUCCESS;
261}
262
263static void InitBufferHandle(struct gbm_bo *bo, int fd, const AllocInfo *info, PriBufferHandle *buffer)
264{
265    BufferHandle *bufferHandle = &(buffer->hdl);
266    bufferHandle->fd = fd;
267    bufferHandle->reserveFds = 0;
268    bufferHandle->reserveInts = 0;
269    bufferHandle->stride = HdiGbmBoGetStride(bo);
270    bufferHandle->width = HdiGbmBoGetWidth(bo);
271    bufferHandle->height = HdiGbmBoGetHeight(bo);
272    bufferHandle->usage = info->usage;
273    bufferHandle->format = info->format;
274    bufferHandle->virAddr = nullptr;
275    bufferHandle->size = HdiGbmBoGetSize(bo);
276}
277
278int32_t GbmAllocMem(const AllocInfo *info, BufferHandle **buffer)
279{
280    DISPLAY_CHK_RETURN((info == nullptr), HDF_FAILURE, DISPLAY_LOGE("info is null"));
281    DISPLAY_CHK_RETURN((buffer == nullptr), HDF_FAILURE, DISPLAY_LOGE("buffer is null"));
282    PriBufferHandle *priBuffer = nullptr;
283    uint32_t drmFmt = ConvertFormatToDrm(static_cast<PixelFormat>(info->format));
284    DISPLAY_CHK_RETURN((drmFmt == INVALID_PIXEL_FMT), HDF_ERR_NOT_SUPPORT,
285        DISPLAY_LOGE("format %{public}d can not support", info->format));
286    DISPLAY_LOGD("requeset width %{public}d, heigt %{public}d, format %{public}d",
287        info->width, info->height, drmFmt);
288
289        GRALLOC_LOCK();
290    GrallocManager *grallocManager = GetGrallocManager();
291    DISPLAY_CHK_RETURN((grallocManager == nullptr), HDF_ERR_INVALID_PARAM, DISPLAY_LOGE("gralloc manager failed");
292        GRALLOC_UNLOCK());
293    struct gbm_bo *bo =
294        HdiGbmBoCreate(grallocManager->gbmDevice, info->width, info->height, drmFmt, ConvertUsageToGbm(info->usage));
295    DISPLAY_CHK_RETURN((bo == nullptr), HDF_DEV_ERR_NO_MEMORY, DISPLAY_LOGE("gbm create bo failed"); \
296        GRALLOC_UNLOCK());
297
298    int fd = HdiGbmBoGetFd(bo);
299    DISPLAY_CHK_RETURN((fd < 0), HDF_ERR_BAD_FD, DISPLAY_LOGE("gbm can not get fd"); \
300        HdiGbmBoDestroy(bo); \
301        GRALLOC_UNLOCK());
302
303    errno_t eok = EOK;
304    priBuffer = (PriBufferHandle *)malloc(sizeof(PriBufferHandle));
305    if (priBuffer == nullptr) {
306        DISPLAY_LOGE("bufferhandle malloc failed");
307        goto error;
308    }
309
310    eok = memset_s(priBuffer, sizeof(PriBufferHandle), 0, sizeof(PriBufferHandle));
311    if (eok != EOK) {
312        DISPLAY_LOGE("memset_s failed");
313        goto error;
314    }
315    DISPLAY_CHK_RETURN((eok != EOK), DISPLAY_PARAM_ERR, DISPLAY_LOGE("memset_s failed"));
316
317    InitBufferHandle(bo, fd, info, priBuffer);
318    *buffer = &priBuffer->hdl;
319    HdiGbmBoDestroy(bo);
320    GRALLOC_UNLOCK();
321    return HDF_SUCCESS;
322error:
323    close(fd);
324    HdiGbmBoDestroy(bo);
325    if (priBuffer != nullptr) {
326        free(priBuffer);
327    }
328    GRALLOC_UNLOCK();
329    return HDF_FAILURE;
330}
331
332static void CloseBufferHandle(BufferHandle *handle)
333{
334    DISPLAY_CHK_RETURN_NOT_VALUE((handle == nullptr), DISPLAY_LOGE("buffer is null"));
335    if (handle->fd >= 0) {
336        close(handle->fd);
337        handle->fd = -1;
338    }
339    const uint32_t reserveFds = handle->reserveFds;
340    for (uint32_t i = 0; i < reserveFds; i++) {
341        if (handle->reserve[i] >= 0) {
342            close(handle->reserve[i]);
343            handle->reserve[i] = -1;
344        }
345    }
346}
347
348void GbmFreeMem(BufferHandle *buffer)
349{
350    DISPLAY_LOGD();
351    DISPLAY_CHK_RETURN_NOT_VALUE((buffer == nullptr), DISPLAY_LOGE("buffer is null"));
352    if ((buffer->virAddr != nullptr) && (GbmUnmap(buffer) != HDF_SUCCESS)) {
353        DISPLAY_LOGE("freeMem unmap buffer failed");
354    }
355    CloseBufferHandle(buffer);
356    free(buffer);
357}
358
359void *GbmMmap(BufferHandle *buffer)
360{
361    void *virAddr = nullptr;
362    DISPLAY_LOGD();
363    if (buffer == nullptr) {
364        DISPLAY_LOGE("gbmmap the buffer handle is nullptr");
365        return nullptr;
366    }
367    if (buffer->virAddr != nullptr) {
368        DISPLAY_LOGD("the buffer has virtual addr");
369        return buffer->virAddr;
370    }
371    virAddr = mmap(nullptr, buffer->size, PROT_READ | PROT_WRITE, MAP_SHARED, buffer->fd, 0);
372    if (virAddr == reinterpret_cast<void *>(MAP_FAILED)) {
373        DISPLAY_LOGE("mmap failed errno %{public}s, fd : %{public}d", strerror(errno), buffer->fd);
374    }
375    buffer->virAddr = virAddr;
376    return virAddr;
377}
378
379int32_t GbmUnmap(BufferHandle *buffer)
380{
381    DISPLAY_LOGD();
382    if (buffer == nullptr) {
383        DISPLAY_LOGE("gbmumap the buffer handle is null");
384        return HDF_FAILURE;
385    }
386
387    if (buffer->virAddr == nullptr) {
388        DISPLAY_LOGE("virAddr is nullptr , has not map the buffer");
389        return HDF_ERR_INVALID_PARAM;
390    }
391    int ret = munmap(buffer->virAddr, buffer->size);
392    if (ret != 0) {
393        DISPLAY_LOGE("munmap failed err: %{public}s", strerror(errno));
394        return HDF_FAILURE;
395    }
396    buffer->virAddr = nullptr;
397    return HDF_SUCCESS;
398}
399
400int32_t GbmInvalidateCache(BufferHandle *buffer)
401{
402    DISPLAY_LOGD();
403    return DmaBufferSync(buffer, true);
404}
405
406int32_t GbmFlushCache(BufferHandle *buffer)
407{
408    DISPLAY_LOGD();
409    return DmaBufferSync(buffer, false);
410}
411
412int32_t GbmGrallocUninitialize(void)
413{
414    DISPLAY_LOGD();
415    GRALLOC_LOCK();
416    GrallocManager *grallocManager = GetGrallocManager();
417    DISPLAY_CHK_RETURN((grallocManager == nullptr), HDF_ERR_INVALID_PARAM, DISPLAY_LOGE("gralloc manager failed"); \
418        GRALLOC_UNLOCK());
419    grallocManager->referCount--;
420    if (grallocManager->referCount < 0) {
421        DeInitGbmDevice(grallocManager);
422        free(g_grallocManager);
423        g_grallocManager = nullptr;
424    }
425    GRALLOC_UNLOCK();
426    return HDF_SUCCESS;
427}
428
429int32_t GbmGrallocInitialize(void)
430{
431    DISPLAY_LOGD();
432    GRALLOC_LOCK();
433    GrallocManager *grallocManager = GetGrallocManager();
434    DISPLAY_CHK_RETURN((grallocManager == nullptr), HDF_ERR_INVALID_PARAM, DISPLAY_LOGE("gralloc manager failed"); \
435        GRALLOC_UNLOCK());
436    int ret = InitGbmDevice(g_drmFileNode, grallocManager);
437    DISPLAY_CHK_RETURN((ret != HDF_SUCCESS), ret, DISPLAY_LOGE("gralloc manager failed"); \
438        GRALLOC_UNLOCK());
439    grallocManager->referCount++;
440    GRALLOC_UNLOCK();
441    return HDF_SUCCESS;
442}
443} // namespace DISPLAY
444} // namespace HDI
445} // namespace OHOS
446