Try to make buffer object / fence object ioctl args 64-bit safe.

Introduce tile members for future tiled buffer support.
Allow user-space to explicitly define a fence-class.
Remove the implicit fence-class mechanism.
64-bit wide buffer object flag member.

10 files changed, 173 insertions, 97 deletions

diff --git a/libdrm/xf86drm.c b/libdrm/xf86drm.c
index 63b9354f..4f12bd0b 100644
--- a/libdrm/xf86drm.c
+++ b/libdrm/xf86drm.c
@@ -2611,13 +2611,16 @@ static void drmBOCopyReply(struct drm_bo_info_rep *rep,
     buf->fenceFlags = rep->fence_flags;
     buf->replyFlags = rep->rep_flags;
     buf->pageAlignment = rep->page_alignment;
+    buf->tileInfo = rep->tile_info;
+    buf->hwTileStride = rep->hw_tile_stride;
+    buf->desiredTileStride = rep->desired_tile_stride;
 }
-    
-    
 
-int drmBOCreate(int fd, unsigned long start, unsigned long size, 
-		unsigned pageAlignment, void *user_buffer, drm_bo_type_t type, 
-		unsigned mask,
+
+
+int drmBOCreate(int fd, unsigned long start, unsigned long size,
+		unsigned pageAlignment, void *user_buffer, drm_bo_type_t type,
+		drm_u64_t mask,
 		unsigned hint, drmBO *buf)
 {
     struct drm_bo_create_arg arg;
@@ -2798,8 +2801,9 @@ int drmBOUnmap(int fd, drmBO *buf)
     }
     return 0;
 }
-    
-int drmBOValidate(int fd, drmBO *buf, unsigned flags, unsigned mask, 
+
+int drmBOValidate(int fd, drmBO *buf,
+		  drm_u64_t flags, drm_u64_t mask,
 		  unsigned hint)
 {
     struct drm_bo_op_arg arg;
@@ -2809,9 +2813,10 @@ int drmBOValidate(int fd, drmBO *buf, unsigned flags, unsigned mask,
 
     memset(&arg, 0, sizeof(arg));
     req->bo_req.handle = buf->handle;
-    req->bo_req.mask = flags;
+    req->bo_req.flags = flags;
+    req->bo_req.mask = mask;
     req->bo_req.hint = hint;
-    req->arg_handle = mask; /* Encode mask in the arg_handle field :/ */
+    req->bo_req.fence_class = 0; /* Backwards compatibility. */
     req->op = drm_bo_validate;
 
     do{
@@ -2839,7 +2844,7 @@ int drmBOFence(int fd, drmBO *buf, unsigned flags, unsigned fenceHandle)
 
     memset(&arg, 0, sizeof(arg));
     req->bo_req.handle = buf->handle;
-    req->bo_req.mask = flags;
+    req->bo_req.flags = flags;
     req->arg_handle = fenceHandle;
     req->op = drm_bo_fence;
 
@@ -2999,12 +3004,13 @@ int drmBOValidateList(int fd, drmBOList *list)
       prevNext = &arg->next;
       req->bo_req.handle = node->buf->handle;
       req->op = drm_bo_validate;
-      req->bo_req.mask = node->arg0;
+      req->bo_req.flags = node->arg0;
       req->bo_req.hint = 0;
-      req->arg_handle = node->arg1;
+      req->bo_req.mask = node->arg1;
+      req->bo_req.fence_class = 0; /* Backwards compat. */
   }
-  
-  if (!first) 
+
+  if (!first)
       return 0;
 
   do{
@@ -3101,6 +3107,9 @@ int drmMMInit(int fd, unsigned long pOffset, unsigned long pSize,
     
     memset(&arg, 0, sizeof(arg));
 
+    arg.magic = DRM_BO_INIT_MAGIC;
+    arg.major = DRM_BO_INIT_MAJOR;
+    arg.minor = DRM_BO_INIT_MINOR;
     arg.p_offset = pOffset;
     arg.p_size = pSize;
     arg.mem_type = memType;
diff --git a/libdrm/xf86mm.h b/libdrm/xf86mm.h
index 0b284cc0..68cd7cdd 100644
--- a/libdrm/xf86mm.h
+++ b/libdrm/xf86mm.h
@@ -106,8 +106,8 @@ typedef struct _drmBO{
     drm_bo_type_t type;
     unsigned handle;
     drm_u64_t mapHandle;
-    unsigned flags;
-    unsigned mask;
+    drm_u64_t flags;
+    drm_u64_t mask;
     unsigned mapFlags;
     unsigned long size;
     unsigned long offset;
@@ -115,6 +115,9 @@ typedef struct _drmBO{
     unsigned replyFlags;
     unsigned fenceFlags;
     unsigned pageAlignment;
+    unsigned tileInfo;
+    unsigned hwTileStride;
+    unsigned desiredTileStride;
     void *virtual;
     void *mapVirtual;
     int mapCount;
@@ -172,8 +175,8 @@ extern int drmBOCreateList(int numTarget, drmBOList *list);
  */
 
 extern int drmBOCreate(int fd, unsigned long start, unsigned long size,
-		       unsigned pageAlignment,void *user_buffer, 
-		       drm_bo_type_t type, unsigned mask,
+		       unsigned pageAlignment,void *user_buffer,
+		       drm_bo_type_t type, drm_u64_t mask,
 		       unsigned hint, drmBO *buf);
 extern int drmBODestroy(int fd, drmBO *buf);
 extern int drmBOReference(int fd, unsigned handle, drmBO *buf);
@@ -181,14 +184,14 @@ extern int drmBOUnReference(int fd, drmBO *buf);
 extern int drmBOMap(int fd, drmBO *buf, unsigned mapFlags, unsigned mapHint,
 		    void **address);
 extern int drmBOUnmap(int fd, drmBO *buf);
-extern int drmBOValidate(int fd, drmBO *buf, unsigned flags, unsigned mask, 
-			 unsigned hint);
+extern int drmBOValidate(int fd, drmBO *buf, drm_u64_t flags,
+			 drm_u64_t mask, unsigned hint);
+
 extern int drmBOFence(int fd, drmBO *buf, unsigned flags, unsigned fenceHandle);
 extern int drmBOInfo(int fd, drmBO *buf);
 extern int drmBOBusy(int fd, drmBO *buf, int *busy);
 
-
-extern int drmAddValidateItem(drmBOList *list, drmBO *buf, unsigned flags, 
+extern int drmAddValidateItem(drmBOList *list, drmBO *buf, unsigned flags,
 		       unsigned mask,
 		       int *newItem);
 extern int drmBOValidateList(int fd, drmBOList *list);
diff --git a/linux-core/drm_bo.c b/linux-core/drm_bo.c
index be5fd6a8..b6a31943 100644
--- a/linux-core/drm_bo.c
+++ b/linux-core/drm_bo.c
@@ -195,8 +195,8 @@ static int drm_bo_handle_move_mem(drm_buffer_object_t * bo,
 	if ((bo->mem.mem_type == DRM_BO_MEM_LOCAL) && bo->ttm == NULL) {
 
 		drm_bo_mem_reg_t *old_mem = &bo->mem;
-		uint32_t save_flags = old_mem->flags;
-		uint32_t save_mask = old_mem->mask;
+		uint64_t save_flags = old_mem->flags;
+		uint64_t save_mask = old_mem->mask;
 
 		*old_mem = *mem;
 		mem->mm_node = NULL;
@@ -871,7 +871,7 @@ int drm_bo_mem_space(drm_buffer_object_t * bo,
 EXPORT_SYMBOL(drm_bo_mem_space);
 
 static int drm_bo_new_mask(drm_buffer_object_t * bo,
-			   uint32_t new_mask, uint32_t hint)
+			   uint64_t new_mask, uint32_t hint)
 {
 	uint32_t new_props;
 
@@ -1343,7 +1343,8 @@ static int drm_bo_check_fake(drm_device_t * dev, drm_bo_mem_reg_t * mem)
 		return 0;
 	}
 
-	DRM_ERROR("Illegal fake buffer flags 0x%08x\n", mem->mask);
+	DRM_ERROR("Illegal fake buffer flags 0x%016llx\n",
+		  (unsigned long long) mem->mask);
 	return -EINVAL;
 }
 
@@ -1352,22 +1353,45 @@ static int drm_bo_check_fake(drm_device_t * dev, drm_bo_mem_reg_t * mem)
  */
 
 static int drm_buffer_object_validate(drm_buffer_object_t * bo,
+				      uint32_t fence_class,
 				      int move_unfenced, int no_wait)
 {
 	drm_device_t *dev = bo->dev;
 	drm_buffer_manager_t *bm = &dev->bm;
 	drm_bo_driver_t *driver = dev->driver->bo_driver;
+	uint32_t ftype;
 	int ret;
 
-	DRM_DEBUG("New flags 0x%08x, Old flags 0x%08x\n", bo->mem.mask,
-		  bo->mem.flags);
-	ret =
-	    driver->fence_type(bo, &bo->fence_class, &bo->fence_type);
+	DRM_DEBUG("New flags 0x%016llx, Old flags 0x%016llx\n",
+		  (unsigned long long) bo->mem.mask,
+		  (unsigned long long) bo->mem.flags);
+
+	ret = driver->fence_type(bo, &ftype);
+
 	if (ret) {
 		DRM_ERROR("Driver did not support given buffer permissions\n");
 		return ret;
 	}
 
+	/*
+	 * We're switching command submission mechanism,
+	 * or cannot simply rely on the hardware serializing for us.
+	 *
+	 * Wait for buffer idle.
+	 */
+
+	if ((fence_class != bo->fence_class) ||
+	    ((ftype ^ bo->fence_type) & bo->fence_type)) {
+
+		ret = drm_bo_wait(bo, 0, 0, no_wait);
+
+		if (ret)
+			return ret;
+
+	}
+	
+	bo->fence_class = fence_class;
+	bo->fence_type = ftype;
 	ret = drm_bo_wait_unmapped(bo, no_wait);
 	if (ret)
 		return ret;
@@ -1457,8 +1481,10 @@ static int drm_buffer_object_validate(drm_buffer_object_t * bo,
 	return 0;
 }
 
-static int drm_bo_handle_validate(drm_file_t * priv, uint32_t handle,
-				  uint32_t flags, uint32_t mask, uint32_t hint,
+static int drm_bo_handle_validate(drm_file_t * priv,
+				  uint32_t handle,
+				  uint32_t fence_class,
+				  uint64_t flags, uint64_t mask, uint32_t hint,
 				  struct drm_bo_info_rep *rep)
 {
 	drm_buffer_object_t *bo;
@@ -1482,7 +1508,8 @@ static int drm_bo_handle_validate(drm_file_t * priv, uint32_t handle,
 		goto out;
 
 	ret =
-	    drm_buffer_object_validate(bo, !(hint & DRM_BO_HINT_DONT_FENCE),
+	    drm_buffer_object_validate(bo, fence_class,
+				       !(hint & DRM_BO_HINT_DONT_FENCE),
 				       no_wait);
 	drm_bo_fill_rep_arg(bo, rep);
 
@@ -1544,7 +1571,7 @@ static int drm_bo_handle_wait(drm_file_t *priv, uint32_t handle,
 int drm_buffer_object_create(drm_device_t *dev,
 			     unsigned long size,
 			     drm_bo_type_t type,
-			     uint32_t mask,
+			     uint64_t mask,
 			     uint32_t hint,
 			     uint32_t page_alignment,
 			     unsigned long buffer_start,
@@ -1596,8 +1623,8 @@ int drm_buffer_object_create(drm_device_t *dev,
 		bo->buffer_start = buffer_start;
 	}
 	bo->priv_flags = 0;
-	bo->mem.flags = 0;
-	bo->mem.mask = 0;
+	bo->mem.flags = 0ULL;
+	bo->mem.mask = 0ULL;
 	atomic_inc(&bm->count);
 	ret = drm_bo_new_mask(bo, mask, hint);
 
@@ -1611,7 +1638,7 @@ int drm_buffer_object_create(drm_device_t *dev,
 		if (ret)
 			goto out_err;
 	}
-	ret = drm_buffer_object_validate(bo, 0, hint & DRM_BO_HINT_DONT_BLOCK);
+	ret = drm_buffer_object_validate(bo, 0, 0, hint & DRM_BO_HINT_DONT_BLOCK);
 	if (ret)
 		goto out_err;
 
@@ -1682,8 +1709,9 @@ int drm_bo_op_ioctl(DRM_IOCTL_ARGS)
 			if (ret)
 				break;
 			ret = drm_bo_handle_validate(priv, req->bo_req.handle,
+						     req->bo_req.fence_class,
+						     req->bo_req.flags,
 						     req->bo_req.mask,
-						     req->arg_handle,
 						     req->bo_req.hint,
 						     &rep);
 			break;
@@ -2305,6 +2333,25 @@ int drm_mm_init_ioctl(DRM_IOCTL_ARGS)
 
 	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 	ret = -EINVAL;
+	if (arg.magic != DRM_BO_INIT_MAGIC) {
+		DRM_ERROR("You are using an old libdrm that is not compatible with\n"
+			  "\tthe kernel DRM module. Please upgrade your libdrm.\n");
+		return -EINVAL;
+	}
+	if (arg.major != DRM_BO_INIT_MAJOR) {
+		DRM_ERROR("libdrm and kernel DRM buffer object interface major\n"
+			  "\tversion don't match. Got %d, expected %d,\n",
+			  arg.major, DRM_BO_INIT_MAJOR);
+		return -EINVAL;
+	}
+	if (arg.minor > DRM_BO_INIT_MINOR) {
+		DRM_ERROR("libdrm expects a newer DRM buffer object interface.\n"
+			  "\tlibdrm buffer object interface version is %d.%d.\n"
+			  "\tkernel DRM buffer object interface version is %d.%d\n",
+			  arg.major, arg.minor, DRM_BO_INIT_MAJOR, DRM_BO_INIT_MINOR);
+		return -EINVAL;
+	}
+
 	mutex_lock(&dev->bm.init_mutex);
 	mutex_lock(&dev->struct_mutex);
 	if (!bm->initialized) {
diff --git a/linux-core/drm_compat.c b/linux-core/drm_compat.c
index 867cee85..d47b92e5 100644
--- a/linux-core/drm_compat.c
+++ b/linux-core/drm_compat.c
@@ -184,7 +184,7 @@ static int drm_pte_is_clear(struct vm_area_struct *vma,
 	spin_unlock(&mm->page_table_lock);
 	return ret;
 }
-#if 0
+
 static int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
 		  unsigned long pfn)
 {
@@ -195,9 +195,9 @@ static int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
 	ret = io_remap_pfn_range(vma, addr, pfn, PAGE_SIZE, vma->vm_page_prot);
 	return ret;
 }
-#endif
 
-static struct page *drm_bo_vm_fault(struct vm_area_struct *vma, 
+
+static struct page *drm_bo_vm_fault(struct vm_area_struct *vma,
 				    struct fault_data *data)
 {
 	unsigned long address = data->address;
diff --git a/linux-core/drm_objects.h b/linux-core/drm_objects.h
index 61059a05..b40320aa 100644
--- a/linux-core/drm_objects.h
+++ b/linux-core/drm_objects.h
@@ -321,8 +321,8 @@ typedef struct drm_bo_mem_reg {
 	unsigned long num_pages;
 	uint32_t page_alignment;
 	uint32_t mem_type;
-	uint32_t flags;
-	uint32_t mask;
+	uint64_t flags;
+	uint64_t mask;
 } drm_bo_mem_reg_t;
 
 typedef struct drm_buffer_object {
@@ -423,8 +423,8 @@ typedef struct drm_bo_driver {
 	uint32_t num_mem_busy_prio;
 	drm_ttm_backend_t *(*create_ttm_backend_entry)
 	 (struct drm_device * dev);
-	int (*fence_type) (struct drm_buffer_object *bo, uint32_t * class, uint32_t * type);
-	int (*invalidate_caches) (struct drm_device * dev, uint32_t flags);
+	int (*fence_type) (struct drm_buffer_object *bo, uint32_t * type);
+	int (*invalidate_caches) (struct drm_device * dev, uint64_t flags);
 	int (*init_mem_type) (struct drm_device * dev, uint32_t type,
 			      drm_mem_type_manager_t * man);
 	 uint32_t(*evict_mask) (struct drm_buffer_object *bo);
diff --git a/linux-core/i915_buffer.c b/linux-core/i915_buffer.c
index 8589f467..2850fb94 100644
--- a/linux-core/i915_buffer.c
+++ b/linux-core/i915_buffer.c
@@ -38,9 +38,8 @@ drm_ttm_backend_t *i915_create_ttm_backend_entry(drm_device_t * dev)
 	return drm_agp_init_ttm(dev);
 }
 
-int i915_fence_types(drm_buffer_object_t *bo, uint32_t * class, uint32_t * type)
+int i915_fence_types(drm_buffer_object_t *bo, uint32_t * type)
 {
-	*class = 0;
 	if (bo->mem.flags & (DRM_BO_FLAG_READ | DRM_BO_FLAG_WRITE))
 		*type = 3;
 	else
@@ -48,7 +47,7 @@ int i915_fence_types(drm_buffer_object_t *bo, uint32_t * class, uint32_t * type)
 	return 0;
 }
 
-int i915_invalidate_caches(drm_device_t * dev, uint32_t flags)
+int i915_invalidate_caches(drm_device_t * dev, uint64_t flags)
 {
 	/*
 	 * FIXME: Only emit once per batchbuffer submission.
diff --git a/linux-core/via_buffer.c b/linux-core/via_buffer.c
index ebc8c371..86883998 100644
--- a/linux-core/via_buffer.c
+++ b/linux-core/via_buffer.c
@@ -37,14 +37,13 @@ drm_ttm_backend_t *via_create_ttm_backend_entry(drm_device_t * dev)
 	return drm_agp_init_ttm(dev);
 }
 
-int via_fence_types(drm_buffer_object_t *bo, uint32_t * class, uint32_t * type)
+int via_fence_types(drm_buffer_object_t *bo, uint32_t * type)
 {
-	*class = 0;
 	*type = 3;
 	return 0;
 }
 
-int via_invalidate_caches(drm_device_t * dev, uint32_t flags)
+int via_invalidate_caches(drm_device_t * dev, uint64_t flags)
 {
 	/*
 	 * FIXME: Invalidate texture caches here.
diff --git a/shared-core/drm.h b/shared-core/drm.h
index ae308be6..bc2e718c 100644
--- a/shared-core/drm.h
+++ b/shared-core/drm.h
@@ -671,12 +671,13 @@ typedef struct drm_set_version {
 #define DRM_FENCE_TYPE_EXE                 0x00000001
 
 typedef struct drm_fence_arg {
-	unsigned handle;
-	int class;
-	unsigned type;
-	unsigned flags;
-	unsigned signaled;
-	unsigned expand_pad[4]; /*Future expansion */
+	unsigned int handle;
+	unsigned int class;
+	unsigned int type;
+	unsigned int flags;
+	unsigned int signaled;
+	unsigned int pad_64;
+	drm_u64_t expand_pad[3]; /*Future expansion */
 } drm_fence_arg_t;
 
 /* Buffer permissions, referring to how the GPU uses the buffers.
@@ -685,9 +686,9 @@ typedef struct drm_fence_arg {
  *  a command (batch-) buffer is exe. Can be or-ed together.
  */
 
-#define DRM_BO_FLAG_READ        0x00000001
-#define DRM_BO_FLAG_WRITE       0x00000002
-#define DRM_BO_FLAG_EXE         0x00000004
+#define DRM_BO_FLAG_READ        (1ULL << 0)
+#define DRM_BO_FLAG_WRITE       (1ULL << 1)
+#define DRM_BO_FLAG_EXE         (1ULL << 2)
 
 /*
  * Status flags. Can be read to determine the actual state of a buffer.
@@ -700,25 +701,25 @@ typedef struct drm_fence_arg {
  * or lock.
  * Flags: Acknowledge
  */
-#define DRM_BO_FLAG_NO_EVICT    0x00000010
+#define DRM_BO_FLAG_NO_EVICT    (1ULL << 4)
 
 /*
  * Mask: Require that the buffer is placed in mappable memory when validated.
  *       If not set the buffer may or may not be in mappable memory when validated.
  * Flags: If set, the buffer is in mappable memory.
  */
-#define DRM_BO_FLAG_MAPPABLE 0x00000020
+#define DRM_BO_FLAG_MAPPABLE    (1ULL << 5)
 
 /* Mask: The buffer should be shareable with other processes.
  * Flags: The buffer is shareable with other processes.
  */
-#define DRM_BO_FLAG_SHAREABLE   0x00000040
+#define DRM_BO_FLAG_SHAREABLE   (1ULL << 6)
 
 /* Mask: If set, place the buffer in cache-coherent memory if available.
  *       If clear, never place the buffer in cache coherent memory if validated.
  * Flags: The buffer is currently in cache-coherent memory.
  */
-#define DRM_BO_FLAG_CACHED      0x00000080
+#define DRM_BO_FLAG_CACHED      (1ULL << 7)
 
 /* Mask: Make sure that every time this buffer is validated,
  *       it ends up on the same location provided that the memory mask is the same.
@@ -727,23 +728,23 @@ typedef struct drm_fence_arg {
  *       part of buffer manager shutdown or locking.
  * Flags: Acknowledge.
  */
-#define DRM_BO_FLAG_NO_MOVE     0x00000100
+#define DRM_BO_FLAG_NO_MOVE     (1ULL << 8)
 
 /* Mask: Make sure the buffer is in cached memory when mapped for reading.
  * Flags: Acknowledge.
  */
-#define DRM_BO_FLAG_READ_CACHED    0x00080000
+#define DRM_BO_FLAG_READ_CACHED    (1ULL << 16)
 
 /* Mask: Force DRM_BO_FLAG_CACHED flag strictly also if it is set.
  * Flags: Acknowledge.
  */
-#define DRM_BO_FLAG_FORCE_CACHING  0x00002000
+#define DRM_BO_FLAG_FORCE_CACHING  (1ULL << 13)
 
 /*
  * Mask: Force DRM_BO_FLAG_MAPPABLE flag strictly also if it is clear.
  * Flags: Acknowledge.
  */
-#define DRM_BO_FLAG_FORCE_MAPPABLE 0x00004000
+#define DRM_BO_FLAG_FORCE_MAPPABLE (1ULL << 14)
 
 /*
  * Memory type flags that can be or'ed together in the mask, but only
@@ -751,21 +752,25 @@ typedef struct drm_fence_arg {
  */
 
 /* System memory */
-#define DRM_BO_FLAG_MEM_LOCAL  0x01000000
+#define DRM_BO_FLAG_MEM_LOCAL  (1ULL << 24)
 /* Translation table memory */
-#define DRM_BO_FLAG_MEM_TT     0x02000000
+#define DRM_BO_FLAG_MEM_TT     (1ULL << 25)
 /* Vram memory */
-#define DRM_BO_FLAG_MEM_VRAM   0x04000000
+#define DRM_BO_FLAG_MEM_VRAM   (1ULL << 26)
 /* Up to the driver to define. */
-#define DRM_BO_FLAG_MEM_PRIV0  0x08000000
-#define DRM_BO_FLAG_MEM_PRIV1  0x10000000
-#define DRM_BO_FLAG_MEM_PRIV2  0x20000000
-#define DRM_BO_FLAG_MEM_PRIV3  0x40000000
-#define DRM_BO_FLAG_MEM_PRIV4  0x80000000
+#define DRM_BO_FLAG_MEM_PRIV0  (1ULL << 27)
+#define DRM_BO_FLAG_MEM_PRIV1  (1ULL << 28)
+#define DRM_BO_FLAG_MEM_PRIV2  (1ULL << 29)
+#define DRM_BO_FLAG_MEM_PRIV3  (1ULL << 30)
+#define DRM_BO_FLAG_MEM_PRIV4  (1ULL << 31)
+/* We can add more of these now with a 64-bit flag type */
 
 /* Memory flag mask */
-#define DRM_BO_MASK_MEM         0xFF000000
-#define DRM_BO_MASK_MEMTYPE     0xFF0000A0
+#define DRM_BO_MASK_MEM         0x00000000FF000000ULL
+#define DRM_BO_MASK_MEMTYPE     0x00000000FF0000A0ULL
+
+/* Driver-private flags */
+#define DRM_BO_MASK_DRIVER      0xFFFF000000000000ULL
 
 /* Don't block on validate and map */
 #define DRM_BO_HINT_DONT_BLOCK  0x00000002
@@ -774,6 +779,10 @@ typedef struct drm_fence_arg {
 #define DRM_BO_HINT_WAIT_LAZY   0x00000008
 #define DRM_BO_HINT_ALLOW_UNFENCED_MAP 0x00000010
 
+#define DRM_BO_INIT_MAGIC 0xfe769812
+#define DRM_BO_INIT_MAJOR 0
+#define DRM_BO_INIT_MINOR 1
+
 
 typedef enum {
 	drm_bo_type_dc,
@@ -783,28 +792,30 @@ typedef enum {
 }drm_bo_type_t;
 
 struct drm_bo_info_req {
-	unsigned int handle;
-	unsigned int mask;
+	drm_u64_t mask;
+        drm_u64_t flags;
+        unsigned int handle;
 	unsigned int hint;
+	unsigned int fence_class;
 };
 
 struct drm_bo_create_req {
-	unsigned int mask;
-	unsigned int hint;
-	unsigned page_alignment;
+        drm_u64_t mask;
 	drm_u64_t size;
-	drm_bo_type_t type;
 	drm_u64_t buffer_start;
+	unsigned int hint;
+	unsigned int page_alignment;
+	drm_bo_type_t type;
 };
 
 struct drm_bo_op_req {
-	struct drm_bo_info_req bo_req;
-	unsigned int arg_handle;
 	enum {
 		drm_bo_validate,
 		drm_bo_fence,
 		drm_bo_ref_fence,
 	} op;
+	unsigned int arg_handle;
+	struct drm_bo_info_req bo_req;
 };
 
 /*
@@ -814,22 +825,26 @@ struct drm_bo_op_req {
 #define DRM_BO_REP_BUSY 0x00000001
 
 struct drm_bo_info_rep {
-	unsigned int handle;
-	unsigned int flags;
+        drm_u64_t flags;
+        drm_u64_t mask;
 	drm_u64_t size;
 	drm_u64_t offset;
 	drm_u64_t arg_handle;
-	unsigned int mask;
 	drm_u64_t buffer_start;
+	unsigned int handle;
 	unsigned int fence_flags;
 	unsigned int rep_flags;
 	unsigned int page_alignment;
-	unsigned int expand_pad[4]; /*Future expansion */
+	unsigned int desired_tile_stride;
+        unsigned int hw_tile_stride;
+	unsigned int tile_info;
+        unsigned int pad64;
+	drm_u64_t expand_pad[4]; /*Future expansion */
 };
 
 struct drm_bo_arg_rep {
-	int ret;
 	struct drm_bo_info_rep bo_info;
+	int ret;
 };
 
 struct drm_bo_create_arg {
@@ -859,6 +874,7 @@ struct drm_bo_map_wait_idle_arg {
 
 struct drm_bo_op_arg {
 	int handled;
+	unsigned int pad_64;
 	drm_u64_t next;
 	union {
 		struct drm_bo_op_req req;
@@ -879,12 +895,15 @@ struct drm_bo_op_arg {
 
 typedef struct drm_mm_type_arg {
 	unsigned int mem_type;
-} drm_mm_type_arg_t; 
+} drm_mm_type_arg_t;
 
 typedef struct drm_mm_init_arg {
+	unsigned int magic;
+	unsigned int major;
+	unsigned int minor;
+	unsigned int mem_type;
 	drm_u64_t p_offset;
 	drm_u64_t p_size;
-	unsigned int mem_type;
 } drm_mm_init_arg_t;
 
 /**
diff --git a/shared-core/i915_drv.h b/shared-core/i915_drv.h
index e8a7be29..52a958d9 100644
--- a/shared-core/i915_drv.h
+++ b/shared-core/i915_drv.h
@@ -196,8 +196,8 @@ extern int i915_fence_has_irq(drm_device_t *dev, uint32_t class, uint32_t flags)
 #ifdef I915_HAVE_BUFFER
 /* i915_buffer.c */
 extern drm_ttm_backend_t *i915_create_ttm_backend_entry(drm_device_t *dev);
-extern int i915_fence_types(drm_buffer_object_t *bo, uint32_t *class, uint32_t *type);
-extern int i915_invalidate_caches(drm_device_t *dev, uint32_t buffer_flags);
+extern int i915_fence_types(drm_buffer_object_t *bo, uint32_t *type);
+extern int i915_invalidate_caches(drm_device_t *dev, uint64_t buffer_flags);
 extern int i915_init_mem_type(drm_device_t *dev, uint32_t type,
 			       drm_mem_type_manager_t *man);
 extern uint32_t i915_evict_mask(drm_buffer_object_t *bo);
diff --git a/shared-core/via_drv.h b/shared-core/via_drv.h
index baafbbff..b6dbf6c1 100644
--- a/shared-core/via_drv.h
+++ b/shared-core/via_drv.h
@@ -205,8 +205,8 @@ extern int via_fence_has_irq(struct drm_device * dev, uint32_t class,
 
 #ifdef VIA_HAVE_BUFFER
 extern drm_ttm_backend_t *via_create_ttm_backend_entry(drm_device_t *dev);
-extern int via_fence_types(drm_buffer_object_t *bo, uint32_t *class, uint32_t *type);
-extern int via_invalidate_caches(drm_device_t *dev, uint32_t buffer_flags);
+extern int via_fence_types(drm_buffer_object_t *bo, uint32_t *type);
+extern int via_invalidate_caches(drm_device_t *dev, uint64_t buffer_flags);
 extern int via_init_mem_type(drm_device_t *dev, uint32_t type,
 			       drm_mem_type_manager_t *man);
 extern uint32_t via_evict_mask(drm_buffer_object_t *bo);