1 /**************************************************************************
3 * Copyright © 2011-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_kms.h"
29 #include <drm/drm_plane_helper.h>
32 #define vmw_crtc_to_sou(x) \
33 container_of(x, struct vmw_screen_object_unit, base.crtc)
34 #define vmw_encoder_to_sou(x) \
35 container_of(x, struct vmw_screen_object_unit, base.encoder)
36 #define vmw_connector_to_sou(x) \
37 container_of(x, struct vmw_screen_object_unit, base.connector)
40 * struct vmw_kms_sou_surface_dirty - Closure structure for
41 * blit surface to screen command.
42 * @base: The base type we derive from. Used by vmw_kms_helper_dirty().
43 * @left: Left side of bounding box.
44 * @right: Right side of bounding box.
45 * @top: Top side of bounding box.
46 * @bottom: Bottom side of bounding box.
47 * @dst_x: Difference between source clip rects and framebuffer coordinates.
48 * @dst_y: Difference between source clip rects and framebuffer coordinates.
49 * @sid: Surface id of surface to copy from.
51 struct vmw_kms_sou_surface_dirty
{
52 struct vmw_kms_dirty base
;
53 s32 left
, right
, top
, bottom
;
59 * SVGA commands that are used by this code. Please see the device headers
62 struct vmw_kms_sou_readback_blit
{
64 SVGAFifoCmdBlitScreenToGMRFB body
;
67 struct vmw_kms_sou_dmabuf_blit
{
69 SVGAFifoCmdBlitGMRFBToScreen body
;
72 struct vmw_kms_sou_dirty_cmd
{
73 SVGA3dCmdHeader header
;
74 SVGA3dCmdBlitSurfaceToScreen body
;
78 * Display unit using screen objects.
80 struct vmw_screen_object_unit
{
81 struct vmw_display_unit base
;
83 unsigned long buffer_size
; /**< Size of allocated buffer */
84 struct vmw_dma_buffer
*buffer
; /**< Backing store buffer */
89 static void vmw_sou_destroy(struct vmw_screen_object_unit
*sou
)
91 vmw_du_cleanup(&sou
->base
);
97 * Screen Object Display Unit CRTC functions
100 static void vmw_sou_crtc_destroy(struct drm_crtc
*crtc
)
102 vmw_sou_destroy(vmw_crtc_to_sou(crtc
));
106 * Send the fifo command to create a screen.
108 static int vmw_sou_fifo_create(struct vmw_private
*dev_priv
,
109 struct vmw_screen_object_unit
*sou
,
110 uint32_t x
, uint32_t y
,
111 struct drm_display_mode
*mode
)
119 SVGAScreenObject obj
;
122 BUG_ON(!sou
->buffer
);
124 fifo_size
= sizeof(*cmd
);
125 cmd
= vmw_fifo_reserve(dev_priv
, fifo_size
);
126 /* The hardware has hung, nothing we can do about it here. */
127 if (unlikely(cmd
== NULL
)) {
128 DRM_ERROR("Fifo reserve failed.\n");
132 memset(cmd
, 0, fifo_size
);
133 cmd
->header
.cmdType
= SVGA_CMD_DEFINE_SCREEN
;
134 cmd
->obj
.structSize
= sizeof(SVGAScreenObject
);
135 cmd
->obj
.id
= sou
->base
.unit
;
136 cmd
->obj
.flags
= SVGA_SCREEN_HAS_ROOT
|
137 (sou
->base
.unit
== 0 ? SVGA_SCREEN_IS_PRIMARY
: 0);
138 cmd
->obj
.size
.width
= mode
->hdisplay
;
139 cmd
->obj
.size
.height
= mode
->vdisplay
;
140 if (sou
->base
.is_implicit
) {
144 cmd
->obj
.root
.x
= sou
->base
.gui_x
;
145 cmd
->obj
.root
.y
= sou
->base
.gui_y
;
147 sou
->base
.set_gui_x
= cmd
->obj
.root
.x
;
148 sou
->base
.set_gui_y
= cmd
->obj
.root
.y
;
150 /* Ok to assume that buffer is pinned in vram */
151 vmw_bo_get_guest_ptr(&sou
->buffer
->base
, &cmd
->obj
.backingStore
.ptr
);
152 cmd
->obj
.backingStore
.pitch
= mode
->hdisplay
* 4;
154 vmw_fifo_commit(dev_priv
, fifo_size
);
162 * Send the fifo command to destroy a screen.
164 static int vmw_sou_fifo_destroy(struct vmw_private
*dev_priv
,
165 struct vmw_screen_object_unit
*sou
)
174 SVGAFifoCmdDestroyScreen body
;
177 /* no need to do anything */
178 if (unlikely(!sou
->defined
))
181 fifo_size
= sizeof(*cmd
);
182 cmd
= vmw_fifo_reserve(dev_priv
, fifo_size
);
183 /* the hardware has hung, nothing we can do about it here */
184 if (unlikely(cmd
== NULL
)) {
185 DRM_ERROR("Fifo reserve failed.\n");
189 memset(cmd
, 0, fifo_size
);
190 cmd
->header
.cmdType
= SVGA_CMD_DESTROY_SCREEN
;
191 cmd
->body
.screenId
= sou
->base
.unit
;
193 vmw_fifo_commit(dev_priv
, fifo_size
);
196 ret
= vmw_fallback_wait(dev_priv
, false, true, 0, false, 3*HZ
);
197 if (unlikely(ret
!= 0))
198 DRM_ERROR("Failed to sync with HW");
200 sou
->defined
= false;
206 * Free the backing store.
208 static void vmw_sou_backing_free(struct vmw_private
*dev_priv
,
209 struct vmw_screen_object_unit
*sou
)
211 vmw_dmabuf_unreference(&sou
->buffer
);
212 sou
->buffer_size
= 0;
216 * Allocate the backing store for the buffer.
218 static int vmw_sou_backing_alloc(struct vmw_private
*dev_priv
,
219 struct vmw_screen_object_unit
*sou
,
224 if (sou
->buffer_size
== size
)
228 vmw_sou_backing_free(dev_priv
, sou
);
230 sou
->buffer
= kzalloc(sizeof(*sou
->buffer
), GFP_KERNEL
);
231 if (unlikely(sou
->buffer
== NULL
))
234 /* After we have alloced the backing store might not be able to
235 * resume the overlays, this is preferred to failing to alloc.
237 vmw_overlay_pause_all(dev_priv
);
238 ret
= vmw_dmabuf_init(dev_priv
, sou
->buffer
, size
,
239 &vmw_vram_ne_placement
,
240 false, &vmw_dmabuf_bo_free
);
241 vmw_overlay_resume_all(dev_priv
);
243 if (unlikely(ret
!= 0))
244 sou
->buffer
= NULL
; /* vmw_dmabuf_init frees on error */
246 sou
->buffer_size
= size
;
251 static int vmw_sou_crtc_set_config(struct drm_mode_set
*set
)
253 struct vmw_private
*dev_priv
;
254 struct vmw_screen_object_unit
*sou
;
255 struct drm_connector
*connector
;
256 struct drm_display_mode
*mode
;
257 struct drm_encoder
*encoder
;
258 struct vmw_framebuffer
*vfb
;
259 struct drm_framebuffer
*fb
;
260 struct drm_crtc
*crtc
;
271 sou
= vmw_crtc_to_sou(crtc
);
272 vfb
= set
->fb
? vmw_framebuffer_to_vfb(set
->fb
) : NULL
;
273 dev_priv
= vmw_priv(crtc
->dev
);
275 if (set
->num_connectors
> 1) {
276 DRM_ERROR("Too many connectors\n");
280 if (set
->num_connectors
== 1 &&
281 set
->connectors
[0] != &sou
->base
.connector
) {
282 DRM_ERROR("Connector doesn't match %p %p\n",
283 set
->connectors
[0], &sou
->base
.connector
);
287 /* Only one active implicit frame-buffer at a time. */
288 mutex_lock(&dev_priv
->global_kms_state_mutex
);
289 if (sou
->base
.is_implicit
&&
290 dev_priv
->implicit_fb
&& vfb
&&
291 !(dev_priv
->num_implicit
== 1 &&
292 sou
->base
.active_implicit
) &&
293 dev_priv
->implicit_fb
!= vfb
) {
294 mutex_unlock(&dev_priv
->global_kms_state_mutex
);
295 DRM_ERROR("Multiple implicit framebuffers not supported.\n");
298 mutex_unlock(&dev_priv
->global_kms_state_mutex
);
300 /* since they always map one to one these are safe */
301 connector
= &sou
->base
.connector
;
302 encoder
= &sou
->base
.encoder
;
304 /* should we turn the crtc off */
305 if (set
->num_connectors
== 0 || !set
->mode
|| !set
->fb
) {
306 ret
= vmw_sou_fifo_destroy(dev_priv
, sou
);
307 /* the hardware has hung don't do anything more */
308 if (unlikely(ret
!= 0))
311 connector
->encoder
= NULL
;
312 encoder
->crtc
= NULL
;
313 crtc
->primary
->fb
= NULL
;
316 crtc
->enabled
= false;
318 vmw_kms_del_active(dev_priv
, &sou
->base
);
320 vmw_sou_backing_free(dev_priv
, sou
);
326 /* we now know we want to set a mode */
330 if (set
->x
+ mode
->hdisplay
> fb
->width
||
331 set
->y
+ mode
->vdisplay
> fb
->height
) {
332 DRM_ERROR("set outside of framebuffer\n");
336 vmw_svga_enable(dev_priv
);
338 if (mode
->hdisplay
!= crtc
->mode
.hdisplay
||
339 mode
->vdisplay
!= crtc
->mode
.vdisplay
) {
340 /* no need to check if depth is different, because backing
341 * store depth is forced to 4 by the device.
344 ret
= vmw_sou_fifo_destroy(dev_priv
, sou
);
345 /* the hardware has hung don't do anything more */
346 if (unlikely(ret
!= 0))
349 vmw_sou_backing_free(dev_priv
, sou
);
353 /* forced to depth 4 by the device */
354 size_t size
= mode
->hdisplay
* mode
->vdisplay
* 4;
355 ret
= vmw_sou_backing_alloc(dev_priv
, sou
, size
);
356 if (unlikely(ret
!= 0))
360 ret
= vmw_sou_fifo_create(dev_priv
, sou
, set
->x
, set
->y
, mode
);
361 if (unlikely(ret
!= 0)) {
363 * We are in a bit of a situation here, the hardware has
364 * hung and we may or may not have a buffer hanging of
365 * the screen object, best thing to do is not do anything
366 * if we where defined, if not just turn the crtc of.
367 * Not what userspace wants but it needs to htfu.
372 connector
->encoder
= NULL
;
373 encoder
->crtc
= NULL
;
374 crtc
->primary
->fb
= NULL
;
377 crtc
->enabled
= false;
382 vmw_kms_add_active(dev_priv
, &sou
->base
, vfb
);
384 connector
->encoder
= encoder
;
385 encoder
->crtc
= crtc
;
387 crtc
->primary
->fb
= fb
;
390 crtc
->enabled
= true;
395 static int vmw_sou_crtc_page_flip(struct drm_crtc
*crtc
,
396 struct drm_framebuffer
*fb
,
397 struct drm_pending_vblank_event
*event
,
400 struct vmw_private
*dev_priv
= vmw_priv(crtc
->dev
);
401 struct drm_framebuffer
*old_fb
= crtc
->primary
->fb
;
402 struct vmw_framebuffer
*vfb
= vmw_framebuffer_to_vfb(fb
);
403 struct vmw_fence_obj
*fence
= NULL
;
404 struct drm_vmw_rect vclips
;
407 if (!vmw_kms_crtc_flippable(dev_priv
, crtc
))
410 crtc
->primary
->fb
= fb
;
412 /* do a full screen dirty update */
415 vclips
.w
= crtc
->mode
.hdisplay
;
416 vclips
.h
= crtc
->mode
.vdisplay
;
419 ret
= vmw_kms_sou_do_dmabuf_dirty(dev_priv
, vfb
,
423 ret
= vmw_kms_sou_do_surface_dirty(dev_priv
, vfb
,
436 struct drm_file
*file_priv
= event
->base
.file_priv
;
438 ret
= vmw_event_fence_action_queue(file_priv
, fence
,
440 &event
->event
.tv_sec
,
441 &event
->event
.tv_usec
,
446 * No need to hold on to this now. The only cleanup
447 * we need to do if we fail is unref the fence.
449 vmw_fence_obj_unreference(&fence
);
451 if (vmw_crtc_to_du(crtc
)->is_implicit
)
452 vmw_kms_update_implicit_fb(dev_priv
, crtc
);
457 crtc
->primary
->fb
= old_fb
;
461 static const struct drm_crtc_funcs vmw_screen_object_crtc_funcs
= {
462 .cursor_set2
= vmw_du_crtc_cursor_set2
,
463 .cursor_move
= vmw_du_crtc_cursor_move
,
464 .gamma_set
= vmw_du_crtc_gamma_set
,
465 .destroy
= vmw_sou_crtc_destroy
,
466 .set_config
= vmw_sou_crtc_set_config
,
467 .page_flip
= vmw_sou_crtc_page_flip
,
471 * Screen Object Display Unit encoder functions
474 static void vmw_sou_encoder_destroy(struct drm_encoder
*encoder
)
476 vmw_sou_destroy(vmw_encoder_to_sou(encoder
));
479 static const struct drm_encoder_funcs vmw_screen_object_encoder_funcs
= {
480 .destroy
= vmw_sou_encoder_destroy
,
484 * Screen Object Display Unit connector functions
487 static void vmw_sou_connector_destroy(struct drm_connector
*connector
)
489 vmw_sou_destroy(vmw_connector_to_sou(connector
));
492 static const struct drm_connector_funcs vmw_sou_connector_funcs
= {
493 .dpms
= vmw_du_connector_dpms
,
494 .detect
= vmw_du_connector_detect
,
495 .fill_modes
= vmw_du_connector_fill_modes
,
496 .set_property
= vmw_du_connector_set_property
,
497 .destroy
= vmw_sou_connector_destroy
,
500 static int vmw_sou_init(struct vmw_private
*dev_priv
, unsigned unit
)
502 struct vmw_screen_object_unit
*sou
;
503 struct drm_device
*dev
= dev_priv
->dev
;
504 struct drm_connector
*connector
;
505 struct drm_encoder
*encoder
;
506 struct drm_crtc
*crtc
;
508 sou
= kzalloc(sizeof(*sou
), GFP_KERNEL
);
512 sou
->base
.unit
= unit
;
513 crtc
= &sou
->base
.crtc
;
514 encoder
= &sou
->base
.encoder
;
515 connector
= &sou
->base
.connector
;
517 sou
->base
.active_implicit
= false;
518 sou
->base
.pref_active
= (unit
== 0);
519 sou
->base
.pref_width
= dev_priv
->initial_width
;
520 sou
->base
.pref_height
= dev_priv
->initial_height
;
521 sou
->base
.pref_mode
= NULL
;
522 sou
->base
.is_implicit
= false;
524 drm_connector_init(dev
, connector
, &vmw_sou_connector_funcs
,
525 DRM_MODE_CONNECTOR_VIRTUAL
);
526 connector
->status
= vmw_du_connector_detect(connector
, true);
528 drm_encoder_init(dev
, encoder
, &vmw_screen_object_encoder_funcs
,
529 DRM_MODE_ENCODER_VIRTUAL
, NULL
);
530 drm_mode_connector_attach_encoder(connector
, encoder
);
531 encoder
->possible_crtcs
= (1 << unit
);
532 encoder
->possible_clones
= 0;
534 (void) drm_connector_register(connector
);
536 drm_crtc_init(dev
, crtc
, &vmw_screen_object_crtc_funcs
);
538 drm_mode_crtc_set_gamma_size(crtc
, 256);
540 drm_object_attach_property(&connector
->base
,
541 dev
->mode_config
.dirty_info_property
,
543 drm_object_attach_property(&connector
->base
,
544 dev_priv
->hotplug_mode_update_property
, 1);
545 drm_object_attach_property(&connector
->base
,
546 dev
->mode_config
.suggested_x_property
, 0);
547 drm_object_attach_property(&connector
->base
,
548 dev
->mode_config
.suggested_y_property
, 0);
549 if (dev_priv
->implicit_placement_property
)
550 drm_object_attach_property
552 dev_priv
->implicit_placement_property
,
553 sou
->base
.is_implicit
);
558 int vmw_kms_sou_init_display(struct vmw_private
*dev_priv
)
560 struct drm_device
*dev
= dev_priv
->dev
;
563 if (!(dev_priv
->capabilities
& SVGA_CAP_SCREEN_OBJECT_2
)) {
564 DRM_INFO("Not using screen objects,"
565 " missing cap SCREEN_OBJECT_2\n");
570 dev_priv
->num_implicit
= 0;
571 dev_priv
->implicit_fb
= NULL
;
573 ret
= drm_vblank_init(dev
, VMWGFX_NUM_DISPLAY_UNITS
);
574 if (unlikely(ret
!= 0))
577 ret
= drm_mode_create_dirty_info_property(dev
);
578 if (unlikely(ret
!= 0))
579 goto err_vblank_cleanup
;
581 vmw_kms_create_implicit_placement_property(dev_priv
, false);
583 for (i
= 0; i
< VMWGFX_NUM_DISPLAY_UNITS
; ++i
)
584 vmw_sou_init(dev_priv
, i
);
586 dev_priv
->active_display_unit
= vmw_du_screen_object
;
588 DRM_INFO("Screen Objects Display Unit initialized\n");
593 drm_vblank_cleanup(dev
);
597 int vmw_kms_sou_close_display(struct vmw_private
*dev_priv
)
599 struct drm_device
*dev
= dev_priv
->dev
;
601 drm_vblank_cleanup(dev
);
606 static int do_dmabuf_define_gmrfb(struct vmw_private
*dev_priv
,
607 struct vmw_framebuffer
*framebuffer
)
609 struct vmw_dma_buffer
*buf
=
610 container_of(framebuffer
, struct vmw_framebuffer_dmabuf
,
612 int depth
= framebuffer
->base
.depth
;
615 SVGAFifoCmdDefineGMRFB body
;
618 /* Emulate RGBA support, contrary to svga_reg.h this is not
619 * supported by hosts. This is only a problem if we are reading
620 * this value later and expecting what we uploaded back.
625 cmd
= vmw_fifo_reserve(dev_priv
, sizeof(*cmd
));
627 DRM_ERROR("Out of fifo space for dirty framebuffer command.\n");
631 cmd
->header
= SVGA_CMD_DEFINE_GMRFB
;
632 cmd
->body
.format
.bitsPerPixel
= framebuffer
->base
.bits_per_pixel
;
633 cmd
->body
.format
.colorDepth
= depth
;
634 cmd
->body
.format
.reserved
= 0;
635 cmd
->body
.bytesPerLine
= framebuffer
->base
.pitches
[0];
636 /* Buffer is reserved in vram or GMR */
637 vmw_bo_get_guest_ptr(&buf
->base
, &cmd
->body
.ptr
);
638 vmw_fifo_commit(dev_priv
, sizeof(*cmd
));
644 * vmw_sou_surface_fifo_commit - Callback to fill in and submit a
645 * blit surface to screen command.
647 * @dirty: The closure structure.
649 * Fills in the missing fields in the command, and translates the cliprects
650 * to match the destination bounding box encoded.
652 static void vmw_sou_surface_fifo_commit(struct vmw_kms_dirty
*dirty
)
654 struct vmw_kms_sou_surface_dirty
*sdirty
=
655 container_of(dirty
, typeof(*sdirty
), base
);
656 struct vmw_kms_sou_dirty_cmd
*cmd
= dirty
->cmd
;
657 s32 trans_x
= dirty
->unit
->crtc
.x
- sdirty
->dst_x
;
658 s32 trans_y
= dirty
->unit
->crtc
.y
- sdirty
->dst_y
;
659 size_t region_size
= dirty
->num_hits
* sizeof(SVGASignedRect
);
660 SVGASignedRect
*blit
= (SVGASignedRect
*) &cmd
[1];
663 if (!dirty
->num_hits
) {
664 vmw_fifo_commit(dirty
->dev_priv
, 0);
668 cmd
->header
.id
= SVGA_3D_CMD_BLIT_SURFACE_TO_SCREEN
;
669 cmd
->header
.size
= sizeof(cmd
->body
) + region_size
;
672 * Use the destination bounding box to specify destination - and
673 * source bounding regions.
675 cmd
->body
.destRect
.left
= sdirty
->left
;
676 cmd
->body
.destRect
.right
= sdirty
->right
;
677 cmd
->body
.destRect
.top
= sdirty
->top
;
678 cmd
->body
.destRect
.bottom
= sdirty
->bottom
;
680 cmd
->body
.srcRect
.left
= sdirty
->left
+ trans_x
;
681 cmd
->body
.srcRect
.right
= sdirty
->right
+ trans_x
;
682 cmd
->body
.srcRect
.top
= sdirty
->top
+ trans_y
;
683 cmd
->body
.srcRect
.bottom
= sdirty
->bottom
+ trans_y
;
685 cmd
->body
.srcImage
.sid
= sdirty
->sid
;
686 cmd
->body
.destScreenId
= dirty
->unit
->unit
;
688 /* Blits are relative to the destination rect. Translate. */
689 for (i
= 0; i
< dirty
->num_hits
; ++i
, ++blit
) {
690 blit
->left
-= sdirty
->left
;
691 blit
->right
-= sdirty
->left
;
692 blit
->top
-= sdirty
->top
;
693 blit
->bottom
-= sdirty
->top
;
696 vmw_fifo_commit(dirty
->dev_priv
, region_size
+ sizeof(*cmd
));
698 sdirty
->left
= sdirty
->top
= S32_MAX
;
699 sdirty
->right
= sdirty
->bottom
= S32_MIN
;
703 * vmw_sou_surface_clip - Callback to encode a blit surface to screen cliprect.
705 * @dirty: The closure structure
707 * Encodes a SVGASignedRect cliprect and updates the bounding box of the
708 * BLIT_SURFACE_TO_SCREEN command.
710 static void vmw_sou_surface_clip(struct vmw_kms_dirty
*dirty
)
712 struct vmw_kms_sou_surface_dirty
*sdirty
=
713 container_of(dirty
, typeof(*sdirty
), base
);
714 struct vmw_kms_sou_dirty_cmd
*cmd
= dirty
->cmd
;
715 SVGASignedRect
*blit
= (SVGASignedRect
*) &cmd
[1];
717 /* Destination rect. */
718 blit
+= dirty
->num_hits
;
719 blit
->left
= dirty
->unit_x1
;
720 blit
->top
= dirty
->unit_y1
;
721 blit
->right
= dirty
->unit_x2
;
722 blit
->bottom
= dirty
->unit_y2
;
724 /* Destination bounding box */
725 sdirty
->left
= min_t(s32
, sdirty
->left
, dirty
->unit_x1
);
726 sdirty
->top
= min_t(s32
, sdirty
->top
, dirty
->unit_y1
);
727 sdirty
->right
= max_t(s32
, sdirty
->right
, dirty
->unit_x2
);
728 sdirty
->bottom
= max_t(s32
, sdirty
->bottom
, dirty
->unit_y2
);
734 * vmw_kms_sou_do_surface_dirty - Dirty part of a surface backed framebuffer
736 * @dev_priv: Pointer to the device private structure.
737 * @framebuffer: Pointer to the surface-buffer backed framebuffer.
738 * @clips: Array of clip rects. Either @clips or @vclips must be NULL.
739 * @vclips: Alternate array of clip rects. Either @clips or @vclips must
741 * @srf: Pointer to surface to blit from. If NULL, the surface attached
742 * to @framebuffer will be used.
743 * @dest_x: X coordinate offset to align @srf with framebuffer coordinates.
744 * @dest_y: Y coordinate offset to align @srf with framebuffer coordinates.
745 * @num_clips: Number of clip rects in @clips.
746 * @inc: Increment to use when looping over @clips.
747 * @out_fence: If non-NULL, will return a ref-counted pointer to a
748 * struct vmw_fence_obj. The returned fence pointer may be NULL in which
749 * case the device has already synchronized.
751 * Returns 0 on success, negative error code on failure. -ERESTARTSYS if
754 int vmw_kms_sou_do_surface_dirty(struct vmw_private
*dev_priv
,
755 struct vmw_framebuffer
*framebuffer
,
756 struct drm_clip_rect
*clips
,
757 struct drm_vmw_rect
*vclips
,
758 struct vmw_resource
*srf
,
761 unsigned num_clips
, int inc
,
762 struct vmw_fence_obj
**out_fence
)
764 struct vmw_framebuffer_surface
*vfbs
=
765 container_of(framebuffer
, typeof(*vfbs
), base
);
766 struct vmw_kms_sou_surface_dirty sdirty
;
770 srf
= &vfbs
->surface
->res
;
772 ret
= vmw_kms_helper_resource_prepare(srf
, true);
776 sdirty
.base
.fifo_commit
= vmw_sou_surface_fifo_commit
;
777 sdirty
.base
.clip
= vmw_sou_surface_clip
;
778 sdirty
.base
.dev_priv
= dev_priv
;
779 sdirty
.base
.fifo_reserve_size
= sizeof(struct vmw_kms_sou_dirty_cmd
) +
780 sizeof(SVGASignedRect
) * num_clips
;
782 sdirty
.sid
= srf
->id
;
783 sdirty
.left
= sdirty
.top
= S32_MAX
;
784 sdirty
.right
= sdirty
.bottom
= S32_MIN
;
785 sdirty
.dst_x
= dest_x
;
786 sdirty
.dst_y
= dest_y
;
788 ret
= vmw_kms_helper_dirty(dev_priv
, framebuffer
, clips
, vclips
,
789 dest_x
, dest_y
, num_clips
, inc
,
791 vmw_kms_helper_resource_finish(srf
, out_fence
);
797 * vmw_sou_dmabuf_fifo_commit - Callback to submit a set of readback clips.
799 * @dirty: The closure structure.
801 * Commits a previously built command buffer of readback clips.
803 static void vmw_sou_dmabuf_fifo_commit(struct vmw_kms_dirty
*dirty
)
805 if (!dirty
->num_hits
) {
806 vmw_fifo_commit(dirty
->dev_priv
, 0);
810 vmw_fifo_commit(dirty
->dev_priv
,
811 sizeof(struct vmw_kms_sou_dmabuf_blit
) *
816 * vmw_sou_dmabuf_clip - Callback to encode a readback cliprect.
818 * @dirty: The closure structure
820 * Encodes a BLIT_GMRFB_TO_SCREEN cliprect.
822 static void vmw_sou_dmabuf_clip(struct vmw_kms_dirty
*dirty
)
824 struct vmw_kms_sou_dmabuf_blit
*blit
= dirty
->cmd
;
826 blit
+= dirty
->num_hits
;
827 blit
->header
= SVGA_CMD_BLIT_GMRFB_TO_SCREEN
;
828 blit
->body
.destScreenId
= dirty
->unit
->unit
;
829 blit
->body
.srcOrigin
.x
= dirty
->fb_x
;
830 blit
->body
.srcOrigin
.y
= dirty
->fb_y
;
831 blit
->body
.destRect
.left
= dirty
->unit_x1
;
832 blit
->body
.destRect
.top
= dirty
->unit_y1
;
833 blit
->body
.destRect
.right
= dirty
->unit_x2
;
834 blit
->body
.destRect
.bottom
= dirty
->unit_y2
;
839 * vmw_kms_do_dmabuf_dirty - Dirty part of a dma-buffer backed framebuffer
841 * @dev_priv: Pointer to the device private structure.
842 * @framebuffer: Pointer to the dma-buffer backed framebuffer.
843 * @clips: Array of clip rects.
844 * @vclips: Alternate array of clip rects. Either @clips or @vclips must
846 * @num_clips: Number of clip rects in @clips.
847 * @increment: Increment to use when looping over @clips.
848 * @interruptible: Whether to perform waits interruptible if possible.
849 * @out_fence: If non-NULL, will return a ref-counted pointer to a
850 * struct vmw_fence_obj. The returned fence pointer may be NULL in which
851 * case the device has already synchronized.
853 * Returns 0 on success, negative error code on failure. -ERESTARTSYS if
856 int vmw_kms_sou_do_dmabuf_dirty(struct vmw_private
*dev_priv
,
857 struct vmw_framebuffer
*framebuffer
,
858 struct drm_clip_rect
*clips
,
859 struct drm_vmw_rect
*vclips
,
860 unsigned num_clips
, int increment
,
862 struct vmw_fence_obj
**out_fence
)
864 struct vmw_dma_buffer
*buf
=
865 container_of(framebuffer
, struct vmw_framebuffer_dmabuf
,
867 struct vmw_kms_dirty dirty
;
870 ret
= vmw_kms_helper_buffer_prepare(dev_priv
, buf
, interruptible
,
875 ret
= do_dmabuf_define_gmrfb(dev_priv
, framebuffer
);
876 if (unlikely(ret
!= 0))
879 dirty
.fifo_commit
= vmw_sou_dmabuf_fifo_commit
;
880 dirty
.clip
= vmw_sou_dmabuf_clip
;
881 dirty
.fifo_reserve_size
= sizeof(struct vmw_kms_sou_dmabuf_blit
) *
883 ret
= vmw_kms_helper_dirty(dev_priv
, framebuffer
, clips
, vclips
,
884 0, 0, num_clips
, increment
, &dirty
);
885 vmw_kms_helper_buffer_finish(dev_priv
, NULL
, buf
, out_fence
, NULL
);
890 vmw_kms_helper_buffer_revert(buf
);
897 * vmw_sou_readback_fifo_commit - Callback to submit a set of readback clips.
899 * @dirty: The closure structure.
901 * Commits a previously built command buffer of readback clips.
903 static void vmw_sou_readback_fifo_commit(struct vmw_kms_dirty
*dirty
)
905 if (!dirty
->num_hits
) {
906 vmw_fifo_commit(dirty
->dev_priv
, 0);
910 vmw_fifo_commit(dirty
->dev_priv
,
911 sizeof(struct vmw_kms_sou_readback_blit
) *
916 * vmw_sou_readback_clip - Callback to encode a readback cliprect.
918 * @dirty: The closure structure
920 * Encodes a BLIT_SCREEN_TO_GMRFB cliprect.
922 static void vmw_sou_readback_clip(struct vmw_kms_dirty
*dirty
)
924 struct vmw_kms_sou_readback_blit
*blit
= dirty
->cmd
;
926 blit
+= dirty
->num_hits
;
927 blit
->header
= SVGA_CMD_BLIT_SCREEN_TO_GMRFB
;
928 blit
->body
.srcScreenId
= dirty
->unit
->unit
;
929 blit
->body
.destOrigin
.x
= dirty
->fb_x
;
930 blit
->body
.destOrigin
.y
= dirty
->fb_y
;
931 blit
->body
.srcRect
.left
= dirty
->unit_x1
;
932 blit
->body
.srcRect
.top
= dirty
->unit_y1
;
933 blit
->body
.srcRect
.right
= dirty
->unit_x2
;
934 blit
->body
.srcRect
.bottom
= dirty
->unit_y2
;
939 * vmw_kms_sou_readback - Perform a readback from the screen object system to
940 * a dma-buffer backed framebuffer.
942 * @dev_priv: Pointer to the device private structure.
943 * @file_priv: Pointer to a struct drm_file identifying the caller.
944 * Must be set to NULL if @user_fence_rep is NULL.
945 * @vfb: Pointer to the dma-buffer backed framebuffer.
946 * @user_fence_rep: User-space provided structure for fence information.
947 * Must be set to non-NULL if @file_priv is non-NULL.
948 * @vclips: Array of clip rects.
949 * @num_clips: Number of clip rects in @vclips.
951 * Returns 0 on success, negative error code on failure. -ERESTARTSYS if
954 int vmw_kms_sou_readback(struct vmw_private
*dev_priv
,
955 struct drm_file
*file_priv
,
956 struct vmw_framebuffer
*vfb
,
957 struct drm_vmw_fence_rep __user
*user_fence_rep
,
958 struct drm_vmw_rect
*vclips
,
961 struct vmw_dma_buffer
*buf
=
962 container_of(vfb
, struct vmw_framebuffer_dmabuf
, base
)->buffer
;
963 struct vmw_kms_dirty dirty
;
966 ret
= vmw_kms_helper_buffer_prepare(dev_priv
, buf
, true, false);
970 ret
= do_dmabuf_define_gmrfb(dev_priv
, vfb
);
971 if (unlikely(ret
!= 0))
974 dirty
.fifo_commit
= vmw_sou_readback_fifo_commit
;
975 dirty
.clip
= vmw_sou_readback_clip
;
976 dirty
.fifo_reserve_size
= sizeof(struct vmw_kms_sou_readback_blit
) *
978 ret
= vmw_kms_helper_dirty(dev_priv
, vfb
, NULL
, vclips
,
979 0, 0, num_clips
, 1, &dirty
);
980 vmw_kms_helper_buffer_finish(dev_priv
, file_priv
, buf
, NULL
,
986 vmw_kms_helper_buffer_revert(buf
);