minigbm: add clang-format and presubmit hooks

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

diff --git a/drv.c b/drv.c
index cfeb4b5..e94c2a8 100644 (file)
--- a/drv.c
+++ b/drv.c
@@ -64,8 +64,7 @@ static struct backend *drv_get_backend(int fd)
 #ifdef DRV_AMDGPU
                &backend_amdgpu,
 #endif
-               &backend_cirrus,
-               &backend_evdi,
+               &backend_cirrus,   &backend_evdi,
 #ifdef DRV_EXYNOS
                &backend_exynos,
 #endif
@@ -90,11 +89,10 @@ static struct backend *drv_get_backend(int fd)
 #ifdef DRV_VC4
                &backend_vc4,
 #endif
-               &backend_vgem,
-               &backend_virtio_gpu,
+               &backend_vgem,     &backend_virtio_gpu,
        };
 
-       for(i = 0; i < ARRAY_SIZE(backend_list); i++)
+       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];
@@ -109,7 +107,7 @@ struct driver *drv_create(int fd)
        struct driver *drv;
        int ret;
 
-       drv = (struct driver *) calloc(1, sizeof(*drv));
+       drv = (struct driver *)calloc(1, sizeof(*drv));
 
        if (!drv)
                return NULL;
@@ -134,8 +132,8 @@ struct driver *drv_create(int fd)
        /* Start with a power of 2 number of allocations. */
        drv->backend->combos.allocations = 2;
        drv->backend->combos.size = 0;
-       drv->backend->combos.data = calloc(drv->backend->combos.allocations,
-                                          sizeof(struct combination));
+       drv->backend->combos.data =
+           calloc(drv->backend->combos.allocations, sizeof(struct combination));
        if (!drv->backend->combos.data)
                goto free_map_table;
 
@@ -183,14 +181,12 @@ int drv_get_fd(struct driver *drv)
        return drv->fd;
 }
 
-const char *
-drv_get_name(struct driver *drv)
+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 usage)
 {
        struct combination *curr, *best;
 
@@ -202,20 +198,18 @@ struct combination *drv_get_combination(struct driver *drv, uint32_t format,
        for (i = 0; i < drv->backend->combos.size; i++) {
                curr = &drv->backend->combos.data[i];
                if ((format == curr->format) && usage == (curr->usage & usage))
-                       if (!best ||
-                           best->metadata.priority < curr->metadata.priority)
+                       if (!best || best->metadata.priority < curr->metadata.priority)
                                best = curr;
        }
 
        return best;
 }
 
-struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height,
-                     uint32_t format)
+struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height, uint32_t format)
 {
 
        struct bo *bo;
-       bo = (struct bo *) calloc(1, sizeof(*bo));
+       bo = (struct bo *)calloc(1, sizeof(*bo));
 
        if (!bo)
                return NULL;
@@ -234,8 +228,8 @@ struct bo *drv_bo_new(struct driver *drv, uint32_t width, uint32_t height,
        return bo;
 }
 
-struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height,
-                        uint32_t format, uint64_t flags)
+struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height, uint32_t format,
+                        uint64_t flags)
 {
        int ret;
        size_t plane;
@@ -263,10 +257,8 @@ struct bo *drv_bo_create(struct driver *drv, uint32_t width, uint32_t height,
        return bo;
 }
 
-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)
+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)
 {
        int ret;
        size_t plane;
@@ -282,8 +274,7 @@ struct bo *drv_bo_create_with_modifiers(struct driver *drv,
        if (!bo)
                return NULL;
 
-       ret = drv->backend->bo_create_with_modifiers(bo, width, height,
-                                                    format, modifiers, count);
+       ret = drv->backend->bo_create_with_modifiers(bo, width, height, format, modifiers, count);
 
        if (ret) {
                free(bo);
@@ -300,7 +291,6 @@ struct bo *drv_bo_create_with_modifiers(struct driver *drv,
        return bo;
 }
 
-
 void drv_bo_destroy(struct bo *bo)
 {
        size_t plane;
@@ -351,9 +341,8 @@ struct bo *drv_bo_import(struct driver *drv, struct drv_import_fd_data *data)
        return bo;
 }
 
-void *drv_bo_map(struct bo *bo, uint32_t x, uint32_t y, uint32_t width,
-                uint32_t height, uint32_t flags, struct map_info **map_data,
-                size_t plane)
+void *drv_bo_map(struct bo *bo, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
+                uint32_t flags, struct map_info **map_data, size_t plane)
 {
        void *ptr;
        uint8_t *addr;
@@ -368,7 +357,7 @@ void *drv_bo_map(struct bo *bo, uint32_t x, uint32_t y, uint32_t width,
        pthread_mutex_lock(&bo->drv->driver_lock);
 
        if (!drmHashLookup(bo->drv->map_table, bo->handles[plane].u32, &ptr)) {
-               data = (struct map_info *) ptr;
+               data = (struct map_info *)ptr;
                data->refcount++;
                goto success;
        }
@@ -385,18 +374,17 @@ void *drv_bo_map(struct bo *bo, uint32_t x, uint32_t y, uint32_t width,
        data->refcount = 1;
        data->addr = addr;
        data->handle = bo->handles[plane].u32;
-       drmHashInsert(bo->drv->map_table, bo->handles[plane].u32,
-                     (void *) data);
+       drmHashInsert(bo->drv->map_table, bo->handles[plane].u32, (void *)data);
 
 success:
        *map_data = data;
        offset = drv_bo_get_plane_stride(bo, plane) * y;
        offset += drv_stride_from_format(bo->format, x, plane);
-       addr = (uint8_t *) data->addr;
+       addr = (uint8_t *)data->addr;
        addr += drv_bo_get_plane_offset(bo, plane) + offset;
        pthread_mutex_unlock(&bo->drv->driver_lock);
 
-       return (void *) addr;
+       return (void *)addr;
 }
 
 int drv_bo_unmap(struct bo *bo, struct map_info *data)
@@ -457,11 +445,9 @@ 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);
+       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)
@@ -484,7 +470,7 @@ 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)
 {
-        assert(plane < bo->num_planes);
+       assert(plane < bo->num_planes);
        return bo->format_modifiers[plane];
 }
 
@@ -563,8 +549,7 @@ size_t drv_num_planes_from_format(uint32_t format)
        return 0;
 }
 
-uint32_t drv_size_from_format(uint32_t format, uint32_t stride,
-                             uint32_t height, size_t plane)
+uint32_t drv_size_from_format(uint32_t format, uint32_t stride, uint32_t height, size_t plane)
 {
        assert(plane < drv_num_planes_from_format(format));
        uint32_t vertical_subsampling;