Lines Matching refs:res
38 * @res: The resource
40 void vmw_resource_mob_attach(struct vmw_resource *res)
42 struct vmw_buffer_object *backup = res->backup;
45 dma_resv_assert_held(res->backup->base.base.resv);
46 res->used_prio = (res->res_dirty) ? res->func->dirty_prio :
47 res->func->prio;
54 new = (res->backup_offset < this->backup_offset) ?
58 rb_link_node(&res->mob_node, parent, new);
59 rb_insert_color(&res->mob_node, &backup->res_tree);
61 vmw_bo_prio_add(backup, res->used_prio);
66 * @res: The resource
68 void vmw_resource_mob_detach(struct vmw_resource *res)
70 struct vmw_buffer_object *backup = res->backup;
73 if (vmw_resource_mob_attached(res)) {
74 rb_erase(&res->mob_node, &backup->res_tree);
75 RB_CLEAR_NODE(&res->mob_node);
76 vmw_bo_prio_del(backup, res->used_prio);
80 struct vmw_resource *vmw_resource_reference(struct vmw_resource *res)
82 kref_get(&res->kref);
83 return res;
87 vmw_resource_reference_unless_doomed(struct vmw_resource *res)
89 return kref_get_unless_zero(&res->kref) ? res : NULL;
95 * @res: Pointer to the resource.
99 void vmw_resource_release_id(struct vmw_resource *res)
101 struct vmw_private *dev_priv = res->dev_priv;
102 struct idr *idr = &dev_priv->res_idr[res->func->res_type];
105 if (res->id != -1)
106 idr_remove(idr, res->id);
107 res->id = -1;
113 struct vmw_resource *res =
115 struct vmw_private *dev_priv = res->dev_priv;
117 struct idr *idr = &dev_priv->res_idr[res->func->res_type];
120 list_del_init(&res->lru_head);
122 if (res->backup) {
123 struct ttm_buffer_object *bo = &res->backup->base;
126 if (vmw_resource_mob_attached(res) &&
127 res->func->unbind != NULL) {
132 res->func->unbind(res, false, &val_buf);
134 res->backup_dirty = false;
135 vmw_resource_mob_detach(res);
136 if (res->dirty)
137 res->func->dirty_free(res);
138 if (res->coherent)
139 vmw_bo_dirty_release(res->backup);
141 vmw_bo_unreference(&res->backup);
144 if (likely(res->hw_destroy != NULL)) {
146 vmw_binding_res_list_kill(&res->binding_head);
148 res->hw_destroy(res);
151 id = res->id;
152 if (res->res_free != NULL)
153 res->res_free(res);
155 kfree(res);
165 struct vmw_resource *res = *p_res;
168 kref_put(&res->kref, vmw_resource_release);
175 * @res: Pointer to the resource.
178 * @res->id to that id. Returns 0 on success and -ENOMEM on failure.
180 int vmw_resource_alloc_id(struct vmw_resource *res)
182 struct vmw_private *dev_priv = res->dev_priv;
184 struct idr *idr = &dev_priv->res_idr[res->func->res_type];
186 BUG_ON(res->id != -1);
191 ret = idr_alloc(idr, res, 1, 0, GFP_NOWAIT);
193 res->id = ret;
204 * @res: The struct vmw_resource to initialize.
211 int vmw_resource_init(struct vmw_private *dev_priv, struct vmw_resource *res,
213 void (*res_free) (struct vmw_resource *res),
216 kref_init(&res->kref);
217 res->hw_destroy = NULL;
218 res->res_free = res_free;
219 res->dev_priv = dev_priv;
220 res->func = func;
221 RB_CLEAR_NODE(&res->mob_node);
222 INIT_LIST_HEAD(&res->lru_head);
223 INIT_LIST_HEAD(&res->binding_head);
224 res->id = -1;
225 res->backup = NULL;
226 res->backup_offset = 0;
227 res->backup_dirty = false;
228 res->res_dirty = false;
229 res->coherent = false;
230 res->used_prio = 3;
231 res->dirty = NULL;
235 return vmw_resource_alloc_id(res);
261 struct vmw_resource *res;
271 res = converter->base_obj_to_res(base);
272 kref_get(&res->kref);
274 *p_res = res;
329 struct vmw_resource *res;
336 &res);
338 *out_surf = vmw_res_to_srf(res);
350 * @res: The resource for which to allocate a backup buffer.
354 static int vmw_resource_buf_alloc(struct vmw_resource *res,
358 (res->backup_size + PAGE_SIZE - 1) & PAGE_MASK;
362 if (likely(res->backup)) {
363 BUG_ON(res->backup->base.num_pages * PAGE_SIZE < size);
371 ret = vmw_bo_init(res->dev_priv, backup, res->backup_size,
372 res->func->backup_placement,
378 res->backup = backup;
388 * @res: The resource to make visible to the device.
395 static int vmw_resource_do_validate(struct vmw_resource *res,
400 const struct vmw_res_func *func = res->func;
402 if (unlikely(res->id == -1)) {
403 ret = func->create(res);
409 ((func->needs_backup && !vmw_resource_mob_attached(res) &&
412 ret = func->bind(res, val_buf);
416 vmw_resource_mob_attach(res);
423 if (func->dirty_alloc && vmw_resource_mob_attached(res) &&
424 !res->coherent) {
425 if (res->backup->dirty && !res->dirty) {
426 ret = func->dirty_alloc(res);
429 } else if (!res->backup->dirty && res->dirty) {
430 func->dirty_free(res);
438 if (res->dirty) {
439 if (dirtying && !res->res_dirty) {
440 pgoff_t start = res->backup_offset >> PAGE_SHIFT;
442 (res->backup_offset + res->backup_size,
445 vmw_bo_dirty_unmap(res->backup, start, end);
448 vmw_bo_dirty_transfer_to_res(res);
449 return func->dirty_sync(res);
455 func->destroy(res);
464 * @res: Pointer to the struct vmw_resource to unreserve.
475 void vmw_resource_unreserve(struct vmw_resource *res,
482 struct vmw_private *dev_priv = res->dev_priv;
484 if (!list_empty(&res->lru_head))
487 if (switch_backup && new_backup != res->backup) {
488 if (res->backup) {
489 vmw_resource_mob_detach(res);
490 if (res->coherent)
491 vmw_bo_dirty_release(res->backup);
492 vmw_bo_unreference(&res->backup);
496 res->backup = vmw_bo_reference(new_backup);
502 WARN_ON(res->coherent && !new_backup->dirty);
504 vmw_resource_mob_attach(res);
506 res->backup = NULL;
508 } else if (switch_backup && res->coherent) {
509 vmw_bo_dirty_release(res->backup);
513 res->backup_offset = new_backup_offset;
516 res->res_dirty = dirty;
518 if (!res->func->may_evict || res->id == -1 || res->pin_count)
522 list_add_tail(&res->lru_head,
523 &res->dev_priv->res_lru[res->func->res_type]);
533 * @res: The resource for which to allocate a backup buffer.
541 struct vmw_resource *res,
550 if (unlikely(res->backup == NULL)) {
551 ret = vmw_resource_buf_alloc(res, interruptible);
557 ttm_bo_get(&res->backup->base);
558 val_buf->bo = &res->backup->base;
565 if (res->func->needs_backup && !vmw_resource_mob_attached(res))
568 backup_dirty = res->backup_dirty;
569 ret = ttm_bo_validate(&res->backup->base,
570 res->func->backup_placement,
584 vmw_bo_unreference(&res->backup);
592 * @res: The resource to reserve.
599 int vmw_resource_reserve(struct vmw_resource *res, bool interruptible,
602 struct vmw_private *dev_priv = res->dev_priv;
606 list_del_init(&res->lru_head);
609 if (res->func->needs_backup && res->backup == NULL &&
611 ret = vmw_resource_buf_alloc(res, interruptible);
615 (unsigned long) res->backup_size);
651 * @res: The resource to evict.
655 struct vmw_resource *res, bool interruptible)
658 const struct vmw_res_func *func = res->func;
665 ret = vmw_resource_check_buffer(ticket, res, interruptible, &val_buf);
670 (!func->needs_backup || vmw_resource_mob_attached(res)))) {
671 ret = func->unbind(res, res->res_dirty, &val_buf);
674 vmw_resource_mob_detach(res);
676 ret = func->destroy(res);
677 res->backup_dirty = true;
678 res->res_dirty = false;
689 * @res: The resource to make visible to the device.
693 * On succesful return, any backup DMA buffer pointed to by @res->backup will
701 int vmw_resource_validate(struct vmw_resource *res, bool intr,
706 struct vmw_private *dev_priv = res->dev_priv;
707 struct list_head *lru_list = &dev_priv->res_lru[res->func->res_type];
711 if (!res->func->create)
716 if (res->backup)
717 val_buf.bo = &res->backup->base;
719 ret = vmw_resource_do_validate(res, &val_buf, dirtying);
724 if (list_empty(lru_list) || !res->func->may_evict) {
726 "for %s.\n", res->func->type_name);
757 else if (!res->func->needs_backup && res->backup) {
758 WARN_ON_ONCE(vmw_resource_mob_attached(res));
759 vmw_bo_unreference(&res->backup);
790 struct vmw_resource *res =
793 if (!WARN_ON_ONCE(!res->func->unbind))
794 (void) res->func->unbind(res, res->res_dirty, &val_buf);
796 res->backup_dirty = true;
797 res->res_dirty = false;
798 vmw_resource_mob_detach(res);
898 * @res: The resource being queried.
900 bool vmw_resource_needs_backup(const struct vmw_resource *res)
902 return res->func->needs_backup;
979 * @res: The resource to add a pin reference on
986 int vmw_resource_pin(struct vmw_resource *res, bool interruptible)
989 struct vmw_private *dev_priv = res->dev_priv;
994 ret = vmw_resource_reserve(res, interruptible, false);
998 if (res->pin_count == 0) {
1001 if (res->backup) {
1002 vbo = res->backup;
1008 res->func->backup_placement,
1019 ret = vmw_resource_validate(res, interruptible, true);
1025 res->pin_count++;
1028 vmw_resource_unreserve(res, false, false, false, NULL, 0UL);
1039 * @res: The resource to remove a pin reference from
1044 void vmw_resource_unpin(struct vmw_resource *res)
1046 struct vmw_private *dev_priv = res->dev_priv;
1052 ret = vmw_resource_reserve(res, false, true);
1055 WARN_ON(res->pin_count == 0);
1056 if (--res->pin_count == 0 && res->backup) {
1057 struct vmw_buffer_object *vbo = res->backup;
1064 vmw_resource_unreserve(res, false, false, false, NULL, 0UL);
1073 * @res: Pointer to the resource
1075 enum vmw_res_type vmw_res_type(const struct vmw_resource *res)
1077 return res->func->res_type;
1083 * @res: The resource.
1087 void vmw_resource_dirty_update(struct vmw_resource *res, pgoff_t start,
1090 if (res->dirty)
1091 res->func->dirty_range_add(res, start << PAGE_SHIFT,