15 files changed, 205 insertions, 132 deletions

diff --git a/drivers/gpu/host1x/cdma.c b/drivers/gpu/host1x/cdma.c
index a18db4d5347c..c5d82a8a2ec9 100644
--- a/drivers/gpu/host1x/cdma.c
+++ b/drivers/gpu/host1x/cdma.c
@@ -96,12 +96,12 @@ fail:
  */
 static void host1x_pushbuffer_push(struct push_buffer *pb, u32 op1, u32 op2)
 {
-        u32 pos = pb->pos;
-        u32 *p = (u32 *)((void *)pb->mapped + pos);
-        WARN_ON(pos == pb->fence);
+        u32 *p = (u32 *)((void *)pb->mapped + pb->pos);
+
+        WARN_ON(pb->pos == pb->fence);
         *(p++) = op1;
         *(p++) = op2;
-        pb->pos = (pos + 8) & (pb->size_bytes - 1);
+        pb->pos = (pb->pos + 8) & (pb->size_bytes - 1);
 }
 
 /*
@@ -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;
                 }
 
@@ -247,7 +255,9 @@ static void update_cdma_locked(struct host1x_cdma *cdma)
                 /* Pop push buffer slots */
                 if (job->num_slots) {
                         struct push_buffer *pb = &cdma->push_buffer;
+
                         host1x_pushbuffer_pop(pb, job->num_slots);
+
                         if (cdma->event == CDMA_EVENT_PUSH_BUFFER_SPACE)
                                 signal = true;
                 }
@@ -269,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);
 
@@ -342,9 +350,11 @@ void host1x_cdma_update_sync_queue(struct host1x_cdma *cdma,
                 syncpt_val += syncpt_incrs;
         }
 
-        /* The following sumbits from the same client may be dependent on the
+        /*
+         * The following sumbits from the same client may be dependent on the
          * failed submit and therefore they may fail. Force a small timeout
-         * to make the queue cleanup faster */
+         * to make the queue cleanup faster.
+         */
 
         list_for_each_entry_from(job, &cdma->sync_queue, list)
                 if (job->client == cdma->timeout.client)
@@ -375,6 +385,7 @@ int host1x_cdma_init(struct host1x_cdma *cdma)
         err = host1x_pushbuffer_init(&cdma->push_buffer);
         if (err)
                 return err;
+
         return 0;
 }
 
@@ -410,6 +421,7 @@ int host1x_cdma_begin(struct host1x_cdma *cdma, struct host1x_job *job)
                 /* init state on first submit with timeout value */
                 if (!cdma->timeout.initialized) {
                         int err;
+
                         err = host1x_hw_cdma_timeout_init(host1x, cdma,
                                                           job->syncpt_id);
                         if (err) {
@@ -418,6 +430,7 @@ int host1x_cdma_begin(struct host1x_cdma *cdma, struct host1x_job *job)
                         }
                 }
         }
+
         if (!cdma->running)
                 host1x_hw_cdma_start(host1x, cdma);
 
@@ -448,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/channel.c b/drivers/gpu/host1x/channel.c
index b4ae3affb987..8f437d924c10 100644
--- a/drivers/gpu/host1x/channel.c
+++ b/drivers/gpu/host1x/channel.c
@@ -83,9 +83,10 @@ EXPORT_SYMBOL(host1x_channel_put);
 struct host1x_channel *host1x_channel_request(struct device *dev)
 {
         struct host1x *host = dev_get_drvdata(dev->parent);
-        int max_channels = host->info->nb_channels;
+        unsigned int max_channels = host->info->nb_channels;
         struct host1x_channel *channel = NULL;
-        int index, err;
+        unsigned long index;
+        int err;
 
         mutex_lock(&host->chlist_mutex);
 
diff --git a/drivers/gpu/host1x/debug.c b/drivers/gpu/host1x/debug.c
index ee3d12b51c50..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;
@@ -62,22 +67,27 @@ static int show_channels(struct host1x_channel *ch, void *data, bool show_fifo)
 
 static void show_syncpts(struct host1x *m, struct output *o)
 {
-        int i;
+        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);
+
                 if (!min && !max)
                         continue;
-                host1x_debug_output(o, "id %d (%s) min %d max %d\n",
+
+                host1x_debug_output(o, "id %u (%s) min %d max %d\n",
                                     i, m->syncpt[i].name, min, max);
         }
 
         for (i = 0; i < host1x_syncpt_nb_bases(m); i++) {
                 u32 base_val;
+
                 base_val = host1x_syncpt_load_wait_base(m->syncpt + i);
                 if (base_val)
-                        host1x_debug_output(o, "waitbase id %d val %d\n", i,
+                        host1x_debug_output(o, "waitbase id %u val %d\n", i,
                                             base_val);
         }
 
@@ -114,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;
 }
 
@@ -124,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;
 }
 
@@ -134,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)
@@ -146,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)
@@ -201,6 +215,7 @@ void host1x_debug_dump(struct host1x *host1x)
         struct output o = {
                 .fn = write_to_printk
         };
+
         show_all(host1x, &o);
 }
 
@@ -209,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 ff348690df94..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 = {
@@ -102,7 +102,7 @@ static const struct host1x_info host1x05_info = {
         .dma_mask = DMA_BIT_MASK(34),
 };
 
-static struct of_device_id host1x_of_match[] = {
+static const struct of_device_id host1x_of_match[] = {
         { .compatible = "nvidia,tegra210-host1x", .data = &host1x05_info, },
         { .compatible = "nvidia,tegra124-host1x", .data = &host1x04_info, },
         { .compatible = "nvidia,tegra114-host1x", .data = &host1x02_info, },
diff --git a/drivers/gpu/host1x/dev.h b/drivers/gpu/host1x/dev.h
index dace124994bb..5220510f39da 100644
--- a/drivers/gpu/host1x/dev.h
+++ b/drivers/gpu/host1x/dev.h
@@ -45,7 +45,7 @@ struct host1x_cdma_ops {
         void (*start)(struct host1x_cdma *cdma);
         void (*stop)(struct host1x_cdma *cdma);
         void (*flush)(struct  host1x_cdma *cdma);
-        int (*timeout_init)(struct host1x_cdma *cdma, u32 syncpt_id);
+        int (*timeout_init)(struct host1x_cdma *cdma, unsigned int syncpt);
         void (*timeout_destroy)(struct host1x_cdma *cdma);
         void (*freeze)(struct host1x_cdma *cdma);
         void (*resume)(struct host1x_cdma *cdma, u32 getptr);
@@ -82,21 +82,21 @@ struct host1x_intr_ops {
         int (*init_host_sync)(struct host1x *host, u32 cpm,
                 void (*syncpt_thresh_work)(struct work_struct *work));
         void (*set_syncpt_threshold)(
-                struct host1x *host, u32 id, u32 thresh);
-        void (*enable_syncpt_intr)(struct host1x *host, u32 id);
-        void (*disable_syncpt_intr)(struct host1x *host, u32 id);
+                struct host1x *host, unsigned int id, u32 thresh);
+        void (*enable_syncpt_intr)(struct host1x *host, unsigned int id);
+        void (*disable_syncpt_intr)(struct host1x *host, unsigned int id);
         void (*disable_all_syncpt_intrs)(struct host1x *host);
         int (*free_syncpt_irq)(struct host1x *host);
 };
 
 struct host1x_info {
-        int     nb_channels;            /* host1x: num channels supported */
-        int     nb_pts;                 /* host1x: num syncpoints supported */
-        int     nb_bases;               /* host1x: num syncpoints supported */
-        int     nb_mlocks;              /* host1x: number of mlocks */
-        int     (*init)(struct host1x *); /* initialize per SoC ops */
-        int     sync_offset;
-        u64     dma_mask;               /* mask of addressable memory */
+        unsigned int nb_channels; /* host1x: number of channels supported */
+        unsigned int nb_pts; /* host1x: number of syncpoints supported */
+        unsigned int nb_bases; /* host1x: number of syncpoint bases supported */
+        unsigned int nb_mlocks; /* host1x: number of mlocks supported */
+        int (*init)(struct host1x *host1x); /* initialize per SoC ops */
+        unsigned int sync_offset; /* offset of syncpoint registers */
+        u64 dma_mask; /* mask of addressable memory */
 };
 
 struct host1x {
@@ -109,7 +109,6 @@ struct host1x {
         struct clk *clk;
 
         struct mutex intr_mutex;
-        struct workqueue_struct *intr_wq;
         int intr_syncpt_irq;
 
         const struct host1x_syncpt_ops *syncpt_op;
@@ -183,19 +182,20 @@ static inline int host1x_hw_intr_init_host_sync(struct host1x *host, u32 cpm,
 }
 
 static inline void host1x_hw_intr_set_syncpt_threshold(struct host1x *host,
-                                                       u32 id, u32 thresh)
+                                                       unsigned int id,
+                                                       u32 thresh)
 {
         host->intr_op->set_syncpt_threshold(host, id, thresh);
 }
 
 static inline void host1x_hw_intr_enable_syncpt_intr(struct host1x *host,
-                                                     u32 id)
+                                                     unsigned int id)
 {
         host->intr_op->enable_syncpt_intr(host, id);
 }
 
 static inline void host1x_hw_intr_disable_syncpt_intr(struct host1x *host,
-                                                      u32 id)
+                                                      unsigned int id)
 {
         host->intr_op->disable_syncpt_intr(host, id);
 }
@@ -212,9 +212,9 @@ static inline int host1x_hw_intr_free_syncpt_irq(struct host1x *host)
 
 static inline int host1x_hw_channel_init(struct host1x *host,
                                          struct host1x_channel *channel,
-                                         int chid)
+                                         unsigned int id)
 {
-        return host->channel_op->init(channel, host, chid);
+        return host->channel_op->init(channel, host, id);
 }
 
 static inline int host1x_hw_channel_submit(struct host1x *host,
@@ -243,9 +243,9 @@ static inline void host1x_hw_cdma_flush(struct host1x *host,
 
 static inline int host1x_hw_cdma_timeout_init(struct host1x *host,
                                               struct host1x_cdma *cdma,
-                                              u32 syncpt_id)
+                                              unsigned int syncpt)
 {
-        return host->cdma_op->timeout_init(cdma, syncpt_id);
+        return host->cdma_op->timeout_init(cdma, syncpt);
 }
 
 static inline void host1x_hw_cdma_timeout_destroy(struct host1x *host,
diff --git a/drivers/gpu/host1x/hw/cdma_hw.c b/drivers/gpu/host1x/hw/cdma_hw.c
index 305ea8f3382d..659c1bbfeeba 100644
--- a/drivers/gpu/host1x/hw/cdma_hw.c
+++ b/drivers/gpu/host1x/hw/cdma_hw.c
@@ -41,7 +41,7 @@ static void cdma_timeout_cpu_incr(struct host1x_cdma *cdma, u32 getptr,
 {
         struct host1x *host1x = cdma_to_host1x(cdma);
         struct push_buffer *pb = &cdma->push_buffer;
-        u32 i;
+        unsigned int i;
 
         for (i = 0; i < syncpt_incrs; i++)
                 host1x_syncpt_incr(cdma->timeout.syncpt);
@@ -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);
 }
 
@@ -213,11 +216,11 @@ static void cdma_resume(struct host1x_cdma *cdma, u32 getptr)
         u32 cmdproc_stop;
 
         dev_dbg(host1x->dev,
-                "resuming channel (id %d, DMAGET restart = 0x%x)\n",
+                "resuming channel (id %u, DMAGET restart = 0x%x)\n",
                 ch->id, getptr);
 
         cmdproc_stop = host1x_sync_readl(host1x, HOST1X_SYNC_CMDPROC_STOP);
-        cmdproc_stop &= ~(BIT(ch->id));
+        cmdproc_stop &= ~BIT(ch->id);
         host1x_sync_writel(host1x, cmdproc_stop, HOST1X_SYNC_CMDPROC_STOP);
 
         cdma->torndown = false;
@@ -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);
@@ -277,9 +277,9 @@ static void cdma_timeout_handler(struct work_struct *work)
                 return;
         }
 
-        dev_warn(host1x->dev, "%s: timeout: %d (%s), HW thresh %d, done %d\n",
-                __func__, cdma->timeout.syncpt->id, cdma->timeout.syncpt->name,
-                syncpt_val, cdma->timeout.syncpt_val);
+        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);
 
         /* stop HW, resetting channel/module */
         host1x_hw_cdma_freeze(host1x, cdma);
@@ -291,7 +291,7 @@ static void cdma_timeout_handler(struct work_struct *work)
 /*
  * Init timeout resources
  */
-static int cdma_timeout_init(struct host1x_cdma *cdma, u32 syncpt_id)
+static int cdma_timeout_init(struct host1x_cdma *cdma, unsigned int syncpt)
 {
         INIT_DELAYED_WORK(&cdma->timeout.wq, cdma_timeout_handler);
         cdma->timeout.initialized = true;
@@ -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 946c332c3906..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);
         }
@@ -75,7 +77,8 @@ static inline void synchronize_syncpt_base(struct host1x_job *job)
 {
         struct host1x *host = dev_get_drvdata(job->channel->dev->parent);
         struct host1x_syncpt *sp = host->syncpt + job->syncpt_id;
-        u32 id, value;
+        unsigned int id;
+        u32 value;
 
         value = host1x_syncpt_read_max(sp);
         id = sp->base->id;
diff --git a/drivers/gpu/host1x/hw/debug_hw.c b/drivers/gpu/host1x/hw/debug_hw.c
index cc3f1825c735..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:
@@ -51,12 +50,11 @@ static unsigned int show_channel_command(struct output *o, u32 val)
                                             val >> 6 & 0x3ff,
                                             val >> 16 & 0xfff, mask);
                         return hweight8(mask);
-                } else {
-                        host1x_debug_output(o, "SETCL(class=%03x)\n",
-                                            val >> 6 & 0x3ff);
-                        return 0;
                 }
 
+                host1x_debug_output(o, "SETCL(class=%03x)\n", val >> 6 & 0x3ff);
+                return 0;
+
         case HOST1X_OPCODE_INCR:
                 host1x_debug_output(o, "INCR(offset=%03x, [",
                                     val >> 16 & 0xfff);
@@ -143,7 +141,8 @@ static void show_channel_gathers(struct output *o, struct host1x_cdma *cdma)
         struct host1x_job *job;
 
         list_for_each_entry(job, &cdma->sync_queue, list) {
-                int i;
+                unsigned int i;
+
                 host1x_debug_output(o, "\n%p: JOB, syncpt_id=%d, syncpt_val=%d, first_get=%08x, timeout=%d num_slots=%d, num_handles=%d\n",
                                     job, job->syncpt_id, job->syncpt_end,
                                     job->first_get, job->timeout,
@@ -190,7 +189,7 @@ static void host1x_debug_show_channel_cdma(struct host1x *host,
         cbread = host1x_sync_readl(host, HOST1X_SYNC_CBREAD(ch->id));
         cbstat = host1x_sync_readl(host, HOST1X_SYNC_CBSTAT(ch->id));
 
-        host1x_debug_output(o, "%d-%s: ", ch->id, dev_name(ch->dev));
+        host1x_debug_output(o, "%u-%s: ", ch->id, dev_name(ch->dev));
 
         if (HOST1X_CHANNEL_DMACTRL_DMASTOP_V(dmactrl) ||
             !ch->cdma.push_buffer.mapped) {
@@ -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));
@@ -236,7 +234,7 @@ static void host1x_debug_show_channel_fifo(struct host1x *host,
         u32 val, rd_ptr, wr_ptr, start, end;
         unsigned int data_count = 0;
 
-        host1x_debug_output(o, "%d: fifo:\n", ch->id);
+        host1x_debug_output(o, "%u: fifo:\n", ch->id);
 
         val = host1x_ch_readl(ch, HOST1X_CHANNEL_FIFOSTAT);
         host1x_debug_output(o, "FIFOSTAT %08x\n", val);
@@ -290,20 +288,22 @@ static void host1x_debug_show_channel_fifo(struct host1x *host,
 
 static void host1x_debug_show_mlocks(struct host1x *host, struct output *o)
 {
-        int i;
+        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));
                 if (HOST1X_SYNC_MLOCK_OWNER_CH_OWNS_V(owner))
-                        host1x_debug_output(o, "%d: locked by channel %d\n",
+                        host1x_debug_output(o, "%u: locked by channel %u\n",
                                 i, HOST1X_SYNC_MLOCK_OWNER_CHID_V(owner));
                 else if (HOST1X_SYNC_MLOCK_OWNER_CPU_OWNS_V(owner))
-                        host1x_debug_output(o, "%d: locked by cpu\n", i);
+                        host1x_debug_output(o, "%u: locked by cpu\n", i);
                 else
-                        host1x_debug_output(o, "%d: unlocked\n", i);
+                        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 e1e31e9e67cd..dacb8009a605 100644
--- a/drivers/gpu/host1x/hw/intr_hw.c
+++ b/drivers/gpu/host1x/hw/intr_hw.c
@@ -38,14 +38,14 @@ static void host1x_intr_syncpt_handle(struct host1x_syncpt *syncpt)
         host1x_sync_writel(host, BIT_MASK(id),
                 HOST1X_SYNC_SYNCPT_THRESH_CPU0_INT_STATUS(BIT_WORD(id)));
 
-        queue_work(host->intr_wq, &syncpt->intr.work);
+        schedule_work(&syncpt->intr.work);
 }
 
 static irqreturn_t syncpt_thresh_isr(int irq, void *dev_id)
 {
         struct host1x *host = dev_id;
         unsigned long reg;
-        int i, id;
+        unsigned int i, id;
 
         for (i = 0; i < DIV_ROUND_UP(host->info->nb_pts, 32); i++) {
                 reg = host1x_sync_readl(host,
@@ -62,7 +62,7 @@ static irqreturn_t syncpt_thresh_isr(int irq, void *dev_id)
 
 static void _host1x_intr_disable_all_syncpt_intrs(struct host1x *host)
 {
-        u32 i;
+        unsigned int i;
 
         for (i = 0; i < DIV_ROUND_UP(host->info->nb_pts, 32); ++i) {
                 host1x_sync_writel(host, 0xffffffffu,
@@ -72,10 +72,12 @@ 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 *))
 {
-        int i, err;
+        unsigned int i;
+        int err;
 
         host1x_hw_intr_disable_all_syncpt_intrs(host);
 
@@ -106,18 +108,21 @@ static int _host1x_intr_init_host_sync(struct host1x *host, u32 cpm,
 }
 
 static void _host1x_intr_set_syncpt_threshold(struct host1x *host,
-        u32 id, u32 thresh)
+                                              unsigned int id,
+                                              u32 thresh)
 {
         host1x_sync_writel(host, thresh, HOST1X_SYNC_SYNCPT_INT_THRESH(id));
 }
 
-static void _host1x_intr_enable_syncpt_intr(struct host1x *host, u32 id)
+static void _host1x_intr_enable_syncpt_intr(struct host1x *host,
+                                            unsigned int id)
 {
         host1x_sync_writel(host, BIT_MASK(id),
                 HOST1X_SYNC_SYNCPT_THRESH_INT_ENABLE_CPU0(BIT_WORD(id)));
 }
 
-static void _host1x_intr_disable_syncpt_intr(struct host1x *host, u32 id)
+static void _host1x_intr_disable_syncpt_intr(struct host1x *host,
+                                             unsigned int id)
 {
         host1x_sync_writel(host, BIT_MASK(id),
                 HOST1X_SYNC_SYNCPT_THRESH_INT_DISABLE(BIT_WORD(id)));
@@ -127,8 +132,13 @@ static void _host1x_intr_disable_syncpt_intr(struct host1x *host, u32 id)
 
 static int _host1x_free_syncpt_irq(struct host1x *host)
 {
+        unsigned int i;
+
         devm_free_irq(host->dev, host->intr_syncpt_irq, host);
-        flush_workqueue(host->intr_wq);
+
+        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 56e85395ac24..c93f74fcce72 100644
--- a/drivers/gpu/host1x/hw/syncpt_hw.c
+++ b/drivers/gpu/host1x/hw/syncpt_hw.c
@@ -26,8 +26,9 @@
  */
 static void syncpt_restore(struct host1x_syncpt *sp)
 {
+        u32 min = host1x_syncpt_read_min(sp);
         struct host1x *host = sp->host;
-        int min = host1x_syncpt_read_min(sp);
+
         host1x_sync_writel(host, min, HOST1X_SYNC_SYNCPT(sp->id));
 }
 
@@ -37,6 +38,7 @@ static void syncpt_restore(struct host1x_syncpt *sp)
 static void syncpt_restore_wait_base(struct host1x_syncpt *sp)
 {
         struct host1x *host = sp->host;
+
         host1x_sync_writel(host, sp->base_val,
                            HOST1X_SYNC_SYNCPT_BASE(sp->id));
 }
@@ -47,6 +49,7 @@ static void syncpt_restore_wait_base(struct host1x_syncpt *sp)
 static void syncpt_read_wait_base(struct host1x_syncpt *sp)
 {
         struct host1x *host = sp->host;
+
         sp->base_val =
                 host1x_sync_readl(host, HOST1X_SYNC_SYNCPT_BASE(sp->id));
 }
@@ -85,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();
@@ -95,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/intr.c b/drivers/gpu/host1x/intr.c
index 2491bf82e30c..8b4fad0ab35d 100644
--- a/drivers/gpu/host1x/intr.c
+++ b/drivers/gpu/host1x/intr.c
@@ -122,18 +122,20 @@ static void action_submit_complete(struct host1x_waitlist *waiter)
 static void action_wakeup(struct host1x_waitlist *waiter)
 {
         wait_queue_head_t *wq = waiter->data;
+
         wake_up(wq);
 }
 
 static void action_wakeup_interruptible(struct host1x_waitlist *waiter)
 {
         wait_queue_head_t *wq = waiter->data;
+
         wake_up_interruptible(wq);
 }
 
 typedef void (*action_handler)(struct host1x_waitlist *waiter);
 
-static action_handler action_handlers[HOST1X_INTR_ACTION_COUNT] = {
+static const action_handler action_handlers[HOST1X_INTR_ACTION_COUNT] = {
         action_submit_complete,
         action_wakeup,
         action_wakeup_interruptible,
@@ -209,7 +211,7 @@ static void syncpt_thresh_work(struct work_struct *work)
                                 host1x_syncpt_load(host->syncpt + id));
 }
 
-int host1x_intr_add_action(struct host1x *host, u32 id, u32 thresh,
+int host1x_intr_add_action(struct host1x *host, unsigned int id, u32 thresh,
                            enum host1x_intr_action action, void *data,
                            struct host1x_waitlist *waiter, void **ref)
 {
@@ -254,7 +256,7 @@ int host1x_intr_add_action(struct host1x *host, u32 id, u32 thresh,
         return 0;
 }
 
-void host1x_intr_put_ref(struct host1x *host, u32 id, void *ref)
+void host1x_intr_put_ref(struct host1x *host, unsigned int id, void *ref)
 {
         struct host1x_waitlist *waiter = ref;
         struct host1x_syncpt *syncpt;
@@ -277,9 +279,6 @@ int host1x_intr_init(struct host1x *host, unsigned int irq_sync)
 
         mutex_init(&host->intr_mutex);
         host->intr_syncpt_irq = irq_sync;
-        host->intr_wq = create_workqueue("host_syncpt");
-        if (!host->intr_wq)
-                return -ENOMEM;
 
         for (id = 0; id < nb_pts; ++id) {
                 struct host1x_syncpt *syncpt = host->syncpt + id;
@@ -288,7 +287,7 @@ int host1x_intr_init(struct host1x *host, unsigned int irq_sync)
                 INIT_LIST_HEAD(&syncpt->intr.wait_head);
                 snprintf(syncpt->intr.thresh_irq_name,
                          sizeof(syncpt->intr.thresh_irq_name),
-                         "host1x_sp_%02d", id);
+                         "host1x_sp_%02u", id);
         }
 
         host1x_intr_start(host);
@@ -299,7 +298,6 @@ int host1x_intr_init(struct host1x *host, unsigned int irq_sync)
 void host1x_intr_deinit(struct host1x *host)
 {
         host1x_intr_stop(host);
-        destroy_workqueue(host->intr_wq);
 }
 
 void host1x_intr_start(struct host1x *host)
@@ -342,7 +340,7 @@ void host1x_intr_stop(struct host1x *host)
                 if (!list_empty(&syncpt[id].intr.wait_head)) {
                         /* output diagnostics */
                         mutex_unlock(&host->intr_mutex);
-                        pr_warn("%s cannot stop syncpt intr id=%d\n",
+                        pr_warn("%s cannot stop syncpt intr id=%u\n",
                                 __func__, id);
                         return;
                 }
diff --git a/drivers/gpu/host1x/intr.h b/drivers/gpu/host1x/intr.h
index 2b8adf016a05..1370c2bb75b8 100644
--- a/drivers/gpu/host1x/intr.h
+++ b/drivers/gpu/host1x/intr.h
@@ -75,7 +75,7 @@ struct host1x_waitlist {
  *
  * This is a non-blocking api.
  */
-int host1x_intr_add_action(struct host1x *host, u32 id, u32 thresh,
+int host1x_intr_add_action(struct host1x *host, unsigned int id, u32 thresh,
         enum host1x_intr_action action, void *data,
         struct host1x_waitlist *waiter, void **ref);
 
@@ -84,7 +84,7 @@ int host1x_intr_add_action(struct host1x *host, u32 id, u32 thresh,
  * You must call this if you passed non-NULL as ref.
  * @ref the ref returned from host1x_intr_add_action()
  */
-void host1x_intr_put_ref(struct host1x *host, u32 id, void *ref);
+void host1x_intr_put_ref(struct host1x *host, unsigned int id, void *ref);
 
 /* Initialize host1x sync point interrupt */
 int host1x_intr_init(struct host1x *host, unsigned int irq_sync);
diff --git a/drivers/gpu/host1x/job.c b/drivers/gpu/host1x/job.c
index b4515d544039..a91b7c4a6110 100644
--- a/drivers/gpu/host1x/job.c
+++ b/drivers/gpu/host1x/job.c
@@ -161,7 +161,7 @@ static int do_waitchks(struct host1x_job *job, struct host1x *host,
 
                 if (host1x_syncpt_is_expired(sp, wait->thresh)) {
                         dev_dbg(host->dev,
-                                "drop WAIT id %d (%s) thresh 0x%x, min 0x%x\n",
+                                "drop WAIT id %u (%s) thresh 0x%x, min 0x%x\n",
                                 wait->syncpt_id, sp->name, wait->thresh,
                                 host1x_syncpt_read_min(sp));
 
@@ -464,6 +464,7 @@ static inline int copy_gathers(struct host1x_job *job, struct device *dev)
 
         for (i = 0; i < job->num_gathers; i++) {
                 struct host1x_job_gather *g = &job->gathers[i];
+
                 size += g->words * sizeof(u32);
         }
 
@@ -514,6 +515,7 @@ int host1x_job_pin(struct host1x_job *job, struct device *dev)
         bitmap_zero(waitchk_mask, host1x_syncpt_nb_pts(host));
         for (i = 0; i < job->num_waitchk; i++) {
                 u32 syncpt_id = job->waitchk[i].syncpt_id;
+
                 if (syncpt_id < host1x_syncpt_nb_pts(host))
                         set_bit(syncpt_id, waitchk_mask);
         }
@@ -571,14 +573,16 @@ void host1x_job_unpin(struct host1x_job *job)
 
         for (i = 0; i < job->num_unpins; i++) {
                 struct host1x_job_unpin_data *unpin = &job->unpins[i];
+
                 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 6b7fdc1e2ed0..95589328ad52 100644
--- a/drivers/gpu/host1x/syncpt.c
+++ b/drivers/gpu/host1x/syncpt.c
@@ -73,7 +73,7 @@ static struct host1x_syncpt *host1x_syncpt_alloc(struct host1x *host,
                         return NULL;
         }
 
-        name = kasprintf(GFP_KERNEL, "%02d-%s", sp->id,
+        name = kasprintf(GFP_KERNEL, "%02u-%s", sp->id,
                         dev ? dev_name(dev) : NULL);
         if (!name)
                 return NULL;
@@ -110,12 +110,14 @@ EXPORT_SYMBOL(host1x_syncpt_incr_max);
 void host1x_syncpt_restore(struct host1x *host)
 {
         struct host1x_syncpt *sp_base = host->syncpt;
-        u32 i;
+        unsigned int i;
 
         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();
 }
 
@@ -126,7 +128,7 @@ void host1x_syncpt_restore(struct host1x *host)
 void host1x_syncpt_save(struct host1x *host)
 {
         struct host1x_syncpt *sp_base = host->syncpt;
-        u32 i;
+        unsigned int i;
 
         for (i = 0; i < host1x_syncpt_nb_pts(host); i++) {
                 if (host1x_syncpt_client_managed(sp_base + i))
@@ -146,6 +148,7 @@ void host1x_syncpt_save(struct host1x *host)
 u32 host1x_syncpt_load(struct host1x_syncpt *sp)
 {
         u32 val;
+
         val = host1x_hw_syncpt_load(sp->host, sp);
         trace_host1x_syncpt_load_min(sp->id, val);
 
@@ -157,10 +160,9 @@ u32 host1x_syncpt_load(struct host1x_syncpt *sp)
  */
 u32 host1x_syncpt_load_wait_base(struct host1x_syncpt *sp)
 {
-        u32 val;
         host1x_hw_syncpt_load_wait_base(sp->host, sp);
-        val = sp->base_val;
-        return val;
+
+        return sp->base_val;
 }
 
 /*
@@ -179,6 +181,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);
 }
 
@@ -186,7 +189,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;
@@ -201,6 +204,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;
         }
 
@@ -209,6 +213,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;
         }
 
@@ -239,32 +244,42 @@ 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 %d (%s) stuck waiting %d, timeout=%ld\n",
+                                "%s: syncpoint id %u (%s) stuck waiting %d, timeout=%ld\n",
                                  current->comm, sp->id, sp->name,
                                  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:
@@ -279,7 +294,9 @@ bool host1x_syncpt_is_expired(struct host1x_syncpt *sp, u32 thresh)
 {
         u32 current_val;
         u32 future_val;
+
         smp_rmb();
+
         current_val = (u32)atomic_read(&sp->min_val);
         future_val = (u32)atomic_read(&sp->max_val);
 
@@ -341,14 +358,14 @@ int host1x_syncpt_init(struct host1x *host)
 {
         struct host1x_syncpt_base *bases;
         struct host1x_syncpt *syncpt;
-        int i;
+        unsigned int i;
 
-        syncpt = devm_kzalloc(host->dev, sizeof(*syncpt) * host->info->nb_pts,
+        syncpt = devm_kcalloc(host->dev, host->info->nb_pts, sizeof(*syncpt),
                               GFP_KERNEL);
         if (!syncpt)
                 return -ENOMEM;
 
-        bases = devm_kzalloc(host->dev, sizeof(*bases) * host->info->nb_bases,
+        bases = devm_kcalloc(host->dev, host->info->nb_bases, sizeof(*bases),
                              GFP_KERNEL);
         if (!bases)
                 return -ENOMEM;
@@ -378,6 +395,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);
@@ -398,8 +416,9 @@ EXPORT_SYMBOL(host1x_syncpt_free);
 
 void host1x_syncpt_deinit(struct host1x *host)
 {
-        int i;
         struct host1x_syncpt *sp = host->syncpt;
+        unsigned int i;
+
         for (i = 0; i < host->info->nb_pts; i++, sp++)
                 kfree(sp->name);
 }
@@ -407,10 +426,11 @@ void host1x_syncpt_deinit(struct host1x *host)
 /*
  * Read max. It indicates how many operations there are in queue, either in
  * channel or in a software thread.
- * */
+ */
 u32 host1x_syncpt_read_max(struct host1x_syncpt *sp)
 {
         smp_rmb();
+
         return (u32)atomic_read(&sp->max_val);
 }
 EXPORT_SYMBOL(host1x_syncpt_read_max);
@@ -421,6 +441,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);
@@ -431,25 +452,26 @@ u32 host1x_syncpt_read(struct host1x_syncpt *sp)
 }
 EXPORT_SYMBOL(host1x_syncpt_read);
 
-int host1x_syncpt_nb_pts(struct host1x *host)
+unsigned int host1x_syncpt_nb_pts(struct host1x *host)
 {
         return host->info->nb_pts;
 }
 
-int host1x_syncpt_nb_bases(struct host1x *host)
+unsigned int host1x_syncpt_nb_bases(struct host1x *host)
 {
         return host->info->nb_bases;
 }
 
-int host1x_syncpt_nb_mlocks(struct host1x *host)
+unsigned int host1x_syncpt_nb_mlocks(struct host1x *host)
 {
         return host->info->nb_mlocks;
 }
 
-struct host1x_syncpt *host1x_syncpt_get(struct host1x *host, u32 id)
+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);
diff --git a/drivers/gpu/host1x/syncpt.h b/drivers/gpu/host1x/syncpt.h
index 9056465ecd3f..f719205105ac 100644
--- a/drivers/gpu/host1x/syncpt.h
+++ b/drivers/gpu/host1x/syncpt.h
@@ -37,7 +37,7 @@ struct host1x_syncpt_base {
 };
 
 struct host1x_syncpt {
-        int id;
+        unsigned int id;
         atomic_t min_val;
         atomic_t max_val;
         u32 base_val;
@@ -58,13 +58,13 @@ int host1x_syncpt_init(struct host1x *host);
 void host1x_syncpt_deinit(struct host1x *host);
 
 /* Return number of sync point supported. */
-int host1x_syncpt_nb_pts(struct host1x *host);
+unsigned int host1x_syncpt_nb_pts(struct host1x *host);
 
 /* Return number of wait bases supported. */
-int host1x_syncpt_nb_bases(struct host1x *host);
+unsigned int host1x_syncpt_nb_bases(struct host1x *host);
 
 /* Return number of mlocks supported. */
-int host1x_syncpt_nb_mlocks(struct host1x *host);
+unsigned int host1x_syncpt_nb_mlocks(struct host1x *host);
 
 /*
  * Check sync point sanity. If max is larger than min, there have too many