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