if (!ring)
                        continue;
 
-               ret = msm_gem_get_iova(ring->bo, gpu->aspace, &ring->iova);
+               ret = msm_gem_get_and_pin_iova(ring->bo, gpu->aspace,
+                       &ring->iova);
                if (ret) {
                        ring->iova = 0;
                        DRM_DEV_ERROR(gpu->dev->dev,
 
                if (next_bo) {
                        /* take a obj ref + iova ref when we start scanning out: */
                        drm_gem_object_get(next_bo);
-                       msm_gem_get_iova(next_bo, kms->aspace, &iova);
+                       msm_gem_get_and_pin_iova(next_bo, kms->aspace, &iova);
 
                        /* enable cursor: */
                        mdp4_write(mdp4_kms, REG_MDP4_DMA_CURSOR_SIZE(dma),
        }
 
        if (cursor_bo) {
-               ret = msm_gem_get_iova(cursor_bo, kms->aspace, &iova);
+               ret = msm_gem_get_and_pin_iova(cursor_bo, kms->aspace, &iova);
                if (ret)
                        goto fail;
        } else {
 
                goto fail;
        }
 
-       ret = msm_gem_get_iova(mdp4_kms->blank_cursor_bo, kms->aspace,
+       ret = msm_gem_get_and_pin_iova(mdp4_kms->blank_cursor_bo, kms->aspace,
                        &mdp4_kms->blank_cursor_iova);
        if (ret) {
                DRM_DEV_ERROR(dev->dev, "could not pin blank-cursor bo: %d\n", ret);
 
        if (!cursor_bo)
                return -ENOENT;
 
-       ret = msm_gem_get_iova(cursor_bo, kms->aspace,
+       ret = msm_gem_get_and_pin_iova(cursor_bo, kms->aspace,
                        &mdp5_crtc->cursor.iova);
        if (ret)
                return -EINVAL;
 
        if (!dma_base)
                return -EINVAL;
 
-       return msm_gem_get_iova(msm_host->tx_gem_obj,
+       return msm_gem_get_and_pin_iova(msm_host->tx_gem_obj,
                                priv->kms->aspace, dma_base);
 }
 
 
        if (!priv->gpu)
                return -EINVAL;
 
+       /*
+        * Don't pin the memory here - just get an address so that userspace can
+        * be productive
+        */
        return msm_gem_get_iova(obj, priv->gpu->aspace, iova);
 }
 
 
 uint64_t msm_gem_mmap_offset(struct drm_gem_object *obj);
 int msm_gem_get_iova(struct drm_gem_object *obj,
                struct msm_gem_address_space *aspace, uint64_t *iova);
+int msm_gem_get_and_pin_iova(struct drm_gem_object *obj,
+               struct msm_gem_address_space *aspace, uint64_t *iova);
 uint64_t msm_gem_iova(struct drm_gem_object *obj,
                struct msm_gem_address_space *aspace);
 struct page **msm_gem_get_pages(struct drm_gem_object *obj);
 
        uint64_t iova;
 
        for (i = 0; i < n; i++) {
-               ret = msm_gem_get_iova(fb->obj[i], aspace, &iova);
+               ret = msm_gem_get_and_pin_iova(fb->obj[i], aspace, &iova);
                DBG("FB[%u]: iova[%d]: %08llx (%d)", fb->base.id, i, iova, ret);
                if (ret)
                        return ret;
 
         * in panic (ie. lock-safe, etc) we could avoid pinning the
         * buffer now:
         */
-       ret = msm_gem_get_iova(bo, priv->kms->aspace, &paddr);
+       ret = msm_gem_get_and_pin_iova(bo, priv->kms->aspace, &paddr);
        if (ret) {
                DRM_DEV_ERROR(dev->dev, "failed to get buffer obj iova: %d\n", ret);
                goto fail_unlock;
 
                        obj->size >> PAGE_SHIFT);
 }
 
-
-/* get iova, taking a reference.  Should have a matching put */
-int msm_gem_get_iova(struct drm_gem_object *obj,
+/* get iova and pin it. Should have a matching put */
+int msm_gem_get_and_pin_iova(struct drm_gem_object *obj,
                struct msm_gem_address_space *aspace, uint64_t *iova)
 {
        struct msm_gem_object *msm_obj = to_msm_bo(obj);
        return ret;
 }
 
+/* Get an iova but don't pin the memory behind it */
+int msm_gem_get_iova(struct drm_gem_object *obj,
+               struct msm_gem_address_space *aspace, uint64_t *iova)
+{
+       struct msm_gem_object *msm_obj = to_msm_bo(obj);
+       int ret;
+
+       mutex_lock(&msm_obj->lock);
+       ret = msm_gem_get_iova_locked(obj, aspace, iova);
+       mutex_unlock(&msm_obj->lock);
+
+       return ret;
+}
+
+
 /* get iova without taking a reference, used in places where you have
- * already done a 'msm_gem_get_iova()'.
+ * already done a 'msm_gem_get_and_pin_iova' or 'msm_gem_get_iova'
  */
 uint64_t msm_gem_iova(struct drm_gem_object *obj,
                struct msm_gem_address_space *aspace)
                return ERR_CAST(obj);
 
        if (iova) {
-               ret = msm_gem_get_iova(obj, aspace, iova);
+               ret = msm_gem_get_and_pin_iova(obj, aspace, iova);
                if (ret)
                        goto err;
        }
 
                uint64_t iova;
 
                /* if locking succeeded, pin bo: */
-               ret = msm_gem_get_iova(&msm_obj->base,
+               ret = msm_gem_get_and_pin_iova(&msm_obj->base,
                                submit->gpu->aspace, &iova);
 
                if (ret)
 
 
                /* submit takes a reference to the bo and iova until retired: */
                drm_gem_object_get(&msm_obj->base);
-               msm_gem_get_iova(&msm_obj->base,
+               msm_gem_get_and_pin_iova(&msm_obj->base,
                                submit->gpu->aspace, &iova);
 
                if (submit->bos[i].flags & MSM_SUBMIT_BO_WRITE)