struct hrtimer comparecount_timer;
        /* Count timer control KVM register */
-       uint32_t count_ctl;
+       u32 count_ctl;
        /* Count bias from the raw time */
-       uint32_t count_bias;
+       u32 count_bias;
        /* Frequency of timer in Hz */
-       uint32_t count_hz;
+       u32 count_hz;
        /* Dynamic nanosecond bias (multiple of count_period) to avoid overflow */
        s64 count_dyn_bias;
        /* Resume time */
        struct kvm_mips_tlb guest_tlb[KVM_MIPS_GUEST_TLB_SIZE];
 
        /* Cached guest kernel/user ASIDs */
-       uint32_t guest_user_asid[NR_CPUS];
-       uint32_t guest_kernel_asid[NR_CPUS];
+       u32 guest_user_asid[NR_CPUS];
+       u32 guest_kernel_asid[NR_CPUS];
        struct mm_struct guest_kernel_mm, guest_user_mm;
 
        int last_sched_cpu;
        void (*dequeue_io_int)(struct kvm_vcpu *vcpu,
                               struct kvm_mips_interrupt *irq);
        int (*irq_deliver)(struct kvm_vcpu *vcpu, unsigned int priority,
-                          uint32_t cause);
+                          u32 cause);
        int (*irq_clear)(struct kvm_vcpu *vcpu, unsigned int priority,
-                        uint32_t cause);
+                        u32 cause);
        int (*get_one_reg)(struct kvm_vcpu *vcpu,
                           const struct kvm_one_reg *reg, s64 *v);
        int (*set_one_reg)(struct kvm_vcpu *vcpu,
 void kvm_lose_fpu(struct kvm_vcpu *vcpu);
 
 /* TLB handling */
-uint32_t kvm_get_kernel_asid(struct kvm_vcpu *vcpu);
+u32 kvm_get_kernel_asid(struct kvm_vcpu *vcpu);
 
-uint32_t kvm_get_user_asid(struct kvm_vcpu *vcpu);
+u32 kvm_get_user_asid(struct kvm_vcpu *vcpu);
 
-uint32_t kvm_get_commpage_asid (struct kvm_vcpu *vcpu);
+u32 kvm_get_commpage_asid (struct kvm_vcpu *vcpu);
 
 extern int kvm_mips_handle_kseg0_tlb_fault(unsigned long badbaddr,
                                           struct kvm_vcpu *vcpu);
                                                unsigned long *hpa1);
 
 extern enum emulation_result kvm_mips_handle_tlbmiss(unsigned long cause,
-                                                    uint32_t *opc,
+                                                    u32 *opc,
                                                     struct kvm_run *run,
                                                     struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_handle_tlbmod(unsigned long cause,
-                                                   uint32_t *opc,
+                                                   u32 *opc,
                                                    struct kvm_run *run,
                                                    struct kvm_vcpu *vcpu);
 
 extern void kvm_mips_vcpu_put(struct kvm_vcpu *vcpu);
 
 /* Emulation */
-uint32_t kvm_get_inst(uint32_t *opc, struct kvm_vcpu *vcpu);
-enum emulation_result update_pc(struct kvm_vcpu *vcpu, uint32_t cause);
+u32 kvm_get_inst(u32 *opc, struct kvm_vcpu *vcpu);
+enum emulation_result update_pc(struct kvm_vcpu *vcpu, u32 cause);
 
 extern enum emulation_result kvm_mips_emulate_inst(unsigned long cause,
-                                                  uint32_t *opc,
+                                                  u32 *opc,
                                                   struct kvm_run *run,
                                                   struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_syscall(unsigned long cause,
-                                                     uint32_t *opc,
+                                                     u32 *opc,
                                                      struct kvm_run *run,
                                                      struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_tlbmiss_ld(unsigned long cause,
-                                                        uint32_t *opc,
+                                                        u32 *opc,
                                                         struct kvm_run *run,
                                                         struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_tlbinv_ld(unsigned long cause,
-                                                       uint32_t *opc,
+                                                       u32 *opc,
                                                        struct kvm_run *run,
                                                        struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_tlbmiss_st(unsigned long cause,
-                                                        uint32_t *opc,
+                                                        u32 *opc,
                                                         struct kvm_run *run,
                                                         struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_tlbinv_st(unsigned long cause,
-                                                       uint32_t *opc,
+                                                       u32 *opc,
                                                        struct kvm_run *run,
                                                        struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_tlbmod(unsigned long cause,
-                                                    uint32_t *opc,
+                                                    u32 *opc,
                                                     struct kvm_run *run,
                                                     struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_fpu_exc(unsigned long cause,
-                                                     uint32_t *opc,
+                                                     u32 *opc,
                                                      struct kvm_run *run,
                                                      struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_handle_ri(unsigned long cause,
-                                               uint32_t *opc,
+                                               u32 *opc,
                                                struct kvm_run *run,
                                                struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_ri_exc(unsigned long cause,
-                                                    uint32_t *opc,
+                                                    u32 *opc,
                                                     struct kvm_run *run,
                                                     struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_bp_exc(unsigned long cause,
-                                                    uint32_t *opc,
+                                                    u32 *opc,
                                                     struct kvm_run *run,
                                                     struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_trap_exc(unsigned long cause,
-                                                      uint32_t *opc,
+                                                      u32 *opc,
                                                       struct kvm_run *run,
                                                       struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_msafpe_exc(unsigned long cause,
-                                                        uint32_t *opc,
+                                                        u32 *opc,
                                                         struct kvm_run *run,
                                                         struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_fpe_exc(unsigned long cause,
-                                                     uint32_t *opc,
+                                                     u32 *opc,
                                                      struct kvm_run *run,
                                                      struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_emulate_msadis_exc(unsigned long cause,
-                                                        uint32_t *opc,
+                                                        u32 *opc,
                                                         struct kvm_run *run,
                                                         struct kvm_vcpu *vcpu);
 
 extern enum emulation_result kvm_mips_complete_mmio_load(struct kvm_vcpu *vcpu,
                                                         struct kvm_run *run);
 
-uint32_t kvm_mips_read_count(struct kvm_vcpu *vcpu);
-void kvm_mips_write_count(struct kvm_vcpu *vcpu, uint32_t count);
-void kvm_mips_write_compare(struct kvm_vcpu *vcpu, uint32_t compare, bool ack);
+u32 kvm_mips_read_count(struct kvm_vcpu *vcpu);
+void kvm_mips_write_count(struct kvm_vcpu *vcpu, u32 count);
+void kvm_mips_write_compare(struct kvm_vcpu *vcpu, u32 compare, bool ack);
 void kvm_mips_init_count(struct kvm_vcpu *vcpu);
 int kvm_mips_set_count_ctl(struct kvm_vcpu *vcpu, s64 count_ctl);
 int kvm_mips_set_count_resume(struct kvm_vcpu *vcpu, s64 count_resume);
 enum hrtimer_restart kvm_mips_count_timeout(struct kvm_vcpu *vcpu);
 
 enum emulation_result kvm_mips_check_privilege(unsigned long cause,
-                                              uint32_t *opc,
+                                              u32 *opc,
                                               struct kvm_run *run,
                                               struct kvm_vcpu *vcpu);
 
-enum emulation_result kvm_mips_emulate_cache(uint32_t inst,
-                                            uint32_t *opc,
-                                            uint32_t cause,
+enum emulation_result kvm_mips_emulate_cache(u32 inst,
+                                            u32 *opc,
+                                            u32 cause,
                                             struct kvm_run *run,
                                             struct kvm_vcpu *vcpu);
-enum emulation_result kvm_mips_emulate_CP0(uint32_t inst,
-                                          uint32_t *opc,
-                                          uint32_t cause,
+enum emulation_result kvm_mips_emulate_CP0(u32 inst,
+                                          u32 *opc,
+                                          u32 cause,
                                           struct kvm_run *run,
                                           struct kvm_vcpu *vcpu);
-enum emulation_result kvm_mips_emulate_store(uint32_t inst,
-                                            uint32_t cause,
+enum emulation_result kvm_mips_emulate_store(u32 inst,
+                                            u32 cause,
                                             struct kvm_run *run,
                                             struct kvm_vcpu *vcpu);
-enum emulation_result kvm_mips_emulate_load(uint32_t inst,
-                                           uint32_t cause,
+enum emulation_result kvm_mips_emulate_load(u32 inst,
+                                           u32 cause,
                                            struct kvm_run *run,
                                            struct kvm_vcpu *vcpu);
 
 unsigned int kvm_mips_config5_wrmask(struct kvm_vcpu *vcpu);
 
 /* Dynamic binary translation */
-extern int kvm_mips_trans_cache_index(uint32_t inst, uint32_t *opc,
+extern int kvm_mips_trans_cache_index(u32 inst, u32 *opc,
                                      struct kvm_vcpu *vcpu);
-extern int kvm_mips_trans_cache_va(uint32_t inst, uint32_t *opc,
-                                  struct kvm_vcpu *vcpu);
-extern int kvm_mips_trans_mfc0(uint32_t inst, uint32_t *opc,
-                              struct kvm_vcpu *vcpu);
-extern int kvm_mips_trans_mtc0(uint32_t inst, uint32_t *opc,
-                              struct kvm_vcpu *vcpu);
+extern int kvm_mips_trans_cache_va(u32 inst, u32 *opc, struct kvm_vcpu *vcpu);
+extern int kvm_mips_trans_mfc0(u32 inst, u32 *opc, struct kvm_vcpu *vcpu);
+extern int kvm_mips_trans_mtc0(u32 inst, u32 *opc, struct kvm_vcpu *vcpu);
 
 /* Misc */
 extern void kvm_mips_dump_stats(struct kvm_vcpu *vcpu);
 
 #define CLEAR_TEMPLATE  0x00000020
 #define SW_TEMPLATE     0xac000000
 
-int kvm_mips_trans_cache_index(uint32_t inst, uint32_t *opc,
+int kvm_mips_trans_cache_index(u32 inst, u32 *opc,
                               struct kvm_vcpu *vcpu)
 {
        int result = 0;
  * Address based CACHE instructions are transformed into synci(s). A little
  * heavy for just D-cache invalidates, but avoids an expensive trap
  */
-int kvm_mips_trans_cache_va(uint32_t inst, uint32_t *opc,
+int kvm_mips_trans_cache_va(u32 inst, u32 *opc,
                            struct kvm_vcpu *vcpu)
 {
        int result = 0;
        return result;
 }
 
-int kvm_mips_trans_mfc0(uint32_t inst, uint32_t *opc, struct kvm_vcpu *vcpu)
+int kvm_mips_trans_mfc0(u32 inst, u32 *opc, struct kvm_vcpu *vcpu)
 {
        int32_t rt, rd, sel;
        uint32_t mfc0_inst;
        return 0;
 }
 
-int kvm_mips_trans_mtc0(uint32_t inst, uint32_t *opc, struct kvm_vcpu *vcpu)
+int kvm_mips_trans_mtc0(u32 inst, u32 *opc, struct kvm_vcpu *vcpu)
 {
        int32_t rt, rd, sel;
        uint32_t mtc0_inst = SW_TEMPLATE;
 
        return nextpc;
 }
 
-enum emulation_result update_pc(struct kvm_vcpu *vcpu, uint32_t cause)
+enum emulation_result update_pc(struct kvm_vcpu *vcpu, u32 cause)
 {
        unsigned long branch_pc;
        enum emulation_result er = EMULATE_DONE;
  *
  * Assumes !kvm_mips_count_disabled(@vcpu) (guest CP0_Count timer is running).
  */
-static uint32_t kvm_mips_ktime_to_count(struct kvm_vcpu *vcpu, ktime_t now)
+static u32 kvm_mips_ktime_to_count(struct kvm_vcpu *vcpu, ktime_t now)
 {
        s64 now_ns, periods;
        u64 delta;
  *
  * Returns:    The current value of the guest CP0_Count register.
  */
-static uint32_t kvm_mips_read_count_running(struct kvm_vcpu *vcpu, ktime_t now)
+static u32 kvm_mips_read_count_running(struct kvm_vcpu *vcpu, ktime_t now)
 {
        struct mips_coproc *cop0 = vcpu->arch.cop0;
        ktime_t expires, threshold;
  *
  * Returns:    The current guest CP0_Count value.
  */
-uint32_t kvm_mips_read_count(struct kvm_vcpu *vcpu)
+u32 kvm_mips_read_count(struct kvm_vcpu *vcpu)
 {
        struct mips_coproc *cop0 = vcpu->arch.cop0;
 
  *
  * Returns:    The ktime at the point of freeze.
  */
-static ktime_t kvm_mips_freeze_hrtimer(struct kvm_vcpu *vcpu,
-                                      uint32_t *count)
+static ktime_t kvm_mips_freeze_hrtimer(struct kvm_vcpu *vcpu, u32 *count)
 {
        ktime_t now;
 
  * Assumes !kvm_mips_count_disabled(@vcpu) (guest CP0_Count timer is running).
  */
 static void kvm_mips_resume_hrtimer(struct kvm_vcpu *vcpu,
-                                   ktime_t now, uint32_t count)
+                                   ktime_t now, u32 count)
 {
        struct mips_coproc *cop0 = vcpu->arch.cop0;
        uint32_t compare;
  *
  * Sets the CP0_Count value and updates the timer accordingly.
  */
-void kvm_mips_write_count(struct kvm_vcpu *vcpu, uint32_t count)
+void kvm_mips_write_count(struct kvm_vcpu *vcpu, u32 count)
 {
        struct mips_coproc *cop0 = vcpu->arch.cop0;
        ktime_t now;
  * If @ack, atomically acknowledge any pending timer interrupt, otherwise ensure
  * any pending timer interrupt is preserved.
  */
-void kvm_mips_write_compare(struct kvm_vcpu *vcpu, uint32_t compare, bool ack)
+void kvm_mips_write_compare(struct kvm_vcpu *vcpu, u32 compare, bool ack)
 {
        struct mips_coproc *cop0 = vcpu->arch.cop0;
        int dc;
        return mask;
 }
 
-enum emulation_result kvm_mips_emulate_CP0(uint32_t inst, uint32_t *opc,
-                                          uint32_t cause, struct kvm_run *run,
+enum emulation_result kvm_mips_emulate_CP0(u32 inst, u32 *opc, u32 cause,
+                                          struct kvm_run *run,
                                           struct kvm_vcpu *vcpu)
 {
        struct mips_coproc *cop0 = vcpu->arch.cop0;
        return er;
 }
 
-enum emulation_result kvm_mips_emulate_store(uint32_t inst, uint32_t cause,
+enum emulation_result kvm_mips_emulate_store(u32 inst, u32 cause,
                                             struct kvm_run *run,
                                             struct kvm_vcpu *vcpu)
 {
        return er;
 }
 
-enum emulation_result kvm_mips_emulate_load(uint32_t inst, uint32_t cause,
+enum emulation_result kvm_mips_emulate_load(u32 inst, u32 cause,
                                            struct kvm_run *run,
                                            struct kvm_vcpu *vcpu)
 {
        return er;
 }
 
-enum emulation_result kvm_mips_emulate_cache(uint32_t inst, uint32_t *opc,
-                                            uint32_t cause,
+enum emulation_result kvm_mips_emulate_cache(u32 inst, u32 *opc,
+                                            u32 cause,
                                             struct kvm_run *run,
                                             struct kvm_vcpu *vcpu)
 {
        return er;
 }
 
-enum emulation_result kvm_mips_emulate_inst(unsigned long cause, uint32_t *opc,
+enum emulation_result kvm_mips_emulate_inst(unsigned long cause, u32 *opc,
                                            struct kvm_run *run,
                                            struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_syscall(unsigned long cause,
-                                              uint32_t *opc,
+                                              u32 *opc,
                                               struct kvm_run *run,
                                               struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_tlbmiss_ld(unsigned long cause,
-                                                 uint32_t *opc,
+                                                 u32 *opc,
                                                  struct kvm_run *run,
                                                  struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_tlbinv_ld(unsigned long cause,
-                                                uint32_t *opc,
+                                                u32 *opc,
                                                 struct kvm_run *run,
                                                 struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_tlbmiss_st(unsigned long cause,
-                                                 uint32_t *opc,
+                                                 u32 *opc,
                                                  struct kvm_run *run,
                                                  struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_tlbinv_st(unsigned long cause,
-                                                uint32_t *opc,
+                                                u32 *opc,
                                                 struct kvm_run *run,
                                                 struct kvm_vcpu *vcpu)
 {
 }
 
 /* TLBMOD: store into address matching TLB with Dirty bit off */
-enum emulation_result kvm_mips_handle_tlbmod(unsigned long cause, uint32_t *opc,
+enum emulation_result kvm_mips_handle_tlbmod(unsigned long cause, u32 *opc,
                                             struct kvm_run *run,
                                             struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_tlbmod(unsigned long cause,
-                                             uint32_t *opc,
+                                             u32 *opc,
                                              struct kvm_run *run,
                                              struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_fpu_exc(unsigned long cause,
-                                              uint32_t *opc,
+                                              u32 *opc,
                                               struct kvm_run *run,
                                               struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_ri_exc(unsigned long cause,
-                                             uint32_t *opc,
+                                             u32 *opc,
                                              struct kvm_run *run,
                                              struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_bp_exc(unsigned long cause,
-                                             uint32_t *opc,
+                                             u32 *opc,
                                              struct kvm_run *run,
                                              struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_trap_exc(unsigned long cause,
-                                               uint32_t *opc,
+                                               u32 *opc,
                                                struct kvm_run *run,
                                                struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_msafpe_exc(unsigned long cause,
-                                                 uint32_t *opc,
+                                                 u32 *opc,
                                                  struct kvm_run *run,
                                                  struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_fpe_exc(unsigned long cause,
-                                              uint32_t *opc,
+                                              u32 *opc,
                                               struct kvm_run *run,
                                               struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_emulate_msadis_exc(unsigned long cause,
-                                                 uint32_t *opc,
+                                                 u32 *opc,
                                                  struct kvm_run *run,
                                                  struct kvm_vcpu *vcpu)
 {
 #define SYNC   0x0000000f
 #define RDHWR  0x0000003b
 
-enum emulation_result kvm_mips_handle_ri(unsigned long cause, uint32_t *opc,
+enum emulation_result kvm_mips_handle_ri(unsigned long cause, u32 *opc,
                                         struct kvm_run *run,
                                         struct kvm_vcpu *vcpu)
 {
 }
 
 static enum emulation_result kvm_mips_emulate_exc(unsigned long cause,
-                                                 uint32_t *opc,
+                                                 u32 *opc,
                                                  struct kvm_run *run,
                                                  struct kvm_vcpu *vcpu)
 {
 }
 
 enum emulation_result kvm_mips_check_privilege(unsigned long cause,
-                                              uint32_t *opc,
+                                              u32 *opc,
                                               struct kvm_run *run,
                                               struct kvm_vcpu *vcpu)
 {
  *     case we inject the TLB from the Guest TLB into the shadow host TLB
  */
 enum emulation_result kvm_mips_handle_tlbmiss(unsigned long cause,
-                                             uint32_t *opc,
+                                             u32 *opc,
                                              struct kvm_run *run,
                                              struct kvm_vcpu *vcpu)
 {
 
 
 #include "interrupt.h"
 
-void kvm_mips_queue_irq(struct kvm_vcpu *vcpu, uint32_t priority)
+void kvm_mips_queue_irq(struct kvm_vcpu *vcpu, unsigned int priority)
 {
        set_bit(priority, &vcpu->arch.pending_exceptions);
 }
 
-void kvm_mips_dequeue_irq(struct kvm_vcpu *vcpu, uint32_t priority)
+void kvm_mips_dequeue_irq(struct kvm_vcpu *vcpu, unsigned int priority)
 {
        clear_bit(priority, &vcpu->arch.pending_exceptions);
 }
 
 /* Deliver the interrupt of the corresponding priority, if possible. */
 int kvm_mips_irq_deliver_cb(struct kvm_vcpu *vcpu, unsigned int priority,
-                           uint32_t cause)
+                           u32 cause)
 {
        int allowed = 0;
        uint32_t exccode;
 }
 
 int kvm_mips_irq_clear_cb(struct kvm_vcpu *vcpu, unsigned int priority,
-                         uint32_t cause)
+                         u32 cause)
 {
        return 1;
 }
 
-void kvm_mips_deliver_interrupts(struct kvm_vcpu *vcpu, uint32_t cause)
+void kvm_mips_deliver_interrupts(struct kvm_vcpu *vcpu, u32 cause)
 {
        unsigned long *pending = &vcpu->arch.pending_exceptions;
        unsigned long *pending_clr = &vcpu->arch.pending_exceptions_clr;
 
 #define KVM_MIPS_IRQ_DELIVER_ALL_AT_ONCE (0)
 #define KVM_MIPS_IRQ_CLEAR_ALL_AT_ONCE   (0)
 
-void kvm_mips_queue_irq(struct kvm_vcpu *vcpu, uint32_t priority);
-void kvm_mips_dequeue_irq(struct kvm_vcpu *vcpu, uint32_t priority);
+void kvm_mips_queue_irq(struct kvm_vcpu *vcpu, unsigned int priority);
+void kvm_mips_dequeue_irq(struct kvm_vcpu *vcpu, unsigned int priority);
 int kvm_mips_pending_timer(struct kvm_vcpu *vcpu);
 
 void kvm_mips_queue_timer_int_cb(struct kvm_vcpu *vcpu);
 void kvm_mips_dequeue_io_int_cb(struct kvm_vcpu *vcpu,
                                struct kvm_mips_interrupt *irq);
 int kvm_mips_irq_deliver_cb(struct kvm_vcpu *vcpu, unsigned int priority,
-                           uint32_t cause);
+                           u32 cause);
 int kvm_mips_irq_clear_cb(struct kvm_vcpu *vcpu, unsigned int priority,
-                         uint32_t cause);
-void kvm_mips_deliver_interrupts(struct kvm_vcpu *vcpu, uint32_t cause);
+                         u32 cause);
+void kvm_mips_deliver_interrupts(struct kvm_vcpu *vcpu, u32 cause);
 
 bool (*kvm_mips_is_error_pfn)(kvm_pfn_t pfn);
 EXPORT_SYMBOL_GPL(kvm_mips_is_error_pfn);
 
-uint32_t kvm_mips_get_kernel_asid(struct kvm_vcpu *vcpu)
+u32 kvm_mips_get_kernel_asid(struct kvm_vcpu *vcpu)
 {
        int cpu = smp_processor_id();
 
                        cpu_asid_mask(&cpu_data[cpu]);
 }
 
-uint32_t kvm_mips_get_user_asid(struct kvm_vcpu *vcpu)
+u32 kvm_mips_get_user_asid(struct kvm_vcpu *vcpu)
 {
        int cpu = smp_processor_id();
 
                        cpu_asid_mask(&cpu_data[cpu]);
 }
 
-inline uint32_t kvm_mips_get_commpage_asid(struct kvm_vcpu *vcpu)
+inline u32 kvm_mips_get_commpage_asid(struct kvm_vcpu *vcpu)
 {
        return vcpu->kvm->arch.commpage_tlb;
 }
 }
 EXPORT_SYMBOL_GPL(kvm_arch_vcpu_put);
 
-uint32_t kvm_get_inst(uint32_t *opc, struct kvm_vcpu *vcpu)
+u32 kvm_get_inst(u32 *opc, struct kvm_vcpu *vcpu)
 {
        struct mips_coproc *cop0 = vcpu->arch.cop0;
        unsigned long paddr, flags, vpn2, asid;