CPPFLAGS += -std=c99 -D_GNU_SOURCE=1
CFLAGS += -Wall -Wsign-compare -Wpointer-arith -Wcast-qual -Wcast-align
-ifdef GBM_EXYNOS
+ifdef DRV_EXYNOS
CFLAGS += $(shell $(PKG_CONFIG) --cflags libdrm_exynos)
endif
-ifdef GBM_I915
+ifdef DRV_I915
CFLAGS += $(shell $(PKG_CONFIG) --cflags libdrm_intel)
endif
-ifdef GBM_ROCKCHIP
+ifdef DRV_ROCKCHIP
CFLAGS += $(shell $(PKG_CONFIG) --cflags libdrm_rockchip)
endif
* found in the LICENSE file.
*/
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
-const struct gbm_driver gbm_driver_cirrus =
+const struct backend backend_cirrus =
{
.name = "cirrus",
- .bo_create = gbm_dumb_bo_create,
- .bo_destroy = gbm_dumb_bo_destroy,
+ .bo_create = drv_dumb_bo_create,
+ .bo_destroy = drv_dumb_bo_destroy,
.format_list = {
- {GBM_FORMAT_RGB888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
+ {DRV_FORMAT_RGB888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
}
};
--- /dev/null
+/*
+ * Copyright (c) 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+#include <assert.h>
+#include <fcntl.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <xf86drm.h>
+
+#include "drv_priv.h"
+#include "helpers.h"
+#include "util.h"
+
+extern struct backend backend_cirrus;
+extern struct backend backend_evdi;
+#ifdef DRV_EXYNOS
+extern struct backend backend_exynos;
+#endif
+extern struct backend backend_gma500;
+#ifdef DRV_I915
+extern struct backend backend_i915;
+#endif
+#ifdef DRV_MARVELL
+extern struct backend backend_marvell;
+#endif
+#ifdef DRV_MEDIATEK
+extern struct backend backend_mediatek;
+#endif
+#ifdef DRV_ROCKCHIP
+extern struct backend backend_rockchip;
+#endif
+#ifdef DRV_TEGRA
+extern struct backend backend_tegra;
+#endif
+extern struct backend backend_udl;
+extern struct backend backend_virtio_gpu;
+
+static struct backend *drv_get_backend(int fd)
+{
+ drmVersionPtr drm_version;
+ unsigned int i;
+
+ drm_version = drmGetVersion(fd);
+
+ if (!drm_version)
+ return NULL;
+
+ struct backend *backend_list[] = {
+ &backend_cirrus,
+ &backend_evdi,
+#ifdef DRV_EXYNOS
+ &backend_exynos,
+#endif
+ &backend_gma500,
+#ifdef DRV_I915
+ &backend_i915,
+#endif
+#ifdef DRV_MARVELL
+ &backend_marvell,
+#endif
+#ifdef DRV_MEDIATEK
+ &backend_mediatek,
+#endif
+#ifdef DRV_ROCKCHIP
+ &backend_rockchip,
+#endif
+#ifdef DRV_TEGRA
+ &backend_tegra,
+#endif
+ &backend_udl,
+ &backend_virtio_gpu,
+ };
+
+ for(i = 0; i < ARRAY_SIZE(backend_list); i++)
+ if (!strcmp(drm_version->name, backend_list[i]->name)) {
+ drmFreeVersion(drm_version);
+ return backend_list[i];
+ }
+
+ drmFreeVersion(drm_version);
+ return NULL;
+}
+
+struct driver *drv_create(int fd)
+{
+ struct driver *drv;
+ int ret;
+
+ drv = (struct driver *) calloc(1, sizeof(*drv));
+
+ if (!drv)
+ return NULL;
+
+ drv->fd = fd;
+ drv->backend = drv_get_backend(fd);
+
+ if (!drv->backend) {
+ free(drv);
+ return NULL;
+ }
+
+ if (drv->backend->init) {
+ ret = drv->backend->init(drv);
+ if (ret) {
+ free(drv);
+ return NULL;
+ }
+ }
+
+ return drv;
+}
+
+void drv_destroy(struct driver *drv)
+{
+ if (drv->backend->close)
+ drv->backend->close(drv);
+
+ free(drv);
+}
+
+int drv_get_fd(struct driver *drv)
+{
+ return drv->fd;
+}
+
+const char *
+drv_get_name(struct driver *drv)
+{
+ return drv->backend->name;
+}
+
+int drv_is_format_supported(struct driver *drv, drv_format_t format,
+ uint64_t usage)
+{
+ unsigned int i;
+
+ if (format == DRV_FORMAT_NONE || usage == DRV_BO_USE_NONE)
+ return 0;
+
+ for (i = 0 ; i < ARRAY_SIZE(drv->backend->format_list); i++)
+ {
+ if (!drv->backend->format_list[i].format)
+ break;
+
+ if (drv->backend->format_list[i].format == format &&
+ (drv->backend->format_list[i].usage & usage) == usage)
+ return 1;
+ }
+
+ return 0;
+}
+
+struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height,
+ drv_format_t format)
+{
+
+ struct bo *bo;
+ bo = (struct bo *) calloc(1, sizeof(*bo));
+
+ if (!bo)
+ return NULL;
+
+ bo->drv = drv;
+ bo->width = width;
+ bo->height = height;
+ bo->format = format;
+ bo->num_planes = drv_num_planes_from_format(format);
+
+ if (!bo->num_planes) {
+ free(bo);
+ return NULL;
+ }
+
+ return bo;
+}
+
+struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height,
+ drv_format_t format, uint64_t flags)
+{
+ int ret;
+ struct bo *bo;
+
+ bo = drv_bo_new(drv, width, height, format);
+
+ if (!bo)
+ return NULL;
+
+ ret = drv->backend->bo_create(bo, width, height, format, flags);
+
+ if (ret) {
+ free(bo);
+ return NULL;
+ }
+
+ return bo;
+}
+
+void drv_bo_destroy(struct bo *bo)
+{
+ bo->drv->backend->bo_destroy(bo);
+ free(bo);
+}
+
+struct bo *drv_bo_import(struct driver *drv, struct drv_import_fd_data *data)
+{
+ int ret;
+ struct bo *bo;
+ struct drm_prime_handle prime_handle;
+
+ memset(&prime_handle, 0, sizeof(prime_handle));
+ prime_handle.fd = data->fd;
+
+ /* This function can support only single plane formats. */
+ /* If multi-plane import is desired, new function should be added. */
+ if (drv_num_planes_from_format(data->format) != 1)
+ return NULL;
+
+ bo = drv_bo_new(drv, data->width, data->height, data->format);
+
+ ret = drmIoctl(drv->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE,
+ &prime_handle);
+
+ if (ret) {
+ fprintf(stderr, "drv: DRM_IOCTL_PRIME_FD_TO_HANDLE failed "
+ "(fd=%u)\n", prime_handle.fd);
+ free(bo);
+ return NULL;
+ }
+
+ bo->strides[0] = data->stride;
+ bo->sizes[0] = data->height * data->stride;
+ bo->handles[0].u32 = prime_handle.handle;
+
+ return bo;
+}
+
+uint32_t drv_bo_get_width(struct bo *bo)
+{
+ return bo->width;
+}
+
+uint32_t drv_bo_get_height(struct bo *bo)
+{
+ return bo->height;
+}
+
+uint32_t drv_bo_get_stride_or_tiling(struct bo *bo)
+{
+ return bo->tiling ? bo->tiling : drv_bo_get_plane_stride(bo, 0);
+}
+
+size_t drv_bo_get_num_planes(struct bo *bo)
+{
+ return bo->num_planes;
+}
+
+union bo_handle drv_bo_get_plane_handle(struct bo *bo, size_t plane)
+{
+ return bo->handles[plane];
+}
+
+#ifndef DRM_RDWR
+#define DRM_RDWR O_RDWR
+#endif
+
+int drv_bo_get_plane_fd(struct bo *bo, size_t plane)
+{
+
+ int ret, fd;
+ assert(plane < bo->num_planes);
+
+ ret = drmPrimeHandleToFD(bo->drv->fd, bo->handles[plane].u32,
+ DRM_CLOEXEC | DRM_RDWR, &fd);
+
+ return (ret) ? ret : fd;
+
+}
+
+uint32_t drv_bo_get_plane_offset(struct bo *bo, size_t plane)
+{
+ assert(plane < bo->num_planes);
+ return bo->offsets[plane];
+}
+
+uint32_t drv_bo_get_plane_size(struct bo *bo, size_t plane)
+{
+ assert(plane < bo->num_planes);
+ return bo->sizes[plane];
+}
+
+uint32_t drv_bo_get_plane_stride(struct bo *bo, size_t plane)
+{
+ assert(plane < bo->num_planes);
+ return bo->strides[plane];
+}
+
+uint64_t drv_bo_get_plane_format_modifier(struct bo *bo, size_t plane)
+{
+ assert(plane < bo->num_planes);
+ return bo->format_modifiers[plane];
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef DRV_H_
+#define DRV_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+#define DRV_MAX_PLANES 4
+
+/* Vendor ids and mod_code fourcc function must match gbm.h */
+#define DRV_FORMAT_MOD_NONE 0
+#define DRV_FORMAT_MOD_VENDOR_INTEL 0x01
+#define DRV_FORMAT_MOD_VENDOR_AMD 0x02
+#define DRV_FORMAT_MOD_VENDOR_NV 0x03
+#define DRV_FORMAT_MOD_VENDOR_SAMSUNG 0x04
+#define DRV_FORMAT_MOD_VENDOR_QCOM 0x05
+
+#define drv_fourcc_mod_code(vendor, val) \
+ ((((__u64)DRV_FORMAT_MOD_VENDOR_## vendor) << 56) | (val & 0x00ffffffffffffffULL))
+
+/* Use flags */
+#define DRV_BO_USE_NONE 0
+#define DRV_BO_USE_SCANOUT (1ull << 0)
+#define DRV_BO_USE_CURSOR (1ull << 1)
+#define DRV_BO_USE_CURSOR_64X64 DRV_BO_USE_CURSOR
+#define DRV_BO_USE_RENDERING (1ull << 2)
+#define DRV_BO_USE_LINEAR (1ull << 3)
+
+typedef enum {
+ DRV_FORMAT_NONE,
+ DRV_FORMAT_C8,
+ DRV_FORMAT_R8,
+ DRV_FORMAT_RG88,
+ DRV_FORMAT_GR88,
+ DRV_FORMAT_RGB332,
+ DRV_FORMAT_BGR233,
+ DRV_FORMAT_XRGB4444,
+ DRV_FORMAT_XBGR4444,
+ DRV_FORMAT_RGBX4444,
+ DRV_FORMAT_BGRX4444,
+ DRV_FORMAT_ARGB4444,
+ DRV_FORMAT_ABGR4444,
+ DRV_FORMAT_RGBA4444,
+ DRV_FORMAT_BGRA4444,
+ DRV_FORMAT_XRGB1555,
+ DRV_FORMAT_XBGR1555,
+ DRV_FORMAT_RGBX5551,
+ DRV_FORMAT_BGRX5551,
+ DRV_FORMAT_ARGB1555,
+ DRV_FORMAT_ABGR1555,
+ DRV_FORMAT_RGBA5551,
+ DRV_FORMAT_BGRA5551,
+ DRV_FORMAT_RGB565,
+ DRV_FORMAT_BGR565,
+ DRV_FORMAT_RGB888,
+ DRV_FORMAT_BGR888,
+ DRV_FORMAT_XRGB8888,
+ DRV_FORMAT_XBGR8888,
+ DRV_FORMAT_RGBX8888,
+ DRV_FORMAT_BGRX8888,
+ DRV_FORMAT_ARGB8888,
+ DRV_FORMAT_ABGR8888,
+ DRV_FORMAT_RGBA8888,
+ DRV_FORMAT_BGRA8888,
+ DRV_FORMAT_XRGB2101010,
+ DRV_FORMAT_XBGR2101010,
+ DRV_FORMAT_RGBX1010102,
+ DRV_FORMAT_BGRX1010102,
+ DRV_FORMAT_ARGB2101010,
+ DRV_FORMAT_ABGR2101010,
+ DRV_FORMAT_RGBA1010102,
+ DRV_FORMAT_BGRA1010102,
+ DRV_FORMAT_YUYV,
+ DRV_FORMAT_YVYU,
+ DRV_FORMAT_UYVY,
+ DRV_FORMAT_VYUY,
+ DRV_FORMAT_AYUV,
+ DRV_FORMAT_NV12,
+ DRV_FORMAT_NV21,
+ DRV_FORMAT_NV16,
+ DRV_FORMAT_NV61,
+ DRV_FORMAT_YUV410,
+ DRV_FORMAT_YVU410,
+ DRV_FORMAT_YUV411,
+ DRV_FORMAT_YVU411,
+ DRV_FORMAT_YUV420,
+ DRV_FORMAT_YVU420,
+ DRV_FORMAT_YUV422,
+ DRV_FORMAT_YVU422,
+ DRV_FORMAT_YUV444,
+ DRV_FORMAT_YVU444,
+} drv_format_t;
+
+struct driver;
+struct bo;
+
+union bo_handle {
+ void *ptr;
+ int32_t s32;
+ uint32_t u32;
+ int64_t s64;
+ uint64_t u64;
+};
+
+struct drv_import_fd_data {
+ int fd;
+ uint32_t width;
+ uint32_t height;
+ uint32_t stride;
+ drv_format_t format;
+};
+
+struct driver *
+drv_create(int fd);
+
+void
+drv_destroy(struct driver *drv);
+
+int
+drv_get_fd(struct driver *drv);
+
+const char *
+drv_get_name(struct driver *drv);
+
+int
+drv_is_format_supported(struct driver *drv, drv_format_t format,
+ uint64_t usage);
+
+struct bo *
+drv_bo_new(struct driver *drv, uint32_t width, uint32_t height,
+ drv_format_t format);
+
+struct bo *
+drv_bo_create(struct driver *drv, uint32_t width, uint32_t height,
+ drv_format_t format, uint64_t flags);
+
+void
+drv_bo_destroy(struct bo *bo);
+
+struct bo *
+drv_bo_import(struct driver *drv, struct drv_import_fd_data *data);
+
+uint32_t
+drv_bo_get_width(struct bo *bo);
+
+uint32_t
+drv_bo_get_height(struct bo *bo);
+
+uint32_t
+drv_bo_get_stride_or_tiling(struct bo *bo);
+
+size_t
+drv_bo_get_num_planes(struct bo *bo);
+
+union bo_handle
+drv_bo_get_plane_handle(struct bo *bo, size_t plane);
+
+int
+drv_bo_get_plane_fd(struct bo *bo, size_t plane);
+
+uint32_t
+drv_bo_get_plane_offset(struct bo *bo, size_t plane);
+
+uint32_t
+drv_bo_get_plane_size(struct bo *bo, size_t plane);
+
+uint32_t
+drv_bo_get_plane_stride(struct bo *bo, size_t plane);
+
+uint64_t
+drv_bo_get_plane_format_modifier(struct bo *bo, size_t plane);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+
--- /dev/null
+/*
+ * Copyright (c) 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef DRV_PRIV_H
+#define DRV_PRIV_H
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+#include "drv.h"
+
+struct bo
+{
+ struct driver *drv;
+ uint32_t width;
+ uint32_t height;
+ uint32_t format;
+ uint32_t tiling;
+ size_t num_planes;
+ union bo_handle handles[DRV_MAX_PLANES];
+ uint32_t offsets[DRV_MAX_PLANES];
+ uint32_t sizes[DRV_MAX_PLANES];
+ uint32_t strides[DRV_MAX_PLANES];
+ uint64_t format_modifiers[DRV_MAX_PLANES];
+ void *priv;
+};
+
+struct driver {
+ int fd;
+ struct backend *backend;
+ void *priv;
+};
+
+struct backend
+{
+ char *name;
+ int (*init)(struct driver *drv);
+ void (*close)(struct driver *drv);
+ int (*bo_create)(struct bo *bo, uint32_t width, uint32_t height,
+ drv_format_t format, uint32_t flags);
+ int (*bo_destroy)(struct bo *bo);
+ struct format_supported {
+ drv_format_t format;
+ uint64_t usage;
+ }
+ format_list[18];
+};
+
+#endif
* found in the LICENSE file.
*/
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
-const struct gbm_driver gbm_driver_evdi =
+const struct backend backend_evdi =
{
.name = "evdi",
- .bo_create = gbm_dumb_bo_create,
- .bo_destroy = gbm_dumb_bo_destroy,
+ .bo_create = drv_dumb_bo_create,
+ .bo_destroy = drv_dumb_bo_destroy,
.format_list = {
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
}
};
* found in the LICENSE file.
*/
-#ifdef GBM_EXYNOS
+#ifdef DRV_EXYNOS
#include <assert.h>
#include <errno.h>
#include <xf86drm.h>
#include <exynos_drm.h>
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
#include "util.h"
-static int gbm_exynos_bo_create(struct gbm_bo *bo,
+static int drv_exynos_bo_create(struct bo *bo,
uint32_t width, uint32_t height,
uint32_t format, uint32_t flags)
{
size_t plane;
- if (format == GBM_FORMAT_NV12) {
+ if (format == DRV_FORMAT_NV12) {
uint32_t chroma_height;
/* V4L2 s5p-mfc requires width to be 16 byte aligned and height 32. */
width = ALIGN(width, 16);
bo->sizes[0] = bo->strides[0] * height + 64;
bo->sizes[1] = bo->strides[1] * chroma_height + 64;
bo->offsets[0] = bo->offsets[1] = 0;
- } else if (format == GBM_FORMAT_XRGB8888 || format == GBM_FORMAT_ARGB8888) {
- bo->strides[0] = gbm_stride_from_format(format, width);
+ } else if (format == DRV_FORMAT_XRGB8888 || format == DRV_FORMAT_ARGB8888) {
+ bo->strides[0] = drv_stride_from_format(format, width);
bo->sizes[0] = height * bo->strides[0];
bo->offsets[0] = 0;
} else {
- fprintf(stderr, "minigbm: unsupported format %X\n", format);
+ fprintf(stderr, "drv: unsupported format %X\n", format);
assert(0);
return -EINVAL;
}
gem_create.size = size;
gem_create.flags = EXYNOS_BO_NONCONTIG;
- ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_EXYNOS_GEM_CREATE, &gem_create);
+ ret = drmIoctl(bo->drv->fd, DRM_IOCTL_EXYNOS_GEM_CREATE, &gem_create);
if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_EXYNOS_GEM_CREATE failed "
+ fprintf(stderr, "drv: DRM_IOCTL_EXYNOS_GEM_CREATE failed "
"(size=%zu)\n", size);
goto cleanup_planes;
}
struct drm_gem_close gem_close;
memset(&gem_close, 0, sizeof(gem_close));
gem_close.handle = bo->handles[plane - 1].u32;
- int gem_close_ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_GEM_CLOSE,
+ int gem_close_ret = drmIoctl(bo->drv->fd, DRM_IOCTL_GEM_CLOSE,
&gem_close);
if (gem_close_ret) {
fprintf(stderr,
- "minigbm: DRM_IOCTL_GEM_CLOSE failed: %d\n",
+ "drv: DRM_IOCTL_GEM_CLOSE failed: %d\n",
gem_close_ret);
}
}
return ret;
}
-const struct gbm_driver gbm_driver_exynos =
+const struct backend backend_exynos =
{
.name = "exynos",
- .bo_create = gbm_exynos_bo_create,
- .bo_destroy = gbm_gem_bo_destroy,
+ .bo_create = drv_exynos_bo_create,
+ .bo_destroy = drv_gem_bo_destroy,
.format_list = {
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_NV12, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_NV12, DRV_BO_USE_SCANOUT | DRV_BO_USE_RENDERING},
}
};
#include <string.h>
#include <xf86drm.h>
+#include "drv.h"
#include "gbm_priv.h"
-#include "helpers.h"
+#include "gbm_helpers.h"
#include "util.h"
-extern struct gbm_driver gbm_driver_cirrus;
-extern struct gbm_driver gbm_driver_evdi;
-#ifdef GBM_EXYNOS
-extern struct gbm_driver gbm_driver_exynos;
-#endif
-extern struct gbm_driver gbm_driver_gma500;
-#ifdef GBM_I915
-extern struct gbm_driver gbm_driver_i915;
-#endif
-#ifdef GBM_MARVELL
-extern struct gbm_driver gbm_driver_marvell;
-#endif
-#ifdef GBM_MEDIATEK
-extern struct gbm_driver gbm_driver_mediatek;
-#endif
-#ifdef GBM_ROCKCHIP
-extern struct gbm_driver gbm_driver_rockchip;
-#endif
-#ifdef GBM_TEGRA
-extern struct gbm_driver gbm_driver_tegra;
-#endif
-extern struct gbm_driver gbm_driver_udl;
-extern struct gbm_driver gbm_driver_virtio_gpu;
-
-static struct gbm_driver *gbm_get_driver(int fd)
-{
- drmVersionPtr drm_version;
- unsigned int i;
-
- drm_version = drmGetVersion(fd);
-
- if (!drm_version)
- return NULL;
-
- struct gbm_driver *driver_list[] = {
- &gbm_driver_cirrus,
- &gbm_driver_evdi,
-#ifdef GBM_EXYNOS
- &gbm_driver_exynos,
-#endif
- &gbm_driver_gma500,
-#ifdef GBM_I915
- &gbm_driver_i915,
-#endif
-#ifdef GBM_MARVELL
- &gbm_driver_marvell,
-#endif
-#ifdef GBM_MEDIATEK
- &gbm_driver_mediatek,
-#endif
-#ifdef GBM_ROCKCHIP
- &gbm_driver_rockchip,
-#endif
-#ifdef GBM_TEGRA
- &gbm_driver_tegra,
-#endif
- &gbm_driver_udl,
- &gbm_driver_virtio_gpu,
- };
-
- for(i = 0; i < ARRAY_SIZE(driver_list); i++)
- if (!strcmp(drm_version->name, driver_list[i]->name))
- {
- drmFreeVersion(drm_version);
- return driver_list[i];
- }
-
- drmFreeVersion(drm_version);
- return NULL;
-}
-
PUBLIC int
gbm_device_get_fd(struct gbm_device *gbm)
{
- return gbm->fd;
+
+ return drv_get_fd(gbm->drv);
}
PUBLIC const char *
gbm_device_get_backend_name(struct gbm_device *gbm)
{
- return gbm->driver->name;
+ return drv_get_name(gbm->drv);
}
PUBLIC int
gbm_device_is_format_supported(struct gbm_device *gbm,
uint32_t format, uint32_t usage)
{
- unsigned i;
+ uint32_t drv_format;
+ uint64_t drv_usage;
if (usage & GBM_BO_USE_CURSOR &&
usage & GBM_BO_USE_RENDERING)
return 0;
- for(i = 0 ; i < ARRAY_SIZE(gbm->driver->format_list); i++)
- {
- if (!gbm->driver->format_list[i].format)
- break;
-
- if (gbm->driver->format_list[i].format == format &&
- (gbm->driver->format_list[i].usage & usage) == usage)
- return 1;
- }
+ drv_format = gbm_convert_format(format);
+ drv_usage = gbm_convert_flags(usage);
- return 0;
+ return drv_is_format_supported(gbm->drv, drv_format, drv_usage);
}
PUBLIC struct gbm_device *gbm_create_device(int fd)
{
struct gbm_device *gbm;
- int ret;
gbm = (struct gbm_device*) malloc(sizeof(*gbm));
+
if (!gbm)
return NULL;
- gbm->fd = fd;
-
- gbm->driver = gbm_get_driver(fd);
- if (!gbm->driver) {
+ gbm->drv = drv_create(fd);
+ if (!gbm->drv) {
free(gbm);
return NULL;
}
- if (gbm->driver->init) {
- ret = gbm->driver->init(gbm);
- if (ret) {
- free(gbm);
- return NULL;
- }
- }
-
return gbm;
}
PUBLIC void gbm_device_destroy(struct gbm_device *gbm)
{
- if (gbm->driver->close)
- gbm->driver->close(gbm);
+ drv_destroy(gbm->drv);
free(gbm);
}
{
}
-static struct gbm_bo *gbm_bo_new(struct gbm_device *gbm,
- uint32_t width, uint32_t height,
- uint32_t format)
+static struct gbm_bo *gbm_bo_new(struct gbm_device *gbm, uint32_t format)
{
struct gbm_bo *bo;
return NULL;
bo->gbm = gbm;
- bo->width = width;
- bo->height = height;
- bo->format = format;
- bo->num_planes = gbm_num_planes_from_format(format);
- if (!bo->num_planes) {
- free(bo);
- return NULL;
- }
+ bo->gbm_format = format;
return bo;
}
uint32_t flags)
{
struct gbm_bo *bo;
- int ret;
if (!gbm_device_is_format_supported(gbm, format, flags))
return NULL;
- bo = gbm_bo_new(gbm, width, height, format);
+ bo = gbm_bo_new(gbm, format);
+
if (!bo)
return NULL;
- ret = gbm->driver->bo_create(bo, width, height, format, flags);
- if (ret) {
+ bo->bo = drv_bo_create(gbm->drv, width, height,
+ gbm_convert_format(format),
+ gbm_convert_flags(flags));
+
+ if (!bo->bo) {
free(bo);
return NULL;
}
bo->user_data = NULL;
}
- bo->gbm->driver->bo_destroy(bo);
+ drv_bo_destroy(bo->bo);
free(bo);
}
gbm_bo_import(struct gbm_device *gbm, uint32_t type,
void *buffer, uint32_t usage)
{
- struct gbm_import_fd_data *fd_data = buffer;
struct gbm_bo *bo;
- struct drm_prime_handle prime_handle;
- int ret;
+ struct drv_import_fd_data drv_data;
+ struct gbm_import_fd_data *fd_data = buffer;
if (type != GBM_BO_IMPORT_FD)
return NULL;
if (!gbm_device_is_format_supported(gbm, fd_data->format, usage))
return NULL;
- /* This function can support only single plane formats. */
- /* If multi-plane import is desired, new function should be added. */
- if (gbm_num_planes_from_format(fd_data->format) != 1)
- return NULL;
+ bo = gbm_bo_new(gbm, fd_data->format);
- bo = gbm_bo_new(gbm, fd_data->width, fd_data->height, fd_data->format);
if (!bo)
return NULL;
- bo->strides[0] = fd_data->stride;
- bo->sizes[0] = fd_data->height * fd_data->stride;
+ drv_data.fd = fd_data->fd;
+ drv_data.width = fd_data->width;
+ drv_data.height = fd_data->height;
+ drv_data.format = gbm_convert_format(fd_data->format);
+ drv_data.stride = fd_data->stride;
- memset(&prime_handle, 0, sizeof(prime_handle));
- prime_handle.fd = fd_data->fd;
+ bo->bo = drv_bo_import(gbm->drv, &drv_data);
- ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &prime_handle);
- if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_PRIME_FD_TO_HANDLE failed "
- "(fd=%u)\n", prime_handle.fd);
+ if (!bo->bo) {
free(bo);
return NULL;
}
- bo->handles[0].u32 = prime_handle.handle;
-
return bo;
}
PUBLIC uint32_t
gbm_bo_get_width(struct gbm_bo *bo)
{
- return bo->width;
+ return drv_bo_get_width(bo->bo);
}
PUBLIC uint32_t
gbm_bo_get_height(struct gbm_bo *bo)
{
- return bo->height;
+ return drv_bo_get_height(bo->bo);
}
PUBLIC uint32_t
PUBLIC uint32_t
gbm_bo_get_stride_or_tiling(struct gbm_bo *bo)
{
- return bo->tiling ? bo->tiling : gbm_bo_get_stride(bo);
+ return drv_bo_get_stride_or_tiling(bo->bo);
}
PUBLIC uint32_t
gbm_bo_get_format(struct gbm_bo *bo)
{
- return bo->format;
+ return bo->gbm_format;
}
PUBLIC uint64_t
PUBLIC size_t
gbm_bo_get_num_planes(struct gbm_bo *bo)
{
- return bo->num_planes;
+ return drv_bo_get_num_planes(bo->bo);
}
PUBLIC union gbm_bo_handle
gbm_bo_get_plane_handle(struct gbm_bo *bo, size_t plane)
{
- assert(plane < bo->num_planes);
- return bo->handles[plane];
+ return (union gbm_bo_handle) drv_bo_get_plane_handle(bo->bo, plane).u64;
}
-#ifndef DRM_RDWR
-#define DRM_RDWR O_RDWR
-#endif
-
PUBLIC int
gbm_bo_get_plane_fd(struct gbm_bo *bo, size_t plane)
{
- int fd;
- assert(plane < bo->num_planes);
-
- if (drmPrimeHandleToFD(
- gbm_device_get_fd(bo->gbm),
- gbm_bo_get_plane_handle(bo, plane).u32,
- DRM_CLOEXEC | DRM_RDWR,
- &fd))
- return -1;
- else
- return fd;
+ return drv_bo_get_plane_fd(bo->bo, plane);
}
PUBLIC uint32_t
gbm_bo_get_plane_offset(struct gbm_bo *bo, size_t plane)
{
- assert(plane < bo->num_planes);
- return bo->offsets[plane];
+ return drv_bo_get_plane_offset(bo->bo, plane);
}
PUBLIC uint32_t
gbm_bo_get_plane_size(struct gbm_bo *bo, size_t plane)
{
- assert(plane < bo->num_planes);
- return bo->sizes[plane];
+ return drv_bo_get_plane_size(bo->bo, plane);
}
PUBLIC uint32_t
gbm_bo_get_plane_stride(struct gbm_bo *bo, size_t plane)
{
- assert(plane < bo->num_planes);
- return bo->strides[plane];
+ return drv_bo_get_plane_stride(bo->bo, plane);
}
PUBLIC uint64_t
gbm_bo_get_plane_format_modifier(struct gbm_bo *bo, size_t plane)
{
- assert(plane < bo->num_planes);
- return bo->format_modifiers[plane];
+ return drv_bo_get_plane_format_modifier(bo->bo, plane);
}
PUBLIC void
--- /dev/null
+/*
+ * Copyright (c) 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "drv.h"
+#include "gbm.h"
+
+drv_format_t gbm_convert_format(uint32_t format)
+{
+
+ switch (format) {
+ case GBM_FORMAT_C8:
+ return DRV_FORMAT_C8;
+ case GBM_FORMAT_R8:
+ return DRV_FORMAT_R8;
+ case GBM_FORMAT_RG88:
+ return DRV_FORMAT_RG88;
+ case GBM_FORMAT_GR88:
+ return DRV_FORMAT_GR88;
+ case GBM_FORMAT_RGB332:
+ return DRV_FORMAT_RGB332;
+ case GBM_FORMAT_BGR233:
+ return DRV_FORMAT_BGR233;
+ case GBM_FORMAT_XRGB4444:
+ return DRV_FORMAT_XRGB4444;
+ case GBM_FORMAT_XBGR4444:
+ return DRV_FORMAT_XBGR4444;
+ case GBM_FORMAT_RGBX4444:
+ return DRV_FORMAT_RGBX4444;
+ case GBM_FORMAT_BGRX4444:
+ return DRV_FORMAT_BGRX4444;
+ case GBM_FORMAT_ARGB4444:
+ return DRV_FORMAT_ARGB4444;
+ case GBM_FORMAT_ABGR4444:
+ return DRV_FORMAT_ABGR4444;
+ case GBM_FORMAT_RGBA4444:
+ return DRV_FORMAT_RGBA4444;
+ case GBM_FORMAT_BGRA4444:
+ return DRV_FORMAT_BGRA4444;
+ case GBM_FORMAT_XRGB1555:
+ return DRV_FORMAT_XRGB1555;
+ case GBM_FORMAT_XBGR1555:
+ return DRV_FORMAT_XBGR1555;
+ case GBM_FORMAT_RGBX5551:
+ return DRV_FORMAT_RGBX5551;
+ case GBM_FORMAT_BGRX5551:
+ return DRV_FORMAT_BGRX5551;
+ case GBM_FORMAT_ARGB1555:
+ return DRV_FORMAT_ARGB1555;
+ case GBM_FORMAT_ABGR1555:
+ return DRV_FORMAT_ABGR1555;
+ case GBM_FORMAT_RGBA5551:
+ return DRV_FORMAT_RGBA5551;
+ case GBM_FORMAT_BGRA5551:
+ return DRV_FORMAT_BGRA5551;
+ case GBM_FORMAT_RGB565:
+ return DRV_FORMAT_RGB565;
+ case GBM_FORMAT_BGR565:
+ return DRV_FORMAT_BGR565;
+ case GBM_FORMAT_RGB888:
+ return DRV_FORMAT_RGB888;
+ case GBM_FORMAT_BGR888:
+ return DRV_FORMAT_BGR888;
+ case GBM_FORMAT_XRGB8888:
+ return DRV_FORMAT_XRGB8888;
+ case GBM_FORMAT_XBGR8888:
+ return DRV_FORMAT_XBGR8888;
+ case GBM_FORMAT_RGBX8888:
+ return DRV_FORMAT_RGBX8888;
+ case GBM_FORMAT_BGRX8888:
+ return DRV_FORMAT_BGRX8888;
+ case GBM_FORMAT_ARGB8888:
+ return DRV_FORMAT_ARGB8888;
+ case GBM_FORMAT_ABGR8888:
+ return DRV_FORMAT_ABGR8888;
+ case GBM_FORMAT_RGBA8888:
+ return DRV_FORMAT_RGBA8888;
+ case GBM_FORMAT_BGRA8888:
+ return DRV_FORMAT_BGRA8888;
+ case GBM_FORMAT_XRGB2101010:
+ return DRV_FORMAT_XRGB2101010;
+ case GBM_FORMAT_XBGR2101010:
+ return DRV_FORMAT_XBGR2101010;
+ case GBM_FORMAT_RGBX1010102:
+ return DRV_FORMAT_RGBX1010102;
+ case GBM_FORMAT_BGRX1010102:
+ return DRV_FORMAT_BGRX1010102;
+ case GBM_FORMAT_ARGB2101010:
+ return DRV_FORMAT_ARGB2101010;
+ case GBM_FORMAT_ABGR2101010:
+ return DRV_FORMAT_ABGR2101010;
+ case GBM_FORMAT_RGBA1010102:
+ return DRV_FORMAT_RGBA1010102;
+ case GBM_FORMAT_BGRA1010102:
+ return DRV_FORMAT_BGRA1010102;
+ case GBM_FORMAT_YUYV:
+ return DRV_FORMAT_YUYV;
+ case GBM_FORMAT_YVYU:
+ return DRV_FORMAT_YVYU;
+ case GBM_FORMAT_UYVY:
+ return DRV_FORMAT_UYVY;
+ case GBM_FORMAT_VYUY:
+ return DRV_FORMAT_VYUY;
+ case GBM_FORMAT_AYUV:
+ return DRV_FORMAT_AYUV;
+ case GBM_FORMAT_NV12:
+ return DRV_FORMAT_NV12;
+ case GBM_FORMAT_NV21:
+ return DRV_FORMAT_NV21;
+ case GBM_FORMAT_NV16:
+ return DRV_FORMAT_NV16;
+ case GBM_FORMAT_NV61:
+ return DRV_FORMAT_NV61;
+ case GBM_FORMAT_YUV410:
+ return DRV_FORMAT_YUV410;
+ case GBM_FORMAT_YVU410:
+ return DRV_FORMAT_YVU410;
+ case GBM_FORMAT_YUV411:
+ return DRV_FORMAT_YUV411;
+ case GBM_FORMAT_YVU411:
+ return DRV_FORMAT_YVU411;
+ case GBM_FORMAT_YUV420:
+ return DRV_FORMAT_YUV420;
+ case GBM_FORMAT_YVU420:
+ return DRV_FORMAT_YVU420;
+ case GBM_FORMAT_YUV422:
+ return DRV_FORMAT_YUV422;
+ case GBM_FORMAT_YVU422:
+ return DRV_FORMAT_YVU422;
+ case GBM_FORMAT_YUV444:
+ return DRV_FORMAT_YVU444;
+ case GBM_FORMAT_YVU444:
+ return DRV_FORMAT_YVU444;
+ }
+
+ fprintf(stderr, "minigbm: UNKNOWN FORMAT %d\n", format);
+ return DRV_FORMAT_NONE;
+}
+
+uint64_t gbm_convert_flags(uint32_t flags)
+{
+ uint64_t usage = DRV_BO_USE_NONE;
+
+ if (flags & GBM_BO_USE_SCANOUT)
+ usage |= DRV_BO_USE_SCANOUT;
+ if (flags & GBM_BO_USE_CURSOR)
+ usage |= DRV_BO_USE_CURSOR;
+ if (flags & GBM_BO_USE_CURSOR_64X64)
+ usage |= DRV_BO_USE_CURSOR_64X64;
+ if (flags & GBM_BO_USE_RENDERING)
+ usage |= DRV_BO_USE_RENDERING;
+ if (flags & GBM_BO_USE_LINEAR)
+ usage |= DRV_BO_USE_LINEAR;
+
+ return usage;
+}
--- /dev/null
+/*
+ * Copyright (c) 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GBM_HELPERS_H
+#define GBM_HELPERS_H
+
+drv_format_t gbm_convert_format(uint32_t format);
+uint64_t gbm_convert_flags(uint32_t flags);
+
+#endif
#include <stdint.h>
#include <sys/types.h>
#include <stdlib.h>
-#include "gbm.h"
-#define GBM_MAX_PLANES 4
+#include "drv.h"
+#include "gbm.h"
struct gbm_device
{
- int fd;
- struct gbm_driver *driver;
- void *priv;
+ struct driver *drv;
};
struct gbm_surface
struct gbm_bo
{
struct gbm_device *gbm;
- uint32_t width;
- uint32_t height;
- uint32_t format;
- uint32_t tiling;
- size_t num_planes;
- union gbm_bo_handle handles[GBM_MAX_PLANES];
- uint32_t offsets[GBM_MAX_PLANES];
- uint32_t sizes[GBM_MAX_PLANES];
- uint32_t strides[GBM_MAX_PLANES];
- uint64_t format_modifiers[GBM_MAX_PLANES];
- void *priv;
+ struct bo *bo;
+ uint32_t gbm_format;
void *user_data;
void (*destroy_user_data)(struct gbm_bo *, void *);
};
-struct gbm_driver
-{
- char *name;
- int (*init)(struct gbm_device *gbm);
- void (*close)(struct gbm_device *gbm);
- int (*bo_create)(struct gbm_bo *bo, uint32_t width, uint32_t height, uint32_t format, uint32_t flags);
- int (*bo_destroy)(struct gbm_bo *bo);
- struct format_supported {
- uint32_t format;
- enum gbm_bo_flags usage;
- }
- format_list[18];
-};
-
#endif
* found in the LICENSE file.
*/
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
-const struct gbm_driver gbm_driver_gma500 =
+const struct backend backend_gma500 =
{
.name = "gma500",
- .bo_create = gbm_dumb_bo_create,
- .bo_destroy = gbm_dumb_bo_destroy,
+ .bo_create = drv_dumb_bo_create,
+ .bo_destroy = drv_dumb_bo_destroy,
.format_list = {
- {GBM_FORMAT_RGBX8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
+ {DRV_FORMAT_RGBX8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
}
};
#include <string.h>
#include <xf86drm.h>
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
#include "util.h"
-size_t gbm_num_planes_from_format(uint32_t format)
+size_t drv_num_planes_from_format(uint32_t format)
{
switch(format)
{
- case GBM_FORMAT_C8:
- case GBM_FORMAT_R8:
- case GBM_FORMAT_RG88:
- case GBM_FORMAT_GR88:
- case GBM_FORMAT_RGB332:
- case GBM_FORMAT_BGR233:
- case GBM_FORMAT_XRGB4444:
- case GBM_FORMAT_XBGR4444:
- case GBM_FORMAT_RGBX4444:
- case GBM_FORMAT_BGRX4444:
- case GBM_FORMAT_ARGB4444:
- case GBM_FORMAT_ABGR4444:
- case GBM_FORMAT_RGBA4444:
- case GBM_FORMAT_BGRA4444:
- case GBM_FORMAT_XRGB1555:
- case GBM_FORMAT_XBGR1555:
- case GBM_FORMAT_RGBX5551:
- case GBM_FORMAT_BGRX5551:
- case GBM_FORMAT_ARGB1555:
- case GBM_FORMAT_ABGR1555:
- case GBM_FORMAT_RGBA5551:
- case GBM_FORMAT_BGRA5551:
- case GBM_FORMAT_RGB565:
- case GBM_FORMAT_BGR565:
- case GBM_FORMAT_YUYV:
- case GBM_FORMAT_YVYU:
- case GBM_FORMAT_UYVY:
- case GBM_FORMAT_VYUY:
- case GBM_FORMAT_RGB888:
- case GBM_FORMAT_BGR888:
- case GBM_FORMAT_XRGB8888:
- case GBM_FORMAT_XBGR8888:
- case GBM_FORMAT_RGBX8888:
- case GBM_FORMAT_BGRX8888:
- case GBM_FORMAT_ARGB8888:
- case GBM_FORMAT_ABGR8888:
- case GBM_FORMAT_RGBA8888:
- case GBM_FORMAT_BGRA8888:
- case GBM_FORMAT_XRGB2101010:
- case GBM_FORMAT_XBGR2101010:
- case GBM_FORMAT_RGBX1010102:
- case GBM_FORMAT_BGRX1010102:
- case GBM_FORMAT_ARGB2101010:
- case GBM_FORMAT_ABGR2101010:
- case GBM_FORMAT_RGBA1010102:
- case GBM_FORMAT_BGRA1010102:
- case GBM_FORMAT_AYUV:
+ case DRV_FORMAT_C8:
+ case DRV_FORMAT_R8:
+ case DRV_FORMAT_RG88:
+ case DRV_FORMAT_GR88:
+ case DRV_FORMAT_RGB332:
+ case DRV_FORMAT_BGR233:
+ case DRV_FORMAT_XRGB4444:
+ case DRV_FORMAT_XBGR4444:
+ case DRV_FORMAT_RGBX4444:
+ case DRV_FORMAT_BGRX4444:
+ case DRV_FORMAT_ARGB4444:
+ case DRV_FORMAT_ABGR4444:
+ case DRV_FORMAT_RGBA4444:
+ case DRV_FORMAT_BGRA4444:
+ case DRV_FORMAT_XRGB1555:
+ case DRV_FORMAT_XBGR1555:
+ case DRV_FORMAT_RGBX5551:
+ case DRV_FORMAT_BGRX5551:
+ case DRV_FORMAT_ARGB1555:
+ case DRV_FORMAT_ABGR1555:
+ case DRV_FORMAT_RGBA5551:
+ case DRV_FORMAT_BGRA5551:
+ case DRV_FORMAT_RGB565:
+ case DRV_FORMAT_BGR565:
+ case DRV_FORMAT_YUYV:
+ case DRV_FORMAT_YVYU:
+ case DRV_FORMAT_UYVY:
+ case DRV_FORMAT_VYUY:
+ case DRV_FORMAT_RGB888:
+ case DRV_FORMAT_BGR888:
+ case DRV_FORMAT_XRGB8888:
+ case DRV_FORMAT_XBGR8888:
+ case DRV_FORMAT_RGBX8888:
+ case DRV_FORMAT_BGRX8888:
+ case DRV_FORMAT_ARGB8888:
+ case DRV_FORMAT_ABGR8888:
+ case DRV_FORMAT_RGBA8888:
+ case DRV_FORMAT_BGRA8888:
+ case DRV_FORMAT_XRGB2101010:
+ case DRV_FORMAT_XBGR2101010:
+ case DRV_FORMAT_RGBX1010102:
+ case DRV_FORMAT_BGRX1010102:
+ case DRV_FORMAT_ARGB2101010:
+ case DRV_FORMAT_ABGR2101010:
+ case DRV_FORMAT_RGBA1010102:
+ case DRV_FORMAT_BGRA1010102:
+ case DRV_FORMAT_AYUV:
return 1;
- case GBM_FORMAT_NV12:
+ case DRV_FORMAT_NV12:
return 2;
}
- fprintf(stderr, "minigbm: UNKNOWN FORMAT %d\n", format);
+ fprintf(stderr, "drv: UNKNOWN FORMAT %d\n", format);
return 0;
}
-int gbm_bpp_from_format(uint32_t format)
+int drv_bpp_from_format(uint32_t format)
{
switch(format)
{
- case GBM_FORMAT_C8:
- case GBM_FORMAT_R8:
- case GBM_FORMAT_RGB332:
- case GBM_FORMAT_BGR233:
+ case DRV_FORMAT_C8:
+ case DRV_FORMAT_R8:
+ case DRV_FORMAT_RGB332:
+ case DRV_FORMAT_BGR233:
return 8;
- case GBM_FORMAT_NV12:
+ case DRV_FORMAT_NV12:
return 12;
- case GBM_FORMAT_RG88:
- case GBM_FORMAT_GR88:
- case GBM_FORMAT_XRGB4444:
- case GBM_FORMAT_XBGR4444:
- case GBM_FORMAT_RGBX4444:
- case GBM_FORMAT_BGRX4444:
- case GBM_FORMAT_ARGB4444:
- case GBM_FORMAT_ABGR4444:
- case GBM_FORMAT_RGBA4444:
- case GBM_FORMAT_BGRA4444:
- case GBM_FORMAT_XRGB1555:
- case GBM_FORMAT_XBGR1555:
- case GBM_FORMAT_RGBX5551:
- case GBM_FORMAT_BGRX5551:
- case GBM_FORMAT_ARGB1555:
- case GBM_FORMAT_ABGR1555:
- case GBM_FORMAT_RGBA5551:
- case GBM_FORMAT_BGRA5551:
- case GBM_FORMAT_RGB565:
- case GBM_FORMAT_BGR565:
- case GBM_FORMAT_YUYV:
- case GBM_FORMAT_YVYU:
- case GBM_FORMAT_UYVY:
- case GBM_FORMAT_VYUY:
+ case DRV_FORMAT_RG88:
+ case DRV_FORMAT_GR88:
+ case DRV_FORMAT_XRGB4444:
+ case DRV_FORMAT_XBGR4444:
+ case DRV_FORMAT_RGBX4444:
+ case DRV_FORMAT_BGRX4444:
+ case DRV_FORMAT_ARGB4444:
+ case DRV_FORMAT_ABGR4444:
+ case DRV_FORMAT_RGBA4444:
+ case DRV_FORMAT_BGRA4444:
+ case DRV_FORMAT_XRGB1555:
+ case DRV_FORMAT_XBGR1555:
+ case DRV_FORMAT_RGBX5551:
+ case DRV_FORMAT_BGRX5551:
+ case DRV_FORMAT_ARGB1555:
+ case DRV_FORMAT_ABGR1555:
+ case DRV_FORMAT_RGBA5551:
+ case DRV_FORMAT_BGRA5551:
+ case DRV_FORMAT_RGB565:
+ case DRV_FORMAT_BGR565:
+ case DRV_FORMAT_YUYV:
+ case DRV_FORMAT_YVYU:
+ case DRV_FORMAT_UYVY:
+ case DRV_FORMAT_VYUY:
return 16;
- case GBM_FORMAT_RGB888:
- case GBM_FORMAT_BGR888:
+ case DRV_FORMAT_RGB888:
+ case DRV_FORMAT_BGR888:
return 24;
- case GBM_FORMAT_XRGB8888:
- case GBM_FORMAT_XBGR8888:
- case GBM_FORMAT_RGBX8888:
- case GBM_FORMAT_BGRX8888:
- case GBM_FORMAT_ARGB8888:
- case GBM_FORMAT_ABGR8888:
- case GBM_FORMAT_RGBA8888:
- case GBM_FORMAT_BGRA8888:
- case GBM_FORMAT_XRGB2101010:
- case GBM_FORMAT_XBGR2101010:
- case GBM_FORMAT_RGBX1010102:
- case GBM_FORMAT_BGRX1010102:
- case GBM_FORMAT_ARGB2101010:
- case GBM_FORMAT_ABGR2101010:
- case GBM_FORMAT_RGBA1010102:
- case GBM_FORMAT_BGRA1010102:
- case GBM_FORMAT_AYUV:
+ case DRV_FORMAT_XRGB8888:
+ case DRV_FORMAT_XBGR8888:
+ case DRV_FORMAT_RGBX8888:
+ case DRV_FORMAT_BGRX8888:
+ case DRV_FORMAT_ARGB8888:
+ case DRV_FORMAT_ABGR8888:
+ case DRV_FORMAT_RGBA8888:
+ case DRV_FORMAT_BGRA8888:
+ case DRV_FORMAT_XRGB2101010:
+ case DRV_FORMAT_XBGR2101010:
+ case DRV_FORMAT_RGBX1010102:
+ case DRV_FORMAT_BGRX1010102:
+ case DRV_FORMAT_ARGB2101010:
+ case DRV_FORMAT_ABGR2101010:
+ case DRV_FORMAT_RGBA1010102:
+ case DRV_FORMAT_BGRA1010102:
+ case DRV_FORMAT_AYUV:
return 32;
}
- fprintf(stderr, "minigbm: UNKNOWN FORMAT %d\n", format);
+ fprintf(stderr, "drv: UNKNOWN FORMAT %d\n", format);
return 0;
}
-int gbm_stride_from_format(uint32_t format, uint32_t width)
+int drv_stride_from_format(uint32_t format, uint32_t width)
{
/* Only single-plane formats are supported */
- assert(gbm_num_planes_from_format(format) == 1);
- return DIV_ROUND_UP(width * gbm_bpp_from_format(format), 8);
+ assert(drv_num_planes_from_format(format) == 1);
+ return DIV_ROUND_UP(width * drv_bpp_from_format(format), 8);
}
-int gbm_is_format_supported(struct gbm_bo *bo)
-{
- return 1;
-}
-
-int gbm_dumb_bo_create(struct gbm_bo *bo, uint32_t width, uint32_t height,
+int drv_dumb_bo_create(struct bo *bo, uint32_t width, uint32_t height,
uint32_t format, uint32_t flags)
{
struct drm_mode_create_dumb create_dumb;
int ret;
/* Only single-plane formats are supported */
- assert(gbm_num_planes_from_format(format) == 1);
+ assert(drv_num_planes_from_format(format) == 1);
memset(&create_dumb, 0, sizeof(create_dumb));
create_dumb.height = height;
create_dumb.width = width;
- create_dumb.bpp = gbm_bpp_from_format(format);
+ create_dumb.bpp = drv_bpp_from_format(format);
create_dumb.flags = 0;
- ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
+ ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_MODE_CREATE_DUMB failed\n");
+ fprintf(stderr, "drv: DRM_IOCTL_MODE_CREATE_DUMB failed\n");
return ret;
}
return 0;
}
-int gbm_dumb_bo_destroy(struct gbm_bo *bo)
+int drv_dumb_bo_destroy(struct bo *bo)
{
struct drm_mode_destroy_dumb destroy_dumb;
int ret;
memset(&destroy_dumb, 0, sizeof(destroy_dumb));
destroy_dumb.handle = bo->handles[0].u32;
- ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
+ ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_MODE_DESTROY_DUMB failed "
+ fprintf(stderr, "drv: DRM_IOCTL_MODE_DESTROY_DUMB failed "
"(handle=%x)\n", bo->handles[0].u32);
return ret;
}
return 0;
}
-int gbm_gem_bo_destroy(struct gbm_bo *bo)
+int drv_gem_bo_destroy(struct bo *bo)
{
struct drm_gem_close gem_close;
int ret, error = 0;
memset(&gem_close, 0, sizeof(gem_close));
gem_close.handle = bo->handles[plane].u32;
- ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
+ ret = drmIoctl(bo->drv->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_GEM_CLOSE failed "
+ fprintf(stderr, "drv: DRM_IOCTL_GEM_CLOSE failed "
"(handle=%x) error %d\n",
bo->handles[plane].u32, ret);
error = ret;
#ifndef HELPERS_H
#define HELPERS_H
-size_t gbm_num_planes_from_format(uint32_t format);
-int gbm_bpp_from_format(uint32_t format);
-int gbm_stride_from_format(uint32_t format, uint32_t width);
-int gbm_is_format_supported(struct gbm_bo *bo);
-int gbm_dumb_bo_create(struct gbm_bo *bo, uint32_t width, uint32_t height,
+#include "drv.h"
+
+size_t drv_num_planes_from_format(uint32_t format);
+int drv_bpp_from_format(uint32_t format);
+int drv_stride_from_format(uint32_t format, uint32_t width);
+int drv_dumb_bo_create(struct bo *bo, uint32_t width, uint32_t height,
uint32_t format, uint32_t flags);
-int gbm_dumb_bo_destroy(struct gbm_bo *bo);
-int gbm_gem_bo_destroy(struct gbm_bo *bo);
+int drv_dumb_bo_destroy(struct bo *bo);
+int drv_gem_bo_destroy(struct bo *bo);
#endif
* found in the LICENSE file.
*/
-#ifdef GBM_I915
+#ifdef DRV_I915
#include <stdio.h>
#include <errno.h>
#include <xf86drm.h>
#include <i915_drm.h>
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
#include "util.h"
-struct gbm_i915_device
+struct i915_device
{
int gen;
};
return 4;
}
-static int gbm_i915_init(struct gbm_device *gbm)
+static int drv_i915_init(struct driver *drv)
{
- struct gbm_i915_device *i915_gbm;
+ struct i915_device *i915_drv;
drm_i915_getparam_t get_param;
int device_id;
int ret;
- i915_gbm = (struct gbm_i915_device*)malloc(sizeof(*i915_gbm));
- if (!i915_gbm)
+ i915_drv = (struct i915_device*)malloc(sizeof(*i915_drv));
+ if (!i915_drv)
return -1;
memset(&get_param, 0, sizeof(get_param));
get_param.param = I915_PARAM_CHIPSET_ID;
get_param.value = &device_id;
- ret = drmIoctl(gbm->fd, DRM_IOCTL_I915_GETPARAM, &get_param);
+ ret = drmIoctl(drv->fd, DRM_IOCTL_I915_GETPARAM, &get_param);
if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_I915_GETPARAM failed\n");
- free(i915_gbm);
+ fprintf(stderr, "drv: DRM_IOCTL_I915_GETPARAM failed\n");
+ free(i915_drv);
return -1;
}
- i915_gbm->gen = get_gen(device_id);
+ i915_drv->gen = get_gen(device_id);
- gbm->priv = i915_gbm;
+ drv->priv = i915_drv;
return 0;
}
-static void gbm_i915_close(struct gbm_device *gbm)
+static void drv_i915_close(struct driver *drv)
{
- free(gbm->priv);
- gbm->priv = NULL;
+ free(drv->priv);
+ drv->priv = NULL;
}
-static void i915_align_dimensions(struct gbm_device *gbm, uint32_t tiling_mode,
+static void i915_align_dimensions(struct driver *drv, uint32_t tiling_mode,
uint32_t *width, uint32_t *height, int bpp)
{
- struct gbm_i915_device *i915_gbm = (struct gbm_i915_device *)gbm->priv;
+ struct i915_device *i915_drv = (struct i915_device *)drv->priv;
uint32_t width_alignment = 4, height_alignment = 4;
switch(tiling_mode) {
break;
case I915_TILING_Y:
- if (i915_gbm->gen == 3) {
+ if (i915_drv->gen == 3) {
width_alignment = 512 / bpp;
height_alignment = 8;
} else {
break;
}
- if (i915_gbm->gen > 3) {
+ if (i915_drv->gen > 3) {
*width = ALIGN(*width, width_alignment);
*height = ALIGN(*height, height_alignment);
} else {
}
}
-static int i915_verify_dimensions(struct gbm_device *gbm, uint32_t stride,
+static int i915_verify_dimensions(struct driver *drv, uint32_t stride,
uint32_t height)
{
- struct gbm_i915_device *i915_gbm = (struct gbm_i915_device *)gbm->priv;
- if (i915_gbm->gen <= 3 && stride > 8192)
+ struct i915_device *i915_drv = (struct i915_device *)drv->priv;
+ if (i915_drv->gen <= 3 && stride > 8192)
return 0;
return 1;
}
-static int gbm_i915_bo_create(struct gbm_bo *bo,
+static int drv_i915_bo_create(struct bo *bo,
uint32_t width, uint32_t height,
uint32_t format, uint32_t flags)
{
- struct gbm_device *gbm = bo->gbm;
- int bpp = gbm_stride_from_format(format, 1);
+ struct driver *drv = bo->drv;
+ int bpp = drv_stride_from_format(format, 1);
struct drm_i915_gem_create gem_create;
struct drm_i915_gem_set_tiling gem_set_tiling;
uint32_t tiling_mode = I915_TILING_NONE;
size_t size;
int ret;
- if (flags & (GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR))
+ if (flags & (DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR))
tiling_mode = I915_TILING_NONE;
- else if (flags & GBM_BO_USE_SCANOUT)
+ else if (flags & DRV_BO_USE_SCANOUT)
tiling_mode = I915_TILING_X;
- else if (flags & GBM_BO_USE_RENDERING)
+ else if (flags & DRV_BO_USE_RENDERING)
tiling_mode = I915_TILING_Y;
- i915_align_dimensions(gbm, tiling_mode, &width, &height, bpp);
+ i915_align_dimensions(drv, tiling_mode, &width, &height, bpp);
bo->strides[0] = width * bpp;
- if (!i915_verify_dimensions(gbm, bo->strides[0], height))
+ if (!i915_verify_dimensions(drv, bo->strides[0], height))
return EINVAL;
memset(&gem_create, 0, sizeof(gem_create));
size = width * height * bpp;
gem_create.size = size;
- ret = drmIoctl(gbm->fd, DRM_IOCTL_I915_GEM_CREATE, &gem_create);
+ ret = drmIoctl(drv->fd, DRM_IOCTL_I915_GEM_CREATE, &gem_create);
if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_I915_GEM_CREATE failed "
+ fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_CREATE failed "
"(size=%zu)\n", size);
return ret;
}
gem_set_tiling.handle = bo->handles[0].u32;
gem_set_tiling.tiling_mode = tiling_mode;
gem_set_tiling.stride = bo->strides[0];
- ret = drmIoctl(gbm->fd, DRM_IOCTL_I915_GEM_SET_TILING,
+ ret = drmIoctl(drv->fd, DRM_IOCTL_I915_GEM_SET_TILING,
&gem_set_tiling);
} while (ret == -1 && (errno == EINTR || errno == EAGAIN));
if (ret == -1) {
struct drm_gem_close gem_close;
gem_close.handle = bo->handles[0].u32;
- fprintf(stderr, "minigbm: DRM_IOCTL_I915_GEM_SET_TILING failed "
+ fprintf(stderr, "drv: DRM_IOCTL_I915_GEM_SET_TILING failed "
"errno=%x (handle=%x, tiling=%x, stride=%x)\n",
errno,
gem_set_tiling.handle,
gem_set_tiling.tiling_mode,
gem_set_tiling.stride);
- drmIoctl(gbm->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
+ drmIoctl(drv->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
return -errno;
}
return 0;
}
-const struct gbm_driver gbm_driver_i915 =
+const struct backend backend_i915 =
{
.name = "i915",
- .init = gbm_i915_init,
- .close = gbm_i915_close,
- .bo_create = gbm_i915_bo_create,
- .bo_destroy = gbm_gem_bo_destroy,
+ .init = drv_i915_init,
+ .close = drv_i915_close,
+ .bo_create = drv_i915_bo_create,
+ .bo_destroy = drv_gem_bo_destroy,
.format_list = {
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_XBGR8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ABGR8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB1555, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB1555, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_RGB565, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_UYVY, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_UYVY, GBM_BO_USE_SCANOUT | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_YUYV, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_YUYV, GBM_BO_USE_SCANOUT | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_R8, GBM_BO_USE_RENDERING | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_GR88, GBM_BO_USE_RENDERING | GBM_BO_USE_LINEAR},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_XBGR8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ABGR8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB1555, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB1555, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_RGB565, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_UYVY, DRV_BO_USE_SCANOUT | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_UYVY, DRV_BO_USE_SCANOUT | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_YUYV, DRV_BO_USE_SCANOUT | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_YUYV, DRV_BO_USE_SCANOUT | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_R8, DRV_BO_USE_RENDERING | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_GR88, DRV_BO_USE_RENDERING | DRV_BO_USE_LINEAR},
}
};
* found in the LICENSE file.
*/
-#ifdef GBM_MARVELL
+#ifdef DRV_MARVELL
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
-const struct gbm_driver gbm_driver_marvell =
+const struct backend backend_marvell =
{
.name = "marvell",
- .bo_create = gbm_dumb_bo_create,
- .bo_destroy = gbm_dumb_bo_destroy,
+ .bo_create = drv_dumb_bo_create,
+ .bo_destroy = drv_dumb_bo_destroy,
.format_list = {
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
}
};
* found in the LICENSE file.
*/
-#ifdef GBM_MEDIATEK
+#ifdef DRV_MEDIATEK
#include <stdio.h>
#include <string.h>
#include <xf86drm.h>
#include <mediatek_drm.h>
#include <stdio.h>
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
-static int gbm_mediatek_bo_create(struct gbm_bo *bo,
+static int drv_mediatek_bo_create(struct bo *bo,
uint32_t width, uint32_t height,
uint32_t format, uint32_t flags)
{
struct drm_mtk_gem_create gem_create;
int ret;
- bo->strides[0] = gbm_stride_from_format(format, width);
+ bo->strides[0] = drv_stride_from_format(format, width);
size = height * bo->strides[0];
memset(&gem_create, 0, sizeof(gem_create));
gem_create.size = size;
- ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_MTK_GEM_CREATE, &gem_create);
+ ret = drmIoctl(bo->drv->fd, DRM_IOCTL_MTK_GEM_CREATE, &gem_create);
if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_MTK_GEM_CREATE failed "
+ fprintf(stderr, "drv: DRM_IOCTL_MTK_GEM_CREATE failed "
"(size=%zu)\n", size);
return ret;
}
return 0;
}
-const struct gbm_driver gbm_driver_mediatek =
+const struct backend backend_mediatek =
{
.name = "mediatek",
- .bo_create = gbm_mediatek_bo_create,
- .bo_destroy = gbm_gem_bo_destroy,
+ .bo_create = drv_mediatek_bo_create,
+ .bo_destroy = drv_gem_bo_destroy,
.format_list = {
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
}
};
* found in the LICENSE file.
*/
-#ifdef GBM_ROCKCHIP
+#ifdef DRV_ROCKCHIP
#include <assert.h>
#include <errno.h>
#include <xf86drm.h>
#include <rockchip_drm.h>
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
#include "util.h"
-static int gbm_rockchip_bo_create(struct gbm_bo *bo,
+static int drv_rockchip_bo_create(struct bo *bo,
uint32_t width, uint32_t height,
uint32_t format, uint32_t flags)
{
size_t plane;
switch (format) {
- case GBM_FORMAT_NV12:
+ case DRV_FORMAT_NV12:
width = ALIGN(width, 4);
height = ALIGN(height, 4);
bo->strides[0] = bo->strides[1] = width;
bo->offsets[0] = 0;
bo->offsets[1] = height * bo->strides[0];
break;
- case GBM_FORMAT_XRGB8888:
- case GBM_FORMAT_ARGB8888:
- case GBM_FORMAT_ABGR8888:
- bo->strides[0] = gbm_stride_from_format(format, width);
+ case DRV_FORMAT_XRGB8888:
+ case DRV_FORMAT_ARGB8888:
+ case DRV_FORMAT_ABGR8888:
+ bo->strides[0] = drv_stride_from_format(format, width);
bo->sizes[0] = height * bo->strides[0];
bo->offsets[0] = 0;
break;
default:
- fprintf(stderr, "minigbm: rockchip: unsupported format %4.4s\n",
+ fprintf(stderr, "drv: rockchip: unsupported format %4.4s\n",
(char*)&format);
assert(0);
return -EINVAL;
memset(&gem_create, 0, sizeof(gem_create));
gem_create.size = size;
- ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_ROCKCHIP_GEM_CREATE,
+ ret = drmIoctl(bo->drv->fd, DRM_IOCTL_ROCKCHIP_GEM_CREATE,
&gem_create);
if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_ROCKCHIP_GEM_CREATE failed "
+ fprintf(stderr, "drv: DRM_IOCTL_ROCKCHIP_GEM_CREATE failed "
"(size=%zu)\n", size);
}
else {
return ret;
}
-const struct gbm_driver gbm_driver_rockchip =
+const struct backend backend_rockchip =
{
.name = "rockchip",
- .bo_create = gbm_rockchip_bo_create,
- .bo_destroy = gbm_gem_bo_destroy,
+ .bo_create = drv_rockchip_bo_create,
+ .bo_destroy = drv_gem_bo_destroy,
.format_list = {
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ABGR8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_NV12, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_NV12, GBM_BO_USE_SCANOUT | GBM_BO_USE_LINEAR},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ABGR8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_NV12, DRV_BO_USE_SCANOUT | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_NV12, DRV_BO_USE_SCANOUT | DRV_BO_USE_LINEAR},
}
};
* found in the LICENSE file.
*/
-#ifdef GBM_TEGRA
+#ifdef DRV_TEGRA
#include <stdio.h>
#include <string.h>
#include <xf86drm.h>
#include <tegra_drm.h>
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
#include "util.h"
uint32_t *block_height_log2,
uint32_t *stride, uint32_t *size)
{
- int pitch = gbm_stride_from_format(format, width);
+ int pitch = drv_stride_from_format(format, width);
/* Align to blocklinear blocks. */
pitch = ALIGN(pitch, NV_BLOCKLINEAR_GOB_WIDTH);
static void compute_layout_linear(int width, int height, int format,
uint32_t *stride, uint32_t *size)
{
- *stride = gbm_stride_from_format(format, width);
+ *stride = drv_stride_from_format(format, width);
*size = *stride * height;
}
-static int gbm_tegra_bo_create(struct gbm_bo *bo, uint32_t width,
+static int drv_tegra_bo_create(struct bo *bo, uint32_t width,
uint32_t height, uint32_t format, uint32_t flags)
{
uint32_t size, stride, block_height_log2 = 0;
struct drm_tegra_gem_create gem_create;
int ret;
- if (flags & GBM_BO_USE_RENDERING)
+ if (flags & DRV_BO_USE_RENDERING)
compute_layout_blocklinear(width, height, format, &kind,
&block_height_log2, &stride, &size);
else
gem_create.size = size;
gem_create.flags = 0;
- ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_TEGRA_GEM_CREATE, &gem_create);
+ ret = drmIoctl(bo->drv->fd, DRM_IOCTL_TEGRA_GEM_CREATE, &gem_create);
if (ret) {
- fprintf(stderr, "minigbm: DRM_IOCTL_TEGRA_GEM_CREATE failed "
+ fprintf(stderr, "drv: DRM_IOCTL_TEGRA_GEM_CREATE failed "
"(size=%zu)\n", size);
return ret;
}
gem_tile.mode = DRM_TEGRA_GEM_TILING_MODE_BLOCK;
gem_tile.value = block_height_log2;
- ret = drmCommandWriteRead(bo->gbm->fd, DRM_TEGRA_GEM_SET_TILING,
+ ret = drmCommandWriteRead(bo->drv->fd, DRM_TEGRA_GEM_SET_TILING,
&gem_tile, sizeof(gem_tile));
if (ret < 0) {
- gbm_gem_bo_destroy(bo);
+ drv_gem_bo_destroy(bo);
return ret;
}
/* Encode blocklinear parameters for EGLImage creation. */
bo->tiling = (kind & 0xff) |
((block_height_log2 & 0xf) << 8);
- bo->format_modifiers[0] = gbm_fourcc_mod_code(NV, bo->tiling);
+ bo->format_modifiers[0] = drv_fourcc_mod_code(NV, bo->tiling);
}
return 0;
}
-const struct gbm_driver gbm_driver_tegra =
+const struct backend backend_tegra =
{
.name = "tegra",
- .bo_create = gbm_tegra_bo_create,
- .bo_destroy = gbm_gem_bo_destroy,
+ .bo_create = drv_tegra_bo_create,
+ .bo_destroy = drv_gem_bo_destroy,
.format_list = {
/* Linear support */
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
/* Blocklinear support */
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_RENDERING},
}
};
* found in the LICENSE file.
*/
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
-const struct gbm_driver gbm_driver_udl =
+const struct backend backend_udl =
{
.name = "udl",
- .bo_create = gbm_dumb_bo_create,
- .bo_destroy = gbm_dumb_bo_destroy,
+ .bo_create = drv_dumb_bo_create,
+ .bo_destroy = drv_dumb_bo_destroy,
.format_list = {
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
}
};
* found in the LICENSE file.
*/
-#include "gbm_priv.h"
+#include "drv_priv.h"
#include "helpers.h"
-const struct gbm_driver gbm_driver_virtio_gpu =
+const struct backend backend_virtio_gpu =
{
.name = "virtio_gpu",
- .bo_create = gbm_dumb_bo_create,
- .bo_destroy = gbm_dumb_bo_destroy,
+ .bo_create = drv_dumb_bo_create,
+ .bo_destroy = drv_dumb_bo_destroy,
.format_list = {
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_XRGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_RENDERING},
- {GBM_FORMAT_ARGB8888, GBM_BO_USE_SCANOUT | GBM_BO_USE_CURSOR | GBM_BO_USE_LINEAR},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_XRGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_RENDERING},
+ {DRV_FORMAT_ARGB8888, DRV_BO_USE_SCANOUT | DRV_BO_USE_CURSOR | DRV_BO_USE_LINEAR},
}
};
OSDN Git Service
