1 /**************************************************************************
3 * Copyright © 2009-2015 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 "vmwgfx_so.h"
31 #include "vmwgfx_binding.h"
32 #include <ttm/ttm_placement.h>
33 #include "device_include/svga3d_surfacedefs.h"
37 * struct vmw_user_surface - User-space visible surface resource
39 * @base: The TTM base object handling user-space visibility.
40 * @srf: The surface metadata.
41 * @size: TTM accounting size for the surface.
42 * @master: master of the creating client. Used for security check.
44 struct vmw_user_surface {
45 struct ttm_prime_object prime;
46 struct vmw_surface srf;
48 struct drm_master *master;
52 * struct vmw_surface_offset - Backing store mip level offset info
54 * @face: Surface face.
56 * @bo_offset: Offset into backing store of this mip level.
59 struct vmw_surface_offset {
65 static void vmw_user_surface_free(struct vmw_resource *res);
66 static struct vmw_resource *
67 vmw_user_surface_base_to_res(struct ttm_base_object *base);
68 static int vmw_legacy_srf_bind(struct vmw_resource *res,
69 struct ttm_validate_buffer *val_buf);
70 static int vmw_legacy_srf_unbind(struct vmw_resource *res,
72 struct ttm_validate_buffer *val_buf);
73 static int vmw_legacy_srf_create(struct vmw_resource *res);
74 static int vmw_legacy_srf_destroy(struct vmw_resource *res);
75 static int vmw_gb_surface_create(struct vmw_resource *res);
76 static int vmw_gb_surface_bind(struct vmw_resource *res,
77 struct ttm_validate_buffer *val_buf);
78 static int vmw_gb_surface_unbind(struct vmw_resource *res,
80 struct ttm_validate_buffer *val_buf);
81 static int vmw_gb_surface_destroy(struct vmw_resource *res);
84 static const struct vmw_user_resource_conv user_surface_conv = {
85 .object_type = VMW_RES_SURFACE,
86 .base_obj_to_res = vmw_user_surface_base_to_res,
87 .res_free = vmw_user_surface_free
90 const struct vmw_user_resource_conv *user_surface_converter =
94 static uint64_t vmw_user_surface_size;
96 static const struct vmw_res_func vmw_legacy_surface_func = {
97 .res_type = vmw_res_surface,
98 .needs_backup = false,
100 .type_name = "legacy surfaces",
101 .backup_placement = &vmw_srf_placement,
102 .create = &vmw_legacy_srf_create,
103 .destroy = &vmw_legacy_srf_destroy,
104 .bind = &vmw_legacy_srf_bind,
105 .unbind = &vmw_legacy_srf_unbind
108 static const struct vmw_res_func vmw_gb_surface_func = {
109 .res_type = vmw_res_surface,
110 .needs_backup = true,
112 .type_name = "guest backed surfaces",
113 .backup_placement = &vmw_mob_placement,
114 .create = vmw_gb_surface_create,
115 .destroy = vmw_gb_surface_destroy,
116 .bind = vmw_gb_surface_bind,
117 .unbind = vmw_gb_surface_unbind
121 * struct vmw_surface_dma - SVGA3D DMA command
123 struct vmw_surface_dma {
124 SVGA3dCmdHeader header;
125 SVGA3dCmdSurfaceDMA body;
127 SVGA3dCmdSurfaceDMASuffix suffix;
131 * struct vmw_surface_define - SVGA3D Surface Define command
133 struct vmw_surface_define {
134 SVGA3dCmdHeader header;
135 SVGA3dCmdDefineSurface body;
139 * struct vmw_surface_destroy - SVGA3D Surface Destroy command
141 struct vmw_surface_destroy {
142 SVGA3dCmdHeader header;
143 SVGA3dCmdDestroySurface body;
148 * vmw_surface_dma_size - Compute fifo size for a dma command.
150 * @srf: Pointer to a struct vmw_surface
152 * Computes the required size for a surface dma command for backup or
153 * restoration of the surface represented by @srf.
155 static inline uint32_t vmw_surface_dma_size(const struct vmw_surface *srf)
157 return srf->num_sizes * sizeof(struct vmw_surface_dma);
162 * vmw_surface_define_size - Compute fifo size for a surface define command.
164 * @srf: Pointer to a struct vmw_surface
166 * Computes the required size for a surface define command for the definition
167 * of the surface represented by @srf.
169 static inline uint32_t vmw_surface_define_size(const struct vmw_surface *srf)
171 return sizeof(struct vmw_surface_define) + srf->num_sizes *
177 * vmw_surface_destroy_size - Compute fifo size for a surface destroy command.
179 * Computes the required size for a surface destroy command for the destruction
182 static inline uint32_t vmw_surface_destroy_size(void)
184 return sizeof(struct vmw_surface_destroy);
188 * vmw_surface_destroy_encode - Encode a surface_destroy command.
190 * @id: The surface id
191 * @cmd_space: Pointer to memory area in which the commands should be encoded.
193 static void vmw_surface_destroy_encode(uint32_t id,
196 struct vmw_surface_destroy *cmd = (struct vmw_surface_destroy *)
199 cmd->header.id = SVGA_3D_CMD_SURFACE_DESTROY;
200 cmd->header.size = sizeof(cmd->body);
205 * vmw_surface_define_encode - Encode a surface_define command.
207 * @srf: Pointer to a struct vmw_surface object.
208 * @cmd_space: Pointer to memory area in which the commands should be encoded.
210 static void vmw_surface_define_encode(const struct vmw_surface *srf,
213 struct vmw_surface_define *cmd = (struct vmw_surface_define *)
215 struct drm_vmw_size *src_size;
216 SVGA3dSize *cmd_size;
220 cmd_len = sizeof(cmd->body) + srf->num_sizes * sizeof(SVGA3dSize);
222 cmd->header.id = SVGA_3D_CMD_SURFACE_DEFINE;
223 cmd->header.size = cmd_len;
224 cmd->body.sid = srf->res.id;
225 cmd->body.surfaceFlags = srf->flags;
226 cmd->body.format = srf->format;
227 for (i = 0; i < DRM_VMW_MAX_SURFACE_FACES; ++i)
228 cmd->body.face[i].numMipLevels = srf->mip_levels[i];
231 cmd_size = (SVGA3dSize *) cmd;
232 src_size = srf->sizes;
234 for (i = 0; i < srf->num_sizes; ++i, cmd_size++, src_size++) {
235 cmd_size->width = src_size->width;
236 cmd_size->height = src_size->height;
237 cmd_size->depth = src_size->depth;
242 * vmw_surface_dma_encode - Encode a surface_dma command.
244 * @srf: Pointer to a struct vmw_surface object.
245 * @cmd_space: Pointer to memory area in which the commands should be encoded.
246 * @ptr: Pointer to an SVGAGuestPtr indicating where the surface contents
247 * should be placed or read from.
248 * @to_surface: Boolean whether to DMA to the surface or from the surface.
250 static void vmw_surface_dma_encode(struct vmw_surface *srf,
252 const SVGAGuestPtr *ptr,
256 struct vmw_surface_dma *cmd = (struct vmw_surface_dma *)cmd_space;
257 const struct svga3d_surface_desc *desc =
258 svga3dsurface_get_desc(srf->format);
260 for (i = 0; i < srf->num_sizes; ++i) {
261 SVGA3dCmdHeader *header = &cmd->header;
262 SVGA3dCmdSurfaceDMA *body = &cmd->body;
263 SVGA3dCopyBox *cb = &cmd->cb;
264 SVGA3dCmdSurfaceDMASuffix *suffix = &cmd->suffix;
265 const struct vmw_surface_offset *cur_offset = &srf->offsets[i];
266 const struct drm_vmw_size *cur_size = &srf->sizes[i];
268 header->id = SVGA_3D_CMD_SURFACE_DMA;
269 header->size = sizeof(*body) + sizeof(*cb) + sizeof(*suffix);
271 body->guest.ptr = *ptr;
272 body->guest.ptr.offset += cur_offset->bo_offset;
273 body->guest.pitch = svga3dsurface_calculate_pitch(desc,
275 body->host.sid = srf->res.id;
276 body->host.face = cur_offset->face;
277 body->host.mipmap = cur_offset->mip;
278 body->transfer = ((to_surface) ? SVGA3D_WRITE_HOST_VRAM :
279 SVGA3D_READ_HOST_VRAM);
286 cb->w = cur_size->width;
287 cb->h = cur_size->height;
288 cb->d = cur_size->depth;
290 suffix->suffixSize = sizeof(*suffix);
291 suffix->maximumOffset =
292 svga3dsurface_get_image_buffer_size(desc, cur_size,
294 suffix->flags.discard = 0;
295 suffix->flags.unsynchronized = 0;
296 suffix->flags.reserved = 0;
303 * vmw_hw_surface_destroy - destroy a Device surface
305 * @res: Pointer to a struct vmw_resource embedded in a struct
308 * Destroys a the device surface associated with a struct vmw_surface if
309 * any, and adjusts accounting and resource count accordingly.
311 static void vmw_hw_surface_destroy(struct vmw_resource *res)
314 struct vmw_private *dev_priv = res->dev_priv;
315 struct vmw_surface *srf;
318 if (res->func->destroy == vmw_gb_surface_destroy) {
319 (void) vmw_gb_surface_destroy(res);
325 cmd = vmw_fifo_reserve(dev_priv, vmw_surface_destroy_size());
326 if (unlikely(cmd == NULL)) {
327 DRM_ERROR("Failed reserving FIFO space for surface "
332 vmw_surface_destroy_encode(res->id, cmd);
333 vmw_fifo_commit(dev_priv, vmw_surface_destroy_size());
336 * used_memory_size_atomic, or separate lock
337 * to avoid taking dev_priv::cmdbuf_mutex in
341 mutex_lock(&dev_priv->cmdbuf_mutex);
342 srf = vmw_res_to_srf(res);
343 dev_priv->used_memory_size -= res->backup_size;
344 mutex_unlock(&dev_priv->cmdbuf_mutex);
346 vmw_fifo_resource_dec(dev_priv);
350 * vmw_legacy_srf_create - Create a device surface as part of the
351 * resource validation process.
353 * @res: Pointer to a struct vmw_surface.
355 * If the surface doesn't have a hw id.
357 * Returns -EBUSY if there wasn't sufficient device resources to
358 * complete the validation. Retry after freeing up resources.
360 * May return other errors if the kernel is out of guest resources.
362 static int vmw_legacy_srf_create(struct vmw_resource *res)
364 struct vmw_private *dev_priv = res->dev_priv;
365 struct vmw_surface *srf;
366 uint32_t submit_size;
370 if (likely(res->id != -1))
373 srf = vmw_res_to_srf(res);
374 if (unlikely(dev_priv->used_memory_size + res->backup_size >=
375 dev_priv->memory_size))
379 * Alloc id for the resource.
382 ret = vmw_resource_alloc_id(res);
383 if (unlikely(ret != 0)) {
384 DRM_ERROR("Failed to allocate a surface id.\n");
388 if (unlikely(res->id >= SVGA3D_MAX_SURFACE_IDS)) {
394 * Encode surface define- commands.
397 submit_size = vmw_surface_define_size(srf);
398 cmd = vmw_fifo_reserve(dev_priv, submit_size);
399 if (unlikely(cmd == NULL)) {
400 DRM_ERROR("Failed reserving FIFO space for surface "
406 vmw_surface_define_encode(srf, cmd);
407 vmw_fifo_commit(dev_priv, submit_size);
409 * Surface memory usage accounting.
412 dev_priv->used_memory_size += res->backup_size;
416 vmw_resource_release_id(res);
422 * vmw_legacy_srf_dma - Copy backup data to or from a legacy surface.
424 * @res: Pointer to a struct vmw_res embedded in a struct
426 * @val_buf: Pointer to a struct ttm_validate_buffer containing
427 * information about the backup buffer.
428 * @bind: Boolean wether to DMA to the surface.
430 * Transfer backup data to or from a legacy surface as part of the
431 * validation process.
432 * May return other errors if the kernel is out of guest resources.
433 * The backup buffer will be fenced or idle upon successful completion,
434 * and if the surface needs persistent backup storage, the backup buffer
435 * will also be returned reserved iff @bind is true.
437 static int vmw_legacy_srf_dma(struct vmw_resource *res,
438 struct ttm_validate_buffer *val_buf,
442 struct vmw_fence_obj *fence;
443 uint32_t submit_size;
444 struct vmw_surface *srf = vmw_res_to_srf(res);
446 struct vmw_private *dev_priv = res->dev_priv;
448 BUG_ON(val_buf->bo == NULL);
450 submit_size = vmw_surface_dma_size(srf);
451 cmd = vmw_fifo_reserve(dev_priv, submit_size);
452 if (unlikely(cmd == NULL)) {
453 DRM_ERROR("Failed reserving FIFO space for surface "
457 vmw_bo_get_guest_ptr(val_buf->bo, &ptr);
458 vmw_surface_dma_encode(srf, cmd, &ptr, bind);
460 vmw_fifo_commit(dev_priv, submit_size);
463 * Create a fence object and fence the backup buffer.
466 (void) vmw_execbuf_fence_commands(NULL, dev_priv,
469 vmw_fence_single_bo(val_buf->bo, fence);
471 if (likely(fence != NULL))
472 vmw_fence_obj_unreference(&fence);
478 * vmw_legacy_srf_bind - Perform a legacy surface bind as part of the
479 * surface validation process.
481 * @res: Pointer to a struct vmw_res embedded in a struct
483 * @val_buf: Pointer to a struct ttm_validate_buffer containing
484 * information about the backup buffer.
486 * This function will copy backup data to the surface if the
487 * backup buffer is dirty.
489 static int vmw_legacy_srf_bind(struct vmw_resource *res,
490 struct ttm_validate_buffer *val_buf)
492 if (!res->backup_dirty)
495 return vmw_legacy_srf_dma(res, val_buf, true);
500 * vmw_legacy_srf_unbind - Perform a legacy surface unbind as part of the
501 * surface eviction process.
503 * @res: Pointer to a struct vmw_res embedded in a struct
505 * @val_buf: Pointer to a struct ttm_validate_buffer containing
506 * information about the backup buffer.
508 * This function will copy backup data from the surface.
510 static int vmw_legacy_srf_unbind(struct vmw_resource *res,
512 struct ttm_validate_buffer *val_buf)
514 if (unlikely(readback))
515 return vmw_legacy_srf_dma(res, val_buf, false);
520 * vmw_legacy_srf_destroy - Destroy a device surface as part of a
521 * resource eviction process.
523 * @res: Pointer to a struct vmw_res embedded in a struct
526 static int vmw_legacy_srf_destroy(struct vmw_resource *res)
528 struct vmw_private *dev_priv = res->dev_priv;
529 uint32_t submit_size;
532 BUG_ON(res->id == -1);
535 * Encode the dma- and surface destroy commands.
538 submit_size = vmw_surface_destroy_size();
539 cmd = vmw_fifo_reserve(dev_priv, submit_size);
540 if (unlikely(cmd == NULL)) {
541 DRM_ERROR("Failed reserving FIFO space for surface "
546 vmw_surface_destroy_encode(res->id, cmd);
547 vmw_fifo_commit(dev_priv, submit_size);
550 * Surface memory usage accounting.
553 dev_priv->used_memory_size -= res->backup_size;
556 * Release the surface ID.
559 vmw_resource_release_id(res);
566 * vmw_surface_init - initialize a struct vmw_surface
568 * @dev_priv: Pointer to a device private struct.
569 * @srf: Pointer to the struct vmw_surface to initialize.
570 * @res_free: Pointer to a resource destructor used to free
573 static int vmw_surface_init(struct vmw_private *dev_priv,
574 struct vmw_surface *srf,
575 void (*res_free) (struct vmw_resource *res))
578 struct vmw_resource *res = &srf->res;
580 BUG_ON(res_free == NULL);
581 if (!dev_priv->has_mob)
582 vmw_fifo_resource_inc(dev_priv);
583 ret = vmw_resource_init(dev_priv, res, true, res_free,
584 (dev_priv->has_mob) ? &vmw_gb_surface_func :
585 &vmw_legacy_surface_func);
587 if (unlikely(ret != 0)) {
588 if (!dev_priv->has_mob)
589 vmw_fifo_resource_dec(dev_priv);
595 * The surface won't be visible to hardware until a
599 INIT_LIST_HEAD(&srf->view_list);
600 vmw_resource_activate(res, vmw_hw_surface_destroy);
605 * vmw_user_surface_base_to_res - TTM base object to resource converter for
606 * user visible surfaces
608 * @base: Pointer to a TTM base object
610 * Returns the struct vmw_resource embedded in a struct vmw_surface
611 * for the user-visible object identified by the TTM base object @base.
613 static struct vmw_resource *
614 vmw_user_surface_base_to_res(struct ttm_base_object *base)
616 return &(container_of(base, struct vmw_user_surface,
617 prime.base)->srf.res);
621 * vmw_user_surface_free - User visible surface resource destructor
623 * @res: A struct vmw_resource embedded in a struct vmw_surface.
625 static void vmw_user_surface_free(struct vmw_resource *res)
627 struct vmw_surface *srf = vmw_res_to_srf(res);
628 struct vmw_user_surface *user_srf =
629 container_of(srf, struct vmw_user_surface, srf);
630 struct vmw_private *dev_priv = srf->res.dev_priv;
631 uint32_t size = user_srf->size;
633 if (user_srf->master)
634 drm_master_put(&user_srf->master);
637 kfree(srf->snooper.image);
638 ttm_prime_object_kfree(user_srf, prime);
639 ttm_mem_global_free(vmw_mem_glob(dev_priv), size);
643 * vmw_user_surface_free - User visible surface TTM base object destructor
645 * @p_base: Pointer to a pointer to a TTM base object
646 * embedded in a struct vmw_user_surface.
648 * Drops the base object's reference on its resource, and the
649 * pointer pointed to by *p_base is set to NULL.
651 static void vmw_user_surface_base_release(struct ttm_base_object **p_base)
653 struct ttm_base_object *base = *p_base;
654 struct vmw_user_surface *user_srf =
655 container_of(base, struct vmw_user_surface, prime.base);
656 struct vmw_resource *res = &user_srf->srf.res;
659 vmw_resource_unreference(&res);
663 * vmw_user_surface_destroy_ioctl - Ioctl function implementing
664 * the user surface destroy functionality.
666 * @dev: Pointer to a struct drm_device.
667 * @data: Pointer to data copied from / to user-space.
668 * @file_priv: Pointer to a drm file private structure.
670 int vmw_surface_destroy_ioctl(struct drm_device *dev, void *data,
671 struct drm_file *file_priv)
673 struct drm_vmw_surface_arg *arg = (struct drm_vmw_surface_arg *)data;
674 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
676 return ttm_ref_object_base_unref(tfile, arg->sid, TTM_REF_USAGE);
680 * vmw_user_surface_define_ioctl - Ioctl function implementing
681 * the user surface define functionality.
683 * @dev: Pointer to a struct drm_device.
684 * @data: Pointer to data copied from / to user-space.
685 * @file_priv: Pointer to a drm file private structure.
687 int vmw_surface_define_ioctl(struct drm_device *dev, void *data,
688 struct drm_file *file_priv)
690 struct vmw_private *dev_priv = vmw_priv(dev);
691 struct vmw_user_surface *user_srf;
692 struct vmw_surface *srf;
693 struct vmw_resource *res;
694 struct vmw_resource *tmp;
695 union drm_vmw_surface_create_arg *arg =
696 (union drm_vmw_surface_create_arg *)data;
697 struct drm_vmw_surface_create_req *req = &arg->req;
698 struct drm_vmw_surface_arg *rep = &arg->rep;
699 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
700 struct drm_vmw_size __user *user_sizes;
703 uint32_t cur_bo_offset;
704 struct drm_vmw_size *cur_size;
705 struct vmw_surface_offset *cur_offset;
708 const struct svga3d_surface_desc *desc;
710 if (unlikely(vmw_user_surface_size == 0))
711 vmw_user_surface_size = ttm_round_pot(sizeof(*user_srf)) +
715 for (i = 0; i < DRM_VMW_MAX_SURFACE_FACES; ++i)
716 num_sizes += req->mip_levels[i];
718 if (num_sizes > DRM_VMW_MAX_SURFACE_FACES *
719 DRM_VMW_MAX_MIP_LEVELS)
722 size = vmw_user_surface_size + 128 +
723 ttm_round_pot(num_sizes * sizeof(struct drm_vmw_size)) +
724 ttm_round_pot(num_sizes * sizeof(struct vmw_surface_offset));
727 desc = svga3dsurface_get_desc(req->format);
728 if (unlikely(desc->block_desc == SVGA3DBLOCKDESC_NONE)) {
729 DRM_ERROR("Invalid surface format for surface creation.\n");
730 DRM_ERROR("Format requested is: %d\n", req->format);
734 ret = ttm_read_lock(&dev_priv->reservation_sem, true);
735 if (unlikely(ret != 0))
738 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv),
740 if (unlikely(ret != 0)) {
741 if (ret != -ERESTARTSYS)
742 DRM_ERROR("Out of graphics memory for surface"
747 user_srf = kzalloc(sizeof(*user_srf), GFP_KERNEL);
748 if (unlikely(user_srf == NULL)) {
750 goto out_no_user_srf;
753 srf = &user_srf->srf;
756 srf->flags = req->flags;
757 srf->format = req->format;
758 srf->scanout = req->scanout;
760 memcpy(srf->mip_levels, req->mip_levels, sizeof(srf->mip_levels));
761 srf->num_sizes = num_sizes;
762 user_srf->size = size;
764 srf->sizes = kmalloc(srf->num_sizes * sizeof(*srf->sizes), GFP_KERNEL);
765 if (unlikely(srf->sizes == NULL)) {
769 srf->offsets = kmalloc(srf->num_sizes * sizeof(*srf->offsets),
771 if (unlikely(srf->sizes == NULL)) {
776 user_sizes = (struct drm_vmw_size __user *)(unsigned long)
779 ret = copy_from_user(srf->sizes, user_sizes,
780 srf->num_sizes * sizeof(*srf->sizes));
781 if (unlikely(ret != 0)) {
786 srf->base_size = *srf->sizes;
787 srf->autogen_filter = SVGA3D_TEX_FILTER_NONE;
788 srf->multisample_count = 0;
791 cur_offset = srf->offsets;
792 cur_size = srf->sizes;
794 for (i = 0; i < DRM_VMW_MAX_SURFACE_FACES; ++i) {
795 for (j = 0; j < srf->mip_levels[i]; ++j) {
796 uint32_t stride = svga3dsurface_calculate_pitch
799 cur_offset->face = i;
801 cur_offset->bo_offset = cur_bo_offset;
802 cur_bo_offset += svga3dsurface_get_image_buffer_size
803 (desc, cur_size, stride);
808 res->backup_size = cur_bo_offset;
810 srf->num_sizes == 1 &&
811 srf->sizes[0].width == 64 &&
812 srf->sizes[0].height == 64 &&
813 srf->format == SVGA3D_A8R8G8B8) {
815 srf->snooper.image = kmalloc(64 * 64 * 4, GFP_KERNEL);
816 /* clear the image */
817 if (srf->snooper.image) {
818 memset(srf->snooper.image, 0x00, 64 * 64 * 4);
820 DRM_ERROR("Failed to allocate cursor_image\n");
825 srf->snooper.image = NULL;
827 srf->snooper.crtc = NULL;
829 user_srf->prime.base.shareable = false;
830 user_srf->prime.base.tfile = NULL;
831 if (drm_is_primary_client(file_priv))
832 user_srf->master = drm_master_get(file_priv->master);
835 * From this point, the generic resource management functions
836 * destroy the object on failure.
839 ret = vmw_surface_init(dev_priv, srf, vmw_user_surface_free);
840 if (unlikely(ret != 0))
844 * A gb-aware client referencing a shared surface will
845 * expect a backup buffer to be present.
847 if (dev_priv->has_mob && req->shareable) {
848 uint32_t backup_handle;
850 ret = vmw_user_dmabuf_alloc(dev_priv, tfile,
855 if (unlikely(ret != 0)) {
856 vmw_resource_unreference(&res);
861 tmp = vmw_resource_reference(&srf->res);
862 ret = ttm_prime_object_init(tfile, res->backup_size, &user_srf->prime,
863 req->shareable, VMW_RES_SURFACE,
864 &vmw_user_surface_base_release, NULL);
866 if (unlikely(ret != 0)) {
867 vmw_resource_unreference(&tmp);
868 vmw_resource_unreference(&res);
872 rep->sid = user_srf->prime.base.hash.key;
873 vmw_resource_unreference(&res);
875 ttm_read_unlock(&dev_priv->reservation_sem);
882 ttm_prime_object_kfree(user_srf, prime);
884 ttm_mem_global_free(vmw_mem_glob(dev_priv), size);
886 ttm_read_unlock(&dev_priv->reservation_sem);
892 vmw_surface_handle_reference(struct vmw_private *dev_priv,
893 struct drm_file *file_priv,
895 enum drm_vmw_handle_type handle_type,
896 struct ttm_base_object **base_p)
898 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
899 struct vmw_user_surface *user_srf;
901 struct ttm_base_object *base;
904 if (handle_type == DRM_VMW_HANDLE_PRIME) {
905 ret = ttm_prime_fd_to_handle(tfile, u_handle, &handle);
906 if (unlikely(ret != 0))
909 if (unlikely(drm_is_render_client(file_priv))) {
910 DRM_ERROR("Render client refused legacy "
911 "surface reference.\n");
918 base = ttm_base_object_lookup_for_ref(dev_priv->tdev, handle);
919 if (unlikely(base == NULL)) {
920 DRM_ERROR("Could not find surface to reference.\n");
924 if (unlikely(ttm_base_object_type(base) != VMW_RES_SURFACE)) {
925 DRM_ERROR("Referenced object is not a surface.\n");
926 goto out_bad_resource;
929 if (handle_type != DRM_VMW_HANDLE_PRIME) {
930 user_srf = container_of(base, struct vmw_user_surface,
934 * Make sure the surface creator has the same
935 * authenticating master.
937 if (drm_is_primary_client(file_priv) &&
938 user_srf->master != file_priv->master) {
939 DRM_ERROR("Trying to reference surface outside of"
940 " master domain.\n");
942 goto out_bad_resource;
945 ret = ttm_ref_object_add(tfile, base, TTM_REF_USAGE, NULL);
946 if (unlikely(ret != 0)) {
947 DRM_ERROR("Could not add a reference to a surface.\n");
948 goto out_bad_resource;
956 ttm_base_object_unref(&base);
958 if (handle_type == DRM_VMW_HANDLE_PRIME)
959 (void) ttm_ref_object_base_unref(tfile, handle, TTM_REF_USAGE);
965 * vmw_user_surface_define_ioctl - Ioctl function implementing
966 * the user surface reference functionality.
968 * @dev: Pointer to a struct drm_device.
969 * @data: Pointer to data copied from / to user-space.
970 * @file_priv: Pointer to a drm file private structure.
972 int vmw_surface_reference_ioctl(struct drm_device *dev, void *data,
973 struct drm_file *file_priv)
975 struct vmw_private *dev_priv = vmw_priv(dev);
976 union drm_vmw_surface_reference_arg *arg =
977 (union drm_vmw_surface_reference_arg *)data;
978 struct drm_vmw_surface_arg *req = &arg->req;
979 struct drm_vmw_surface_create_req *rep = &arg->rep;
980 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
981 struct vmw_surface *srf;
982 struct vmw_user_surface *user_srf;
983 struct drm_vmw_size __user *user_sizes;
984 struct ttm_base_object *base;
987 ret = vmw_surface_handle_reference(dev_priv, file_priv, req->sid,
988 req->handle_type, &base);
989 if (unlikely(ret != 0))
992 user_srf = container_of(base, struct vmw_user_surface, prime.base);
993 srf = &user_srf->srf;
995 rep->flags = srf->flags;
996 rep->format = srf->format;
997 memcpy(rep->mip_levels, srf->mip_levels, sizeof(srf->mip_levels));
998 user_sizes = (struct drm_vmw_size __user *)(unsigned long)
1002 ret = copy_to_user(user_sizes, &srf->base_size,
1003 sizeof(srf->base_size));
1004 if (unlikely(ret != 0)) {
1005 DRM_ERROR("copy_to_user failed %p %u\n",
1006 user_sizes, srf->num_sizes);
1007 ttm_ref_object_base_unref(tfile, base->hash.key, TTM_REF_USAGE);
1011 ttm_base_object_unref(&base);
1017 * vmw_surface_define_encode - Encode a surface_define command.
1019 * @srf: Pointer to a struct vmw_surface object.
1020 * @cmd_space: Pointer to memory area in which the commands should be encoded.
1022 static int vmw_gb_surface_create(struct vmw_resource *res)
1024 struct vmw_private *dev_priv = res->dev_priv;
1025 struct vmw_surface *srf = vmw_res_to_srf(res);
1026 uint32_t cmd_len, cmd_id, submit_len;
1029 SVGA3dCmdHeader header;
1030 SVGA3dCmdDefineGBSurface body;
1033 SVGA3dCmdHeader header;
1034 SVGA3dCmdDefineGBSurface_v2 body;
1037 if (likely(res->id != -1))
1040 vmw_fifo_resource_inc(dev_priv);
1041 ret = vmw_resource_alloc_id(res);
1042 if (unlikely(ret != 0)) {
1043 DRM_ERROR("Failed to allocate a surface id.\n");
1047 if (unlikely(res->id >= VMWGFX_NUM_GB_SURFACE)) {
1052 if (srf->array_size > 0) {
1053 /* has_dx checked on creation time. */
1054 cmd_id = SVGA_3D_CMD_DEFINE_GB_SURFACE_V2;
1055 cmd_len = sizeof(cmd2->body);
1056 submit_len = sizeof(*cmd2);
1058 cmd_id = SVGA_3D_CMD_DEFINE_GB_SURFACE;
1059 cmd_len = sizeof(cmd->body);
1060 submit_len = sizeof(*cmd);
1063 cmd = vmw_fifo_reserve(dev_priv, submit_len);
1064 cmd2 = (typeof(cmd2))cmd;
1065 if (unlikely(cmd == NULL)) {
1066 DRM_ERROR("Failed reserving FIFO space for surface "
1072 if (srf->array_size > 0) {
1073 cmd2->header.id = cmd_id;
1074 cmd2->header.size = cmd_len;
1075 cmd2->body.sid = srf->res.id;
1076 cmd2->body.surfaceFlags = srf->flags;
1077 cmd2->body.format = cpu_to_le32(srf->format);
1078 cmd2->body.numMipLevels = srf->mip_levels[0];
1079 cmd2->body.multisampleCount = srf->multisample_count;
1080 cmd2->body.autogenFilter = srf->autogen_filter;
1081 cmd2->body.size.width = srf->base_size.width;
1082 cmd2->body.size.height = srf->base_size.height;
1083 cmd2->body.size.depth = srf->base_size.depth;
1084 cmd2->body.arraySize = srf->array_size;
1086 cmd->header.id = cmd_id;
1087 cmd->header.size = cmd_len;
1088 cmd->body.sid = srf->res.id;
1089 cmd->body.surfaceFlags = srf->flags;
1090 cmd->body.format = cpu_to_le32(srf->format);
1091 cmd->body.numMipLevels = srf->mip_levels[0];
1092 cmd->body.multisampleCount = srf->multisample_count;
1093 cmd->body.autogenFilter = srf->autogen_filter;
1094 cmd->body.size.width = srf->base_size.width;
1095 cmd->body.size.height = srf->base_size.height;
1096 cmd->body.size.depth = srf->base_size.depth;
1099 vmw_fifo_commit(dev_priv, submit_len);
1104 vmw_resource_release_id(res);
1106 vmw_fifo_resource_dec(dev_priv);
1111 static int vmw_gb_surface_bind(struct vmw_resource *res,
1112 struct ttm_validate_buffer *val_buf)
1114 struct vmw_private *dev_priv = res->dev_priv;
1116 SVGA3dCmdHeader header;
1117 SVGA3dCmdBindGBSurface body;
1120 SVGA3dCmdHeader header;
1121 SVGA3dCmdUpdateGBSurface body;
1123 uint32_t submit_size;
1124 struct ttm_buffer_object *bo = val_buf->bo;
1126 BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
1128 submit_size = sizeof(*cmd1) + (res->backup_dirty ? sizeof(*cmd2) : 0);
1130 cmd1 = vmw_fifo_reserve(dev_priv, submit_size);
1131 if (unlikely(cmd1 == NULL)) {
1132 DRM_ERROR("Failed reserving FIFO space for surface "
1137 cmd1->header.id = SVGA_3D_CMD_BIND_GB_SURFACE;
1138 cmd1->header.size = sizeof(cmd1->body);
1139 cmd1->body.sid = res->id;
1140 cmd1->body.mobid = bo->mem.start;
1141 if (res->backup_dirty) {
1142 cmd2 = (void *) &cmd1[1];
1143 cmd2->header.id = SVGA_3D_CMD_UPDATE_GB_SURFACE;
1144 cmd2->header.size = sizeof(cmd2->body);
1145 cmd2->body.sid = res->id;
1146 res->backup_dirty = false;
1148 vmw_fifo_commit(dev_priv, submit_size);
1153 static int vmw_gb_surface_unbind(struct vmw_resource *res,
1155 struct ttm_validate_buffer *val_buf)
1157 struct vmw_private *dev_priv = res->dev_priv;
1158 struct ttm_buffer_object *bo = val_buf->bo;
1159 struct vmw_fence_obj *fence;
1162 SVGA3dCmdHeader header;
1163 SVGA3dCmdReadbackGBSurface body;
1166 SVGA3dCmdHeader header;
1167 SVGA3dCmdInvalidateGBSurface body;
1170 SVGA3dCmdHeader header;
1171 SVGA3dCmdBindGBSurface body;
1173 uint32_t submit_size;
1177 BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
1179 submit_size = sizeof(*cmd3) + (readback ? sizeof(*cmd1) : sizeof(*cmd2));
1180 cmd = vmw_fifo_reserve(dev_priv, submit_size);
1181 if (unlikely(cmd == NULL)) {
1182 DRM_ERROR("Failed reserving FIFO space for surface "
1188 cmd1 = (void *) cmd;
1189 cmd1->header.id = SVGA_3D_CMD_READBACK_GB_SURFACE;
1190 cmd1->header.size = sizeof(cmd1->body);
1191 cmd1->body.sid = res->id;
1192 cmd3 = (void *) &cmd1[1];
1194 cmd2 = (void *) cmd;
1195 cmd2->header.id = SVGA_3D_CMD_INVALIDATE_GB_SURFACE;
1196 cmd2->header.size = sizeof(cmd2->body);
1197 cmd2->body.sid = res->id;
1198 cmd3 = (void *) &cmd2[1];
1201 cmd3->header.id = SVGA_3D_CMD_BIND_GB_SURFACE;
1202 cmd3->header.size = sizeof(cmd3->body);
1203 cmd3->body.sid = res->id;
1204 cmd3->body.mobid = SVGA3D_INVALID_ID;
1206 vmw_fifo_commit(dev_priv, submit_size);
1209 * Create a fence object and fence the backup buffer.
1212 (void) vmw_execbuf_fence_commands(NULL, dev_priv,
1215 vmw_fence_single_bo(val_buf->bo, fence);
1217 if (likely(fence != NULL))
1218 vmw_fence_obj_unreference(&fence);
1223 static int vmw_gb_surface_destroy(struct vmw_resource *res)
1225 struct vmw_private *dev_priv = res->dev_priv;
1226 struct vmw_surface *srf = vmw_res_to_srf(res);
1228 SVGA3dCmdHeader header;
1229 SVGA3dCmdDestroyGBSurface body;
1232 if (likely(res->id == -1))
1235 mutex_lock(&dev_priv->binding_mutex);
1236 vmw_view_surface_list_destroy(dev_priv, &srf->view_list);
1237 vmw_binding_res_list_scrub(&res->binding_head);
1239 cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
1240 if (unlikely(cmd == NULL)) {
1241 DRM_ERROR("Failed reserving FIFO space for surface "
1243 mutex_unlock(&dev_priv->binding_mutex);
1247 cmd->header.id = SVGA_3D_CMD_DESTROY_GB_SURFACE;
1248 cmd->header.size = sizeof(cmd->body);
1249 cmd->body.sid = res->id;
1250 vmw_fifo_commit(dev_priv, sizeof(*cmd));
1251 mutex_unlock(&dev_priv->binding_mutex);
1252 vmw_resource_release_id(res);
1253 vmw_fifo_resource_dec(dev_priv);
1260 * vmw_gb_surface_define_ioctl - Ioctl function implementing
1261 * the user surface define functionality.
1263 * @dev: Pointer to a struct drm_device.
1264 * @data: Pointer to data copied from / to user-space.
1265 * @file_priv: Pointer to a drm file private structure.
1267 int vmw_gb_surface_define_ioctl(struct drm_device *dev, void *data,
1268 struct drm_file *file_priv)
1270 struct vmw_private *dev_priv = vmw_priv(dev);
1271 struct vmw_user_surface *user_srf;
1272 struct vmw_surface *srf;
1273 struct vmw_resource *res;
1274 struct vmw_resource *tmp;
1275 union drm_vmw_gb_surface_create_arg *arg =
1276 (union drm_vmw_gb_surface_create_arg *)data;
1277 struct drm_vmw_gb_surface_create_req *req = &arg->req;
1278 struct drm_vmw_gb_surface_create_rep *rep = &arg->rep;
1279 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
1282 uint32_t backup_handle;
1285 if (unlikely(vmw_user_surface_size == 0))
1286 vmw_user_surface_size = ttm_round_pot(sizeof(*user_srf)) +
1289 size = vmw_user_surface_size + 128;
1291 /* Define a surface based on the parameters. */
1292 ret = vmw_surface_gb_priv_define(dev,
1296 req->drm_surface_flags & drm_vmw_surface_flag_scanout,
1298 req->multisample_count,
1302 if (unlikely(ret != 0))
1305 user_srf = container_of(srf, struct vmw_user_surface, srf);
1306 if (drm_is_primary_client(file_priv))
1307 user_srf->master = drm_master_get(file_priv->master);
1309 ret = ttm_read_lock(&dev_priv->reservation_sem, true);
1310 if (unlikely(ret != 0))
1313 res = &user_srf->srf.res;
1316 if (req->buffer_handle != SVGA3D_INVALID_ID) {
1317 ret = vmw_user_dmabuf_lookup(tfile, req->buffer_handle,
1319 if (ret == 0 && res->backup->base.num_pages * PAGE_SIZE <
1321 DRM_ERROR("Surface backup buffer is too small.\n");
1322 vmw_dmabuf_unreference(&res->backup);
1326 } else if (req->drm_surface_flags & drm_vmw_surface_flag_create_buffer)
1327 ret = vmw_user_dmabuf_alloc(dev_priv, tfile,
1329 req->drm_surface_flags &
1330 drm_vmw_surface_flag_shareable,
1334 if (unlikely(ret != 0)) {
1335 vmw_resource_unreference(&res);
1339 tmp = vmw_resource_reference(res);
1340 ret = ttm_prime_object_init(tfile, res->backup_size, &user_srf->prime,
1341 req->drm_surface_flags &
1342 drm_vmw_surface_flag_shareable,
1344 &vmw_user_surface_base_release, NULL);
1346 if (unlikely(ret != 0)) {
1347 vmw_resource_unreference(&tmp);
1348 vmw_resource_unreference(&res);
1352 rep->handle = user_srf->prime.base.hash.key;
1353 rep->backup_size = res->backup_size;
1355 rep->buffer_map_handle =
1356 drm_vma_node_offset_addr(&res->backup->base.vma_node);
1357 rep->buffer_size = res->backup->base.num_pages * PAGE_SIZE;
1358 rep->buffer_handle = backup_handle;
1360 rep->buffer_map_handle = 0;
1361 rep->buffer_size = 0;
1362 rep->buffer_handle = SVGA3D_INVALID_ID;
1365 vmw_resource_unreference(&res);
1368 ttm_read_unlock(&dev_priv->reservation_sem);
1373 * vmw_gb_surface_reference_ioctl - Ioctl function implementing
1374 * the user surface reference functionality.
1376 * @dev: Pointer to a struct drm_device.
1377 * @data: Pointer to data copied from / to user-space.
1378 * @file_priv: Pointer to a drm file private structure.
1380 int vmw_gb_surface_reference_ioctl(struct drm_device *dev, void *data,
1381 struct drm_file *file_priv)
1383 struct vmw_private *dev_priv = vmw_priv(dev);
1384 union drm_vmw_gb_surface_reference_arg *arg =
1385 (union drm_vmw_gb_surface_reference_arg *)data;
1386 struct drm_vmw_surface_arg *req = &arg->req;
1387 struct drm_vmw_gb_surface_ref_rep *rep = &arg->rep;
1388 struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
1389 struct vmw_surface *srf;
1390 struct vmw_user_surface *user_srf;
1391 struct ttm_base_object *base;
1392 uint32_t backup_handle;
1395 ret = vmw_surface_handle_reference(dev_priv, file_priv, req->sid,
1396 req->handle_type, &base);
1397 if (unlikely(ret != 0))
1400 user_srf = container_of(base, struct vmw_user_surface, prime.base);
1401 srf = &user_srf->srf;
1402 if (srf->res.backup == NULL) {
1403 DRM_ERROR("Shared GB surface is missing a backup buffer.\n");
1404 goto out_bad_resource;
1407 mutex_lock(&dev_priv->cmdbuf_mutex); /* Protect res->backup */
1408 ret = vmw_user_dmabuf_reference(tfile, srf->res.backup,
1410 mutex_unlock(&dev_priv->cmdbuf_mutex);
1412 if (unlikely(ret != 0)) {
1413 DRM_ERROR("Could not add a reference to a GB surface "
1414 "backup buffer.\n");
1415 (void) ttm_ref_object_base_unref(tfile, base->hash.key,
1417 goto out_bad_resource;
1420 rep->creq.svga3d_flags = srf->flags;
1421 rep->creq.format = srf->format;
1422 rep->creq.mip_levels = srf->mip_levels[0];
1423 rep->creq.drm_surface_flags = 0;
1424 rep->creq.multisample_count = srf->multisample_count;
1425 rep->creq.autogen_filter = srf->autogen_filter;
1426 rep->creq.array_size = srf->array_size;
1427 rep->creq.buffer_handle = backup_handle;
1428 rep->creq.base_size = srf->base_size;
1429 rep->crep.handle = user_srf->prime.base.hash.key;
1430 rep->crep.backup_size = srf->res.backup_size;
1431 rep->crep.buffer_handle = backup_handle;
1432 rep->crep.buffer_map_handle =
1433 drm_vma_node_offset_addr(&srf->res.backup->base.vma_node);
1434 rep->crep.buffer_size = srf->res.backup->base.num_pages * PAGE_SIZE;
1437 ttm_base_object_unref(&base);
1443 * vmw_surface_gb_priv_define - Define a private GB surface
1445 * @dev: Pointer to a struct drm_device
1446 * @user_accounting_size: Used to track user-space memory usage, set
1447 * to 0 for kernel mode only memory
1448 * @svga3d_flags: SVGA3d surface flags for the device
1449 * @format: requested surface format
1450 * @for_scanout: true if inteded to be used for scanout buffer
1451 * @num_mip_levels: number of MIP levels
1452 * @multisample_count:
1453 * @array_size: Surface array size.
1454 * @size: width, heigh, depth of the surface requested
1455 * @user_srf_out: allocated user_srf. Set to NULL on failure.
1457 * GB surfaces allocated by this function will not have a user mode handle, and
1458 * thus will only be visible to vmwgfx. For optimization reasons the
1459 * surface may later be given a user mode handle by another function to make
1460 * it available to user mode drivers.
1462 int vmw_surface_gb_priv_define(struct drm_device *dev,
1463 uint32_t user_accounting_size,
1464 uint32_t svga3d_flags,
1465 SVGA3dSurfaceFormat format,
1467 uint32_t num_mip_levels,
1468 uint32_t multisample_count,
1469 uint32_t array_size,
1470 struct drm_vmw_size size,
1471 struct vmw_surface **srf_out)
1473 struct vmw_private *dev_priv = vmw_priv(dev);
1474 struct vmw_user_surface *user_srf;
1475 struct vmw_surface *srf;
1482 if (!svga3dsurface_is_screen_target_format(format)) {
1483 DRM_ERROR("Invalid Screen Target surface format.");
1487 const struct svga3d_surface_desc *desc;
1489 desc = svga3dsurface_get_desc(format);
1490 if (unlikely(desc->block_desc == SVGA3DBLOCKDESC_NONE)) {
1491 DRM_ERROR("Invalid surface format.\n");
1496 /* array_size must be null for non-GL3 host. */
1497 if (array_size > 0 && !dev_priv->has_dx) {
1498 DRM_ERROR("Tried to create DX surface on non-DX host.\n");
1502 ret = ttm_read_lock(&dev_priv->reservation_sem, true);
1503 if (unlikely(ret != 0))
1506 ret = ttm_mem_global_alloc(vmw_mem_glob(dev_priv),
1507 user_accounting_size, false, true);
1508 if (unlikely(ret != 0)) {
1509 if (ret != -ERESTARTSYS)
1510 DRM_ERROR("Out of graphics memory for surface"
1515 user_srf = kzalloc(sizeof(*user_srf), GFP_KERNEL);
1516 if (unlikely(user_srf == NULL)) {
1518 goto out_no_user_srf;
1521 *srf_out = &user_srf->srf;
1522 user_srf->size = user_accounting_size;
1523 user_srf->prime.base.shareable = false;
1524 user_srf->prime.base.tfile = NULL;
1526 srf = &user_srf->srf;
1527 srf->flags = svga3d_flags;
1528 srf->format = format;
1529 srf->scanout = for_scanout;
1530 srf->mip_levels[0] = num_mip_levels;
1533 srf->offsets = NULL;
1534 srf->base_size = size;
1535 srf->autogen_filter = SVGA3D_TEX_FILTER_NONE;
1536 srf->array_size = array_size;
1537 srf->multisample_count = multisample_count;
1540 num_layers = array_size;
1541 else if (svga3d_flags & SVGA3D_SURFACE_CUBEMAP)
1542 num_layers = SVGA3D_MAX_SURFACE_FACES;
1546 srf->res.backup_size =
1547 svga3dsurface_get_serialized_size(srf->format,
1552 if (srf->flags & SVGA3D_SURFACE_BIND_STREAM_OUTPUT)
1553 srf->res.backup_size += sizeof(SVGA3dDXSOState);
1555 if (dev_priv->active_display_unit == vmw_du_screen_target &&
1557 srf->flags |= SVGA3D_SURFACE_SCREENTARGET;
1560 * From this point, the generic resource management functions
1561 * destroy the object on failure.
1563 ret = vmw_surface_init(dev_priv, srf, vmw_user_surface_free);
1565 ttm_read_unlock(&dev_priv->reservation_sem);
1569 ttm_mem_global_free(vmw_mem_glob(dev_priv), user_accounting_size);
1572 ttm_read_unlock(&dev_priv->reservation_sem);