/** * vmw_simple_resource_init - Initialize a simple resource object. * * @dev_priv: Pointer to a struct device private. * @simple: The struct vmw_simple_resource to initialize. * @data: Data passed to the information initialization function. * @res_free: Function pointer to destroy the simple resource. * * Returns: * 0 if succeeded. * Negative error value if error, in which case the resource will have been * freed. */ static int vmw_simple_resource_init(struct vmw_private *dev_priv, struct vmw_simple_resource *simple, void *data, void (*res_free)(struct vmw_resource *res)) { struct vmw_resource *res = &simple->res; int ret; ret = vmw_resource_init(dev_priv, res, false, res_free, &simple->func->res_func); if (ret) { res_free(res); return ret; } ret = simple->func->init(res, data); if (ret) { vmw_resource_unreference(&res); return ret; } simple->res.hw_destroy = simple->func->hw_destroy; return 0; }
/** * vmw_simple_resource_base_release - TTM object release callback * * @p_base: The struct ttm_base_object member of the simple resource object. * * Called when the last reference to the embedded struct ttm_base_object is * gone. Typically results in an object free, unless there are other * references to the embedded struct vmw_resource. */ static void vmw_simple_resource_base_release(struct ttm_base_object **p_base) { struct ttm_base_object *base = *p_base; struct vmw_user_simple_resource *usimple = container_of(base, struct vmw_user_simple_resource, base); struct vmw_resource *res = &usimple->simple.res; *p_base = NULL; vmw_resource_unreference(&res); }
static void vmw_resource_to_validate_list(struct vmw_sw_context *sw_context, struct vmw_resource **p_res) { struct vmw_resource *res = *p_res; if (list_empty(&res->validate_head)) { list_add_tail(&res->validate_head, &sw_context->resource_list); *p_res = NULL; } else vmw_resource_unreference(p_res); }
/** * vmw_stdu_unpin_display - unpins the resource associated with display surface * * @stdu: contains the display surface * * If the display surface was privatedly allocated by * vmw_surface_gb_priv_define() and not registered as a framebuffer, then it * won't be automatically cleaned up when all the framebuffers are freed. As * such, we have to explicitly call vmw_resource_unreference() to get it freed. */ static void vmw_stdu_unpin_display(struct vmw_screen_target_display_unit *stdu) { if (stdu->display_srf) { struct vmw_resource *res = &stdu->display_srf->res; vmw_resource_unpin(res); if (stdu->content_fb_type != SAME_AS_DISPLAY) { vmw_resource_unreference(&res); stdu->content_fb_type = SAME_AS_DISPLAY; } stdu->display_srf = NULL; } }
int vmw_overlay_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv) { struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; struct vmw_private *dev_priv = vmw_priv(dev); struct vmw_overlay *overlay = dev_priv->overlay_priv; struct drm_vmw_control_stream_arg *arg = (struct drm_vmw_control_stream_arg *)data; struct vmw_dma_buffer *buf; struct vmw_resource *res; int ret; if (!vmw_overlay_available(dev_priv)) return -ENOSYS; ret = vmw_user_stream_lookup(dev_priv, tfile, &arg->stream_id, &res); if (ret) return ret; mutex_lock(&overlay->mutex); if (!arg->enabled) { ret = vmw_overlay_stop(dev_priv, arg->stream_id, false, true); goto out_unlock; } ret = vmw_user_dmabuf_lookup(tfile, arg->handle, &buf, NULL); if (ret) goto out_unlock; ret = vmw_overlay_update_stream(dev_priv, buf, arg, true); vmw_dmabuf_unreference(&buf); out_unlock: mutex_unlock(&overlay->mutex); vmw_resource_unreference(&res); return ret; }
/** * vmw_simple_resource_create_ioctl - Helper to set up an ioctl function to * create a struct vmw_simple_resource. * * @dev: Pointer to a struct drm device. * @data: Ioctl argument. * @file_priv: Pointer to a struct drm_file identifying the caller. * @func: Pointer to a struct vmw_simple_resource_func identifying the * simple resource type. * * Returns: * 0 if success, * Negative error value on error. */ int vmw_simple_resource_create_ioctl(struct drm_device *dev, void *data, struct drm_file *file_priv, const struct vmw_simple_resource_func *func) { struct vmw_private *dev_priv = vmw_priv(dev); struct vmw_user_simple_resource *usimple; struct vmw_resource *res; struct vmw_resource *tmp; struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; struct ttm_operation_ctx ctx = { .interruptible = true, .no_wait_gpu = false }; size_t alloc_size; size_t account_size; int ret; alloc_size = offsetof(struct vmw_user_simple_resource, simple) + func->size; account_size = ttm_round_pot(alloc_size) + VMW_IDA_ACC_SIZE + TTM_OBJ_EXTRA_SIZE; ret = ttm_read_lock(&dev_priv->reservation_sem, true); if (ret) return ret; ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), account_size, &ctx); ttm_read_unlock(&dev_priv->reservation_sem); if (ret) { if (ret != -ERESTARTSYS) DRM_ERROR("Out of graphics memory for %s" " creation.\n", func->res_func.type_name); goto out_ret; } usimple = kzalloc(alloc_size, GFP_KERNEL); if (!usimple) { ttm_mem_global_free(vmw_mem_glob(dev_priv), account_size); ret = -ENOMEM; goto out_ret; } usimple->simple.func = func; usimple->account_size = account_size; res = &usimple->simple.res; usimple->base.shareable = false; usimple->base.tfile = NULL; /* * From here on, the destructor takes over resource freeing. */ ret = vmw_simple_resource_init(dev_priv, &usimple->simple, data, vmw_simple_resource_free); if (ret) goto out_ret; tmp = vmw_resource_reference(res); ret = ttm_base_object_init(tfile, &usimple->base, false, func->ttm_res_type, &vmw_simple_resource_base_release, NULL); if (ret) { vmw_resource_unreference(&tmp); goto out_err; } func->set_arg_handle(data, usimple->base.handle); out_err: vmw_resource_unreference(&res); out_ret: return ret; } /** * vmw_simple_resource_lookup - Look up a simple resource from its user-space * handle. * * @tfile: struct ttm_object_file identifying the caller. * @handle: The user-space handle. * @func: The struct vmw_simple_resource_func identifying the simple resource * type. * * Returns: Refcounted pointer to the embedded struct vmw_resource if * successfule. Error pointer otherwise. */ struct vmw_resource * vmw_simple_resource_lookup(struct ttm_object_file *tfile, uint32_t handle, const struct vmw_simple_resource_func *func) { struct vmw_user_simple_resource *usimple; struct ttm_base_object *base; struct vmw_resource *res; base = ttm_base_object_lookup(tfile, handle); if (!base) { DRM_ERROR("Invalid %s handle 0x%08lx.\n", func->res_func.type_name, (unsigned long) handle); return ERR_PTR(-ESRCH); } if (ttm_base_object_type(base) != func->ttm_res_type) { ttm_base_object_unref(&base); DRM_ERROR("Invalid type of %s handle 0x%08lx.\n", func->res_func.type_name, (unsigned long) handle); return ERR_PTR(-EINVAL); } usimple = container_of(base, typeof(*usimple), base); res = vmw_resource_reference(&usimple->simple.res); ttm_base_object_unref(&base); return res; }