Commit | Line | Data |
---|---|---|
c74c162f TH |
1 | /************************************************************************** |
2 | * | |
3 | * Copyright © 2009-2012 VMware, Inc., Palo Alto, CA., USA | |
4 | * All Rights Reserved. | |
5 | * | |
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: | |
13 | * | |
14 | * The above copyright notice and this permission notice (including the | |
15 | * next paragraph) shall be included in all copies or substantial portions | |
16 | * of the Software. | |
17 | * | |
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. | |
25 | * | |
26 | **************************************************************************/ | |
27 | ||
28 | #include "vmwgfx_drv.h" | |
29 | #include "vmwgfx_resource_priv.h" | |
30 | #include "ttm/ttm_placement.h" | |
31 | ||
32 | struct vmw_shader { | |
33 | struct vmw_resource res; | |
34 | SVGA3dShaderType type; | |
35 | uint32_t size; | |
36 | }; | |
37 | ||
38 | struct vmw_user_shader { | |
39 | struct ttm_base_object base; | |
40 | struct vmw_shader shader; | |
41 | }; | |
42 | ||
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); | |
46 | ||
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, | |
51 | bool readback, | |
52 | struct ttm_validate_buffer *val_buf); | |
53 | static int vmw_gb_shader_destroy(struct vmw_resource *res); | |
54 | ||
55 | static uint64_t vmw_user_shader_size; | |
56 | ||
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 | |
61 | }; | |
62 | ||
63 | const struct vmw_user_resource_conv *user_shader_converter = | |
64 | &user_shader_conv; | |
65 | ||
66 | ||
67 | static const struct vmw_res_func vmw_gb_shader_func = { | |
68 | .res_type = vmw_res_shader, | |
69 | .needs_backup = true, | |
70 | .may_evict = true, | |
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 | |
77 | }; | |
78 | ||
79 | /** | |
80 | * Shader management: | |
81 | */ | |
82 | ||
83 | static inline struct vmw_shader * | |
84 | vmw_res_to_shader(struct vmw_resource *res) | |
85 | { | |
86 | return container_of(res, struct vmw_shader, res); | |
87 | } | |
88 | ||
89 | static void vmw_hw_shader_destroy(struct vmw_resource *res) | |
90 | { | |
91 | (void) vmw_gb_shader_destroy(res); | |
92 | } | |
93 | ||
94 | static int vmw_gb_shader_init(struct vmw_private *dev_priv, | |
95 | struct vmw_resource *res, | |
96 | uint32_t size, | |
97 | uint64_t offset, | |
98 | SVGA3dShaderType type, | |
99 | struct vmw_dma_buffer *byte_code, | |
100 | void (*res_free) (struct vmw_resource *res)) | |
101 | { | |
102 | struct vmw_shader *shader = vmw_res_to_shader(res); | |
103 | int ret; | |
104 | ||
105 | ret = vmw_resource_init(dev_priv, res, true, | |
106 | res_free, &vmw_gb_shader_func); | |
107 | ||
108 | ||
109 | if (unlikely(ret != 0)) { | |
110 | if (res_free) | |
111 | res_free(res); | |
112 | else | |
113 | kfree(res); | |
114 | return ret; | |
115 | } | |
116 | ||
117 | res->backup_size = size; | |
118 | if (byte_code) { | |
119 | res->backup = vmw_dmabuf_reference(byte_code); | |
120 | res->backup_offset = offset; | |
121 | } | |
122 | shader->size = size; | |
123 | shader->type = type; | |
124 | ||
125 | vmw_resource_activate(res, vmw_hw_shader_destroy); | |
126 | return 0; | |
127 | } | |
128 | ||
129 | static int vmw_gb_shader_create(struct vmw_resource *res) | |
130 | { | |
131 | struct vmw_private *dev_priv = res->dev_priv; | |
132 | struct vmw_shader *shader = vmw_res_to_shader(res); | |
133 | int ret; | |
134 | struct { | |
135 | SVGA3dCmdHeader header; | |
136 | SVGA3dCmdDefineGBShader body; | |
137 | } *cmd; | |
138 | ||
139 | if (likely(res->id != -1)) | |
140 | return 0; | |
141 | ||
142 | ret = vmw_resource_alloc_id(res); | |
143 | if (unlikely(ret != 0)) { | |
144 | DRM_ERROR("Failed to allocate a shader id.\n"); | |
145 | goto out_no_id; | |
146 | } | |
147 | ||
148 | if (unlikely(res->id >= VMWGFX_NUM_GB_SHADER)) { | |
149 | ret = -EBUSY; | |
150 | goto out_no_fifo; | |
151 | } | |
152 | ||
153 | cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd)); | |
154 | if (unlikely(cmd == NULL)) { | |
155 | DRM_ERROR("Failed reserving FIFO space for shader " | |
156 | "creation.\n"); | |
157 | ret = -ENOMEM; | |
158 | goto out_no_fifo; | |
159 | } | |
160 | ||
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); | |
168 | ||
169 | return 0; | |
170 | ||
171 | out_no_fifo: | |
172 | vmw_resource_release_id(res); | |
173 | out_no_id: | |
174 | return ret; | |
175 | } | |
176 | ||
177 | static int vmw_gb_shader_bind(struct vmw_resource *res, | |
178 | struct ttm_validate_buffer *val_buf) | |
179 | { | |
180 | struct vmw_private *dev_priv = res->dev_priv; | |
181 | struct { | |
182 | SVGA3dCmdHeader header; | |
183 | SVGA3dCmdBindGBShader body; | |
184 | } *cmd; | |
185 | struct ttm_buffer_object *bo = val_buf->bo; | |
186 | ||
187 | BUG_ON(bo->mem.mem_type != VMW_PL_MOB); | |
188 | ||
189 | cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd)); | |
190 | if (unlikely(cmd == NULL)) { | |
191 | DRM_ERROR("Failed reserving FIFO space for shader " | |
192 | "binding.\n"); | |
193 | return -ENOMEM; | |
194 | } | |
195 | ||
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)); | |
203 | ||
204 | return 0; | |
205 | } | |
206 | ||
207 | static int vmw_gb_shader_unbind(struct vmw_resource *res, | |
208 | bool readback, | |
209 | struct ttm_validate_buffer *val_buf) | |
210 | { | |
211 | struct vmw_private *dev_priv = res->dev_priv; | |
212 | struct { | |
213 | SVGA3dCmdHeader header; | |
214 | SVGA3dCmdBindGBShader body; | |
215 | } *cmd; | |
216 | struct vmw_fence_obj *fence; | |
217 | ||
218 | BUG_ON(res->backup->base.mem.mem_type != VMW_PL_MOB); | |
219 | ||
220 | cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd)); | |
221 | if (unlikely(cmd == NULL)) { | |
222 | DRM_ERROR("Failed reserving FIFO space for shader " | |
223 | "unbinding.\n"); | |
224 | return -ENOMEM; | |
225 | } | |
226 | ||
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)); | |
233 | ||
234 | /* | |
235 | * Create a fence object and fence the backup buffer. | |
236 | */ | |
237 | ||
238 | (void) vmw_execbuf_fence_commands(NULL, dev_priv, | |
239 | &fence, NULL); | |
240 | ||
241 | vmw_fence_single_bo(val_buf->bo, fence); | |
242 | ||
243 | if (likely(fence != NULL)) | |
244 | vmw_fence_obj_unreference(&fence); | |
245 | ||
246 | return 0; | |
247 | } | |
248 | ||
249 | static int vmw_gb_shader_destroy(struct vmw_resource *res) | |
250 | { | |
251 | struct vmw_private *dev_priv = res->dev_priv; | |
252 | struct { | |
253 | SVGA3dCmdHeader header; | |
254 | SVGA3dCmdDestroyGBShader body; | |
255 | } *cmd; | |
256 | ||
257 | if (likely(res->id == -1)) | |
258 | return 0; | |
259 | ||
260 | cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd)); | |
261 | if (unlikely(cmd == NULL)) { | |
262 | DRM_ERROR("Failed reserving FIFO space for shader " | |
263 | "destruction.\n"); | |
264 | return -ENOMEM; | |
265 | } | |
266 | ||
267 | cmd->header.id = SVGA_3D_CMD_DESTROY_GB_SHADER; | |
268 | cmd->header.size = sizeof(cmd->body); | |
269 | cmd->body.shid = res->id; | |
270 | vmw_fifo_commit(dev_priv, sizeof(*cmd)); | |
271 | vmw_resource_release_id(res); | |
272 | vmw_3d_resource_dec(dev_priv, false); | |
273 | ||
274 | return 0; | |
275 | } | |
276 | ||
277 | /** | |
278 | * User-space shader management: | |
279 | */ | |
280 | ||
281 | static struct vmw_resource * | |
282 | vmw_user_shader_base_to_res(struct ttm_base_object *base) | |
283 | { | |
284 | return &(container_of(base, struct vmw_user_shader, base)-> | |
285 | shader.res); | |
286 | } | |
287 | ||
288 | static void vmw_user_shader_free(struct vmw_resource *res) | |
289 | { | |
290 | struct vmw_user_shader *ushader = | |
291 | container_of(res, struct vmw_user_shader, shader.res); | |
292 | struct vmw_private *dev_priv = res->dev_priv; | |
293 | ||
294 | ttm_base_object_kfree(ushader, base); | |
295 | ttm_mem_global_free(vmw_mem_glob(dev_priv), | |
296 | vmw_user_shader_size); | |
297 | } | |
298 | ||
299 | /** | |
300 | * This function is called when user space has no more references on the | |
301 | * base object. It releases the base-object's reference on the resource object. | |
302 | */ | |
303 | ||
304 | static void vmw_user_shader_base_release(struct ttm_base_object **p_base) | |
305 | { | |
306 | struct ttm_base_object *base = *p_base; | |
307 | struct vmw_resource *res = vmw_user_shader_base_to_res(base); | |
308 | ||
309 | *p_base = NULL; | |
310 | vmw_resource_unreference(&res); | |
311 | } | |
312 | ||
313 | int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data, | |
314 | struct drm_file *file_priv) | |
315 | { | |
316 | struct drm_vmw_shader_arg *arg = (struct drm_vmw_shader_arg *)data; | |
317 | struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; | |
318 | ||
319 | return ttm_ref_object_base_unref(tfile, arg->handle, | |
320 | TTM_REF_USAGE); | |
321 | } | |
322 | ||
323 | int vmw_shader_define_ioctl(struct drm_device *dev, void *data, | |
324 | struct drm_file *file_priv) | |
325 | { | |
326 | struct vmw_private *dev_priv = vmw_priv(dev); | |
327 | struct vmw_user_shader *ushader; | |
328 | struct vmw_resource *res; | |
329 | struct vmw_resource *tmp; | |
330 | struct drm_vmw_shader_create_arg *arg = | |
331 | (struct drm_vmw_shader_create_arg *)data; | |
332 | struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile; | |
333 | struct vmw_master *vmaster = vmw_master(file_priv->master); | |
334 | struct vmw_dma_buffer *buffer = NULL; | |
335 | SVGA3dShaderType shader_type; | |
336 | int ret; | |
337 | ||
338 | if (arg->buffer_handle != SVGA3D_INVALID_ID) { | |
339 | ret = vmw_user_dmabuf_lookup(tfile, arg->buffer_handle, | |
340 | &buffer); | |
341 | if (unlikely(ret != 0)) { | |
342 | DRM_ERROR("Could not find buffer for shader " | |
343 | "creation.\n"); | |
344 | return ret; | |
345 | } | |
346 | ||
347 | if ((u64)buffer->base.num_pages * PAGE_SIZE < | |
348 | (u64)arg->size + (u64)arg->offset) { | |
349 | DRM_ERROR("Illegal buffer- or shader size.\n"); | |
350 | ret = -EINVAL; | |
351 | goto out_bad_arg; | |
352 | } | |
353 | } | |
354 | ||
355 | switch (arg->shader_type) { | |
356 | case drm_vmw_shader_type_vs: | |
357 | shader_type = SVGA3D_SHADERTYPE_VS; | |
358 | break; | |
359 | case drm_vmw_shader_type_ps: | |
360 | shader_type = SVGA3D_SHADERTYPE_PS; | |
361 | break; | |
362 | case drm_vmw_shader_type_gs: | |
363 | shader_type = SVGA3D_SHADERTYPE_GS; | |
364 | break; | |
365 | default: | |
366 | DRM_ERROR("Illegal shader type.\n"); | |
367 | ret = -EINVAL; | |
368 | goto out_bad_arg; | |
369 | } | |
370 | ||
371 | /* | |
372 | * Approximate idr memory usage with 128 bytes. It will be limited | |
373 | * by maximum number_of shaders anyway. | |
374 | */ | |
375 | ||
376 | if (unlikely(vmw_user_shader_size == 0)) | |
377 | vmw_user_shader_size = ttm_round_pot(sizeof(*ushader)) | |
378 | + 128; | |
379 | ||
380 | ret = ttm_read_lock(&vmaster->lock, true); | |
381 | if (unlikely(ret != 0)) | |
382 | return ret; | |
383 | ||
384 | ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv), | |
385 | vmw_user_shader_size, | |
386 | false, true); | |
387 | if (unlikely(ret != 0)) { | |
388 | if (ret != -ERESTARTSYS) | |
389 | DRM_ERROR("Out of graphics memory for shader" | |
390 | " creation.\n"); | |
391 | goto out_unlock; | |
392 | } | |
393 | ||
394 | ushader = kzalloc(sizeof(*ushader), GFP_KERNEL); | |
395 | if (unlikely(ushader == NULL)) { | |
396 | ttm_mem_global_free(vmw_mem_glob(dev_priv), | |
397 | vmw_user_shader_size); | |
398 | ret = -ENOMEM; | |
399 | goto out_unlock; | |
400 | } | |
401 | ||
402 | res = &ushader->shader.res; | |
403 | ushader->base.shareable = false; | |
404 | ushader->base.tfile = NULL; | |
405 | ||
406 | /* | |
407 | * From here on, the destructor takes over resource freeing. | |
408 | */ | |
409 | ||
410 | ret = vmw_gb_shader_init(dev_priv, res, arg->size, | |
411 | arg->offset, shader_type, buffer, | |
412 | vmw_user_shader_free); | |
413 | if (unlikely(ret != 0)) | |
414 | goto out_unlock; | |
415 | ||
416 | tmp = vmw_resource_reference(res); | |
417 | ret = ttm_base_object_init(tfile, &ushader->base, false, | |
418 | VMW_RES_SHADER, | |
419 | &vmw_user_shader_base_release, NULL); | |
420 | ||
421 | if (unlikely(ret != 0)) { | |
422 | vmw_resource_unreference(&tmp); | |
423 | goto out_err; | |
424 | } | |
425 | ||
426 | arg->shader_handle = ushader->base.hash.key; | |
427 | out_err: | |
428 | vmw_resource_unreference(&res); | |
429 | out_unlock: | |
430 | ttm_read_unlock(&vmaster->lock); | |
431 | out_bad_arg: | |
432 | vmw_dmabuf_unreference(&buffer); | |
433 | ||
434 | return ret; | |
435 | ||
436 | } |