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 
38 namespace OHOS {
39 namespace HDI {
40 namespace DISPLAY {
41 using namespace OHOS::HDI::Display::Composer::V1_0;
42 using namespace OHOS::HDI::Display::Buffer::V1_0;
43 
44 const char *g_drmFileNode = "/dev/dri/renderD128";
45 static GrallocManager *g_grallocManager = nullptr;
46 static pthread_mutex_t g_lock;
47 
48 using PixelFormatConvertTbl = struct {
49     uint32_t drmFormat;
50     PixelFormat pixFormat;
51 };
52 
53 using ValueStrMap = struct {
54     uint32_t value;
55     const char *str;
56 };
57 
GetGrallocManager(void)58 static 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 
GetPixelFmtStr(PixelFormat format)73 const 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 
GetDrmFmtStr(uint32_t format)105 const 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 
ConvertFormatToDrm(PixelFormat fmtIn)151 static 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 
ConvertUsageToGbm(uint64_t inUsage)176 static 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 
InitGbmDevice(const char * drmFile,GrallocManager * grallocManager)189 static 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 
DeInitGbmDevice(GrallocManager * grallocManager)219 static 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 
DmaBufferSync(const BufferHandle * handle,bool start)230 static 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 
InitBufferHandle(struct gbm_bo * bo,int fd,const AllocInfo * info,PriBufferHandle * buffer)263 static 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 
GbmAllocMem(const AllocInfo * info,BufferHandle ** buffer)278 int32_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;
322 error:
323     close(fd);
324     HdiGbmBoDestroy(bo);
325     if (priBuffer != nullptr) {
326         free(priBuffer);
327     }
328     GRALLOC_UNLOCK();
329     return HDF_FAILURE;
330 }
331 
CloseBufferHandle(BufferHandle * handle)332 static 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 
GbmFreeMem(BufferHandle * buffer)348 void 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 
GbmMmap(BufferHandle * buffer)359 void *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 
GbmUnmap(BufferHandle * buffer)379 int32_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 
GbmInvalidateCache(BufferHandle * buffer)400 int32_t GbmInvalidateCache(BufferHandle *buffer)
401 {
402     DISPLAY_LOGD();
403     return DmaBufferSync(buffer, true);
404 }
405 
GbmFlushCache(BufferHandle * buffer)406 int32_t GbmFlushCache(BufferHandle *buffer)
407 {
408     DISPLAY_LOGD();
409     return DmaBufferSync(buffer, false);
410 }
411 
GbmGrallocUninitialize(void)412 int32_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 
GbmGrallocInitialize(void)429 int32_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