minigbm: standardize naming of buffer creation flags

We use the terms "flags" and "usage" interchangeably in this repo,
since they essentally mean the same thing.  However, let's be a
little more consistent since it's kind of confusing, especially
when buffer map flags come to play. Let's:

	- refer to everything in the drv_* layer as use_flags
	- refer to everything in the gbm/gralloc layers as
	  usages

BUG=chromium:764871
TEST=emerge-eve {arc-cros-gralloc, minigbm}

Change-Id: If987d72369b895f38cde87e50ce1080f78f2a084
Reviewed-on: https://chromium-review.googlesource.com/691423
Commit-Ready: Gurchetan Singh <gurchetansingh@chromium.org>
Tested-by: Gurchetan Singh <gurchetansingh@chromium.org>
Reviewed-by: Stéphane Marchesin <marcheu@chromium.org>

diff --git a/amdgpu.c b/amdgpu.c
index dfd4154..1210d1f 100644 (file)
--- a/amdgpu.c
+++ b/amdgpu.c
@@ -135,7 +135,7 @@ static ADDR_E_RETURNCODE ADDR_API free_sys_mem(const ADDR_FREESYSMEM_INPUT *in)
 }
 
 static int amdgpu_addrlib_compute(void *addrlib, uint32_t width, uint32_t height, uint32_t format,
-                                 uint64_t usage, uint32_t *tiling_flags,
+                                 uint64_t use_flags, uint32_t *tiling_flags,
                                  ADDR_COMPUTE_SURFACE_INFO_OUTPUT *addr_out)
 {
        ADDR_COMPUTE_SURFACE_INFO_INPUT addr_surf_info_in = { 0 };
@@ -147,7 +147,8 @@ static int amdgpu_addrlib_compute(void *addrlib, uint32_t width, uint32_t height
 
        /* Set the requested tiling mode. */
        addr_surf_info_in.tileMode = ADDR_TM_2D_TILED_THIN1;
-       if (usage & (BO_USE_CURSOR | BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN))
+       if (use_flags &
+           (BO_USE_CURSOR | BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN))
                addr_surf_info_in.tileMode = ADDR_TM_LINEAR_ALIGNED;
        else if (width <= 16 || height <= 16)
                addr_surf_info_in.tileMode = ADDR_TM_1D_TILED_THIN1;
@@ -166,7 +167,7 @@ static int amdgpu_addrlib_compute(void *addrlib, uint32_t width, uint32_t height
        addr_surf_info_in.flags.noStencil = 1;
 
        /* Set the micro tile type. */
-       if (usage & BO_USE_SCANOUT)
+       if (use_flags & BO_USE_SCANOUT)
                addr_surf_info_in.tileType = ADDR_DISPLAYABLE;
        else
                addr_surf_info_in.tileType = ADDR_NON_DISPLAYABLE;
@@ -273,7 +274,7 @@ static int amdgpu_init(struct driver *drv)
        int ret;
        void *addrlib;
        struct format_metadata metadata;
-       uint64_t flags = BO_USE_RENDER_MASK;
+       uint64_t use_flags = BO_USE_RENDER_MASK;
 
        addrlib = amdgpu_addrlib_init(drv_get_fd(drv));
        if (!addrlib)
@@ -294,7 +295,7 @@ static int amdgpu_init(struct driver *drv)
        metadata.modifier = DRM_FORMAT_MOD_NONE;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-                                  &metadata, flags);
+                                  &metadata, use_flags);
        if (ret)
                return ret;
 
@@ -307,19 +308,19 @@ static int amdgpu_init(struct driver *drv)
        metadata.modifier = DRM_FORMAT_MOD_NONE;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-                                  &metadata, flags);
+                                  &metadata, use_flags);
        if (ret)
                return ret;
 
-       flags &= ~BO_USE_SW_WRITE_OFTEN;
-       flags &= ~BO_USE_SW_READ_OFTEN;
-       flags &= ~BO_USE_LINEAR;
+       use_flags &= ~BO_USE_SW_WRITE_OFTEN;
+       use_flags &= ~BO_USE_SW_READ_OFTEN;
+       use_flags &= ~BO_USE_LINEAR;
 
        metadata.tiling = ADDR_DISPLAYABLE << 16 | ADDR_TM_2D_TILED_THIN1;
        metadata.priority = 4;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-                                  &metadata, flags);
+                                  &metadata, use_flags);
        if (ret)
                return ret;
 
@@ -331,7 +332,7 @@ static int amdgpu_init(struct driver *drv)
        metadata.priority = 5;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-                                  &metadata, flags);
+                                  &metadata, use_flags);
        if (ret)
                return ret;
 
@@ -345,7 +346,7 @@ static void amdgpu_close(struct driver *drv)
 }
 
 static int amdgpu_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                           uint64_t usage)
+                           uint64_t use_flags)
 {
        void *addrlib = bo->drv->priv;
        union drm_amdgpu_gem_create gem_create;
@@ -359,7 +360,7 @@ static int amdgpu_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint
        if (format == DRM_FORMAT_NV12 || format == DRM_FORMAT_NV21) {
                drv_bo_from_format(bo, ALIGN(width, 64), height, format);
        } else {
-               if (amdgpu_addrlib_compute(addrlib, width, height, format, usage, &tiling_flags,
+               if (amdgpu_addrlib_compute(addrlib, width, height, format, use_flags, &tiling_flags,
                                           &addr_out) < 0)
                        return -EINVAL;
 
@@ -370,8 +371,8 @@ static int amdgpu_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint
                bo->strides[0] = addr_out.pixelPitch * DIV_ROUND_UP(addr_out.pixelBits, 8);
        }
 
-       if (usage & (BO_USE_CURSOR | BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN |
-                    BO_USE_SW_WRITE_RARELY | BO_USE_SW_READ_RARELY))
+       if (use_flags & (BO_USE_CURSOR | BO_USE_LINEAR | BO_USE_SW_READ_OFTEN |
+                        BO_USE_SW_WRITE_OFTEN | BO_USE_SW_WRITE_RARELY | BO_USE_SW_READ_RARELY))
                gem_create_flags |= AMDGPU_GEM_CREATE_CPU_ACCESS_REQUIRED;
        else
                gem_create_flags |= AMDGPU_GEM_CREATE_NO_CPU_ACCESS;
@@ -418,7 +419,7 @@ static void *amdgpu_bo_map(struct bo *bo, struct map_info *data, size_t plane, i
        return mmap(0, bo->total_size, prot, MAP_SHARED, bo->drv->fd, gem_map.out.addr_ptr);
 }
 
-static uint32_t amdgpu_resolve_format(uint32_t format, uint64_t usage)
+static uint32_t amdgpu_resolve_format(uint32_t format, uint64_t use_flags)
 {
        switch (format) {
        case DRM_FORMAT_FLEX_YCbCr_420_888:

diff --git a/cros_gralloc/cros_gralloc_driver.cc b/cros_gralloc/cros_gralloc_driver.cc
index 805c123..7a4632e 100644 (file)
--- a/cros_gralloc/cros_gralloc_driver.cc
+++ b/cros_gralloc/cros_gralloc_driver.cc
@@ -78,8 +78,8 @@ bool cros_gralloc_driver::is_supported(const struct cros_gralloc_buffer_descript
 {
        struct combination *combo;
        uint32_t resolved_format;
-       resolved_format = drv_resolve_format(drv_, descriptor->drm_format, descriptor->drv_usage);
-       combo = drv_get_combination(drv_, resolved_format, descriptor->drv_usage);
+       resolved_format = drv_resolve_format(drv_, descriptor->drm_format, descriptor->use_flags);
+       combo = drv_get_combination(drv_, resolved_format, descriptor->use_flags);
        return (combo != nullptr);
 }
 
@@ -94,9 +94,9 @@ int32_t cros_gralloc_driver::allocate(const struct cros_gralloc_buffer_descripto
        struct bo *bo;
        struct cros_gralloc_handle *hnd;
 
-       resolved_format = drv_resolve_format(drv_, descriptor->drm_format, descriptor->drv_usage);
+       resolved_format = drv_resolve_format(drv_, descriptor->drm_format, descriptor->use_flags);
        bo = drv_bo_create(drv_, descriptor->width, descriptor->height, resolved_format,
-                          descriptor->drv_usage);
+                          descriptor->use_flags);
        if (!bo) {
                cros_gralloc_error("Failed to create bo.");
                return -ENOMEM;
@@ -133,8 +133,8 @@ int32_t cros_gralloc_driver::allocate(const struct cros_gralloc_buffer_descripto
        hnd->width = drv_bo_get_width(bo);
        hnd->height = drv_bo_get_height(bo);
        hnd->format = drv_bo_get_format(bo);
-       hnd->flags[0] = static_cast<uint32_t>(descriptor->drv_usage >> 32);
-       hnd->flags[1] = static_cast<uint32_t>(descriptor->drv_usage);
+       hnd->use_flags[0] = static_cast<uint32_t>(descriptor->use_flags >> 32);
+       hnd->use_flags[1] = static_cast<uint32_t>(descriptor->use_flags);
        hnd->pixel_stride = drv_bo_get_stride_in_pixels(bo);
        hnd->magic = cros_gralloc_magic;
        hnd->droid_format = descriptor->droid_format;
@@ -182,8 +182,8 @@ int32_t cros_gralloc_driver::retain(buffer_handle_t handle)
                data.format = hnd->format;
                data.width = hnd->width;
                data.height = hnd->height;
-               data.flags = static_cast<uint64_t>(hnd->flags[0]) << 32;
-               data.flags |= hnd->flags[1];
+               data.use_flags = static_cast<uint64_t>(hnd->use_flags[0]) << 32;
+               data.use_flags |= hnd->use_flags[1];
 
                memcpy(data.fds, hnd->fds, sizeof(data.fds));
                memcpy(data.strides, hnd->strides, sizeof(data.strides));

diff --git a/cros_gralloc/cros_gralloc_handle.h b/cros_gralloc/cros_gralloc_handle.h
index bdd3f07..cd3edfe 100644 (file)
--- a/cros_gralloc/cros_gralloc_handle.h
+++ b/cros_gralloc/cros_gralloc_handle.h
@@ -25,8 +25,8 @@ struct cros_gralloc_handle {
        uint32_t format_modifiers[2 * DRV_MAX_PLANES];
        uint32_t width;
        uint32_t height;
-       uint32_t format;   /* DRM format */
-       uint32_t flags[2]; /* driver creation time flags */
+       uint32_t format;       /* DRM format */
+       uint32_t use_flags[2]; /* Buffer creation flags */
        uint32_t magic;
        uint32_t pixel_stride;
        int32_t droid_format;

diff --git a/cros_gralloc/cros_gralloc_types.h b/cros_gralloc/cros_gralloc_types.h
index 2f6122e..1fa81de 100644 (file)
--- a/cros_gralloc/cros_gralloc_types.h
+++ b/cros_gralloc/cros_gralloc_types.h
@@ -14,7 +14,7 @@ struct cros_gralloc_buffer_descriptor {
        uint32_t producer_usage;
        uint32_t droid_format;
        uint32_t drm_format;
-       uint64_t drv_usage;
+       uint64_t use_flags;
 };
 
 #endif

diff --git a/cros_gralloc/gralloc0/gralloc0.cc b/cros_gralloc/gralloc0/gralloc0.cc
index 533f8ca..22932f5 100644 (file)
--- a/cros_gralloc/gralloc0/gralloc0.cc
+++ b/cros_gralloc/gralloc0/gralloc0.cc
@@ -32,50 +32,50 @@ enum {
 };
 // clang-format on
 
-static int64_t gralloc0_convert_flags(int flags)
+static uint64_t gralloc0_convert_usage(int usage)
 {
-       uint64_t usage = BO_USE_NONE;
-
-       if (flags & GRALLOC_USAGE_CURSOR)
-               usage |= BO_USE_NONE;
-       if ((flags & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_RARELY)
-               usage |= BO_USE_SW_READ_RARELY;
-       if ((flags & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN)
-               usage |= BO_USE_SW_READ_OFTEN;
-       if ((flags & GRALLOC_USAGE_SW_WRITE_MASK) == GRALLOC_USAGE_SW_WRITE_RARELY)
-               usage |= BO_USE_SW_WRITE_RARELY;
-       if ((flags & GRALLOC_USAGE_SW_WRITE_MASK) == GRALLOC_USAGE_SW_WRITE_OFTEN)
-               usage |= BO_USE_SW_WRITE_OFTEN;
-       if (flags & GRALLOC_USAGE_HW_TEXTURE)
-               usage |= BO_USE_TEXTURE;
-       if (flags & GRALLOC_USAGE_HW_RENDER)
-               usage |= BO_USE_RENDERING;
-       if (flags & GRALLOC_USAGE_HW_2D)
-               usage |= BO_USE_RENDERING;
-       if (flags & GRALLOC_USAGE_HW_COMPOSER)
+       uint64_t use_flags = BO_USE_NONE;
+
+       if (usage & GRALLOC_USAGE_CURSOR)
+               use_flags |= BO_USE_NONE;
+       if ((usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_RARELY)
+               use_flags |= BO_USE_SW_READ_RARELY;
+       if ((usage & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN)
+               use_flags |= BO_USE_SW_READ_OFTEN;
+       if ((usage & GRALLOC_USAGE_SW_WRITE_MASK) == GRALLOC_USAGE_SW_WRITE_RARELY)
+               use_flags |= BO_USE_SW_WRITE_RARELY;
+       if ((usage & GRALLOC_USAGE_SW_WRITE_MASK) == GRALLOC_USAGE_SW_WRITE_OFTEN)
+               use_flags |= BO_USE_SW_WRITE_OFTEN;
+       if (usage & GRALLOC_USAGE_HW_TEXTURE)
+               use_flags |= BO_USE_TEXTURE;
+       if (usage & GRALLOC_USAGE_HW_RENDER)
+               use_flags |= BO_USE_RENDERING;
+       if (usage & GRALLOC_USAGE_HW_2D)
+               use_flags |= BO_USE_RENDERING;
+       if (usage & GRALLOC_USAGE_HW_COMPOSER)
                /* HWC wants to use display hardware, but can defer to OpenGL. */
-               usage |= BO_USE_SCANOUT | BO_USE_TEXTURE;
-       if (flags & GRALLOC_USAGE_HW_FB)
-               usage |= BO_USE_NONE;
-       if (flags & GRALLOC_USAGE_EXTERNAL_DISP)
+               use_flags |= BO_USE_SCANOUT | BO_USE_TEXTURE;
+       if (usage & GRALLOC_USAGE_HW_FB)
+               use_flags |= BO_USE_NONE;
+       if (usage & GRALLOC_USAGE_EXTERNAL_DISP)
                /*
                 * This flag potentially covers external display for the normal drivers (i915,
                 * rockchip) and usb monitors (evdi/udl). It's complicated so ignore it.
                 * */
-               usage |= BO_USE_NONE;
-       if (flags & GRALLOC_USAGE_PROTECTED)
-               usage |= BO_USE_PROTECTED;
-       if (flags & GRALLOC_USAGE_HW_VIDEO_ENCODER)
+               use_flags |= BO_USE_NONE;
+       if (usage & GRALLOC_USAGE_PROTECTED)
+               use_flags |= BO_USE_PROTECTED;
+       if (usage & GRALLOC_USAGE_HW_VIDEO_ENCODER)
                /*HACK: See b/30054495 */
-               usage |= BO_USE_SW_READ_OFTEN;
-       if (flags & GRALLOC_USAGE_HW_CAMERA_WRITE)
-               usage |= BO_USE_CAMERA_WRITE;
-       if (flags & GRALLOC_USAGE_HW_CAMERA_READ)
-               usage |= BO_USE_CAMERA_READ;
-       if (flags & GRALLOC_USAGE_RENDERSCRIPT)
-               usage |= BO_USE_RENDERSCRIPT;
-
-       return usage;
+               use_flags |= BO_USE_SW_READ_OFTEN;
+       if (usage & GRALLOC_USAGE_HW_CAMERA_WRITE)
+               use_flags |= BO_USE_CAMERA_WRITE;
+       if (usage & GRALLOC_USAGE_HW_CAMERA_READ)
+               use_flags |= BO_USE_CAMERA_READ;
+       if (usage & GRALLOC_USAGE_RENDERSCRIPT)
+               use_flags |= BO_USE_RENDERSCRIPT;
+
+       return use_flags;
 }
 
 static int gralloc0_alloc(alloc_device_t *dev, int w, int h, int format, int usage,
@@ -91,19 +91,19 @@ static int gralloc0_alloc(alloc_device_t *dev, int w, int h, int format, int usa
        descriptor.droid_format = format;
        descriptor.producer_usage = descriptor.consumer_usage = usage;
        descriptor.drm_format = cros_gralloc_convert_format(format);
-       descriptor.drv_usage = gralloc0_convert_flags(usage);
+       descriptor.use_flags = gralloc0_convert_usage(usage);
 
        supported = mod->driver->is_supported(&descriptor);
        if (!supported && (usage & GRALLOC_USAGE_HW_COMPOSER)) {
-               descriptor.drv_usage &= ~BO_USE_SCANOUT;
+               descriptor.use_flags &= ~BO_USE_SCANOUT;
                supported = mod->driver->is_supported(&descriptor);
        }
 
        if (!supported) {
-               cros_gralloc_error("Unsupported combination -- HAL format: %u, HAL flags: %u, "
-                                  "drv_format: %4.4s, drv_flags: %llu",
+               cros_gralloc_error("Unsupported combination -- HAL format: %u, HAL usage: %u, "
+                                  "drv_format: %4.4s, use_flags: %llu",
                                   format, usage, reinterpret_cast<char *>(&descriptor.drm_format),
-                                  static_cast<unsigned long long>(descriptor.drv_usage));
+                                  static_cast<unsigned long long>(descriptor.use_flags));
                return -EINVAL;
        }
 
@@ -297,7 +297,7 @@ static int gralloc0_lock_async(struct gralloc_module_t const *module, buffer_han
                return -EINVAL;
        }
 
-       flags = gralloc0_convert_flags(usage);
+       flags = gralloc0_convert_usage(usage);
        ret = mod->driver->lock(handle, fence_fd, flags, addr);
        *vaddr = addr[0];
        return ret;
@@ -332,7 +332,7 @@ static int gralloc0_lock_async_ycbcr(struct gralloc_module_t const *module, buff
                return -EINVAL;
        }
 
-       flags = gralloc0_convert_flags(usage);
+       flags = gralloc0_convert_usage(usage);
        ret = mod->driver->lock(handle, fence_fd, flags, addr);
        if (ret)
                return ret;

diff --git a/drv.c b/drv.c
index 8b8418b..339aac1 100644 (file)
--- a/drv.c
+++ b/drv.c
@@ -194,18 +194,18 @@ const char *drv_get_name(struct driver *drv)
        return drv->backend->name;
 }
 
-struct combination *drv_get_combination(struct driver *drv, uint32_t format, uint64_t usage)
+struct combination *drv_get_combination(struct driver *drv, uint32_t format, uint64_t use_flags)
 {
        struct combination *curr, *best;
 
-       if (format == DRM_FORMAT_NONE || usage == BO_USE_NONE)
+       if (format == DRM_FORMAT_NONE || use_flags == BO_USE_NONE)
                return 0;
 
        best = NULL;
        uint32_t i;
        for (i = 0; i < drv->combos.size; i++) {
                curr = &drv->combos.data[i];
-               if ((format == curr->format) && usage == (curr->usage & usage))
+               if ((format == curr->format) && use_flags == (curr->use_flags & use_flags))
                        if (!best || best->metadata.priority < curr->metadata.priority)
                                best = curr;
        }
@@ -214,7 +214,7 @@ struct combination *drv_get_combination(struct driver *drv, uint32_t format, uin
 }
 
 struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, uint32_t format,
-                     uint64_t flags)
+                     uint64_t use_flags)
 {
 
        struct bo *bo;
@@ -227,7 +227,7 @@ struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, uint3
        bo->width = width;
        bo->height = height;
        bo->format = format;
-       bo->flags = flags;
+       bo->use_flags = use_flags;
        bo->num_planes = drv_num_planes_from_format(format);
 
        if (!bo->num_planes) {
@@ -239,18 +239,18 @@ struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, uint3
 }
 
 struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height, uint32_t format,
-                        uint64_t flags)
+                        uint64_t use_flags)
 {
        int ret;
        size_t plane;
        struct bo *bo;
 
-       bo = drv_bo_new(drv, width, height, format, flags);
+       bo = drv_bo_new(drv, width, height, format, use_flags);
 
        if (!bo)
                return NULL;
 
-       ret = drv->backend->bo_create(bo, width, height, format, flags);
+       ret = drv->backend->bo_create(bo, width, height, format, use_flags);
 
        if (ret) {
                free(bo);
@@ -331,7 +331,7 @@ struct bo *drv_bo_import(struct driver *drv, struct drv_import_fd_data *data)
        size_t plane;
        struct bo *bo;
 
-       bo = drv_bo_new(drv, data->width, data->height, data->format, data->flags);
+       bo = drv_bo_new(drv, data->width, data->height, data->format, data->use_flags);
 
        if (!bo)
                return NULL;
@@ -509,10 +509,10 @@ uint32_t drv_bo_get_format(struct bo *bo)
        return bo->format;
 }
 
-uint32_t drv_resolve_format(struct driver *drv, uint32_t format, uint64_t usage)
+uint32_t drv_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags)
 {
        if (drv->backend->resolve_format)
-               return drv->backend->resolve_format(format, usage);
+               return drv->backend->resolve_format(format, use_flags);
 
        return format;
 }

diff --git a/drv.h b/drv.h
index 8c132d3..fd544ca 100644 (file)
--- a/drv.h
+++ b/drv.h
@@ -75,7 +75,7 @@ struct drv_import_fd_data {
        uint32_t width;
        uint32_t height;
        uint32_t format;
-       uint64_t flags;
+       uint64_t use_flags;
 };
 
 struct map_info {
@@ -94,13 +94,13 @@ int drv_get_fd(struct driver *drv);
 
 const char *drv_get_name(struct driver *drv);
 
-struct combination *drv_get_combination(struct driver *drv, uint32_t format, uint64_t usage);
+struct combination *drv_get_combination(struct driver *drv, uint32_t format, uint64_t use_flags);
 
 struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, uint32_t format,
-                     uint64_t flags);
+                     uint64_t use_flags);
 
 struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height, uint32_t format,
-                        uint64_t flags);
+                        uint64_t use_flags);
 
 struct bo *drv_bo_create_with_modifiers(struct driver *drv, uint32_t width, uint32_t height,
                                        uint32_t format, const uint64_t *modifiers, uint32_t count);
@@ -140,7 +140,7 @@ uint32_t drv_bo_get_format(struct bo *bo);
 
 uint32_t drv_bo_get_stride_in_pixels(struct bo *bo);
 
-uint32_t drv_resolve_format(struct driver *drv, uint32_t format, uint64_t usage);
+uint32_t drv_resolve_format(struct driver *drv, uint32_t format, uint64_t use_flags);
 
 size_t drv_num_planes_from_format(uint32_t format);
 

diff --git a/drv_priv.h b/drv_priv.h
index 9684e9d..739e1a0 100644 (file)
--- a/drv_priv.h
+++ b/drv_priv.h
@@ -26,7 +26,7 @@ struct bo {
        uint32_t sizes[DRV_MAX_PLANES];
        uint32_t strides[DRV_MAX_PLANES];
        uint64_t format_modifiers[DRV_MAX_PLANES];
-       uint64_t flags;
+       uint64_t use_flags;
        size_t total_size;
        void *priv;
 };
@@ -34,7 +34,7 @@ struct bo {
 struct kms_item {
        uint32_t format;
        uint64_t modifier;
-       uint64_t usage;
+       uint64_t use_flags;
 };
 
 struct format_metadata {
@@ -46,7 +46,7 @@ struct format_metadata {
 struct combination {
        uint32_t format;
        struct format_metadata metadata;
-       uint64_t usage;
+       uint64_t use_flags;
 };
 
 struct combinations {
@@ -70,7 +70,7 @@ struct backend {
        int (*init)(struct driver *drv);
        void (*close)(struct driver *drv);
        int (*bo_create)(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                        uint64_t flags);
+                        uint64_t use_flags);
        int (*bo_create_with_modifiers)(struct bo *bo, uint32_t width, uint32_t height,
                                        uint32_t format, const uint64_t *modifiers, uint32_t count);
        int (*bo_destroy)(struct bo *bo);
@@ -78,7 +78,7 @@ struct backend {
        void *(*bo_map)(struct bo *bo, struct map_info *data, size_t plane, int prot);
        int (*bo_unmap)(struct bo *bo, struct map_info *data);
        int (*bo_flush)(struct bo *bo, struct map_info *data);
-       uint32_t (*resolve_format)(uint32_t format, uint64_t usage);
+       uint32_t (*resolve_format)(uint32_t format, uint64_t use_flags);
 };
 
 // clang-format off

diff --git a/exynos.c b/exynos.c
index b620963..963f030 100644 (file)
--- a/exynos.c
+++ b/exynos.c
@@ -40,7 +40,7 @@ static int exynos_init(struct driver *drv)
 }
 
 static int exynos_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                           uint64_t flags)
+                           uint64_t use_flags)
 {
        size_t plane;
 

diff --git a/gbm.c b/gbm.c
index d54c975..f76e4ca 100644 (file)
--- a/gbm.c
+++ b/gbm.c
@@ -30,14 +30,14 @@ PUBLIC const char *gbm_device_get_backend_name(struct gbm_device *gbm)
 
 PUBLIC int gbm_device_is_format_supported(struct gbm_device *gbm, uint32_t format, uint32_t usage)
 {
-       uint64_t drv_usage;
+       uint64_t use_flags;
 
        if (usage & GBM_BO_USE_CURSOR && usage & GBM_BO_USE_RENDERING)
                return 0;
 
-       drv_usage = gbm_convert_flags(usage);
+       use_flags = gbm_convert_usage(usage);
 
-       return (drv_get_combination(gbm->drv, format, drv_usage) != NULL);
+       return (drv_get_combination(gbm->drv, format, use_flags) != NULL);
 }
 
 PUBLIC struct gbm_device *gbm_create_device(int fd)
@@ -65,7 +65,7 @@ PUBLIC void gbm_device_destroy(struct gbm_device *gbm)
 }
 
 PUBLIC struct gbm_surface *gbm_surface_create(struct gbm_device *gbm, uint32_t width,
-                                             uint32_t height, uint32_t format, uint32_t flags)
+                                             uint32_t height, uint32_t format, uint32_t usage)
 {
        struct gbm_surface *surface = (struct gbm_surface *)malloc(sizeof(*surface));
 
@@ -104,11 +104,11 @@ static struct gbm_bo *gbm_bo_new(struct gbm_device *gbm, uint32_t format)
 }
 
 PUBLIC struct gbm_bo *gbm_bo_create(struct gbm_device *gbm, uint32_t width, uint32_t height,
-                                   uint32_t format, uint32_t flags)
+                                   uint32_t format, uint32_t usage)
 {
        struct gbm_bo *bo;
 
-       if (!gbm_device_is_format_supported(gbm, format, flags))
+       if (!gbm_device_is_format_supported(gbm, format, usage))
                return NULL;
 
        bo = gbm_bo_new(gbm, format);
@@ -116,7 +116,7 @@ PUBLIC struct gbm_bo *gbm_bo_create(struct gbm_device *gbm, uint32_t width, uint
        if (!bo)
                return NULL;
 
-       bo->bo = drv_bo_create(gbm->drv, width, height, format, gbm_convert_flags(flags));
+       bo->bo = drv_bo_create(gbm->drv, width, height, format, gbm_convert_usage(usage));
 
        if (!bo->bo) {
                free(bo);
@@ -170,7 +170,7 @@ PUBLIC struct gbm_bo *gbm_bo_import(struct gbm_device *gbm, uint32_t type, void
        size_t num_planes, i;
 
        memset(&drv_data, 0, sizeof(drv_data));
-       drv_data.flags = gbm_convert_flags(usage);
+       drv_data.use_flags = gbm_convert_usage(usage);
        switch (type) {
        case GBM_BO_IMPORT_FD:
                gbm_format = fd_data->format;

diff --git a/gbm_helpers.c b/gbm_helpers.c
index 529d7fe..13904f6 100644 (file)
--- a/gbm_helpers.c
+++ b/gbm_helpers.c
@@ -10,26 +10,26 @@
 #include "drv.h"
 #include "gbm.h"
 
-uint64_t gbm_convert_flags(uint32_t flags)
+uint64_t gbm_convert_usage(uint32_t usage)
 {
-       uint64_t usage = BO_USE_NONE;
+       uint64_t use_flags = BO_USE_NONE;
 
-       if (flags & GBM_BO_USE_SCANOUT)
-               usage |= BO_USE_SCANOUT;
-       if (flags & GBM_BO_USE_CURSOR)
-               usage |= BO_USE_CURSOR;
-       if (flags & GBM_BO_USE_CURSOR_64X64)
-               usage |= BO_USE_CURSOR_64X64;
-       if (flags & GBM_BO_USE_RENDERING)
-               usage |= BO_USE_RENDERING;
-       if (flags & GBM_BO_USE_TEXTURING)
-               usage |= BO_USE_TEXTURE;
-       if (flags & GBM_BO_USE_LINEAR)
-               usage |= BO_USE_LINEAR;
-       if (flags & GBM_BO_USE_CAMERA_WRITE)
-               usage |= BO_USE_CAMERA_WRITE;
-       if (flags & GBM_BO_USE_CAMERA_READ)
-               usage |= BO_USE_CAMERA_READ;
+       if (usage & GBM_BO_USE_SCANOUT)
+               use_flags |= BO_USE_SCANOUT;
+       if (usage & GBM_BO_USE_CURSOR)
+               use_flags |= BO_USE_CURSOR;
+       if (usage & GBM_BO_USE_CURSOR_64X64)
+               use_flags |= BO_USE_CURSOR_64X64;
+       if (usage & GBM_BO_USE_RENDERING)
+               use_flags |= BO_USE_RENDERING;
+       if (usage & GBM_BO_USE_TEXTURING)
+               use_flags |= BO_USE_TEXTURE;
+       if (usage & GBM_BO_USE_LINEAR)
+               use_flags |= BO_USE_LINEAR;
+       if (usage & GBM_BO_USE_CAMERA_WRITE)
+               use_flags |= BO_USE_CAMERA_WRITE;
+       if (usage & GBM_BO_USE_CAMERA_READ)
+               use_flags |= BO_USE_CAMERA_READ;
 
-       return usage;
+       return use_flags;
 }

diff --git a/gbm_helpers.h b/gbm_helpers.h
index 48ff391..4d625c5 100644 (file)
--- a/gbm_helpers.h
+++ b/gbm_helpers.h
@@ -7,6 +7,6 @@
 #ifndef GBM_HELPERS_H
 #define GBM_HELPERS_H
 
-uint64_t gbm_convert_flags(uint32_t flags);
+uint64_t gbm_convert_usage(uint32_t usage);
 
 #endif

diff --git a/helpers.c b/helpers.c
index b0c72ad..a470b9c 100644 (file)
--- a/helpers.c
+++ b/helpers.c
@@ -182,7 +182,7 @@ int drv_bo_from_format(struct bo *bo, uint32_t stride, uint32_t aligned_height,
 }
 
 int drv_dumb_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                      uint64_t flags)
+                      uint64_t use_flags)
 {
        int ret;
        size_t plane;
@@ -406,7 +406,7 @@ uint32_t drv_log_base2(uint32_t value)
 }
 
 int drv_add_combination(struct driver *drv, uint32_t format, struct format_metadata *metadata,
-                       uint64_t usage)
+                       uint64_t use_flags)
 {
        struct combinations *combos = &drv->combos;
        if (combos->size >= combos->allocations) {
@@ -423,18 +423,18 @@ int drv_add_combination(struct driver *drv, uint32_t format, struct format_metad
        combos->data[combos->size].metadata.priority = metadata->priority;
        combos->data[combos->size].metadata.tiling = metadata->tiling;
        combos->data[combos->size].metadata.modifier = metadata->modifier;
-       combos->data[combos->size].usage = usage;
+       combos->data[combos->size].use_flags = use_flags;
        combos->size++;
        return 0;
 }
 
 int drv_add_combinations(struct driver *drv, const uint32_t *formats, uint32_t num_formats,
-                        struct format_metadata *metadata, uint64_t usage)
+                        struct format_metadata *metadata, uint64_t use_flags)
 {
        int ret;
        uint32_t i;
        for (i = 0; i < num_formats; i++) {
-               ret = drv_add_combination(drv, formats[i], metadata, usage);
+               ret = drv_add_combination(drv, formats[i], metadata, use_flags);
                if (ret)
                        return ret;
        }
@@ -443,23 +443,23 @@ int drv_add_combinations(struct driver *drv, const uint32_t *formats, uint32_t n
 }
 
 void drv_modify_combination(struct driver *drv, uint32_t format, struct format_metadata *metadata,
-                           uint64_t usage)
+                           uint64_t use_flags)
 {
        uint32_t i;
        struct combination *combo;
-       /* Attempts to add the specified usage to an existing combination. */
+       /* Attempts to add the specified flags to an existing combination. */
        for (i = 0; i < drv->combos.size; i++) {
                combo = &drv->combos.data[i];
                if (combo->format == format && combo->metadata.tiling == metadata->tiling &&
                    combo->metadata.modifier == metadata->modifier)
-                       combo->usage |= usage;
+                       combo->use_flags |= use_flags;
        }
 }
 
 struct kms_item *drv_query_kms(struct driver *drv, uint32_t *num_items)
 {
-       uint64_t flag, usage;
        struct kms_item *items;
+       uint64_t plane_type, use_flag;
        uint32_t i, j, k, allocations, item_size;
 
        drmModePlanePtr plane;
@@ -501,20 +501,20 @@ struct kms_item *drv_query_kms(struct driver *drv, uint32_t *num_items)
                        prop = drmModeGetProperty(drv->fd, props->props[j]);
                        if (prop) {
                                if (strcmp(prop->name, "type") == 0) {
-                                       flag = props->prop_values[j];
+                                       plane_type = props->prop_values[j];
                                }
 
                                drmModeFreeProperty(prop);
                        }
                }
 
-               switch (flag) {
+               switch (plane_type) {
                case DRM_PLANE_TYPE_OVERLAY:
                case DRM_PLANE_TYPE_PRIMARY:
-                       usage = BO_USE_SCANOUT;
+                       use_flag = BO_USE_SCANOUT;
                        break;
                case DRM_PLANE_TYPE_CURSOR:
-                       usage = BO_USE_CURSOR;
+                       use_flag = BO_USE_CURSOR;
                        break;
                default:
                        assert(0);
@@ -525,7 +525,7 @@ struct kms_item *drv_query_kms(struct driver *drv, uint32_t *num_items)
                        for (k = 0; k < item_size; k++) {
                                if (items[k].format == plane->formats[j] &&
                                    items[k].modifier == DRM_FORMAT_MOD_NONE) {
-                                       items[k].usage |= usage;
+                                       items[k].use_flags |= use_flag;
                                        found = true;
                                        break;
                                }
@@ -546,7 +546,7 @@ struct kms_item *drv_query_kms(struct driver *drv, uint32_t *num_items)
                        if (!found) {
                                items[item_size].format = plane->formats[j];
                                items[item_size].modifier = DRM_FORMAT_MOD_NONE;
-                               items[item_size].usage = usage;
+                               items[item_size].use_flags = use_flag;
                                item_size++;
                        }
                }
@@ -592,7 +592,7 @@ int drv_modify_linear_combinations(struct driver *drv)
                for (j = 0; j < drv->combos.size; j++) {
                        combo = &drv->combos.data[j];
                        if (items[i].format == combo->format)
-                               combo->usage |= BO_USE_SCANOUT;
+                               combo->use_flags |= BO_USE_SCANOUT;
                }
        }
 

diff --git a/helpers.h b/helpers.h
index 2140dd6..6192086 100644 (file)
--- a/helpers.h
+++ b/helpers.h
@@ -13,7 +13,7 @@ uint32_t drv_stride_from_format(uint32_t format, uint32_t width, size_t plane);
 uint32_t drv_size_from_format(uint32_t format, uint32_t stride, uint32_t height, size_t plane);
 int drv_bo_from_format(struct bo *bo, uint32_t stride, uint32_t aligned_height, uint32_t format);
 int drv_dumb_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                      uint64_t flags);
+                      uint64_t use_flags);
 int drv_dumb_bo_destroy(struct bo *bo);
 int drv_map_info_destroy(struct bo *bo);
 int drv_gem_bo_destroy(struct bo *bo);

diff --git a/i915.c b/i915.c
index 4710feb..47d33c0 100644 (file)
--- a/i915.c
+++ b/i915.c
@@ -70,11 +70,11 @@ static int i915_add_kms_item(struct driver *drv, const struct kms_item *item)
                         * buffers, so let's add this to our combinations, except for
                         * cursor, which must not be tiled.
                         */
-                       combo->usage |= item->usage & ~BO_USE_CURSOR;
+                       combo->use_flags |= item->use_flags & ~BO_USE_CURSOR;
                }
 
                if (combo->metadata.modifier == item->modifier)
-                       combo->usage |= item->usage;
+                       combo->use_flags |= item->use_flags;
        }
 
        return 0;
@@ -86,28 +86,28 @@ static int i915_add_combinations(struct driver *drv)
        uint32_t i, num_items;
        struct kms_item *items;
        struct format_metadata metadata;
-       uint64_t render_flags, texture_flags;
+       uint64_t render_use_flags, texture_use_flags;
 
-       render_flags = BO_USE_RENDER_MASK;
-       texture_flags = BO_USE_TEXTURE_MASK;
+       render_use_flags = BO_USE_RENDER_MASK;
+       texture_use_flags = BO_USE_TEXTURE_MASK;
 
        metadata.tiling = I915_TILING_NONE;
        metadata.priority = 1;
        metadata.modifier = DRM_FORMAT_MOD_NONE;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-                                  &metadata, render_flags);
+                                  &metadata, render_use_flags);
        if (ret)
                return ret;
 
        ret = drv_add_combinations(drv, texture_source_formats, ARRAY_SIZE(texture_source_formats),
-                                  &metadata, texture_flags);
+                                  &metadata, texture_use_flags);
        if (ret)
                return ret;
 
        ret = drv_add_combinations(drv, tileable_texture_source_formats,
                                   ARRAY_SIZE(tileable_texture_source_formats), &metadata,
-                                  texture_flags);
+                                  texture_use_flags);
        if (ret)
                return ret;
 
@@ -124,28 +124,28 @@ static int i915_add_combinations(struct driver *drv)
        drv_modify_combination(drv, DRM_FORMAT_R8, &metadata,
                               BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE);
 
-       render_flags &= ~BO_USE_RENDERSCRIPT;
-       render_flags &= ~BO_USE_SW_WRITE_OFTEN;
-       render_flags &= ~BO_USE_SW_READ_OFTEN;
-       render_flags &= ~BO_USE_LINEAR;
+       render_use_flags &= ~BO_USE_RENDERSCRIPT;
+       render_use_flags &= ~BO_USE_SW_WRITE_OFTEN;
+       render_use_flags &= ~BO_USE_SW_READ_OFTEN;
+       render_use_flags &= ~BO_USE_LINEAR;
 
-       texture_flags &= ~BO_USE_RENDERSCRIPT;
-       texture_flags &= ~BO_USE_SW_WRITE_OFTEN;
-       texture_flags &= ~BO_USE_SW_READ_OFTEN;
-       texture_flags &= ~BO_USE_LINEAR;
+       texture_use_flags &= ~BO_USE_RENDERSCRIPT;
+       texture_use_flags &= ~BO_USE_SW_WRITE_OFTEN;
+       texture_use_flags &= ~BO_USE_SW_READ_OFTEN;
+       texture_use_flags &= ~BO_USE_LINEAR;
 
        metadata.tiling = I915_TILING_X;
        metadata.priority = 2;
        metadata.modifier = I915_FORMAT_MOD_X_TILED;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-                                  &metadata, render_flags);
+                                  &metadata, render_use_flags);
        if (ret)
                return ret;
 
        ret = drv_add_combinations(drv, tileable_texture_source_formats,
                                   ARRAY_SIZE(tileable_texture_source_formats), &metadata,
-                                  texture_flags);
+                                  texture_use_flags);
        if (ret)
                return ret;
 
@@ -154,13 +154,13 @@ static int i915_add_combinations(struct driver *drv)
        metadata.modifier = I915_FORMAT_MOD_Y_TILED;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-                                  &metadata, render_flags);
+                                  &metadata, render_use_flags);
        if (ret)
                return ret;
 
        ret = drv_add_combinations(drv, tileable_texture_source_formats,
                                   ARRAY_SIZE(tileable_texture_source_formats), &metadata,
-                                  texture_flags);
+                                  texture_use_flags);
        if (ret)
                return ret;
 
@@ -297,7 +297,7 @@ static int i915_init(struct driver *drv)
 }
 
 static int i915_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                         uint64_t flags)
+                         uint64_t use_flags)
 {
        int ret;
        size_t plane;
@@ -306,7 +306,7 @@ static int i915_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32
        struct drm_i915_gem_set_tiling gem_set_tiling;
        struct combination *combo;
 
-       combo = drv_get_combination(bo->drv, format, flags);
+       combo = drv_get_combination(bo->drv, format, use_flags);
        if (!combo)
                return -EINVAL;
 
@@ -430,7 +430,7 @@ static void *i915_bo_map(struct bo *bo, struct map_info *data, size_t plane, int
                struct drm_i915_gem_mmap gem_map;
                memset(&gem_map, 0, sizeof(gem_map));
 
-               if ((bo->flags & BO_USE_SCANOUT) && !(bo->flags & BO_USE_RENDERSCRIPT))
+               if ((bo->use_flags & BO_USE_SCANOUT) && !(bo->use_flags & BO_USE_RENDERSCRIPT))
                        gem_map.flags = I915_MMAP_WC;
 
                gem_map.handle = bo->handles[0].u32;
@@ -488,18 +488,18 @@ static int i915_bo_flush(struct bo *bo, struct map_info *data)
        return 0;
 }
 
-static uint32_t i915_resolve_format(uint32_t format, uint64_t usage)
+static uint32_t i915_resolve_format(uint32_t format, uint64_t use_flags)
 {
        switch (format) {
        case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:
                /* KBL camera subsystem requires NV12. */
-               if (usage & (BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE))
+               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:
                /* KBL camera subsystem requires NV12. */
-               if (usage & (BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE))
+               if (use_flags & (BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE))
                        return DRM_FORMAT_NV12;
                return DRM_FORMAT_YVU420;
        default:

diff --git a/mediatek.c b/mediatek.c
index fd2c74b..b999e28 100644 (file)
--- a/mediatek.c
+++ b/mediatek.c
@@ -47,7 +47,7 @@ static int mediatek_init(struct driver *drv)
 }
 
 static int mediatek_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                             uint64_t flags)
+                             uint64_t use_flags)
 {
        int ret;
        size_t plane;
@@ -97,7 +97,7 @@ static void *mediatek_bo_map(struct bo *bo, struct map_info *data, size_t plane,
 
        data->length = bo->total_size;
 
-       if (bo->flags & BO_USE_RENDERSCRIPT) {
+       if (bo->use_flags & BO_USE_RENDERSCRIPT) {
                priv = calloc(1, sizeof(*priv));
                priv->cached_addr = calloc(1, bo->total_size);
                priv->gem_addr = addr;
@@ -131,7 +131,7 @@ static int mediatek_bo_flush(struct bo *bo, struct map_info *data)
        return 0;
 }
 
-static uint32_t mediatek_resolve_format(uint32_t format, uint64_t usage)
+static uint32_t mediatek_resolve_format(uint32_t format, uint64_t use_flags)
 {
        switch (format) {
        case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:

diff --git a/rockchip.c b/rockchip.c
index 860f3b9..58a60aa 100644 (file)
--- a/rockchip.c
+++ b/rockchip.c
@@ -78,7 +78,7 @@ 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;
 
@@ -86,21 +86,22 @@ static int rockchip_add_kms_item(struct driver *drv, const struct kms_item *item
                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;
                        }
                }
        }
@@ -231,7 +232,7 @@ 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,
-                             uint64_t flags)
+                             uint64_t use_flags)
 {
        uint64_t modifiers[] = { DRM_FORMAT_MOD_NONE };
        return rockchip_bo_create_with_modifiers(bo, width, height, format, modifiers,
@@ -262,7 +263,7 @@ static void *rockchip_bo_map(struct bo *bo, struct map_info *data, size_t plane,
 
        data->length = bo->total_size;
 
-       if (bo->flags & BO_USE_RENDERSCRIPT) {
+       if (bo->use_flags & BO_USE_RENDERSCRIPT) {
                priv = calloc(1, sizeof(*priv));
                priv->cached_addr = calloc(1, bo->total_size);
                priv->gem_addr = addr;
@@ -296,12 +297,12 @@ static int rockchip_bo_flush(struct bo *bo, struct map_info *data)
        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 (usage & (BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE))
+               if (use_flags & (BO_USE_CAMERA_READ | BO_USE_CAMERA_WRITE))
                        return DRM_FORMAT_NV12;
                /*HACK: See b/28671744 */
                return DRM_FORMAT_XBGR8888;

diff --git a/tegra.c b/tegra.c
index 2281872..a3e864e 100644 (file)
--- a/tegra.c
+++ b/tegra.c
@@ -182,29 +182,29 @@ static int tegra_init(struct driver *drv)
 {
        int ret;
        struct format_metadata metadata;
-       uint64_t flags = BO_USE_RENDER_MASK;
+       uint64_t use_flags = BO_USE_RENDER_MASK;
 
        metadata.tiling = NV_MEM_KIND_PITCH;
        metadata.priority = 1;
        metadata.modifier = DRM_FORMAT_MOD_NONE;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-                                  &metadata, flags);
+                                  &metadata, use_flags);
        if (ret)
                return ret;
 
        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);
 
-       flags &= ~BO_USE_SW_WRITE_OFTEN;
-       flags &= ~BO_USE_SW_READ_OFTEN;
-       flags &= ~BO_USE_LINEAR;
+       use_flags &= ~BO_USE_SW_WRITE_OFTEN;
+       use_flags &= ~BO_USE_SW_READ_OFTEN;
+       use_flags &= ~BO_USE_LINEAR;
 
        metadata.tiling = NV_MEM_KIND_C32_2CRA;
        metadata.priority = 2;
 
        ret = drv_add_combinations(drv, render_target_formats, ARRAY_SIZE(render_target_formats),
-                                  &metadata, flags);
+                                  &metadata, use_flags);
        if (ret)
                return ret;
 
@@ -214,14 +214,15 @@ static int tegra_init(struct driver *drv)
 }
 
 static int tegra_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                          uint64_t flags)
+                          uint64_t use_flags)
 {
        uint32_t size, stride, block_height_log2 = 0;
        enum nv_mem_kind kind = NV_MEM_KIND_PITCH;
        struct drm_tegra_gem_create gem_create;
        int ret;
 
-       if (flags & (BO_USE_CURSOR | BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN))
+       if (use_flags &
+           (BO_USE_CURSOR | BO_USE_LINEAR | BO_USE_SW_READ_OFTEN | BO_USE_SW_WRITE_OFTEN))
                compute_layout_linear(width, height, format, &stride, &size);
        else
                compute_layout_blocklinear(width, height, format, &kind, &block_height_log2,

diff --git a/vc4.c b/vc4.c
index dd85bc3..04e0ad9 100644 (file)
--- a/vc4.c
+++ b/vc4.c
@@ -31,7 +31,7 @@ static int vc4_init(struct driver *drv)
 }
 
 static int vc4_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                        uint64_t flags)
+                        uint64_t use_flags)
 {
        int ret;
        size_t plane;

diff --git a/vgem.c b/vgem.c
index d5dc823..867b439 100644 (file)
--- a/vgem.c
+++ b/vgem.c
@@ -47,7 +47,7 @@ static int vgem_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32
        return drv_dumb_bo_create(bo, width, height, format, flags);
 }
 
-static uint32_t vgem_resolve_format(uint32_t format, uint64_t usage)
+static uint32_t vgem_resolve_format(uint32_t format, uint64_t flags)
 {
        switch (format) {
        case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED:

diff --git a/virtio_gpu.c b/virtio_gpu.c
index 49e2e7a..6548e59 100644 (file)
--- a/virtio_gpu.c
+++ b/virtio_gpu.c
@@ -35,7 +35,7 @@ static int virtio_gpu_init(struct driver *drv)
 }
 
 static int virtio_gpu_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
-                               uint64_t flags)
+                               uint64_t use_flags)
 {
        width = ALIGN(width, MESA_LLVMPIPE_TILE_SIZE);
        height = ALIGN(height, MESA_LLVMPIPE_TILE_SIZE);
@@ -44,10 +44,10 @@ static int virtio_gpu_bo_create(struct bo *bo, uint32_t width, uint32_t height,
        if (bo->format == DRM_FORMAT_YVU420_ANDROID)
                height = bo->height;
 
-       return drv_dumb_bo_create(bo, width, height, format, flags);
+       return drv_dumb_bo_create(bo, width, height, format, use_flags);
 }
 
-static uint32_t virtio_gpu_resolve_format(uint32_t format, uint64_t usage)
+static uint32_t virtio_gpu_resolve_format(uint32_t format, uint64_t use_flags)
 {
        switch (format) {
        case DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED: