1 // SPDX-License-Identifier: GPL-2.0 OR MIT
2 /**************************************************************************
4 * Copyright 2009-2023 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 **************************************************************************/
27 #include "vmwgfx_kms.h"
29 #include "vmwgfx_bo.h"
30 #include "vmw_surface_cache.h"
32 #include <drm/drm_atomic.h>
33 #include <drm/drm_atomic_helper.h>
34 #include <drm/drm_damage_helper.h>
35 #include <drm/drm_fourcc.h>
36 #include <drm/drm_rect.h>
37 #include <drm/drm_sysfs.h>
38 #include <drm/drm_edid.h>
40 void vmw_du_cleanup(struct vmw_display_unit *du)
42 struct vmw_private *dev_priv = vmw_priv(du->primary.dev);
43 drm_plane_cleanup(&du->primary);
44 if (vmw_cmd_supported(dev_priv))
45 drm_plane_cleanup(&du->cursor.base);
47 drm_connector_unregister(&du->connector);
48 drm_crtc_cleanup(&du->crtc);
49 drm_encoder_cleanup(&du->encoder);
50 drm_connector_cleanup(&du->connector);
54 * Display Unit Cursor functions
57 static int vmw_du_cursor_plane_unmap_cm(struct vmw_plane_state *vps);
58 static void vmw_cursor_update_mob(struct vmw_private *dev_priv,
59 struct vmw_plane_state *vps,
60 u32 *image, u32 width, u32 height,
61 u32 hotspotX, u32 hotspotY);
63 struct vmw_svga_fifo_cmd_define_cursor {
65 SVGAFifoCmdDefineAlphaCursor cursor;
69 * vmw_send_define_cursor_cmd - queue a define cursor command
70 * @dev_priv: the private driver struct
71 * @image: buffer which holds the cursor image
72 * @width: width of the mouse cursor image
73 * @height: height of the mouse cursor image
74 * @hotspotX: the horizontal position of mouse hotspot
75 * @hotspotY: the vertical position of mouse hotspot
77 static void vmw_send_define_cursor_cmd(struct vmw_private *dev_priv,
78 u32 *image, u32 width, u32 height,
79 u32 hotspotX, u32 hotspotY)
81 struct vmw_svga_fifo_cmd_define_cursor *cmd;
82 const u32 image_size = width * height * sizeof(*image);
83 const u32 cmd_size = sizeof(*cmd) + image_size;
85 /* Try to reserve fifocmd space and swallow any failures;
86 such reservations cannot be left unconsumed for long
87 under the risk of clogging other fifocmd users, so
88 we treat reservations separtely from the way we treat
89 other fallible KMS-atomic resources at prepare_fb */
90 cmd = VMW_CMD_RESERVE(dev_priv, cmd_size);
95 memset(cmd, 0, sizeof(*cmd));
97 memcpy(&cmd[1], image, image_size);
99 cmd->cmd = SVGA_CMD_DEFINE_ALPHA_CURSOR;
101 cmd->cursor.width = width;
102 cmd->cursor.height = height;
103 cmd->cursor.hotspotX = hotspotX;
104 cmd->cursor.hotspotY = hotspotY;
106 vmw_cmd_commit_flush(dev_priv, cmd_size);
110 * vmw_cursor_update_image - update the cursor image on the provided plane
111 * @dev_priv: the private driver struct
112 * @vps: the plane state of the cursor plane
113 * @image: buffer which holds the cursor image
114 * @width: width of the mouse cursor image
115 * @height: height of the mouse cursor image
116 * @hotspotX: the horizontal position of mouse hotspot
117 * @hotspotY: the vertical position of mouse hotspot
119 static void vmw_cursor_update_image(struct vmw_private *dev_priv,
120 struct vmw_plane_state *vps,
121 u32 *image, u32 width, u32 height,
122 u32 hotspotX, u32 hotspotY)
125 vmw_cursor_update_mob(dev_priv, vps, image,
126 vps->base.crtc_w, vps->base.crtc_h,
130 vmw_send_define_cursor_cmd(dev_priv, image, width, height,
136 * vmw_cursor_update_mob - Update cursor vis CursorMob mechanism
138 * Called from inside vmw_du_cursor_plane_atomic_update to actually
139 * make the cursor-image live.
141 * @dev_priv: device to work with
142 * @vps: the plane state of the cursor plane
143 * @image: cursor source data to fill the MOB with
144 * @width: source data width
145 * @height: source data height
146 * @hotspotX: cursor hotspot x
147 * @hotspotY: cursor hotspot Y
149 static void vmw_cursor_update_mob(struct vmw_private *dev_priv,
150 struct vmw_plane_state *vps,
151 u32 *image, u32 width, u32 height,
152 u32 hotspotX, u32 hotspotY)
154 SVGAGBCursorHeader *header;
155 SVGAGBAlphaCursorHeader *alpha_header;
156 const u32 image_size = width * height * sizeof(*image);
158 header = vmw_bo_map_and_cache(vps->cursor.bo);
159 alpha_header = &header->header.alphaHeader;
161 memset(header, 0, sizeof(*header));
163 header->type = SVGA_ALPHA_CURSOR;
164 header->sizeInBytes = image_size;
166 alpha_header->hotspotX = hotspotX;
167 alpha_header->hotspotY = hotspotY;
168 alpha_header->width = width;
169 alpha_header->height = height;
171 memcpy(header + 1, image, image_size);
172 vmw_write(dev_priv, SVGA_REG_CURSOR_MOBID,
173 vps->cursor.bo->tbo.resource->start);
177 static u32 vmw_du_cursor_mob_size(u32 w, u32 h)
179 return w * h * sizeof(u32) + sizeof(SVGAGBCursorHeader);
183 * vmw_du_cursor_plane_acquire_image -- Acquire the image data
184 * @vps: cursor plane state
186 static u32 *vmw_du_cursor_plane_acquire_image(struct vmw_plane_state *vps)
189 if (vps->surf_mapped)
190 return vmw_bo_map_and_cache(vps->surf->res.guest_memory_bo);
191 return vps->surf->snooper.image;
193 return vmw_bo_map_and_cache(vps->bo);
197 static bool vmw_du_cursor_plane_has_changed(struct vmw_plane_state *old_vps,
198 struct vmw_plane_state *new_vps)
205 if (old_vps->base.crtc_w != new_vps->base.crtc_w ||
206 old_vps->base.crtc_h != new_vps->base.crtc_h)
209 if (old_vps->cursor.hotspot_x != new_vps->cursor.hotspot_x ||
210 old_vps->cursor.hotspot_y != new_vps->cursor.hotspot_y)
213 size = new_vps->base.crtc_w * new_vps->base.crtc_h * sizeof(u32);
215 old_image = vmw_du_cursor_plane_acquire_image(old_vps);
216 new_image = vmw_du_cursor_plane_acquire_image(new_vps);
219 if (old_image && new_image)
220 changed = memcmp(old_image, new_image, size) != 0;
225 static void vmw_du_destroy_cursor_mob(struct vmw_bo **vbo)
230 ttm_bo_unpin(&(*vbo)->tbo);
231 vmw_bo_unreference(vbo);
234 static void vmw_du_put_cursor_mob(struct vmw_cursor_plane *vcp,
235 struct vmw_plane_state *vps)
242 vmw_du_cursor_plane_unmap_cm(vps);
244 /* Look for a free slot to return this mob to the cache. */
245 for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++) {
246 if (!vcp->cursor_mobs[i]) {
247 vcp->cursor_mobs[i] = vps->cursor.bo;
248 vps->cursor.bo = NULL;
253 /* Cache is full: See if this mob is bigger than an existing mob. */
254 for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++) {
255 if (vcp->cursor_mobs[i]->tbo.base.size <
256 vps->cursor.bo->tbo.base.size) {
257 vmw_du_destroy_cursor_mob(&vcp->cursor_mobs[i]);
258 vcp->cursor_mobs[i] = vps->cursor.bo;
259 vps->cursor.bo = NULL;
264 /* Destroy it if it's not worth caching. */
265 vmw_du_destroy_cursor_mob(&vps->cursor.bo);
268 static int vmw_du_get_cursor_mob(struct vmw_cursor_plane *vcp,
269 struct vmw_plane_state *vps)
271 struct vmw_private *dev_priv = vcp->base.dev->dev_private;
272 u32 size = vmw_du_cursor_mob_size(vps->base.crtc_w, vps->base.crtc_h);
274 u32 cursor_max_dim, mob_max_size;
275 struct vmw_fence_obj *fence = NULL;
278 if (!dev_priv->has_mob ||
279 (dev_priv->capabilities2 & SVGA_CAP2_CURSOR_MOB) == 0)
282 mob_max_size = vmw_read(dev_priv, SVGA_REG_MOB_MAX_SIZE);
283 cursor_max_dim = vmw_read(dev_priv, SVGA_REG_CURSOR_MAX_DIMENSION);
285 if (size > mob_max_size || vps->base.crtc_w > cursor_max_dim ||
286 vps->base.crtc_h > cursor_max_dim)
289 if (vps->cursor.bo) {
290 if (vps->cursor.bo->tbo.base.size >= size)
292 vmw_du_put_cursor_mob(vcp, vps);
295 /* Look for an unused mob in the cache. */
296 for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++) {
297 if (vcp->cursor_mobs[i] &&
298 vcp->cursor_mobs[i]->tbo.base.size >= size) {
299 vps->cursor.bo = vcp->cursor_mobs[i];
300 vcp->cursor_mobs[i] = NULL;
304 /* Create a new mob if we can't find an existing one. */
305 ret = vmw_bo_create_and_populate(dev_priv, size,
312 /* Fence the mob creation so we are guarateed to have the mob */
313 ret = ttm_bo_reserve(&vps->cursor.bo->tbo, false, false, NULL);
317 ret = vmw_execbuf_fence_commands(NULL, dev_priv, &fence, NULL);
319 ttm_bo_unreserve(&vps->cursor.bo->tbo);
323 dma_fence_wait(&fence->base, false);
324 dma_fence_put(&fence->base);
326 ttm_bo_unreserve(&vps->cursor.bo->tbo);
330 vmw_du_destroy_cursor_mob(&vps->cursor.bo);
335 static void vmw_cursor_update_position(struct vmw_private *dev_priv,
336 bool show, int x, int y)
338 const uint32_t svga_cursor_on = show ? SVGA_CURSOR_ON_SHOW
339 : SVGA_CURSOR_ON_HIDE;
342 spin_lock(&dev_priv->cursor_lock);
343 if (dev_priv->capabilities2 & SVGA_CAP2_EXTRA_REGS) {
344 vmw_write(dev_priv, SVGA_REG_CURSOR4_X, x);
345 vmw_write(dev_priv, SVGA_REG_CURSOR4_Y, y);
346 vmw_write(dev_priv, SVGA_REG_CURSOR4_SCREEN_ID, SVGA3D_INVALID_ID);
347 vmw_write(dev_priv, SVGA_REG_CURSOR4_ON, svga_cursor_on);
348 vmw_write(dev_priv, SVGA_REG_CURSOR4_SUBMIT, 1);
349 } else if (vmw_is_cursor_bypass3_enabled(dev_priv)) {
350 vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_ON, svga_cursor_on);
351 vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_X, x);
352 vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_Y, y);
353 count = vmw_fifo_mem_read(dev_priv, SVGA_FIFO_CURSOR_COUNT);
354 vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_COUNT, ++count);
356 vmw_write(dev_priv, SVGA_REG_CURSOR_X, x);
357 vmw_write(dev_priv, SVGA_REG_CURSOR_Y, y);
358 vmw_write(dev_priv, SVGA_REG_CURSOR_ON, svga_cursor_on);
360 spin_unlock(&dev_priv->cursor_lock);
363 void vmw_kms_cursor_snoop(struct vmw_surface *srf,
364 struct ttm_object_file *tfile,
365 struct ttm_buffer_object *bo,
366 SVGA3dCmdHeader *header)
368 struct ttm_bo_kmap_obj map;
369 unsigned long kmap_offset;
370 unsigned long kmap_num;
376 SVGA3dCmdHeader header;
377 SVGA3dCmdSurfaceDMA dma;
380 const struct SVGA3dSurfaceDesc *desc =
381 vmw_surface_get_desc(VMW_CURSOR_SNOOP_FORMAT);
382 const u32 image_pitch = VMW_CURSOR_SNOOP_WIDTH * desc->pitchBytesPerBlock;
384 cmd = container_of(header, struct vmw_dma_cmd, header);
386 /* No snooper installed, nothing to copy */
387 if (!srf->snooper.image)
390 if (cmd->dma.host.face != 0 || cmd->dma.host.mipmap != 0) {
391 DRM_ERROR("face and mipmap for cursors should never != 0\n");
395 if (cmd->header.size < 64) {
396 DRM_ERROR("at least one full copy box must be given\n");
400 box = (SVGA3dCopyBox *)&cmd[1];
401 box_count = (cmd->header.size - sizeof(SVGA3dCmdSurfaceDMA)) /
402 sizeof(SVGA3dCopyBox);
404 if (cmd->dma.guest.ptr.offset % PAGE_SIZE ||
405 box->x != 0 || box->y != 0 || box->z != 0 ||
406 box->srcx != 0 || box->srcy != 0 || box->srcz != 0 ||
407 box->d != 1 || box_count != 1 ||
408 box->w > VMW_CURSOR_SNOOP_WIDTH || box->h > VMW_CURSOR_SNOOP_HEIGHT) {
409 /* TODO handle none page aligned offsets */
410 /* TODO handle more dst & src != 0 */
411 /* TODO handle more then one copy */
412 DRM_ERROR("Can't snoop dma request for cursor!\n");
413 DRM_ERROR("(%u, %u, %u) (%u, %u, %u) (%ux%ux%u) %u %u\n",
414 box->srcx, box->srcy, box->srcz,
415 box->x, box->y, box->z,
416 box->w, box->h, box->d, box_count,
417 cmd->dma.guest.ptr.offset);
421 kmap_offset = cmd->dma.guest.ptr.offset >> PAGE_SHIFT;
422 kmap_num = (VMW_CURSOR_SNOOP_HEIGHT*image_pitch) >> PAGE_SHIFT;
424 ret = ttm_bo_reserve(bo, true, false, NULL);
425 if (unlikely(ret != 0)) {
426 DRM_ERROR("reserve failed\n");
430 ret = ttm_bo_kmap(bo, kmap_offset, kmap_num, &map);
431 if (unlikely(ret != 0))
434 virtual = ttm_kmap_obj_virtual(&map, &is_iomem);
436 if (box->w == VMW_CURSOR_SNOOP_WIDTH && cmd->dma.guest.pitch == image_pitch) {
437 memcpy(srf->snooper.image, virtual,
438 VMW_CURSOR_SNOOP_HEIGHT*image_pitch);
440 /* Image is unsigned pointer. */
441 for (i = 0; i < box->h; i++)
442 memcpy(srf->snooper.image + i * image_pitch,
443 virtual + i * cmd->dma.guest.pitch,
444 box->w * desc->pitchBytesPerBlock);
451 ttm_bo_unreserve(bo);
455 * vmw_kms_legacy_hotspot_clear - Clear legacy hotspots
457 * @dev_priv: Pointer to the device private struct.
459 * Clears all legacy hotspots.
461 void vmw_kms_legacy_hotspot_clear(struct vmw_private *dev_priv)
463 struct drm_device *dev = &dev_priv->drm;
464 struct vmw_display_unit *du;
465 struct drm_crtc *crtc;
467 drm_modeset_lock_all(dev);
468 drm_for_each_crtc(crtc, dev) {
469 du = vmw_crtc_to_du(crtc);
474 drm_modeset_unlock_all(dev);
477 void vmw_kms_cursor_post_execbuf(struct vmw_private *dev_priv)
479 struct drm_device *dev = &dev_priv->drm;
480 struct vmw_display_unit *du;
481 struct drm_crtc *crtc;
483 mutex_lock(&dev->mode_config.mutex);
485 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
486 du = vmw_crtc_to_du(crtc);
487 if (!du->cursor_surface ||
488 du->cursor_age == du->cursor_surface->snooper.age ||
489 !du->cursor_surface->snooper.image)
492 du->cursor_age = du->cursor_surface->snooper.age;
493 vmw_send_define_cursor_cmd(dev_priv,
494 du->cursor_surface->snooper.image,
495 VMW_CURSOR_SNOOP_WIDTH,
496 VMW_CURSOR_SNOOP_HEIGHT,
497 du->hotspot_x + du->core_hotspot_x,
498 du->hotspot_y + du->core_hotspot_y);
501 mutex_unlock(&dev->mode_config.mutex);
505 void vmw_du_cursor_plane_destroy(struct drm_plane *plane)
507 struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
510 vmw_cursor_update_position(plane->dev->dev_private, false, 0, 0);
512 for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++)
513 vmw_du_destroy_cursor_mob(&vcp->cursor_mobs[i]);
515 drm_plane_cleanup(plane);
519 void vmw_du_primary_plane_destroy(struct drm_plane *plane)
521 drm_plane_cleanup(plane);
523 /* Planes are static in our case so we don't free it */
528 * vmw_du_plane_unpin_surf - unpins resource associated with a framebuffer surface
530 * @vps: plane state associated with the display surface
531 * @unreference: true if we also want to unreference the display.
533 void vmw_du_plane_unpin_surf(struct vmw_plane_state *vps,
538 vmw_resource_unpin(&vps->surf->res);
544 DRM_ERROR("Surface still pinned\n");
545 vmw_surface_unreference(&vps->surf);
552 * vmw_du_plane_cleanup_fb - Unpins the plane surface
554 * @plane: display plane
555 * @old_state: Contains the FB to clean up
557 * Unpins the framebuffer surface
559 * Returns 0 on success
562 vmw_du_plane_cleanup_fb(struct drm_plane *plane,
563 struct drm_plane_state *old_state)
565 struct vmw_plane_state *vps = vmw_plane_state_to_vps(old_state);
567 vmw_du_plane_unpin_surf(vps, false);
572 * vmw_du_cursor_plane_map_cm - Maps the cursor mobs.
576 * Returns 0 on success
580 vmw_du_cursor_plane_map_cm(struct vmw_plane_state *vps)
583 u32 size = vmw_du_cursor_mob_size(vps->base.crtc_w, vps->base.crtc_h);
584 struct ttm_buffer_object *bo;
589 bo = &vps->cursor.bo->tbo;
591 if (bo->base.size < size)
594 if (vps->cursor.bo->map.virtual)
597 ret = ttm_bo_reserve(bo, false, false, NULL);
598 if (unlikely(ret != 0))
601 vmw_bo_map_and_cache(vps->cursor.bo);
603 ttm_bo_unreserve(bo);
605 if (unlikely(ret != 0))
613 * vmw_du_cursor_plane_unmap_cm - Unmaps the cursor mobs.
615 * @vps: state of the cursor plane
617 * Returns 0 on success
621 vmw_du_cursor_plane_unmap_cm(struct vmw_plane_state *vps)
624 struct vmw_bo *vbo = vps->cursor.bo;
626 if (!vbo || !vbo->map.virtual)
629 ret = ttm_bo_reserve(&vbo->tbo, true, false, NULL);
630 if (likely(ret == 0)) {
632 ttm_bo_unreserve(&vbo->tbo);
640 * vmw_du_cursor_plane_cleanup_fb - Unpins the plane surface
642 * @plane: cursor plane
643 * @old_state: contains the state to clean up
645 * Unmaps all cursor bo mappings and unpins the cursor surface
647 * Returns 0 on success
650 vmw_du_cursor_plane_cleanup_fb(struct drm_plane *plane,
651 struct drm_plane_state *old_state)
653 struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
654 struct vmw_plane_state *vps = vmw_plane_state_to_vps(old_state);
656 if (vps->surf_mapped) {
657 vmw_bo_unmap(vps->surf->res.guest_memory_bo);
658 vps->surf_mapped = false;
661 vmw_du_cursor_plane_unmap_cm(vps);
662 vmw_du_put_cursor_mob(vcp, vps);
664 vmw_du_plane_unpin_surf(vps, false);
667 vmw_surface_unreference(&vps->surf);
672 vmw_bo_unreference(&vps->bo);
679 * vmw_du_cursor_plane_prepare_fb - Readies the cursor by referencing it
681 * @plane: display plane
682 * @new_state: info on the new plane state, including the FB
684 * Returns 0 on success
687 vmw_du_cursor_plane_prepare_fb(struct drm_plane *plane,
688 struct drm_plane_state *new_state)
690 struct drm_framebuffer *fb = new_state->fb;
691 struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
692 struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state);
696 if (vps->surf_mapped) {
697 vmw_bo_unmap(vps->surf->res.guest_memory_bo);
698 vps->surf_mapped = false;
700 vmw_surface_unreference(&vps->surf);
705 vmw_bo_unreference(&vps->bo);
710 if (vmw_framebuffer_to_vfb(fb)->bo) {
711 vps->bo = vmw_framebuffer_to_vfbd(fb)->buffer;
712 vmw_bo_reference(vps->bo);
714 vps->surf = vmw_framebuffer_to_vfbs(fb)->surface;
715 vmw_surface_reference(vps->surf);
719 if (!vps->surf && vps->bo) {
720 const u32 size = new_state->crtc_w * new_state->crtc_h * sizeof(u32);
723 * Not using vmw_bo_map_and_cache() helper here as we need to
724 * reserve the ttm_buffer_object first which
725 * vmw_bo_map_and_cache() omits.
727 ret = ttm_bo_reserve(&vps->bo->tbo, true, false, NULL);
729 if (unlikely(ret != 0))
732 ret = ttm_bo_kmap(&vps->bo->tbo, 0, PFN_UP(size), &vps->bo->map);
734 ttm_bo_unreserve(&vps->bo->tbo);
736 if (unlikely(ret != 0))
738 } else if (vps->surf && !vps->bo && vps->surf->res.guest_memory_bo) {
740 WARN_ON(vps->surf->snooper.image);
741 ret = ttm_bo_reserve(&vps->surf->res.guest_memory_bo->tbo, true, false,
743 if (unlikely(ret != 0))
745 vmw_bo_map_and_cache(vps->surf->res.guest_memory_bo);
746 ttm_bo_unreserve(&vps->surf->res.guest_memory_bo->tbo);
747 vps->surf_mapped = true;
750 if (vps->surf || vps->bo) {
751 vmw_du_get_cursor_mob(vcp, vps);
752 vmw_du_cursor_plane_map_cm(vps);
760 vmw_du_cursor_plane_atomic_update(struct drm_plane *plane,
761 struct drm_atomic_state *state)
763 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
765 struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
767 struct drm_crtc *crtc = new_state->crtc ?: old_state->crtc;
768 struct vmw_private *dev_priv = vmw_priv(crtc->dev);
769 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
770 struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state);
771 struct vmw_plane_state *old_vps = vmw_plane_state_to_vps(old_state);
772 s32 hotspot_x, hotspot_y;
774 hotspot_x = du->hotspot_x + new_state->hotspot_x;
775 hotspot_y = du->hotspot_y + new_state->hotspot_y;
777 du->cursor_surface = vps->surf;
778 du->cursor_bo = vps->bo;
780 if (!vps->surf && !vps->bo) {
781 vmw_cursor_update_position(dev_priv, false, 0, 0);
785 vps->cursor.hotspot_x = hotspot_x;
786 vps->cursor.hotspot_y = hotspot_y;
789 du->cursor_age = du->cursor_surface->snooper.age;
792 if (!vmw_du_cursor_plane_has_changed(old_vps, vps)) {
794 * If it hasn't changed, avoid making the device do extra
795 * work by keeping the old cursor active.
797 struct vmw_cursor_plane_state tmp = old_vps->cursor;
798 old_vps->cursor = vps->cursor;
801 void *image = vmw_du_cursor_plane_acquire_image(vps);
803 vmw_cursor_update_image(dev_priv, vps, image,
806 hotspot_x, hotspot_y);
809 du->cursor_x = new_state->crtc_x + du->set_gui_x;
810 du->cursor_y = new_state->crtc_y + du->set_gui_y;
812 vmw_cursor_update_position(dev_priv, true,
813 du->cursor_x + hotspot_x,
814 du->cursor_y + hotspot_y);
816 du->core_hotspot_x = hotspot_x - du->hotspot_x;
817 du->core_hotspot_y = hotspot_y - du->hotspot_y;
822 * vmw_du_primary_plane_atomic_check - check if the new state is okay
824 * @plane: display plane
825 * @state: info on the new plane state, including the FB
827 * Check if the new state is settable given the current state. Other
828 * than what the atomic helper checks, we care about crtc fitting
829 * the FB and maintaining one active framebuffer.
831 * Returns 0 on success
833 int vmw_du_primary_plane_atomic_check(struct drm_plane *plane,
834 struct drm_atomic_state *state)
836 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
838 struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
840 struct drm_crtc_state *crtc_state = NULL;
841 struct drm_framebuffer *new_fb = new_state->fb;
842 struct drm_framebuffer *old_fb = old_state->fb;
846 * Ignore damage clips if the framebuffer attached to the plane's state
847 * has changed since the last plane update (page-flip). In this case, a
848 * full plane update should happen because uploads are done per-buffer.
850 if (old_fb != new_fb)
851 new_state->ignore_damage_clips = true;
854 crtc_state = drm_atomic_get_new_crtc_state(state,
857 ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
858 DRM_PLANE_NO_SCALING,
859 DRM_PLANE_NO_SCALING,
862 if (!ret && new_fb) {
863 struct drm_crtc *crtc = new_state->crtc;
864 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
866 vmw_connector_state_to_vcs(du->connector.state);
875 * vmw_du_cursor_plane_atomic_check - check if the new state is okay
877 * @plane: cursor plane
878 * @state: info on the new plane state
880 * This is a chance to fail if the new cursor state does not fit
883 * Returns 0 on success
885 int vmw_du_cursor_plane_atomic_check(struct drm_plane *plane,
886 struct drm_atomic_state *state)
888 struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
891 struct drm_crtc_state *crtc_state = NULL;
892 struct vmw_surface *surface = NULL;
893 struct drm_framebuffer *fb = new_state->fb;
896 crtc_state = drm_atomic_get_new_crtc_state(new_state->state,
899 ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
900 DRM_PLANE_NO_SCALING,
901 DRM_PLANE_NO_SCALING,
910 /* A lot of the code assumes this */
911 if (new_state->crtc_w != 64 || new_state->crtc_h != 64) {
912 DRM_ERROR("Invalid cursor dimensions (%d, %d)\n",
913 new_state->crtc_w, new_state->crtc_h);
917 if (!vmw_framebuffer_to_vfb(fb)->bo) {
918 surface = vmw_framebuffer_to_vfbs(fb)->surface;
923 (!surface->snooper.image && !surface->res.guest_memory_bo)) {
924 DRM_ERROR("surface not suitable for cursor\n");
933 int vmw_du_crtc_atomic_check(struct drm_crtc *crtc,
934 struct drm_atomic_state *state)
936 struct vmw_private *vmw = vmw_priv(crtc->dev);
937 struct drm_crtc_state *new_state = drm_atomic_get_new_crtc_state(state,
939 struct vmw_display_unit *du = vmw_crtc_to_du(new_state->crtc);
940 int connector_mask = drm_connector_mask(&du->connector);
941 bool has_primary = new_state->plane_mask &
942 drm_plane_mask(crtc->primary);
945 * This is fine in general, but broken userspace might expect
946 * some actual rendering so give a clue as why it's blank.
948 if (new_state->enable && !has_primary)
949 drm_dbg_driver(&vmw->drm,
950 "CRTC without a primary plane will be blank.\n");
953 if (new_state->connector_mask != connector_mask &&
954 new_state->connector_mask != 0) {
955 DRM_ERROR("Invalid connectors configuration\n");
960 * Our virtual device does not have a dot clock, so use the logical
961 * clock value as the dot clock.
963 if (new_state->mode.crtc_clock == 0)
964 new_state->adjusted_mode.crtc_clock = new_state->mode.clock;
970 void vmw_du_crtc_atomic_begin(struct drm_crtc *crtc,
971 struct drm_atomic_state *state)
976 void vmw_du_crtc_atomic_flush(struct drm_crtc *crtc,
977 struct drm_atomic_state *state)
983 * vmw_du_crtc_duplicate_state - duplicate crtc state
986 * Allocates and returns a copy of the crtc state (both common and
987 * vmw-specific) for the specified crtc.
989 * Returns: The newly allocated crtc state, or NULL on failure.
991 struct drm_crtc_state *
992 vmw_du_crtc_duplicate_state(struct drm_crtc *crtc)
994 struct drm_crtc_state *state;
995 struct vmw_crtc_state *vcs;
997 if (WARN_ON(!crtc->state))
1000 vcs = kmemdup(crtc->state, sizeof(*vcs), GFP_KERNEL);
1007 __drm_atomic_helper_crtc_duplicate_state(crtc, state);
1014 * vmw_du_crtc_reset - creates a blank vmw crtc state
1017 * Resets the atomic state for @crtc by freeing the state pointer (which
1018 * might be NULL, e.g. at driver load time) and allocating a new empty state
1021 void vmw_du_crtc_reset(struct drm_crtc *crtc)
1023 struct vmw_crtc_state *vcs;
1027 __drm_atomic_helper_crtc_destroy_state(crtc->state);
1029 kfree(vmw_crtc_state_to_vcs(crtc->state));
1032 vcs = kzalloc(sizeof(*vcs), GFP_KERNEL);
1035 DRM_ERROR("Cannot allocate vmw_crtc_state\n");
1039 __drm_atomic_helper_crtc_reset(crtc, &vcs->base);
1044 * vmw_du_crtc_destroy_state - destroy crtc state
1046 * @state: state object to destroy
1048 * Destroys the crtc state (both common and vmw-specific) for the
1052 vmw_du_crtc_destroy_state(struct drm_crtc *crtc,
1053 struct drm_crtc_state *state)
1055 drm_atomic_helper_crtc_destroy_state(crtc, state);
1060 * vmw_du_plane_duplicate_state - duplicate plane state
1063 * Allocates and returns a copy of the plane state (both common and
1064 * vmw-specific) for the specified plane.
1066 * Returns: The newly allocated plane state, or NULL on failure.
1068 struct drm_plane_state *
1069 vmw_du_plane_duplicate_state(struct drm_plane *plane)
1071 struct drm_plane_state *state;
1072 struct vmw_plane_state *vps;
1074 vps = kmemdup(plane->state, sizeof(*vps), GFP_KERNEL);
1082 memset(&vps->cursor, 0, sizeof(vps->cursor));
1084 /* Each ref counted resource needs to be acquired again */
1086 (void) vmw_surface_reference(vps->surf);
1089 (void) vmw_bo_reference(vps->bo);
1093 __drm_atomic_helper_plane_duplicate_state(plane, state);
1100 * vmw_du_plane_reset - creates a blank vmw plane state
1103 * Resets the atomic state for @plane by freeing the state pointer (which might
1104 * be NULL, e.g. at driver load time) and allocating a new empty state object.
1106 void vmw_du_plane_reset(struct drm_plane *plane)
1108 struct vmw_plane_state *vps;
1111 vmw_du_plane_destroy_state(plane, plane->state);
1113 vps = kzalloc(sizeof(*vps), GFP_KERNEL);
1116 DRM_ERROR("Cannot allocate vmw_plane_state\n");
1120 __drm_atomic_helper_plane_reset(plane, &vps->base);
1125 * vmw_du_plane_destroy_state - destroy plane state
1127 * @state: state object to destroy
1129 * Destroys the plane state (both common and vmw-specific) for the
1133 vmw_du_plane_destroy_state(struct drm_plane *plane,
1134 struct drm_plane_state *state)
1136 struct vmw_plane_state *vps = vmw_plane_state_to_vps(state);
1138 /* Should have been freed by cleanup_fb */
1140 vmw_surface_unreference(&vps->surf);
1143 vmw_bo_unreference(&vps->bo);
1145 drm_atomic_helper_plane_destroy_state(plane, state);
1150 * vmw_du_connector_duplicate_state - duplicate connector state
1151 * @connector: DRM connector
1153 * Allocates and returns a copy of the connector state (both common and
1154 * vmw-specific) for the specified connector.
1156 * Returns: The newly allocated connector state, or NULL on failure.
1158 struct drm_connector_state *
1159 vmw_du_connector_duplicate_state(struct drm_connector *connector)
1161 struct drm_connector_state *state;
1162 struct vmw_connector_state *vcs;
1164 if (WARN_ON(!connector->state))
1167 vcs = kmemdup(connector->state, sizeof(*vcs), GFP_KERNEL);
1174 __drm_atomic_helper_connector_duplicate_state(connector, state);
1181 * vmw_du_connector_reset - creates a blank vmw connector state
1182 * @connector: DRM connector
1184 * Resets the atomic state for @connector by freeing the state pointer (which
1185 * might be NULL, e.g. at driver load time) and allocating a new empty state
1188 void vmw_du_connector_reset(struct drm_connector *connector)
1190 struct vmw_connector_state *vcs;
1193 if (connector->state) {
1194 __drm_atomic_helper_connector_destroy_state(connector->state);
1196 kfree(vmw_connector_state_to_vcs(connector->state));
1199 vcs = kzalloc(sizeof(*vcs), GFP_KERNEL);
1202 DRM_ERROR("Cannot allocate vmw_connector_state\n");
1206 __drm_atomic_helper_connector_reset(connector, &vcs->base);
1211 * vmw_du_connector_destroy_state - destroy connector state
1212 * @connector: DRM connector
1213 * @state: state object to destroy
1215 * Destroys the connector state (both common and vmw-specific) for the
1219 vmw_du_connector_destroy_state(struct drm_connector *connector,
1220 struct drm_connector_state *state)
1222 drm_atomic_helper_connector_destroy_state(connector, state);
1225 * Generic framebuffer code
1229 * Surface framebuffer code
1232 static void vmw_framebuffer_surface_destroy(struct drm_framebuffer *framebuffer)
1234 struct vmw_framebuffer_surface *vfbs =
1235 vmw_framebuffer_to_vfbs(framebuffer);
1237 drm_framebuffer_cleanup(framebuffer);
1238 vmw_surface_unreference(&vfbs->surface);
1244 * vmw_kms_readback - Perform a readback from the screen system to
1245 * a buffer-object backed framebuffer.
1247 * @dev_priv: Pointer to the device private structure.
1248 * @file_priv: Pointer to a struct drm_file identifying the caller.
1249 * Must be set to NULL if @user_fence_rep is NULL.
1250 * @vfb: Pointer to the buffer-object backed framebuffer.
1251 * @user_fence_rep: User-space provided structure for fence information.
1252 * Must be set to non-NULL if @file_priv is non-NULL.
1253 * @vclips: Array of clip rects.
1254 * @num_clips: Number of clip rects in @vclips.
1256 * Returns 0 on success, negative error code on failure. -ERESTARTSYS if
1259 int vmw_kms_readback(struct vmw_private *dev_priv,
1260 struct drm_file *file_priv,
1261 struct vmw_framebuffer *vfb,
1262 struct drm_vmw_fence_rep __user *user_fence_rep,
1263 struct drm_vmw_rect *vclips,
1266 switch (dev_priv->active_display_unit) {
1267 case vmw_du_screen_object:
1268 return vmw_kms_sou_readback(dev_priv, file_priv, vfb,
1269 user_fence_rep, vclips, num_clips,
1271 case vmw_du_screen_target:
1272 return vmw_kms_stdu_readback(dev_priv, file_priv, vfb,
1273 user_fence_rep, NULL, vclips, num_clips,
1277 "Readback called with invalid display system.\n");
1284 static const struct drm_framebuffer_funcs vmw_framebuffer_surface_funcs = {
1285 .destroy = vmw_framebuffer_surface_destroy,
1286 .dirty = drm_atomic_helper_dirtyfb,
1289 static int vmw_kms_new_framebuffer_surface(struct vmw_private *dev_priv,
1290 struct vmw_surface *surface,
1291 struct vmw_framebuffer **out,
1292 const struct drm_mode_fb_cmd2
1297 struct drm_device *dev = &dev_priv->drm;
1298 struct vmw_framebuffer_surface *vfbs;
1299 enum SVGA3dSurfaceFormat format;
1302 /* 3D is only supported on HWv8 and newer hosts */
1303 if (dev_priv->active_display_unit == vmw_du_legacy)
1310 if (!drm_any_plane_has_format(&dev_priv->drm,
1311 mode_cmd->pixel_format,
1312 mode_cmd->modifier[0])) {
1313 drm_dbg(&dev_priv->drm,
1314 "unsupported pixel format %p4cc / modifier 0x%llx\n",
1315 &mode_cmd->pixel_format, mode_cmd->modifier[0]);
1319 /* Surface must be marked as a scanout. */
1320 if (unlikely(!surface->metadata.scanout))
1323 if (unlikely(surface->metadata.mip_levels[0] != 1 ||
1324 surface->metadata.num_sizes != 1 ||
1325 surface->metadata.base_size.width < mode_cmd->width ||
1326 surface->metadata.base_size.height < mode_cmd->height ||
1327 surface->metadata.base_size.depth != 1)) {
1328 DRM_ERROR("Incompatible surface dimensions "
1329 "for requested mode.\n");
1333 switch (mode_cmd->pixel_format) {
1334 case DRM_FORMAT_ARGB8888:
1335 format = SVGA3D_A8R8G8B8;
1337 case DRM_FORMAT_XRGB8888:
1338 format = SVGA3D_X8R8G8B8;
1340 case DRM_FORMAT_RGB565:
1341 format = SVGA3D_R5G6B5;
1343 case DRM_FORMAT_XRGB1555:
1344 format = SVGA3D_A1R5G5B5;
1347 DRM_ERROR("Invalid pixel format: %p4cc\n",
1348 &mode_cmd->pixel_format);
1353 * For DX, surface format validation is done when surface->scanout
1356 if (!has_sm4_context(dev_priv) && format != surface->metadata.format) {
1357 DRM_ERROR("Invalid surface format for requested mode.\n");
1361 vfbs = kzalloc(sizeof(*vfbs), GFP_KERNEL);
1367 drm_helper_mode_fill_fb_struct(dev, &vfbs->base.base, mode_cmd);
1368 vfbs->surface = vmw_surface_reference(surface);
1369 vfbs->base.user_handle = mode_cmd->handles[0];
1370 vfbs->is_bo_proxy = is_bo_proxy;
1374 ret = drm_framebuffer_init(dev, &vfbs->base.base,
1375 &vmw_framebuffer_surface_funcs);
1382 vmw_surface_unreference(&surface);
1389 * Buffer-object framebuffer code
1392 static int vmw_framebuffer_bo_create_handle(struct drm_framebuffer *fb,
1393 struct drm_file *file_priv,
1394 unsigned int *handle)
1396 struct vmw_framebuffer_bo *vfbd =
1397 vmw_framebuffer_to_vfbd(fb);
1399 return drm_gem_handle_create(file_priv, &vfbd->buffer->tbo.base, handle);
1402 static void vmw_framebuffer_bo_destroy(struct drm_framebuffer *framebuffer)
1404 struct vmw_framebuffer_bo *vfbd =
1405 vmw_framebuffer_to_vfbd(framebuffer);
1407 drm_framebuffer_cleanup(framebuffer);
1408 vmw_bo_unreference(&vfbd->buffer);
1413 static const struct drm_framebuffer_funcs vmw_framebuffer_bo_funcs = {
1414 .create_handle = vmw_framebuffer_bo_create_handle,
1415 .destroy = vmw_framebuffer_bo_destroy,
1416 .dirty = drm_atomic_helper_dirtyfb,
1420 * vmw_create_bo_proxy - create a proxy surface for the buffer object
1423 * @mode_cmd: parameters for the new surface
1424 * @bo_mob: MOB backing the buffer object
1425 * @srf_out: newly created surface
1427 * When the content FB is a buffer object, we create a surface as a proxy to the
1428 * same buffer. This way we can do a surface copy rather than a surface DMA.
1429 * This is a more efficient approach
1432 * 0 on success, error code otherwise
1434 static int vmw_create_bo_proxy(struct drm_device *dev,
1435 const struct drm_mode_fb_cmd2 *mode_cmd,
1436 struct vmw_bo *bo_mob,
1437 struct vmw_surface **srf_out)
1439 struct vmw_surface_metadata metadata = {0};
1441 struct vmw_resource *res;
1442 unsigned int bytes_pp;
1445 switch (mode_cmd->pixel_format) {
1446 case DRM_FORMAT_ARGB8888:
1447 case DRM_FORMAT_XRGB8888:
1448 format = SVGA3D_X8R8G8B8;
1452 case DRM_FORMAT_RGB565:
1453 case DRM_FORMAT_XRGB1555:
1454 format = SVGA3D_R5G6B5;
1464 DRM_ERROR("Invalid framebuffer format %p4cc\n",
1465 &mode_cmd->pixel_format);
1469 metadata.format = format;
1470 metadata.mip_levels[0] = 1;
1471 metadata.num_sizes = 1;
1472 metadata.base_size.width = mode_cmd->pitches[0] / bytes_pp;
1473 metadata.base_size.height = mode_cmd->height;
1474 metadata.base_size.depth = 1;
1475 metadata.scanout = true;
1477 ret = vmw_gb_surface_define(vmw_priv(dev), &metadata, srf_out);
1479 DRM_ERROR("Failed to allocate proxy content buffer\n");
1483 res = &(*srf_out)->res;
1485 /* Reserve and switch the backing mob. */
1486 mutex_lock(&res->dev_priv->cmdbuf_mutex);
1487 (void) vmw_resource_reserve(res, false, true);
1488 vmw_user_bo_unref(&res->guest_memory_bo);
1489 res->guest_memory_bo = vmw_user_bo_ref(bo_mob);
1490 res->guest_memory_offset = 0;
1491 vmw_resource_unreserve(res, false, false, false, NULL, 0);
1492 mutex_unlock(&res->dev_priv->cmdbuf_mutex);
1499 static int vmw_kms_new_framebuffer_bo(struct vmw_private *dev_priv,
1501 struct vmw_framebuffer **out,
1502 const struct drm_mode_fb_cmd2
1506 struct drm_device *dev = &dev_priv->drm;
1507 struct vmw_framebuffer_bo *vfbd;
1508 unsigned int requested_size;
1511 requested_size = mode_cmd->height * mode_cmd->pitches[0];
1512 if (unlikely(requested_size > bo->tbo.base.size)) {
1513 DRM_ERROR("Screen buffer object size is too small "
1514 "for requested mode.\n");
1518 if (!drm_any_plane_has_format(&dev_priv->drm,
1519 mode_cmd->pixel_format,
1520 mode_cmd->modifier[0])) {
1521 drm_dbg(&dev_priv->drm,
1522 "unsupported pixel format %p4cc / modifier 0x%llx\n",
1523 &mode_cmd->pixel_format, mode_cmd->modifier[0]);
1527 vfbd = kzalloc(sizeof(*vfbd), GFP_KERNEL);
1533 vfbd->base.base.obj[0] = &bo->tbo.base;
1534 drm_helper_mode_fill_fb_struct(dev, &vfbd->base.base, mode_cmd);
1535 vfbd->base.bo = true;
1536 vfbd->buffer = vmw_bo_reference(bo);
1537 vfbd->base.user_handle = mode_cmd->handles[0];
1540 ret = drm_framebuffer_init(dev, &vfbd->base.base,
1541 &vmw_framebuffer_bo_funcs);
1548 vmw_bo_unreference(&bo);
1556 * vmw_kms_srf_ok - check if a surface can be created
1558 * @dev_priv: Pointer to device private struct.
1559 * @width: requested width
1560 * @height: requested height
1562 * Surfaces need to be less than texture size
1565 vmw_kms_srf_ok(struct vmw_private *dev_priv, uint32_t width, uint32_t height)
1567 if (width > dev_priv->texture_max_width ||
1568 height > dev_priv->texture_max_height)
1575 * vmw_kms_new_framebuffer - Create a new framebuffer.
1577 * @dev_priv: Pointer to device private struct.
1578 * @bo: Pointer to buffer object to wrap the kms framebuffer around.
1579 * Either @bo or @surface must be NULL.
1580 * @surface: Pointer to a surface to wrap the kms framebuffer around.
1581 * Either @bo or @surface must be NULL.
1582 * @only_2d: No presents will occur to this buffer object based framebuffer.
1583 * This helps the code to do some important optimizations.
1584 * @mode_cmd: Frame-buffer metadata.
1586 struct vmw_framebuffer *
1587 vmw_kms_new_framebuffer(struct vmw_private *dev_priv,
1589 struct vmw_surface *surface,
1591 const struct drm_mode_fb_cmd2 *mode_cmd)
1593 struct vmw_framebuffer *vfb = NULL;
1594 bool is_bo_proxy = false;
1598 * We cannot use the SurfaceDMA command in an non-accelerated VM,
1599 * therefore, wrap the buffer object in a surface so we can use the
1600 * SurfaceCopy command.
1602 if (vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height) &&
1604 mode_cmd->width > 64 && /* Don't create a proxy for cursor */
1605 dev_priv->active_display_unit == vmw_du_screen_target) {
1606 ret = vmw_create_bo_proxy(&dev_priv->drm, mode_cmd,
1609 return ERR_PTR(ret);
1614 /* Create the new framebuffer depending one what we have */
1616 ret = vmw_kms_new_framebuffer_surface(dev_priv, surface, &vfb,
1620 * vmw_create_bo_proxy() adds a reference that is no longer
1624 vmw_surface_unreference(&surface);
1626 ret = vmw_kms_new_framebuffer_bo(dev_priv, bo, &vfb,
1633 return ERR_PTR(ret);
1639 * Generic Kernel modesetting functions
1642 static struct drm_framebuffer *vmw_kms_fb_create(struct drm_device *dev,
1643 struct drm_file *file_priv,
1644 const struct drm_mode_fb_cmd2 *mode_cmd)
1646 struct vmw_private *dev_priv = vmw_priv(dev);
1647 struct vmw_framebuffer *vfb = NULL;
1648 struct vmw_surface *surface = NULL;
1649 struct vmw_bo *bo = NULL;
1652 /* returns either a bo or surface */
1653 ret = vmw_user_lookup_handle(dev_priv, file_priv,
1654 mode_cmd->handles[0],
1657 DRM_ERROR("Invalid buffer object handle %u (0x%x).\n",
1658 mode_cmd->handles[0], mode_cmd->handles[0]);
1664 !vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height)) {
1665 DRM_ERROR("Surface size cannot exceed %dx%d\n",
1666 dev_priv->texture_max_width,
1667 dev_priv->texture_max_height);
1672 vfb = vmw_kms_new_framebuffer(dev_priv, bo, surface,
1673 !(dev_priv->capabilities & SVGA_CAP_3D),
1681 /* vmw_user_lookup_handle takes one ref so does new_fb */
1683 vmw_user_bo_unref(&bo);
1685 vmw_surface_unreference(&surface);
1688 DRM_ERROR("failed to create vmw_framebuffer: %i\n", ret);
1689 return ERR_PTR(ret);
1696 * vmw_kms_check_display_memory - Validates display memory required for a
1699 * @num_rects: number of drm_rect in rects
1700 * @rects: array of drm_rect representing the topology to validate indexed by
1704 * 0 on success otherwise negative error code
1706 static int vmw_kms_check_display_memory(struct drm_device *dev,
1708 struct drm_rect *rects)
1710 struct vmw_private *dev_priv = vmw_priv(dev);
1711 struct drm_rect bounding_box = {0};
1712 u64 total_pixels = 0, pixel_mem, bb_mem;
1715 for (i = 0; i < num_rects; i++) {
1717 * For STDU only individual screen (screen target) is limited by
1718 * SCREENTARGET_MAX_WIDTH/HEIGHT registers.
1720 if (dev_priv->active_display_unit == vmw_du_screen_target &&
1721 (drm_rect_width(&rects[i]) > dev_priv->stdu_max_width ||
1722 drm_rect_height(&rects[i]) > dev_priv->stdu_max_height)) {
1723 VMW_DEBUG_KMS("Screen size not supported.\n");
1727 /* Bounding box upper left is at (0,0). */
1728 if (rects[i].x2 > bounding_box.x2)
1729 bounding_box.x2 = rects[i].x2;
1731 if (rects[i].y2 > bounding_box.y2)
1732 bounding_box.y2 = rects[i].y2;
1734 total_pixels += (u64) drm_rect_width(&rects[i]) *
1735 (u64) drm_rect_height(&rects[i]);
1738 /* Virtual svga device primary limits are always in 32-bpp. */
1739 pixel_mem = total_pixels * 4;
1742 * For HV10 and below prim_bb_mem is vram size. When
1743 * SVGA_REG_MAX_PRIMARY_BOUNDING_BOX_MEM is not present vram size is
1744 * limit on primary bounding box
1746 if (pixel_mem > dev_priv->max_primary_mem) {
1747 VMW_DEBUG_KMS("Combined output size too large.\n");
1751 /* SVGA_CAP_NO_BB_RESTRICTION is available for STDU only. */
1752 if (dev_priv->active_display_unit != vmw_du_screen_target ||
1753 !(dev_priv->capabilities & SVGA_CAP_NO_BB_RESTRICTION)) {
1754 bb_mem = (u64) bounding_box.x2 * bounding_box.y2 * 4;
1756 if (bb_mem > dev_priv->max_primary_mem) {
1757 VMW_DEBUG_KMS("Topology is beyond supported limits.\n");
1766 * vmw_crtc_state_and_lock - Return new or current crtc state with locked
1768 * @state: The atomic state pointer containing the new atomic state
1771 * This function returns the new crtc state if it's part of the state update.
1772 * Otherwise returns the current crtc state. It also makes sure that the
1773 * crtc mutex is locked.
1775 * Returns: A valid crtc state pointer or NULL. It may also return a
1776 * pointer error, in particular -EDEADLK if locking needs to be rerun.
1778 static struct drm_crtc_state *
1779 vmw_crtc_state_and_lock(struct drm_atomic_state *state, struct drm_crtc *crtc)
1781 struct drm_crtc_state *crtc_state;
1783 crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
1785 lockdep_assert_held(&crtc->mutex.mutex.base);
1787 int ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
1789 if (ret != 0 && ret != -EALREADY)
1790 return ERR_PTR(ret);
1792 crtc_state = crtc->state;
1799 * vmw_kms_check_implicit - Verify that all implicit display units scan out
1800 * from the same fb after the new state is committed.
1801 * @dev: The drm_device.
1802 * @state: The new state to be checked.
1806 * -EINVAL on invalid state,
1807 * -EDEADLK if modeset locking needs to be rerun.
1809 static int vmw_kms_check_implicit(struct drm_device *dev,
1810 struct drm_atomic_state *state)
1812 struct drm_framebuffer *implicit_fb = NULL;
1813 struct drm_crtc *crtc;
1814 struct drm_crtc_state *crtc_state;
1815 struct drm_plane_state *plane_state;
1817 drm_for_each_crtc(crtc, dev) {
1818 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1820 if (!du->is_implicit)
1823 crtc_state = vmw_crtc_state_and_lock(state, crtc);
1824 if (IS_ERR(crtc_state))
1825 return PTR_ERR(crtc_state);
1827 if (!crtc_state || !crtc_state->enable)
1831 * Can't move primary planes across crtcs, so this is OK.
1832 * It also means we don't need to take the plane mutex.
1834 plane_state = du->primary.state;
1835 if (plane_state->crtc != crtc)
1839 implicit_fb = plane_state->fb;
1840 else if (implicit_fb != plane_state->fb)
1848 * vmw_kms_check_topology - Validates topology in drm_atomic_state
1850 * @state: the driver state object
1853 * 0 on success otherwise negative error code
1855 static int vmw_kms_check_topology(struct drm_device *dev,
1856 struct drm_atomic_state *state)
1858 struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1859 struct drm_rect *rects;
1860 struct drm_crtc *crtc;
1864 rects = kcalloc(dev->mode_config.num_crtc, sizeof(struct drm_rect),
1869 drm_for_each_crtc(crtc, dev) {
1870 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1871 struct drm_crtc_state *crtc_state;
1873 i = drm_crtc_index(crtc);
1875 crtc_state = vmw_crtc_state_and_lock(state, crtc);
1876 if (IS_ERR(crtc_state)) {
1877 ret = PTR_ERR(crtc_state);
1884 if (crtc_state->enable) {
1885 rects[i].x1 = du->gui_x;
1886 rects[i].y1 = du->gui_y;
1887 rects[i].x2 = du->gui_x + crtc_state->mode.hdisplay;
1888 rects[i].y2 = du->gui_y + crtc_state->mode.vdisplay;
1897 /* Determine change to topology due to new atomic state */
1898 for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state,
1899 new_crtc_state, i) {
1900 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1901 struct drm_connector *connector;
1902 struct drm_connector_state *conn_state;
1903 struct vmw_connector_state *vmw_conn_state;
1905 if (!du->pref_active && new_crtc_state->enable) {
1906 VMW_DEBUG_KMS("Enabling a disabled display unit\n");
1912 * For vmwgfx each crtc has only one connector attached and it
1913 * is not changed so don't really need to check the
1914 * crtc->connector_mask and iterate over it.
1916 connector = &du->connector;
1917 conn_state = drm_atomic_get_connector_state(state, connector);
1918 if (IS_ERR(conn_state)) {
1919 ret = PTR_ERR(conn_state);
1923 vmw_conn_state = vmw_connector_state_to_vcs(conn_state);
1924 vmw_conn_state->gui_x = du->gui_x;
1925 vmw_conn_state->gui_y = du->gui_y;
1928 ret = vmw_kms_check_display_memory(dev, dev->mode_config.num_crtc,
1937 * vmw_kms_atomic_check_modeset- validate state object for modeset changes
1940 * @state: the driver state object
1942 * This is a simple wrapper around drm_atomic_helper_check_modeset() for
1943 * us to assign a value to mode->crtc_clock so that
1944 * drm_calc_timestamping_constants() won't throw an error message
1947 * Zero for success or -errno
1950 vmw_kms_atomic_check_modeset(struct drm_device *dev,
1951 struct drm_atomic_state *state)
1953 struct drm_crtc *crtc;
1954 struct drm_crtc_state *crtc_state;
1955 bool need_modeset = false;
1958 ret = drm_atomic_helper_check(dev, state);
1962 ret = vmw_kms_check_implicit(dev, state);
1964 VMW_DEBUG_KMS("Invalid implicit state\n");
1968 for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1969 if (drm_atomic_crtc_needs_modeset(crtc_state))
1970 need_modeset = true;
1974 return vmw_kms_check_topology(dev, state);
1979 static const struct drm_mode_config_funcs vmw_kms_funcs = {
1980 .fb_create = vmw_kms_fb_create,
1981 .atomic_check = vmw_kms_atomic_check_modeset,
1982 .atomic_commit = drm_atomic_helper_commit,
1985 static int vmw_kms_generic_present(struct vmw_private *dev_priv,
1986 struct drm_file *file_priv,
1987 struct vmw_framebuffer *vfb,
1988 struct vmw_surface *surface,
1990 int32_t destX, int32_t destY,
1991 struct drm_vmw_rect *clips,
1994 return vmw_kms_sou_do_surface_dirty(dev_priv, vfb, NULL, clips,
1995 &surface->res, destX, destY,
1996 num_clips, 1, NULL, NULL);
2000 int vmw_kms_present(struct vmw_private *dev_priv,
2001 struct drm_file *file_priv,
2002 struct vmw_framebuffer *vfb,
2003 struct vmw_surface *surface,
2005 int32_t destX, int32_t destY,
2006 struct drm_vmw_rect *clips,
2011 switch (dev_priv->active_display_unit) {
2012 case vmw_du_screen_target:
2013 ret = vmw_kms_stdu_surface_dirty(dev_priv, vfb, NULL, clips,
2014 &surface->res, destX, destY,
2015 num_clips, 1, NULL, NULL);
2017 case vmw_du_screen_object:
2018 ret = vmw_kms_generic_present(dev_priv, file_priv, vfb, surface,
2019 sid, destX, destY, clips,
2024 "Present called with invalid display system.\n");
2031 vmw_cmd_flush(dev_priv, false);
2037 vmw_kms_create_hotplug_mode_update_property(struct vmw_private *dev_priv)
2039 if (dev_priv->hotplug_mode_update_property)
2042 dev_priv->hotplug_mode_update_property =
2043 drm_property_create_range(&dev_priv->drm,
2044 DRM_MODE_PROP_IMMUTABLE,
2045 "hotplug_mode_update", 0, 1);
2048 int vmw_kms_init(struct vmw_private *dev_priv)
2050 struct drm_device *dev = &dev_priv->drm;
2052 static const char *display_unit_names[] = {
2060 drm_mode_config_init(dev);
2061 dev->mode_config.funcs = &vmw_kms_funcs;
2062 dev->mode_config.min_width = 1;
2063 dev->mode_config.min_height = 1;
2064 dev->mode_config.max_width = dev_priv->texture_max_width;
2065 dev->mode_config.max_height = dev_priv->texture_max_height;
2066 dev->mode_config.preferred_depth = dev_priv->assume_16bpp ? 16 : 32;
2068 drm_mode_create_suggested_offset_properties(dev);
2069 vmw_kms_create_hotplug_mode_update_property(dev_priv);
2071 ret = vmw_kms_stdu_init_display(dev_priv);
2073 ret = vmw_kms_sou_init_display(dev_priv);
2074 if (ret) /* Fallback */
2075 ret = vmw_kms_ldu_init_display(dev_priv);
2077 BUILD_BUG_ON(ARRAY_SIZE(display_unit_names) != (vmw_du_max + 1));
2078 drm_info(&dev_priv->drm, "%s display unit initialized\n",
2079 display_unit_names[dev_priv->active_display_unit]);
2084 int vmw_kms_close(struct vmw_private *dev_priv)
2089 * Docs says we should take the lock before calling this function
2090 * but since it destroys encoders and our destructor calls
2091 * drm_encoder_cleanup which takes the lock we deadlock.
2093 drm_mode_config_cleanup(&dev_priv->drm);
2094 if (dev_priv->active_display_unit == vmw_du_legacy)
2095 ret = vmw_kms_ldu_close_display(dev_priv);
2100 int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,
2101 struct drm_file *file_priv)
2103 struct drm_vmw_cursor_bypass_arg *arg = data;
2104 struct vmw_display_unit *du;
2105 struct drm_crtc *crtc;
2108 mutex_lock(&dev->mode_config.mutex);
2109 if (arg->flags & DRM_VMW_CURSOR_BYPASS_ALL) {
2111 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
2112 du = vmw_crtc_to_du(crtc);
2113 du->hotspot_x = arg->xhot;
2114 du->hotspot_y = arg->yhot;
2117 mutex_unlock(&dev->mode_config.mutex);
2121 crtc = drm_crtc_find(dev, file_priv, arg->crtc_id);
2127 du = vmw_crtc_to_du(crtc);
2129 du->hotspot_x = arg->xhot;
2130 du->hotspot_y = arg->yhot;
2133 mutex_unlock(&dev->mode_config.mutex);
2138 int vmw_kms_write_svga(struct vmw_private *vmw_priv,
2139 unsigned width, unsigned height, unsigned pitch,
2140 unsigned bpp, unsigned depth)
2142 if (vmw_priv->capabilities & SVGA_CAP_PITCHLOCK)
2143 vmw_write(vmw_priv, SVGA_REG_PITCHLOCK, pitch);
2144 else if (vmw_fifo_have_pitchlock(vmw_priv))
2145 vmw_fifo_mem_write(vmw_priv, SVGA_FIFO_PITCHLOCK, pitch);
2146 vmw_write(vmw_priv, SVGA_REG_WIDTH, width);
2147 vmw_write(vmw_priv, SVGA_REG_HEIGHT, height);
2148 if ((vmw_priv->capabilities & SVGA_CAP_8BIT_EMULATION) != 0)
2149 vmw_write(vmw_priv, SVGA_REG_BITS_PER_PIXEL, bpp);
2151 if (vmw_read(vmw_priv, SVGA_REG_DEPTH) != depth) {
2152 DRM_ERROR("Invalid depth %u for %u bpp, host expects %u\n",
2153 depth, bpp, vmw_read(vmw_priv, SVGA_REG_DEPTH));
2160 bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
2164 return ((u64) pitch * (u64) height) < (u64)
2165 ((dev_priv->active_display_unit == vmw_du_screen_target) ?
2166 dev_priv->max_primary_mem : dev_priv->vram_size);
2170 * vmw_du_update_layout - Update the display unit with topology from resolution
2171 * plugin and generate DRM uevent
2172 * @dev_priv: device private
2173 * @num_rects: number of drm_rect in rects
2174 * @rects: toplogy to update
2176 static int vmw_du_update_layout(struct vmw_private *dev_priv,
2177 unsigned int num_rects, struct drm_rect *rects)
2179 struct drm_device *dev = &dev_priv->drm;
2180 struct vmw_display_unit *du;
2181 struct drm_connector *con;
2182 struct drm_connector_list_iter conn_iter;
2183 struct drm_modeset_acquire_ctx ctx;
2184 struct drm_crtc *crtc;
2187 /* Currently gui_x/y is protected with the crtc mutex */
2188 mutex_lock(&dev->mode_config.mutex);
2189 drm_modeset_acquire_init(&ctx, 0);
2191 drm_for_each_crtc(crtc, dev) {
2192 ret = drm_modeset_lock(&crtc->mutex, &ctx);
2194 if (ret == -EDEADLK) {
2195 drm_modeset_backoff(&ctx);
2202 drm_connector_list_iter_begin(dev, &conn_iter);
2203 drm_for_each_connector_iter(con, &conn_iter) {
2204 du = vmw_connector_to_du(con);
2205 if (num_rects > du->unit) {
2206 du->pref_width = drm_rect_width(&rects[du->unit]);
2207 du->pref_height = drm_rect_height(&rects[du->unit]);
2208 du->pref_active = true;
2209 du->gui_x = rects[du->unit].x1;
2210 du->gui_y = rects[du->unit].y1;
2212 du->pref_width = VMWGFX_MIN_INITIAL_WIDTH;
2213 du->pref_height = VMWGFX_MIN_INITIAL_HEIGHT;
2214 du->pref_active = false;
2219 drm_connector_list_iter_end(&conn_iter);
2221 list_for_each_entry(con, &dev->mode_config.connector_list, head) {
2222 du = vmw_connector_to_du(con);
2223 if (num_rects > du->unit) {
2224 drm_object_property_set_value
2225 (&con->base, dev->mode_config.suggested_x_property,
2227 drm_object_property_set_value
2228 (&con->base, dev->mode_config.suggested_y_property,
2231 drm_object_property_set_value
2232 (&con->base, dev->mode_config.suggested_x_property,
2234 drm_object_property_set_value
2235 (&con->base, dev->mode_config.suggested_y_property,
2238 con->status = vmw_du_connector_detect(con, true);
2241 drm_modeset_drop_locks(&ctx);
2242 drm_modeset_acquire_fini(&ctx);
2243 mutex_unlock(&dev->mode_config.mutex);
2245 drm_sysfs_hotplug_event(dev);
2250 int vmw_du_crtc_gamma_set(struct drm_crtc *crtc,
2251 u16 *r, u16 *g, u16 *b,
2253 struct drm_modeset_acquire_ctx *ctx)
2255 struct vmw_private *dev_priv = vmw_priv(crtc->dev);
2258 for (i = 0; i < size; i++) {
2259 DRM_DEBUG("%d r/g/b = 0x%04x / 0x%04x / 0x%04x\n", i,
2261 vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 0, r[i] >> 8);
2262 vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 1, g[i] >> 8);
2263 vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 2, b[i] >> 8);
2269 int vmw_du_connector_dpms(struct drm_connector *connector, int mode)
2274 enum drm_connector_status
2275 vmw_du_connector_detect(struct drm_connector *connector, bool force)
2277 uint32_t num_displays;
2278 struct drm_device *dev = connector->dev;
2279 struct vmw_private *dev_priv = vmw_priv(dev);
2280 struct vmw_display_unit *du = vmw_connector_to_du(connector);
2282 num_displays = vmw_read(dev_priv, SVGA_REG_NUM_DISPLAYS);
2284 return ((vmw_connector_to_du(connector)->unit < num_displays &&
2286 connector_status_connected : connector_status_disconnected);
2290 * vmw_guess_mode_timing - Provide fake timings for a
2291 * 60Hz vrefresh mode.
2293 * @mode: Pointer to a struct drm_display_mode with hdisplay and vdisplay
2294 * members filled in.
2296 void vmw_guess_mode_timing(struct drm_display_mode *mode)
2298 mode->hsync_start = mode->hdisplay + 50;
2299 mode->hsync_end = mode->hsync_start + 50;
2300 mode->htotal = mode->hsync_end + 50;
2302 mode->vsync_start = mode->vdisplay + 50;
2303 mode->vsync_end = mode->vsync_start + 50;
2304 mode->vtotal = mode->vsync_end + 50;
2306 mode->clock = (u32)mode->htotal * (u32)mode->vtotal / 100 * 6;
2311 * vmw_kms_update_layout_ioctl - Handler for DRM_VMW_UPDATE_LAYOUT ioctl
2312 * @dev: drm device for the ioctl
2313 * @data: data pointer for the ioctl
2314 * @file_priv: drm file for the ioctl call
2316 * Update preferred topology of display unit as per ioctl request. The topology
2317 * is expressed as array of drm_vmw_rect.
2319 * [0 0 640 480] [640 0 800 600] [0 480 640 480]
2322 * The x and y offset (upper left) in drm_vmw_rect cannot be less than 0. Beside
2323 * device limit on topology, x + w and y + h (lower right) cannot be greater
2324 * than INT_MAX. So topology beyond these limits will return with error.
2327 * Zero on success, negative errno on failure.
2329 int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
2330 struct drm_file *file_priv)
2332 struct vmw_private *dev_priv = vmw_priv(dev);
2333 struct drm_mode_config *mode_config = &dev->mode_config;
2334 struct drm_vmw_update_layout_arg *arg =
2335 (struct drm_vmw_update_layout_arg *)data;
2336 void __user *user_rects;
2337 struct drm_vmw_rect *rects;
2338 struct drm_rect *drm_rects;
2339 unsigned rects_size;
2342 if (!arg->num_outputs) {
2343 struct drm_rect def_rect = {0, 0,
2344 VMWGFX_MIN_INITIAL_WIDTH,
2345 VMWGFX_MIN_INITIAL_HEIGHT};
2346 vmw_du_update_layout(dev_priv, 1, &def_rect);
2350 rects_size = arg->num_outputs * sizeof(struct drm_vmw_rect);
2351 rects = kcalloc(arg->num_outputs, sizeof(struct drm_vmw_rect),
2353 if (unlikely(!rects))
2356 user_rects = (void __user *)(unsigned long)arg->rects;
2357 ret = copy_from_user(rects, user_rects, rects_size);
2358 if (unlikely(ret != 0)) {
2359 DRM_ERROR("Failed to get rects.\n");
2364 drm_rects = (struct drm_rect *)rects;
2366 VMW_DEBUG_KMS("Layout count = %u\n", arg->num_outputs);
2367 for (i = 0; i < arg->num_outputs; i++) {
2368 struct drm_vmw_rect curr_rect;
2370 /* Verify user-space for overflow as kernel use drm_rect */
2371 if ((rects[i].x + rects[i].w > INT_MAX) ||
2372 (rects[i].y + rects[i].h > INT_MAX)) {
2377 curr_rect = rects[i];
2378 drm_rects[i].x1 = curr_rect.x;
2379 drm_rects[i].y1 = curr_rect.y;
2380 drm_rects[i].x2 = curr_rect.x + curr_rect.w;
2381 drm_rects[i].y2 = curr_rect.y + curr_rect.h;
2383 VMW_DEBUG_KMS(" x1 = %d y1 = %d x2 = %d y2 = %d\n",
2384 drm_rects[i].x1, drm_rects[i].y1,
2385 drm_rects[i].x2, drm_rects[i].y2);
2388 * Currently this check is limiting the topology within
2389 * mode_config->max (which actually is max texture size
2390 * supported by virtual device). This limit is here to address
2391 * window managers that create a big framebuffer for whole
2394 if (drm_rects[i].x1 < 0 || drm_rects[i].y1 < 0 ||
2395 drm_rects[i].x2 > mode_config->max_width ||
2396 drm_rects[i].y2 > mode_config->max_height) {
2397 VMW_DEBUG_KMS("Invalid layout %d %d %d %d\n",
2398 drm_rects[i].x1, drm_rects[i].y1,
2399 drm_rects[i].x2, drm_rects[i].y2);
2405 ret = vmw_kms_check_display_memory(dev, arg->num_outputs, drm_rects);
2408 vmw_du_update_layout(dev_priv, arg->num_outputs, drm_rects);
2416 * vmw_kms_helper_dirty - Helper to build commands and perform actions based
2417 * on a set of cliprects and a set of display units.
2419 * @dev_priv: Pointer to a device private structure.
2420 * @framebuffer: Pointer to the framebuffer on which to perform the actions.
2421 * @clips: A set of struct drm_clip_rect. Either this os @vclips must be NULL.
2422 * Cliprects are given in framebuffer coordinates.
2423 * @vclips: A set of struct drm_vmw_rect cliprects. Either this or @clips must
2424 * be NULL. Cliprects are given in source coordinates.
2425 * @dest_x: X coordinate offset for the crtc / destination clip rects.
2426 * @dest_y: Y coordinate offset for the crtc / destination clip rects.
2427 * @num_clips: Number of cliprects in the @clips or @vclips array.
2428 * @increment: Integer with which to increment the clip counter when looping.
2429 * Used to skip a predetermined number of clip rects.
2430 * @dirty: Closure structure. See the description of struct vmw_kms_dirty.
2432 int vmw_kms_helper_dirty(struct vmw_private *dev_priv,
2433 struct vmw_framebuffer *framebuffer,
2434 const struct drm_clip_rect *clips,
2435 const struct drm_vmw_rect *vclips,
2436 s32 dest_x, s32 dest_y,
2439 struct vmw_kms_dirty *dirty)
2441 struct vmw_display_unit *units[VMWGFX_NUM_DISPLAY_UNITS];
2442 struct drm_crtc *crtc;
2446 dirty->dev_priv = dev_priv;
2448 /* If crtc is passed, no need to iterate over other display units */
2450 units[num_units++] = vmw_crtc_to_du(dirty->crtc);
2452 list_for_each_entry(crtc, &dev_priv->drm.mode_config.crtc_list,
2454 struct drm_plane *plane = crtc->primary;
2456 if (plane->state->fb == &framebuffer->base)
2457 units[num_units++] = vmw_crtc_to_du(crtc);
2461 for (k = 0; k < num_units; k++) {
2462 struct vmw_display_unit *unit = units[k];
2463 s32 crtc_x = unit->crtc.x;
2464 s32 crtc_y = unit->crtc.y;
2465 s32 crtc_width = unit->crtc.mode.hdisplay;
2466 s32 crtc_height = unit->crtc.mode.vdisplay;
2467 const struct drm_clip_rect *clips_ptr = clips;
2468 const struct drm_vmw_rect *vclips_ptr = vclips;
2471 if (dirty->fifo_reserve_size > 0) {
2472 dirty->cmd = VMW_CMD_RESERVE(dev_priv,
2473 dirty->fifo_reserve_size);
2477 memset(dirty->cmd, 0, dirty->fifo_reserve_size);
2479 dirty->num_hits = 0;
2480 for (i = 0; i < num_clips; i++, clips_ptr += increment,
2481 vclips_ptr += increment) {
2486 * Select clip array type. Note that integer type
2487 * in @clips is unsigned short, whereas in @vclips
2491 dirty->fb_x = (s32) clips_ptr->x1;
2492 dirty->fb_y = (s32) clips_ptr->y1;
2493 dirty->unit_x2 = (s32) clips_ptr->x2 + dest_x -
2495 dirty->unit_y2 = (s32) clips_ptr->y2 + dest_y -
2498 dirty->fb_x = vclips_ptr->x;
2499 dirty->fb_y = vclips_ptr->y;
2500 dirty->unit_x2 = dirty->fb_x + vclips_ptr->w +
2502 dirty->unit_y2 = dirty->fb_y + vclips_ptr->h +
2506 dirty->unit_x1 = dirty->fb_x + dest_x - crtc_x;
2507 dirty->unit_y1 = dirty->fb_y + dest_y - crtc_y;
2509 /* Skip this clip if it's outside the crtc region */
2510 if (dirty->unit_x1 >= crtc_width ||
2511 dirty->unit_y1 >= crtc_height ||
2512 dirty->unit_x2 <= 0 || dirty->unit_y2 <= 0)
2515 /* Clip right and bottom to crtc limits */
2516 dirty->unit_x2 = min_t(s32, dirty->unit_x2,
2518 dirty->unit_y2 = min_t(s32, dirty->unit_y2,
2521 /* Clip left and top to crtc limits */
2522 clip_left = min_t(s32, dirty->unit_x1, 0);
2523 clip_top = min_t(s32, dirty->unit_y1, 0);
2524 dirty->unit_x1 -= clip_left;
2525 dirty->unit_y1 -= clip_top;
2526 dirty->fb_x -= clip_left;
2527 dirty->fb_y -= clip_top;
2532 dirty->fifo_commit(dirty);
2539 * vmw_kms_helper_validation_finish - Helper for post KMS command submission
2540 * cleanup and fencing
2541 * @dev_priv: Pointer to the device-private struct
2542 * @file_priv: Pointer identifying the client when user-space fencing is used
2543 * @ctx: Pointer to the validation context
2544 * @out_fence: If non-NULL, returned refcounted fence-pointer
2545 * @user_fence_rep: If non-NULL, pointer to user-space address area
2546 * in which to copy user-space fence info
2548 void vmw_kms_helper_validation_finish(struct vmw_private *dev_priv,
2549 struct drm_file *file_priv,
2550 struct vmw_validation_context *ctx,
2551 struct vmw_fence_obj **out_fence,
2552 struct drm_vmw_fence_rep __user *
2555 struct vmw_fence_obj *fence = NULL;
2556 uint32_t handle = 0;
2559 if (file_priv || user_fence_rep || vmw_validation_has_bos(ctx) ||
2561 ret = vmw_execbuf_fence_commands(file_priv, dev_priv, &fence,
2562 file_priv ? &handle : NULL);
2563 vmw_validation_done(ctx, fence);
2565 vmw_execbuf_copy_fence_user(dev_priv, vmw_fpriv(file_priv),
2566 ret, user_fence_rep, fence,
2571 vmw_fence_obj_unreference(&fence);
2575 * vmw_kms_update_proxy - Helper function to update a proxy surface from
2578 * @res: Pointer to the surface resource
2579 * @clips: Clip rects in framebuffer (surface) space.
2580 * @num_clips: Number of clips in @clips.
2581 * @increment: Integer with which to increment the clip counter when looping.
2582 * Used to skip a predetermined number of clip rects.
2584 * This function makes sure the proxy surface is updated from its backing MOB
2585 * using the region given by @clips. The surface resource @res and its backing
2586 * MOB needs to be reserved and validated on call.
2588 int vmw_kms_update_proxy(struct vmw_resource *res,
2589 const struct drm_clip_rect *clips,
2593 struct vmw_private *dev_priv = res->dev_priv;
2594 struct drm_vmw_size *size = &vmw_res_to_srf(res)->metadata.base_size;
2596 SVGA3dCmdHeader header;
2597 SVGA3dCmdUpdateGBImage body;
2600 size_t copy_size = 0;
2606 cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd) * num_clips);
2610 for (i = 0; i < num_clips; ++i, clips += increment, ++cmd) {
2611 box = &cmd->body.box;
2613 cmd->header.id = SVGA_3D_CMD_UPDATE_GB_IMAGE;
2614 cmd->header.size = sizeof(cmd->body);
2615 cmd->body.image.sid = res->id;
2616 cmd->body.image.face = 0;
2617 cmd->body.image.mipmap = 0;
2619 if (clips->x1 > size->width || clips->x2 > size->width ||
2620 clips->y1 > size->height || clips->y2 > size->height) {
2621 DRM_ERROR("Invalid clips outsize of framebuffer.\n");
2628 box->w = clips->x2 - clips->x1;
2629 box->h = clips->y2 - clips->y1;
2632 copy_size += sizeof(*cmd);
2635 vmw_cmd_commit(dev_priv, copy_size);
2641 * vmw_kms_create_implicit_placement_property - Set up the implicit placement
2644 * @dev_priv: Pointer to a device private struct.
2646 * Sets up the implicit placement property unless it's already set up.
2649 vmw_kms_create_implicit_placement_property(struct vmw_private *dev_priv)
2651 if (dev_priv->implicit_placement_property)
2654 dev_priv->implicit_placement_property =
2655 drm_property_create_range(&dev_priv->drm,
2656 DRM_MODE_PROP_IMMUTABLE,
2657 "implicit_placement", 0, 1);
2661 * vmw_kms_suspend - Save modesetting state and turn modesetting off.
2663 * @dev: Pointer to the drm device
2664 * Return: 0 on success. Negative error code on failure.
2666 int vmw_kms_suspend(struct drm_device *dev)
2668 struct vmw_private *dev_priv = vmw_priv(dev);
2670 dev_priv->suspend_state = drm_atomic_helper_suspend(dev);
2671 if (IS_ERR(dev_priv->suspend_state)) {
2672 int ret = PTR_ERR(dev_priv->suspend_state);
2674 DRM_ERROR("Failed kms suspend: %d\n", ret);
2675 dev_priv->suspend_state = NULL;
2685 * vmw_kms_resume - Re-enable modesetting and restore state
2687 * @dev: Pointer to the drm device
2688 * Return: 0 on success. Negative error code on failure.
2690 * State is resumed from a previous vmw_kms_suspend(). It's illegal
2691 * to call this function without a previous vmw_kms_suspend().
2693 int vmw_kms_resume(struct drm_device *dev)
2695 struct vmw_private *dev_priv = vmw_priv(dev);
2698 if (WARN_ON(!dev_priv->suspend_state))
2701 ret = drm_atomic_helper_resume(dev, dev_priv->suspend_state);
2702 dev_priv->suspend_state = NULL;
2708 * vmw_kms_lost_device - Notify kms that modesetting capabilities will be lost
2710 * @dev: Pointer to the drm device
2712 void vmw_kms_lost_device(struct drm_device *dev)
2714 drm_atomic_helper_shutdown(dev);
2718 * vmw_du_helper_plane_update - Helper to do plane update on a display unit.
2719 * @update: The closure structure.
2721 * Call this helper after setting callbacks in &vmw_du_update_plane to do plane
2722 * update on display unit.
2724 * Return: 0 on success or a negative error code on failure.
2726 int vmw_du_helper_plane_update(struct vmw_du_update_plane *update)
2728 struct drm_plane_state *state = update->plane->state;
2729 struct drm_plane_state *old_state = update->old_state;
2730 struct drm_atomic_helper_damage_iter iter;
2731 struct drm_rect clip;
2733 DECLARE_VAL_CONTEXT(val_ctx, NULL, 0);
2734 uint32_t reserved_size = 0;
2735 uint32_t submit_size = 0;
2736 uint32_t curr_size = 0;
2737 uint32_t num_hits = 0;
2743 * Iterate in advance to check if really need plane update and find the
2744 * number of clips that actually are in plane src for fifo allocation.
2746 drm_atomic_helper_damage_iter_init(&iter, old_state, state);
2747 drm_atomic_for_each_plane_damage(&iter, &clip)
2753 if (update->vfb->bo) {
2754 struct vmw_framebuffer_bo *vfbbo =
2755 container_of(update->vfb, typeof(*vfbbo), base);
2758 * For screen targets we want a mappable bo, for everything else we want
2759 * accelerated i.e. host backed (vram or gmr) bo. If the display unit
2760 * is not screen target then mob's shouldn't be available.
2762 if (update->dev_priv->active_display_unit == vmw_du_screen_target) {
2763 vmw_bo_placement_set(vfbbo->buffer,
2764 VMW_BO_DOMAIN_SYS | VMW_BO_DOMAIN_MOB | VMW_BO_DOMAIN_GMR,
2765 VMW_BO_DOMAIN_SYS | VMW_BO_DOMAIN_MOB | VMW_BO_DOMAIN_GMR);
2767 WARN_ON(update->dev_priv->has_mob);
2768 vmw_bo_placement_set_default_accelerated(vfbbo->buffer);
2770 ret = vmw_validation_add_bo(&val_ctx, vfbbo->buffer);
2772 struct vmw_framebuffer_surface *vfbs =
2773 container_of(update->vfb, typeof(*vfbs), base);
2775 ret = vmw_validation_add_resource(&val_ctx, &vfbs->surface->res,
2776 0, VMW_RES_DIRTY_NONE, NULL,
2783 ret = vmw_validation_prepare(&val_ctx, update->mutex, update->intr);
2787 reserved_size = update->calc_fifo_size(update, num_hits);
2788 cmd_start = VMW_CMD_RESERVE(update->dev_priv, reserved_size);
2794 cmd_next = cmd_start;
2796 if (update->post_prepare) {
2797 curr_size = update->post_prepare(update, cmd_next);
2798 cmd_next += curr_size;
2799 submit_size += curr_size;
2802 if (update->pre_clip) {
2803 curr_size = update->pre_clip(update, cmd_next, num_hits);
2804 cmd_next += curr_size;
2805 submit_size += curr_size;
2813 drm_atomic_helper_damage_iter_init(&iter, old_state, state);
2814 drm_atomic_for_each_plane_damage(&iter, &clip) {
2815 uint32_t fb_x = clip.x1;
2816 uint32_t fb_y = clip.y1;
2818 vmw_du_translate_to_crtc(state, &clip);
2820 curr_size = update->clip(update, cmd_next, &clip, fb_x,
2822 cmd_next += curr_size;
2823 submit_size += curr_size;
2825 bb.x1 = min_t(int, bb.x1, clip.x1);
2826 bb.y1 = min_t(int, bb.y1, clip.y1);
2827 bb.x2 = max_t(int, bb.x2, clip.x2);
2828 bb.y2 = max_t(int, bb.y2, clip.y2);
2831 curr_size = update->post_clip(update, cmd_next, &bb);
2832 submit_size += curr_size;
2834 if (reserved_size < submit_size)
2837 vmw_cmd_commit(update->dev_priv, submit_size);
2839 vmw_kms_helper_validation_finish(update->dev_priv, NULL, &val_ctx,
2840 update->out_fence, NULL);
2844 vmw_validation_revert(&val_ctx);
2847 vmw_validation_unref_lists(&val_ctx);
2852 * vmw_connector_mode_valid - implements drm_connector_helper_funcs.mode_valid callback
2854 * @connector: the drm connector, part of a DU container
2855 * @mode: drm mode to check
2857 * Returns MODE_OK on success, or a drm_mode_status error code.
2859 enum drm_mode_status vmw_connector_mode_valid(struct drm_connector *connector,
2860 struct drm_display_mode *mode)
2862 struct drm_device *dev = connector->dev;
2863 struct vmw_private *dev_priv = vmw_priv(dev);
2864 u32 max_width = dev_priv->texture_max_width;
2865 u32 max_height = dev_priv->texture_max_height;
2866 u32 assumed_cpp = 4;
2868 if (dev_priv->assume_16bpp)
2871 if (dev_priv->active_display_unit == vmw_du_screen_target) {
2872 max_width = min(dev_priv->stdu_max_width, max_width);
2873 max_height = min(dev_priv->stdu_max_height, max_height);
2876 if (max_width < mode->hdisplay)
2877 return MODE_BAD_HVALUE;
2879 if (max_height < mode->vdisplay)
2880 return MODE_BAD_VVALUE;
2882 if (!vmw_kms_validate_mode_vram(dev_priv,
2883 mode->hdisplay * assumed_cpp,
2891 * vmw_connector_get_modes - implements drm_connector_helper_funcs.get_modes callback
2893 * @connector: the drm connector, part of a DU container
2895 * Returns the number of added modes.
2897 int vmw_connector_get_modes(struct drm_connector *connector)
2899 struct vmw_display_unit *du = vmw_connector_to_du(connector);
2900 struct drm_device *dev = connector->dev;
2901 struct vmw_private *dev_priv = vmw_priv(dev);
2902 struct drm_display_mode *mode = NULL;
2903 struct drm_display_mode prefmode = { DRM_MODE("preferred",
2904 DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
2905 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2906 DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC)
2912 /* Add preferred mode */
2913 mode = drm_mode_duplicate(dev, &prefmode);
2917 mode->hdisplay = du->pref_width;
2918 mode->vdisplay = du->pref_height;
2919 vmw_guess_mode_timing(mode);
2920 drm_mode_set_name(mode);
2922 drm_mode_probed_add(connector, mode);
2923 drm_dbg_kms(dev, "preferred mode " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
2925 /* Probe connector for all modes not exceeding our geom limits */
2926 max_width = dev_priv->texture_max_width;
2927 max_height = dev_priv->texture_max_height;
2929 if (dev_priv->active_display_unit == vmw_du_screen_target) {
2930 max_width = min(dev_priv->stdu_max_width, max_width);
2931 max_height = min(dev_priv->stdu_max_height, max_height);
2934 num_modes = 1 + drm_add_modes_noedid(connector, max_width, max_height);