2 * Copyright (c) 2014 The Chromium OS Authors. All rights reserved.
3 * Use of this source code is governed by a BSD-style license that can be
4 * found in the LICENSE file.
19 extern struct gbm_driver gbm_driver_cirrus;
20 extern struct gbm_driver gbm_driver_evdi;
22 extern struct gbm_driver gbm_driver_exynos;
24 extern struct gbm_driver gbm_driver_gma500;
26 extern struct gbm_driver gbm_driver_i915;
29 extern struct gbm_driver gbm_driver_marvell;
32 extern struct gbm_driver gbm_driver_mediatek;
35 extern struct gbm_driver gbm_driver_rockchip;
38 extern struct gbm_driver gbm_driver_tegra;
40 extern struct gbm_driver gbm_driver_udl;
41 extern struct gbm_driver gbm_driver_virtio_gpu;
43 static struct gbm_driver *gbm_get_driver(int fd)
45 drmVersionPtr drm_version;
48 drm_version = drmGetVersion(fd);
53 struct gbm_driver *driver_list[] = {
76 &gbm_driver_virtio_gpu,
79 for(i = 0; i < ARRAY_SIZE(driver_list); i++)
80 if (!strcmp(drm_version->name, driver_list[i]->name))
82 drmFreeVersion(drm_version);
83 return driver_list[i];
86 drmFreeVersion(drm_version);
91 gbm_device_get_fd(struct gbm_device *gbm)
97 gbm_device_get_backend_name(struct gbm_device *gbm)
99 return gbm->driver->name;
103 gbm_device_is_format_supported(struct gbm_device *gbm,
104 uint32_t format, uint32_t usage)
108 if (format == GBM_BO_FORMAT_XRGB8888)
109 format = GBM_FORMAT_XRGB8888;
110 if (format == GBM_BO_FORMAT_ARGB8888)
111 format = GBM_FORMAT_ARGB8888;
113 if (usage & GBM_BO_USE_CURSOR &&
114 usage & GBM_BO_USE_RENDERING)
117 for(i = 0 ; i < ARRAY_SIZE(gbm->driver->format_list); i++)
119 if (!gbm->driver->format_list[i].format)
122 if (gbm->driver->format_list[i].format == format &&
123 (gbm->driver->format_list[i].usage & usage) == usage)
130 PUBLIC struct gbm_device *gbm_create_device(int fd)
132 struct gbm_device *gbm;
135 gbm = (struct gbm_device*) malloc(sizeof(*gbm));
141 gbm->driver = gbm_get_driver(fd);
147 if (gbm->driver->init) {
148 ret = gbm->driver->init(gbm);
158 PUBLIC void gbm_device_destroy(struct gbm_device *gbm)
160 if (gbm->driver->close)
161 gbm->driver->close(gbm);
165 PUBLIC struct gbm_surface *gbm_surface_create(struct gbm_device *gbm,
166 uint32_t width, uint32_t height,
167 uint32_t format, uint32_t flags)
169 struct gbm_surface *surface =
170 (struct gbm_surface*) malloc(sizeof(*surface));
178 PUBLIC void gbm_surface_destroy(struct gbm_surface *surface)
183 PUBLIC struct gbm_bo *gbm_surface_lock_front_buffer(struct gbm_surface *surface)
188 PUBLIC void gbm_surface_release_buffer(struct gbm_surface *surface,
193 static struct gbm_bo *gbm_bo_new(struct gbm_device *gbm,
194 uint32_t width, uint32_t height,
199 bo = (struct gbm_bo*) calloc(1, sizeof(*bo));
207 bo->num_planes = gbm_num_planes_from_format(format);
208 if (!bo->num_planes) {
216 PUBLIC struct gbm_bo *gbm_bo_create(struct gbm_device *gbm, uint32_t width,
217 uint32_t height, uint32_t format,
223 if (!gbm_device_is_format_supported(gbm, format, flags))
226 bo = gbm_bo_new(gbm, width, height, format);
230 ret = gbm->driver->bo_create(bo, width, height, format, flags);
239 PUBLIC void gbm_bo_destroy(struct gbm_bo *bo)
241 if (bo->destroy_user_data) {
242 bo->destroy_user_data(bo, bo->user_data);
243 bo->destroy_user_data = NULL;
244 bo->user_data = NULL;
247 bo->gbm->driver->bo_destroy(bo);
251 PUBLIC struct gbm_bo *
252 gbm_bo_import(struct gbm_device *gbm, uint32_t type,
253 void *buffer, uint32_t usage)
255 struct gbm_import_fd_data *fd_data = buffer;
257 struct drm_prime_handle prime_handle;
260 if (type != GBM_BO_IMPORT_FD)
263 if (!gbm_device_is_format_supported(gbm, fd_data->format, usage))
266 /* This function can support only single plane formats. */
267 /* If multi-plane import is desired, new function should be added. */
268 if (gbm_num_planes_from_format(fd_data->format) != 1)
271 bo = gbm_bo_new(gbm, fd_data->width, fd_data->height, fd_data->format);
275 bo->strides[0] = fd_data->stride;
276 bo->sizes[0] = fd_data->height * fd_data->stride;
278 prime_handle.fd = fd_data->fd;
280 ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &prime_handle);
282 fprintf(stderr, "minigbm: DRM_IOCTL_PRIME_FD_TO_HANDLE failed "
283 "(fd=%u)\n", prime_handle.fd);
288 bo->handles[0].u32 = prime_handle.handle;
294 gbm_bo_get_width(struct gbm_bo *bo)
300 gbm_bo_get_height(struct gbm_bo *bo)
306 gbm_bo_get_stride(struct gbm_bo *bo)
308 return gbm_bo_get_plane_stride(bo, 0);
312 gbm_bo_get_stride_or_tiling(struct gbm_bo *bo)
314 return bo->tiling ? bo->tiling : gbm_bo_get_stride(bo);
318 gbm_bo_get_format(struct gbm_bo *bo)
323 PUBLIC struct gbm_device *
324 gbm_bo_get_device(struct gbm_bo *bo)
329 PUBLIC union gbm_bo_handle
330 gbm_bo_get_handle(struct gbm_bo *bo)
332 return gbm_bo_get_plane_handle(bo, 0);
336 gbm_bo_get_fd(struct gbm_bo *bo)
338 return gbm_bo_get_plane_fd(bo, 0);
342 gbm_bo_get_num_planes(struct gbm_bo *bo)
344 return bo->num_planes;
347 PUBLIC union gbm_bo_handle
348 gbm_bo_get_plane_handle(struct gbm_bo *bo, size_t plane)
350 assert(plane < bo->num_planes);
351 return bo->handles[plane];
355 #define DRM_RDWR O_RDWR
359 gbm_bo_get_plane_fd(struct gbm_bo *bo, size_t plane)
362 assert(plane < bo->num_planes);
364 if (drmPrimeHandleToFD(
365 gbm_device_get_fd(bo->gbm),
366 gbm_bo_get_plane_handle(bo, plane).u32,
367 DRM_CLOEXEC | DRM_RDWR,
375 gbm_bo_get_plane_offset(struct gbm_bo *bo, size_t plane)
377 assert(plane < bo->num_planes);
378 return bo->offsets[plane];
382 gbm_bo_get_plane_size(struct gbm_bo *bo, size_t plane)
384 assert(plane < bo->num_planes);
385 return bo->sizes[plane];
389 gbm_bo_get_plane_stride(struct gbm_bo *bo, size_t plane)
391 assert(plane < bo->num_planes);
392 return bo->strides[plane];
396 gbm_bo_set_user_data(struct gbm_bo *bo, void *data,
397 void (*destroy_user_data)(struct gbm_bo *, void *))
399 bo->user_data = data;
400 bo->destroy_user_data = destroy_user_data;
404 gbm_bo_get_user_data(struct gbm_bo *bo)
406 return bo->user_data;