Lines Matching refs:res
43 * @res: The resource
45 void vmw_resource_mob_attach(struct vmw_resource *res)
47 struct vmw_buffer_object *backup = res->backup;
50 dma_resv_assert_held(res->backup->base.base.resv);
51 res->used_prio = (res->res_dirty) ? res->func->dirty_prio :
52 res->func->prio;
62 new = (res->backup_offset < this->backup_offset) ?
66 rb_link_node(&res->mob_node, parent, new);
67 rb_insert_color(&res->mob_node, &backup->res_tree);
69 res->mob_attached = true;
71 vmw_bo_prio_add(backup, res->used_prio);
76 * @res: The resource
78 void vmw_resource_mob_detach(struct vmw_resource *res)
80 struct vmw_buffer_object *backup = res->backup;
83 if (vmw_resource_mob_attached(res)) {
84 res->mob_attached = false;
85 rb_erase(&res->mob_node, &backup->res_tree);
86 RB_CLEAR_NODE(&res->mob_node);
87 vmw_bo_prio_del(backup, res->used_prio);
91 struct vmw_resource *vmw_resource_reference(struct vmw_resource *res)
93 kref_get(&res->kref);
94 return res;
98 vmw_resource_reference_unless_doomed(struct vmw_resource *res)
100 return kref_get_unless_zero(&res->kref) ? res : NULL;
106 * @res: Pointer to the resource.
110 void vmw_resource_release_id(struct vmw_resource *res)
112 struct vmw_private *dev_priv = res->dev_priv;
113 struct idr *idr = &dev_priv->res_idr[res->func->res_type];
116 if (res->id != -1)
117 idr_remove(idr, res->id);
118 res->id = -1;
124 struct vmw_resource *res =
126 struct vmw_private *dev_priv = res->dev_priv;
128 struct idr *idr = &dev_priv->res_idr[res->func->res_type];
131 list_del_init(&res->lru_head);
133 if (res->backup) {
134 struct ttm_buffer_object *bo = &res->backup->base;
137 if (vmw_resource_mob_attached(res) &&
138 res->func->unbind != NULL) {
143 res->func->unbind(res, false, &val_buf);
145 res->backup_dirty = false;
146 vmw_resource_mob_detach(res);
147 if (res->dirty)
148 res->func->dirty_free(res);
149 if (res->coherent)
150 vmw_bo_dirty_release(res->backup);
152 vmw_bo_unreference(&res->backup);
155 if (likely(res->hw_destroy != NULL)) {
157 vmw_binding_res_list_kill(&res->binding_head);
159 res->hw_destroy(res);
162 id = res->id;
163 if (res->res_free != NULL)
164 res->res_free(res);
166 kfree(res);
176 struct vmw_resource *res = *p_res;
179 kref_put(&res->kref, vmw_resource_release);
186 * @res: Pointer to the resource.
189 * @res->id to that id. Returns 0 on success and -ENOMEM on failure.
191 int vmw_resource_alloc_id(struct vmw_resource *res)
193 struct vmw_private *dev_priv = res->dev_priv;
195 struct idr *idr = &dev_priv->res_idr[res->func->res_type];
197 BUG_ON(res->id != -1);
202 ret = idr_alloc(idr, res, 1, 0, GFP_NOWAIT);
204 res->id = ret;
215 * @res: The struct vmw_resource to initialize.
222 int vmw_resource_init(struct vmw_private *dev_priv, struct vmw_resource *res,
224 void (*res_free) (struct vmw_resource *res),
227 kref_init(&res->kref);
228 res->hw_destroy = NULL;
229 res->res_free = res_free;
230 res->dev_priv = dev_priv;
231 res->func = func;
232 RB_CLEAR_NODE(&res->mob_node);
233 INIT_LIST_HEAD(&res->lru_head);
234 INIT_LIST_HEAD(&res->binding_head);
235 res->id = -1;
236 res->backup = NULL;
237 res->backup_offset = 0;
238 res->backup_dirty = false;
239 res->res_dirty = false;
240 res->coherent = false;
241 res->used_prio = 3;
242 res->dirty = NULL;
246 return vmw_resource_alloc_id(res);
272 struct vmw_resource *res;
282 res = converter->base_obj_to_res(base);
283 kref_get(&res->kref);
285 *p_res = res;
340 struct vmw_resource *res;
347 &res);
349 *out_surf = vmw_res_to_srf(res);
361 * @res: The resource for which to allocate a backup buffer.
365 static int vmw_resource_buf_alloc(struct vmw_resource *res,
369 (res->backup_size + PAGE_SIZE - 1) & PAGE_MASK;
373 if (likely(res->backup)) {
374 BUG_ON(res->backup->base.num_pages * PAGE_SIZE < size);
382 ret = vmw_bo_init(res->dev_priv, backup, res->backup_size,
383 res->func->backup_placement,
389 res->backup = backup;
399 * @res: The resource to make visible to the device.
406 static int vmw_resource_do_validate(struct vmw_resource *res,
411 const struct vmw_res_func *func = res->func;
413 if (unlikely(res->id == -1)) {
414 ret = func->create(res);
420 ((func->needs_backup && !vmw_resource_mob_attached(res) &&
423 ret = func->bind(res, val_buf);
427 vmw_resource_mob_attach(res);
434 if (func->dirty_alloc && vmw_resource_mob_attached(res) &&
435 !res->coherent) {
436 if (res->backup->dirty && !res->dirty) {
437 ret = func->dirty_alloc(res);
440 } else if (!res->backup->dirty && res->dirty) {
441 func->dirty_free(res);
449 if (res->dirty) {
450 if (dirtying && !res->res_dirty) {
451 pgoff_t start = res->backup_offset >> PAGE_SHIFT;
453 (res->backup_offset + res->backup_size,
456 vmw_bo_dirty_unmap(res->backup, start, end);
459 vmw_bo_dirty_transfer_to_res(res);
460 return func->dirty_sync(res);
466 func->destroy(res);
475 * @res: Pointer to the struct vmw_resource to unreserve.
486 void vmw_resource_unreserve(struct vmw_resource *res,
493 struct vmw_private *dev_priv = res->dev_priv;
495 if (!list_empty(&res->lru_head))
498 if (switch_backup && new_backup != res->backup) {
499 if (res->backup) {
500 vmw_resource_mob_detach(res);
501 if (res->coherent)
502 vmw_bo_dirty_release(res->backup);
503 vmw_bo_unreference(&res->backup);
507 res->backup = vmw_bo_reference(new_backup);
513 WARN_ON(res->coherent && !new_backup->dirty);
515 vmw_resource_mob_attach(res);
517 res->backup = NULL;
519 } else if (switch_backup && res->coherent) {
520 vmw_bo_dirty_release(res->backup);
524 res->backup_offset = new_backup_offset;
527 res->res_dirty = dirty;
529 if (!res->func->may_evict || res->id == -1 || res->pin_count)
533 list_add_tail(&res->lru_head,
534 &res->dev_priv->res_lru[res->func->res_type]);
544 * @res: The resource for which to allocate a backup buffer.
552 struct vmw_resource *res,
561 if (unlikely(res->backup == NULL)) {
562 ret = vmw_resource_buf_alloc(res, interruptible);
568 ttm_bo_get(&res->backup->base);
569 val_buf->bo = &res->backup->base;
576 if (res->func->needs_backup && !vmw_resource_mob_attached(res))
579 res->backup_dirty;
580 ret = ttm_bo_validate(&res->backup->base,
581 res->func->backup_placement,
595 vmw_bo_unreference(&res->backup);
603 * @res: The resource to reserve.
610 int vmw_resource_reserve(struct vmw_resource *res, bool interruptible,
613 struct vmw_private *dev_priv = res->dev_priv;
617 list_del_init(&res->lru_head);
620 if (res->func->needs_backup && res->backup == NULL &&
622 ret = vmw_resource_buf_alloc(res, interruptible);
626 (unsigned long) res->backup_size);
662 * @res: The resource to evict.
666 struct vmw_resource *res, bool interruptible)
669 const struct vmw_res_func *func = res->func;
676 ret = vmw_resource_check_buffer(ticket, res, interruptible, &val_buf);
681 (!func->needs_backup || vmw_resource_mob_attached(res)))) {
682 ret = func->unbind(res, res->res_dirty, &val_buf);
685 vmw_resource_mob_detach(res);
687 ret = func->destroy(res);
688 res->backup_dirty = true;
689 res->res_dirty = false;
700 * @res: The resource to make visible to the device.
704 * On succesful return, any backup DMA buffer pointed to by @res->backup will
712 int vmw_resource_validate(struct vmw_resource *res, bool intr,
717 struct vmw_private *dev_priv = res->dev_priv;
718 struct list_head *lru_list = &dev_priv->res_lru[res->func->res_type];
722 if (!res->func->create)
727 if (res->backup)
728 val_buf.bo = &res->backup->base;
730 ret = vmw_resource_do_validate(res, &val_buf, dirtying);
735 if (list_empty(lru_list) || !res->func->may_evict) {
737 "for %s.\n", res->func->type_name);
768 else if (!res->func->needs_backup && res->backup) {
769 WARN_ON_ONCE(vmw_resource_mob_attached(res));
770 vmw_bo_unreference(&res->backup);
801 struct vmw_resource *res =
804 if (!WARN_ON_ONCE(!res->func->unbind))
805 (void) res->func->unbind(res, res->res_dirty, &val_buf);
807 res->backup_dirty = true;
808 res->res_dirty = false;
809 vmw_resource_mob_detach(res);
909 * @res: The resource being queried.
911 bool vmw_resource_needs_backup(const struct vmw_resource *res)
913 return res->func->needs_backup;
990 * @res: The resource to add a pin reference on
997 int vmw_resource_pin(struct vmw_resource *res, bool interruptible)
1000 struct vmw_private *dev_priv = res->dev_priv;
1005 ret = vmw_resource_reserve(res, interruptible, false);
1009 if (res->pin_count == 0) {
1012 if (res->backup) {
1013 vbo = res->backup;
1019 res->func->backup_placement,
1030 ret = vmw_resource_validate(res, interruptible, true);
1036 res->pin_count++;
1039 vmw_resource_unreserve(res, false, false, false, NULL, 0UL);
1050 * @res: The resource to remove a pin reference from
1055 void vmw_resource_unpin(struct vmw_resource *res)
1057 struct vmw_private *dev_priv = res->dev_priv;
1063 ret = vmw_resource_reserve(res, false, true);
1066 WARN_ON(res->pin_count == 0);
1067 if (--res->pin_count == 0 && res->backup) {
1068 struct vmw_buffer_object *vbo = res->backup;
1075 vmw_resource_unreserve(res, false, false, false, NULL, 0UL);
1084 * @res: Pointer to the resource
1086 enum vmw_res_type vmw_res_type(const struct vmw_resource *res)
1088 return res->func->res_type;
1094 * @res: The resource.
1098 void vmw_resource_dirty_update(struct vmw_resource *res, pgoff_t start,
1101 if (res->dirty)
1102 res->func->dirty_range_add(res, start << PAGE_SHIFT,
Indexes created Wed Oct 22 13:09:56 GMT 2025