lineage-rockchip/android_external_minigbm
1
0
Fork 0
Code Activity Actions

minigbm: Refactored minigbm on top a private API

Browse source 
We would like to reuse the same set of drivers for ChromeOS (with
a minigbm frontend) and Android (with a gralloc frontend).  Since
we don't want to pollute the gbm API with gralloc formats and usages,
we can refactor minigbm on top a private API that will be a superset
of gbm and gralloc.  This change redirects gbm calls to the
private API.

TEST=Ran graphics_Gbm on minnie and cyan, and checked if Chrome boots.
BUG=chromium:616275

CQ-DEPEND=CL:367791

Change-Id: I50d10f9d6c7ea936b0d76c5299a58d948939fdf9
Reviewed-on: https://chromium-review.googlesource.com/367780
Commit-Ready: Gurchetan Singh <gurchetansingh@chromium.org>
Tested-by: Gurchetan Singh <gurchetansingh@chromium.org>
Reviewed-by: Stéphane Marchesin <marcheu@chromium.org>
This commit is contained in:
Gurchetan Singh 2016-08-05 14:40:07 -07:00 • committed by chrome-bot
parent 0fd114250d
commit 46faf6bf43
21 changed files with 1067 additions and 497 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Makefile
View file

@ -11,13 +11,13 @@ PC_LIBS := $(shell $(PKG_CONFIG) --libs $(PC_DEPS))
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

18
cirrus.c
View file

@ -4,19 +4,19 @@
* 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},
}
};

305
drv.c Normal file
View file

@ -0,0 +1,305 @@
/*
* 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];
}

186
drv.h Normal file
View file

@ -0,0 +1,186 @@
/*
* 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

53
drv_priv.h Normal file
View file

@ -0,0 +1,53 @@
/*
* 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

16
evdi.c
View file

@ -4,19 +4,19 @@
* 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},
}
};

38
exynos.c
View file

@ -4,7 +4,7 @@
* found in the LICENSE file.
*/
#ifdef GBM_EXYNOS
#ifdef DRV_EXYNOS
#include <assert.h>
#include <errno.h>
@ -13,17 +13,17 @@
#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);
@ -34,12 +34,12 @@ static int gbm_exynos_bo_create(struct gbm_bo *bo,
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;
}
@ -53,9 +53,9 @@ static int gbm_exynos_bo_create(struct gbm_bo *bo,
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;
}
@ -70,11 +70,11 @@ 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);
}
}
@ -82,17 +82,17 @@ cleanup_planes:
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},
}
};

209
gbm.c
View file

@ -12,148 +12,62 @@
#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;
drv_format = gbm_convert_format(format);
drv_usage = gbm_convert_flags(usage);
if (gbm->driver->format_list[i].format == format &&
(gbm->driver->format_list[i].usage & usage) == usage)
return 1;
}
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);
}
@ -185,9 +99,7 @@ PUBLIC void gbm_surface_release_buffer(struct gbm_surface *surface,
{
}
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;
@ -196,14 +108,7 @@ static struct gbm_bo *gbm_bo_new(struct gbm_device *gbm,
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;
}
@ -213,17 +118,20 @@ PUBLIC struct gbm_bo *gbm_bo_create(struct gbm_device *gbm, uint32_t width,
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;
}
@ -239,7 +147,7 @@ PUBLIC void gbm_bo_destroy(struct gbm_bo *bo)
bo->user_data = NULL;
}
bo->gbm->driver->bo_destroy(bo);
drv_bo_destroy(bo->bo);
free(bo);
}
@ -247,10 +155,9 @@ PUBLIC struct gbm_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;
@ -258,44 +165,37 @@ gbm_bo_import(struct gbm_device *gbm, uint32_t type,
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
@ -307,13 +207,13 @@ gbm_bo_get_stride(struct gbm_bo *bo)
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
@ -343,62 +243,43 @@ gbm_bo_get_fd(struct gbm_bo *bo)
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

161
gbm_helpers.c Normal file
View file

@ -0,0 +1,161 @@
/*
* 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;
}

13
gbm_helpers.h Normal file
View file

@ -0,0 +1,13 @@
/*
* 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

35
gbm_priv.h
View file

@ -10,15 +10,13 @@
#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
@ -28,33 +26,10 @@ 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

10
gma500.c
View file

@ -4,15 +4,15 @@
* 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},
}
};

235
helpers.c
View file

@ -11,167 +11,162 @@
#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;
}
@ -183,7 +178,7 @@ int gbm_dumb_bo_create(struct gbm_bo *bo, uint32_t width, uint32_t height,
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;
@ -191,9 +186,9 @@ int gbm_dumb_bo_destroy(struct gbm_bo *bo)
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;
}
@ -201,7 +196,7 @@ int gbm_dumb_bo_destroy(struct gbm_bo *bo)
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;
@ -218,9 +213,9 @@ int gbm_gem_bo_destroy(struct gbm_bo *bo)
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;

15
helpers.h
View file

@ -7,13 +7,14 @@
#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

110
i915.c
View file

@ -4,7 +4,7 @@
* found in the LICENSE file.
*/
#ifdef GBM_I915
#ifdef DRV_I915
#include <stdio.h>
#include <errno.h>
@ -13,11 +13,11 @@
#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;
};
@ -35,44 +35,44 @@ static int get_gen(int device_id)
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) {
@ -87,7 +87,7 @@ static void i915_align_dimensions(struct gbm_device *gbm, uint32_t 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 {
@ -97,7 +97,7 @@ static void i915_align_dimensions(struct gbm_device *gbm, uint32_t tiling_mode,
break;
}
if (i915_gbm->gen > 3) {
if (i915_drv->gen > 3) {
*width = ALIGN(*width, width_alignment);
*height = ALIGN(*height, height_alignment);
} else {
@ -109,49 +109,49 @@ static void i915_align_dimensions(struct gbm_device *gbm, uint32_t tiling_mode,
}
}
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;
}
@ -164,49 +164,49 @@ static int gbm_i915_bo_create(struct gbm_bo *bo,
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},
}
};

18
marvell.c
View file

@ -4,21 +4,21 @@
* 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},
}
};

26
mediatek.c
View file

@ -4,17 +4,17 @@
* 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)
{
@ -22,15 +22,15 @@ static int gbm_mediatek_bo_create(struct gbm_bo *bo,
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;
}
@ -42,16 +42,16 @@ static int gbm_mediatek_bo_create(struct gbm_bo *bo,
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},
}
};

42
rockchip.c
View file

@ -4,7 +4,7 @@
* found in the LICENSE file.
*/
#ifdef GBM_ROCKCHIP
#ifdef DRV_ROCKCHIP
#include <assert.h>
#include <errno.h>
@ -13,18 +13,18 @@
#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;
@ -33,15 +33,15 @@ static int gbm_rockchip_bo_create(struct gbm_bo *bo,
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;
@ -58,11 +58,11 @@ static int gbm_rockchip_bo_create(struct gbm_bo *bo,
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 {
@ -73,19 +73,19 @@ static int gbm_rockchip_bo_create(struct gbm_bo *bo,
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},
}
};

36
tegra.c
View file

@ -4,14 +4,14 @@
* 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"
@ -55,7 +55,7 @@ static void compute_layout_blocklinear(int width, int height, int format,
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);
@ -82,11 +82,11 @@ static void compute_layout_blocklinear(int width, int height, int format,
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;
@ -94,7 +94,7 @@ static int gbm_tegra_bo_create(struct gbm_bo *bo, uint32_t width,
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
@ -104,9 +104,9 @@ static int gbm_tegra_bo_create(struct gbm_bo *bo, uint32_t width,
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;
}
@ -124,34 +124,34 @@ static int gbm_tegra_bo_create(struct gbm_bo *bo, uint32_t width,
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},
}
};

16
udl.c
View file

@ -4,18 +4,18 @@
* 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},
}
};

16
virtio_gpu.c
View file

@ -4,19 +4,19 @@
* 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},
}
};