#define R_VECS (1 << VECS)
 #define R_ALL (R_RCS | R_VCS | R_BCS | R_VECS)
        /* rings that support this cmd: BLT/RCS/VCS/VECS */
-       uint16_t rings;
+       u16 rings;
 
        /* devices that support this cmd: SNB/IVB/HSW/... */
-       uint16_t devices;
+       u16 devices;
 
        /* which DWords are address that need fix up.
         * bit 0 means a 32-bit non address operand in command
         * No matter the address length, each address only takes
         * one bit in the bitmap.
         */
-       uint16_t addr_bitmap;
+       u16 addr_bitmap;
 
        /* flag == F_LEN_CONST : command length
         * flag == F_LEN_VAR : length bias bits
         * Note: length is in DWord
         */
-       uint8_t len;
+       u8 len;
 
        parser_cmd_handler handler;
 };
 {
        unsigned long gma = 0;
        const struct cmd_info *info;
-       uint32_t cmd_len = 0;
+       u32 cmd_len = 0;
        bool bb_end = false;
        struct intel_vgpu *vgpu = s->vgpu;
        u32 cmd;
                                        I915_GTT_PAGE_SIZE)))
                return -EINVAL;
 
-       ring_tail = wa_ctx->indirect_ctx.size + 3 * sizeof(uint32_t);
+       ring_tail = wa_ctx->indirect_ctx.size + 3 * sizeof(u32);
        ring_size = round_up(wa_ctx->indirect_ctx.size + CACHELINE_BYTES,
                        PAGE_SIZE);
        gma_head = wa_ctx->indirect_ctx.guest_gma;
 
 static int combine_wa_ctx(struct intel_shadow_wa_ctx *wa_ctx)
 {
-       uint32_t per_ctx_start[CACHELINE_DWORDS] = {0};
+       u32 per_ctx_start[CACHELINE_DWORDS] = {0};
        unsigned char *bb_start_sva;
 
        if (!wa_ctx->per_ctx.valid)
 
        __intel_vgpu_release(vgpu);
 }
 
-static uint64_t intel_vgpu_get_bar_addr(struct intel_vgpu *vgpu, int bar)
+static u64 intel_vgpu_get_bar_addr(struct intel_vgpu *vgpu, int bar)
 {
        u32 start_lo, start_hi;
        u32 mem_type;
        return ((u64)start_hi << 32) | start_lo;
 }
 
-static int intel_vgpu_bar_rw(struct intel_vgpu *vgpu, int bar, uint64_t off,
+static int intel_vgpu_bar_rw(struct intel_vgpu *vgpu, int bar, u64 off,
                             void *buf, unsigned int count, bool is_write)
 {
-       uint64_t bar_start = intel_vgpu_get_bar_addr(vgpu, bar);
+       u64 bar_start = intel_vgpu_get_bar_addr(vgpu, bar);
        int ret;
 
        if (is_write)
        return ret;
 }
 
-static inline bool intel_vgpu_in_aperture(struct intel_vgpu *vgpu, uint64_t off)
+static inline bool intel_vgpu_in_aperture(struct intel_vgpu *vgpu, u64 off)
 {
        return off >= vgpu_aperture_offset(vgpu) &&
               off < vgpu_aperture_offset(vgpu) + vgpu_aperture_sz(vgpu);
 }
 
-static int intel_vgpu_aperture_rw(struct intel_vgpu *vgpu, uint64_t off,
+static int intel_vgpu_aperture_rw(struct intel_vgpu *vgpu, u64 off,
                void *buf, unsigned long count, bool is_write)
 {
        void *aperture_va;
 {
        struct intel_vgpu *vgpu = mdev_get_drvdata(mdev);
        unsigned int index = VFIO_PCI_OFFSET_TO_INDEX(*ppos);
-       uint64_t pos = *ppos & VFIO_PCI_OFFSET_MASK;
+       u64 pos = *ppos & VFIO_PCI_OFFSET_MASK;
        int ret = -EINVAL;
 
 
 
 static int intel_vgpu_set_intx_mask(struct intel_vgpu *vgpu,
                        unsigned int index, unsigned int start,
-                       unsigned int count, uint32_t flags,
+                       unsigned int count, u32 flags,
                        void *data)
 {
        return 0;
 
 static int intel_vgpu_set_intx_unmask(struct intel_vgpu *vgpu,
                        unsigned int index, unsigned int start,
-                       unsigned int count, uint32_t flags, void *data)
+                       unsigned int count, u32 flags, void *data)
 {
        return 0;
 }
 
 static int intel_vgpu_set_intx_trigger(struct intel_vgpu *vgpu,
                unsigned int index, unsigned int start, unsigned int count,
-               uint32_t flags, void *data)
+               u32 flags, void *data)
 {
        return 0;
 }
 
 static int intel_vgpu_set_msi_trigger(struct intel_vgpu *vgpu,
                unsigned int index, unsigned int start, unsigned int count,
-               uint32_t flags, void *data)
+               u32 flags, void *data)
 {
        struct eventfd_ctx *trigger;
 
        return 0;
 }
 
-static int intel_vgpu_set_irqs(struct intel_vgpu *vgpu, uint32_t flags,
+static int intel_vgpu_set_irqs(struct intel_vgpu *vgpu, u32 flags,
                unsigned int index, unsigned int start, unsigned int count,
                void *data)
 {
        int (*func)(struct intel_vgpu *vgpu, unsigned int index,
-                       unsigned int start, unsigned int count, uint32_t flags,
+                       unsigned int start, unsigned int count, u32 flags,
                        void *data) = NULL;
 
        switch (index) {
 
        (reg >= gvt->device_info.gtt_start_offset \
         && reg < gvt->device_info.gtt_start_offset + gvt_ggtt_sz(gvt))
 
-static void failsafe_emulate_mmio_rw(struct intel_vgpu *vgpu, uint64_t pa,
+static void failsafe_emulate_mmio_rw(struct intel_vgpu *vgpu, u64 pa,
                void *p_data, unsigned int bytes, bool read)
 {
        struct intel_gvt *gvt = NULL;
  * Returns:
  * Zero on success, negative error code if failed
  */
-int intel_vgpu_emulate_mmio_read(struct intel_vgpu *vgpu, uint64_t pa,
+int intel_vgpu_emulate_mmio_read(struct intel_vgpu *vgpu, u64 pa,
                void *p_data, unsigned int bytes)
 {
        struct intel_gvt *gvt = vgpu->gvt;
  * Returns:
  * Zero on success, negative error code if failed
  */
-int intel_vgpu_emulate_mmio_write(struct intel_vgpu *vgpu, uint64_t pa,
+int intel_vgpu_emulate_mmio_write(struct intel_vgpu *vgpu, u64 pa,
                void *p_data, unsigned int bytes)
 {
        struct intel_gvt *gvt = vgpu->gvt;