Adds an extra argument to nouveau_bo_new, which is only used in nouveau_prime.c.
Signed-off-by: Maarten Lankhorst <maarten.lankhorst@canonical.com>
        drm_mode_crtc_set_gamma_size(&nv_crtc->base, 256);
 
        ret = nouveau_bo_new(dev, 64*64*4, 0x100, TTM_PL_FLAG_VRAM,
-                            0, 0x0000, NULL, &nv_crtc->cursor.nvbo);
+                            0, 0x0000, NULL, NULL, &nv_crtc->cursor.nvbo);
        if (!ret) {
                ret = nouveau_bo_pin(nv_crtc->cursor.nvbo, TTM_PL_FLAG_VRAM);
                if (!ret) {
 
 int
 nouveau_bo_new(struct drm_device *dev, int size, int align,
               uint32_t flags, uint32_t tile_mode, uint32_t tile_flags,
-              struct sg_table *sg,
+              struct sg_table *sg, struct reservation_object *robj,
               struct nouveau_bo **pnvbo)
 {
        struct nouveau_drm *drm = nouveau_drm(dev);
        ret = ttm_bo_init(&drm->ttm.bdev, &nvbo->bo, size,
                          type, &nvbo->placement,
                          align >> PAGE_SHIFT, false, NULL, acc_size, sg,
-                         NULL, nouveau_bo_del_ttm);
+                         robj, nouveau_bo_del_ttm);
        if (ret) {
                /* ttm will call nouveau_bo_del_ttm if it fails.. */
                return ret;
 
 void nouveau_bo_move_init(struct nouveau_drm *);
 int  nouveau_bo_new(struct drm_device *, int size, int align, u32 flags,
                    u32 tile_mode, u32 tile_flags, struct sg_table *sg,
+                   struct reservation_object *robj,
                    struct nouveau_bo **);
 int  nouveau_bo_pin(struct nouveau_bo *, u32 flags);
 int  nouveau_bo_unpin(struct nouveau_bo *);
 
        if (nouveau_vram_pushbuf)
                target = TTM_PL_FLAG_VRAM;
 
-       ret = nouveau_bo_new(drm->dev, size, 0, target, 0, 0, NULL,
+       ret = nouveau_bo_new(drm->dev, size, 0, target, 0, 0, NULL, NULL,
                            &chan->push.buffer);
        if (ret == 0) {
                ret = nouveau_bo_pin(chan->push.buffer, target);
 
 
        work = kmalloc(sizeof(*work), GFP_KERNEL);
        if (!work) {
+               /*
+                * this might not be a nouveau fence any more,
+                * so force a lazy wait here
+                */
                WARN_ON(nouveau_fence_wait((struct nouveau_fence *)fence,
-                                          false, false));
+                                          true, false));
                goto err;
        }
 
 
                flags |= TTM_PL_FLAG_SYSTEM;
 
        ret = nouveau_bo_new(dev, size, align, flags, tile_mode,
-                            tile_flags, NULL, pnvbo);
+                            tile_flags, NULL, NULL, pnvbo);
        if (ret)
                return ret;
        nvbo = *pnvbo;
 
                                                         struct sg_table *sg)
 {
        struct nouveau_bo *nvbo;
+       struct reservation_object *robj = attach->dmabuf->resv;
        u32 flags = 0;
        int ret;
 
        flags = TTM_PL_FLAG_TT;
 
+       ww_mutex_lock(&robj->lock, NULL);
        ret = nouveau_bo_new(dev, attach->dmabuf->size, 0, flags, 0, 0,
-                            sg, &nvbo);
+                            sg, robj, &nvbo);
+       ww_mutex_unlock(&robj->lock);
        if (ret)
                return ERR_PTR(ret);
 
 
        spin_lock_init(&priv->lock);
 
        ret = nouveau_bo_new(drm->dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
-                            0, 0x0000, NULL, &priv->bo);
+                            0, 0x0000, NULL, NULL, &priv->bo);
        if (!ret) {
                ret = nouveau_bo_pin(priv->bo, TTM_PL_FLAG_VRAM);
                if (!ret) {
 
        drm_mode_crtc_set_gamma_size(crtc, 256);
 
        ret = nouveau_bo_new(dev, 8192, 0x100, TTM_PL_FLAG_VRAM,
-                            0, 0x0000, NULL, &head->base.lut.nvbo);
+                            0, 0x0000, NULL, NULL, &head->base.lut.nvbo);
        if (!ret) {
                ret = nouveau_bo_pin(head->base.lut.nvbo, TTM_PL_FLAG_VRAM);
                if (!ret) {
                goto out;
 
        ret = nouveau_bo_new(dev, 64 * 64 * 4, 0x100, TTM_PL_FLAG_VRAM,
-                            0, 0x0000, NULL, &head->base.cursor.nvbo);
+                            0, 0x0000, NULL, NULL, &head->base.cursor.nvbo);
        if (!ret) {
                ret = nouveau_bo_pin(head->base.cursor.nvbo, TTM_PL_FLAG_VRAM);
                if (!ret) {
 
        /* small shared memory area we use for notifiers and semaphores */
        ret = nouveau_bo_new(dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
-                            0, 0x0000, NULL, &disp->sync);
+                            0, 0x0000, NULL, NULL, &disp->sync);
        if (!ret) {
                ret = nouveau_bo_pin(disp->sync, TTM_PL_FLAG_VRAM);
                if (!ret) {
 
        spin_lock_init(&priv->lock);
 
        ret = nouveau_bo_new(drm->dev, 4096, 0x1000, TTM_PL_FLAG_VRAM,
-                            0, 0x0000, NULL, &priv->bo);
+                            0, 0x0000, NULL, NULL, &priv->bo);
        if (!ret) {
                ret = nouveau_bo_pin(priv->bo, TTM_PL_FLAG_VRAM);
                if (!ret) {
 
        priv->base.uevent = true;
 
        ret = nouveau_bo_new(drm->dev, 16 * priv->base.contexts, 0,
-                            TTM_PL_FLAG_VRAM, 0, 0, NULL, &priv->bo);
+                            TTM_PL_FLAG_VRAM, 0, 0, NULL, NULL, &priv->bo);
        if (ret == 0) {
                ret = nouveau_bo_pin(priv->bo, TTM_PL_FLAG_VRAM);
                if (ret == 0) {
 
        if (ret == 0)
                ret = nouveau_bo_new(drm->dev, 16 * priv->base.contexts, 0,
-                                    TTM_PL_FLAG_TT, 0, 0, NULL,
+                                    TTM_PL_FLAG_TT, 0, 0, NULL, NULL,
                                     &priv->bo_gart);
        if (ret == 0) {
                ret = nouveau_bo_pin(priv->bo_gart, TTM_PL_FLAG_TT);