1 /**************************************************************************
3 * Copyright © 2009 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 <drm/vmwgfx_drm.h>
30 #include <drm/ttm/ttm_object.h>
31 #include <drm/ttm/ttm_placement.h>
34 struct vmw_user_context
{
35 struct ttm_base_object base
;
36 struct vmw_resource res
;
39 struct vmw_user_surface
{
40 struct ttm_base_object base
;
41 struct vmw_surface srf
;
45 struct vmw_user_dma_buffer
{
46 struct ttm_base_object base
;
47 struct vmw_dma_buffer dma
;
50 struct vmw_bo_user_rep
{
56 struct vmw_resource res
;
60 struct vmw_user_stream
{
61 struct ttm_base_object base
;
62 struct vmw_stream stream
;
65 struct vmw_surface_offset
{
72 static uint64_t vmw_user_context_size
;
73 static uint64_t vmw_user_surface_size
;
74 static uint64_t vmw_user_stream_size
;
76 static inline struct vmw_dma_buffer
*
77 vmw_dma_buffer(struct ttm_buffer_object
*bo
)
79 return container_of(bo
, struct vmw_dma_buffer
, base
);
82 static inline struct vmw_user_dma_buffer
*
83 vmw_user_dma_buffer(struct ttm_buffer_object
*bo
)
85 struct vmw_dma_buffer
*vmw_bo
= vmw_dma_buffer(bo
);
86 return container_of(vmw_bo
, struct vmw_user_dma_buffer
, dma
);
89 struct vmw_resource
*vmw_resource_reference(struct vmw_resource
*res
)
97 * vmw_resource_release_id - release a resource id to the id manager.
99 * @res: Pointer to the resource.
101 * Release the resource id to the resource id manager and set it to -1
103 static void vmw_resource_release_id(struct vmw_resource
*res
)
105 struct vmw_private
*dev_priv
= res
->dev_priv
;
107 write_lock(&dev_priv
->resource_lock
);
109 idr_remove(res
->idr
, res
->id
);
111 write_unlock(&dev_priv
->resource_lock
);
114 static void vmw_resource_release(struct kref
*kref
)
116 struct vmw_resource
*res
=
117 container_of(kref
, struct vmw_resource
, kref
);
118 struct vmw_private
*dev_priv
= res
->dev_priv
;
120 struct idr
*idr
= res
->idr
;
123 if (res
->remove_from_lists
!= NULL
)
124 res
->remove_from_lists(res
);
125 write_unlock(&dev_priv
->resource_lock
);
127 if (likely(res
->hw_destroy
!= NULL
))
128 res
->hw_destroy(res
);
130 if (res
->res_free
!= NULL
)
135 write_lock(&dev_priv
->resource_lock
);
141 void vmw_resource_unreference(struct vmw_resource
**p_res
)
143 struct vmw_resource
*res
= *p_res
;
144 struct vmw_private
*dev_priv
= res
->dev_priv
;
147 write_lock(&dev_priv
->resource_lock
);
148 kref_put(&res
->kref
, vmw_resource_release
);
149 write_unlock(&dev_priv
->resource_lock
);
154 * vmw_resource_alloc_id - release a resource id to the id manager.
156 * @dev_priv: Pointer to the device private structure.
157 * @res: Pointer to the resource.
159 * Allocate the lowest free resource from the resource manager, and set
160 * @res->id to that id. Returns 0 on success and -ENOMEM on failure.
162 static int vmw_resource_alloc_id(struct vmw_private
*dev_priv
,
163 struct vmw_resource
*res
)
167 BUG_ON(res
->id
!= -1);
170 if (unlikely(idr_pre_get(res
->idr
, GFP_KERNEL
) == 0))
173 write_lock(&dev_priv
->resource_lock
);
174 ret
= idr_get_new_above(res
->idr
, res
, 1, &res
->id
);
175 write_unlock(&dev_priv
->resource_lock
);
177 } while (ret
== -EAGAIN
);
183 static int vmw_resource_init(struct vmw_private
*dev_priv
,
184 struct vmw_resource
*res
,
186 enum ttm_object_type obj_type
,
188 void (*res_free
) (struct vmw_resource
*res
),
189 void (*remove_from_lists
)
190 (struct vmw_resource
*res
))
192 kref_init(&res
->kref
);
193 res
->hw_destroy
= NULL
;
194 res
->res_free
= res_free
;
195 res
->remove_from_lists
= remove_from_lists
;
196 res
->res_type
= obj_type
;
199 res
->dev_priv
= dev_priv
;
200 INIT_LIST_HEAD(&res
->query_head
);
201 INIT_LIST_HEAD(&res
->validate_head
);
206 return vmw_resource_alloc_id(dev_priv
, res
);
210 * vmw_resource_activate
212 * @res: Pointer to the newly created resource
213 * @hw_destroy: Destroy function. NULL if none.
215 * Activate a resource after the hardware has been made aware of it.
216 * Set tye destroy function to @destroy. Typically this frees the
217 * resource and destroys the hardware resources associated with it.
218 * Activate basically means that the function vmw_resource_lookup will
222 static void vmw_resource_activate(struct vmw_resource
*res
,
223 void (*hw_destroy
) (struct vmw_resource
*))
225 struct vmw_private
*dev_priv
= res
->dev_priv
;
227 write_lock(&dev_priv
->resource_lock
);
229 res
->hw_destroy
= hw_destroy
;
230 write_unlock(&dev_priv
->resource_lock
);
233 struct vmw_resource
*vmw_resource_lookup(struct vmw_private
*dev_priv
,
234 struct idr
*idr
, int id
)
236 struct vmw_resource
*res
;
238 read_lock(&dev_priv
->resource_lock
);
239 res
= idr_find(idr
, id
);
240 if (res
&& res
->avail
)
241 kref_get(&res
->kref
);
244 read_unlock(&dev_priv
->resource_lock
);
246 if (unlikely(res
== NULL
))
253 * Context management:
256 static void vmw_hw_context_destroy(struct vmw_resource
*res
)
259 struct vmw_private
*dev_priv
= res
->dev_priv
;
261 SVGA3dCmdHeader header
;
262 SVGA3dCmdDestroyContext body
;
266 vmw_execbuf_release_pinned_bo(dev_priv
, true, res
->id
);
268 cmd
= vmw_fifo_reserve(dev_priv
, sizeof(*cmd
));
269 if (unlikely(cmd
== NULL
)) {
270 DRM_ERROR("Failed reserving FIFO space for surface "
275 cmd
->header
.id
= cpu_to_le32(SVGA_3D_CMD_CONTEXT_DESTROY
);
276 cmd
->header
.size
= cpu_to_le32(sizeof(cmd
->body
));
277 cmd
->body
.cid
= cpu_to_le32(res
->id
);
279 vmw_fifo_commit(dev_priv
, sizeof(*cmd
));
280 vmw_3d_resource_dec(dev_priv
, false);
283 static int vmw_context_init(struct vmw_private
*dev_priv
,
284 struct vmw_resource
*res
,
285 void (*res_free
) (struct vmw_resource
*res
))
290 SVGA3dCmdHeader header
;
291 SVGA3dCmdDefineContext body
;
294 ret
= vmw_resource_init(dev_priv
, res
, &dev_priv
->context_idr
,
295 VMW_RES_CONTEXT
, false, res_free
, NULL
);
297 if (unlikely(ret
!= 0)) {
298 DRM_ERROR("Failed to allocate a resource id.\n");
302 if (unlikely(res
->id
>= SVGA3D_MAX_CONTEXT_IDS
)) {
303 DRM_ERROR("Out of hw context ids.\n");
304 vmw_resource_unreference(&res
);
308 cmd
= vmw_fifo_reserve(dev_priv
, sizeof(*cmd
));
309 if (unlikely(cmd
== NULL
)) {
310 DRM_ERROR("Fifo reserve failed.\n");
311 vmw_resource_unreference(&res
);
315 cmd
->header
.id
= cpu_to_le32(SVGA_3D_CMD_CONTEXT_DEFINE
);
316 cmd
->header
.size
= cpu_to_le32(sizeof(cmd
->body
));
317 cmd
->body
.cid
= cpu_to_le32(res
->id
);
319 vmw_fifo_commit(dev_priv
, sizeof(*cmd
));
320 (void) vmw_3d_resource_inc(dev_priv
, false);
321 vmw_resource_activate(res
, vmw_hw_context_destroy
);
325 if (res_free
== NULL
)
332 struct vmw_resource
*vmw_context_alloc(struct vmw_private
*dev_priv
)
334 struct vmw_resource
*res
= kmalloc(sizeof(*res
), GFP_KERNEL
);
337 if (unlikely(res
== NULL
))
340 ret
= vmw_context_init(dev_priv
, res
, NULL
);
341 return (ret
== 0) ? res
: NULL
;
345 * User-space context management:
348 static void vmw_user_context_free(struct vmw_resource
*res
)
350 struct vmw_user_context
*ctx
=
351 container_of(res
, struct vmw_user_context
, res
);
352 struct vmw_private
*dev_priv
= res
->dev_priv
;
355 ttm_mem_global_free(vmw_mem_glob(dev_priv
),
356 vmw_user_context_size
);
360 * This function is called when user space has no more references on the
361 * base object. It releases the base-object's reference on the resource object.
364 static void vmw_user_context_base_release(struct ttm_base_object
**p_base
)
366 struct ttm_base_object
*base
= *p_base
;
367 struct vmw_user_context
*ctx
=
368 container_of(base
, struct vmw_user_context
, base
);
369 struct vmw_resource
*res
= &ctx
->res
;
372 vmw_resource_unreference(&res
);
375 int vmw_context_destroy_ioctl(struct drm_device
*dev
, void *data
,
376 struct drm_file
*file_priv
)
378 struct vmw_private
*dev_priv
= vmw_priv(dev
);
379 struct vmw_resource
*res
;
380 struct vmw_user_context
*ctx
;
381 struct drm_vmw_context_arg
*arg
= (struct drm_vmw_context_arg
*)data
;
382 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
385 res
= vmw_resource_lookup(dev_priv
, &dev_priv
->context_idr
, arg
->cid
);
386 if (unlikely(res
== NULL
))
389 if (res
->res_free
!= &vmw_user_context_free
) {
394 ctx
= container_of(res
, struct vmw_user_context
, res
);
395 if (ctx
->base
.tfile
!= tfile
&& !ctx
->base
.shareable
) {
400 ttm_ref_object_base_unref(tfile
, ctx
->base
.hash
.key
, TTM_REF_USAGE
);
402 vmw_resource_unreference(&res
);
406 int vmw_context_define_ioctl(struct drm_device
*dev
, void *data
,
407 struct drm_file
*file_priv
)
409 struct vmw_private
*dev_priv
= vmw_priv(dev
);
410 struct vmw_user_context
*ctx
;
411 struct vmw_resource
*res
;
412 struct vmw_resource
*tmp
;
413 struct drm_vmw_context_arg
*arg
= (struct drm_vmw_context_arg
*)data
;
414 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
415 struct vmw_master
*vmaster
= vmw_master(file_priv
->master
);
420 * Approximate idr memory usage with 128 bytes. It will be limited
421 * by maximum number_of contexts anyway.
424 if (unlikely(vmw_user_context_size
== 0))
425 vmw_user_context_size
= ttm_round_pot(sizeof(*ctx
)) + 128;
427 ret
= ttm_read_lock(&vmaster
->lock
, true);
428 if (unlikely(ret
!= 0))
431 ret
= ttm_mem_global_alloc(vmw_mem_glob(dev_priv
),
432 vmw_user_context_size
,
434 if (unlikely(ret
!= 0)) {
435 if (ret
!= -ERESTARTSYS
)
436 DRM_ERROR("Out of graphics memory for context"
441 ctx
= kmalloc(sizeof(*ctx
), GFP_KERNEL
);
442 if (unlikely(ctx
== NULL
)) {
443 ttm_mem_global_free(vmw_mem_glob(dev_priv
),
444 vmw_user_context_size
);
450 ctx
->base
.shareable
= false;
451 ctx
->base
.tfile
= NULL
;
454 * From here on, the destructor takes over resource freeing.
457 ret
= vmw_context_init(dev_priv
, res
, vmw_user_context_free
);
458 if (unlikely(ret
!= 0))
461 tmp
= vmw_resource_reference(&ctx
->res
);
462 ret
= ttm_base_object_init(tfile
, &ctx
->base
, false, VMW_RES_CONTEXT
,
463 &vmw_user_context_base_release
, NULL
);
465 if (unlikely(ret
!= 0)) {
466 vmw_resource_unreference(&tmp
);
472 vmw_resource_unreference(&res
);
474 ttm_read_unlock(&vmaster
->lock
);
479 int vmw_context_check(struct vmw_private
*dev_priv
,
480 struct ttm_object_file
*tfile
,
482 struct vmw_resource
**p_res
)
484 struct vmw_resource
*res
;
487 read_lock(&dev_priv
->resource_lock
);
488 res
= idr_find(&dev_priv
->context_idr
, id
);
489 if (res
&& res
->avail
) {
490 struct vmw_user_context
*ctx
=
491 container_of(res
, struct vmw_user_context
, res
);
492 if (ctx
->base
.tfile
!= tfile
&& !ctx
->base
.shareable
)
495 *p_res
= vmw_resource_reference(res
);
498 read_unlock(&dev_priv
->resource_lock
);
509 * Size table for the supported SVGA3D surface formats. It consists of
510 * two values. The bpp value and the s_bpp value which is short for
511 * "stride bits per pixel" The values are given in such a way that the
512 * minimum stride for the image is calculated using
514 * min_stride = w*s_bpp
516 * and the total memory requirement for the image is
518 * h*min_stride*bpp/s_bpp
521 static const struct vmw_bpp vmw_sf_bpp
[] = {
522 [SVGA3D_FORMAT_INVALID
] = {0, 0},
523 [SVGA3D_X8R8G8B8
] = {32, 32},
524 [SVGA3D_A8R8G8B8
] = {32, 32},
525 [SVGA3D_R5G6B5
] = {16, 16},
526 [SVGA3D_X1R5G5B5
] = {16, 16},
527 [SVGA3D_A1R5G5B5
] = {16, 16},
528 [SVGA3D_A4R4G4B4
] = {16, 16},
529 [SVGA3D_Z_D32
] = {32, 32},
530 [SVGA3D_Z_D16
] = {16, 16},
531 [SVGA3D_Z_D24S8
] = {32, 32},
532 [SVGA3D_Z_D15S1
] = {16, 16},
533 [SVGA3D_LUMINANCE8
] = {8, 8},
534 [SVGA3D_LUMINANCE4_ALPHA4
] = {8, 8},
535 [SVGA3D_LUMINANCE16
] = {16, 16},
536 [SVGA3D_LUMINANCE8_ALPHA8
] = {16, 16},
537 [SVGA3D_DXT1
] = {4, 16},
538 [SVGA3D_DXT2
] = {8, 32},
539 [SVGA3D_DXT3
] = {8, 32},
540 [SVGA3D_DXT4
] = {8, 32},
541 [SVGA3D_DXT5
] = {8, 32},
542 [SVGA3D_BUMPU8V8
] = {16, 16},
543 [SVGA3D_BUMPL6V5U5
] = {16, 16},
544 [SVGA3D_BUMPX8L8V8U8
] = {32, 32},
545 [SVGA3D_ARGB_S10E5
] = {16, 16},
546 [SVGA3D_ARGB_S23E8
] = {32, 32},
547 [SVGA3D_A2R10G10B10
] = {32, 32},
548 [SVGA3D_V8U8
] = {16, 16},
549 [SVGA3D_Q8W8V8U8
] = {32, 32},
550 [SVGA3D_CxV8U8
] = {16, 16},
551 [SVGA3D_X8L8V8U8
] = {32, 32},
552 [SVGA3D_A2W10V10U10
] = {32, 32},
553 [SVGA3D_ALPHA8
] = {8, 8},
554 [SVGA3D_R_S10E5
] = {16, 16},
555 [SVGA3D_R_S23E8
] = {32, 32},
556 [SVGA3D_RG_S10E5
] = {16, 16},
557 [SVGA3D_RG_S23E8
] = {32, 32},
558 [SVGA3D_BUFFER
] = {8, 8},
559 [SVGA3D_Z_D24X8
] = {32, 32},
560 [SVGA3D_V16U16
] = {32, 32},
561 [SVGA3D_G16R16
] = {32, 32},
562 [SVGA3D_A16B16G16R16
] = {64, 64},
563 [SVGA3D_UYVY
] = {12, 12},
564 [SVGA3D_YUY2
] = {12, 12},
565 [SVGA3D_NV12
] = {12, 8},
566 [SVGA3D_AYUV
] = {32, 32},
567 [SVGA3D_BC4_UNORM
] = {4, 16},
568 [SVGA3D_BC5_UNORM
] = {8, 32},
569 [SVGA3D_Z_DF16
] = {16, 16},
570 [SVGA3D_Z_DF24
] = {24, 24},
571 [SVGA3D_Z_D24S8_INT
] = {32, 32}
576 * Surface management.
579 struct vmw_surface_dma
{
580 SVGA3dCmdHeader header
;
581 SVGA3dCmdSurfaceDMA body
;
583 SVGA3dCmdSurfaceDMASuffix suffix
;
586 struct vmw_surface_define
{
587 SVGA3dCmdHeader header
;
588 SVGA3dCmdDefineSurface body
;
591 struct vmw_surface_destroy
{
592 SVGA3dCmdHeader header
;
593 SVGA3dCmdDestroySurface body
;
598 * vmw_surface_dma_size - Compute fifo size for a dma command.
600 * @srf: Pointer to a struct vmw_surface
602 * Computes the required size for a surface dma command for backup or
603 * restoration of the surface represented by @srf.
605 static inline uint32_t vmw_surface_dma_size(const struct vmw_surface
*srf
)
607 return srf
->num_sizes
* sizeof(struct vmw_surface_dma
);
612 * vmw_surface_define_size - Compute fifo size for a surface define command.
614 * @srf: Pointer to a struct vmw_surface
616 * Computes the required size for a surface define command for the definition
617 * of the surface represented by @srf.
619 static inline uint32_t vmw_surface_define_size(const struct vmw_surface
*srf
)
621 return sizeof(struct vmw_surface_define
) + srf
->num_sizes
*
627 * vmw_surface_destroy_size - Compute fifo size for a surface destroy command.
629 * Computes the required size for a surface destroy command for the destruction
632 static inline uint32_t vmw_surface_destroy_size(void)
634 return sizeof(struct vmw_surface_destroy
);
638 * vmw_surface_destroy_encode - Encode a surface_destroy command.
640 * @id: The surface id
641 * @cmd_space: Pointer to memory area in which the commands should be encoded.
643 static void vmw_surface_destroy_encode(uint32_t id
,
646 struct vmw_surface_destroy
*cmd
= (struct vmw_surface_destroy
*)
649 cmd
->header
.id
= SVGA_3D_CMD_SURFACE_DESTROY
;
650 cmd
->header
.size
= sizeof(cmd
->body
);
655 * vmw_surface_define_encode - Encode a surface_define command.
657 * @srf: Pointer to a struct vmw_surface object.
658 * @cmd_space: Pointer to memory area in which the commands should be encoded.
660 static void vmw_surface_define_encode(const struct vmw_surface
*srf
,
663 struct vmw_surface_define
*cmd
= (struct vmw_surface_define
*)
665 struct drm_vmw_size
*src_size
;
666 SVGA3dSize
*cmd_size
;
670 cmd_len
= sizeof(cmd
->body
) + srf
->num_sizes
* sizeof(SVGA3dSize
);
672 cmd
->header
.id
= SVGA_3D_CMD_SURFACE_DEFINE
;
673 cmd
->header
.size
= cmd_len
;
674 cmd
->body
.sid
= srf
->res
.id
;
675 cmd
->body
.surfaceFlags
= srf
->flags
;
676 cmd
->body
.format
= cpu_to_le32(srf
->format
);
677 for (i
= 0; i
< DRM_VMW_MAX_SURFACE_FACES
; ++i
)
678 cmd
->body
.face
[i
].numMipLevels
= srf
->mip_levels
[i
];
681 cmd_size
= (SVGA3dSize
*) cmd
;
682 src_size
= srf
->sizes
;
684 for (i
= 0; i
< srf
->num_sizes
; ++i
, cmd_size
++, src_size
++) {
685 cmd_size
->width
= src_size
->width
;
686 cmd_size
->height
= src_size
->height
;
687 cmd_size
->depth
= src_size
->depth
;
693 * vmw_surface_dma_encode - Encode a surface_dma command.
695 * @srf: Pointer to a struct vmw_surface object.
696 * @cmd_space: Pointer to memory area in which the commands should be encoded.
697 * @ptr: Pointer to an SVGAGuestPtr indicating where the surface contents
698 * should be placed or read from.
699 * @to_surface: Boolean whether to DMA to the surface or from the surface.
701 static void vmw_surface_dma_encode(struct vmw_surface
*srf
,
703 const SVGAGuestPtr
*ptr
,
707 uint32_t bpp
= vmw_sf_bpp
[srf
->format
].bpp
;
708 uint32_t stride_bpp
= vmw_sf_bpp
[srf
->format
].s_bpp
;
709 struct vmw_surface_dma
*cmd
= (struct vmw_surface_dma
*)cmd_space
;
711 for (i
= 0; i
< srf
->num_sizes
; ++i
) {
712 SVGA3dCmdHeader
*header
= &cmd
->header
;
713 SVGA3dCmdSurfaceDMA
*body
= &cmd
->body
;
714 SVGA3dCopyBox
*cb
= &cmd
->cb
;
715 SVGA3dCmdSurfaceDMASuffix
*suffix
= &cmd
->suffix
;
716 const struct vmw_surface_offset
*cur_offset
= &srf
->offsets
[i
];
717 const struct drm_vmw_size
*cur_size
= &srf
->sizes
[i
];
719 header
->id
= SVGA_3D_CMD_SURFACE_DMA
;
720 header
->size
= sizeof(*body
) + sizeof(*cb
) + sizeof(*suffix
);
722 body
->guest
.ptr
= *ptr
;
723 body
->guest
.ptr
.offset
+= cur_offset
->bo_offset
;
724 body
->guest
.pitch
= (cur_size
->width
* stride_bpp
+ 7) >> 3;
725 body
->host
.sid
= srf
->res
.id
;
726 body
->host
.face
= cur_offset
->face
;
727 body
->host
.mipmap
= cur_offset
->mip
;
728 body
->transfer
= ((to_surface
) ? SVGA3D_WRITE_HOST_VRAM
:
729 SVGA3D_READ_HOST_VRAM
);
736 cb
->w
= cur_size
->width
;
737 cb
->h
= cur_size
->height
;
738 cb
->d
= cur_size
->depth
;
740 suffix
->suffixSize
= sizeof(*suffix
);
741 suffix
->maximumOffset
= body
->guest
.pitch
*cur_size
->height
*
742 cur_size
->depth
*bpp
/ stride_bpp
;
743 suffix
->flags
.discard
= 0;
744 suffix
->flags
.unsynchronized
= 0;
745 suffix
->flags
.reserved
= 0;
751 static void vmw_hw_surface_destroy(struct vmw_resource
*res
)
754 struct vmw_private
*dev_priv
= res
->dev_priv
;
755 struct vmw_surface
*srf
;
760 cmd
= vmw_fifo_reserve(dev_priv
, vmw_surface_destroy_size());
761 if (unlikely(cmd
== NULL
)) {
762 DRM_ERROR("Failed reserving FIFO space for surface "
767 vmw_surface_destroy_encode(res
->id
, cmd
);
768 vmw_fifo_commit(dev_priv
, vmw_surface_destroy_size());
771 * used_memory_size_atomic, or separate lock
772 * to avoid taking dev_priv::cmdbuf_mutex in
776 mutex_lock(&dev_priv
->cmdbuf_mutex
);
777 srf
= container_of(res
, struct vmw_surface
, res
);
778 dev_priv
->used_memory_size
-= srf
->backup_size
;
779 mutex_unlock(&dev_priv
->cmdbuf_mutex
);
782 vmw_3d_resource_dec(dev_priv
, false);
785 void vmw_surface_res_free(struct vmw_resource
*res
)
787 struct vmw_surface
*srf
= container_of(res
, struct vmw_surface
, res
);
790 ttm_bo_unref(&srf
->backup
);
793 kfree(srf
->snooper
.image
);
799 * vmw_surface_do_validate - make a surface available to the device.
801 * @dev_priv: Pointer to a device private struct.
802 * @srf: Pointer to a struct vmw_surface.
804 * If the surface doesn't have a hw id, allocate one, and optionally
805 * DMA the backed up surface contents to the device.
807 * Returns -EBUSY if there wasn't sufficient device resources to
808 * complete the validation. Retry after freeing up resources.
810 * May return other errors if the kernel is out of guest resources.
812 int vmw_surface_do_validate(struct vmw_private
*dev_priv
,
813 struct vmw_surface
*srf
)
815 struct vmw_resource
*res
= &srf
->res
;
816 struct list_head val_list
;
817 struct ttm_validate_buffer val_buf
;
818 uint32_t submit_size
;
822 if (likely(res
->id
!= -1))
825 if (unlikely(dev_priv
->used_memory_size
+ srf
->backup_size
>=
826 dev_priv
->memory_size
))
830 * Reserve- and validate the backup DMA bo.
834 INIT_LIST_HEAD(&val_list
);
835 val_buf
.bo
= ttm_bo_reference(srf
->backup
);
836 list_add_tail(&val_buf
.head
, &val_list
);
837 ret
= ttm_eu_reserve_buffers(&val_list
);
838 if (unlikely(ret
!= 0))
841 ret
= ttm_bo_validate(srf
->backup
, &vmw_srf_placement
,
843 if (unlikely(ret
!= 0))
844 goto out_no_validate
;
848 * Alloc id for the resource.
851 ret
= vmw_resource_alloc_id(dev_priv
, res
);
852 if (unlikely(ret
!= 0)) {
853 DRM_ERROR("Failed to allocate a surface id.\n");
856 if (unlikely(res
->id
>= SVGA3D_MAX_SURFACE_IDS
)) {
863 * Encode surface define- and dma commands.
866 submit_size
= vmw_surface_define_size(srf
);
868 submit_size
+= vmw_surface_dma_size(srf
);
870 cmd
= vmw_fifo_reserve(dev_priv
, submit_size
);
871 if (unlikely(cmd
== NULL
)) {
872 DRM_ERROR("Failed reserving FIFO space for surface "
878 vmw_surface_define_encode(srf
, cmd
);
882 cmd
+= vmw_surface_define_size(srf
);
883 vmw_bo_get_guest_ptr(srf
->backup
, &ptr
);
884 vmw_surface_dma_encode(srf
, cmd
, &ptr
, true);
887 vmw_fifo_commit(dev_priv
, submit_size
);
890 * Create a fence object and fence the backup buffer.
894 struct vmw_fence_obj
*fence
;
896 (void) vmw_execbuf_fence_commands(NULL
, dev_priv
,
898 ttm_eu_fence_buffer_objects(&val_list
, fence
);
899 if (likely(fence
!= NULL
))
900 vmw_fence_obj_unreference(&fence
);
901 ttm_bo_unref(&val_buf
.bo
);
902 ttm_bo_unref(&srf
->backup
);
906 * Surface memory usage accounting.
909 dev_priv
->used_memory_size
+= srf
->backup_size
;
914 vmw_resource_release_id(res
);
918 ttm_eu_backoff_reservation(&val_list
);
921 ttm_bo_unref(&val_buf
.bo
);
926 * vmw_surface_evict - Evict a hw surface.
928 * @dev_priv: Pointer to a device private struct.
929 * @srf: Pointer to a struct vmw_surface
931 * DMA the contents of a hw surface to a backup guest buffer object,
932 * and destroy the hw surface, releasing its id.
934 int vmw_surface_evict(struct vmw_private
*dev_priv
,
935 struct vmw_surface
*srf
)
937 struct vmw_resource
*res
= &srf
->res
;
938 struct list_head val_list
;
939 struct ttm_validate_buffer val_buf
;
940 uint32_t submit_size
;
943 struct vmw_fence_obj
*fence
;
946 BUG_ON(res
->id
== -1);
949 * Create a surface backup buffer object.
953 ret
= ttm_bo_create(&dev_priv
->bdev
, srf
->backup_size
,
955 &vmw_srf_placement
, 0, true,
957 if (unlikely(ret
!= 0))
962 * Reserve- and validate the backup DMA bo.
965 INIT_LIST_HEAD(&val_list
);
966 val_buf
.bo
= ttm_bo_reference(srf
->backup
);
967 list_add_tail(&val_buf
.head
, &val_list
);
968 ret
= ttm_eu_reserve_buffers(&val_list
);
969 if (unlikely(ret
!= 0))
972 ret
= ttm_bo_validate(srf
->backup
, &vmw_srf_placement
,
974 if (unlikely(ret
!= 0))
975 goto out_no_validate
;
979 * Encode the dma- and surface destroy commands.
982 submit_size
= vmw_surface_dma_size(srf
) + vmw_surface_destroy_size();
983 cmd
= vmw_fifo_reserve(dev_priv
, submit_size
);
984 if (unlikely(cmd
== NULL
)) {
985 DRM_ERROR("Failed reserving FIFO space for surface "
991 vmw_bo_get_guest_ptr(srf
->backup
, &ptr
);
992 vmw_surface_dma_encode(srf
, cmd
, &ptr
, false);
993 cmd
+= vmw_surface_dma_size(srf
);
994 vmw_surface_destroy_encode(res
->id
, cmd
);
995 vmw_fifo_commit(dev_priv
, submit_size
);
998 * Surface memory usage accounting.
1001 dev_priv
->used_memory_size
-= srf
->backup_size
;
1004 * Create a fence object and fence the DMA buffer.
1007 (void) vmw_execbuf_fence_commands(NULL
, dev_priv
,
1009 ttm_eu_fence_buffer_objects(&val_list
, fence
);
1010 if (likely(fence
!= NULL
))
1011 vmw_fence_obj_unreference(&fence
);
1012 ttm_bo_unref(&val_buf
.bo
);
1015 * Release the surface ID.
1018 vmw_resource_release_id(res
);
1025 ttm_eu_backoff_reservation(&val_list
);
1027 ttm_bo_unref(&val_buf
.bo
);
1028 ttm_bo_unref(&srf
->backup
);
1034 * vmw_surface_validate - make a surface available to the device, evicting
1035 * other surfaces if needed.
1037 * @dev_priv: Pointer to a device private struct.
1038 * @srf: Pointer to a struct vmw_surface.
1040 * Try to validate a surface and if it fails due to limited device resources,
1041 * repeatedly try to evict other surfaces until the request can be
1044 * May return errors if out of resources.
1046 int vmw_surface_validate(struct vmw_private
*dev_priv
,
1047 struct vmw_surface
*srf
)
1050 struct vmw_surface
*evict_srf
;
1053 write_lock(&dev_priv
->resource_lock
);
1054 list_del_init(&srf
->lru_head
);
1055 write_unlock(&dev_priv
->resource_lock
);
1057 ret
= vmw_surface_do_validate(dev_priv
, srf
);
1058 if (likely(ret
!= -EBUSY
))
1061 write_lock(&dev_priv
->resource_lock
);
1062 if (list_empty(&dev_priv
->surface_lru
)) {
1063 DRM_ERROR("Out of device memory for surfaces.\n");
1065 write_unlock(&dev_priv
->resource_lock
);
1069 evict_srf
= vmw_surface_reference
1070 (list_first_entry(&dev_priv
->surface_lru
,
1073 list_del_init(&evict_srf
->lru_head
);
1075 write_unlock(&dev_priv
->resource_lock
);
1076 (void) vmw_surface_evict(dev_priv
, evict_srf
);
1078 vmw_surface_unreference(&evict_srf
);
1082 if (unlikely(ret
!= 0 && srf
->res
.id
!= -1)) {
1083 write_lock(&dev_priv
->resource_lock
);
1084 list_add_tail(&srf
->lru_head
, &dev_priv
->surface_lru
);
1085 write_unlock(&dev_priv
->resource_lock
);
1093 * vmw_surface_remove_from_lists - Remove surface resources from lookup lists
1095 * @res: Pointer to a struct vmw_resource embedded in a struct vmw_surface
1097 * As part of the resource destruction, remove the surface from any
1100 static void vmw_surface_remove_from_lists(struct vmw_resource
*res
)
1102 struct vmw_surface
*srf
= container_of(res
, struct vmw_surface
, res
);
1104 list_del_init(&srf
->lru_head
);
1107 int vmw_surface_init(struct vmw_private
*dev_priv
,
1108 struct vmw_surface
*srf
,
1109 void (*res_free
) (struct vmw_resource
*res
))
1112 struct vmw_resource
*res
= &srf
->res
;
1114 BUG_ON(res_free
== NULL
);
1115 INIT_LIST_HEAD(&srf
->lru_head
);
1116 ret
= vmw_resource_init(dev_priv
, res
, &dev_priv
->surface_idr
,
1117 VMW_RES_SURFACE
, true, res_free
,
1118 vmw_surface_remove_from_lists
);
1120 if (unlikely(ret
!= 0))
1124 * The surface won't be visible to hardware until a
1128 (void) vmw_3d_resource_inc(dev_priv
, false);
1129 vmw_resource_activate(res
, vmw_hw_surface_destroy
);
1133 static void vmw_user_surface_free(struct vmw_resource
*res
)
1135 struct vmw_surface
*srf
= container_of(res
, struct vmw_surface
, res
);
1136 struct vmw_user_surface
*user_srf
=
1137 container_of(srf
, struct vmw_user_surface
, srf
);
1138 struct vmw_private
*dev_priv
= srf
->res
.dev_priv
;
1139 uint32_t size
= user_srf
->size
;
1142 ttm_bo_unref(&srf
->backup
);
1143 kfree(srf
->offsets
);
1145 kfree(srf
->snooper
.image
);
1147 ttm_mem_global_free(vmw_mem_glob(dev_priv
), size
);
1151 * vmw_resource_unreserve - unreserve resources previously reserved for
1152 * command submission.
1154 * @list_head: list of resources to unreserve.
1156 * Currently only surfaces are considered, and unreserving a surface
1157 * means putting it back on the device's surface lru list,
1158 * so that it can be evicted if necessary.
1159 * This function traverses the resource list and
1160 * checks whether resources are surfaces, and in that case puts them back
1161 * on the device's surface LRU list.
1163 void vmw_resource_unreserve(struct list_head
*list
)
1165 struct vmw_resource
*res
;
1166 struct vmw_surface
*srf
;
1167 rwlock_t
*lock
= NULL
;
1169 list_for_each_entry(res
, list
, validate_head
) {
1171 if (res
->res_free
!= &vmw_surface_res_free
&&
1172 res
->res_free
!= &vmw_user_surface_free
)
1175 if (unlikely(lock
== NULL
)) {
1176 lock
= &res
->dev_priv
->resource_lock
;
1180 srf
= container_of(res
, struct vmw_surface
, res
);
1181 list_del_init(&srf
->lru_head
);
1182 list_add_tail(&srf
->lru_head
, &res
->dev_priv
->surface_lru
);
1190 * Helper function that looks either a surface or dmabuf.
1192 * The pointer this pointed at by out_surf and out_buf needs to be null.
1194 int vmw_user_lookup_handle(struct vmw_private
*dev_priv
,
1195 struct ttm_object_file
*tfile
,
1197 struct vmw_surface
**out_surf
,
1198 struct vmw_dma_buffer
**out_buf
)
1202 BUG_ON(*out_surf
|| *out_buf
);
1204 ret
= vmw_user_surface_lookup_handle(dev_priv
, tfile
, handle
, out_surf
);
1208 ret
= vmw_user_dmabuf_lookup(tfile
, handle
, out_buf
);
1213 int vmw_user_surface_lookup_handle(struct vmw_private
*dev_priv
,
1214 struct ttm_object_file
*tfile
,
1215 uint32_t handle
, struct vmw_surface
**out
)
1217 struct vmw_resource
*res
;
1218 struct vmw_surface
*srf
;
1219 struct vmw_user_surface
*user_srf
;
1220 struct ttm_base_object
*base
;
1223 base
= ttm_base_object_lookup(tfile
, handle
);
1224 if (unlikely(base
== NULL
))
1227 if (unlikely(base
->object_type
!= VMW_RES_SURFACE
))
1228 goto out_bad_resource
;
1230 user_srf
= container_of(base
, struct vmw_user_surface
, base
);
1231 srf
= &user_srf
->srf
;
1234 read_lock(&dev_priv
->resource_lock
);
1236 if (!res
->avail
|| res
->res_free
!= &vmw_user_surface_free
) {
1237 read_unlock(&dev_priv
->resource_lock
);
1238 goto out_bad_resource
;
1241 kref_get(&res
->kref
);
1242 read_unlock(&dev_priv
->resource_lock
);
1248 ttm_base_object_unref(&base
);
1253 static void vmw_user_surface_base_release(struct ttm_base_object
**p_base
)
1255 struct ttm_base_object
*base
= *p_base
;
1256 struct vmw_user_surface
*user_srf
=
1257 container_of(base
, struct vmw_user_surface
, base
);
1258 struct vmw_resource
*res
= &user_srf
->srf
.res
;
1261 vmw_resource_unreference(&res
);
1264 int vmw_surface_destroy_ioctl(struct drm_device
*dev
, void *data
,
1265 struct drm_file
*file_priv
)
1267 struct drm_vmw_surface_arg
*arg
= (struct drm_vmw_surface_arg
*)data
;
1268 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
1270 return ttm_ref_object_base_unref(tfile
, arg
->sid
, TTM_REF_USAGE
);
1273 int vmw_surface_define_ioctl(struct drm_device
*dev
, void *data
,
1274 struct drm_file
*file_priv
)
1276 struct vmw_private
*dev_priv
= vmw_priv(dev
);
1277 struct vmw_user_surface
*user_srf
;
1278 struct vmw_surface
*srf
;
1279 struct vmw_resource
*res
;
1280 struct vmw_resource
*tmp
;
1281 union drm_vmw_surface_create_arg
*arg
=
1282 (union drm_vmw_surface_create_arg
*)data
;
1283 struct drm_vmw_surface_create_req
*req
= &arg
->req
;
1284 struct drm_vmw_surface_arg
*rep
= &arg
->rep
;
1285 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
1286 struct drm_vmw_size __user
*user_sizes
;
1289 uint32_t cur_bo_offset
;
1290 struct drm_vmw_size
*cur_size
;
1291 struct vmw_surface_offset
*cur_offset
;
1292 uint32_t stride_bpp
;
1296 struct vmw_master
*vmaster
= vmw_master(file_priv
->master
);
1298 if (unlikely(vmw_user_surface_size
== 0))
1299 vmw_user_surface_size
= ttm_round_pot(sizeof(*user_srf
)) +
1303 for (i
= 0; i
< DRM_VMW_MAX_SURFACE_FACES
; ++i
)
1304 num_sizes
+= req
->mip_levels
[i
];
1306 if (num_sizes
> DRM_VMW_MAX_SURFACE_FACES
*
1307 DRM_VMW_MAX_MIP_LEVELS
)
1310 size
= vmw_user_surface_size
+ 128 +
1311 ttm_round_pot(num_sizes
* sizeof(struct drm_vmw_size
)) +
1312 ttm_round_pot(num_sizes
* sizeof(struct vmw_surface_offset
));
1315 ret
= ttm_read_lock(&vmaster
->lock
, true);
1316 if (unlikely(ret
!= 0))
1319 ret
= ttm_mem_global_alloc(vmw_mem_glob(dev_priv
),
1321 if (unlikely(ret
!= 0)) {
1322 if (ret
!= -ERESTARTSYS
)
1323 DRM_ERROR("Out of graphics memory for surface"
1328 user_srf
= kmalloc(sizeof(*user_srf
), GFP_KERNEL
);
1329 if (unlikely(user_srf
== NULL
)) {
1331 goto out_no_user_srf
;
1334 srf
= &user_srf
->srf
;
1337 srf
->flags
= req
->flags
;
1338 srf
->format
= req
->format
;
1339 srf
->scanout
= req
->scanout
;
1342 memcpy(srf
->mip_levels
, req
->mip_levels
, sizeof(srf
->mip_levels
));
1343 srf
->num_sizes
= num_sizes
;
1344 user_srf
->size
= size
;
1346 srf
->sizes
= kmalloc(srf
->num_sizes
* sizeof(*srf
->sizes
), GFP_KERNEL
);
1347 if (unlikely(srf
->sizes
== NULL
)) {
1351 srf
->offsets
= kmalloc(srf
->num_sizes
* sizeof(*srf
->offsets
),
1353 if (unlikely(srf
->sizes
== NULL
)) {
1355 goto out_no_offsets
;
1358 user_sizes
= (struct drm_vmw_size __user
*)(unsigned long)
1361 ret
= copy_from_user(srf
->sizes
, user_sizes
,
1362 srf
->num_sizes
* sizeof(*srf
->sizes
));
1363 if (unlikely(ret
!= 0)) {
1369 cur_offset
= srf
->offsets
;
1370 cur_size
= srf
->sizes
;
1372 bpp
= vmw_sf_bpp
[srf
->format
].bpp
;
1373 stride_bpp
= vmw_sf_bpp
[srf
->format
].s_bpp
;
1375 for (i
= 0; i
< DRM_VMW_MAX_SURFACE_FACES
; ++i
) {
1376 for (j
= 0; j
< srf
->mip_levels
[i
]; ++j
) {
1378 (cur_size
->width
* stride_bpp
+ 7) >> 3;
1380 cur_offset
->face
= i
;
1381 cur_offset
->mip
= j
;
1382 cur_offset
->bo_offset
= cur_bo_offset
;
1383 cur_bo_offset
+= stride
* cur_size
->height
*
1384 cur_size
->depth
* bpp
/ stride_bpp
;
1389 srf
->backup_size
= cur_bo_offset
;
1392 srf
->num_sizes
== 1 &&
1393 srf
->sizes
[0].width
== 64 &&
1394 srf
->sizes
[0].height
== 64 &&
1395 srf
->format
== SVGA3D_A8R8G8B8
) {
1397 /* allocate image area and clear it */
1398 srf
->snooper
.image
= kzalloc(64 * 64 * 4, GFP_KERNEL
);
1399 if (!srf
->snooper
.image
) {
1400 DRM_ERROR("Failed to allocate cursor_image\n");
1405 srf
->snooper
.image
= NULL
;
1407 srf
->snooper
.crtc
= NULL
;
1409 user_srf
->base
.shareable
= false;
1410 user_srf
->base
.tfile
= NULL
;
1413 * From this point, the generic resource management functions
1414 * destroy the object on failure.
1417 ret
= vmw_surface_init(dev_priv
, srf
, vmw_user_surface_free
);
1418 if (unlikely(ret
!= 0))
1421 tmp
= vmw_resource_reference(&srf
->res
);
1422 ret
= ttm_base_object_init(tfile
, &user_srf
->base
,
1423 req
->shareable
, VMW_RES_SURFACE
,
1424 &vmw_user_surface_base_release
, NULL
);
1426 if (unlikely(ret
!= 0)) {
1427 vmw_resource_unreference(&tmp
);
1428 vmw_resource_unreference(&res
);
1432 rep
->sid
= user_srf
->base
.hash
.key
;
1433 if (rep
->sid
== SVGA3D_INVALID_ID
)
1434 DRM_ERROR("Created bad Surface ID.\n");
1436 vmw_resource_unreference(&res
);
1438 ttm_read_unlock(&vmaster
->lock
);
1441 kfree(srf
->offsets
);
1447 ttm_mem_global_free(vmw_mem_glob(dev_priv
), size
);
1449 ttm_read_unlock(&vmaster
->lock
);
1453 int vmw_surface_reference_ioctl(struct drm_device
*dev
, void *data
,
1454 struct drm_file
*file_priv
)
1456 union drm_vmw_surface_reference_arg
*arg
=
1457 (union drm_vmw_surface_reference_arg
*)data
;
1458 struct drm_vmw_surface_arg
*req
= &arg
->req
;
1459 struct drm_vmw_surface_create_req
*rep
= &arg
->rep
;
1460 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
1461 struct vmw_surface
*srf
;
1462 struct vmw_user_surface
*user_srf
;
1463 struct drm_vmw_size __user
*user_sizes
;
1464 struct ttm_base_object
*base
;
1467 base
= ttm_base_object_lookup(tfile
, req
->sid
);
1468 if (unlikely(base
== NULL
)) {
1469 DRM_ERROR("Could not find surface to reference.\n");
1473 if (unlikely(base
->object_type
!= VMW_RES_SURFACE
))
1474 goto out_bad_resource
;
1476 user_srf
= container_of(base
, struct vmw_user_surface
, base
);
1477 srf
= &user_srf
->srf
;
1479 ret
= ttm_ref_object_add(tfile
, &user_srf
->base
, TTM_REF_USAGE
, NULL
);
1480 if (unlikely(ret
!= 0)) {
1481 DRM_ERROR("Could not add a reference to a surface.\n");
1482 goto out_no_reference
;
1485 rep
->flags
= srf
->flags
;
1486 rep
->format
= srf
->format
;
1487 memcpy(rep
->mip_levels
, srf
->mip_levels
, sizeof(srf
->mip_levels
));
1488 user_sizes
= (struct drm_vmw_size __user
*)(unsigned long)
1492 ret
= copy_to_user(user_sizes
, srf
->sizes
,
1493 srf
->num_sizes
* sizeof(*srf
->sizes
));
1494 if (unlikely(ret
!= 0)) {
1495 DRM_ERROR("copy_to_user failed %p %u\n",
1496 user_sizes
, srf
->num_sizes
);
1501 ttm_base_object_unref(&base
);
1506 int vmw_surface_check(struct vmw_private
*dev_priv
,
1507 struct ttm_object_file
*tfile
,
1508 uint32_t handle
, int *id
)
1510 struct ttm_base_object
*base
;
1511 struct vmw_user_surface
*user_srf
;
1515 base
= ttm_base_object_lookup(tfile
, handle
);
1516 if (unlikely(base
== NULL
))
1519 if (unlikely(base
->object_type
!= VMW_RES_SURFACE
))
1520 goto out_bad_surface
;
1522 user_srf
= container_of(base
, struct vmw_user_surface
, base
);
1523 *id
= user_srf
->srf
.res
.id
;
1528 * FIXME: May deadlock here when called from the
1529 * command parsing code.
1532 ttm_base_object_unref(&base
);
1537 * Buffer management.
1539 void vmw_dmabuf_bo_free(struct ttm_buffer_object
*bo
)
1541 struct vmw_dma_buffer
*vmw_bo
= vmw_dma_buffer(bo
);
1546 int vmw_dmabuf_init(struct vmw_private
*dev_priv
,
1547 struct vmw_dma_buffer
*vmw_bo
,
1548 size_t size
, struct ttm_placement
*placement
,
1550 void (*bo_free
) (struct ttm_buffer_object
*bo
))
1552 struct ttm_bo_device
*bdev
= &dev_priv
->bdev
;
1558 acc_size
= ttm_bo_acc_size(bdev
, size
, sizeof(struct vmw_dma_buffer
));
1559 memset(vmw_bo
, 0, sizeof(*vmw_bo
));
1561 INIT_LIST_HEAD(&vmw_bo
->validate_list
);
1563 ret
= ttm_bo_init(bdev
, &vmw_bo
->base
, size
,
1564 ttm_bo_type_device
, placement
,
1566 NULL
, acc_size
, NULL
, bo_free
);
1570 static void vmw_user_dmabuf_destroy(struct ttm_buffer_object
*bo
)
1572 struct vmw_user_dma_buffer
*vmw_user_bo
= vmw_user_dma_buffer(bo
);
1577 static void vmw_user_dmabuf_release(struct ttm_base_object
**p_base
)
1579 struct vmw_user_dma_buffer
*vmw_user_bo
;
1580 struct ttm_base_object
*base
= *p_base
;
1581 struct ttm_buffer_object
*bo
;
1585 if (unlikely(base
== NULL
))
1588 vmw_user_bo
= container_of(base
, struct vmw_user_dma_buffer
, base
);
1589 bo
= &vmw_user_bo
->dma
.base
;
1593 int vmw_dmabuf_alloc_ioctl(struct drm_device
*dev
, void *data
,
1594 struct drm_file
*file_priv
)
1596 struct vmw_private
*dev_priv
= vmw_priv(dev
);
1597 union drm_vmw_alloc_dmabuf_arg
*arg
=
1598 (union drm_vmw_alloc_dmabuf_arg
*)data
;
1599 struct drm_vmw_alloc_dmabuf_req
*req
= &arg
->req
;
1600 struct drm_vmw_dmabuf_rep
*rep
= &arg
->rep
;
1601 struct vmw_user_dma_buffer
*vmw_user_bo
;
1602 struct ttm_buffer_object
*tmp
;
1603 struct vmw_master
*vmaster
= vmw_master(file_priv
->master
);
1606 vmw_user_bo
= kzalloc(sizeof(*vmw_user_bo
), GFP_KERNEL
);
1607 if (unlikely(vmw_user_bo
== NULL
))
1610 ret
= ttm_read_lock(&vmaster
->lock
, true);
1611 if (unlikely(ret
!= 0)) {
1616 ret
= vmw_dmabuf_init(dev_priv
, &vmw_user_bo
->dma
, req
->size
,
1617 &vmw_vram_sys_placement
, true,
1618 &vmw_user_dmabuf_destroy
);
1619 if (unlikely(ret
!= 0))
1622 tmp
= ttm_bo_reference(&vmw_user_bo
->dma
.base
);
1623 ret
= ttm_base_object_init(vmw_fpriv(file_priv
)->tfile
,
1627 &vmw_user_dmabuf_release
, NULL
);
1628 if (unlikely(ret
!= 0))
1629 goto out_no_base_object
;
1631 rep
->handle
= vmw_user_bo
->base
.hash
.key
;
1632 rep
->map_handle
= vmw_user_bo
->dma
.base
.addr_space_offset
;
1633 rep
->cur_gmr_id
= vmw_user_bo
->base
.hash
.key
;
1634 rep
->cur_gmr_offset
= 0;
1640 ttm_read_unlock(&vmaster
->lock
);
1645 int vmw_dmabuf_unref_ioctl(struct drm_device
*dev
, void *data
,
1646 struct drm_file
*file_priv
)
1648 struct drm_vmw_unref_dmabuf_arg
*arg
=
1649 (struct drm_vmw_unref_dmabuf_arg
*)data
;
1651 return ttm_ref_object_base_unref(vmw_fpriv(file_priv
)->tfile
,
1656 uint32_t vmw_dmabuf_validate_node(struct ttm_buffer_object
*bo
,
1657 uint32_t cur_validate_node
)
1659 struct vmw_dma_buffer
*vmw_bo
= vmw_dma_buffer(bo
);
1661 if (likely(vmw_bo
->on_validate_list
))
1662 return vmw_bo
->cur_validate_node
;
1664 vmw_bo
->cur_validate_node
= cur_validate_node
;
1665 vmw_bo
->on_validate_list
= true;
1667 return cur_validate_node
;
1670 void vmw_dmabuf_validate_clear(struct ttm_buffer_object
*bo
)
1672 struct vmw_dma_buffer
*vmw_bo
= vmw_dma_buffer(bo
);
1674 vmw_bo
->on_validate_list
= false;
1677 int vmw_user_dmabuf_lookup(struct ttm_object_file
*tfile
,
1678 uint32_t handle
, struct vmw_dma_buffer
**out
)
1680 struct vmw_user_dma_buffer
*vmw_user_bo
;
1681 struct ttm_base_object
*base
;
1683 base
= ttm_base_object_lookup(tfile
, handle
);
1684 if (unlikely(base
== NULL
)) {
1685 printk(KERN_ERR
"Invalid buffer object handle 0x%08lx.\n",
1686 (unsigned long)handle
);
1690 if (unlikely(base
->object_type
!= ttm_buffer_type
)) {
1691 ttm_base_object_unref(&base
);
1692 printk(KERN_ERR
"Invalid buffer object handle 0x%08lx.\n",
1693 (unsigned long)handle
);
1697 vmw_user_bo
= container_of(base
, struct vmw_user_dma_buffer
, base
);
1698 (void)ttm_bo_reference(&vmw_user_bo
->dma
.base
);
1699 ttm_base_object_unref(&base
);
1700 *out
= &vmw_user_bo
->dma
;
1709 static void vmw_stream_destroy(struct vmw_resource
*res
)
1711 struct vmw_private
*dev_priv
= res
->dev_priv
;
1712 struct vmw_stream
*stream
;
1715 DRM_INFO("%s: unref\n", __func__
);
1716 stream
= container_of(res
, struct vmw_stream
, res
);
1718 ret
= vmw_overlay_unref(dev_priv
, stream
->stream_id
);
1722 static int vmw_stream_init(struct vmw_private
*dev_priv
,
1723 struct vmw_stream
*stream
,
1724 void (*res_free
) (struct vmw_resource
*res
))
1726 struct vmw_resource
*res
= &stream
->res
;
1729 ret
= vmw_resource_init(dev_priv
, res
, &dev_priv
->stream_idr
,
1730 VMW_RES_STREAM
, false, res_free
, NULL
);
1732 if (unlikely(ret
!= 0)) {
1733 if (res_free
== NULL
)
1736 res_free(&stream
->res
);
1740 ret
= vmw_overlay_claim(dev_priv
, &stream
->stream_id
);
1742 vmw_resource_unreference(&res
);
1746 DRM_INFO("%s: claimed\n", __func__
);
1748 vmw_resource_activate(&stream
->res
, vmw_stream_destroy
);
1753 * User-space context management:
1756 static void vmw_user_stream_free(struct vmw_resource
*res
)
1758 struct vmw_user_stream
*stream
=
1759 container_of(res
, struct vmw_user_stream
, stream
.res
);
1760 struct vmw_private
*dev_priv
= res
->dev_priv
;
1763 ttm_mem_global_free(vmw_mem_glob(dev_priv
),
1764 vmw_user_stream_size
);
1768 * This function is called when user space has no more references on the
1769 * base object. It releases the base-object's reference on the resource object.
1772 static void vmw_user_stream_base_release(struct ttm_base_object
**p_base
)
1774 struct ttm_base_object
*base
= *p_base
;
1775 struct vmw_user_stream
*stream
=
1776 container_of(base
, struct vmw_user_stream
, base
);
1777 struct vmw_resource
*res
= &stream
->stream
.res
;
1780 vmw_resource_unreference(&res
);
1783 int vmw_stream_unref_ioctl(struct drm_device
*dev
, void *data
,
1784 struct drm_file
*file_priv
)
1786 struct vmw_private
*dev_priv
= vmw_priv(dev
);
1787 struct vmw_resource
*res
;
1788 struct vmw_user_stream
*stream
;
1789 struct drm_vmw_stream_arg
*arg
= (struct drm_vmw_stream_arg
*)data
;
1790 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
1793 res
= vmw_resource_lookup(dev_priv
, &dev_priv
->stream_idr
, arg
->stream_id
);
1794 if (unlikely(res
== NULL
))
1797 if (res
->res_free
!= &vmw_user_stream_free
) {
1802 stream
= container_of(res
, struct vmw_user_stream
, stream
.res
);
1803 if (stream
->base
.tfile
!= tfile
) {
1808 ttm_ref_object_base_unref(tfile
, stream
->base
.hash
.key
, TTM_REF_USAGE
);
1810 vmw_resource_unreference(&res
);
1814 int vmw_stream_claim_ioctl(struct drm_device
*dev
, void *data
,
1815 struct drm_file
*file_priv
)
1817 struct vmw_private
*dev_priv
= vmw_priv(dev
);
1818 struct vmw_user_stream
*stream
;
1819 struct vmw_resource
*res
;
1820 struct vmw_resource
*tmp
;
1821 struct drm_vmw_stream_arg
*arg
= (struct drm_vmw_stream_arg
*)data
;
1822 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
1823 struct vmw_master
*vmaster
= vmw_master(file_priv
->master
);
1827 * Approximate idr memory usage with 128 bytes. It will be limited
1828 * by maximum number_of streams anyway?
1831 if (unlikely(vmw_user_stream_size
== 0))
1832 vmw_user_stream_size
= ttm_round_pot(sizeof(*stream
)) + 128;
1834 ret
= ttm_read_lock(&vmaster
->lock
, true);
1835 if (unlikely(ret
!= 0))
1838 ret
= ttm_mem_global_alloc(vmw_mem_glob(dev_priv
),
1839 vmw_user_stream_size
,
1841 if (unlikely(ret
!= 0)) {
1842 if (ret
!= -ERESTARTSYS
)
1843 DRM_ERROR("Out of graphics memory for stream"
1849 stream
= kmalloc(sizeof(*stream
), GFP_KERNEL
);
1850 if (unlikely(stream
== NULL
)) {
1851 ttm_mem_global_free(vmw_mem_glob(dev_priv
),
1852 vmw_user_stream_size
);
1857 res
= &stream
->stream
.res
;
1858 stream
->base
.shareable
= false;
1859 stream
->base
.tfile
= NULL
;
1862 * From here on, the destructor takes over resource freeing.
1865 ret
= vmw_stream_init(dev_priv
, &stream
->stream
, vmw_user_stream_free
);
1866 if (unlikely(ret
!= 0))
1869 tmp
= vmw_resource_reference(res
);
1870 ret
= ttm_base_object_init(tfile
, &stream
->base
, false, VMW_RES_STREAM
,
1871 &vmw_user_stream_base_release
, NULL
);
1873 if (unlikely(ret
!= 0)) {
1874 vmw_resource_unreference(&tmp
);
1878 arg
->stream_id
= res
->id
;
1880 vmw_resource_unreference(&res
);
1882 ttm_read_unlock(&vmaster
->lock
);
1886 int vmw_user_stream_lookup(struct vmw_private
*dev_priv
,
1887 struct ttm_object_file
*tfile
,
1888 uint32_t *inout_id
, struct vmw_resource
**out
)
1890 struct vmw_user_stream
*stream
;
1891 struct vmw_resource
*res
;
1894 res
= vmw_resource_lookup(dev_priv
, &dev_priv
->stream_idr
, *inout_id
);
1895 if (unlikely(res
== NULL
))
1898 if (res
->res_free
!= &vmw_user_stream_free
) {
1903 stream
= container_of(res
, struct vmw_user_stream
, stream
.res
);
1904 if (stream
->base
.tfile
!= tfile
) {
1909 *inout_id
= stream
->stream
.stream_id
;
1913 vmw_resource_unreference(&res
);
1918 int vmw_dumb_create(struct drm_file
*file_priv
,
1919 struct drm_device
*dev
,
1920 struct drm_mode_create_dumb
*args
)
1922 struct vmw_private
*dev_priv
= vmw_priv(dev
);
1923 struct vmw_master
*vmaster
= vmw_master(file_priv
->master
);
1924 struct vmw_user_dma_buffer
*vmw_user_bo
;
1925 struct ttm_buffer_object
*tmp
;
1928 args
->pitch
= args
->width
* ((args
->bpp
+ 7) / 8);
1929 args
->size
= args
->pitch
* args
->height
;
1931 vmw_user_bo
= kzalloc(sizeof(*vmw_user_bo
), GFP_KERNEL
);
1932 if (vmw_user_bo
== NULL
)
1935 ret
= ttm_read_lock(&vmaster
->lock
, true);
1941 ret
= vmw_dmabuf_init(dev_priv
, &vmw_user_bo
->dma
, args
->size
,
1942 &vmw_vram_sys_placement
, true,
1943 &vmw_user_dmabuf_destroy
);
1947 tmp
= ttm_bo_reference(&vmw_user_bo
->dma
.base
);
1948 ret
= ttm_base_object_init(vmw_fpriv(file_priv
)->tfile
,
1952 &vmw_user_dmabuf_release
, NULL
);
1953 if (unlikely(ret
!= 0))
1954 goto out_no_base_object
;
1956 args
->handle
= vmw_user_bo
->base
.hash
.key
;
1961 ttm_read_unlock(&vmaster
->lock
);
1965 int vmw_dumb_map_offset(struct drm_file
*file_priv
,
1966 struct drm_device
*dev
, uint32_t handle
,
1969 struct ttm_object_file
*tfile
= vmw_fpriv(file_priv
)->tfile
;
1970 struct vmw_dma_buffer
*out_buf
;
1973 ret
= vmw_user_dmabuf_lookup(tfile
, handle
, &out_buf
);
1977 *offset
= out_buf
->base
.addr_space_offset
;
1978 vmw_dmabuf_unreference(&out_buf
);
1982 int vmw_dumb_destroy(struct drm_file
*file_priv
,
1983 struct drm_device
*dev
,
1986 return ttm_ref_object_base_unref(vmw_fpriv(file_priv
)->tfile
,
1987 handle
, TTM_REF_USAGE
);