gpu: host1x: Whitespace cleanup for readability

Insert a number of blank lines in places where they increase readability
of the code. Also collapse various variable declarations to shorten some
functions and finally rewrite some code for readability.

Signed-off-by: Thierry Reding <treding@nvidia.com>

10 files changed, 92 insertions, 43 deletions

diff --git a/drivers/gpu/host1x/cdma.c b/drivers/gpu/host1x/cdma.c
index b83b0a04d9c5..c5d82a8a2ec9 100644
--- a/drivers/gpu/host1x/cdma.c
+++ b/drivers/gpu/host1x/cdma.c
@@ -134,14 +134,19 @@ unsigned int host1x_cdma_wait_locked(struct host1x_cdma *cdma,
                                      enum cdma_event event)
 {
         for (;;) {
+                struct push_buffer *pb = &cdma->push_buffer;
                 unsigned int space;
 
-                if (event == CDMA_EVENT_SYNC_QUEUE_EMPTY)
+                switch (event) {
+                case CDMA_EVENT_SYNC_QUEUE_EMPTY:
                         space = list_empty(&cdma->sync_queue) ? 1 : 0;
-                else if (event == CDMA_EVENT_PUSH_BUFFER_SPACE) {
-                        struct push_buffer *pb = &cdma->push_buffer;
+                        break;
+
+                case CDMA_EVENT_PUSH_BUFFER_SPACE:
                         space = host1x_pushbuffer_space(pb);
-                } else {
+                        break;
+
+                default:
                         WARN_ON(1);
                         return -EINVAL;
                 }
@@ -159,12 +164,14 @@ unsigned int host1x_cdma_wait_locked(struct host1x_cdma *cdma,
                         mutex_lock(&cdma->lock);
                         continue;
                 }
+
                 cdma->event = event;
 
                 mutex_unlock(&cdma->lock);
                 down(&cdma->sem);
                 mutex_lock(&cdma->lock);
         }
+
         return 0;
 }
 
@@ -234,6 +241,7 @@ static void update_cdma_locked(struct host1x_cdma *cdma)
                         /* Start timer on next pending syncpt */
                         if (job->timeout)
                                 cdma_start_timer_locked(cdma, job);
+
                         break;
                 }
 
@@ -249,6 +257,7 @@ static void update_cdma_locked(struct host1x_cdma *cdma)
                         struct push_buffer *pb = &cdma->push_buffer;
 
                         host1x_pushbuffer_pop(pb, job->num_slots);
+
                         if (cdma->event == CDMA_EVENT_PUSH_BUFFER_SPACE)
                                 signal = true;
                 }
@@ -270,11 +279,9 @@ static void update_cdma_locked(struct host1x_cdma *cdma)
 void host1x_cdma_update_sync_queue(struct host1x_cdma *cdma,
                                    struct device *dev)
 {
-        u32 restart_addr;
-        u32 syncpt_incrs;
-        struct host1x_job *job = NULL;
-        u32 syncpt_val;
         struct host1x *host1x = cdma_to_host1x(cdma);
+        u32 restart_addr, syncpt_incrs, syncpt_val;
+        struct host1x_job *job = NULL;
 
         syncpt_val = host1x_syncpt_load(cdma->timeout.syncpt);
 
@@ -378,6 +385,7 @@ int host1x_cdma_init(struct host1x_cdma *cdma)
         err = host1x_pushbuffer_init(&cdma->push_buffer);
         if (err)
                 return err;
+
         return 0;
 }
 
@@ -422,6 +430,7 @@ int host1x_cdma_begin(struct host1x_cdma *cdma, struct host1x_job *job)
                         }
                 }
         }
+
         if (!cdma->running)
                 host1x_hw_cdma_start(host1x, cdma);
 
@@ -452,6 +461,7 @@ void host1x_cdma_push(struct host1x_cdma *cdma, u32 op1, u32 op2)
                 slots_free = host1x_cdma_wait_locked(cdma,
                                                 CDMA_EVENT_PUSH_BUFFER_SPACE);
         }
+
         cdma->slots_free = slots_free - 1;
         cdma->slots_used++;
         host1x_pushbuffer_push(pb, op1, op2);
diff --git a/drivers/gpu/host1x/debug.c b/drivers/gpu/host1x/debug.c
index 7bb86b92ff09..d9330fcc62ad 100644
--- a/drivers/gpu/host1x/debug.c
+++ b/drivers/gpu/host1x/debug.c
@@ -39,6 +39,7 @@ void host1x_debug_output(struct output *o, const char *fmt, ...)
         va_start(args, fmt);
         len = vsnprintf(o->buf, sizeof(o->buf), fmt, args);
         va_end(args);
+
         o->fn(o->ctx, o->buf, len);
 }
 
@@ -48,13 +49,17 @@ static int show_channels(struct host1x_channel *ch, void *data, bool show_fifo)
         struct output *o = data;
 
         mutex_lock(&ch->reflock);
+
         if (ch->refcount) {
                 mutex_lock(&ch->cdma.lock);
+
                 if (show_fifo)
                         host1x_hw_show_channel_fifo(m, ch, o);
+
                 host1x_hw_show_channel_cdma(m, ch, o);
                 mutex_unlock(&ch->cdma.lock);
         }
+
         mutex_unlock(&ch->reflock);
 
         return 0;
@@ -65,6 +70,7 @@ static void show_syncpts(struct host1x *m, struct output *o)
         unsigned int i;
 
         host1x_debug_output(o, "---- syncpts ----\n");
+
         for (i = 0; i < host1x_syncpt_nb_pts(m); i++) {
                 u32 max = host1x_syncpt_read_max(m->syncpt + i);
                 u32 min = host1x_syncpt_load(m->syncpt + i);
@@ -118,7 +124,9 @@ static int host1x_debug_show_all(struct seq_file *s, void *unused)
                 .fn = write_to_seqfile,
                 .ctx = s
         };
+
         show_all(s->private, &o);
+
         return 0;
 }
 
@@ -128,7 +136,9 @@ static int host1x_debug_show(struct seq_file *s, void *unused)
                 .fn = write_to_seqfile,
                 .ctx = s
         };
+
         show_all_no_fifo(s->private, &o);
+
         return 0;
 }
 
@@ -138,10 +148,10 @@ static int host1x_debug_open_all(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations host1x_debug_all_fops = {
-        .open           = host1x_debug_open_all,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
+        .open = host1x_debug_open_all,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
 };
 
 static int host1x_debug_open(struct inode *inode, struct file *file)
@@ -150,10 +160,10 @@ static int host1x_debug_open(struct inode *inode, struct file *file)
 }
 
 static const struct file_operations host1x_debug_fops = {
-        .open           = host1x_debug_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
+        .open = host1x_debug_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
 };
 
 static void host1x_debugfs_init(struct host1x *host1x)
@@ -205,6 +215,7 @@ void host1x_debug_dump(struct host1x *host1x)
         struct output o = {
                 .fn = write_to_printk
         };
+
         show_all(host1x, &o);
 }
 
@@ -213,5 +224,6 @@ void host1x_debug_dump_syncpts(struct host1x *host1x)
         struct output o = {
                 .fn = write_to_printk
         };
+
         show_syncpts(host1x, &o);
 }
diff --git a/drivers/gpu/host1x/dev.c b/drivers/gpu/host1x/dev.c
index 320caf99cff4..a62317af76ad 100644
--- a/drivers/gpu/host1x/dev.c
+++ b/drivers/gpu/host1x/dev.c
@@ -63,13 +63,13 @@ u32 host1x_ch_readl(struct host1x_channel *ch, u32 r)
 }
 
 static const struct host1x_info host1x01_info = {
-        .nb_channels    = 8,
-        .nb_pts         = 32,
-        .nb_mlocks      = 16,
-        .nb_bases       = 8,
-        .init           = host1x01_init,
-        .sync_offset    = 0x3000,
-        .dma_mask       = DMA_BIT_MASK(32),
+        .nb_channels = 8,
+        .nb_pts = 32,
+        .nb_mlocks = 16,
+        .nb_bases = 8,
+        .init = host1x01_init,
+        .sync_offset = 0x3000,
+        .dma_mask = DMA_BIT_MASK(32),
 };
 
 static const struct host1x_info host1x02_info = {
diff --git a/drivers/gpu/host1x/hw/cdma_hw.c b/drivers/gpu/host1x/hw/cdma_hw.c
index e0db00613bca..5c39f1b111f7 100644
--- a/drivers/gpu/host1x/hw/cdma_hw.c
+++ b/drivers/gpu/host1x/hw/cdma_hw.c
@@ -58,6 +58,7 @@ static void cdma_timeout_cpu_incr(struct host1x_cdma *cdma, u32 getptr,
                         &pb->phys, getptr);
                 getptr = (getptr + 8) & (pb->size_bytes - 1);
         }
+
         wmb();
 }
 
@@ -162,12 +163,14 @@ static void cdma_stop(struct host1x_cdma *cdma)
         struct host1x_channel *ch = cdma_to_channel(cdma);
 
         mutex_lock(&cdma->lock);
+
         if (cdma->running) {
                 host1x_cdma_wait_locked(cdma, CDMA_EVENT_SYNC_QUEUE_EMPTY);
                 host1x_ch_writel(ch, HOST1X_CHANNEL_DMACTRL_DMASTOP,
                                  HOST1X_CHANNEL_DMACTRL);
                 cdma->running = false;
         }
+
         mutex_unlock(&cdma->lock);
 }
 
@@ -231,14 +234,11 @@ static void cdma_resume(struct host1x_cdma *cdma, u32 getptr)
  */
 static void cdma_timeout_handler(struct work_struct *work)
 {
+        u32 prev_cmdproc, cmdproc_stop, syncpt_val;
         struct host1x_cdma *cdma;
         struct host1x *host1x;
         struct host1x_channel *ch;
 
-        u32 syncpt_val;
-
-        u32 prev_cmdproc, cmdproc_stop;
-
         cdma = container_of(to_delayed_work(work), struct host1x_cdma,
                             timeout.wq);
         host1x = cdma_to_host1x(cdma);
@@ -278,8 +278,8 @@ static void cdma_timeout_handler(struct work_struct *work)
         }
 
         dev_warn(host1x->dev, "%s: timeout: %u (%s), HW thresh %d, done %d\n",
-                __func__, cdma->timeout.syncpt->id, cdma->timeout.syncpt->name,
-                syncpt_val, cdma->timeout.syncpt_val);
+                 __func__, cdma->timeout.syncpt->id, cdma->timeout.syncpt->name,
+                 syncpt_val, cdma->timeout.syncpt_val);
 
         /* stop HW, resetting channel/module */
         host1x_hw_cdma_freeze(host1x, cdma);
@@ -306,6 +306,7 @@ static void cdma_timeout_destroy(struct host1x_cdma *cdma)
 {
         if (cdma->timeout.initialized)
                 cancel_delayed_work(&cdma->timeout.wq);
+
         cdma->timeout.initialized = false;
 }
 
diff --git a/drivers/gpu/host1x/hw/channel_hw.c b/drivers/gpu/host1x/hw/channel_hw.c
index f359b7ec5e3c..5e8df78b7acd 100644
--- a/drivers/gpu/host1x/hw/channel_hw.c
+++ b/drivers/gpu/host1x/hw/channel_hw.c
@@ -46,6 +46,7 @@ static void trace_write_gather(struct host1x_cdma *cdma, struct host1x_bo *bo,
                  */
                 for (i = 0; i < words; i += TRACE_MAX_LENGTH) {
                         u32 num_words = min(words - i, TRACE_MAX_LENGTH);
+
                         offset += i * sizeof(u32);
 
                         trace_host1x_cdma_push_gather(dev_name(dev), bo,
@@ -66,6 +67,7 @@ static void submit_gathers(struct host1x_job *job)
                 struct host1x_job_gather *g = &job->gathers[i];
                 u32 op1 = host1x_opcode_gather(g->words);
                 u32 op2 = g->base + g->offset;
+
                 trace_write_gather(cdma, g->bo, g->offset, op1 & 0xffff);
                 host1x_cdma_push(cdma, op1, op2);
         }
diff --git a/drivers/gpu/host1x/hw/debug_hw.c b/drivers/gpu/host1x/hw/debug_hw.c
index d2c96dd630ea..7a4a3286e4a7 100644
--- a/drivers/gpu/host1x/hw/debug_hw.c
+++ b/drivers/gpu/host1x/hw/debug_hw.c
@@ -40,8 +40,7 @@ enum {
 
 static unsigned int show_channel_command(struct output *o, u32 val)
 {
-        unsigned mask;
-        unsigned subop;
+        unsigned int mask, subop;
 
         switch (val >> 28) {
         case HOST1X_OPCODE_SETCLASS:
@@ -200,14 +199,13 @@ static void host1x_debug_show_channel_cdma(struct host1x *host,
 
         if (HOST1X_SYNC_CBSTAT_CBCLASS_V(cbstat) == HOST1X_CLASS_HOST1X &&
             HOST1X_SYNC_CBSTAT_CBOFFSET_V(cbstat) ==
-            HOST1X_UCLASS_WAIT_SYNCPT)
+                        HOST1X_UCLASS_WAIT_SYNCPT)
                 host1x_debug_output(o, "waiting on syncpt %d val %d\n",
                                     cbread >> 24, cbread & 0xffffff);
         else if (HOST1X_SYNC_CBSTAT_CBCLASS_V(cbstat) ==
-           HOST1X_CLASS_HOST1X &&
-           HOST1X_SYNC_CBSTAT_CBOFFSET_V(cbstat) ==
-           HOST1X_UCLASS_WAIT_SYNCPT_BASE) {
-
+                                HOST1X_CLASS_HOST1X &&
+                 HOST1X_SYNC_CBSTAT_CBOFFSET_V(cbstat) ==
+                                HOST1X_UCLASS_WAIT_SYNCPT_BASE) {
                 base = (cbread >> 16) & 0xff;
                 baseval =
                         host1x_sync_readl(host, HOST1X_SYNC_SYNCPT_BASE(base));
@@ -293,6 +291,7 @@ static void host1x_debug_show_mlocks(struct host1x *host, struct output *o)
         unsigned int i;
 
         host1x_debug_output(o, "---- mlocks ----\n");
+
         for (i = 0; i < host1x_syncpt_nb_mlocks(host); i++) {
                 u32 owner =
                         host1x_sync_readl(host, HOST1X_SYNC_MLOCK_OWNER(i));
@@ -304,6 +303,7 @@ static void host1x_debug_show_mlocks(struct host1x *host, struct output *o)
                 else
                         host1x_debug_output(o, "%u: unlocked\n", i);
         }
+
         host1x_debug_output(o, "\n");
 }
 
diff --git a/drivers/gpu/host1x/hw/intr_hw.c b/drivers/gpu/host1x/hw/intr_hw.c
index f50c68957c12..dacb8009a605 100644
--- a/drivers/gpu/host1x/hw/intr_hw.c
+++ b/drivers/gpu/host1x/hw/intr_hw.c
@@ -72,8 +72,9 @@ static void _host1x_intr_disable_all_syncpt_intrs(struct host1x *host)
         }
 }
 
-static int _host1x_intr_init_host_sync(struct host1x *host, u32 cpm,
-        void (*syncpt_thresh_work)(struct work_struct *))
+static int
+_host1x_intr_init_host_sync(struct host1x *host, u32 cpm,
+                            void (*syncpt_thresh_work)(struct work_struct *))
 {
         unsigned int i;
         int err;
@@ -137,6 +138,7 @@ static int _host1x_free_syncpt_irq(struct host1x *host)
 
         for (i = 0; i < host->info->nb_pts; i++)
                 cancel_work_sync(&host->syncpt[i].intr.work);
+
         return 0;
 }
 
diff --git a/drivers/gpu/host1x/hw/syncpt_hw.c b/drivers/gpu/host1x/hw/syncpt_hw.c
index 310f24fcd261..c93f74fcce72 100644
--- a/drivers/gpu/host1x/hw/syncpt_hw.c
+++ b/drivers/gpu/host1x/hw/syncpt_hw.c
@@ -88,6 +88,7 @@ static int syncpt_cpu_incr(struct host1x_syncpt *sp)
         if (!host1x_syncpt_client_managed(sp) &&
             host1x_syncpt_idle(sp))
                 return -EINVAL;
+
         host1x_sync_writel(host, BIT_MASK(sp->id),
                            HOST1X_SYNC_SYNCPT_CPU_INCR(reg_offset));
         wmb();
@@ -98,10 +99,10 @@ static int syncpt_cpu_incr(struct host1x_syncpt *sp)
 /* remove a wait pointed to by patch_addr */
 static int syncpt_patch_wait(struct host1x_syncpt *sp, void *patch_addr)
 {
-        u32 override = host1x_class_host_wait_syncpt(
-                HOST1X_SYNCPT_RESERVED, 0);
+        u32 override = host1x_class_host_wait_syncpt(HOST1X_SYNCPT_RESERVED, 0);
 
         *((u32 *)patch_addr) = override;
+
         return 0;
 }
 
diff --git a/drivers/gpu/host1x/job.c b/drivers/gpu/host1x/job.c
index 1bff367f8830..a91b7c4a6110 100644
--- a/drivers/gpu/host1x/job.c
+++ b/drivers/gpu/host1x/job.c
@@ -577,11 +577,12 @@ void host1x_job_unpin(struct host1x_job *job)
                 host1x_bo_unpin(unpin->bo, unpin->sgt);
                 host1x_bo_put(unpin->bo);
         }
+
         job->num_unpins = 0;
 
         if (job->gather_copy_size)
                 dma_free_wc(job->channel->dev, job->gather_copy_size,
-                            job->gather_copy_mapped, job->gather_copy);
+                            job->gather_copy_mapped, job->gather_copy);
 }
 EXPORT_SYMBOL(host1x_job_unpin);
 
diff --git a/drivers/gpu/host1x/syncpt.c b/drivers/gpu/host1x/syncpt.c
index 7c4848f4ce59..73b43c25b04b 100644
--- a/drivers/gpu/host1x/syncpt.c
+++ b/drivers/gpu/host1x/syncpt.c
@@ -114,8 +114,10 @@ void host1x_syncpt_restore(struct host1x *host)
 
         for (i = 0; i < host1x_syncpt_nb_pts(host); i++)
                 host1x_hw_syncpt_restore(host, sp_base + i);
+
         for (i = 0; i < host1x_syncpt_nb_bases(host); i++)
                 host1x_hw_syncpt_restore_wait_base(host, sp_base + i);
+
         wmb();
 }
 
@@ -181,6 +183,7 @@ EXPORT_SYMBOL(host1x_syncpt_incr);
 static bool syncpt_load_min_is_expired(struct host1x_syncpt *sp, u32 thresh)
 {
         host1x_hw_syncpt_load(sp->host, sp);
+
         return host1x_syncpt_is_expired(sp, thresh);
 }
 
@@ -188,7 +191,7 @@ static bool syncpt_load_min_is_expired(struct host1x_syncpt *sp, u32 thresh)
  * Main entrypoint for syncpoint value waits.
  */
 int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout,
-                        u32 *value)
+                       u32 *value)
 {
         DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
         void *ref;
@@ -203,6 +206,7 @@ int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout,
         if (host1x_syncpt_is_expired(sp, thresh)) {
                 if (value)
                         *value = host1x_syncpt_load(sp);
+
                 return 0;
         }
 
@@ -211,6 +215,7 @@ int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout,
         if (host1x_syncpt_is_expired(sp, thresh)) {
                 if (value)
                         *value = val;
+
                 goto done;
         }
 
@@ -241,20 +246,27 @@ int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout,
         /* wait for the syncpoint, or timeout, or signal */
         while (timeout) {
                 long check = min_t(long, SYNCPT_CHECK_PERIOD, timeout);
-                int remain = wait_event_interruptible_timeout(wq,
+                int remain;
+
+                remain = wait_event_interruptible_timeout(wq,
                                 syncpt_load_min_is_expired(sp, thresh),
                                 check);
                 if (remain > 0 || host1x_syncpt_is_expired(sp, thresh)) {
                         if (value)
                                 *value = host1x_syncpt_load(sp);
+
                         err = 0;
+
                         break;
                 }
+
                 if (remain < 0) {
                         err = remain;
                         break;
                 }
+
                 timeout -= check;
+
                 if (timeout && check_count <= MAX_STUCK_CHECK_COUNT) {
                         dev_warn(sp->host->dev,
                                 "%s: syncpoint id %u (%s) stuck waiting %d, timeout=%ld\n",
@@ -262,11 +274,14 @@ int host1x_syncpt_wait(struct host1x_syncpt *sp, u32 thresh, long timeout,
                                  thresh, timeout);
 
                         host1x_debug_dump_syncpts(sp->host);
+
                         if (check_count == MAX_STUCK_CHECK_COUNT)
                                 host1x_debug_dump(sp->host);
+
                         check_count++;
                 }
         }
+
         host1x_intr_put_ref(sp->host, sp->id, ref);
 
 done:
@@ -283,6 +298,7 @@ bool host1x_syncpt_is_expired(struct host1x_syncpt *sp, u32 thresh)
         u32 future_val;
 
         smp_rmb();
+
         current_val = (u32)atomic_read(&sp->min_val);
         future_val = (u32)atomic_read(&sp->max_val);
 
@@ -381,6 +397,7 @@ struct host1x_syncpt *host1x_syncpt_request(struct device *dev,
                                             unsigned long flags)
 {
         struct host1x *host = dev_get_drvdata(dev->parent);
+
         return host1x_syncpt_alloc(host, dev, flags);
 }
 EXPORT_SYMBOL(host1x_syncpt_request);
@@ -415,6 +432,7 @@ void host1x_syncpt_deinit(struct host1x *host)
 u32 host1x_syncpt_read_max(struct host1x_syncpt *sp)
 {
         smp_rmb();
+
         return (u32)atomic_read(&sp->max_val);
 }
 EXPORT_SYMBOL(host1x_syncpt_read_max);
@@ -425,6 +443,7 @@ EXPORT_SYMBOL(host1x_syncpt_read_max);
 u32 host1x_syncpt_read_min(struct host1x_syncpt *sp)
 {
         smp_rmb();
+
         return (u32)atomic_read(&sp->min_val);
 }
 EXPORT_SYMBOL(host1x_syncpt_read_min);
@@ -454,6 +473,7 @@ struct host1x_syncpt *host1x_syncpt_get(struct host1x *host, unsigned int id)
 {
         if (host->info->nb_pts < id)
                 return NULL;
+
         return host->syncpt + id;
 }
 EXPORT_SYMBOL(host1x_syncpt_get);