1 /**************************************************************************
3 * Copyright © 2009-2012 VMware, Inc., Palo Alto, CA., USA
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the
8 * "Software"), to deal in the Software without restriction, including
9 * without limitation the rights to use, copy, modify, merge, publish,
10 * distribute, sub license, and/or sell copies of the Software, and to
11 * permit persons to whom the Software is furnished to do so, subject to
12 * the following conditions:
14 * The above copyright notice and this permission notice (including the
15 * next paragraph) shall be included in all copies or substantial portions
18 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21 * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
22 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24 * USE OR OTHER DEALINGS IN THE SOFTWARE.
26 **************************************************************************/
28 #include "vmwgfx_drv.h"
29 #include "vmwgfx_resource_priv.h"
30 #include "ttm/ttm_placement.h"
33 struct vmw_resource res;
34 SVGA3dShaderType type;
38 struct vmw_user_shader {
39 struct ttm_base_object base;
40 struct vmw_shader shader;
43 static void vmw_user_shader_free(struct vmw_resource *res);
44 static struct vmw_resource *
45 vmw_user_shader_base_to_res(struct ttm_base_object *base);
47 static int vmw_gb_shader_create(struct vmw_resource *res);
48 static int vmw_gb_shader_bind(struct vmw_resource *res,
49 struct ttm_validate_buffer *val_buf);
50 static int vmw_gb_shader_unbind(struct vmw_resource *res,
52 struct ttm_validate_buffer *val_buf);
53 static int vmw_gb_shader_destroy(struct vmw_resource *res);
55 static uint64_t vmw_user_shader_size;
57 static const struct vmw_user_resource_conv user_shader_conv = {
58 .object_type = VMW_RES_SHADER,
59 .base_obj_to_res = vmw_user_shader_base_to_res,
60 .res_free = vmw_user_shader_free
63 const struct vmw_user_resource_conv *user_shader_converter =
67 static const struct vmw_res_func vmw_gb_shader_func = {
68 .res_type = vmw_res_shader,
71 .type_name = "guest backed shaders",
72 .backup_placement = &vmw_mob_placement,
73 .create = vmw_gb_shader_create,
74 .destroy = vmw_gb_shader_destroy,
75 .bind = vmw_gb_shader_bind,
76 .unbind = vmw_gb_shader_unbind
83 static inline struct vmw_shader *
84 vmw_res_to_shader(struct vmw_resource *res)
86 return container_of(res, struct vmw_shader, res);
89 static void vmw_hw_shader_destroy(struct vmw_resource *res)
91 (void) vmw_gb_shader_destroy(res);
94 static int vmw_gb_shader_init(struct vmw_private *dev_priv,
95 struct vmw_resource *res,
98 SVGA3dShaderType type,
99 struct vmw_dma_buffer *byte_code,
100 void (*res_free) (struct vmw_resource *res))
102 struct vmw_shader *shader = vmw_res_to_shader(res);
105 ret = vmw_resource_init(dev_priv, res, true,
106 res_free, &vmw_gb_shader_func);
109 if (unlikely(ret != 0)) {
117 res->backup_size = size;
119 res->backup = vmw_dmabuf_reference(byte_code);
120 res->backup_offset = offset;
125 vmw_resource_activate(res, vmw_hw_shader_destroy);
129 static int vmw_gb_shader_create(struct vmw_resource *res)
131 struct vmw_private *dev_priv = res->dev_priv;
132 struct vmw_shader *shader = vmw_res_to_shader(res);
135 SVGA3dCmdHeader header;
136 SVGA3dCmdDefineGBShader body;
139 if (likely(res->id != -1))
142 ret = vmw_resource_alloc_id(res);
143 if (unlikely(ret != 0)) {
144 DRM_ERROR("Failed to allocate a shader id.\n");
148 if (unlikely(res->id >= VMWGFX_NUM_GB_SHADER)) {
153 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
154 if (unlikely(cmd == NULL)) {
155 DRM_ERROR("Failed reserving FIFO space for shader "
161 cmd->header.id = SVGA_3D_CMD_DEFINE_GB_SHADER;
162 cmd->header.size = sizeof(cmd->body);
163 cmd->body.shid = res->id;
164 cmd->body.type = shader->type;
165 cmd->body.sizeInBytes = shader->size;
166 vmw_fifo_commit(dev_priv, sizeof(*cmd));
167 (void) vmw_3d_resource_inc(dev_priv, false);
172 vmw_resource_release_id(res);
177 static int vmw_gb_shader_bind(struct vmw_resource *res,
178 struct ttm_validate_buffer *val_buf)
180 struct vmw_private *dev_priv = res->dev_priv;
182 SVGA3dCmdHeader header;
183 SVGA3dCmdBindGBShader body;
185 struct ttm_buffer_object *bo = val_buf->bo;
187 BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
189 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
190 if (unlikely(cmd == NULL)) {
191 DRM_ERROR("Failed reserving FIFO space for shader "
196 cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER;
197 cmd->header.size = sizeof(cmd->body);
198 cmd->body.shid = res->id;
199 cmd->body.mobid = bo->mem.start;
200 cmd->body.offsetInBytes = 0;
201 res->backup_dirty = false;
202 vmw_fifo_commit(dev_priv, sizeof(*cmd));
207 static int vmw_gb_shader_unbind(struct vmw_resource *res,
209 struct ttm_validate_buffer *val_buf)
211 struct vmw_private *dev_priv = res->dev_priv;
213 SVGA3dCmdHeader header;
214 SVGA3dCmdBindGBShader body;
216 struct vmw_fence_obj *fence;
218 BUG_ON(res->backup->base.mem.mem_type != VMW_PL_MOB);
220 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
221 if (unlikely(cmd == NULL)) {
222 DRM_ERROR("Failed reserving FIFO space for shader "
227 cmd->header.id = SVGA_3D_CMD_BIND_GB_SHADER;
228 cmd->header.size = sizeof(cmd->body);
229 cmd->body.shid = res->id;
230 cmd->body.mobid = SVGA3D_INVALID_ID;
231 cmd->body.offsetInBytes = 0;
232 vmw_fifo_commit(dev_priv, sizeof(*cmd));
235 * Create a fence object and fence the backup buffer.
238 (void) vmw_execbuf_fence_commands(NULL, dev_priv,
241 vmw_fence_single_bo(val_buf->bo, fence);
243 if (likely(fence != NULL))
244 vmw_fence_obj_unreference(&fence);
249 static int vmw_gb_shader_destroy(struct vmw_resource *res)
251 struct vmw_private *dev_priv = res->dev_priv;
253 SVGA3dCmdHeader header;
254 SVGA3dCmdDestroyGBShader body;
257 if (likely(res->id == -1))
260 mutex_lock(&dev_priv->binding_mutex);
261 vmw_context_binding_res_list_kill(&res->binding_head);
263 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
264 if (unlikely(cmd == NULL)) {
265 DRM_ERROR("Failed reserving FIFO space for shader "
267 mutex_unlock(&dev_priv->binding_mutex);
271 cmd->header.id = SVGA_3D_CMD_DESTROY_GB_SHADER;
272 cmd->header.size = sizeof(cmd->body);
273 cmd->body.shid = res->id;
274 vmw_fifo_commit(dev_priv, sizeof(*cmd));
275 mutex_unlock(&dev_priv->binding_mutex);
276 vmw_resource_release_id(res);
277 vmw_3d_resource_dec(dev_priv, false);
283 * User-space shader management:
286 static struct vmw_resource *
287 vmw_user_shader_base_to_res(struct ttm_base_object *base)
289 return &(container_of(base, struct vmw_user_shader, base)->
293 static void vmw_user_shader_free(struct vmw_resource *res)
295 struct vmw_user_shader *ushader =
296 container_of(res, struct vmw_user_shader, shader.res);
297 struct vmw_private *dev_priv = res->dev_priv;
299 ttm_base_object_kfree(ushader, base);
300 ttm_mem_global_free(vmw_mem_glob(dev_priv),
301 vmw_user_shader_size);
305 * This function is called when user space has no more references on the
306 * base object. It releases the base-object's reference on the resource object.
309 static void vmw_user_shader_base_release(struct ttm_base_object **p_base)
311 struct ttm_base_object *base = *p_base;
312 struct vmw_resource *res = vmw_user_shader_base_to_res(base);
315 vmw_resource_unreference(&res);
318 int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data,
319 struct drm_file *file_priv)
321 struct drm_vmw_shader_arg *arg = (struct drm_vmw_shader_arg *)data;
322 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
324 return ttm_ref_object_base_unref(tfile, arg->handle,
328 int vmw_shader_define_ioctl(struct drm_device *dev, void *data,
329 struct drm_file *file_priv)
331 struct vmw_private *dev_priv = vmw_priv(dev);
332 struct vmw_user_shader *ushader;
333 struct vmw_resource *res;
334 struct vmw_resource *tmp;
335 struct drm_vmw_shader_create_arg *arg =
336 (struct drm_vmw_shader_create_arg *)data;
337 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
338 struct vmw_master *vmaster = vmw_master(file_priv->master);
339 struct vmw_dma_buffer *buffer = NULL;
340 SVGA3dShaderType shader_type;
343 if (arg->buffer_handle != SVGA3D_INVALID_ID) {
344 ret = vmw_user_dmabuf_lookup(tfile, arg->buffer_handle,
346 if (unlikely(ret != 0)) {
347 DRM_ERROR("Could not find buffer for shader "
352 if ((u64)buffer->base.num_pages * PAGE_SIZE <
353 (u64)arg->size + (u64)arg->offset) {
354 DRM_ERROR("Illegal buffer- or shader size.\n");
360 switch (arg->shader_type) {
361 case drm_vmw_shader_type_vs:
362 shader_type = SVGA3D_SHADERTYPE_VS;
364 case drm_vmw_shader_type_ps:
365 shader_type = SVGA3D_SHADERTYPE_PS;
367 case drm_vmw_shader_type_gs:
368 shader_type = SVGA3D_SHADERTYPE_GS;
371 DRM_ERROR("Illegal shader type.\n");
377 * Approximate idr memory usage with 128 bytes. It will be limited
378 * by maximum number_of shaders anyway.
381 if (unlikely(vmw_user_shader_size == 0))
382 vmw_user_shader_size = ttm_round_pot(sizeof(*ushader))
385 ret = ttm_read_lock(&vmaster->lock, true);
386 if (unlikely(ret != 0))
389 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv),
390 vmw_user_shader_size,
392 if (unlikely(ret != 0)) {
393 if (ret != -ERESTARTSYS)
394 DRM_ERROR("Out of graphics memory for shader"
399 ushader = kzalloc(sizeof(*ushader), GFP_KERNEL);
400 if (unlikely(ushader == NULL)) {
401 ttm_mem_global_free(vmw_mem_glob(dev_priv),
402 vmw_user_shader_size);
407 res = &ushader->shader.res;
408 ushader->base.shareable = false;
409 ushader->base.tfile = NULL;
412 * From here on, the destructor takes over resource freeing.
415 ret = vmw_gb_shader_init(dev_priv, res, arg->size,
416 arg->offset, shader_type, buffer,
417 vmw_user_shader_free);
418 if (unlikely(ret != 0))
421 tmp = vmw_resource_reference(res);
422 ret = ttm_base_object_init(tfile, &ushader->base, false,
424 &vmw_user_shader_base_release, NULL);
426 if (unlikely(ret != 0)) {
427 vmw_resource_unreference(&tmp);
431 arg->shader_handle = ushader->base.hash.key;
433 vmw_resource_unreference(&res);
435 ttm_read_unlock(&vmaster->lock);
437 vmw_dmabuf_unreference(&buffer);