remove enum gbm_bo_format

[android-x86/external-minigbm.git] / gbm.c

diff --git a/gbm.c b/gbm.c
index 10b0bcd..06da310 100644 (file)
--- a/gbm.c
+++ b/gbm.c
@@ -4,6 +4,7 @@
  * found in the LICENSE file.
  */
 
+#include <assert.h>
 #include <fcntl.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -16,6 +17,7 @@
 #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
@@ -23,6 +25,9 @@ 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
@@ -33,6 +38,7 @@ extern struct gbm_driver gbm_driver_rockchip;
 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)
 {
@@ -46,6 +52,7 @@ static struct gbm_driver *gbm_get_driver(int fd)
 
        struct gbm_driver *driver_list[] = {
                &gbm_driver_cirrus,
+               &gbm_driver_evdi,
 #ifdef GBM_EXYNOS
                &gbm_driver_exynos,
 #endif
@@ -53,6 +60,9 @@ static struct gbm_driver *gbm_get_driver(int fd)
 #ifdef GBM_I915
                &gbm_driver_i915,
 #endif
+#ifdef GBM_MARVELL
+               &gbm_driver_marvell,
+#endif
 #ifdef GBM_MEDIATEK
                &gbm_driver_mediatek,
 #endif
@@ -63,6 +73,7 @@ static struct gbm_driver *gbm_get_driver(int fd)
                &gbm_driver_tegra,
 #endif
                &gbm_driver_udl,
+               &gbm_driver_virtio_gpu,
        };
 
        for(i = 0; i < ARRAY_SIZE(driver_list); i++)
@@ -94,11 +105,6 @@ gbm_device_is_format_supported(struct gbm_device *gbm,
 {
        unsigned i;
 
-       if (format == GBM_BO_FORMAT_XRGB8888)
-               format = GBM_FORMAT_XRGB8888;
-       if (format == GBM_BO_FORMAT_ARGB8888)
-               format = GBM_FORMAT_ARGB8888;
-
        if (usage & GBM_BO_USE_CURSOR &&
                usage & GBM_BO_USE_RENDERING)
                return 0;
@@ -181,22 +187,23 @@ 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, uint32_t stride)
+                                uint32_t format)
 {
        struct gbm_bo *bo;
 
-       bo = (struct gbm_bo*) malloc(sizeof(*bo));
+       bo = (struct gbm_bo*) calloc(1, sizeof(*bo));
        if (!bo)
                return NULL;
 
        bo->gbm = gbm;
        bo->width = width;
        bo->height = height;
-       bo->stride = stride;
        bo->format = format;
-       bo->handle.u32 = 0;
-       bo->destroy_user_data = NULL;
-       bo->user_data = NULL;
+       bo->num_planes = gbm_num_planes_from_format(format);
+       if (!bo->num_planes) {
+               free(bo);
+               return NULL;
+       }
 
        return bo;
 }
@@ -208,8 +215,10 @@ PUBLIC struct gbm_bo *gbm_bo_create(struct gbm_device *gbm, uint32_t width,
        struct gbm_bo *bo;
        int ret;
 
-       bo = gbm_bo_new(gbm, width, height, format,
-                       width * gbm_bytes_from_format(format));
+       if (!gbm_device_is_format_supported(gbm, format, flags))
+               return NULL;
+
+       bo = gbm_bo_new(gbm, width, height, format);
        if (!bo)
                return NULL;
 
@@ -249,11 +258,19 @@ gbm_bo_import(struct gbm_device *gbm, uint32_t type,
        if (!gbm_device_is_format_supported(gbm, fd_data->format, usage))
                return NULL;
 
-       bo = gbm_bo_new(gbm, fd_data->width, fd_data->height, fd_data->format,
-                       fd_data->stride);
+       /* 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->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;
+
+       memset(&prime_handle, 0, sizeof(prime_handle));
        prime_handle.fd = fd_data->fd;
 
        ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &prime_handle);
@@ -264,7 +281,7 @@ gbm_bo_import(struct gbm_device *gbm, uint32_t type,
                return NULL;
        }
 
-       bo->handle.u32 = prime_handle.handle;
+       bo->handles[0].u32 = prime_handle.handle;
 
        return bo;
 }
@@ -284,13 +301,13 @@ gbm_bo_get_height(struct gbm_bo *bo)
 PUBLIC uint32_t
 gbm_bo_get_stride(struct gbm_bo *bo)
 {
-       return bo->stride;
+       return gbm_bo_get_plane_stride(bo, 0);
 }
 
 PUBLIC uint32_t
 gbm_bo_get_stride_or_tiling(struct gbm_bo *bo)
 {
-       return bo->tiling ? bo->tiling : bo->stride;
+       return bo->tiling ? bo->tiling : gbm_bo_get_stride(bo);
 }
 
 PUBLIC uint32_t
@@ -308,23 +325,69 @@ gbm_bo_get_device(struct gbm_bo *bo)
 PUBLIC union gbm_bo_handle
 gbm_bo_get_handle(struct gbm_bo *bo)
 {
-       return bo->handle;
+       return gbm_bo_get_plane_handle(bo, 0);
 }
 
 PUBLIC int
 gbm_bo_get_fd(struct gbm_bo *bo)
 {
+       return gbm_bo_get_plane_fd(bo, 0);
+}
+
+PUBLIC size_t
+gbm_bo_get_num_planes(struct gbm_bo *bo)
+{
+       return bo->num_planes;
+}
+
+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];
+}
+
+#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_handle(bo).u32,
-                               DRM_CLOEXEC,
-                               &fd))
+       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;
 }
 
+PUBLIC uint32_t
+gbm_bo_get_plane_offset(struct gbm_bo *bo, size_t plane)
+{
+       assert(plane < bo->num_planes);
+       return bo->offsets[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];
+}
+
+PUBLIC uint32_t
+gbm_bo_get_plane_stride(struct gbm_bo *bo, size_t plane)
+{
+       assert(plane < bo->num_planes);
+       return bo->strides[plane];
+}
+
 PUBLIC void
 gbm_bo_set_user_data(struct gbm_bo *bo, void *data,
                     void (*destroy_user_data)(struct gbm_bo *, void *))