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