gralloc0_register_buffer: initialize gralloc0 when needed

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

diff --git a/rockchip.c b/rockchip.c
index 5a907f0..5fb0be4 100644 (file)
--- a/rockchip.c
+++ b/rockchip.c
@@ -18,6 +18,11 @@
 #include "helpers.h"
 #include "util.h"
 
+struct rockchip_private_map_data {
+       void *cached_addr;
+       void *gem_addr;
+};
+
 static const uint32_t render_target_formats[] = { DRM_FORMAT_ABGR8888, DRM_FORMAT_ARGB8888,
                                                  DRM_FORMAT_RGB565, DRM_FORMAT_XBGR8888,
                                                  DRM_FORMAT_XRGB8888 };
@@ -73,29 +78,30 @@ static int rockchip_add_kms_item(struct driver *drv, const struct kms_item *item
 {
        int ret;
        uint32_t i, j;
-       uint64_t flags;
+       uint64_t use_flags;
        struct combination *combo;
        struct format_metadata metadata;
 
-       for (i = 0; i < drv->backend->combos.size; i++) {
-               combo = &drv->backend->combos.data[i];
+       for (i = 0; i < drv->combos.size; i++) {
+               combo = &drv->combos.data[i];
                if (combo->format == item->format) {
                        if (item->modifier == DRM_FORMAT_MOD_CHROMEOS_ROCKCHIP_AFBC) {
-                               flags = BO_USE_RENDERING | BO_USE_SCANOUT | BO_USE_TEXTURE;
+                               use_flags = BO_USE_RENDERING | BO_USE_SCANOUT | BO_USE_TEXTURE;
                                metadata.modifier = item->modifier;
                                metadata.tiling = 0;
                                metadata.priority = 2;
 
                                for (j = 0; j < ARRAY_SIZE(texture_source_formats); j++) {
                                        if (item->format == texture_source_formats[j])
-                                               flags &= ~BO_USE_RENDERING;
+                                               use_flags &= ~BO_USE_RENDERING;
                                }
 
-                               ret = drv_add_combination(drv, item[i].format, &metadata, flags);
+                               ret =
+                                   drv_add_combination(drv, item[i].format, &metadata, use_flags);
                                if (ret)
                                        return ret;
                        } else {
-                               combo->usage |= item->usage;
+                               combo->use_flags |= item->use_flags;
                        }
                }
        }
@@ -112,7 +118,7 @@ static int rockchip_init(struct driver *drv)
 
        metadata.tiling = 0;
        metadata.priority = 1;
-       metadata.modifier = DRM_FORMAT_MOD_NONE;
+       metadata.modifier = DRM_FORMAT_MOD_LINEAR;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
                                   &metadata, BO_USE_RENDER_MASK);
@@ -127,6 +133,16 @@ static int rockchip_init(struct driver *drv)
        drv_modify_combination(drv, DRM_FORMAT_XRGB8888, &metadata, BO_USE_CURSOR | BO_USE_SCANOUT);
        drv_modify_combination(drv, DRM_FORMAT_ARGB8888, &metadata, BO_USE_CURSOR | BO_USE_SCANOUT);
 
+       /* Camera ISP supports only NV12 output. */
+       drv_modify_combination(drv, DRM_FORMAT_NV12, &metadata,
+                              BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE);
+       /*
+        * R8 format is used for Android's HAL_PIXEL_FORMAT_BLOB and is used for JPEG snapshots
+        * from camera.
+        */
+       drv_modify_combination(drv, DRM_FORMAT_R8, &metadata,
+                              BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE);
+
        items = drv_query_kms(drv, &num_items);
        if (!items || !num_items)
                return 0;
@@ -146,7 +162,6 @@ static int rockchip_init(struct driver *drv)
 static bool has_modifier(const uint64_t *list, uint32_t count, uint64_t modifier)
 {
        uint32_t i;
-
        for (i = 0; i < count; i++)
                if (list[i] == modifier)
                        return true;
@@ -177,7 +192,7 @@ static int rockchip_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint
                 * pick that */
                afbc_bo_from_format(bo, width, height, format);
        } else {
-               if (!has_modifier(modifiers, count, DRM_FORMAT_MOD_NONE)) {
+               if (!has_modifier(modifiers, count, DRM_FORMAT_MOD_LINEAR)) {
                        errno = EINVAL;
                        fprintf(stderr, "no usable modifier found\n");
                        return -1;
@@ -217,18 +232,18 @@ static int rockchip_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint
 }
 
 static int rockchip_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                             uint32_t flags)
+                             uint64_t use_flags)
 {
-       uint64_t modifiers[] = { DRM_FORMAT_MOD_NONE };
-
+       uint64_t modifiers[] = { DRM_FORMAT_MOD_LINEAR };
        return rockchip_bo_create_with_modifiers(bo, width, height, format, modifiers,
                                                 ARRAY_SIZE(modifiers));
 }
 
-static void *rockchip_bo_map(struct bo *bo, struct map_info *data, size_t plane)
+static void *rockchip_bo_map(struct bo *bo, struct map_info *data, size_t plane, uint32_t map_flags)
 {
        int ret;
        struct drm_rockchip_gem_map_off gem_map;
+       struct rockchip_private_map_data *priv;
 
        /* We can only map buffers created with SW access flags, which should
         * have no modifiers (ie, not AFBC). */
@@ -244,16 +259,52 @@ static void *rockchip_bo_map(struct bo *bo, struct map_info *data, size_t plane)
                return MAP_FAILED;
        }
 
+       void *addr = mmap(0, bo->total_size, drv_get_prot(map_flags), MAP_SHARED, bo->drv->fd,
+                         gem_map.offset);
+
        data->length = bo->total_size;
 
-       return mmap(0, bo->total_size, PROT_READ | PROT_WRITE, MAP_SHARED, bo->drv->fd,
-                   gem_map.offset);
+       if (bo->use_flags & BO_USE_RENDERSCRIPT) {
+               priv = calloc(1, sizeof(*priv));
+               priv->cached_addr = calloc(1, bo->total_size);
+               priv->gem_addr = addr;
+               memcpy(priv->cached_addr, priv->gem_addr, bo->total_size);
+               data->priv = priv;
+               addr = priv->cached_addr;
+       }
+
+       return addr;
+}
+
+static int rockchip_bo_unmap(struct bo *bo, struct map_info *data)
+{
+       if (data->priv) {
+               struct rockchip_private_map_data *priv = data->priv;
+               data->addr = priv->gem_addr;
+               free(priv->cached_addr);
+               free(priv);
+               data->priv = NULL;
+       }
+
+       return munmap(data->addr, data->length);
+}
+
+static int rockchip_bo_flush(struct bo *bo, struct map_info *data)
+{
+       struct rockchip_private_map_data *priv = data->priv;
+       if (priv && (data->map_flags & BO_MAP_WRITE))
+               memcpy(priv->gem_addr, priv->cached_addr, bo->total_size);
+
+       return 0;
 }
 
-static uint32_t rockchip_resolve_format(uint32_t format, uint64_t usage)
+static uint32_t rockchip_resolve_format(uint32_t format, uint64_t use_flags)
 {
        switch (format) {
        case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
+               /* Camera subsystem requires NV12. */
+               if (use_flags & (BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE))
+                       return DRM_FORMAT_NV12;
                /*HACK: See b/28671744 */
                return DRM_FORMAT_XBGR8888;
        case DRM_FORMAT_FLEX_YCbCr_420_888:
@@ -271,6 +322,8 @@ struct backend backend_rockchip = {
        .bo_destroy = drv_gem_bo_destroy,
        .bo_import = drv_prime_bo_import,
        .bo_map = rockchip_bo_map,
+       .bo_unmap = rockchip_bo_unmap,
+       .bo_flush = rockchip_bo_flush,
        .resolve_format = rockchip_resolve_format,
 };