0,0 → 1,276 |
/************************************************************************** |
* |
* 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); |
} |
|
#if 0 |
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; |
|
} |
#endif |