drm: Branch 'drm-ttm-cleanup-branch' - 98 commits

[<ai...@ke...>]

 bsd-core/Makefile              |    1 
 bsd-core/ati_pcigart.c         |   21 
 bsd-core/drmP.h                |   31 -
 bsd-core/drm_agpsupport.c      |    2 
 bsd-core/drm_drv.c             |   14 
 bsd-core/drm_scatter.c         |   39 -
 libdrm/xf86drm.c               |  650 +++++++++++++------------
 libdrm/xf86mm.h                |   56 +-
 linux-core/Makefile            |    1 
 linux-core/Makefile.kernel     |    8 
 linux-core/ati_pcigart.c       |    6 
 linux-core/drmP.h              |   51 -
 linux-core/drm_agpsupport.c    |   28 -
 linux-core/drm_bo.c            |  137 +++--
 linux-core/drm_bo_move.c       |    6 
 linux-core/drm_bufs.c          |   43 -
 linux-core/drm_compat.c        |  123 ++++
 linux-core/drm_compat.h        |    9 
 linux-core/drm_context.c       |  145 +----
 linux-core/drm_drawable.c      |  235 ++-------
 linux-core/drm_drv.c           |   91 ---
 linux-core/drm_fence.c         |  156 +++---
 linux-core/drm_fops.c          |   45 -
 linux-core/drm_ioc32.c         |    1 
 linux-core/drm_ioctl.c         |   14 
 linux-core/drm_irq.c           |   20 
 linux-core/drm_memory.c        |    2 
 linux-core/drm_object.c        |    9 
 linux-core/drm_objects.h       |   31 -
 linux-core/drm_pci.c           |    2 
 linux-core/drm_proc.c          |   19 
 linux-core/drm_scatter.c       |   49 +
 linux-core/drm_stub.c          |   41 -
 linux-core/drm_sysfs.c         |   31 -
 linux-core/drm_vm.c            |   36 -
 linux-core/i810_dma.c          |    6 
 linux-core/i915_drv.c          |    6 
 linux-core/i915_fence.c        |    2 
 linux-core/i915_ioc32.c        |    1 
 linux-core/mga_ioc32.c         |    1 
 linux-core/nouveau_ioc32.c     |    1 
 linux-core/nouveau_notifier.c  |    1 
 linux-core/nv04_fifo.c         |    1 
 linux-core/nv04_instmem.c      |    1 
 linux-core/nv10_fifo.c         |    1 
 linux-core/nv40_fifo.c         |    1 
 linux-core/nv50_fifo.c         |    1 
 linux-core/nv50_graph.c        |    1 
 linux-core/nv50_instmem.c      |    1 
 linux-core/nv50_mc.c           |    1 
 linux-core/r128_ioc32.c        |    1 
 linux-core/radeon_drv.c        |    3 
 linux-core/radeon_ioc32.c      |   32 +
 linux-core/sis_mm.c            |    2 
 shared-core/drm_pciids.txt     |   22 
 shared-core/i915_dma.c         |  104 +++-
 shared-core/i915_drm.h         |    5 
 shared-core/i915_drv.h         |    5 
 shared-core/i915_irq.c         |   24 
 shared-core/mga_dma.c          |    2 
 shared-core/nouveau_drm.h      |   40 -
 shared-core/nouveau_drv.h      |  316 +++++++++---
 shared-core/nouveau_fifo.c     |  507 ++++++-------------
 shared-core/nouveau_irq.c      |   42 -
 shared-core/nouveau_mem.c      |  289 +++--------
 shared-core/nouveau_notifier.c |  153 +++++
 shared-core/nouveau_object.c   | 1058 +++++++++++++++++++++++++++--------------
 shared-core/nouveau_reg.h      |   38 +
 shared-core/nouveau_state.c    |  272 ++++++++--
 shared-core/nv04_fifo.c        |  130 +++++
 shared-core/nv04_graph.c       |   27 -
 shared-core/nv04_instmem.c     |  165 ++++++
 shared-core/nv10_fifo.c        |  161 ++++++
 shared-core/nv10_graph.c       |   29 -
 shared-core/nv20_graph.c       |   76 +-
 shared-core/nv30_graph.c       |  107 +++-
 shared-core/nv40_fifo.c        |  195 +++++++
 shared-core/nv40_graph.c       |  684 +++++++++++++++++++++++---
 shared-core/nv50_fifo.c        |  334 ++++++++++++
 shared-core/nv50_graph.c       |  301 +++++++++++
 shared-core/nv50_instmem.c     |  262 ++++++++++
 shared-core/nv50_mc.c          |   42 +
 shared-core/r300_cmdbuf.c      |   29 -
 shared-core/r300_reg.h         |   38 +
 shared-core/radeon_cp.c        |   23 
 shared-core/radeon_drm.h       |    5 
 shared-core/radeon_drv.h       |   67 ++
 shared-core/radeon_irq.c       |  106 +++-
 shared-core/radeon_state.c     |    6 
 shared-core/sis_drv.h          |    8 
 shared-core/via_dma.c          |   49 -
 shared-core/via_verifier.c     |    4 
 92 files changed, 5504 insertions(+), 2438 deletions(-)

New commits:
diff-tree 2c9e05cf4c6eb18c941321f764ed1b282a314ba9 (from parents)
Merge: 9b9a127ed0fe9a6a8e2fde84739ccff6fa0bc5ac 694e1c5c3f768436651ddf95e11ab5a89ccc8ffa
Author: Dave Airlie <ai...@li...>
Date:   Wed Jul 11 11:23:41 2007 +1000

    Merge branch 'master' into cleanup
    
    Conflicts:
    
    	libdrm/xf86drm.c
    	linux-core/drm_bo.c
    	linux-core/drm_fence.c

diff --cc libdrm/xf86drm.c
index 4f12bd0,9318551..52a6d92
@@@ -2291,11 -2375,11 +2374,11 @@@
  int drmFenceBuffers(int fd, unsigned flags, drmFence *fence)
  {
      drm_fence_arg_t arg;
-     
+ 
      memset(&arg, 0, sizeof(arg));
      arg.flags = flags;
 -    arg.op = drm_fence_buffers;
 -    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 +
 +    if (ioctl(fd, DRM_IOCTL_FENCE_BUFFERS, &arg))
  	return -errno;
      fence->handle = arg.handle;
      fence->class = arg.class;
@@@ -2308,11 -2392,11 +2391,11 @@@
  int drmFenceDestroy(int fd, const drmFence *fence)
  {
      drm_fence_arg_t arg;
-    
+ 
      memset(&arg, 0, sizeof(arg));
      arg.handle = fence->handle;
 -    arg.op = drm_fence_destroy;
 -    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 +
 +    if (ioctl(fd, DRM_IOCTL_FENCE_DESTROY, &arg))
  	return -errno;
      return 0;
  }
@@@ -2320,11 -2404,11 +2403,11 @@@
  int drmFenceReference(int fd, unsigned handle, drmFence *fence)
  {
      drm_fence_arg_t arg;
-    
+ 
      memset(&arg, 0, sizeof(arg));
      arg.handle = handle;
 -    arg.op = drm_fence_reference;
 -    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 +
 +    if (ioctl(fd, DRM_IOCTL_FENCE_REFERENCE, &arg))
  	return -errno;
      fence->handle = arg.handle;
      fence->class = arg.class;
@@@ -2337,11 -2421,11 +2420,11 @@@
  int drmFenceUnreference(int fd, const drmFence *fence)
  {
      drm_fence_arg_t arg;
-    
+ 
      memset(&arg, 0, sizeof(arg));
      arg.handle = fence->handle;
 -    arg.op = drm_fence_unreference;
 -    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 +
 +    if (ioctl(fd, DRM_IOCTL_FENCE_UNREFERENCE, &arg))
  	return -errno;
      return 0;
  }
@@@ -2364,12 -2448,12 +2447,12 @@@
  
  int drmFenceUpdate(int fd, drmFence *fence)
  {
- 	drm_fence_arg_t arg;
- 	
+     drm_fence_arg_t arg;
+ 
      memset(&arg, 0, sizeof(arg));
      arg.handle = fence->handle;
 -    arg.op = drm_fence_signaled;
 -    if (ioctl(fd, DRM_IOCTL_FENCE, &arg))
 +
 +    if (ioctl(fd, DRM_IOCTL_FENCE_SIGNALED, &arg))
  	return -errno;
      fence->class = arg.class;
      fence->type = arg.type;
@@@ -2598,8 -2678,7 +2677,7 @@@
      return drmAdjustListNodes(list);
  }
  
- static void drmBOCopyReply(struct drm_bo_info_rep *rep, 
- 			   drmBO *buf)
 -static void drmBOCopyReply(const drm_bo_arg_reply_t *rep, drmBO *buf)
++static void drmBOCopyReply(const struct drm_bo_info_rep *rep, drmBO *buf)
  {
      buf->handle = rep->handle;
      buf->flags = rep->flags;
@@@ -2686,13 -2777,12 +2764,12 @@@
      buf->handle = 0;
      return 0;
  }
 - 
 +
  int drmBOReference(int fd, unsigned handle, drmBO *buf)
  {
- 
 -    drm_bo_arg_t arg;
 -    drm_bo_arg_request_t *req = &arg.d.req;
 -    drm_bo_arg_reply_t *rep = &arg.d.rep;
 +    struct drm_bo_reference_info_arg arg;
 +    struct drm_bo_handle_arg *req = &arg.d.req;
 +    struct drm_bo_info_rep *rep = &arg.d.rep;
      
      memset(&arg, 0, sizeof(arg));
      req->handle = handle;
@@@ -2739,10 -2844,9 +2816,9 @@@
  int drmBOMap(int fd, drmBO *buf, unsigned mapFlags, unsigned mapHint,
  	     void **address)
  {
- 
 -    drm_bo_arg_t arg;
 -    drm_bo_arg_request_t *req = &arg.d.req;
 -    drm_bo_arg_reply_t *rep = &arg.d.rep;
 +    struct drm_bo_map_wait_idle_arg arg;
 +    struct drm_bo_info_req *req = &arg.d.req;
 +    struct drm_bo_info_rep *rep = &arg.d.rep;
      int ret = 0;
  
      /*
@@@ -2788,27 -2897,33 +2864,27 @@@
      return 0;
  }
  
 +
  int drmBOUnmap(int fd, drmBO *buf)
  {
 -    drm_bo_arg_t arg;
 -    drm_bo_arg_request_t *req = &arg.d.req;
 -    drm_bo_arg_reply_t *rep = &arg.d.rep;
 +    struct drm_bo_handle_arg arg;
- 	
+ 
      memset(&arg, 0, sizeof(arg));
 -    req->handle = buf->handle;
 -    req->op = drm_bo_unmap;
 +    arg.handle = buf->handle;
  
 -    if (ioctl(fd, DRM_IOCTL_BUFOBJ, &arg)) {
 +    if (ioctl(fd, DRM_IOCTL_BO_UNMAP, &arg)) {
  	return -errno;
      }
 -    if (!arg.handled) 
 -        return -EFAULT;
 -    if (rep->ret)
 -	return rep->ret;
 -
      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)
  {
 -    drm_bo_arg_t arg;
 -    drm_bo_arg_request_t *req = &arg.d.req;
 -    drm_bo_arg_reply_t *rep = &arg.d.rep;
 +    struct drm_bo_op_arg arg;
 +    struct drm_bo_op_req *req = &arg.d.req;
 +    struct drm_bo_arg_rep *rep = &arg.d.rep;
      int ret = 0;
  
      memset(&arg, 0, sizeof(arg));
@@@ -2820,9 -2934,9 +2896,9 @@@
      req->op = drm_bo_validate;
  
      do{
 -	ret = ioctl(fd, DRM_IOCTL_BUFOBJ, &arg);
 +	ret = ioctl(fd, DRM_IOCTL_BO_OP, &arg);
      } while (ret && errno == EAGAIN);
-     
+ 
      if (ret) 
  	return -errno;
      if (!arg.handled)
@@@ -2848,8 -2962,8 +2924,7 @@@
      req->arg_handle = fenceHandle;
      req->op = drm_bo_fence;
  
 -    ret = ioctl(fd, DRM_IOCTL_BUFOBJ, &arg);
 -
 +    ret = ioctl(fd, DRM_IOCTL_BO_OP, &arg);
-     
      if (ret) 
  	return -errno;
      if (!arg.handled)
@@@ -2868,12 -2982,16 +2943,11 @@@
  
      memset(&arg, 0, sizeof(arg));
      req->handle = buf->handle;
 -    req->op = drm_bo_info;
 -
 -    ret = ioctl(fd, DRM_IOCTL_BUFOBJ, &arg);
  
 +    ret = ioctl(fd, DRM_IOCTL_BO_INFO, &arg);
-     
      if (ret) 
  	return -errno;
 -    if (!arg.handled)
 -	return -EFAULT;
 -    if (rep->ret)
 -	return rep->ret;
 +
      drmBOCopyReply(rep, buf);
      return 0;
  }
@@@ -2976,143 -3101,134 +3052,139 @@@
  
  int drmBOValidateList(int fd, drmBOList *list)
  {
-    
-   drmBONode *node;
-   drmMMListHead *l;
-   struct drm_bo_op_arg *arg, *first;
-   struct drm_bo_op_req *req;
-   struct drm_bo_arg_rep *rep;
-   drm_u64_t *prevNext = NULL;
-   drmBO *buf;
-   int ret;
- 
-   first = NULL;
- 
-   for (l = list->list.next; l != &list->list; l = l->next) {
-       node = DRMLISTENTRY(drmBONode, l, head);
- 
-       arg = &node->bo_arg;
-       req = &arg->d.req;
- 
-       if (!first)
- 	  first = arg;
- 
-       if (prevNext)
- 	  *prevNext = (unsigned long) arg;
- 
-       memset(arg, 0, sizeof(*arg));
-       prevNext = &arg->next;
-       req->bo_req.handle = node->buf->handle;
-       req->op = drm_bo_validate;
-       req->bo_req.flags = node->arg0;
-       req->bo_req.hint = 0;
-       req->bo_req.mask = node->arg1;
-       req->bo_req.fence_class = 0; /* Backwards compat. */
-   }
- 
-   if (!first)
-       return 0;
- 
-   do{
-       ret = ioctl(fd, DRM_IOCTL_BO_OP, first);
-   } while (ret && errno == EAGAIN);
+     drmBONode *node;
+     drmMMListHead *l;
 -    drm_bo_arg_t *arg, *first;
 -    drm_bo_arg_request_t *req;
 -    drm_bo_arg_reply_t *rep;
++    struct drm_bo_op_arg *arg, *first;
++    struct drm_bo_op_req *req;
++    struct drm_bo_arg_rep *rep;
+     drm_u64_t *prevNext = NULL;
+     drmBO *buf;
+     int ret;
  
+     first = NULL;
  
-   if (ret)
-       return -errno;
-   
-   for (l = list->list.next; l != &list->list; l = l->next) {
-       node = DRMLISTENTRY(drmBONode, l, head);
-       arg = &node->bo_arg;
-       rep = &arg->d.rep;
-       
-       if (!arg->handled) {
- 	  drmMsg("Unhandled request\n");
- 	  return -EFAULT;
-       }
-       if (rep->ret)
- 	  return rep->ret;
- 
-       buf = node->buf;
-       drmBOCopyReply(&rep->bo_info, buf);
-   }
+     for (l = list->list.next; l != &list->list; l = l->next) {
 -	node = DRMLISTENTRY(drmBONode, l, head);
++        node = DRMLISTENTRY(drmBONode, l, head);
+ 
 -	arg = &node->bo_arg;
 -	req = &arg->d.req;
++        arg = &node->bo_arg;
++        req = &arg->d.req;
+ 
 -	if (!first)
 -	    first = arg;
++        if (!first)
++            first = arg;
+ 
+ 	if (prevNext)
+ 	    *prevNext = (unsigned long) arg;
+ 
+ 	memset(arg, 0, sizeof(*arg));
+ 	prevNext = &arg->next;
 -	req->handle = node->buf->handle;
++	req->bo_req.handle = node->buf->handle;
+ 	req->op = drm_bo_validate;
 -	req->mask = node->arg0;
 -	req->hint = 0;
 -	req->arg_handle = node->arg1;
++	req->bo_req.flags = node->arg0;
++	req->bo_req.hint = 0;
++	req->bo_req.mask = node->arg1;
++	req->bo_req.fence_class = 0; /* Backwards compat. */
+     }
 -  
 -    if (!first) 
++
++    if (!first)
+ 	return 0;
  
-   return 0;
 -    do {
 -	ret = ioctl(fd, DRM_IOCTL_BUFOBJ, first);
++    do{
++	ret = ioctl(fd, DRM_IOCTL_BO_OP, first);
+     } while (ret && errno == EAGAIN);
+ 
+     if (ret)
+ 	return -errno;
 -  
++
+     for (l = list->list.next; l != &list->list; l = l->next) {
+ 	node = DRMLISTENTRY(drmBONode, l, head);
+ 	arg = &node->bo_arg;
+ 	rep = &arg->d.rep;
 -
++      
+ 	if (!arg->handled) {
+ 	    drmMsg("Unhandled request\n");
+ 	    return -EFAULT;
+ 	}
+ 	if (rep->ret)
+ 	    return rep->ret;
 -
++	
+ 	buf = node->buf;
 -	drmBOCopyReply(rep, buf);
++	drmBOCopyReply(&rep->bo_info, buf);
+     }
 -
++    
+     return 0;
  }
  	  
--
  int drmBOFenceList(int fd, drmBOList *list, unsigned fenceHandle)
  {
-    
-   drmBONode *node;
-   drmMMListHead *l;
-   struct drm_bo_op_arg *arg, *first;
-   struct drm_bo_op_req *req;
-   struct drm_bo_arg_rep *rep;
-   drm_u64_t *prevNext = NULL;
-   drmBO *buf;
-   unsigned fence_flags;
-   int ret;
- 
-   first = NULL;
- 
-   for (l = list->list.next; l != &list->list; l = l->next) {
-       node = DRMLISTENTRY(drmBONode, l, head);
- 
-       arg = &node->bo_arg;
-       req = &arg->d.req;
- 
-       if (!first)
- 	  first = arg;
- 
-       if (prevNext)
- 	  *prevNext = (unsigned long) arg;
- 
-       memset(arg, 0, sizeof(*arg));
-       prevNext = &arg->next;
-       req->bo_req.handle = node->buf->handle;
-       req->op = drm_bo_fence;
-       req->bo_req.mask = node->arg0;
-       req->arg_handle = fenceHandle;
-   }
+     drmBONode *node;
+     drmMMListHead *l;
 -    drm_bo_arg_t *arg, *first;
 -    drm_bo_arg_request_t *req;
 -    drm_bo_arg_reply_t *rep;
++    struct drm_bo_op_arg *arg, *first;
++    struct drm_bo_op_req *req;
++    struct drm_bo_arg_rep *rep;
+     drm_u64_t *prevNext = NULL;
+     drmBO *buf;
+     unsigned fence_flags;
+     int ret;
+ 
+     first = NULL;
+ 
+     for (l = list->list.next; l != &list->list; l = l->next) {
 -	node = DRMLISTENTRY(drmBONode, l, head);
 -
++        node = DRMLISTENTRY(drmBONode, l, head);
++	
+ 	arg = &node->bo_arg;
+ 	req = &arg->d.req;
+ 
+ 	if (!first)
+ 	    first = arg;
+ 
+ 	if (prevNext)
+ 	    *prevNext = (unsigned long) arg;
+ 
+ 	memset(arg, 0, sizeof(*arg));
+ 	prevNext = &arg->next;
 -	req->handle = node->buf->handle;
++	req->bo_req.handle = node->buf->handle;
+ 	req->op = drm_bo_fence;
 -	req->mask = node->arg0;
++	req->bo_req.mask = node->arg0;
+ 	req->arg_handle = fenceHandle;
+     }
    
-   if (!first) 
-       return 0;
+     if (!first) 
+ 	return 0;
  
-   ret = ioctl(fd, DRM_IOCTL_BO_OP, first);
 -    ret = ioctl(fd, DRM_IOCTL_BUFOBJ, first);
++    ret = ioctl(fd, DRM_IOCTL_BO_OP, first);
  
-   if (ret)
-       return -errno;
+     if (ret)
+ 	return -errno;
    
-   for (l = list->list.next; l != &list->list; l = l->next) {
-       node = DRMLISTENTRY(drmBONode, l, head);
+     for (l = list->list.next; l != &list->list; l = l->next) {
+ 	node = DRMLISTENTRY(drmBONode, l, head);
 +
-       arg = &node->bo_arg;
-       rep = &arg->d.rep;
-       
-       if (!arg->handled)
- 	  return -EFAULT;
-       if (rep->ret)
- 	  return rep->ret;
-       drmBOCopyReply(&rep->bo_info, node->buf);
-   }
+ 	arg = &node->bo_arg;
+ 	rep = &arg->d.rep;
 +
-   return 0;
+       	if (!arg->handled)
+ 	    return -EFAULT;
+ 	if (rep->ret)
+ 	    return rep->ret;
 -	drmBOCopyReply(rep, node->buf);
++	drmBOCopyReply(&rep->bo_info, node->buf);
+     }
+ 
+     return 0;
  }
  
  int drmMMInit(int fd, unsigned long pOffset, unsigned long pSize,
  	      unsigned memType)
  {
 -    drm_mm_init_arg_t arg;
 +    struct drm_mm_init_arg arg;
-     
+ 
      memset(&arg, 0, sizeof(arg));
 -    arg.req.op = mm_init;
 -    arg.req.p_offset = pOffset;
 -    arg.req.p_size = pSize;
 -    arg.req.mem_type = memType;
 +
 +    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;
  
      if (ioctl(fd, DRM_IOCTL_MM_INIT, &arg))
  	return -errno;
@@@ -3122,14 -3237,14 +3193,13 @@@
  
  int drmMMTakedown(int fd, unsigned memType)
  {
 -    drm_mm_init_arg_t arg;
 +    struct drm_mm_type_arg arg;
  
      memset(&arg, 0, sizeof(arg));
 -    arg.req.op = mm_takedown;
 -    arg.req.mem_type = memType;
 +    arg.mem_type = memType;
  
 -    if (ioctl(fd, DRM_IOCTL_MM_INIT, &arg))
 +    if (ioctl(fd, DRM_IOCTL_MM_TAKEDOWN, &arg))
  	return -errno;
-     
      return 0;	
  }
  
@@@ -3139,13 -3254,14 +3209,13 @@@
      int ret;
  
      memset(&arg, 0, sizeof(arg));
 -    arg.req.op = mm_lock;
 -    arg.req.mem_type = memType;
 +    arg.mem_type = memType;
  
      do{
 -	ret = ioctl(fd, DRM_IOCTL_MM_INIT, &arg);
 +        ret = ioctl(fd, DRM_IOCTL_MM_LOCK, &arg);
      } while (ret && errno == EAGAIN);
-     
-     return -errno;	
+ 
+     return (ret) ? -errno : 0;
  }
  
  int drmMMUnlock(int fd, unsigned memType)
@@@ -3154,14 -3270,14 +3224,14 @@@
      int ret;
  
      memset(&arg, 0, sizeof(arg));
 -    arg.req.op = mm_unlock;
 -    arg.req.mem_type = memType;
 +    
 +    arg.mem_type = memType;
  
      do{
 -	ret = ioctl(fd, DRM_IOCTL_MM_INIT, &arg);
 +	ret = ioctl(fd, DRM_IOCTL_MM_UNLOCK, &arg);
      } while (ret && errno == EAGAIN);
-     
-     return -errno;	
+ 
+     return (ret) ? -errno : 0;
  }
  
  #define DRM_MAX_FDS 16
diff --cc libdrm/xf86mm.h
index 68cd7cd,b3822d4..61978bc
@@@ -124,11 -123,11 +126,11 @@@
      unsigned pad[8];     /* for future expansion */
  } drmBO;
  
- 
- typedef struct _drmBONode {
+ typedef struct _drmBONode
+ {
      drmMMListHead head;
      drmBO *buf;
 -    drm_bo_arg_t bo_arg;
 +    struct drm_bo_op_arg bo_arg;
      unsigned long arg0;
      unsigned long arg1;
  } drmBONode;
diff --cc linux-core/drm_bo.c
index a1a27d1,ab25782..2ce3dbc
@@@ -1481,12 -1465,11 +1489,13 @@@
  	return 0;
  }
  
 -static int drm_bo_handle_validate(drm_file_t * priv, uint32_t handle,
 -				  uint32_t flags, uint32_t mask, uint32_t hint,
 -				  drm_bo_arg_reply_t * rep)
 +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)
  {
+ 	struct drm_device *dev = priv->head->dev;
  	drm_buffer_object_t *bo;
  	int ret;
  	int no_wait = hint & DRM_BO_HINT_DONT_BLOCK;
@@@ -1521,12 -1505,16 +1532,16 @@@
  	return ret;
  }
  
 -static int drm_bo_handle_info(drm_file_t * priv, uint32_t handle,
 -			      drm_bo_arg_reply_t * rep)
 +static int drm_bo_handle_info(drm_file_t *priv, uint32_t handle,
 +			      struct drm_bo_info_rep *rep)
  {
+ 	struct drm_device *dev = priv->head->dev;
  	drm_buffer_object_t *bo;
  
+ 	mutex_lock(&dev->struct_mutex);
  	bo = drm_lookup_buffer_object(priv, handle, 1);
+ 	mutex_unlock(&dev->struct_mutex);
+ 
  	if (!bo) {
  		return -EINVAL;
  	}
@@@ -1539,10 -1527,10 +1554,11 @@@
  	return 0;
  }
  
 -static int drm_bo_handle_wait(drm_file_t * priv, uint32_t handle,
 -			      uint32_t hint, drm_bo_arg_reply_t * rep)
 +static int drm_bo_handle_wait(drm_file_t *priv, uint32_t handle,
 +			      uint32_t hint,
 +			      struct drm_bo_info_rep *rep)
  {
+ 	struct drm_device *dev = priv->head->dev;
  	drm_buffer_object_t *bo;
  	int no_wait = hint & DRM_BO_HINT_DONT_BLOCK;
  	int ret;
@@@ -1744,209 -1803,6 +1763,209 @@@
  	return 0;
  }
  
 +int drm_bo_create_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	struct drm_bo_create_arg arg;
 +	struct drm_bo_create_req *req = &arg.d.req;
 +	struct drm_bo_info_rep *rep = &arg.d.rep;
 +	drm_buffer_object_t *entry;
 +	int ret = 0;
 +
 +	if (!dev->bm.initialized) {
 +		DRM_ERROR("Buffer object manager is not initialized.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +	
 +	ret = drm_bo_lock_test(dev, filp);
 +	if (ret)
 +		goto out;
 +
 +	ret = drm_buffer_object_create(priv->head->dev,
 +				       req->size, req->type, req->mask,
 +				       req->hint, req->page_alignment,
 +				       req->buffer_start, &entry);
 +	if (ret)
 +		goto out;
 +	
 +	ret = drm_bo_add_user_object(priv, entry,
 +				     req->mask & DRM_BO_FLAG_SHAREABLE);
 +	if (ret) {
- 		drm_bo_usage_deref_unlocked(entry);
++		drm_bo_usage_deref_unlocked(&entry);
 +		goto out;
 +	}
 +	
 +	mutex_lock(&entry->mutex);
 +	drm_bo_fill_rep_arg(entry, rep);
 +	mutex_unlock(&entry->mutex);
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +out:
 +	return ret;
 +}
 +
 +
 +int drm_bo_destroy_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	struct drm_bo_handle_arg arg;
 +	drm_user_object_t *uo;
 +	int ret = 0;
 +
 +	if (!dev->bm.initialized) {
 +		DRM_ERROR("Buffer object manager is not initialized.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	mutex_lock(&dev->struct_mutex);
 +	uo = drm_lookup_user_object(priv, arg.handle);
 +	if (!uo || (uo->type != drm_buffer_type) || uo->owner != priv) {
 +		mutex_unlock(&dev->struct_mutex);
 +		return -EINVAL;
 +	}
 +	ret = drm_remove_user_object(priv, uo);
 +	mutex_unlock(&dev->struct_mutex);
 +	
 +	return ret;
 +}
 +
 +int drm_bo_map_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	struct drm_bo_map_wait_idle_arg arg;
 +	struct drm_bo_info_req *req = &arg.d.req;
 +	struct drm_bo_info_rep *rep = &arg.d.rep;
 +	int ret;
 +	if (!dev->bm.initialized) {
 +		DRM_ERROR("Buffer object manager is not initialized.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	ret = drm_buffer_object_map(priv, req->handle, req->mask,
 +				    req->hint, rep);
 +	if (ret)
 +		return ret;
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return 0;
 +}
 +
 +int drm_bo_unmap_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	struct drm_bo_handle_arg arg;
 +	int ret;
 +	if (!dev->bm.initialized) {
 +		DRM_ERROR("Buffer object manager is not initialized.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	ret = drm_buffer_object_unmap(priv, arg.handle);
 +	return ret;
 +}
 +
 +
 +int drm_bo_reference_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	struct drm_bo_reference_info_arg arg;
 +	struct drm_bo_handle_arg *req = &arg.d.req;
 +	struct drm_bo_info_rep *rep = &arg.d.rep;
 +	drm_user_object_t *uo;
 +	int ret;
 +
 +	if (!dev->bm.initialized) {
 +		DRM_ERROR("Buffer object manager is not initialized.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	ret = drm_user_object_ref(priv, req->handle,
 +				  drm_buffer_type, &uo);
 +	if (ret)
 +		return ret;
 +	
 +	ret = drm_bo_handle_info(priv, req->handle, rep);
 +	if (ret)
 +		return ret;
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return 0;
 +}
 +
 +int drm_bo_unreference_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	struct drm_bo_handle_arg arg;
 +	int ret = 0;
 +
 +	if (!dev->bm.initialized) {
 +		DRM_ERROR("Buffer object manager is not initialized.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	ret = drm_user_object_unref(priv, arg.handle, drm_buffer_type);
 +	return ret;
 +}
 +
 +int drm_bo_info_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	struct drm_bo_reference_info_arg arg;
 +	struct drm_bo_handle_arg *req = &arg.d.req;
 +	struct drm_bo_info_rep *rep = &arg.d.rep;
 +	int ret;
 +
 +	if (!dev->bm.initialized) {
 +		DRM_ERROR("Buffer object manager is not initialized.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	ret = drm_bo_handle_info(priv, req->handle, rep);
 +	if (ret)
 +		return ret;
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return 0;
 +}
 +
 +int drm_bo_wait_idle_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	struct drm_bo_map_wait_idle_arg arg;
 +	struct drm_bo_info_req *req = &arg.d.req;
 +	struct drm_bo_info_rep *rep = &arg.d.rep;
 +	int ret;
 +	if (!dev->bm.initialized) {
 +		DRM_ERROR("Buffer object manager is not initialized.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	ret = drm_bo_handle_wait(priv, req->handle,
 +				 req->hint, rep);
 +	if (ret)
 +		return ret;
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return 0;
 +}
 +
 +
 +
  /**
   *Clean the unfenced list and put on regular LRU.
   *This is part of the memory manager cleanup and should only be
diff --cc linux-core/drm_fence.c
index 3d92801,5215feb..b6f1424
@@@ -556,289 -582,92 +581,288 @@@
  	}
  
  	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
- 
 -	switch (arg.op) {
 -	case drm_fence_create:
 -		if (arg.flags & DRM_FENCE_FLAG_EMIT)
 -			LOCK_TEST_WITH_RETURN(dev, filp);
 -		ret = drm_fence_object_create(dev, arg.class,
 -					      arg.type, arg.flags, &fence);
 -		if (ret)
 -			return ret;
 -		ret = drm_fence_add_user_object(priv, fence,
 -						arg.flags &
 -						DRM_FENCE_FLAG_SHAREABLE);
 -		if (ret) {
 -			drm_fence_usage_deref_unlocked(&fence);
 -			return ret;
 -		}
 -		arg.handle = fence->base.hash.key;
 -
 -		break;
 -	case drm_fence_destroy:
 -		mutex_lock(&dev->struct_mutex);
 -		uo = drm_lookup_user_object(priv, arg.handle);
 -		if (!uo || (uo->type != drm_fence_type) || uo->owner != priv) {
 -			mutex_unlock(&dev->struct_mutex);
 -			return -EINVAL;
 -		}
 -		ret = drm_remove_user_object(priv, uo);
 -		mutex_unlock(&dev->struct_mutex);
 +	if (arg.flags & DRM_FENCE_FLAG_EMIT)
 +		LOCK_TEST_WITH_RETURN(dev, filp);
 +	ret = drm_fence_object_create(dev, arg.class,
 +				      arg.type, arg.flags, &fence);
 +	if (ret)
  		return ret;
 -	case drm_fence_reference:
 -		ret =
 -		    drm_user_object_ref(priv, arg.handle, drm_fence_type, &uo);
 -		if (ret)
 -			return ret;
 -		fence = drm_lookup_fence_object(priv, arg.handle);
 -		break;
 -	case drm_fence_unreference:
 -		ret = drm_user_object_unref(priv, arg.handle, drm_fence_type);
 +	ret = drm_fence_add_user_object(priv, fence,
 +					arg.flags &
 +					DRM_FENCE_FLAG_SHAREABLE);
 +	if (ret) {
- 		drm_fence_usage_deref_unlocked(dev, fence);
++		drm_fence_usage_deref_unlocked(&fence);
  		return ret;
 -	case drm_fence_signaled:
 -		fence = drm_lookup_fence_object(priv, arg.handle);
 -		if (!fence)
 -			return -EINVAL;
 -		break;
 -	case drm_fence_flush:
 -		fence = drm_lookup_fence_object(priv, arg.handle);
 -		if (!fence)
 -			return -EINVAL;
 -		ret = drm_fence_object_flush(fence, arg.type);
 -		break;
 -	case drm_fence_wait:
 -		fence = drm_lookup_fence_object(priv, arg.handle);
 -		if (!fence)
 -			return -EINVAL;
 -		ret =
 -		    drm_fence_object_wait(fence,
 -					  arg.flags & DRM_FENCE_FLAG_WAIT_LAZY,
 -					  0, arg.type);
 -		break;
 -	case drm_fence_emit:
 -		LOCK_TEST_WITH_RETURN(dev, filp);
 -		fence = drm_lookup_fence_object(priv, arg.handle);
 -		if (!fence)
 -			return -EINVAL;
 -		ret = drm_fence_object_emit(fence, arg.flags, arg.class,
 -					    arg.type);
 -		break;
 -	case drm_fence_buffers:
 -		if (!dev->bm.initialized) {
 -			DRM_ERROR("Buffer object manager is not initialized\n");
 -			return -EINVAL;
 -		}
 -		LOCK_TEST_WITH_RETURN(dev, filp);
 -		ret = drm_fence_buffer_objects(priv, NULL, arg.flags,
 -					       NULL, &fence);
 -		if (ret)
 -			return ret;
 -		ret = drm_fence_add_user_object(priv, fence,
 -						arg.flags &
 -						DRM_FENCE_FLAG_SHAREABLE);
 -		if (ret)
 -			return ret;
 -		arg.handle = fence->base.hash.key;
 -		break;
 -	default:
 +	}
 +	
 +	/*
 +	 * usage > 0. No need to lock dev->struct_mutex;
 +	 */
 +	
 +	atomic_inc(&fence->usage);
 +	arg.handle = fence->base.hash.key;
 +
 +	read_lock_irqsave(&fm->lock, flags);
 +	arg.class = fence->class;
 +	arg.type = fence->type;
 +	arg.signaled = fence->signaled;
 +	read_unlock_irqrestore(&fm->lock, flags);
- 	drm_fence_usage_deref_unlocked(dev, fence);
++	drm_fence_usage_deref_unlocked(&fence);
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return ret;
 +}
 +
 +int drm_fence_destroy_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	int ret;
 +	drm_fence_manager_t *fm = &dev->fm;
 +	drm_fence_arg_t arg;
 +	drm_user_object_t *uo;
 +	ret = 0;
 +
 +	if (!fm->initialized) {
 +		DRM_ERROR("The DRM driver does not support fencing.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	mutex_lock(&dev->struct_mutex);
 +	uo = drm_lookup_user_object(priv, arg.handle);
 +	if (!uo || (uo->type != drm_fence_type) || uo->owner != priv) {
 +		mutex_unlock(&dev->struct_mutex);
 +		return -EINVAL;
 +	}
 +	ret = drm_remove_user_object(priv, uo);
 +	mutex_unlock(&dev->struct_mutex);
 +	return ret;
 +}
 +
 +
 +int drm_fence_reference_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	int ret;
 +	drm_fence_manager_t *fm = &dev->fm;
 +	drm_fence_arg_t arg;
 +	drm_fence_object_t *fence;
 +	drm_user_object_t *uo;
 +	unsigned long flags;
 +	ret = 0;
 +
 +	if (!fm->initialized) {
 +		DRM_ERROR("The DRM driver does not support fencing.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +	ret = drm_user_object_ref(priv, arg.handle, drm_fence_type, &uo);
 +	if (ret)
 +		return ret;
 +	fence = drm_lookup_fence_object(priv, arg.handle);
 +
 +	read_lock_irqsave(&fm->lock, flags);
 +	arg.class = fence->class;
 +	arg.type = fence->type;
 +	arg.signaled = fence->signaled;
 +	read_unlock_irqrestore(&fm->lock, flags);
- 	drm_fence_usage_deref_unlocked(dev, fence);
++	drm_fence_usage_deref_unlocked(&fence);
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return ret;
 +}
 +
 +
 +int drm_fence_unreference_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	int ret;
 +	drm_fence_manager_t *fm = &dev->fm;
 +	drm_fence_arg_t arg;
 +	ret = 0;
 +
 +	if (!fm->initialized) {
 +		DRM_ERROR("The DRM driver does not support fencing.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +	return drm_user_object_unref(priv, arg.handle, drm_fence_type);
 +}
 +
 +int drm_fence_signaled_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	int ret;
 +	drm_fence_manager_t *fm = &dev->fm;
 +	drm_fence_arg_t arg;
 +	drm_fence_object_t *fence;
 +	unsigned long flags;
 +	ret = 0;
 +
 +	if (!fm->initialized) {
 +		DRM_ERROR("The DRM driver does not support fencing.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	fence = drm_lookup_fence_object(priv, arg.handle);
 +	if (!fence)
 +		return -EINVAL;
 +
 +	read_lock_irqsave(&fm->lock, flags);
 +	arg.class = fence->class;
 +	arg.type = fence->type;
 +	arg.signaled = fence->signaled;
 +	read_unlock_irqrestore(&fm->lock, flags);
- 	drm_fence_usage_deref_unlocked(dev, fence);
++	drm_fence_usage_deref_unlocked(&fence);
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return ret;
 +}
 +
 +int drm_fence_flush_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	int ret;
 +	drm_fence_manager_t *fm = &dev->fm;
 +	drm_fence_arg_t arg;
 +	drm_fence_object_t *fence;
 +	unsigned long flags;
 +	ret = 0;
 +
 +	if (!fm->initialized) {
 +		DRM_ERROR("The DRM driver does not support fencing.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	fence = drm_lookup_fence_object(priv, arg.handle);
 +	if (!fence)
 +		return -EINVAL;
- 	ret = drm_fence_object_flush(dev, fence, arg.type);
++	ret = drm_fence_object_flush(fence, arg.type);
 +
 +	read_lock_irqsave(&fm->lock, flags);
 +	arg.class = fence->class;
 +	arg.type = fence->type;
 +	arg.signaled = fence->signaled;
 +	read_unlock_irqrestore(&fm->lock, flags);
- 	drm_fence_usage_deref_unlocked(dev, fence);
++	drm_fence_usage_deref_unlocked(&fence);
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return ret;
 +}
 +
 +
 +int drm_fence_wait_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	int ret;
 +	drm_fence_manager_t *fm = &dev->fm;
 +	drm_fence_arg_t arg;
 +	drm_fence_object_t *fence;
 +	unsigned long flags;
 +	ret = 0;
 +
 +	if (!fm->initialized) {
 +		DRM_ERROR("The DRM driver does not support fencing.\n");
  		return -EINVAL;
  	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	fence = drm_lookup_fence_object(priv, arg.handle);
 +	if (!fence)
 +		return -EINVAL;
- 	ret = drm_fence_object_wait(dev, fence,
++	ret = drm_fence_object_wait(fence,
 +				    arg.flags & DRM_FENCE_FLAG_WAIT_LAZY,
 +				    0, arg.type);
 +
 +	read_lock_irqsave(&fm->lock, flags);
 +	arg.class = fence->class;
 +	arg.type = fence->type;
 +	arg.signaled = fence->signaled;
 +	read_unlock_irqrestore(&fm->lock, flags);
- 	drm_fence_usage_deref_unlocked(dev, fence);
++	drm_fence_usage_deref_unlocked(&fence);
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return ret;
 +}
 +
 +
 +int drm_fence_emit_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	int ret;
 +	drm_fence_manager_t *fm = &dev->fm;
 +	drm_fence_arg_t arg;
 +	drm_fence_object_t *fence;
 +	unsigned long flags;
 +	ret = 0;
 +
 +	if (!fm->initialized) {
 +		DRM_ERROR("The DRM driver does not support fencing.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	LOCK_TEST_WITH_RETURN(dev, filp);
 +	fence = drm_lookup_fence_object(priv, arg.handle);
 +	if (!fence)
 +		return -EINVAL;
- 	ret = drm_fence_object_emit(dev, fence, arg.flags, arg.class,
++	ret = drm_fence_object_emit(fence, arg.flags, arg.class,
 +				    arg.type);
 +
 +	read_lock_irqsave(&fm->lock, flags);
 +	arg.class = fence->class;
 +	arg.type = fence->type;
 +	arg.signaled = fence->signaled;
 +	read_unlock_irqrestore(&fm->lock, flags);
- 	drm_fence_usage_deref_unlocked(dev, fence);
++	drm_fence_usage_deref_unlocked(&fence);
 +
 +	DRM_COPY_TO_USER_IOCTL((void __user *)data, arg, sizeof(arg));
 +	return ret;
 +}
 +
 +int drm_fence_buffers_ioctl(DRM_IOCTL_ARGS)
 +{
 +	DRM_DEVICE;
 +	int ret;
 +	drm_fence_manager_t *fm = &dev->fm;
 +	drm_fence_arg_t arg;
 +	drm_fence_object_t *fence;
 +	unsigned long flags;
 +	ret = 0;
 +
 +	if (!fm->initialized) {
 +		DRM_ERROR("The DRM driver does not support fencing.\n");
 +		return -EINVAL;
 +	}
 +
 +	DRM_COPY_FROM_USER_IOCTL(arg, (void __user *)data, sizeof(arg));
 +
 +	if (!dev->bm.initialized) {
 +		DRM_ERROR("Buffer object manager is not initialized\n");
 +		return -EINVAL;
 +	}
 +	LOCK_TEST_WITH_RETURN(dev, filp);
 +	ret = drm_fence_buffer_objects(priv, NULL, arg.flags,
 +				       NULL, &fence);
 +	if (ret)
 +		return ret;
 +	ret = drm_fence_add_user_object(priv, fence,
 +					arg.flags &
 +					DRM_FENCE_FLAG_SHAREABLE);
 +	if (ret)
 +		return ret;
 +	atomic_inc(&fence->usage);
 +	arg.handle = fence->base.hash.key;
 +
  	read_lock_irqsave(&fm->lock, flags);
  	arg.class = fence->class;
  	arg.type = fence->type;
diff-tree 694e1c5c3f768436651ddf95e11ab5a89ccc8ffa (from 04e4922c0c407a9f0cfe268f62130891e98fc682)
Author: Arthur Huillet <art...@fr...>
Date:   Wed Jul 11 02:35:10 2007 +0200

    Added support for PCIGART for PCI(E) cards. Bumped DRM interface patchlevel.

diff --git a/shared-core/nouveau_drm.h b/shared-core/nouveau_drm.h
index 0758991..7abe82e 100644
--- a/shared-core/nouveau_drm.h
+++ b/shared-core/nouveau_drm.h
@@ -25,7 +25,7 @@
 #ifndef __NOUVEAU_DRM_H__
 #define __NOUVEAU_DRM_H__
 
-#define NOUVEAU_DRM_HEADER_PATCHLEVEL 7
+#define NOUVEAU_DRM_HEADER_PATCHLEVEL 8
 
 typedef struct drm_nouveau_fifo_alloc {
 	uint32_t     fb_ctxdma_handle;
@@ -68,11 +68,14 @@ drm_nouveau_notifier_alloc_t;
 #define NOUVEAU_MEM_AGP			0x00000002
 #define NOUVEAU_MEM_FB_ACCEPTABLE	0x00000004
 #define NOUVEAU_MEM_AGP_ACCEPTABLE	0x00000008
-#define NOUVEAU_MEM_PINNED		0x00000010
-#define NOUVEAU_MEM_USER_BACKED		0x00000020
-#define NOUVEAU_MEM_MAPPED		0x00000040
-#define NOUVEAU_MEM_INSTANCE		0x00000080 /* internal */
-#define NOUVEAU_MEM_NOTIFIER            0x00000100 /* internal */
+#define NOUVEAU_MEM_PCI			0x00000010
+#define NOUVEAU_MEM_PCI_ACCEPTABLE	0x00000020
+#define NOUVEAU_MEM_PINNED		0x00000040
+#define NOUVEAU_MEM_USER_BACKED		0x00000080
+#define NOUVEAU_MEM_MAPPED		0x00000100
+#define NOUVEAU_MEM_INSTANCE		0x00000200 /* internal */
+#define NOUVEAU_MEM_NOTIFIER            0x00000400 /* internal */
+
 typedef struct drm_nouveau_mem_alloc {
 	int flags;
 	int alignment;
@@ -95,6 +98,7 @@ drm_nouveau_mem_free_t;
 #define NOUVEAU_GETPARAM_AGP_PHYSICAL    7
 #define NOUVEAU_GETPARAM_FB_SIZE         8
 #define NOUVEAU_GETPARAM_AGP_SIZE        9
+#define NOUVEAU_GETPARAM_PCI_PHYSICAL    10
 typedef struct drm_nouveau_getparam {
 	uint64_t param;
 	uint64_t value;
diff --git a/shared-core/nouveau_drv.h b/shared-core/nouveau_drv.h
index 12b78a7..ea03fe3 100644
--- a/shared-core/nouveau_drv.h
+++ b/shared-core/nouveau_drv.h
@@ -34,7 +34,7 @@
 
 #define DRIVER_MAJOR		0
 #define DRIVER_MINOR		0
-#define DRIVER_PATCHLEVEL	7
+#define DRIVER_PATCHLEVEL	8
 
 #define NOUVEAU_FAMILY   0x0000FFFF
 #define NOUVEAU_FLAGS    0xFFFF0000
@@ -229,6 +229,7 @@ typedef struct drm_nouveau_private {
 	struct mem_block *fb_heap;
 	struct mem_block *fb_nomap_heap;
 	struct mem_block *ramin_heap;
+	struct mem_block *pci_heap;
 
         /* context table pointed to be NV_PGRAPH_CHANNEL_CTX_TABLE (0x400780) */
         uint32_t ctx_table_size;
diff --git a/shared-core/nouveau_fifo.c b/shared-core/nouveau_fifo.c
index 4095a57..bc3a994 100644
--- a/shared-core/nouveau_fifo.c
+++ b/shared-core/nouveau_fifo.c
@@ -210,11 +210,19 @@ nouveau_fifo_cmdbuf_alloc(struct drm_dev
 	}
 
 	if (cb->flags & NOUVEAU_MEM_AGP) {
-		ret = nouveau_gpuobj_dma_new
-			(dev, channel, NV_CLASS_DMA_IN_MEMORY,
-			 cb->start - dev_priv->agp_phys,
-			 cb->size, NV_DMA_ACCESS_RO, NV_DMA_TARGET_AGP,
-			 &pushbuf);
+		DRM_DEBUG("Creating CB in AGP memory\n");
+		ret = nouveau_gpuobj_dma_new(dev, channel,
+				NV_CLASS_DMA_IN_MEMORY,
+				cb->start - dev_priv->agp_phys,
+				cb->size,
+				NV_DMA_ACCESS_RO, NV_DMA_TARGET_AGP, &pushbuf);
+	} else if ( cb->flags & NOUVEAU_MEM_PCI) {
+		DRM_DEBUG("Creating CB in PCI memory starting at virt 0x%08llx size %d\n", cb->start, cb->size);
+		ret = nouveau_gpuobj_dma_new(dev, channel,
+				NV_CLASS_DMA_IN_MEMORY,
+				cb->start,
+				cb->size,
+				NV_DMA_ACCESS_RO, NV_DMA_TARGET_PCI_NONLINEAR, &pushbuf);
 	} else if (dev_priv->card_type != NV_04) {
 		ret = nouveau_gpuobj_dma_new
 			(dev, channel, NV_CLASS_DMA_IN_MEMORY,
diff --git a/shared-core/nouveau_mem.c b/shared-core/nouveau_mem.c
index c75a935..79f94fd 100644
--- a/shared-core/nouveau_mem.c
+++ b/shared-core/nouveau_mem.c
@@ -211,6 +211,10 @@ void nouveau_mem_close(struct drm_device
 	drm_nouveau_private_t *dev_priv = dev->dev_private;
 	nouveau_mem_takedown(&dev_priv->agp_heap);
 	nouveau_mem_takedown(&dev_priv->fb_heap);
+	if ( dev_priv->pci_heap ) 
+		{
+		nouveau_mem_takedown(&dev_priv->pci_heap);
+		}
 }
 
 /* returns the amount of FB ram in bytes */
@@ -283,8 +287,10 @@ int nouveau_mem_init(struct drm_device *
 {
 	drm_nouveau_private_t *dev_priv = dev->dev_private;
 	uint32_t fb_size;
+	drm_scatter_gather_t sgreq;
 	dev_priv->agp_phys=0;
 	dev_priv->fb_phys=0;
+	sgreq . size = 4 << 20; //4MB of PCI scatter-gather zone
 
 	/* init AGP */
 	dev_priv->agp_heap=NULL;
@@ -340,8 +346,26 @@ int nouveau_mem_init(struct drm_device *
 		dev_priv->agp_phys		= info.aperture_base;
 		dev_priv->agp_available_size	= info.aperture_size;
 	}
+
+goto have_agp;
 no_agp:
+	dev_priv->pci_heap = NULL;
+	DRM_DEBUG("Allocating sg memory for PCI DMA\n");
+	if ( drm_sg_alloc(dev, &sgreq) )
+		{
+		DRM_ERROR("Unable to allocate 4MB of scatter-gather pages for PCI DMA!");
+		goto no_pci;
+		}
 
+	DRM_DEBUG("Got %d KiB\n", (dev->sg->pages * PAGE_SIZE) >> 10);
+	if ( nouveau_mem_init_heap(&dev_priv->pci_heap, dev->sg->virtual, dev->sg->pages * PAGE_SIZE))
+		{
+		DRM_ERROR("Unable to initialize pci_heap!");	
+		goto no_pci;
+		}
+
+no_pci:
+have_agp:
 	/* setup a mtrr over the FB */
 	dev_priv->fb_mtrr = drm_mtrr_add(drm_get_resource_start(dev, 1),
 					 nouveau_mem_fb_amount(dev),
@@ -405,29 +429,40 @@ struct mem_block* nouveau_mem_alloc(stru
 	if (size & (~PAGE_MASK))
 		size = ((size/PAGE_SIZE) + 1) * PAGE_SIZE;
 
-	if (flags&NOUVEAU_MEM_AGP) {
-		type=NOUVEAU_MEM_AGP;
-		block = nouveau_mem_alloc_block(dev_priv->agp_heap, size,
-						alignment, filp);
-		if (block) goto alloc_ok;
-	}
-	if (flags&(NOUVEAU_MEM_FB|NOUVEAU_MEM_FB_ACCEPTABLE)) {
-		type=NOUVEAU_MEM_FB;
-		if (!(flags&NOUVEAU_MEM_MAPPED)) {
-			block = nouveau_mem_alloc_block(dev_priv->fb_nomap_heap,
-							size, alignment, filp);
-			if (block) goto alloc_ok;
-		}
-		block = nouveau_mem_alloc_block(dev_priv->fb_heap, size,
-						alignment, filp);
-		if (block) goto alloc_ok;	
-	}
-	if (flags&NOUVEAU_MEM_AGP_ACCEPTABLE) {
-		type=NOUVEAU_MEM_AGP;
-		block = nouveau_mem_alloc_block(dev_priv->agp_heap, size,
-						alignment, filp);
-		if (block) goto alloc_ok;
-	}
+
+#define NOUVEAU_MEM_ALLOC_AGP {\
+		type=NOUVEAU_MEM_AGP;\
+                block = nouveau_mem_alloc_block(dev_priv->agp_heap, size,\
+                                                alignment, filp);\
+                if (block) goto alloc_ok;\
+	        }
+
+#define NOUVEAU_MEM_ALLOC_PCI {\
+                type = NOUVEAU_MEM_PCI;\
+                block = nouveau_mem_alloc_block(dev_priv->pci_heap, size, alignment, filp);\
+                if ( block ) goto alloc_ok;\
+	        }
+
+#define NOUVEAU_MEM_ALLOC_FB {\
+                type=NOUVEAU_MEM_FB;\
+                if (!(flags&NOUVEAU_MEM_MAPPED)) {\
+                        block = nouveau_mem_alloc_block(dev_priv->fb_nomap_heap,\
+                                                        size, alignment, filp); \
+                        if (block) goto alloc_ok;\
+                }\
+                block = nouveau_mem_alloc_block(dev_priv->fb_heap, size,\
+                                                alignment, filp);\
+                if (block) goto alloc_ok;\
+	        }
+
+
+	if (flags&NOUVEAU_MEM_FB) NOUVEAU_MEM_ALLOC_FB
+	if (flags&NOUVEAU_MEM_AGP) NOUVEAU_MEM_ALLOC_AGP
+	if (flags&NOUVEAU_MEM_PCI) NOUVEAU_MEM_ALLOC_PCI
+	if (flags&NOUVEAU_MEM_FB_ACCEPTABLE) NOUVEAU_MEM_ALLOC_FB
+	if (flags&NOUVEAU_MEM_AGP_ACCEPTABLE) NOUVEAU_MEM_ALLOC_AGP
+	if (flags&NOUVEAU_MEM_PCI_ACCEPTABLE) NOUVEAU_MEM_ALLOC_PCI
+
 
 	return NULL;
 
@@ -436,15 +471,19 @@ alloc_ok:
 
 	if (flags&NOUVEAU_MEM_MAPPED)
 	{
-		int ret;
+		int ret = 0;
 		block->flags|=NOUVEAU_MEM_MAPPED;
 
 		if (type == NOUVEAU_MEM_AGP)
 			ret = drm_addmap(dev, block->start - dev->agp->base, block->size, 
 					_DRM_AGP, 0, &block->map);
-		else
+		else if (type == NOUVEAU_MEM_FB)
 			ret = drm_addmap(dev, block->start, block->size,
 					_DRM_FRAME_BUFFER, 0, &block->map);
+		else if (type == NOUVEAU_MEM_PCI)
+			ret = drm_addmap(dev, block->start - (unsigned long int)dev->sg->virtual, block->size,
+					_DRM_SCATTER_GATHER, 0, &block->map);
+
 		if (ret) { 
 			nouveau_mem_free_block(block);
 			return NULL;
diff --git a/shared-core/nouveau_object.c b/shared-core/nouveau_object.c
index bf811b4..dcb29b4 100644
--- a/shared-core/nouveau_object.c
+++ b/shared-core/nouveau_object.c
@@ -515,6 +515,20 @@ nouveau_gpuobj_new_fake(drm_device_t *de
 	return 0;
 }
 
+
+static int
+nouveau_gpuobj_class_instmem_size(drm_device_t *dev, int class)
+{
+	drm_nouveau_private_t *dev_priv = dev->dev_private;
+
+	/*XXX: dodgy hack for now */
+	if (dev_priv->card_type >= NV_50)
+		return 24;
+	if (dev_priv->card_type >= NV_40)
+		return 32;
+	return 16;
+}
+
 /*
    DMA objects are used to reference a piece of memory in the
    framebuffer, PCI or AGP address space. Each object is 16 bytes big
@@ -528,31 +542,20 @@ nouveau_gpuobj_new_fake(drm_device_t *de
    17:16 target: 0 NV memory, 1 NV memory tiled, 2 PCI, 3 AGP
    31:20 dma adjust (bits 0-11 of the address)
    entry[1]
-   dma limit
-   entry[2]
+   dma limit (size of transfer)
+   entry[X]
    1     0 readonly, 1 readwrite
-   31:12 dma frame address (bits 12-31 of the address)
+   31:12 dma frame address of the page (bits 12-31 of the address)
+   entry[N]
+   page table terminator, same value as the first pte, as does nvidia
+   rivatv uses 0xffffffff
 
-   Non linear page tables seem to need a list of frame addresses afterwards,
-   the rivatv project has some info on this.   
+   Non linear page tables need a list of frame addresses afterwards,
+   the rivatv project has some info on this.
 
    The method below creates a DMA object in instance RAM and returns a handle
    to it that can be used to set up context objects.
 */
-
-static int
-nouveau_gpuobj_class_instmem_size(drm_device_t *dev, int class)
-{
-	drm_nouveau_private_t *dev_priv = dev->dev_private;
-
-	/*XXX: dodgy hack for now */
-	if (dev_priv->card_type >= NV_50)
-		return 24;
-	if (dev_priv->card_type >= NV_40)
-		return 32;
-	return 16;
-}
-
 int
 nouveau_gpuobj_dma_new(drm_device_t *dev, int channel, int class,
 		       uint64_t offset, uint64_t size, int access, int target,
@@ -560,13 +563,28 @@ nouveau_gpuobj_dma_new(drm_device_t *dev
 {
 	drm_nouveau_private_t *dev_priv = dev->dev_private;
 	int ret;
-
+	uint32_t is_scatter_gather = 0;
+	
 	DRM_DEBUG("ch%d class=0x%04x offset=0x%llx size=0x%llx\n",
 		  channel, class, offset, size);
 	DRM_DEBUG("access=%d target=%d\n", access, target);
 
+	switch (target) {
+        case NV_DMA_TARGET_AGP:
+                 offset += dev_priv->agp_phys;
+                 break;
+        case NV_DMA_TARGET_PCI_NONLINEAR:
+                /*assume the "offset" is a virtual memory address*/
+                is_scatter_gather = 1;
+                /*put back the right value*/
+                target = NV_DMA_TARGET_PCI;
+                break;
+        default:
+                break;
+        }
+	
 	ret = nouveau_gpuobj_new(dev, channel,
-				 nouveau_gpuobj_class_instmem_size(dev, class),
+				 is_scatter_gather ? ((((size + PAGE_SIZE - 1) / PAGE_SIZE) << 2) + 12) : nouveau_gpuobj_class_instmem_size(dev, class),
 				 16,
 				 NVOBJ_FLAG_ZERO_ALLOC | NVOBJ_FLAG_ZERO_FREE,
 				 gpuobj);
@@ -577,22 +595,53 @@ nouveau_gpuobj_dma_new(drm_device_t *dev
 
 	if (dev_priv->card_type < NV_50) {
 		uint32_t frame, adjust, pte_flags = 0;
-
-		if (target == NV_DMA_TARGET_AGP)
-			offset += dev_priv->agp_phys;
-		if (access != NV_DMA_ACCESS_RO)
-			pte_flags |= (1<<1);
-		frame  = offset & ~0x00000fff;
 		adjust = offset &  0x00000fff;
-
-		INSTANCE_WR(*gpuobj, 0, ((1<<12) | (1<<13) |
-					 (adjust << 20) |
+		if (access != NV_DMA_ACCESS_RO)
+				pte_flags |= (1<<1);
+		
+		if ( ! is_scatter_gather ) 
+			{
+			frame  = offset & ~0x00000fff;
+			
+			INSTANCE_WR(*gpuobj, 0, ((1<<12) | (1<<13) |
+					(adjust << 20) |
 					 (access << 14) |
 					 (target << 16) |
 					  class));
-		INSTANCE_WR(*gpuobj, 1, size - 1);
-		INSTANCE_WR(*gpuobj, 2, frame | pte_flags);
-		INSTANCE_WR(*gpuobj, 3, frame | pte_flags);
+			INSTANCE_WR(*gpuobj, 1, size - 1);
+			INSTANCE_WR(*gpuobj, 2, frame | pte_flags);
+			INSTANCE_WR(*gpuobj, 3, frame | pte_flags);
+			}
+		else 
+			{
+			uint32_t instance_offset;
+			uint32_t bus_addr;
+			size = (uint32_t) size;
+
+			DRM_DEBUG("Creating PCI DMA object using virtual zone starting at 0x%08x, size %d\n", (uint32_t) offset, (uint32_t)size);
+	                INSTANCE_WR(*gpuobj, 0, ((1<<12) | (0<<13) |
+                                (adjust << 20) |
+                                (access << 14) |
+                                (target << 16) |
+                                class));
+			INSTANCE_WR(*gpuobj, 1, size-1);
+
+			/*write starting at the third dword*/
+			instance_offset = 2;
+ 
+			/*for each PAGE, get its bus address, fill in the page table entry, and advance*/
+			while ( size > 0 ) {
+				bus_addr = (uint32_t) page_address(vmalloc_to_page((void *) (uint32_t) offset));
+				bus_addr |= (offset & ~PAGE_MASK);
+				bus_addr = virt_to_bus((void *)bus_addr);
+				frame = bus_addr & ~0x00000FFF;
+				INSTANCE_WR(*gpuobj, instance_offset, frame | pte_flags);
+				offset += PAGE_SIZE;
+				instance_offset ++;
+				size -= PAGE_SIZE;
+				}
+
+			}
 	} else {
 		INSTANCE_WR(*gpuobj, 0, 0x00190000 | class);
 		INSTANCE_WR(*gpuobj, 1, offset + size - 1);
@@ -804,24 +853,38 @@ nouveau_gpuobj_channel_init(drm_device_t
 		return ret;
 	}
 
-	/* non-AGP unimplemented */
-	if (dev_priv->agp_heap == NULL)
-		return 0;
-
-	/* GART ctxdma */
-	if ((ret = nouveau_gpuobj_dma_new(dev, channel, NV_CLASS_DMA_IN_MEMORY,
-					  0, dev_priv->agp_available_size,
-					  NV_DMA_ACCESS_RW, NV_DMA_TARGET_AGP,
-					  &tt))) {
-		DRM_ERROR("Error creating TT ctxdma: %d\n", ret);
-		return ret;
+	if (dev_priv->agp_heap) {
+		/* AGPGART ctxdma */
+		if ((ret = nouveau_gpuobj_dma_new(dev, channel, NV_CLASS_DMA_IN_MEMORY,
+						   0, dev_priv->agp_available_size,
+						   NV_DMA_ACCESS_RW,
+						   NV_DMA_TARGET_AGP, &tt))) {
+			DRM_ERROR("Error creating AGP TT ctxdma: %d\n", DRM_ERR(ENOMEM));
+			return DRM_ERR(ENOMEM);
+		}
+	
+		ret = nouveau_gpuobj_ref_add(dev, channel, tt_h, tt, NULL);
+		if (ret) {
+			DRM_ERROR("Error referencing AGP TT ctxdma: %d\n", ret);
+			return ret;
+		}
 	}
-
-	if ((ret = nouveau_gpuobj_ref_add(dev, channel, tt_h, tt, NULL))) {
-		DRM_ERROR("Error referencing TT ctxdma: %d\n", ret);
-		return ret;
+	else {
+		/*PCI*/
+		if((ret = nouveau_gpuobj_dma_new(dev, channel, NV_CLASS_DMA_IN_MEMORY,
+						   (unsigned int) dev->sg->virtual, dev->sg->pages * PAGE_SIZE,
+						   NV_DMA_ACCESS_RW,
+						   NV_DMA_TARGET_PCI_NONLINEAR, &tt))) {
+			DRM_ERROR("Error creating PCI TT ctxdma: %d\n", DRM_ERR(ENOMEM));
+			return DRM_ERR(ENOMEM);
+		}
+	
+		ret = nouveau_gpuobj_ref_add(dev, channel, tt_h, tt, NULL);
+		if (ret) {
+			DRM_ERROR("Error referencing PCI TT ctxdma: %d\n", ret);
+			return ret;
+		}
 	}
-
 	return 0;
 }
 
diff --git a/shared-core/nouveau_reg.h b/shared-core/nouveau_reg.h
index c2ebc71..a66d2d3 100644
--- a/shared-core/nouveau_reg.h
+++ b/shared-core/nouveau_reg.h
@@ -39,6 +39,8 @@
 #define NV_DMA_TARGET_VIDMEM 0
 #define NV_DMA_TARGET_PCI    2
 #define NV_DMA_TARGET_AGP    3
+/*The following is not a real value used by nvidia cards, it's changed by nouveau_object_dma_create*/
+#define NV_DMA_TARGET_PCI_NONLINEAR   8
 
 /* Some object classes we care about in the drm */
 #define NV_CLASS_DMA_FROM_MEMORY                           0x00000002
diff --git a/shared-core/nouveau_state.c b/shared-core/nouveau_state.c
index c51d7d5..14b33a4 100644
--- a/shared-core/nouveau_state.c
+++ b/shared-core/nouveau_state.c
@@ -348,6 +348,7 @@ void nouveau_preclose(drm_device_t * dev
 	nouveau_fifo_cleanup(dev, filp);
 	nouveau_mem_release(filp,dev_priv->fb_heap);
 	nouveau_mem_release(filp,dev_priv->agp_heap);
+	nouveau_mem_release(filp,dev_priv->pci_heap);
 }
 
 /* first module load, setup the mmio/fb mapping */
@@ -442,6 +443,15 @@ int nouveau_ioctl_getparam(DRM_IOCTL_ARG
 	case NOUVEAU_GETPARAM_AGP_PHYSICAL:
 		getparam.value=dev_priv->agp_phys;
 		break;
+	case NOUVEAU_GETPARAM_PCI_PHYSICAL:
+		if ( dev -> sg )
+			getparam.value=dev->sg->virtual;
+		else 
+		     {
+		     DRM_ERROR("Requested PCIGART address, while no PCIGART was created\n");
+		     DRM_ERR(EINVAL);
+		     }
+		break;
 	case NOUVEAU_GETPARAM_FB_SIZE:
 		getparam.value=dev_priv->fb_available_size;
 		break;
@@ -472,6 +482,8 @@ int nouveau_ioctl_setparam(DRM_IOCTL_ARG
 		switch (setparam.value) {
 		case NOUVEAU_MEM_AGP:
 		case NOUVEAU_MEM_FB:
+		case NOUVEAU_MEM_PCI:
+		case NOUVEAU_MEM_AGP | NOUVEAU_MEM_PCI_ACCEPTABLE:
 			break;
 		default:
 			DRM_ERROR("invalid CMDBUF_LOCATION value=%lld\n",
diff-tree 04e4922c0c407a9f0cfe268f62130891e98fc682 (from 023f7d9c0064f912415c92a85c3a9d722191909f)
Author: Arthur Huillet <art...@fr...>
Date:   Wed Jul 11 02:33:12 2007 +0200

    Made drm_sg_alloc accessible from inside the DRM - drm_sg_alloc_ioctl is the ioctl wrapper

diff --git a/bsd-core/drmP.h b/bsd-core/drmP.h
index 9ba3d50..6e05b58 100644
--- a/bsd-core/drmP.h
+++ b/bsd-core/drmP.h
@@ -915,6 +915,7 @@ int	drm_agp_unbind(drm_device_t *dev, dr
 
 /* Scatter Gather Support (drm_scatter.c) */
 void	drm_sg_cleanup(drm_sg_mem_t *entry);
+int	drm_sg_alloc(drm_device_t * dev, drm_scatter_gather_t * request);
 
 #ifdef __FreeBSD__
 /* sysctl support (drm_sysctl.h) */
@@ -989,7 +990,7 @@ int	drm_agp_unbind_ioctl(DRM_IOCTL_ARGS)
 int	drm_agp_bind_ioctl(DRM_IOCTL_ARGS);
 
 /* Scatter Gather Support (drm_scatter.c) */
-int	drm_sg_alloc(DRM_IOCTL_ARGS);
+int	drm_sg_alloc_ioctl(DRM_IOCTL_ARGS);
 int	drm_sg_free(DRM_IOCTL_ARGS);
 
 /* consistent PCI memory functions (drm_pci.c) */
diff --git a/bsd-core/drm_drv.c b/bsd-core/drm_drv.c
index baaeb43..069774c 100644
--- a/bsd-core/drm_drv.c
+++ b/bsd-core/drm_drv.c
@@ -117,7 +117,7 @@ static drm_ioctl_desc_t		  drm_ioctls[25
 	[DRM_IOCTL_NR(DRM_IOCTL_AGP_BIND)]      = { drm_agp_bind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
 	[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)]    = { drm_agp_unbind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
 
-	[DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)]      = { drm_sg_alloc,    DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
+	[DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)]      = { drm_sg_alloc_ioctl,    DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
 	[DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)]       = { drm_sg_free,     DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY },
 
 	[DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)]   = { drm_wait_vblank, 0 },
diff --git a/bsd-core/drm_scatter.c b/bsd-core/drm_scatter.c
index 9dc280a..46222f1 100644
--- a/bsd-core/drm_scatter.c
+++ b/bsd-core/drm_scatter.c
@@ -40,28 +40,20 @@ void drm_sg_cleanup(drm_sg_mem_t *entry)
 	free(entry, M_DRM);
 }
 
-int drm_sg_alloc(DRM_IOCTL_ARGS)
+int drm_sg_alloc(drm_device_t * dev, drm_scatter_gather_t * request)
 {
-	DRM_DEVICE;
-	drm_scatter_gather_t request;
 	drm_sg_mem_t *entry;
 	unsigned long pages;
-	int i;
-
-	DRM_DEBUG( "%s\n", __FUNCTION__ );
 
 	if ( dev->sg )
 		return EINVAL;
 
-	DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
-			     sizeof(request) );
-
 	entry = malloc(sizeof(*entry), M_DRM, M_WAITOK | M_ZERO);
 	if ( !entry )
 		return ENOMEM;
 
 	pages = round_page(request.size) / PAGE_SIZE;
-	DRM_DEBUG( "sg size=%ld pages=%ld\n", request.size, pages );
+	DRM_DEBUG( "sg size=%ld pages=%ld\n", request->size, pages );
 
 	entry->pages = pages;
 
@@ -86,11 +78,7 @@ int drm_sg_alloc(DRM_IOCTL_ARGS)
 	DRM_DEBUG( "sg alloc handle  = %08lx\n", entry->handle );
 
 	entry->virtual = (void *)entry->handle;
-	request.handle = entry->handle;
-
-	DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
-			   request,
-			   sizeof(request) );
+	request->handle = entry->handle;
 
 	DRM_LOCK();
 	if (dev->sg) {
@@ -101,6 +89,27 @@ int drm_sg_alloc(DRM_IOCTL_ARGS)
 	dev->sg = entry;
 	DRM_UNLOCK();
 
+}
+
+int drm_sg_alloc_ioctl(DRM_IOCTL_ARGS)
+{
+	DRM_DEVICE;
+	drm_scatter_gather_t request;
+	int ret;
+
+	DRM_DEBUG( "%s\n", __FUNCTION__ );
+
+
+	DRM_COPY_FROM_USER_IOCTL(request, (drm_scatter_gather_t *)data,
+			     sizeof(request) );
+
+	ret = drm_sg_alloc(dev, &request);
+	if ( ret ) return ret;
+
+	DRM_COPY_TO_USER_IOCTL( (drm_scatter_gather_t *)data,
+			   request,
+			   sizeof(request) );
+
 	return 0;
 }
 
diff --git a/linux-core/drmP.h b/linux-core/drmP.h
index c992c8d..c274f1f 100644
--- a/linux-core/drmP.h
+++ b/linux-core/drmP.h
@@ -1129,8 +1129,9 @@ extern int drm_proc_cleanup(int minor,
 
 				/* Scatter Gather Support (drm_scatter.h) */
 extern void drm_sg_cleanup(drm_sg_mem_t * entry);
-extern int drm_sg_alloc(struct inode *inode, struct file *filp,
+extern int drm_sg_alloc_ioctl(struct inode *inode, struct file *filp,
 			unsigned int cmd, unsigned long arg);
+extern int drm_sg_alloc(drm_device_t *dev, drm_scatter_gather_t * request);
 extern int drm_sg_free(struct inode *inode, struct file *filp,
 		       unsigned int cmd, unsigned long arg);
 
diff --git a/linux-core/drm_drv.c b/linux-core/drm_drv.c
index 6bbe7fc..0d446a1 100644
--- a/linux-core/drm_drv.c
+++ b/linux-core/drm_drv.c
@@ -113,7 +113,7 @@ static drm_ioctl_desc_t drm_ioctls[] = {
 	[DRM_IOCTL_NR(DRM_IOCTL_AGP_UNBIND)] = {drm_agp_unbind_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 #endif
 
-	[DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = {drm_sg_alloc, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
+	[DRM_IOCTL_NR(DRM_IOCTL_SG_ALLOC)] = {drm_sg_alloc_ioctl, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 	[DRM_IOCTL_NR(DRM_IOCTL_SG_FREE)] = {drm_sg_free, DRM_AUTH|DRM_MASTER|DRM_ROOT_ONLY},
 
 	[DRM_IOCTL_NR(DRM_IOCTL_WAIT_VBLANK)] = {drm_wait_vblank, 0},
diff --git a/linux-core/drm_scatter.c b/linux-core/drm_scatter.c
index e5c9f87..c0d6db2 100644
--- a/linux-core/drm_scatter.c
+++ b/linux-core/drm_scatter.c
@@ -55,6 +55,7 @@ void drm_sg_cleanup(drm_sg_mem_t * entry
 		 entry->pages * sizeof(*entry->pagelist), DRM_MEM_PAGES);
 	drm_free(entry, sizeof(*entry), DRM_MEM_SGLISTS);
 }
+EXPORT_SYMBOL(drm_sg_cleanup);
 
 #ifdef _LP64
 # define ScatterHandle(x) (unsigned int)((x >> 32) + (x & ((1L << 32) - 1)))
@@ -62,13 +63,8 @@ void drm_sg_cleanup(drm_sg_mem_t * entry
 # define ScatterHandle(x) (unsigned int)(x)
 #endif
 
-int drm_sg_alloc(struct inode *inode, struct file *filp,
-		 unsigned int cmd, unsigned long arg)
+int drm_sg_alloc(drm_device_t * dev, drm_scatter_gather_t * request)
 {
-	drm_file_t *priv = filp->private_data;
-	drm_device_t *dev = priv->head->dev;
-	drm_scatter_gather_t __user *argp = (void __user *)arg;
-	drm_scatter_gather_t request;
 	drm_sg_mem_t *entry;
 	unsigned long pages, i, j;
 
@@ -80,17 +76,13 @@ int drm_sg_alloc(struct inode *inode, st
 	if (dev->sg)
 		return -EINVAL;
 
-	if (copy_from_user(&request, argp, sizeof(request)))
-		return -EFAULT;
-
 	entry = drm_alloc(sizeof(*entry), DRM_MEM_SGLISTS);
 	if (!entry)
 		return -ENOMEM;
 
 	memset(entry, 0, sizeof(*entry));
-
-	pages = (request.size + PAGE_SIZE - 1) / PAGE_SIZE;
-	DRM_DEBUG("sg size=%ld pages=%ld\n", request.size, pages);
+	pages = (request->size + PAGE_SIZE - 1) / PAGE_SIZE;
+	DRM_DEBUG("sg size=%ld pages=%ld\n", request->size, pages);
 
 	entry->pages = pages;
 	entry->pagelist = drm_alloc(pages * sizeof(*entry->pagelist),
@@ -142,12 +134,7 @@ int drm_sg_alloc(struct inode *inode, st
 		SetPageReserved(entry->pagelist[j]);
 	}
 
-	request.handle = entry->handle;
-
-	if (copy_to_user(argp, &request, sizeof(request))) {
-		drm_sg_cleanup(entry);
-		return -EFAULT;
-	}
+	request->handle = entry->handle;
 
 	dev->sg = entry;
 
@@ -196,6 +183,32 @@ int drm_sg_alloc(struct inode *inode, st
       failed:
 	drm_sg_cleanup(entry);
 	return -ENOMEM;
+
+}
+EXPORT_SYMBOL(drm_sg_alloc);
+
+int drm_sg_alloc_ioctl(struct inode *inode, struct file *filp,
+		 unsigned int cmd, unsigned long arg)
+{
+	drm_file_t *priv = filp->private_data;
+	drm_scatter_gather_t __user *argp = (void __user *)arg;
+	drm_scatter_gather_t request;
+	int ret;
+
+	if (copy_from_user(&request, argp, sizeof(request)))
+		return -EFAULT;
+
+	ret = drm_sg_alloc(priv->head->dev, &request);
+	if ( ret ) return ret;
+
+	if (copy_to_user(argp, &request, sizeof(request))) {
+		drm_sg_cleanup(priv->head->dev->sg);
+		return -EFAULT;
+	}
+
+
+	return 0;
+
 }
 
 int drm_sg_free(struct inode *inode, struct file *filp,
diff-tree 023f7d9c0064f912415c92a85c3a9d722191909f (from 31e33813e8c1b085683e68524e680882368e59a9)
Author: Ben Skeggs <sk...@gm...>
Date:   Mon Jul 9 23:58:00 2007 +1000

    nouveau: Allocate mappable VRAM for notifiers..

diff --git a/shared-core/nouveau_fifo.c b/shared-core/nouveau_fifo.c
index c140a63..4095a57 100644
--- a/shared-core/nouveau_fifo.c
+++ b/shared-core/nouveau_fifo.c
@@ -497,10 +497,6 @@ static int nouveau_ioctl_fifo_alloc(DRM_
 	/* and the notifier block */
 	init.notifier      = chan->notifier_block->start;
 	init.notifier_size = chan->notifier_block->size;
-	res = drm_addmap(dev, init.notifier, init.notifier_size, _DRM_REGISTERS,
-			 0, &chan->notifier_map);
-	if (res != 0)
-		return res;
 
 	DRM_COPY_TO_USER_IOCTL((drm_nouveau_fifo_alloc_t __user *)data,
 			       init, sizeof(init));
diff --git a/shared-core/nouveau_notifier.c b/shared-core/nouveau_notifier.c
index 9e792e5..3021629 100644
--- a/shared-core/nouveau_notifier.c
+++ b/shared-core/nouveau_notifier.c
@@ -41,6 +41,7 @@...
 
[truncated message content]