.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
        .gem_prime_export   = drm_gem_prime_export,
        .gem_prime_import   = drm_gem_prime_import,
-       .gem_prime_res_obj  = etnaviv_gem_prime_res_obj,
        .gem_prime_pin      = etnaviv_gem_prime_pin,
        .gem_prime_unpin    = etnaviv_gem_prime_unpin,
        .gem_prime_get_sg_table = etnaviv_gem_prime_get_sg_table,
 
 void etnaviv_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr);
 int etnaviv_gem_prime_mmap(struct drm_gem_object *obj,
                           struct vm_area_struct *vma);
-struct reservation_object *etnaviv_gem_prime_res_obj(struct drm_gem_object *obj);
 struct drm_gem_object *etnaviv_gem_prime_import_sg_table(struct drm_device *dev,
        struct dma_buf_attachment *attach, struct sg_table *sg);
 int etnaviv_gem_prime_pin(struct drm_gem_object *obj);
 
        }
 
        if (op & ETNA_PREP_NOSYNC) {
-               if (!reservation_object_test_signaled_rcu(etnaviv_obj->resv,
+               if (!reservation_object_test_signaled_rcu(obj->resv,
                                                          write))
                        return -EBUSY;
        } else {
                unsigned long remain = etnaviv_timeout_to_jiffies(timeout);
 
-               ret = reservation_object_wait_timeout_rcu(etnaviv_obj->resv,
+               ret = reservation_object_wait_timeout_rcu(obj->resv,
                                                          write, true, remain);
                if (ret <= 0)
                        return ret == 0 ? -ETIMEDOUT : ret;
 static void etnaviv_gem_describe(struct drm_gem_object *obj, struct seq_file *m)
 {
        struct etnaviv_gem_object *etnaviv_obj = to_etnaviv_bo(obj);
-       struct reservation_object *robj = etnaviv_obj->resv;
+       struct reservation_object *robj = obj->resv;
        struct reservation_object_list *fobj;
        struct dma_fence *fence;
        unsigned long off = drm_vma_node_start(&obj->vma_node);
 
        drm_gem_free_mmap_offset(obj);
        etnaviv_obj->ops->release(etnaviv_obj);
-       if (etnaviv_obj->resv == &etnaviv_obj->_resv)
-               reservation_object_fini(&etnaviv_obj->_resv);
        drm_gem_object_release(obj);
 
        kfree(etnaviv_obj);
 
        etnaviv_obj->flags = flags;
        etnaviv_obj->ops = ops;
-       if (robj) {
-               etnaviv_obj->resv = robj;
-       } else {
-               etnaviv_obj->resv = &etnaviv_obj->_resv;
-               reservation_object_init(&etnaviv_obj->_resv);
-       }
+       if (robj)
+               etnaviv_obj->base.resv = robj;
 
        mutex_init(&etnaviv_obj->lock);
        INIT_LIST_HEAD(&etnaviv_obj->vram_list);
 
        struct sg_table *sgt;
        void *vaddr;
 
-       /* normally (resv == &_resv) except for imported bo's */
-       struct reservation_object *resv;
-       struct reservation_object _resv;
-
        struct list_head vram_list;
 
        /* cache maintenance */
 
 
        return ERR_PTR(ret);
 }
-
-struct reservation_object *etnaviv_gem_prime_res_obj(struct drm_gem_object *obj)
-{
-       struct etnaviv_gem_object *etnaviv_obj = to_etnaviv_bo(obj);
-
-       return etnaviv_obj->resv;
-}
 
 static void submit_unlock_object(struct etnaviv_gem_submit *submit, int i)
 {
        if (submit->bos[i].flags & BO_LOCKED) {
-               struct etnaviv_gem_object *etnaviv_obj = submit->bos[i].obj;
+               struct drm_gem_object *obj = &submit->bos[i].obj->base;
 
-               ww_mutex_unlock(&etnaviv_obj->resv->lock);
+               ww_mutex_unlock(&obj->resv->lock);
                submit->bos[i].flags &= ~BO_LOCKED;
        }
 }
 
 retry:
        for (i = 0; i < submit->nr_bos; i++) {
-               struct etnaviv_gem_object *etnaviv_obj = submit->bos[i].obj;
+               struct drm_gem_object *obj = &submit->bos[i].obj->base;
 
                if (slow_locked == i)
                        slow_locked = -1;
                contended = i;
 
                if (!(submit->bos[i].flags & BO_LOCKED)) {
-                       ret = ww_mutex_lock_interruptible(&etnaviv_obj->resv->lock,
+                       ret = ww_mutex_lock_interruptible(&obj->resv->lock,
                                                          ticket);
                        if (ret == -EALREADY)
                                DRM_ERROR("BO at index %u already on submit list\n",
                submit_unlock_object(submit, slow_locked);
 
        if (ret == -EDEADLK) {
-               struct etnaviv_gem_object *etnaviv_obj;
+               struct drm_gem_object *obj;
 
-               etnaviv_obj = submit->bos[contended].obj;
+               obj = &submit->bos[contended].obj->base;
 
                /* we lost out in a seqno race, lock and retry.. */
-               ret = ww_mutex_lock_slow_interruptible(&etnaviv_obj->resv->lock,
+               ret = ww_mutex_lock_slow_interruptible(&obj->resv->lock,
                                                       ticket);
                if (!ret) {
                        submit->bos[contended].flags |= BO_LOCKED;
 
        for (i = 0; i < submit->nr_bos; i++) {
                struct etnaviv_gem_submit_bo *bo = &submit->bos[i];
-               struct reservation_object *robj = bo->obj->resv;
+               struct reservation_object *robj = bo->obj->base.resv;
 
                if (!(bo->flags & ETNA_SUBMIT_BO_WRITE)) {
                        ret = reservation_object_reserve_shared(robj, 1);
        int i;
 
        for (i = 0; i < submit->nr_bos; i++) {
-               struct etnaviv_gem_object *etnaviv_obj = submit->bos[i].obj;
+               struct drm_gem_object *obj = &submit->bos[i].obj->base;
 
                if (submit->bos[i].flags & ETNA_SUBMIT_BO_WRITE)
-                       reservation_object_add_excl_fence(etnaviv_obj->resv,
+                       reservation_object_add_excl_fence(obj->resv,
                                                          submit->out_fence);
                else
-                       reservation_object_add_shared_fence(etnaviv_obj->resv,
+                       reservation_object_add_shared_fence(obj->resv,
                                                            submit->out_fence);
 
                submit_unlock_object(submit, i);