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);
        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);
 };
 }
 
 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);
 }
 
 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,
 
 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,
 
        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);
                return;
        }
 
-       dev_warn(host1x->dev, "%s: timeout: %d (%s), HW thresh %d, done %d\n",
+       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);
 
 /*
  * 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;
 
 {
        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;
 
        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) {
        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);
 
 }
 
 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)));
 
                                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)
 {
        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;
                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);
                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;
                }
 
  *
  * 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);
 
  * 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);
 
 
                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));
 
 
                        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;
                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);
 
        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;
 
 };
 
 struct host1x_syncpt {
-       int id;
+       unsigned int id;
        atomic_t min_val;
        atomic_t max_val;
        u32 base_val;