![Thomas Hellstrom](/assets/img/avatar_default.png)
Add a resource-private header for common resource definitions Signed-off-by: Thomas Hellstrom <thellstrom@vmware.com> Reviewed-by: Brian Paul <brianp@vmware.com> Reviewed-by: Dmitry Torokhov <dtor@vmware.com> Signed-off-by: Dave Airlie <airlied@redhat.com>
275 lines
7.3 KiB
C
275 lines
7.3 KiB
C
/**************************************************************************
|
|
*
|
|
* Copyright © 2009-2012 VMware, Inc., Palo Alto, CA., USA
|
|
* All Rights Reserved.
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
* copy of this software and associated documentation files (the
|
|
* "Software"), to deal in the Software without restriction, including
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
* distribute, sub license, and/or sell copies of the Software, and to
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
* the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice (including the
|
|
* next paragraph) shall be included in all copies or substantial portions
|
|
* of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
|
|
* THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
|
|
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
|
|
* OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
|
|
* USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
*
|
|
**************************************************************************/
|
|
|
|
#include "vmwgfx_drv.h"
|
|
#include "vmwgfx_resource_priv.h"
|
|
#include "ttm/ttm_placement.h"
|
|
|
|
struct vmw_user_context {
|
|
struct ttm_base_object base;
|
|
struct vmw_resource res;
|
|
};
|
|
|
|
static void vmw_user_context_free(struct vmw_resource *res);
|
|
static struct vmw_resource *
|
|
vmw_user_context_base_to_res(struct ttm_base_object *base);
|
|
|
|
static uint64_t vmw_user_context_size;
|
|
|
|
static const struct vmw_user_resource_conv user_context_conv = {
|
|
.object_type = VMW_RES_CONTEXT,
|
|
.base_obj_to_res = vmw_user_context_base_to_res,
|
|
.res_free = vmw_user_context_free
|
|
};
|
|
|
|
const struct vmw_user_resource_conv *user_context_converter =
|
|
&user_context_conv;
|
|
|
|
|
|
static const struct vmw_res_func vmw_legacy_context_func = {
|
|
.res_type = vmw_res_context,
|
|
.needs_backup = false,
|
|
.may_evict = false,
|
|
.type_name = "legacy contexts",
|
|
.backup_placement = NULL,
|
|
.create = NULL,
|
|
.destroy = NULL,
|
|
.bind = NULL,
|
|
.unbind = NULL
|
|
};
|
|
|
|
/**
|
|
* Context management:
|
|
*/
|
|
|
|
static void vmw_hw_context_destroy(struct vmw_resource *res)
|
|
{
|
|
|
|
struct vmw_private *dev_priv = res->dev_priv;
|
|
struct {
|
|
SVGA3dCmdHeader header;
|
|
SVGA3dCmdDestroyContext body;
|
|
} *cmd;
|
|
|
|
|
|
vmw_execbuf_release_pinned_bo(dev_priv);
|
|
cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
|
|
if (unlikely(cmd == NULL)) {
|
|
DRM_ERROR("Failed reserving FIFO space for surface "
|
|
"destruction.\n");
|
|
return;
|
|
}
|
|
|
|
cmd->header.id = cpu_to_le32(SVGA_3D_CMD_CONTEXT_DESTROY);
|
|
cmd->header.size = cpu_to_le32(sizeof(cmd->body));
|
|
cmd->body.cid = cpu_to_le32(res->id);
|
|
|
|
vmw_fifo_commit(dev_priv, sizeof(*cmd));
|
|
vmw_3d_resource_dec(dev_priv, false);
|
|
}
|
|
|
|
static int vmw_context_init(struct vmw_private *dev_priv,
|
|
struct vmw_resource *res,
|
|
void (*res_free) (struct vmw_resource *res))
|
|
{
|
|
int ret;
|
|
|
|
struct {
|
|
SVGA3dCmdHeader header;
|
|
SVGA3dCmdDefineContext body;
|
|
} *cmd;
|
|
|
|
ret = vmw_resource_init(dev_priv, res, false,
|
|
res_free, &vmw_legacy_context_func);
|
|
|
|
if (unlikely(ret != 0)) {
|
|
DRM_ERROR("Failed to allocate a resource id.\n");
|
|
goto out_early;
|
|
}
|
|
|
|
if (unlikely(res->id >= SVGA3D_MAX_CONTEXT_IDS)) {
|
|
DRM_ERROR("Out of hw context ids.\n");
|
|
vmw_resource_unreference(&res);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
|
|
if (unlikely(cmd == NULL)) {
|
|
DRM_ERROR("Fifo reserve failed.\n");
|
|
vmw_resource_unreference(&res);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
cmd->header.id = cpu_to_le32(SVGA_3D_CMD_CONTEXT_DEFINE);
|
|
cmd->header.size = cpu_to_le32(sizeof(cmd->body));
|
|
cmd->body.cid = cpu_to_le32(res->id);
|
|
|
|
vmw_fifo_commit(dev_priv, sizeof(*cmd));
|
|
(void) vmw_3d_resource_inc(dev_priv, false);
|
|
vmw_resource_activate(res, vmw_hw_context_destroy);
|
|
return 0;
|
|
|
|
out_early:
|
|
if (res_free == NULL)
|
|
kfree(res);
|
|
else
|
|
res_free(res);
|
|
return ret;
|
|
}
|
|
|
|
struct vmw_resource *vmw_context_alloc(struct vmw_private *dev_priv)
|
|
{
|
|
struct vmw_resource *res = kmalloc(sizeof(*res), GFP_KERNEL);
|
|
int ret;
|
|
|
|
if (unlikely(res == NULL))
|
|
return NULL;
|
|
|
|
ret = vmw_context_init(dev_priv, res, NULL);
|
|
|
|
return (ret == 0) ? res : NULL;
|
|
}
|
|
|
|
/**
|
|
* User-space context management:
|
|
*/
|
|
|
|
static struct vmw_resource *
|
|
vmw_user_context_base_to_res(struct ttm_base_object *base)
|
|
{
|
|
return &(container_of(base, struct vmw_user_context, base)->res);
|
|
}
|
|
|
|
static void vmw_user_context_free(struct vmw_resource *res)
|
|
{
|
|
struct vmw_user_context *ctx =
|
|
container_of(res, struct vmw_user_context, res);
|
|
struct vmw_private *dev_priv = res->dev_priv;
|
|
|
|
ttm_base_object_kfree(ctx, base);
|
|
ttm_mem_global_free(vmw_mem_glob(dev_priv),
|
|
vmw_user_context_size);
|
|
}
|
|
|
|
/**
|
|
* This function is called when user space has no more references on the
|
|
* base object. It releases the base-object's reference on the resource object.
|
|
*/
|
|
|
|
static void vmw_user_context_base_release(struct ttm_base_object **p_base)
|
|
{
|
|
struct ttm_base_object *base = *p_base;
|
|
struct vmw_user_context *ctx =
|
|
container_of(base, struct vmw_user_context, base);
|
|
struct vmw_resource *res = &ctx->res;
|
|
|
|
*p_base = NULL;
|
|
vmw_resource_unreference(&res);
|
|
}
|
|
|
|
int vmw_context_destroy_ioctl(struct drm_device *dev, void *data,
|
|
struct drm_file *file_priv)
|
|
{
|
|
struct drm_vmw_context_arg *arg = (struct drm_vmw_context_arg *)data;
|
|
struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
|
|
|
|
return ttm_ref_object_base_unref(tfile, arg->cid, TTM_REF_USAGE);
|
|
}
|
|
|
|
int vmw_context_define_ioctl(struct drm_device *dev, void *data,
|
|
struct drm_file *file_priv)
|
|
{
|
|
struct vmw_private *dev_priv = vmw_priv(dev);
|
|
struct vmw_user_context *ctx;
|
|
struct vmw_resource *res;
|
|
struct vmw_resource *tmp;
|
|
struct drm_vmw_context_arg *arg = (struct drm_vmw_context_arg *)data;
|
|
struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
|
|
struct vmw_master *vmaster = vmw_master(file_priv->master);
|
|
int ret;
|
|
|
|
|
|
/*
|
|
* Approximate idr memory usage with 128 bytes. It will be limited
|
|
* by maximum number_of contexts anyway.
|
|
*/
|
|
|
|
if (unlikely(vmw_user_context_size == 0))
|
|
vmw_user_context_size = ttm_round_pot(sizeof(*ctx)) + 128;
|
|
|
|
ret = ttm_read_lock(&vmaster->lock, true);
|
|
if (unlikely(ret != 0))
|
|
return ret;
|
|
|
|
ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv),
|
|
vmw_user_context_size,
|
|
false, true);
|
|
if (unlikely(ret != 0)) {
|
|
if (ret != -ERESTARTSYS)
|
|
DRM_ERROR("Out of graphics memory for context"
|
|
" creation.\n");
|
|
goto out_unlock;
|
|
}
|
|
|
|
ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
|
|
if (unlikely(ctx == NULL)) {
|
|
ttm_mem_global_free(vmw_mem_glob(dev_priv),
|
|
vmw_user_context_size);
|
|
ret = -ENOMEM;
|
|
goto out_unlock;
|
|
}
|
|
|
|
res = &ctx->res;
|
|
ctx->base.shareable = false;
|
|
ctx->base.tfile = NULL;
|
|
|
|
/*
|
|
* From here on, the destructor takes over resource freeing.
|
|
*/
|
|
|
|
ret = vmw_context_init(dev_priv, res, vmw_user_context_free);
|
|
if (unlikely(ret != 0))
|
|
goto out_unlock;
|
|
|
|
tmp = vmw_resource_reference(&ctx->res);
|
|
ret = ttm_base_object_init(tfile, &ctx->base, false, VMW_RES_CONTEXT,
|
|
&vmw_user_context_base_release, NULL);
|
|
|
|
if (unlikely(ret != 0)) {
|
|
vmw_resource_unreference(&tmp);
|
|
goto out_err;
|
|
}
|
|
|
|
arg->cid = ctx->base.hash.key;
|
|
out_err:
|
|
vmw_resource_unreference(&res);
|
|
out_unlock:
|
|
ttm_read_unlock(&vmaster->lock);
|
|
return ret;
|
|
|
|
}
|