if (obj->base.name)
                seq_printf(m, " (name: %d)", obj->base.name);
        list_for_each_entry(vma, &obj->vma_list, obj_link) {
-               if (vma->pin_count > 0)
+               if (i915_vma_is_pinned(vma))
                        pin_count++;
        }
        seq_printf(m, " (pinned x %d)", pin_count);
 
        pinned = 0;
        mutex_lock(&dev->struct_mutex);
        list_for_each_entry(vma, &ggtt->base.active_list, vm_link)
-               if (vma->pin_count)
+               if (i915_vma_is_pinned(vma))
                        pinned += vma->node.size;
        list_for_each_entry(vma, &ggtt->base.inactive_list, vm_link)
-               if (vma->pin_count)
+               if (i915_vma_is_pinned(vma))
                        pinned += vma->node.size;
        mutex_unlock(&dev->struct_mutex);
 
 
 static void __i915_vma_iounmap(struct i915_vma *vma)
 {
-       GEM_BUG_ON(vma->pin_count);
+       GEM_BUG_ON(i915_vma_is_pinned(vma));
 
        if (vma->iomap == NULL)
                return;
                 * take a pin on the vma so that the second unbind is
                 * aborted.
                 */
-               vma->pin_count++;
+               __i915_vma_pin(vma);
 
                for_each_active(active, idx) {
                        ret = i915_gem_active_retire(&vma->last_read[idx],
                                break;
                }
 
-               vma->pin_count--;
+               __i915_vma_unpin(vma);
                if (ret)
                        return ret;
 
                GEM_BUG_ON(i915_vma_is_active(vma));
        }
 
-       if (vma->pin_count)
+       if (i915_vma_is_pinned(vma))
                return -EBUSY;
 
        if (!drm_mm_node_allocated(&vma->node))
                if (!drm_mm_node_allocated(&vma->node))
                        continue;
 
-               if (vma->pin_count) {
+               if (i915_vma_is_pinned(vma)) {
                        DRM_DEBUG("can not change the cache level of pinned objects\n");
                        return -EBUSY;
                }
                          i915_gem_obj_to_vma(obj, vm);
 
        if (vma) {
-               if (WARN_ON(vma->pin_count == DRM_I915_GEM_OBJECT_MAX_PIN_COUNT))
+               if (WARN_ON(i915_vma_pin_count(vma) == DRM_I915_GEM_OBJECT_MAX_PIN_COUNT))
                        return -EBUSY;
 
                if (i915_vma_misplaced(vma, size, alignment, flags)) {
-                       WARN(vma->pin_count,
+                       WARN(i915_vma_is_pinned(vma),
                             "bo is already pinned in %s with incorrect alignment:"
                             " offset=%08x %08x, req.alignment=%llx, req.map_and_fenceable=%d,"
                             " obj->map_and_fenceable=%d\n",
 
        GEM_BUG_ON(i915_vma_misplaced(vma, size, alignment, flags));
 
-       vma->pin_count++;
+       __i915_vma_pin(vma);
        return 0;
 }
 
 {
        struct i915_vma *vma = i915_gem_obj_to_ggtt_view(obj, view);
 
-       WARN_ON(vma->pin_count == 0);
+       WARN_ON(!i915_vma_is_pinned(vma));
        WARN_ON(!i915_gem_obj_ggtt_bound_view(obj, view));
 
-       --vma->pin_count;
+       __i915_vma_unpin(vma);
 }
 
 int
 {
        struct i915_vma *vma;
        list_for_each_entry(vma, &obj->vma_list, obj_link)
-               if (vma->pin_count > 0)
+               if (i915_vma_is_pinned(vma))
                        return true;
 
        return false;
 
 static bool
 mark_free(struct i915_vma *vma, struct list_head *unwind)
 {
-       if (vma->pin_count)
+       if (i915_vma_is_pinned(vma))
                return false;
 
        if (WARN_ON(!list_empty(&vma->exec_list)))
         */
        list_for_each_entry_safe(vma, next, &eviction_list, exec_list) {
                if (drm_mm_scan_remove_block(&vma->node))
-                       vma->pin_count++;
+                       __i915_vma_pin(vma);
                else
                        list_del_init(&vma->exec_list);
        }
                                       exec_list);
 
                list_del_init(&vma->exec_list);
-               vma->pin_count--;
+               __i915_vma_unpin(vma);
                if (ret == 0)
                        ret = i915_vma_unbind(vma);
        }
 
                vma = container_of(node, typeof(*vma), node);
 
-               if (vma->pin_count) {
-                       if (!vma->exec_entry || (vma->pin_count > 1))
+               if (i915_vma_is_pinned(vma)) {
+                       if (!vma->exec_entry || i915_vma_pin_count(vma) > 1)
                                /* Object is pinned for some other use */
                                return -EBUSY;
 
        }
 
        list_for_each_entry_safe(vma, next, &vm->inactive_list, vm_link)
-               if (vma->pin_count == 0)
+               if (!i915_vma_is_pinned(vma))
                        WARN_ON(i915_vma_unbind(vma));
 
        return 0;
 
                i915_gem_object_unpin_fence(obj);
 
        if (entry->flags & __EXEC_OBJECT_HAS_PIN)
-               vma->pin_count--;
+               __i915_vma_unpin(vma);
 
        entry->flags &= ~(__EXEC_OBJECT_HAS_FENCE | __EXEC_OBJECT_HAS_PIN);
 }
 
 
                WARN_ON(!ggtt_vma ||
                        dev_priv->fence_regs[obj->fence_reg].pin_count >
-                       ggtt_vma->pin_count);
+                       i915_vma_pin_count(ggtt_vma));
                dev_priv->fence_regs[obj->fence_reg].pin_count++;
                return true;
        } else
 
                return;
 
        list_move_tail(&vma->vm_link, &vma->vm->inactive_list);
-       if (unlikely(vma->closed && !vma->pin_count))
+       if (unlikely(vma->closed && !i915_vma_is_pinned(vma)))
                WARN_ON(i915_vma_unbind(vma));
 }
 
        vma->closed = true;
 
        list_del_init(&vma->obj_link);
-       if (!i915_vma_is_active(vma) && !vma->pin_count)
+       if (!i915_vma_is_active(vma) && !i915_vma_is_pinned(vma))
                WARN_ON(i915_vma_unbind(vma));
 }
 
 
        if (vma->bound == 0 && vma->vm->allocate_va_range) {
                /* XXX: i915_vma_pin() will fix this +- hack */
-               vma->pin_count++;
+               __i915_vma_pin(vma);
                trace_i915_va_alloc(vma);
                ret = vma->vm->allocate_va_range(vma->vm,
                                                 vma->node.start,
                                                 vma->node.size);
-               vma->pin_count--;
+               __i915_vma_unpin(vma);
                if (ret)
                        return ret;
        }
                vma->iomap = ptr;
        }
 
-       vma->pin_count++;
+       __i915_vma_pin(vma);
        return ptr;
 }
 
        return true;
 }
 
+static inline int i915_vma_pin_count(const struct i915_vma *vma)
+{
+       return vma->pin_count;
+}
+
+static inline bool i915_vma_is_pinned(const struct i915_vma *vma)
+{
+       return i915_vma_pin_count(vma);
+}
+
+static inline void __i915_vma_pin(struct i915_vma *vma)
+{
+       vma->pin_count++;
+       GEM_BUG_ON(!i915_vma_is_pinned(vma));
+}
+
+static inline void __i915_vma_unpin(struct i915_vma *vma)
+{
+       GEM_BUG_ON(!i915_vma_is_pinned(vma));
+       vma->pin_count--;
+}
+
+static inline void i915_vma_unpin(struct i915_vma *vma)
+{
+       GEM_BUG_ON(!drm_mm_node_allocated(&vma->node));
+       __i915_vma_unpin(vma);
+}
+
 /**
  * i915_vma_pin_iomap - calls ioremap_wc to map the GGTT VMA via the aperture
  * @vma: VMA to iomap
 static inline void i915_vma_unpin_iomap(struct i915_vma *vma)
 {
        lockdep_assert_held(&vma->vm->dev->struct_mutex);
-       GEM_BUG_ON(vma->pin_count == 0);
        GEM_BUG_ON(vma->iomap == NULL);
-       vma->pin_count--;
+       i915_vma_unpin(vma);
 }
 
 #endif
 
                        break;
 
                list_for_each_entry(vma, &obj->vma_list, obj_link)
-                       if (vma->vm == vm && vma->pin_count > 0)
+                       if (vma->vm == vm && i915_vma_is_pinned(vma))
                                capture_bo(err++, vma);
        }
 
 
        list_for_each_entry(obj, &dev_priv->mm.bound_list, global_list) {
                list_for_each_entry(vma, &obj->vma_list, obj_link)
-                       if (vma->vm == vm && vma->pin_count > 0)
+                       if (vma->vm == vm && i915_vma_is_pinned(vma))
                                i++;
        }
        error->pinned_bo_count[ndx] = i - error->active_bo_count[ndx];