minigbm: rename mutex

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

diff --git a/drv.c b/drv.c
index 9f1c771..8861536 100644 (file)
--- a/drv.c
+++ b/drv.c
@@ -111,7 +111,7 @@ struct driver *drv_create(int fd)
        if (!drv->backend)
                goto free_driver;
 
-       if (pthread_mutex_init(&drv->table_lock, NULL))
+       if (pthread_mutex_init(&drv->driver_lock, NULL))
                goto free_driver;
 
        drv->buffer_table = drmHashCreate();
@@ -122,6 +122,8 @@ struct driver *drv_create(int fd)
        if (!drv->map_table)
                goto free_buffer_table;
 
+       LIST_INITHEAD(&drv->backend->combinations);
+
        if (drv->backend->init) {
                ret = drv->backend->init(drv);
                if (ret)
@@ -135,7 +137,7 @@ free_map_table:
 free_buffer_table:
        drmHashDestroy(drv->buffer_table);
 free_lock:
-       pthread_mutex_destroy(&drv->table_lock);
+       pthread_mutex_destroy(&drv->driver_lock);
 free_driver:
        free(drv);
        return NULL;
@@ -143,13 +145,23 @@ free_driver:
 
 void drv_destroy(struct driver *drv)
 {
+       pthread_mutex_lock(&drv->driver_lock);
+
        if (drv->backend->close)
                drv->backend->close(drv);
 
-       pthread_mutex_destroy(&drv->table_lock);
        drmHashDestroy(drv->buffer_table);
        drmHashDestroy(drv->map_table);
 
+       list_for_each_entry_safe(struct combination_list_element, elem,
+                                &drv->backend->combinations, link) {
+               LIST_DEL(&elem->link);
+               free(elem);
+       }
+
+       pthread_mutex_unlock(&drv->driver_lock);
+       pthread_mutex_destroy(&drv->driver_lock);
+
        free(drv);
 }
 
@@ -164,21 +176,18 @@ drv_get_name(struct driver *drv)
        return drv->backend->name;
 }
 
-int drv_is_format_supported(struct driver *drv, uint32_t format,
-                           uint64_t usage)
+int drv_is_combination_supported(struct driver *drv, uint32_t format,
+                                uint64_t usage, uint64_t modifier)
 {
-       unsigned int i;
 
        if (format == DRM_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)
+       list_for_each_entry(struct combination_list_element, elem,
+                           &drv->backend->combinations, link) {
+               if (format == elem->combination.format &&
+                   usage == (elem->combination.usage & usage) &&
+                   modifier == elem->combination.modifier)
                        return 1;
        }
 
@@ -228,12 +237,12 @@ struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height,
                return NULL;
        }
 
-       pthread_mutex_lock(&drv->table_lock);
+       pthread_mutex_lock(&drv->driver_lock);
 
        for (plane = 0; plane < bo->num_planes; plane++)
                drv_increment_reference_count(drv, bo, plane);
 
-       pthread_mutex_unlock(&drv->table_lock);
+       pthread_mutex_unlock(&drv->driver_lock);
 
        return bo;
 }
@@ -244,7 +253,7 @@ void drv_bo_destroy(struct bo *bo)
        uintptr_t total = 0;
        struct driver *drv = bo->drv;
 
-       pthread_mutex_lock(&drv->table_lock);
+       pthread_mutex_lock(&drv->driver_lock);
 
        for (plane = 0; plane < bo->num_planes; plane++)
                drv_decrement_reference_count(drv, bo, plane);
@@ -252,7 +261,7 @@ void drv_bo_destroy(struct bo *bo)
        for (plane = 0; plane < bo->num_planes; plane++)
                total += drv_get_reference_count(drv, bo, plane);
 
-       pthread_mutex_unlock(&drv->table_lock);
+       pthread_mutex_unlock(&drv->driver_lock);
 
        if (total == 0)
                bo->drv->backend->bo_destroy(bo);
@@ -301,9 +310,9 @@ struct bo *drv_bo_import(struct driver *drv, struct drv_import_fd_data *data)
                bo->format_modifiers[plane] = data->format_modifiers[plane];
                bo->total_size += data->sizes[plane];
 
-               pthread_mutex_lock(&drv->table_lock);
+               pthread_mutex_lock(&drv->driver_lock);
                drv_increment_reference_count(drv, bo, plane);
-               pthread_mutex_unlock(&drv->table_lock);
+               pthread_mutex_unlock(&drv->driver_lock);
        }
 
        return bo;
@@ -322,7 +331,7 @@ void *drv_bo_map(struct bo *bo, uint32_t x, uint32_t y, uint32_t width,
        assert(x + width <= drv_bo_get_width(bo));
        assert(y + height <= drv_bo_get_height(bo));
 
-       pthread_mutex_lock(&bo->drv->table_lock);
+       pthread_mutex_lock(&bo->drv->driver_lock);
 
        if (!drmHashLookup(bo->drv->map_table, bo->handles[plane].u32, &ptr)) {
                data = (struct map_info *) ptr;
@@ -335,7 +344,7 @@ void *drv_bo_map(struct bo *bo, uint32_t x, uint32_t y, uint32_t width,
        if (addr == MAP_FAILED) {
                *map_data = NULL;
                free(data);
-               pthread_mutex_unlock(&bo->drv->table_lock);
+               pthread_mutex_unlock(&bo->drv->driver_lock);
                return MAP_FAILED;
        }
 
@@ -351,7 +360,7 @@ success:
        offset += drv_stride_from_format(bo->format, x, plane);
        addr = (uint8_t *) data->addr;
        addr += drv_bo_get_plane_offset(bo, plane) + offset;
-       pthread_mutex_unlock(&bo->drv->table_lock);
+       pthread_mutex_unlock(&bo->drv->driver_lock);
 
        return (void *) addr;
 }
@@ -364,7 +373,7 @@ int drv_bo_unmap(struct bo *bo, void *map_data)
        assert(data);
        assert(data->refcount >= 0);
 
-       pthread_mutex_lock(&bo->drv->table_lock);
+       pthread_mutex_lock(&bo->drv->driver_lock);
 
        if (!--data->refcount) {
                ret = munmap(data->addr, data->length);
@@ -372,7 +381,7 @@ int drv_bo_unmap(struct bo *bo, void *map_data)
                free(data);
        }
 
-       pthread_mutex_unlock(&bo->drv->table_lock);
+       pthread_mutex_unlock(&bo->drv->driver_lock);
 
        return ret;
 }
@@ -484,53 +493,53 @@ int drv_stride_from_format(uint32_t format, uint32_t width, size_t plane)
 size_t drv_num_planes_from_format(uint32_t format)
 {
        switch (format) {
+       case DRM_FORMAT_ABGR1555:
+       case DRM_FORMAT_ABGR2101010:
+       case DRM_FORMAT_ABGR4444:
+       case DRM_FORMAT_ABGR8888:
+       case DRM_FORMAT_ARGB1555:
+       case DRM_FORMAT_ARGB2101010:
+       case DRM_FORMAT_ARGB4444:
+       case DRM_FORMAT_ARGB8888:
+       case DRM_FORMAT_AYUV:
+       case DRM_FORMAT_BGR233:
+       case DRM_FORMAT_BGR565:
+       case DRM_FORMAT_BGR888:
+       case DRM_FORMAT_BGRA1010102:
+       case DRM_FORMAT_BGRA4444:
+       case DRM_FORMAT_BGRA5551:
+       case DRM_FORMAT_BGRA8888:
+       case DRM_FORMAT_BGRX1010102:
+       case DRM_FORMAT_BGRX4444:
+       case DRM_FORMAT_BGRX5551:
+       case DRM_FORMAT_BGRX8888:
        case DRM_FORMAT_C8:
+       case DRM_FORMAT_GR88:
        case DRM_FORMAT_R8:
        case DRM_FORMAT_RG88:
-       case DRM_FORMAT_GR88:
        case DRM_FORMAT_RGB332:
-       case DRM_FORMAT_BGR233:
-       case DRM_FORMAT_XRGB4444:
-       case DRM_FORMAT_XBGR4444:
-       case DRM_FORMAT_RGBX4444:
-       case DRM_FORMAT_BGRX4444:
-       case DRM_FORMAT_ARGB4444:
-       case DRM_FORMAT_ABGR4444:
+       case DRM_FORMAT_RGB565:
+       case DRM_FORMAT_RGB888:
+       case DRM_FORMAT_RGBA1010102:
        case DRM_FORMAT_RGBA4444:
-       case DRM_FORMAT_BGRA4444:
-       case DRM_FORMAT_XRGB1555:
-       case DRM_FORMAT_XBGR1555:
-       case DRM_FORMAT_RGBX5551:
-       case DRM_FORMAT_BGRX5551:
-       case DRM_FORMAT_ARGB1555:
-       case DRM_FORMAT_ABGR1555:
        case DRM_FORMAT_RGBA5551:
-       case DRM_FORMAT_BGRA5551:
-       case DRM_FORMAT_RGB565:
-       case DRM_FORMAT_BGR565:
-       case DRM_FORMAT_YUYV:
-       case DRM_FORMAT_YVYU:
+       case DRM_FORMAT_RGBA8888:
+       case DRM_FORMAT_RGBX1010102:
+       case DRM_FORMAT_RGBX4444:
+       case DRM_FORMAT_RGBX5551:
+       case DRM_FORMAT_RGBX8888:
        case DRM_FORMAT_UYVY:
        case DRM_FORMAT_VYUY:
-       case DRM_FORMAT_RGB888:
-       case DRM_FORMAT_BGR888:
-       case DRM_FORMAT_XRGB8888:
+       case DRM_FORMAT_XBGR1555:
+       case DRM_FORMAT_XBGR2101010:
+       case DRM_FORMAT_XBGR4444:
        case DRM_FORMAT_XBGR8888:
-       case DRM_FORMAT_RGBX8888:
-       case DRM_FORMAT_BGRX8888:
-       case DRM_FORMAT_ARGB8888:
-       case DRM_FORMAT_ABGR8888:
-       case DRM_FORMAT_RGBA8888:
-       case DRM_FORMAT_BGRA8888:
+       case DRM_FORMAT_XRGB1555:
        case DRM_FORMAT_XRGB2101010:
-       case DRM_FORMAT_XBGR2101010:
-       case DRM_FORMAT_RGBX1010102:
-       case DRM_FORMAT_BGRX1010102:
-       case DRM_FORMAT_ARGB2101010:
-       case DRM_FORMAT_ABGR2101010:
-       case DRM_FORMAT_RGBA1010102:
-       case DRM_FORMAT_BGRA1010102:
-       case DRM_FORMAT_AYUV:
+       case DRM_FORMAT_XRGB4444:
+       case DRM_FORMAT_XRGB8888:
+       case DRM_FORMAT_YUYV:
+       case DRM_FORMAT_YVYU:
                return 1;
        case DRM_FORMAT_NV12:
                return 2;
@@ -549,8 +558,8 @@ uint32_t drv_size_from_format(uint32_t format, uint32_t stride,
        uint32_t vertical_subsampling;
 
        switch (format) {
-       case DRM_FORMAT_YVU420:
        case DRM_FORMAT_NV12:
+       case DRM_FORMAT_YVU420:
                vertical_subsampling = (plane == 0) ? 1 : 2;
                break;
        default: