tegra: Indent according to .editorconfig

Reindent the sources according to the settings found in the newly added
.editorconfig.

Reviewed-by: Mikko Perttunen <mperttunen@nvidia.com>
Signed-off-by: Thierry Reding <treding@nvidia.com>

diff --git a/tegra/private.h b/tegra/private.h
index bb6c1a5..215dd33 100644 (file)
--- a/tegra/private.h
+++ b/tegra/private.h
@@ -34,18 +34,18 @@
 #include "tegra.h"
 
 struct drm_tegra {
-       bool close;
-       int fd;
+    bool close;
+    int fd;
 };
 
 struct drm_tegra_bo {
-       struct drm_tegra *drm;
-       uint32_t handle;
-       uint32_t offset;
-       uint32_t flags;
-       uint32_t size;
-       atomic_t ref;
-       void *map;
+    struct drm_tegra *drm;
+    uint32_t handle;
+    uint32_t offset;
+    uint32_t flags;
+    uint32_t size;
+    atomic_t ref;
+    void *map;
 };
 
 #endif /* __DRM_TEGRA_PRIVATE_H__ */

diff --git a/tegra/tegra.c b/tegra/tegra.c
index 420b171..95aaa4b 100644 (file)
--- a/tegra/tegra.c
+++ b/tegra/tegra.c
@@ -37,288 +37,292 @@
 
 static void drm_tegra_bo_free(struct drm_tegra_bo *bo)
 {
-       struct drm_tegra *drm = bo->drm;
+    struct drm_tegra *drm = bo->drm;
 
-       if (bo->map)
-               munmap(bo->map, bo->size);
+    if (bo->map)
+        munmap(bo->map, bo->size);
 
-       drmCloseBufferHandle(drm->fd, bo->handle);
+    drmCloseBufferHandle(drm->fd, bo->handle);
 
-       free(bo);
+    free(bo);
 }
 
 static int drm_tegra_wrap(struct drm_tegra **drmp, int fd, bool close)
 {
-       struct drm_tegra *drm;
+    struct drm_tegra *drm;
 
-       if (fd < 0 || !drmp)
-               return -EINVAL;
+    if (fd < 0 || !drmp)
+        return -EINVAL;
 
-       drm = calloc(1, sizeof(*drm));
-       if (!drm)
-               return -ENOMEM;
+    drm = calloc(1, sizeof(*drm));
+    if (!drm)
+        return -ENOMEM;
 
-       drm->close = close;
-       drm->fd = fd;
+    drm->close = close;
+    drm->fd = fd;
 
-       *drmp = drm;
+    *drmp = drm;
 
-       return 0;
+    return 0;
 }
 
 drm_public int drm_tegra_new(struct drm_tegra **drmp, int fd)
 {
-       bool supported = false;
-       drmVersionPtr version;
+    bool supported = false;
+    drmVersionPtr version;
 
-       version = drmGetVersion(fd);
-       if (!version)
-               return -ENOMEM;
+    version = drmGetVersion(fd);
+    if (!version)
+        return -ENOMEM;
 
-       if (!strncmp(version->name, "tegra", version->name_len))
-               supported = true;
+    if (!strncmp(version->name, "tegra", version->name_len))
+        supported = true;
 
-       drmFreeVersion(version);
+    drmFreeVersion(version);
 
-       if (!supported)
-               return -ENOTSUP;
+    if (!supported)
+        return -ENOTSUP;
 
-       return drm_tegra_wrap(drmp, fd, false);
+    return drm_tegra_wrap(drmp, fd, false);
 }
 
 drm_public void drm_tegra_close(struct drm_tegra *drm)
 {
-       if (!drm)
-               return;
+    if (!drm)
+        return;
 
-       if (drm->close)
-               close(drm->fd);
+    if (drm->close)
+        close(drm->fd);
 
-       free(drm);
+    free(drm);
 }
 
-drm_public int drm_tegra_bo_new(struct drm_tegra_bo **bop, struct drm_tegra *drm,
-                    uint32_t flags, uint32_t size)
+drm_public int
+drm_tegra_bo_new(struct drm_tegra_bo **bop, struct drm_tegra *drm,
+                 uint32_t flags, uint32_t size)
 {
-       struct drm_tegra_gem_create args;
-       struct drm_tegra_bo *bo;
-       int err;
+    struct drm_tegra_gem_create args;
+    struct drm_tegra_bo *bo;
+    int err;
 
-       if (!drm || size == 0 || !bop)
-               return -EINVAL;
+    if (!drm || size == 0 || !bop)
+        return -EINVAL;
 
-       bo = calloc(1, sizeof(*bo));
-       if (!bo)
-               return -ENOMEM;
+    bo = calloc(1, sizeof(*bo));
+    if (!bo)
+        return -ENOMEM;
 
-       atomic_set(&bo->ref, 1);
-       bo->flags = flags;
-       bo->size = size;
-       bo->drm = drm;
+    atomic_set(&bo->ref, 1);
+    bo->flags = flags;
+    bo->size = size;
+    bo->drm = drm;
 
-       memset(&args, 0, sizeof(args));
-       args.flags = flags;
-       args.size = size;
+    memset(&args, 0, sizeof(args));
+    args.flags = flags;
+    args.size = size;
 
-       err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_CREATE, &args,
-                                 sizeof(args));
-       if (err < 0) {
-               err = -errno;
-               free(bo);
-               return err;
-       }
+    err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_CREATE, &args,
+                              sizeof(args));
+    if (err < 0) {
+        err = -errno;
+        free(bo);
+        return err;
+    }
 
-       bo->handle = args.handle;
+    bo->handle = args.handle;
 
-       *bop = bo;
+    *bop = bo;
 
-       return 0;
+    return 0;
 }
 
-drm_public int drm_tegra_bo_wrap(struct drm_tegra_bo **bop, struct drm_tegra *drm,
-                     uint32_t handle, uint32_t flags, uint32_t size)
+drm_public int
+drm_tegra_bo_wrap(struct drm_tegra_bo **bop, struct drm_tegra *drm,
+                  uint32_t handle, uint32_t flags, uint32_t size)
 {
-       struct drm_tegra_bo *bo;
+    struct drm_tegra_bo *bo;
 
-       if (!drm || !bop)
-               return -EINVAL;
+    if (!drm || !bop)
+        return -EINVAL;
 
-       bo = calloc(1, sizeof(*bo));
-       if (!bo)
-               return -ENOMEM;
+    bo = calloc(1, sizeof(*bo));
+    if (!bo)
+        return -ENOMEM;
 
-       atomic_set(&bo->ref, 1);
-       bo->handle = handle;
-       bo->flags = flags;
-       bo->size = size;
-       bo->drm = drm;
+    atomic_set(&bo->ref, 1);
+    bo->handle = handle;
+    bo->flags = flags;
+    bo->size = size;
+    bo->drm = drm;
 
-       *bop = bo;
+    *bop = bo;
 
-       return 0;
+    return 0;
 }
 
 drm_public struct drm_tegra_bo *drm_tegra_bo_ref(struct drm_tegra_bo *bo)
 {
-       if (bo)
-               atomic_inc(&bo->ref);
+    if (bo)
+        atomic_inc(&bo->ref);
 
-       return bo;
+    return bo;
 }
 
 drm_public void drm_tegra_bo_unref(struct drm_tegra_bo *bo)
 {
-       if (bo && atomic_dec_and_test(&bo->ref))
-               drm_tegra_bo_free(bo);
+    if (bo && atomic_dec_and_test(&bo->ref))
+        drm_tegra_bo_free(bo);
 }
 
 drm_public int drm_tegra_bo_get_handle(struct drm_tegra_bo *bo, uint32_t *handle)
 {
-       if (!bo || !handle)
-               return -EINVAL;
+    if (!bo || !handle)
+        return -EINVAL;
 
-       *handle = bo->handle;
+    *handle = bo->handle;
 
-       return 0;
+    return 0;
 }
 
 drm_public int drm_tegra_bo_map(struct drm_tegra_bo *bo, void **ptr)
 {
-       struct drm_tegra *drm = bo->drm;
+    struct drm_tegra *drm = bo->drm;
 
-       if (!bo->map) {
-               struct drm_tegra_gem_mmap args;
-               int err;
+    if (!bo->map) {
+        struct drm_tegra_gem_mmap args;
+        int err;
 
-               memset(&args, 0, sizeof(args));
-               args.handle = bo->handle;
+        memset(&args, 0, sizeof(args));
+        args.handle = bo->handle;
 
-               err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_MMAP, &args,
-                                         sizeof(args));
-               if (err < 0)
-                       return -errno;
+        err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_MMAP, &args,
+                                  sizeof(args));
+        if (err < 0)
+            return -errno;
 
-               bo->offset = args.offset;
+        bo->offset = args.offset;
 
-               bo->map = mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED,
-                              drm->fd, bo->offset);
-               if (bo->map == MAP_FAILED) {
-                       bo->map = NULL;
-                       return -errno;
-               }
-       }
+        bo->map = mmap(0, bo->size, PROT_READ | PROT_WRITE, MAP_SHARED,
+                       drm->fd, bo->offset);
+        if (bo->map == MAP_FAILED) {
+            bo->map = NULL;
+            return -errno;
+        }
+    }
 
-       if (ptr)
-               *ptr = bo->map;
+    if (ptr)
+        *ptr = bo->map;
 
-       return 0;
+    return 0;
 }
 
 drm_public int drm_tegra_bo_unmap(struct drm_tegra_bo *bo)
 {
-       if (!bo)
-               return -EINVAL;
+    if (!bo)
+        return -EINVAL;
 
-       if (!bo->map)
-               return 0;
+    if (!bo->map)
+        return 0;
 
-       if (munmap(bo->map, bo->size))
-               return -errno;
+    if (munmap(bo->map, bo->size))
+        return -errno;
 
-       bo->map = NULL;
+    bo->map = NULL;
 
-       return 0;
+    return 0;
 }
 
 drm_public int drm_tegra_bo_get_flags(struct drm_tegra_bo *bo, uint32_t *flags)
 {
-       struct drm_tegra_gem_get_flags args;
-       struct drm_tegra *drm = bo->drm;
-       int err;
+    struct drm_tegra_gem_get_flags args;
+    struct drm_tegra *drm = bo->drm;
+    int err;
 
-       if (!bo)
-               return -EINVAL;
+    if (!bo)
+        return -EINVAL;
 
-       memset(&args, 0, sizeof(args));
-       args.handle = bo->handle;
+    memset(&args, 0, sizeof(args));
+    args.handle = bo->handle;
 
-       err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_GET_FLAGS, &args,
-                                 sizeof(args));
-       if (err < 0)
-               return -errno;
+    err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_GET_FLAGS, &args,
+                              sizeof(args));
+    if (err < 0)
+        return -errno;
 
-       if (flags)
-               *flags = args.flags;
+    if (flags)
+        *flags = args.flags;
 
-       return 0;
+    return 0;
 }
 
 drm_public int drm_tegra_bo_set_flags(struct drm_tegra_bo *bo, uint32_t flags)
 {
-       struct drm_tegra_gem_get_flags args;
-       struct drm_tegra *drm = bo->drm;
-       int err;
+    struct drm_tegra_gem_get_flags args;
+    struct drm_tegra *drm = bo->drm;
+    int err;
 
-       if (!bo)
-               return -EINVAL;
+    if (!bo)
+        return -EINVAL;
 
-       memset(&args, 0, sizeof(args));
-       args.handle = bo->handle;
-       args.flags = flags;
+    memset(&args, 0, sizeof(args));
+    args.handle = bo->handle;
+    args.flags = flags;
 
-       err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_SET_FLAGS, &args,
-                                 sizeof(args));
-       if (err < 0)
-               return -errno;
+    err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_SET_FLAGS, &args,
+                              sizeof(args));
+    if (err < 0)
+        return -errno;
 
-       return 0;
+    return 0;
 }
 
-drm_public int drm_tegra_bo_get_tiling(struct drm_tegra_bo *bo,
-                           struct drm_tegra_bo_tiling *tiling)
+drm_public int
+drm_tegra_bo_get_tiling(struct drm_tegra_bo *bo,
+                        struct drm_tegra_bo_tiling *tiling)
 {
-       struct drm_tegra_gem_get_tiling args;
-       struct drm_tegra *drm = bo->drm;
-       int err;
+    struct drm_tegra_gem_get_tiling args;
+    struct drm_tegra *drm = bo->drm;
+    int err;
 
-       if (!bo)
-               return -EINVAL;
+    if (!bo)
+        return -EINVAL;
 
-       memset(&args, 0, sizeof(args));
-       args.handle = bo->handle;
+    memset(&args, 0, sizeof(args));
+    args.handle = bo->handle;
 
-       err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_GET_TILING, &args,
-                                 sizeof(args));
-       if (err < 0)
-               return -errno;
+    err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_GET_TILING, &args,
+                              sizeof(args));
+    if (err < 0)
+        return -errno;
 
-       if (tiling) {
-               tiling->mode = args.mode;
-               tiling->value = args.value;
-       }
+    if (tiling) {
+        tiling->mode = args.mode;
+        tiling->value = args.value;
+    }
 
-       return 0;
+    return 0;
 }
 
-drm_public int drm_tegra_bo_set_tiling(struct drm_tegra_bo *bo,
-                           const struct drm_tegra_bo_tiling *tiling)
+drm_public int
+drm_tegra_bo_set_tiling(struct drm_tegra_bo *bo,
+                        const struct drm_tegra_bo_tiling *tiling)
 {
-       struct drm_tegra_gem_set_tiling args;
-       struct drm_tegra *drm = bo->drm;
-       int err;
+    struct drm_tegra_gem_set_tiling args;
+    struct drm_tegra *drm = bo->drm;
+    int err;
 
-       if (!bo)
-               return -EINVAL;
+    if (!bo)
+        return -EINVAL;
 
-       memset(&args, 0, sizeof(args));
-       args.handle = bo->handle;
-       args.mode = tiling->mode;
-       args.value = tiling->value;
+    memset(&args, 0, sizeof(args));
+    args.handle = bo->handle;
+    args.mode = tiling->mode;
+    args.value = tiling->value;
 
-       err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_SET_TILING, &args,
-                                 sizeof(args));
-       if (err < 0)
-               return -errno;
+    err = drmCommandWriteRead(drm->fd, DRM_TEGRA_GEM_SET_TILING, &args,
+                              sizeof(args));
+    if (err < 0)
+        return -errno;
 
-       return 0;
+    return 0;
 }

diff --git a/tegra/tegra.h b/tegra/tegra.h
index 31b0995..62205a5 100644 (file)
--- a/tegra/tegra.h
+++ b/tegra/tegra.h
@@ -35,9 +35,9 @@ int drm_tegra_new(struct drm_tegra **drmp, int fd);
 void drm_tegra_close(struct drm_tegra *drm);
 
 int drm_tegra_bo_new(struct drm_tegra_bo **bop, struct drm_tegra *drm,
-                    uint32_t flags, uint32_t size);
+                     uint32_t flags, uint32_t size);
 int drm_tegra_bo_wrap(struct drm_tegra_bo **bop, struct drm_tegra *drm,
-                     uint32_t handle, uint32_t flags, uint32_t size);
+                      uint32_t handle, uint32_t flags, uint32_t size);
 struct drm_tegra_bo *drm_tegra_bo_ref(struct drm_tegra_bo *bo);
 void drm_tegra_bo_unref(struct drm_tegra_bo *bo);
 int drm_tegra_bo_get_handle(struct drm_tegra_bo *bo, uint32_t *handle);
@@ -48,13 +48,13 @@ int drm_tegra_bo_get_flags(struct drm_tegra_bo *bo, uint32_t *flags);
 int drm_tegra_bo_set_flags(struct drm_tegra_bo *bo, uint32_t flags);
 
 struct drm_tegra_bo_tiling {
-       uint32_t mode;
-       uint32_t value;
+    uint32_t mode;
+    uint32_t value;
 };
 
 int drm_tegra_bo_get_tiling(struct drm_tegra_bo *bo,
-                           struct drm_tegra_bo_tiling *tiling);
+                            struct drm_tegra_bo_tiling *tiling);
 int drm_tegra_bo_set_tiling(struct drm_tegra_bo *bo,
-                           const struct drm_tegra_bo_tiling *tiling);
+                            const struct drm_tegra_bo_tiling *tiling);
 
 #endif /* __DRM_TEGRA_H__ */

diff --git a/tests/tegra/openclose.c b/tests/tegra/openclose.c
index f80f52d..104e838 100644 (file)
--- a/tests/tegra/openclose.c
+++ b/tests/tegra/openclose.c
@@ -31,37 +31,37 @@ static const char default_device[] = "/dev/dri/card0";
 
 int main(int argc, char *argv[])
 {
-       struct drm_tegra *tegra;
-       drmVersionPtr version;
-       const char *device;
-       int err, fd;
+    struct drm_tegra *tegra;
+    drmVersionPtr version;
+    const char *device;
+    int err, fd;
 
-       if (argc < 2)
-               device = default_device;
-       else
-               device = argv[1];
+    if (argc < 2)
+        device = default_device;
+    else
+        device = argv[1];
 
-       fd = open(device, O_RDWR);
-       if (fd < 0)
-               return 1;
+    fd = open(device, O_RDWR);
+    if (fd < 0)
+        return 1;
 
-       version = drmGetVersion(fd);
-       if (version) {
-               printf("Version: %d.%d.%d\n", version->version_major,
-                      version->version_minor, version->version_patchlevel);
-               printf("  Name: %s\n", version->name);
-               printf("  Date: %s\n", version->date);
-               printf("  Description: %s\n", version->desc);
+    version = drmGetVersion(fd);
+    if (version) {
+        printf("Version: %d.%d.%d\n", version->version_major,
+               version->version_minor, version->version_patchlevel);
+        printf("  Name: %s\n", version->name);
+        printf("  Date: %s\n", version->date);
+        printf("  Description: %s\n", version->desc);
 
-               drmFreeVersion(version);
-       }
+        drmFreeVersion(version);
+    }
 
-       err = drm_tegra_new(&tegra, fd);
-       if (err < 0)
-               return 1;
+    err = drm_tegra_new(&tegra, fd);
+    if (err < 0)
+        return 1;
 
-       drm_tegra_close(tegra);
-       close(fd);
+    drm_tegra_close(tegra);
+    close(fd);
 
-       return 0;
+    return 0;
 }