struct drm_i915_private *dev_priv = dev->dev_private;
        struct i915_address_space *vm = &dev_priv->gtt.base;
        struct i915_vma *vma;
-       size_t total_obj_size, total_gtt_size;
+       u64 total_obj_size, total_gtt_size;
        int count, ret;
 
        ret = mutex_lock_interruptible(&dev->struct_mutex);
        }
        mutex_unlock(&dev->struct_mutex);
 
-       seq_printf(m, "Total %d objects, %zu bytes, %zu GTT size\n",
+       seq_printf(m, "Total %d objects, %llu bytes, %llu GTT size\n",
                   count, total_obj_size, total_gtt_size);
        return 0;
 }
        struct drm_device *dev = node->minor->dev;
        struct drm_i915_private *dev_priv = dev->dev_private;
        struct drm_i915_gem_object *obj;
-       size_t total_obj_size, total_gtt_size;
+       u64 total_obj_size, total_gtt_size;
        LIST_HEAD(stolen);
        int count, ret;
 
        }
        mutex_unlock(&dev->struct_mutex);
 
-       seq_printf(m, "Total %d objects, %zu bytes, %zu GTT size\n",
+       seq_printf(m, "Total %d objects, %llu bytes, %llu GTT size\n",
                   count, total_obj_size, total_gtt_size);
        return 0;
 }
 
 struct file_stats {
        struct drm_i915_file_private *file_priv;
-       int count;
-       size_t total, unbound;
-       size_t global, shared;
-       size_t active, inactive;
+       unsigned long count;
+       u64 total, unbound;
+       u64 global, shared;
+       u64 active, inactive;
 };
 
 static int per_file_stats(int id, void *ptr, void *data)
 
 #define print_file_stats(m, name, stats) do { \
        if (stats.count) \
-               seq_printf(m, "%s: %u objects, %zu bytes (%zu active, %zu inactive, %zu global, %zu shared, %zu unbound)\n", \
+               seq_printf(m, "%s: %lu objects, %llu bytes (%llu active, %llu inactive, %llu global, %llu shared, %llu unbound)\n", \
                           name, \
                           stats.count, \
                           stats.total, \
        struct drm_device *dev = node->minor->dev;
        struct drm_i915_private *dev_priv = dev->dev_private;
        u32 count, mappable_count, purgeable_count;
-       size_t size, mappable_size, purgeable_size;
+       u64 size, mappable_size, purgeable_size;
        struct drm_i915_gem_object *obj;
        struct i915_address_space *vm = &dev_priv->gtt.base;
        struct drm_file *file;
 
        size = count = mappable_size = mappable_count = 0;
        count_objects(&dev_priv->mm.bound_list, global_list);
-       seq_printf(m, "%u [%u] objects, %zu [%zu] bytes in gtt\n",
+       seq_printf(m, "%u [%u] objects, %llu [%llu] bytes in gtt\n",
                   count, mappable_count, size, mappable_size);
 
        size = count = mappable_size = mappable_count = 0;
        count_vmas(&vm->active_list, mm_list);
-       seq_printf(m, "  %u [%u] active objects, %zu [%zu] bytes\n",
+       seq_printf(m, "  %u [%u] active objects, %llu [%llu] bytes\n",
                   count, mappable_count, size, mappable_size);
 
        size = count = mappable_size = mappable_count = 0;
        count_vmas(&vm->inactive_list, mm_list);
-       seq_printf(m, "  %u [%u] inactive objects, %zu [%zu] bytes\n",
+       seq_printf(m, "  %u [%u] inactive objects, %llu [%llu] bytes\n",
                   count, mappable_count, size, mappable_size);
 
        size = count = purgeable_size = purgeable_count = 0;
                if (obj->madv == I915_MADV_DONTNEED)
                        purgeable_size += obj->base.size, ++purgeable_count;
        }
-       seq_printf(m, "%u unbound objects, %zu bytes\n", count, size);
+       seq_printf(m, "%u unbound objects, %llu bytes\n", count, size);
 
        size = count = mappable_size = mappable_count = 0;
        list_for_each_entry(obj, &dev_priv->mm.bound_list, global_list) {
                        ++purgeable_count;
                }
        }
-       seq_printf(m, "%u purgeable objects, %zu bytes\n",
+       seq_printf(m, "%u purgeable objects, %llu bytes\n",
                   purgeable_count, purgeable_size);
-       seq_printf(m, "%u pinned mappable objects, %zu bytes\n",
+       seq_printf(m, "%u pinned mappable objects, %llu bytes\n",
                   mappable_count, mappable_size);
-       seq_printf(m, "%u fault mappable objects, %zu bytes\n",
+       seq_printf(m, "%u fault mappable objects, %llu bytes\n",
                   count, size);
 
-       seq_printf(m, "%zu [%lu] gtt total\n",
+       seq_printf(m, "%llu [%llu] gtt total\n",
                   dev_priv->gtt.base.total,
-                  dev_priv->gtt.mappable_end - dev_priv->gtt.base.start);
+                  (u64)dev_priv->gtt.mappable_end - dev_priv->gtt.base.start);
 
        seq_putc(m, '\n');
        print_batch_pool_stats(m, dev_priv);
        uintptr_t list = (uintptr_t) node->info_ent->data;
        struct drm_i915_private *dev_priv = dev->dev_private;
        struct drm_i915_gem_object *obj;
-       size_t total_obj_size, total_gtt_size;
+       u64 total_obj_size, total_gtt_size;
        int count, ret;
 
        ret = mutex_lock_interruptible(&dev->struct_mutex);
 
        mutex_unlock(&dev->struct_mutex);
 
-       seq_printf(m, "Total %d objects, %zu bytes, %zu GTT size\n",
+       seq_printf(m, "Total %d objects, %llu bytes, %llu GTT size\n",
                   count, total_obj_size, total_gtt_size);
 
        return 0;
 
 void i915_gem_init_global_gtt(struct drm_device *dev)
 {
        struct drm_i915_private *dev_priv = dev->dev_private;
-       unsigned long gtt_size, mappable_size;
+       u64 gtt_size, mappable_size;
 
        gtt_size = dev_priv->gtt.base.total;
        mappable_size = dev_priv->gtt.mappable_end;
 }
 
 static int gen8_gmch_probe(struct drm_device *dev,
-                          size_t *gtt_total,
+                          u64 *gtt_total,
                           size_t *stolen,
                           phys_addr_t *mappable_base,
-                          unsigned long *mappable_end)
+                          u64 *mappable_end)
 {
        struct drm_i915_private *dev_priv = dev->dev_private;
-       unsigned int gtt_size;
+       u64 gtt_size;
        u16 snb_gmch_ctl;
        int ret;
 
 }
 
 static int gen6_gmch_probe(struct drm_device *dev,
-                          size_t *gtt_total,
+                          u64 *gtt_total,
                           size_t *stolen,
                           phys_addr_t *mappable_base,
-                          unsigned long *mappable_end)
+                          u64 *mappable_end)
 {
        struct drm_i915_private *dev_priv = dev->dev_private;
        unsigned int gtt_size;
         * a coarse sanity check.
         */
        if ((*mappable_end < (64<<20) || (*mappable_end > (512<<20)))) {
-               DRM_ERROR("Unknown GMADR size (%lx)\n",
+               DRM_ERROR("Unknown GMADR size (%llx)\n",
                          dev_priv->gtt.mappable_end);
                return -ENXIO;
        }
 }
 
 static int i915_gmch_probe(struct drm_device *dev,
-                          size_t *gtt_total,
+                          u64 *gtt_total,
                           size_t *stolen,
                           phys_addr_t *mappable_base,
-                          unsigned long *mappable_end)
+                          u64 *mappable_end)
 {
        struct drm_i915_private *dev_priv = dev->dev_private;
        int ret;
        gtt->base.dev = dev;
 
        /* GMADR is the PCI mmio aperture into the global GTT. */
-       DRM_INFO("Memory usable by graphics device = %zdM\n",
+       DRM_INFO("Memory usable by graphics device = %lluM\n",
                 gtt->base.total >> 20);
-       DRM_DEBUG_DRIVER("GMADR size = %ldM\n", gtt->mappable_end >> 20);
+       DRM_DEBUG_DRIVER("GMADR size = %lldM\n", gtt->mappable_end >> 20);
        DRM_DEBUG_DRIVER("GTT stolen size = %zdM\n", gtt->stolen_size >> 20);
 #ifdef CONFIG_INTEL_IOMMU
        if (intel_iommu_gfx_mapped)