1 // SPDX-License-Identifier: GPL-2.0 OR MIT
2 /**************************************************************************
3  *
4  * Copyright 2009-2023 VMware, Inc., Palo Alto, CA., USA
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a
7  * copy of this software and associated documentation files (the
8  * "Software"), to deal in the Software without restriction, including
9  * without limitation the rights to use, copy, modify, merge, publish,
10  * distribute, sub license, and/or sell copies of the Software, and to
11  * permit persons to whom the Software is furnished to do so, subject to
12  * the following conditions:
13  *
14  * The above copyright notice and this permission notice (including the
15  * next paragraph) shall be included in all copies or substantial portions
16  * of the Software.
17  *
18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
25  *
26  **************************************************************************/
27 #include "vmwgfx_kms.h"
28 
29 #include "vmwgfx_bo.h"
30 #include "vmw_surface_cache.h"
31 
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 
39 void vmw_du_cleanup(struct vmw_display_unit *du)
40 {
41 	struct vmw_private *dev_priv = vmw_priv(du->primary.dev);
42 	drm_plane_cleanup(&du->primary);
43 	if (vmw_cmd_supported(dev_priv))
44 		drm_plane_cleanup(&du->cursor.base);
45 
46 	drm_connector_unregister(&du->connector);
47 	drm_crtc_cleanup(&du->crtc);
48 	drm_encoder_cleanup(&du->encoder);
49 	drm_connector_cleanup(&du->connector);
50 }
51 
52 /*
53  * Display Unit Cursor functions
54  */
55 
56 static int vmw_du_cursor_plane_unmap_cm(struct vmw_plane_state *vps);
57 static void vmw_cursor_update_mob(struct vmw_private *dev_priv,
58 				  struct vmw_plane_state *vps,
59 				  u32 *image, u32 width, u32 height,
60 				  u32 hotspotX, u32 hotspotY);
61 
62 struct vmw_svga_fifo_cmd_define_cursor {
63 	u32 cmd;
64 	SVGAFifoCmdDefineAlphaCursor cursor;
65 };
66 
67 /**
68  * vmw_send_define_cursor_cmd - queue a define cursor command
69  * @dev_priv: the private driver struct
70  * @image: buffer which holds the cursor image
71  * @width: width of the mouse cursor image
72  * @height: height of the mouse cursor image
73  * @hotspotX: the horizontal position of mouse hotspot
74  * @hotspotY: the vertical position of mouse hotspot
75  */
76 static void vmw_send_define_cursor_cmd(struct vmw_private *dev_priv,
77 				       u32 *image, u32 width, u32 height,
78 				       u32 hotspotX, u32 hotspotY)
79 {
80 	struct vmw_svga_fifo_cmd_define_cursor *cmd;
81 	const u32 image_size = width * height * sizeof(*image);
82 	const u32 cmd_size = sizeof(*cmd) + image_size;
83 
84 	/* Try to reserve fifocmd space and swallow any failures;
85 	   such reservations cannot be left unconsumed for long
86 	   under the risk of clogging other fifocmd users, so
87 	   we treat reservations separtely from the way we treat
88 	   other fallible KMS-atomic resources at prepare_fb */
89 	cmd = VMW_CMD_RESERVE(dev_priv, cmd_size);
90 
91 	if (unlikely(!cmd))
92 		return;
93 
94 	memset(cmd, 0, sizeof(*cmd));
95 
96 	memcpy(&cmd[1], image, image_size);
97 
98 	cmd->cmd = SVGA_CMD_DEFINE_ALPHA_CURSOR;
99 	cmd->cursor.id = 0;
100 	cmd->cursor.width = width;
101 	cmd->cursor.height = height;
102 	cmd->cursor.hotspotX = hotspotX;
103 	cmd->cursor.hotspotY = hotspotY;
104 
105 	vmw_cmd_commit_flush(dev_priv, cmd_size);
106 }
107 
108 /**
109  * vmw_cursor_update_image - update the cursor image on the provided plane
110  * @dev_priv: the private driver struct
111  * @vps: the plane state of the cursor plane
112  * @image: buffer which holds the cursor image
113  * @width: width of the mouse cursor image
114  * @height: height of the mouse cursor image
115  * @hotspotX: the horizontal position of mouse hotspot
116  * @hotspotY: the vertical position of mouse hotspot
117  */
118 static void vmw_cursor_update_image(struct vmw_private *dev_priv,
119 				    struct vmw_plane_state *vps,
120 				    u32 *image, u32 width, u32 height,
121 				    u32 hotspotX, u32 hotspotY)
122 {
123 	if (vps->cursor.bo)
124 		vmw_cursor_update_mob(dev_priv, vps, image,
125 				      vps->base.crtc_w, vps->base.crtc_h,
126 				      hotspotX, hotspotY);
127 
128 	else
129 		vmw_send_define_cursor_cmd(dev_priv, image, width, height,
130 					   hotspotX, hotspotY);
131 }
132 
133 
134 /**
135  * vmw_cursor_update_mob - Update cursor vis CursorMob mechanism
136  *
137  * Called from inside vmw_du_cursor_plane_atomic_update to actually
138  * make the cursor-image live.
139  *
140  * @dev_priv: device to work with
141  * @vps: the plane state of the cursor plane
142  * @image: cursor source data to fill the MOB with
143  * @width: source data width
144  * @height: source data height
145  * @hotspotX: cursor hotspot x
146  * @hotspotY: cursor hotspot Y
147  */
148 static void vmw_cursor_update_mob(struct vmw_private *dev_priv,
149 				  struct vmw_plane_state *vps,
150 				  u32 *image, u32 width, u32 height,
151 				  u32 hotspotX, u32 hotspotY)
152 {
153 	SVGAGBCursorHeader *header;
154 	SVGAGBAlphaCursorHeader *alpha_header;
155 	const u32 image_size = width * height * sizeof(*image);
156 
157 	header = vmw_bo_map_and_cache(vps->cursor.bo);
158 	alpha_header = &header->header.alphaHeader;
159 
160 	memset(header, 0, sizeof(*header));
161 
162 	header->type = SVGA_ALPHA_CURSOR;
163 	header->sizeInBytes = image_size;
164 
165 	alpha_header->hotspotX = hotspotX;
166 	alpha_header->hotspotY = hotspotY;
167 	alpha_header->width = width;
168 	alpha_header->height = height;
169 
170 	memcpy(header + 1, image, image_size);
171 	vmw_write(dev_priv, SVGA_REG_CURSOR_MOBID,
172 		  vps->cursor.bo->tbo.resource->start);
173 }
174 
175 
176 static u32 vmw_du_cursor_mob_size(u32 w, u32 h)
177 {
178 	return w * h * sizeof(u32) + sizeof(SVGAGBCursorHeader);
179 }
180 
181 /**
182  * vmw_du_cursor_plane_acquire_image -- Acquire the image data
183  * @vps: cursor plane state
184  */
185 static u32 *vmw_du_cursor_plane_acquire_image(struct vmw_plane_state *vps)
186 {
187 	bool is_iomem;
188 	if (vps->surf) {
189 		if (vps->surf_mapped)
190 			return vmw_bo_map_and_cache(vps->surf->res.guest_memory_bo);
191 		return vps->surf->snooper.image;
192 	} else if (vps->bo)
193 		return ttm_kmap_obj_virtual(&vps->bo->map, &is_iomem);
194 	return NULL;
195 }
196 
197 static bool vmw_du_cursor_plane_has_changed(struct vmw_plane_state *old_vps,
198 					    struct vmw_plane_state *new_vps)
199 {
200 	void *old_image;
201 	void *new_image;
202 	u32 size;
203 	bool changed;
204 
205 	if (old_vps->base.crtc_w != new_vps->base.crtc_w ||
206 	    old_vps->base.crtc_h != new_vps->base.crtc_h)
207 	    return true;
208 
209 	if (old_vps->cursor.hotspot_x != new_vps->cursor.hotspot_x ||
210 	    old_vps->cursor.hotspot_y != new_vps->cursor.hotspot_y)
211 	    return true;
212 
213 	size = new_vps->base.crtc_w * new_vps->base.crtc_h * sizeof(u32);
214 
215 	old_image = vmw_du_cursor_plane_acquire_image(old_vps);
216 	new_image = vmw_du_cursor_plane_acquire_image(new_vps);
217 
218 	changed = false;
219 	if (old_image && new_image)
220 		changed = memcmp(old_image, new_image, size) != 0;
221 
222 	return changed;
223 }
224 
225 static void vmw_du_destroy_cursor_mob(struct vmw_bo **vbo)
226 {
227 	if (!(*vbo))
228 		return;
229 
230 	ttm_bo_unpin(&(*vbo)->tbo);
231 	vmw_bo_unreference(vbo);
232 }
233 
234 static void vmw_du_put_cursor_mob(struct vmw_cursor_plane *vcp,
235 				  struct vmw_plane_state *vps)
236 {
237 	u32 i;
238 
239 	if (!vps->cursor.bo)
240 		return;
241 
242 	vmw_du_cursor_plane_unmap_cm(vps);
243 
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;
249 			return;
250 		}
251 	}
252 
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;
260 			return;
261 		}
262 	}
263 
264 	/* Destroy it if it's not worth caching. */
265 	vmw_du_destroy_cursor_mob(&vps->cursor.bo);
266 }
267 
268 static int vmw_du_get_cursor_mob(struct vmw_cursor_plane *vcp,
269 				 struct vmw_plane_state *vps)
270 {
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);
273 	u32 i;
274 	u32 cursor_max_dim, mob_max_size;
275 	int ret;
276 
277 	if (!dev_priv->has_mob ||
278 	    (dev_priv->capabilities2 & SVGA_CAP2_CURSOR_MOB) == 0)
279 		return -EINVAL;
280 
281 	mob_max_size = vmw_read(dev_priv, SVGA_REG_MOB_MAX_SIZE);
282 	cursor_max_dim = vmw_read(dev_priv, SVGA_REG_CURSOR_MAX_DIMENSION);
283 
284 	if (size > mob_max_size || vps->base.crtc_w > cursor_max_dim ||
285 	    vps->base.crtc_h > cursor_max_dim)
286 		return -EINVAL;
287 
288 	if (vps->cursor.bo) {
289 		if (vps->cursor.bo->tbo.base.size >= size)
290 			return 0;
291 		vmw_du_put_cursor_mob(vcp, vps);
292 	}
293 
294 	/* Look for an unused mob in the cache. */
295 	for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++) {
296 		if (vcp->cursor_mobs[i] &&
297 		    vcp->cursor_mobs[i]->tbo.base.size >= size) {
298 			vps->cursor.bo = vcp->cursor_mobs[i];
299 			vcp->cursor_mobs[i] = NULL;
300 			return 0;
301 		}
302 	}
303 	/* Create a new mob if we can't find an existing one. */
304 	ret = vmw_bo_create_and_populate(dev_priv, size,
305 					 VMW_BO_DOMAIN_MOB,
306 					 &vps->cursor.bo);
307 
308 	if (ret != 0)
309 		return ret;
310 
311 	/* Fence the mob creation so we are guarateed to have the mob */
312 	ret = ttm_bo_reserve(&vps->cursor.bo->tbo, false, false, NULL);
313 	if (ret != 0)
314 		goto teardown;
315 
316 	vmw_bo_fence_single(&vps->cursor.bo->tbo, NULL);
317 	ttm_bo_unreserve(&vps->cursor.bo->tbo);
318 	return 0;
319 
320 teardown:
321 	vmw_du_destroy_cursor_mob(&vps->cursor.bo);
322 	return ret;
323 }
324 
325 
326 static void vmw_cursor_update_position(struct vmw_private *dev_priv,
327 				       bool show, int x, int y)
328 {
329 	const uint32_t svga_cursor_on = show ? SVGA_CURSOR_ON_SHOW
330 					     : SVGA_CURSOR_ON_HIDE;
331 	uint32_t count;
332 
333 	spin_lock(&dev_priv->cursor_lock);
334 	if (dev_priv->capabilities2 & SVGA_CAP2_EXTRA_REGS) {
335 		vmw_write(dev_priv, SVGA_REG_CURSOR4_X, x);
336 		vmw_write(dev_priv, SVGA_REG_CURSOR4_Y, y);
337 		vmw_write(dev_priv, SVGA_REG_CURSOR4_SCREEN_ID, SVGA3D_INVALID_ID);
338 		vmw_write(dev_priv, SVGA_REG_CURSOR4_ON, svga_cursor_on);
339 		vmw_write(dev_priv, SVGA_REG_CURSOR4_SUBMIT, 1);
340 	} else if (vmw_is_cursor_bypass3_enabled(dev_priv)) {
341 		vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_ON, svga_cursor_on);
342 		vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_X, x);
343 		vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_Y, y);
344 		count = vmw_fifo_mem_read(dev_priv, SVGA_FIFO_CURSOR_COUNT);
345 		vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_COUNT, ++count);
346 	} else {
347 		vmw_write(dev_priv, SVGA_REG_CURSOR_X, x);
348 		vmw_write(dev_priv, SVGA_REG_CURSOR_Y, y);
349 		vmw_write(dev_priv, SVGA_REG_CURSOR_ON, svga_cursor_on);
350 	}
351 	spin_unlock(&dev_priv->cursor_lock);
352 }
353 
354 void vmw_kms_cursor_snoop(struct vmw_surface *srf,
355 			  struct ttm_object_file *tfile,
356 			  struct ttm_buffer_object *bo,
357 			  SVGA3dCmdHeader *header)
358 {
359 	struct ttm_bo_kmap_obj map;
360 	unsigned long kmap_offset;
361 	unsigned long kmap_num;
362 	SVGA3dCopyBox *box;
363 	unsigned box_count;
364 	void *virtual;
365 	bool is_iomem;
366 	struct vmw_dma_cmd {
367 		SVGA3dCmdHeader header;
368 		SVGA3dCmdSurfaceDMA dma;
369 	} *cmd;
370 	int i, ret;
371 	const struct SVGA3dSurfaceDesc *desc =
372 		vmw_surface_get_desc(VMW_CURSOR_SNOOP_FORMAT);
373 	const u32 image_pitch = VMW_CURSOR_SNOOP_WIDTH * desc->pitchBytesPerBlock;
374 
375 	cmd = container_of(header, struct vmw_dma_cmd, header);
376 
377 	/* No snooper installed, nothing to copy */
378 	if (!srf->snooper.image)
379 		return;
380 
381 	if (cmd->dma.host.face != 0 || cmd->dma.host.mipmap != 0) {
382 		DRM_ERROR("face and mipmap for cursors should never != 0\n");
383 		return;
384 	}
385 
386 	if (cmd->header.size < 64) {
387 		DRM_ERROR("at least one full copy box must be given\n");
388 		return;
389 	}
390 
391 	box = (SVGA3dCopyBox *)&cmd[1];
392 	box_count = (cmd->header.size - sizeof(SVGA3dCmdSurfaceDMA)) /
393 			sizeof(SVGA3dCopyBox);
394 
395 	if (cmd->dma.guest.ptr.offset % PAGE_SIZE ||
396 	    box->x != 0    || box->y != 0    || box->z != 0    ||
397 	    box->srcx != 0 || box->srcy != 0 || box->srcz != 0 ||
398 	    box->d != 1    || box_count != 1 ||
399 	    box->w > VMW_CURSOR_SNOOP_WIDTH || box->h > VMW_CURSOR_SNOOP_HEIGHT) {
400 		/* TODO handle none page aligned offsets */
401 		/* TODO handle more dst & src != 0 */
402 		/* TODO handle more then one copy */
403 		DRM_ERROR("Can't snoop dma request for cursor!\n");
404 		DRM_ERROR("(%u, %u, %u) (%u, %u, %u) (%ux%ux%u) %u %u\n",
405 			  box->srcx, box->srcy, box->srcz,
406 			  box->x, box->y, box->z,
407 			  box->w, box->h, box->d, box_count,
408 			  cmd->dma.guest.ptr.offset);
409 		return;
410 	}
411 
412 	kmap_offset = cmd->dma.guest.ptr.offset >> PAGE_SHIFT;
413 	kmap_num = (VMW_CURSOR_SNOOP_HEIGHT*image_pitch) >> PAGE_SHIFT;
414 
415 	ret = ttm_bo_reserve(bo, true, false, NULL);
416 	if (unlikely(ret != 0)) {
417 		DRM_ERROR("reserve failed\n");
418 		return;
419 	}
420 
421 	ret = ttm_bo_kmap(bo, kmap_offset, kmap_num, &map);
422 	if (unlikely(ret != 0))
423 		goto err_unreserve;
424 
425 	virtual = ttm_kmap_obj_virtual(&map, &is_iomem);
426 
427 	if (box->w == VMW_CURSOR_SNOOP_WIDTH && cmd->dma.guest.pitch == image_pitch) {
428 		memcpy(srf->snooper.image, virtual,
429 		       VMW_CURSOR_SNOOP_HEIGHT*image_pitch);
430 	} else {
431 		/* Image is unsigned pointer. */
432 		for (i = 0; i < box->h; i++)
433 			memcpy(srf->snooper.image + i * image_pitch,
434 			       virtual + i * cmd->dma.guest.pitch,
435 			       box->w * desc->pitchBytesPerBlock);
436 	}
437 
438 	srf->snooper.age++;
439 
440 	ttm_bo_kunmap(&map);
441 err_unreserve:
442 	ttm_bo_unreserve(bo);
443 }
444 
445 /**
446  * vmw_kms_legacy_hotspot_clear - Clear legacy hotspots
447  *
448  * @dev_priv: Pointer to the device private struct.
449  *
450  * Clears all legacy hotspots.
451  */
452 void vmw_kms_legacy_hotspot_clear(struct vmw_private *dev_priv)
453 {
454 	struct drm_device *dev = &dev_priv->drm;
455 	struct vmw_display_unit *du;
456 	struct drm_crtc *crtc;
457 
458 	drm_modeset_lock_all(dev);
459 	drm_for_each_crtc(crtc, dev) {
460 		du = vmw_crtc_to_du(crtc);
461 
462 		du->hotspot_x = 0;
463 		du->hotspot_y = 0;
464 	}
465 	drm_modeset_unlock_all(dev);
466 }
467 
468 void vmw_kms_cursor_post_execbuf(struct vmw_private *dev_priv)
469 {
470 	struct drm_device *dev = &dev_priv->drm;
471 	struct vmw_display_unit *du;
472 	struct drm_crtc *crtc;
473 
474 	mutex_lock(&dev->mode_config.mutex);
475 
476 	list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
477 		du = vmw_crtc_to_du(crtc);
478 		if (!du->cursor_surface ||
479 		    du->cursor_age == du->cursor_surface->snooper.age ||
480 		    !du->cursor_surface->snooper.image)
481 			continue;
482 
483 		du->cursor_age = du->cursor_surface->snooper.age;
484 		vmw_send_define_cursor_cmd(dev_priv,
485 					   du->cursor_surface->snooper.image,
486 					   VMW_CURSOR_SNOOP_WIDTH,
487 					   VMW_CURSOR_SNOOP_HEIGHT,
488 					   du->hotspot_x + du->core_hotspot_x,
489 					   du->hotspot_y + du->core_hotspot_y);
490 	}
491 
492 	mutex_unlock(&dev->mode_config.mutex);
493 }
494 
495 
496 void vmw_du_cursor_plane_destroy(struct drm_plane *plane)
497 {
498 	struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
499 	u32 i;
500 
501 	vmw_cursor_update_position(plane->dev->dev_private, false, 0, 0);
502 
503 	for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++)
504 		vmw_du_destroy_cursor_mob(&vcp->cursor_mobs[i]);
505 
506 	drm_plane_cleanup(plane);
507 }
508 
509 
510 void vmw_du_primary_plane_destroy(struct drm_plane *plane)
511 {
512 	drm_plane_cleanup(plane);
513 
514 	/* Planes are static in our case so we don't free it */
515 }
516 
517 
518 /**
519  * vmw_du_plane_unpin_surf - unpins resource associated with a framebuffer surface
520  *
521  * @vps: plane state associated with the display surface
522  * @unreference: true if we also want to unreference the display.
523  */
524 void vmw_du_plane_unpin_surf(struct vmw_plane_state *vps,
525 			     bool unreference)
526 {
527 	if (vps->surf) {
528 		if (vps->pinned) {
529 			vmw_resource_unpin(&vps->surf->res);
530 			vps->pinned--;
531 		}
532 
533 		if (unreference) {
534 			if (vps->pinned)
535 				DRM_ERROR("Surface still pinned\n");
536 			vmw_surface_unreference(&vps->surf);
537 		}
538 	}
539 }
540 
541 
542 /**
543  * vmw_du_plane_cleanup_fb - Unpins the plane surface
544  *
545  * @plane:  display plane
546  * @old_state: Contains the FB to clean up
547  *
548  * Unpins the framebuffer surface
549  *
550  * Returns 0 on success
551  */
552 void
553 vmw_du_plane_cleanup_fb(struct drm_plane *plane,
554 			struct drm_plane_state *old_state)
555 {
556 	struct vmw_plane_state *vps = vmw_plane_state_to_vps(old_state);
557 
558 	vmw_du_plane_unpin_surf(vps, false);
559 }
560 
561 
562 /**
563  * vmw_du_cursor_plane_map_cm - Maps the cursor mobs.
564  *
565  * @vps: plane_state
566  *
567  * Returns 0 on success
568  */
569 
570 static int
571 vmw_du_cursor_plane_map_cm(struct vmw_plane_state *vps)
572 {
573 	int ret;
574 	u32 size = vmw_du_cursor_mob_size(vps->base.crtc_w, vps->base.crtc_h);
575 	struct ttm_buffer_object *bo;
576 
577 	if (!vps->cursor.bo)
578 		return -EINVAL;
579 
580 	bo = &vps->cursor.bo->tbo;
581 
582 	if (bo->base.size < size)
583 		return -EINVAL;
584 
585 	if (vps->cursor.bo->map.virtual)
586 		return 0;
587 
588 	ret = ttm_bo_reserve(bo, false, false, NULL);
589 	if (unlikely(ret != 0))
590 		return -ENOMEM;
591 
592 	vmw_bo_map_and_cache(vps->cursor.bo);
593 
594 	ttm_bo_unreserve(bo);
595 
596 	if (unlikely(ret != 0))
597 		return -ENOMEM;
598 
599 	return 0;
600 }
601 
602 
603 /**
604  * vmw_du_cursor_plane_unmap_cm - Unmaps the cursor mobs.
605  *
606  * @vps: state of the cursor plane
607  *
608  * Returns 0 on success
609  */
610 
611 static int
612 vmw_du_cursor_plane_unmap_cm(struct vmw_plane_state *vps)
613 {
614 	int ret = 0;
615 	struct vmw_bo *vbo = vps->cursor.bo;
616 
617 	if (!vbo || !vbo->map.virtual)
618 		return 0;
619 
620 	ret = ttm_bo_reserve(&vbo->tbo, true, false, NULL);
621 	if (likely(ret == 0)) {
622 		vmw_bo_unmap(vbo);
623 		ttm_bo_unreserve(&vbo->tbo);
624 	}
625 
626 	return ret;
627 }
628 
629 
630 /**
631  * vmw_du_cursor_plane_cleanup_fb - Unpins the plane surface
632  *
633  * @plane: cursor plane
634  * @old_state: contains the state to clean up
635  *
636  * Unmaps all cursor bo mappings and unpins the cursor surface
637  *
638  * Returns 0 on success
639  */
640 void
641 vmw_du_cursor_plane_cleanup_fb(struct drm_plane *plane,
642 			       struct drm_plane_state *old_state)
643 {
644 	struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
645 	struct vmw_plane_state *vps = vmw_plane_state_to_vps(old_state);
646 	bool is_iomem;
647 
648 	if (vps->surf_mapped) {
649 		vmw_bo_unmap(vps->surf->res.guest_memory_bo);
650 		vps->surf_mapped = false;
651 	}
652 
653 	if (vps->bo && ttm_kmap_obj_virtual(&vps->bo->map, &is_iomem)) {
654 		const int ret = ttm_bo_reserve(&vps->bo->tbo, true, false, NULL);
655 
656 		if (likely(ret == 0)) {
657 			ttm_bo_kunmap(&vps->bo->map);
658 			ttm_bo_unreserve(&vps->bo->tbo);
659 		}
660 	}
661 
662 	vmw_du_cursor_plane_unmap_cm(vps);
663 	vmw_du_put_cursor_mob(vcp, vps);
664 
665 	vmw_du_plane_unpin_surf(vps, false);
666 
667 	if (vps->surf) {
668 		vmw_surface_unreference(&vps->surf);
669 		vps->surf = NULL;
670 	}
671 
672 	if (vps->bo) {
673 		vmw_bo_unreference(&vps->bo);
674 		vps->bo = NULL;
675 	}
676 }
677 
678 
679 /**
680  * vmw_du_cursor_plane_prepare_fb - Readies the cursor by referencing it
681  *
682  * @plane:  display plane
683  * @new_state: info on the new plane state, including the FB
684  *
685  * Returns 0 on success
686  */
687 int
688 vmw_du_cursor_plane_prepare_fb(struct drm_plane *plane,
689 			       struct drm_plane_state *new_state)
690 {
691 	struct drm_framebuffer *fb = new_state->fb;
692 	struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
693 	struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state);
694 	int ret = 0;
695 
696 	if (vps->surf) {
697 		vmw_surface_unreference(&vps->surf);
698 		vps->surf = NULL;
699 	}
700 
701 	if (vps->bo) {
702 		vmw_bo_unreference(&vps->bo);
703 		vps->bo = NULL;
704 	}
705 
706 	if (fb) {
707 		if (vmw_framebuffer_to_vfb(fb)->bo) {
708 			vps->bo = vmw_framebuffer_to_vfbd(fb)->buffer;
709 			vmw_bo_reference(vps->bo);
710 		} else {
711 			vps->surf = vmw_framebuffer_to_vfbs(fb)->surface;
712 			vmw_surface_reference(vps->surf);
713 		}
714 	}
715 
716 	if (!vps->surf && vps->bo) {
717 		const u32 size = new_state->crtc_w * new_state->crtc_h * sizeof(u32);
718 
719 		/*
720 		 * Not using vmw_bo_map_and_cache() helper here as we need to
721 		 * reserve the ttm_buffer_object first which
722 		 * vmw_bo_map_and_cache() omits.
723 		 */
724 		ret = ttm_bo_reserve(&vps->bo->tbo, true, false, NULL);
725 
726 		if (unlikely(ret != 0))
727 			return -ENOMEM;
728 
729 		ret = ttm_bo_kmap(&vps->bo->tbo, 0, PFN_UP(size), &vps->bo->map);
730 
731 		ttm_bo_unreserve(&vps->bo->tbo);
732 
733 		if (unlikely(ret != 0))
734 			return -ENOMEM;
735 	} else if (vps->surf && !vps->bo && vps->surf->res.guest_memory_bo) {
736 
737 		WARN_ON(vps->surf->snooper.image);
738 		ret = ttm_bo_reserve(&vps->surf->res.guest_memory_bo->tbo, true, false,
739 				     NULL);
740 		if (unlikely(ret != 0))
741 			return -ENOMEM;
742 		vmw_bo_map_and_cache(vps->surf->res.guest_memory_bo);
743 		ttm_bo_unreserve(&vps->surf->res.guest_memory_bo->tbo);
744 		vps->surf_mapped = true;
745 	}
746 
747 	if (vps->surf || vps->bo) {
748 		vmw_du_get_cursor_mob(vcp, vps);
749 		vmw_du_cursor_plane_map_cm(vps);
750 	}
751 
752 	return 0;
753 }
754 
755 
756 void
757 vmw_du_cursor_plane_atomic_update(struct drm_plane *plane,
758 				  struct drm_atomic_state *state)
759 {
760 	struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
761 									   plane);
762 	struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
763 									   plane);
764 	struct drm_crtc *crtc = new_state->crtc ?: old_state->crtc;
765 	struct vmw_private *dev_priv = vmw_priv(crtc->dev);
766 	struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
767 	struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state);
768 	struct vmw_plane_state *old_vps = vmw_plane_state_to_vps(old_state);
769 	s32 hotspot_x, hotspot_y;
770 
771 	hotspot_x = du->hotspot_x;
772 	hotspot_y = du->hotspot_y;
773 
774 	if (new_state->fb) {
775 		hotspot_x += new_state->fb->hot_x;
776 		hotspot_y += new_state->fb->hot_y;
777 	}
778 
779 	du->cursor_surface = vps->surf;
780 	du->cursor_bo = vps->bo;
781 
782 	if (!vps->surf && !vps->bo) {
783 		vmw_cursor_update_position(dev_priv, false, 0, 0);
784 		return;
785 	}
786 
787 	vps->cursor.hotspot_x = hotspot_x;
788 	vps->cursor.hotspot_y = hotspot_y;
789 
790 	if (vps->surf) {
791 		du->cursor_age = du->cursor_surface->snooper.age;
792 	}
793 
794 	if (!vmw_du_cursor_plane_has_changed(old_vps, vps)) {
795 		/*
796 		 * If it hasn't changed, avoid making the device do extra
797 		 * work by keeping the old cursor active.
798 		 */
799 		struct vmw_cursor_plane_state tmp = old_vps->cursor;
800 		old_vps->cursor = vps->cursor;
801 		vps->cursor = tmp;
802 	} else {
803 		void *image = vmw_du_cursor_plane_acquire_image(vps);
804 		if (image)
805 			vmw_cursor_update_image(dev_priv, vps, image,
806 						new_state->crtc_w,
807 						new_state->crtc_h,
808 						hotspot_x, hotspot_y);
809 	}
810 
811 	du->cursor_x = new_state->crtc_x + du->set_gui_x;
812 	du->cursor_y = new_state->crtc_y + du->set_gui_y;
813 
814 	vmw_cursor_update_position(dev_priv, true,
815 				   du->cursor_x + hotspot_x,
816 				   du->cursor_y + hotspot_y);
817 
818 	du->core_hotspot_x = hotspot_x - du->hotspot_x;
819 	du->core_hotspot_y = hotspot_y - du->hotspot_y;
820 }
821 
822 
823 /**
824  * vmw_du_primary_plane_atomic_check - check if the new state is okay
825  *
826  * @plane: display plane
827  * @state: info on the new plane state, including the FB
828  *
829  * Check if the new state is settable given the current state.  Other
830  * than what the atomic helper checks, we care about crtc fitting
831  * the FB and maintaining one active framebuffer.
832  *
833  * Returns 0 on success
834  */
835 int vmw_du_primary_plane_atomic_check(struct drm_plane *plane,
836 				      struct drm_atomic_state *state)
837 {
838 	struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
839 									   plane);
840 	struct drm_crtc_state *crtc_state = NULL;
841 	struct drm_framebuffer *new_fb = new_state->fb;
842 	int ret;
843 
844 	if (new_state->crtc)
845 		crtc_state = drm_atomic_get_new_crtc_state(state,
846 							   new_state->crtc);
847 
848 	ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
849 						  DRM_PLANE_NO_SCALING,
850 						  DRM_PLANE_NO_SCALING,
851 						  false, true);
852 
853 	if (!ret && new_fb) {
854 		struct drm_crtc *crtc = new_state->crtc;
855 		struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
856 
857 		vmw_connector_state_to_vcs(du->connector.state);
858 	}
859 
860 
861 	return ret;
862 }
863 
864 
865 /**
866  * vmw_du_cursor_plane_atomic_check - check if the new state is okay
867  *
868  * @plane: cursor plane
869  * @state: info on the new plane state
870  *
871  * This is a chance to fail if the new cursor state does not fit
872  * our requirements.
873  *
874  * Returns 0 on success
875  */
876 int vmw_du_cursor_plane_atomic_check(struct drm_plane *plane,
877 				     struct drm_atomic_state *state)
878 {
879 	struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
880 									   plane);
881 	int ret = 0;
882 	struct drm_crtc_state *crtc_state = NULL;
883 	struct vmw_surface *surface = NULL;
884 	struct drm_framebuffer *fb = new_state->fb;
885 
886 	if (new_state->crtc)
887 		crtc_state = drm_atomic_get_new_crtc_state(new_state->state,
888 							   new_state->crtc);
889 
890 	ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
891 						  DRM_PLANE_NO_SCALING,
892 						  DRM_PLANE_NO_SCALING,
893 						  true, true);
894 	if (ret)
895 		return ret;
896 
897 	/* Turning off */
898 	if (!fb)
899 		return 0;
900 
901 	/* A lot of the code assumes this */
902 	if (new_state->crtc_w != 64 || new_state->crtc_h != 64) {
903 		DRM_ERROR("Invalid cursor dimensions (%d, %d)\n",
904 			  new_state->crtc_w, new_state->crtc_h);
905 		return -EINVAL;
906 	}
907 
908 	if (!vmw_framebuffer_to_vfb(fb)->bo) {
909 		surface = vmw_framebuffer_to_vfbs(fb)->surface;
910 
911 		WARN_ON(!surface);
912 
913 		if (!surface ||
914 		    (!surface->snooper.image && !surface->res.guest_memory_bo)) {
915 			DRM_ERROR("surface not suitable for cursor\n");
916 			return -EINVAL;
917 		}
918 	}
919 
920 	return 0;
921 }
922 
923 
924 int vmw_du_crtc_atomic_check(struct drm_crtc *crtc,
925 			     struct drm_atomic_state *state)
926 {
927 	struct drm_crtc_state *new_state = drm_atomic_get_new_crtc_state(state,
928 									 crtc);
929 	struct vmw_display_unit *du = vmw_crtc_to_du(new_state->crtc);
930 	int connector_mask = drm_connector_mask(&du->connector);
931 	bool has_primary = new_state->plane_mask &
932 			   drm_plane_mask(crtc->primary);
933 
934 	/* We always want to have an active plane with an active CRTC */
935 	if (has_primary != new_state->enable)
936 		return -EINVAL;
937 
938 
939 	if (new_state->connector_mask != connector_mask &&
940 	    new_state->connector_mask != 0) {
941 		DRM_ERROR("Invalid connectors configuration\n");
942 		return -EINVAL;
943 	}
944 
945 	/*
946 	 * Our virtual device does not have a dot clock, so use the logical
947 	 * clock value as the dot clock.
948 	 */
949 	if (new_state->mode.crtc_clock == 0)
950 		new_state->adjusted_mode.crtc_clock = new_state->mode.clock;
951 
952 	return 0;
953 }
954 
955 
956 void vmw_du_crtc_atomic_begin(struct drm_crtc *crtc,
957 			      struct drm_atomic_state *state)
958 {
959 }
960 
961 
962 void vmw_du_crtc_atomic_flush(struct drm_crtc *crtc,
963 			      struct drm_atomic_state *state)
964 {
965 }
966 
967 
968 /**
969  * vmw_du_crtc_duplicate_state - duplicate crtc state
970  * @crtc: DRM crtc
971  *
972  * Allocates and returns a copy of the crtc state (both common and
973  * vmw-specific) for the specified crtc.
974  *
975  * Returns: The newly allocated crtc state, or NULL on failure.
976  */
977 struct drm_crtc_state *
978 vmw_du_crtc_duplicate_state(struct drm_crtc *crtc)
979 {
980 	struct drm_crtc_state *state;
981 	struct vmw_crtc_state *vcs;
982 
983 	if (WARN_ON(!crtc->state))
984 		return NULL;
985 
986 	vcs = kmemdup(crtc->state, sizeof(*vcs), GFP_KERNEL);
987 
988 	if (!vcs)
989 		return NULL;
990 
991 	state = &vcs->base;
992 
993 	__drm_atomic_helper_crtc_duplicate_state(crtc, state);
994 
995 	return state;
996 }
997 
998 
999 /**
1000  * vmw_du_crtc_reset - creates a blank vmw crtc state
1001  * @crtc: DRM crtc
1002  *
1003  * Resets the atomic state for @crtc by freeing the state pointer (which
1004  * might be NULL, e.g. at driver load time) and allocating a new empty state
1005  * object.
1006  */
1007 void vmw_du_crtc_reset(struct drm_crtc *crtc)
1008 {
1009 	struct vmw_crtc_state *vcs;
1010 
1011 
1012 	if (crtc->state) {
1013 		__drm_atomic_helper_crtc_destroy_state(crtc->state);
1014 
1015 		kfree(vmw_crtc_state_to_vcs(crtc->state));
1016 	}
1017 
1018 	vcs = kzalloc(sizeof(*vcs), GFP_KERNEL);
1019 
1020 	if (!vcs) {
1021 		DRM_ERROR("Cannot allocate vmw_crtc_state\n");
1022 		return;
1023 	}
1024 
1025 	__drm_atomic_helper_crtc_reset(crtc, &vcs->base);
1026 }
1027 
1028 
1029 /**
1030  * vmw_du_crtc_destroy_state - destroy crtc state
1031  * @crtc: DRM crtc
1032  * @state: state object to destroy
1033  *
1034  * Destroys the crtc state (both common and vmw-specific) for the
1035  * specified plane.
1036  */
1037 void
1038 vmw_du_crtc_destroy_state(struct drm_crtc *crtc,
1039 			  struct drm_crtc_state *state)
1040 {
1041 	drm_atomic_helper_crtc_destroy_state(crtc, state);
1042 }
1043 
1044 
1045 /**
1046  * vmw_du_plane_duplicate_state - duplicate plane state
1047  * @plane: drm plane
1048  *
1049  * Allocates and returns a copy of the plane state (both common and
1050  * vmw-specific) for the specified plane.
1051  *
1052  * Returns: The newly allocated plane state, or NULL on failure.
1053  */
1054 struct drm_plane_state *
1055 vmw_du_plane_duplicate_state(struct drm_plane *plane)
1056 {
1057 	struct drm_plane_state *state;
1058 	struct vmw_plane_state *vps;
1059 
1060 	vps = kmemdup(plane->state, sizeof(*vps), GFP_KERNEL);
1061 
1062 	if (!vps)
1063 		return NULL;
1064 
1065 	vps->pinned = 0;
1066 	vps->cpp = 0;
1067 
1068 	memset(&vps->cursor, 0, sizeof(vps->cursor));
1069 
1070 	/* Each ref counted resource needs to be acquired again */
1071 	if (vps->surf)
1072 		(void) vmw_surface_reference(vps->surf);
1073 
1074 	if (vps->bo)
1075 		(void) vmw_bo_reference(vps->bo);
1076 
1077 	state = &vps->base;
1078 
1079 	__drm_atomic_helper_plane_duplicate_state(plane, state);
1080 
1081 	return state;
1082 }
1083 
1084 
1085 /**
1086  * vmw_du_plane_reset - creates a blank vmw plane state
1087  * @plane: drm plane
1088  *
1089  * Resets the atomic state for @plane by freeing the state pointer (which might
1090  * be NULL, e.g. at driver load time) and allocating a new empty state object.
1091  */
1092 void vmw_du_plane_reset(struct drm_plane *plane)
1093 {
1094 	struct vmw_plane_state *vps;
1095 
1096 	if (plane->state)
1097 		vmw_du_plane_destroy_state(plane, plane->state);
1098 
1099 	vps = kzalloc(sizeof(*vps), GFP_KERNEL);
1100 
1101 	if (!vps) {
1102 		DRM_ERROR("Cannot allocate vmw_plane_state\n");
1103 		return;
1104 	}
1105 
1106 	__drm_atomic_helper_plane_reset(plane, &vps->base);
1107 }
1108 
1109 
1110 /**
1111  * vmw_du_plane_destroy_state - destroy plane state
1112  * @plane: DRM plane
1113  * @state: state object to destroy
1114  *
1115  * Destroys the plane state (both common and vmw-specific) for the
1116  * specified plane.
1117  */
1118 void
1119 vmw_du_plane_destroy_state(struct drm_plane *plane,
1120 			   struct drm_plane_state *state)
1121 {
1122 	struct vmw_plane_state *vps = vmw_plane_state_to_vps(state);
1123 
1124 	/* Should have been freed by cleanup_fb */
1125 	if (vps->surf)
1126 		vmw_surface_unreference(&vps->surf);
1127 
1128 	if (vps->bo)
1129 		vmw_bo_unreference(&vps->bo);
1130 
1131 	drm_atomic_helper_plane_destroy_state(plane, state);
1132 }
1133 
1134 
1135 /**
1136  * vmw_du_connector_duplicate_state - duplicate connector state
1137  * @connector: DRM connector
1138  *
1139  * Allocates and returns a copy of the connector state (both common and
1140  * vmw-specific) for the specified connector.
1141  *
1142  * Returns: The newly allocated connector state, or NULL on failure.
1143  */
1144 struct drm_connector_state *
1145 vmw_du_connector_duplicate_state(struct drm_connector *connector)
1146 {
1147 	struct drm_connector_state *state;
1148 	struct vmw_connector_state *vcs;
1149 
1150 	if (WARN_ON(!connector->state))
1151 		return NULL;
1152 
1153 	vcs = kmemdup(connector->state, sizeof(*vcs), GFP_KERNEL);
1154 
1155 	if (!vcs)
1156 		return NULL;
1157 
1158 	state = &vcs->base;
1159 
1160 	__drm_atomic_helper_connector_duplicate_state(connector, state);
1161 
1162 	return state;
1163 }
1164 
1165 
1166 /**
1167  * vmw_du_connector_reset - creates a blank vmw connector state
1168  * @connector: DRM connector
1169  *
1170  * Resets the atomic state for @connector by freeing the state pointer (which
1171  * might be NULL, e.g. at driver load time) and allocating a new empty state
1172  * object.
1173  */
1174 void vmw_du_connector_reset(struct drm_connector *connector)
1175 {
1176 	struct vmw_connector_state *vcs;
1177 
1178 
1179 	if (connector->state) {
1180 		__drm_atomic_helper_connector_destroy_state(connector->state);
1181 
1182 		kfree(vmw_connector_state_to_vcs(connector->state));
1183 	}
1184 
1185 	vcs = kzalloc(sizeof(*vcs), GFP_KERNEL);
1186 
1187 	if (!vcs) {
1188 		DRM_ERROR("Cannot allocate vmw_connector_state\n");
1189 		return;
1190 	}
1191 
1192 	__drm_atomic_helper_connector_reset(connector, &vcs->base);
1193 }
1194 
1195 
1196 /**
1197  * vmw_du_connector_destroy_state - destroy connector state
1198  * @connector: DRM connector
1199  * @state: state object to destroy
1200  *
1201  * Destroys the connector state (both common and vmw-specific) for the
1202  * specified plane.
1203  */
1204 void
1205 vmw_du_connector_destroy_state(struct drm_connector *connector,
1206 			  struct drm_connector_state *state)
1207 {
1208 	drm_atomic_helper_connector_destroy_state(connector, state);
1209 }
1210 /*
1211  * Generic framebuffer code
1212  */
1213 
1214 /*
1215  * Surface framebuffer code
1216  */
1217 
1218 static void vmw_framebuffer_surface_destroy(struct drm_framebuffer *framebuffer)
1219 {
1220 	struct vmw_framebuffer_surface *vfbs =
1221 		vmw_framebuffer_to_vfbs(framebuffer);
1222 
1223 	drm_framebuffer_cleanup(framebuffer);
1224 	vmw_surface_unreference(&vfbs->surface);
1225 
1226 	kfree(vfbs);
1227 }
1228 
1229 /**
1230  * vmw_kms_readback - Perform a readback from the screen system to
1231  * a buffer-object backed framebuffer.
1232  *
1233  * @dev_priv: Pointer to the device private structure.
1234  * @file_priv: Pointer to a struct drm_file identifying the caller.
1235  * Must be set to NULL if @user_fence_rep is NULL.
1236  * @vfb: Pointer to the buffer-object backed framebuffer.
1237  * @user_fence_rep: User-space provided structure for fence information.
1238  * Must be set to non-NULL if @file_priv is non-NULL.
1239  * @vclips: Array of clip rects.
1240  * @num_clips: Number of clip rects in @vclips.
1241  *
1242  * Returns 0 on success, negative error code on failure. -ERESTARTSYS if
1243  * interrupted.
1244  */
1245 int vmw_kms_readback(struct vmw_private *dev_priv,
1246 		     struct drm_file *file_priv,
1247 		     struct vmw_framebuffer *vfb,
1248 		     struct drm_vmw_fence_rep __user *user_fence_rep,
1249 		     struct drm_vmw_rect *vclips,
1250 		     uint32_t num_clips)
1251 {
1252 	switch (dev_priv->active_display_unit) {
1253 	case vmw_du_screen_object:
1254 		return vmw_kms_sou_readback(dev_priv, file_priv, vfb,
1255 					    user_fence_rep, vclips, num_clips,
1256 					    NULL);
1257 	case vmw_du_screen_target:
1258 		return vmw_kms_stdu_readback(dev_priv, file_priv, vfb,
1259 					     user_fence_rep, NULL, vclips, num_clips,
1260 					     1, NULL);
1261 	default:
1262 		WARN_ONCE(true,
1263 			  "Readback called with invalid display system.\n");
1264 }
1265 
1266 	return -ENOSYS;
1267 }
1268 
1269 
1270 static const struct drm_framebuffer_funcs vmw_framebuffer_surface_funcs = {
1271 	.destroy = vmw_framebuffer_surface_destroy,
1272 	.dirty = drm_atomic_helper_dirtyfb,
1273 };
1274 
1275 static int vmw_kms_new_framebuffer_surface(struct vmw_private *dev_priv,
1276 					   struct vmw_surface *surface,
1277 					   struct vmw_framebuffer **out,
1278 					   const struct drm_mode_fb_cmd2
1279 					   *mode_cmd,
1280 					   bool is_bo_proxy)
1281 
1282 {
1283 	struct drm_device *dev = &dev_priv->drm;
1284 	struct vmw_framebuffer_surface *vfbs;
1285 	enum SVGA3dSurfaceFormat format;
1286 	int ret;
1287 
1288 	/* 3D is only supported on HWv8 and newer hosts */
1289 	if (dev_priv->active_display_unit == vmw_du_legacy)
1290 		return -ENOSYS;
1291 
1292 	/*
1293 	 * Sanity checks.
1294 	 */
1295 
1296 	if (!drm_any_plane_has_format(&dev_priv->drm,
1297 				      mode_cmd->pixel_format,
1298 				      mode_cmd->modifier[0])) {
1299 		drm_dbg(&dev_priv->drm,
1300 			"unsupported pixel format %p4cc / modifier 0x%llx\n",
1301 			&mode_cmd->pixel_format, mode_cmd->modifier[0]);
1302 		return -EINVAL;
1303 	}
1304 
1305 	/* Surface must be marked as a scanout. */
1306 	if (unlikely(!surface->metadata.scanout))
1307 		return -EINVAL;
1308 
1309 	if (unlikely(surface->metadata.mip_levels[0] != 1 ||
1310 		     surface->metadata.num_sizes != 1 ||
1311 		     surface->metadata.base_size.width < mode_cmd->width ||
1312 		     surface->metadata.base_size.height < mode_cmd->height ||
1313 		     surface->metadata.base_size.depth != 1)) {
1314 		DRM_ERROR("Incompatible surface dimensions "
1315 			  "for requested mode.\n");
1316 		return -EINVAL;
1317 	}
1318 
1319 	switch (mode_cmd->pixel_format) {
1320 	case DRM_FORMAT_ARGB8888:
1321 		format = SVGA3D_A8R8G8B8;
1322 		break;
1323 	case DRM_FORMAT_XRGB8888:
1324 		format = SVGA3D_X8R8G8B8;
1325 		break;
1326 	case DRM_FORMAT_RGB565:
1327 		format = SVGA3D_R5G6B5;
1328 		break;
1329 	case DRM_FORMAT_XRGB1555:
1330 		format = SVGA3D_A1R5G5B5;
1331 		break;
1332 	default:
1333 		DRM_ERROR("Invalid pixel format: %p4cc\n",
1334 			  &mode_cmd->pixel_format);
1335 		return -EINVAL;
1336 	}
1337 
1338 	/*
1339 	 * For DX, surface format validation is done when surface->scanout
1340 	 * is set.
1341 	 */
1342 	if (!has_sm4_context(dev_priv) && format != surface->metadata.format) {
1343 		DRM_ERROR("Invalid surface format for requested mode.\n");
1344 		return -EINVAL;
1345 	}
1346 
1347 	vfbs = kzalloc(sizeof(*vfbs), GFP_KERNEL);
1348 	if (!vfbs) {
1349 		ret = -ENOMEM;
1350 		goto out_err1;
1351 	}
1352 
1353 	drm_helper_mode_fill_fb_struct(dev, &vfbs->base.base, mode_cmd);
1354 	vfbs->surface = vmw_surface_reference(surface);
1355 	vfbs->base.user_handle = mode_cmd->handles[0];
1356 	vfbs->is_bo_proxy = is_bo_proxy;
1357 
1358 	*out = &vfbs->base;
1359 
1360 	ret = drm_framebuffer_init(dev, &vfbs->base.base,
1361 				   &vmw_framebuffer_surface_funcs);
1362 	if (ret)
1363 		goto out_err2;
1364 
1365 	return 0;
1366 
1367 out_err2:
1368 	vmw_surface_unreference(&surface);
1369 	kfree(vfbs);
1370 out_err1:
1371 	return ret;
1372 }
1373 
1374 /*
1375  * Buffer-object framebuffer code
1376  */
1377 
1378 static int vmw_framebuffer_bo_create_handle(struct drm_framebuffer *fb,
1379 					    struct drm_file *file_priv,
1380 					    unsigned int *handle)
1381 {
1382 	struct vmw_framebuffer_bo *vfbd =
1383 			vmw_framebuffer_to_vfbd(fb);
1384 
1385 	return drm_gem_handle_create(file_priv, &vfbd->buffer->tbo.base, handle);
1386 }
1387 
1388 static void vmw_framebuffer_bo_destroy(struct drm_framebuffer *framebuffer)
1389 {
1390 	struct vmw_framebuffer_bo *vfbd =
1391 		vmw_framebuffer_to_vfbd(framebuffer);
1392 
1393 	drm_framebuffer_cleanup(framebuffer);
1394 	vmw_bo_unreference(&vfbd->buffer);
1395 
1396 	kfree(vfbd);
1397 }
1398 
1399 static const struct drm_framebuffer_funcs vmw_framebuffer_bo_funcs = {
1400 	.create_handle = vmw_framebuffer_bo_create_handle,
1401 	.destroy = vmw_framebuffer_bo_destroy,
1402 	.dirty = drm_atomic_helper_dirtyfb,
1403 };
1404 
1405 /**
1406  * vmw_create_bo_proxy - create a proxy surface for the buffer object
1407  *
1408  * @dev: DRM device
1409  * @mode_cmd: parameters for the new surface
1410  * @bo_mob: MOB backing the buffer object
1411  * @srf_out: newly created surface
1412  *
1413  * When the content FB is a buffer object, we create a surface as a proxy to the
1414  * same buffer.  This way we can do a surface copy rather than a surface DMA.
1415  * This is a more efficient approach
1416  *
1417  * RETURNS:
1418  * 0 on success, error code otherwise
1419  */
1420 static int vmw_create_bo_proxy(struct drm_device *dev,
1421 			       const struct drm_mode_fb_cmd2 *mode_cmd,
1422 			       struct vmw_bo *bo_mob,
1423 			       struct vmw_surface **srf_out)
1424 {
1425 	struct vmw_surface_metadata metadata = {0};
1426 	uint32_t format;
1427 	struct vmw_resource *res;
1428 	unsigned int bytes_pp;
1429 	int ret;
1430 
1431 	switch (mode_cmd->pixel_format) {
1432 	case DRM_FORMAT_ARGB8888:
1433 	case DRM_FORMAT_XRGB8888:
1434 		format = SVGA3D_X8R8G8B8;
1435 		bytes_pp = 4;
1436 		break;
1437 
1438 	case DRM_FORMAT_RGB565:
1439 	case DRM_FORMAT_XRGB1555:
1440 		format = SVGA3D_R5G6B5;
1441 		bytes_pp = 2;
1442 		break;
1443 
1444 	case 8:
1445 		format = SVGA3D_P8;
1446 		bytes_pp = 1;
1447 		break;
1448 
1449 	default:
1450 		DRM_ERROR("Invalid framebuffer format %p4cc\n",
1451 			  &mode_cmd->pixel_format);
1452 		return -EINVAL;
1453 	}
1454 
1455 	metadata.format = format;
1456 	metadata.mip_levels[0] = 1;
1457 	metadata.num_sizes = 1;
1458 	metadata.base_size.width = mode_cmd->pitches[0] / bytes_pp;
1459 	metadata.base_size.height =  mode_cmd->height;
1460 	metadata.base_size.depth = 1;
1461 	metadata.scanout = true;
1462 
1463 	ret = vmw_gb_surface_define(vmw_priv(dev), &metadata, srf_out);
1464 	if (ret) {
1465 		DRM_ERROR("Failed to allocate proxy content buffer\n");
1466 		return ret;
1467 	}
1468 
1469 	res = &(*srf_out)->res;
1470 
1471 	/* Reserve and switch the backing mob. */
1472 	mutex_lock(&res->dev_priv->cmdbuf_mutex);
1473 	(void) vmw_resource_reserve(res, false, true);
1474 	vmw_bo_unreference(&res->guest_memory_bo);
1475 	res->guest_memory_bo = vmw_bo_reference(bo_mob);
1476 	res->guest_memory_offset = 0;
1477 	vmw_resource_unreserve(res, false, false, false, NULL, 0);
1478 	mutex_unlock(&res->dev_priv->cmdbuf_mutex);
1479 
1480 	return 0;
1481 }
1482 
1483 
1484 
1485 static int vmw_kms_new_framebuffer_bo(struct vmw_private *dev_priv,
1486 				      struct vmw_bo *bo,
1487 				      struct vmw_framebuffer **out,
1488 				      const struct drm_mode_fb_cmd2
1489 				      *mode_cmd)
1490 
1491 {
1492 	struct drm_device *dev = &dev_priv->drm;
1493 	struct vmw_framebuffer_bo *vfbd;
1494 	unsigned int requested_size;
1495 	int ret;
1496 
1497 	requested_size = mode_cmd->height * mode_cmd->pitches[0];
1498 	if (unlikely(requested_size > bo->tbo.base.size)) {
1499 		DRM_ERROR("Screen buffer object size is too small "
1500 			  "for requested mode.\n");
1501 		return -EINVAL;
1502 	}
1503 
1504 	if (!drm_any_plane_has_format(&dev_priv->drm,
1505 				      mode_cmd->pixel_format,
1506 				      mode_cmd->modifier[0])) {
1507 		drm_dbg(&dev_priv->drm,
1508 			"unsupported pixel format %p4cc / modifier 0x%llx\n",
1509 			&mode_cmd->pixel_format, mode_cmd->modifier[0]);
1510 		return -EINVAL;
1511 	}
1512 
1513 	vfbd = kzalloc(sizeof(*vfbd), GFP_KERNEL);
1514 	if (!vfbd) {
1515 		ret = -ENOMEM;
1516 		goto out_err1;
1517 	}
1518 
1519 	vfbd->base.base.obj[0] = &bo->tbo.base;
1520 	drm_helper_mode_fill_fb_struct(dev, &vfbd->base.base, mode_cmd);
1521 	vfbd->base.bo = true;
1522 	vfbd->buffer = vmw_bo_reference(bo);
1523 	vfbd->base.user_handle = mode_cmd->handles[0];
1524 	*out = &vfbd->base;
1525 
1526 	ret = drm_framebuffer_init(dev, &vfbd->base.base,
1527 				   &vmw_framebuffer_bo_funcs);
1528 	if (ret)
1529 		goto out_err2;
1530 
1531 	return 0;
1532 
1533 out_err2:
1534 	vmw_bo_unreference(&bo);
1535 	kfree(vfbd);
1536 out_err1:
1537 	return ret;
1538 }
1539 
1540 
1541 /**
1542  * vmw_kms_srf_ok - check if a surface can be created
1543  *
1544  * @dev_priv: Pointer to device private struct.
1545  * @width: requested width
1546  * @height: requested height
1547  *
1548  * Surfaces need to be less than texture size
1549  */
1550 static bool
1551 vmw_kms_srf_ok(struct vmw_private *dev_priv, uint32_t width, uint32_t height)
1552 {
1553 	if (width  > dev_priv->texture_max_width ||
1554 	    height > dev_priv->texture_max_height)
1555 		return false;
1556 
1557 	return true;
1558 }
1559 
1560 /**
1561  * vmw_kms_new_framebuffer - Create a new framebuffer.
1562  *
1563  * @dev_priv: Pointer to device private struct.
1564  * @bo: Pointer to buffer object to wrap the kms framebuffer around.
1565  * Either @bo or @surface must be NULL.
1566  * @surface: Pointer to a surface to wrap the kms framebuffer around.
1567  * Either @bo or @surface must be NULL.
1568  * @only_2d: No presents will occur to this buffer object based framebuffer.
1569  * This helps the code to do some important optimizations.
1570  * @mode_cmd: Frame-buffer metadata.
1571  */
1572 struct vmw_framebuffer *
1573 vmw_kms_new_framebuffer(struct vmw_private *dev_priv,
1574 			struct vmw_bo *bo,
1575 			struct vmw_surface *surface,
1576 			bool only_2d,
1577 			const struct drm_mode_fb_cmd2 *mode_cmd)
1578 {
1579 	struct vmw_framebuffer *vfb = NULL;
1580 	bool is_bo_proxy = false;
1581 	int ret;
1582 
1583 	/*
1584 	 * We cannot use the SurfaceDMA command in an non-accelerated VM,
1585 	 * therefore, wrap the buffer object in a surface so we can use the
1586 	 * SurfaceCopy command.
1587 	 */
1588 	if (vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height)  &&
1589 	    bo && only_2d &&
1590 	    mode_cmd->width > 64 &&  /* Don't create a proxy for cursor */
1591 	    dev_priv->active_display_unit == vmw_du_screen_target) {
1592 		ret = vmw_create_bo_proxy(&dev_priv->drm, mode_cmd,
1593 					  bo, &surface);
1594 		if (ret)
1595 			return ERR_PTR(ret);
1596 
1597 		is_bo_proxy = true;
1598 	}
1599 
1600 	/* Create the new framebuffer depending one what we have */
1601 	if (surface) {
1602 		ret = vmw_kms_new_framebuffer_surface(dev_priv, surface, &vfb,
1603 						      mode_cmd,
1604 						      is_bo_proxy);
1605 		/*
1606 		 * vmw_create_bo_proxy() adds a reference that is no longer
1607 		 * needed
1608 		 */
1609 		if (is_bo_proxy)
1610 			vmw_surface_unreference(&surface);
1611 	} else if (bo) {
1612 		ret = vmw_kms_new_framebuffer_bo(dev_priv, bo, &vfb,
1613 						 mode_cmd);
1614 	} else {
1615 		BUG();
1616 	}
1617 
1618 	if (ret)
1619 		return ERR_PTR(ret);
1620 
1621 	return vfb;
1622 }
1623 
1624 /*
1625  * Generic Kernel modesetting functions
1626  */
1627 
1628 static struct drm_framebuffer *vmw_kms_fb_create(struct drm_device *dev,
1629 						 struct drm_file *file_priv,
1630 						 const struct drm_mode_fb_cmd2 *mode_cmd)
1631 {
1632 	struct vmw_private *dev_priv = vmw_priv(dev);
1633 	struct vmw_framebuffer *vfb = NULL;
1634 	struct vmw_surface *surface = NULL;
1635 	struct vmw_bo *bo = NULL;
1636 	int ret;
1637 
1638 	/* returns either a bo or surface */
1639 	ret = vmw_user_lookup_handle(dev_priv, file_priv,
1640 				     mode_cmd->handles[0],
1641 				     &surface, &bo);
1642 	if (ret) {
1643 		DRM_ERROR("Invalid buffer object handle %u (0x%x).\n",
1644 			  mode_cmd->handles[0], mode_cmd->handles[0]);
1645 		goto err_out;
1646 	}
1647 
1648 
1649 	if (!bo &&
1650 	    !vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height)) {
1651 		DRM_ERROR("Surface size cannot exceed %dx%d\n",
1652 			dev_priv->texture_max_width,
1653 			dev_priv->texture_max_height);
1654 		goto err_out;
1655 	}
1656 
1657 
1658 	vfb = vmw_kms_new_framebuffer(dev_priv, bo, surface,
1659 				      !(dev_priv->capabilities & SVGA_CAP_3D),
1660 				      mode_cmd);
1661 	if (IS_ERR(vfb)) {
1662 		ret = PTR_ERR(vfb);
1663 		goto err_out;
1664 	}
1665 
1666 err_out:
1667 	/* vmw_user_lookup_handle takes one ref so does new_fb */
1668 	if (bo)
1669 		vmw_user_bo_unref(bo);
1670 	if (surface)
1671 		vmw_surface_unreference(&surface);
1672 
1673 	if (ret) {
1674 		DRM_ERROR("failed to create vmw_framebuffer: %i\n", ret);
1675 		return ERR_PTR(ret);
1676 	}
1677 
1678 	return &vfb->base;
1679 }
1680 
1681 /**
1682  * vmw_kms_check_display_memory - Validates display memory required for a
1683  * topology
1684  * @dev: DRM device
1685  * @num_rects: number of drm_rect in rects
1686  * @rects: array of drm_rect representing the topology to validate indexed by
1687  * crtc index.
1688  *
1689  * Returns:
1690  * 0 on success otherwise negative error code
1691  */
1692 static int vmw_kms_check_display_memory(struct drm_device *dev,
1693 					uint32_t num_rects,
1694 					struct drm_rect *rects)
1695 {
1696 	struct vmw_private *dev_priv = vmw_priv(dev);
1697 	struct drm_rect bounding_box = {0};
1698 	u64 total_pixels = 0, pixel_mem, bb_mem;
1699 	int i;
1700 
1701 	for (i = 0; i < num_rects; i++) {
1702 		/*
1703 		 * For STDU only individual screen (screen target) is limited by
1704 		 * SCREENTARGET_MAX_WIDTH/HEIGHT registers.
1705 		 */
1706 		if (dev_priv->active_display_unit == vmw_du_screen_target &&
1707 		    (drm_rect_width(&rects[i]) > dev_priv->stdu_max_width ||
1708 		     drm_rect_height(&rects[i]) > dev_priv->stdu_max_height)) {
1709 			VMW_DEBUG_KMS("Screen size not supported.\n");
1710 			return -EINVAL;
1711 		}
1712 
1713 		/* Bounding box upper left is at (0,0). */
1714 		if (rects[i].x2 > bounding_box.x2)
1715 			bounding_box.x2 = rects[i].x2;
1716 
1717 		if (rects[i].y2 > bounding_box.y2)
1718 			bounding_box.y2 = rects[i].y2;
1719 
1720 		total_pixels += (u64) drm_rect_width(&rects[i]) *
1721 			(u64) drm_rect_height(&rects[i]);
1722 	}
1723 
1724 	/* Virtual svga device primary limits are always in 32-bpp. */
1725 	pixel_mem = total_pixels * 4;
1726 
1727 	/*
1728 	 * For HV10 and below prim_bb_mem is vram size. When
1729 	 * SVGA_REG_MAX_PRIMARY_BOUNDING_BOX_MEM is not present vram size is
1730 	 * limit on primary bounding box
1731 	 */
1732 	if (pixel_mem > dev_priv->max_primary_mem) {
1733 		VMW_DEBUG_KMS("Combined output size too large.\n");
1734 		return -EINVAL;
1735 	}
1736 
1737 	/* SVGA_CAP_NO_BB_RESTRICTION is available for STDU only. */
1738 	if (dev_priv->active_display_unit != vmw_du_screen_target ||
1739 	    !(dev_priv->capabilities & SVGA_CAP_NO_BB_RESTRICTION)) {
1740 		bb_mem = (u64) bounding_box.x2 * bounding_box.y2 * 4;
1741 
1742 		if (bb_mem > dev_priv->max_primary_mem) {
1743 			VMW_DEBUG_KMS("Topology is beyond supported limits.\n");
1744 			return -EINVAL;
1745 		}
1746 	}
1747 
1748 	return 0;
1749 }
1750 
1751 /**
1752  * vmw_crtc_state_and_lock - Return new or current crtc state with locked
1753  * crtc mutex
1754  * @state: The atomic state pointer containing the new atomic state
1755  * @crtc: The crtc
1756  *
1757  * This function returns the new crtc state if it's part of the state update.
1758  * Otherwise returns the current crtc state. It also makes sure that the
1759  * crtc mutex is locked.
1760  *
1761  * Returns: A valid crtc state pointer or NULL. It may also return a
1762  * pointer error, in particular -EDEADLK if locking needs to be rerun.
1763  */
1764 static struct drm_crtc_state *
1765 vmw_crtc_state_and_lock(struct drm_atomic_state *state, struct drm_crtc *crtc)
1766 {
1767 	struct drm_crtc_state *crtc_state;
1768 
1769 	crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
1770 	if (crtc_state) {
1771 		lockdep_assert_held(&crtc->mutex.mutex.base);
1772 	} else {
1773 		int ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
1774 
1775 		if (ret != 0 && ret != -EALREADY)
1776 			return ERR_PTR(ret);
1777 
1778 		crtc_state = crtc->state;
1779 	}
1780 
1781 	return crtc_state;
1782 }
1783 
1784 /**
1785  * vmw_kms_check_implicit - Verify that all implicit display units scan out
1786  * from the same fb after the new state is committed.
1787  * @dev: The drm_device.
1788  * @state: The new state to be checked.
1789  *
1790  * Returns:
1791  *   Zero on success,
1792  *   -EINVAL on invalid state,
1793  *   -EDEADLK if modeset locking needs to be rerun.
1794  */
1795 static int vmw_kms_check_implicit(struct drm_device *dev,
1796 				  struct drm_atomic_state *state)
1797 {
1798 	struct drm_framebuffer *implicit_fb = NULL;
1799 	struct drm_crtc *crtc;
1800 	struct drm_crtc_state *crtc_state;
1801 	struct drm_plane_state *plane_state;
1802 
1803 	drm_for_each_crtc(crtc, dev) {
1804 		struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1805 
1806 		if (!du->is_implicit)
1807 			continue;
1808 
1809 		crtc_state = vmw_crtc_state_and_lock(state, crtc);
1810 		if (IS_ERR(crtc_state))
1811 			return PTR_ERR(crtc_state);
1812 
1813 		if (!crtc_state || !crtc_state->enable)
1814 			continue;
1815 
1816 		/*
1817 		 * Can't move primary planes across crtcs, so this is OK.
1818 		 * It also means we don't need to take the plane mutex.
1819 		 */
1820 		plane_state = du->primary.state;
1821 		if (plane_state->crtc != crtc)
1822 			continue;
1823 
1824 		if (!implicit_fb)
1825 			implicit_fb = plane_state->fb;
1826 		else if (implicit_fb != plane_state->fb)
1827 			return -EINVAL;
1828 	}
1829 
1830 	return 0;
1831 }
1832 
1833 /**
1834  * vmw_kms_check_topology - Validates topology in drm_atomic_state
1835  * @dev: DRM device
1836  * @state: the driver state object
1837  *
1838  * Returns:
1839  * 0 on success otherwise negative error code
1840  */
1841 static int vmw_kms_check_topology(struct drm_device *dev,
1842 				  struct drm_atomic_state *state)
1843 {
1844 	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
1845 	struct drm_rect *rects;
1846 	struct drm_crtc *crtc;
1847 	uint32_t i;
1848 	int ret = 0;
1849 
1850 	rects = kcalloc(dev->mode_config.num_crtc, sizeof(struct drm_rect),
1851 			GFP_KERNEL);
1852 	if (!rects)
1853 		return -ENOMEM;
1854 
1855 	drm_for_each_crtc(crtc, dev) {
1856 		struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1857 		struct drm_crtc_state *crtc_state;
1858 
1859 		i = drm_crtc_index(crtc);
1860 
1861 		crtc_state = vmw_crtc_state_and_lock(state, crtc);
1862 		if (IS_ERR(crtc_state)) {
1863 			ret = PTR_ERR(crtc_state);
1864 			goto clean;
1865 		}
1866 
1867 		if (!crtc_state)
1868 			continue;
1869 
1870 		if (crtc_state->enable) {
1871 			rects[i].x1 = du->gui_x;
1872 			rects[i].y1 = du->gui_y;
1873 			rects[i].x2 = du->gui_x + crtc_state->mode.hdisplay;
1874 			rects[i].y2 = du->gui_y + crtc_state->mode.vdisplay;
1875 		} else {
1876 			rects[i].x1 = 0;
1877 			rects[i].y1 = 0;
1878 			rects[i].x2 = 0;
1879 			rects[i].y2 = 0;
1880 		}
1881 	}
1882 
1883 	/* Determine change to topology due to new atomic state */
1884 	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state,
1885 				      new_crtc_state, i) {
1886 		struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1887 		struct drm_connector *connector;
1888 		struct drm_connector_state *conn_state;
1889 		struct vmw_connector_state *vmw_conn_state;
1890 
1891 		if (!du->pref_active && new_crtc_state->enable) {
1892 			VMW_DEBUG_KMS("Enabling a disabled display unit\n");
1893 			ret = -EINVAL;
1894 			goto clean;
1895 		}
1896 
1897 		/*
1898 		 * For vmwgfx each crtc has only one connector attached and it
1899 		 * is not changed so don't really need to check the
1900 		 * crtc->connector_mask and iterate over it.
1901 		 */
1902 		connector = &du->connector;
1903 		conn_state = drm_atomic_get_connector_state(state, connector);
1904 		if (IS_ERR(conn_state)) {
1905 			ret = PTR_ERR(conn_state);
1906 			goto clean;
1907 		}
1908 
1909 		vmw_conn_state = vmw_connector_state_to_vcs(conn_state);
1910 		vmw_conn_state->gui_x = du->gui_x;
1911 		vmw_conn_state->gui_y = du->gui_y;
1912 	}
1913 
1914 	ret = vmw_kms_check_display_memory(dev, dev->mode_config.num_crtc,
1915 					   rects);
1916 
1917 clean:
1918 	kfree(rects);
1919 	return ret;
1920 }
1921 
1922 /**
1923  * vmw_kms_atomic_check_modeset- validate state object for modeset changes
1924  *
1925  * @dev: DRM device
1926  * @state: the driver state object
1927  *
1928  * This is a simple wrapper around drm_atomic_helper_check_modeset() for
1929  * us to assign a value to mode->crtc_clock so that
1930  * drm_calc_timestamping_constants() won't throw an error message
1931  *
1932  * Returns:
1933  * Zero for success or -errno
1934  */
1935 static int
1936 vmw_kms_atomic_check_modeset(struct drm_device *dev,
1937 			     struct drm_atomic_state *state)
1938 {
1939 	struct drm_crtc *crtc;
1940 	struct drm_crtc_state *crtc_state;
1941 	bool need_modeset = false;
1942 	int i, ret;
1943 
1944 	ret = drm_atomic_helper_check(dev, state);
1945 	if (ret)
1946 		return ret;
1947 
1948 	ret = vmw_kms_check_implicit(dev, state);
1949 	if (ret) {
1950 		VMW_DEBUG_KMS("Invalid implicit state\n");
1951 		return ret;
1952 	}
1953 
1954 	for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1955 		if (drm_atomic_crtc_needs_modeset(crtc_state))
1956 			need_modeset = true;
1957 	}
1958 
1959 	if (need_modeset)
1960 		return vmw_kms_check_topology(dev, state);
1961 
1962 	return ret;
1963 }
1964 
1965 static const struct drm_mode_config_funcs vmw_kms_funcs = {
1966 	.fb_create = vmw_kms_fb_create,
1967 	.atomic_check = vmw_kms_atomic_check_modeset,
1968 	.atomic_commit = drm_atomic_helper_commit,
1969 };
1970 
1971 static int vmw_kms_generic_present(struct vmw_private *dev_priv,
1972 				   struct drm_file *file_priv,
1973 				   struct vmw_framebuffer *vfb,
1974 				   struct vmw_surface *surface,
1975 				   uint32_t sid,
1976 				   int32_t destX, int32_t destY,
1977 				   struct drm_vmw_rect *clips,
1978 				   uint32_t num_clips)
1979 {
1980 	return vmw_kms_sou_do_surface_dirty(dev_priv, vfb, NULL, clips,
1981 					    &surface->res, destX, destY,
1982 					    num_clips, 1, NULL, NULL);
1983 }
1984 
1985 
1986 int vmw_kms_present(struct vmw_private *dev_priv,
1987 		    struct drm_file *file_priv,
1988 		    struct vmw_framebuffer *vfb,
1989 		    struct vmw_surface *surface,
1990 		    uint32_t sid,
1991 		    int32_t destX, int32_t destY,
1992 		    struct drm_vmw_rect *clips,
1993 		    uint32_t num_clips)
1994 {
1995 	int ret;
1996 
1997 	switch (dev_priv->active_display_unit) {
1998 	case vmw_du_screen_target:
1999 		ret = vmw_kms_stdu_surface_dirty(dev_priv, vfb, NULL, clips,
2000 						 &surface->res, destX, destY,
2001 						 num_clips, 1, NULL, NULL);
2002 		break;
2003 	case vmw_du_screen_object:
2004 		ret = vmw_kms_generic_present(dev_priv, file_priv, vfb, surface,
2005 					      sid, destX, destY, clips,
2006 					      num_clips);
2007 		break;
2008 	default:
2009 		WARN_ONCE(true,
2010 			  "Present called with invalid display system.\n");
2011 		ret = -ENOSYS;
2012 		break;
2013 	}
2014 	if (ret)
2015 		return ret;
2016 
2017 	vmw_cmd_flush(dev_priv, false);
2018 
2019 	return 0;
2020 }
2021 
2022 static void
2023 vmw_kms_create_hotplug_mode_update_property(struct vmw_private *dev_priv)
2024 {
2025 	if (dev_priv->hotplug_mode_update_property)
2026 		return;
2027 
2028 	dev_priv->hotplug_mode_update_property =
2029 		drm_property_create_range(&dev_priv->drm,
2030 					  DRM_MODE_PROP_IMMUTABLE,
2031 					  "hotplug_mode_update", 0, 1);
2032 }
2033 
2034 int vmw_kms_init(struct vmw_private *dev_priv)
2035 {
2036 	struct drm_device *dev = &dev_priv->drm;
2037 	int ret;
2038 	static const char *display_unit_names[] = {
2039 		"Invalid",
2040 		"Legacy",
2041 		"Screen Object",
2042 		"Screen Target",
2043 		"Invalid (max)"
2044 	};
2045 
2046 	drm_mode_config_init(dev);
2047 	dev->mode_config.funcs = &vmw_kms_funcs;
2048 	dev->mode_config.min_width = 1;
2049 	dev->mode_config.min_height = 1;
2050 	dev->mode_config.max_width = dev_priv->texture_max_width;
2051 	dev->mode_config.max_height = dev_priv->texture_max_height;
2052 	dev->mode_config.preferred_depth = dev_priv->assume_16bpp ? 16 : 32;
2053 
2054 	drm_mode_create_suggested_offset_properties(dev);
2055 	vmw_kms_create_hotplug_mode_update_property(dev_priv);
2056 
2057 	ret = vmw_kms_stdu_init_display(dev_priv);
2058 	if (ret) {
2059 		ret = vmw_kms_sou_init_display(dev_priv);
2060 		if (ret) /* Fallback */
2061 			ret = vmw_kms_ldu_init_display(dev_priv);
2062 	}
2063 	BUILD_BUG_ON(ARRAY_SIZE(display_unit_names) != (vmw_du_max + 1));
2064 	drm_info(&dev_priv->drm, "%s display unit initialized\n",
2065 		 display_unit_names[dev_priv->active_display_unit]);
2066 
2067 	return ret;
2068 }
2069 
2070 int vmw_kms_close(struct vmw_private *dev_priv)
2071 {
2072 	int ret = 0;
2073 
2074 	/*
2075 	 * Docs says we should take the lock before calling this function
2076 	 * but since it destroys encoders and our destructor calls
2077 	 * drm_encoder_cleanup which takes the lock we deadlock.
2078 	 */
2079 	drm_mode_config_cleanup(&dev_priv->drm);
2080 	if (dev_priv->active_display_unit == vmw_du_legacy)
2081 		ret = vmw_kms_ldu_close_display(dev_priv);
2082 
2083 	return ret;
2084 }
2085 
2086 int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,
2087 				struct drm_file *file_priv)
2088 {
2089 	struct drm_vmw_cursor_bypass_arg *arg = data;
2090 	struct vmw_display_unit *du;
2091 	struct drm_crtc *crtc;
2092 	int ret = 0;
2093 
2094 	mutex_lock(&dev->mode_config.mutex);
2095 	if (arg->flags & DRM_VMW_CURSOR_BYPASS_ALL) {
2096 
2097 		list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
2098 			du = vmw_crtc_to_du(crtc);
2099 			du->hotspot_x = arg->xhot;
2100 			du->hotspot_y = arg->yhot;
2101 		}
2102 
2103 		mutex_unlock(&dev->mode_config.mutex);
2104 		return 0;
2105 	}
2106 
2107 	crtc = drm_crtc_find(dev, file_priv, arg->crtc_id);
2108 	if (!crtc) {
2109 		ret = -ENOENT;
2110 		goto out;
2111 	}
2112 
2113 	du = vmw_crtc_to_du(crtc);
2114 
2115 	du->hotspot_x = arg->xhot;
2116 	du->hotspot_y = arg->yhot;
2117 
2118 out:
2119 	mutex_unlock(&dev->mode_config.mutex);
2120 
2121 	return ret;
2122 }
2123 
2124 int vmw_kms_write_svga(struct vmw_private *vmw_priv,
2125 			unsigned width, unsigned height, unsigned pitch,
2126 			unsigned bpp, unsigned depth)
2127 {
2128 	if (vmw_priv->capabilities & SVGA_CAP_PITCHLOCK)
2129 		vmw_write(vmw_priv, SVGA_REG_PITCHLOCK, pitch);
2130 	else if (vmw_fifo_have_pitchlock(vmw_priv))
2131 		vmw_fifo_mem_write(vmw_priv, SVGA_FIFO_PITCHLOCK, pitch);
2132 	vmw_write(vmw_priv, SVGA_REG_WIDTH, width);
2133 	vmw_write(vmw_priv, SVGA_REG_HEIGHT, height);
2134 	if ((vmw_priv->capabilities & SVGA_CAP_8BIT_EMULATION) != 0)
2135 		vmw_write(vmw_priv, SVGA_REG_BITS_PER_PIXEL, bpp);
2136 
2137 	if (vmw_read(vmw_priv, SVGA_REG_DEPTH) != depth) {
2138 		DRM_ERROR("Invalid depth %u for %u bpp, host expects %u\n",
2139 			  depth, bpp, vmw_read(vmw_priv, SVGA_REG_DEPTH));
2140 		return -EINVAL;
2141 	}
2142 
2143 	return 0;
2144 }
2145 
2146 bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
2147 				uint32_t pitch,
2148 				uint32_t height)
2149 {
2150 	return ((u64) pitch * (u64) height) < (u64)
2151 		((dev_priv->active_display_unit == vmw_du_screen_target) ?
2152 		 dev_priv->max_primary_mem : dev_priv->vram_size);
2153 }
2154 
2155 /**
2156  * vmw_du_update_layout - Update the display unit with topology from resolution
2157  * plugin and generate DRM uevent
2158  * @dev_priv: device private
2159  * @num_rects: number of drm_rect in rects
2160  * @rects: toplogy to update
2161  */
2162 static int vmw_du_update_layout(struct vmw_private *dev_priv,
2163 				unsigned int num_rects, struct drm_rect *rects)
2164 {
2165 	struct drm_device *dev = &dev_priv->drm;
2166 	struct vmw_display_unit *du;
2167 	struct drm_connector *con;
2168 	struct drm_connector_list_iter conn_iter;
2169 	struct drm_modeset_acquire_ctx ctx;
2170 	struct drm_crtc *crtc;
2171 	int ret;
2172 
2173 	/* Currently gui_x/y is protected with the crtc mutex */
2174 	mutex_lock(&dev->mode_config.mutex);
2175 	drm_modeset_acquire_init(&ctx, 0);
2176 retry:
2177 	drm_for_each_crtc(crtc, dev) {
2178 		ret = drm_modeset_lock(&crtc->mutex, &ctx);
2179 		if (ret < 0) {
2180 			if (ret == -EDEADLK) {
2181 				drm_modeset_backoff(&ctx);
2182 				goto retry;
2183 		}
2184 			goto out_fini;
2185 		}
2186 	}
2187 
2188 	drm_connector_list_iter_begin(dev, &conn_iter);
2189 	drm_for_each_connector_iter(con, &conn_iter) {
2190 		du = vmw_connector_to_du(con);
2191 		if (num_rects > du->unit) {
2192 			du->pref_width = drm_rect_width(&rects[du->unit]);
2193 			du->pref_height = drm_rect_height(&rects[du->unit]);
2194 			du->pref_active = true;
2195 			du->gui_x = rects[du->unit].x1;
2196 			du->gui_y = rects[du->unit].y1;
2197 		} else {
2198 			du->pref_width  = VMWGFX_MIN_INITIAL_WIDTH;
2199 			du->pref_height = VMWGFX_MIN_INITIAL_HEIGHT;
2200 			du->pref_active = false;
2201 			du->gui_x = 0;
2202 			du->gui_y = 0;
2203 		}
2204 	}
2205 	drm_connector_list_iter_end(&conn_iter);
2206 
2207 	list_for_each_entry(con, &dev->mode_config.connector_list, head) {
2208 		du = vmw_connector_to_du(con);
2209 		if (num_rects > du->unit) {
2210 			drm_object_property_set_value
2211 			  (&con->base, dev->mode_config.suggested_x_property,
2212 			   du->gui_x);
2213 			drm_object_property_set_value
2214 			  (&con->base, dev->mode_config.suggested_y_property,
2215 			   du->gui_y);
2216 		} else {
2217 			drm_object_property_set_value
2218 			  (&con->base, dev->mode_config.suggested_x_property,
2219 			   0);
2220 			drm_object_property_set_value
2221 			  (&con->base, dev->mode_config.suggested_y_property,
2222 			   0);
2223 		}
2224 		con->status = vmw_du_connector_detect(con, true);
2225 	}
2226 out_fini:
2227 	drm_modeset_drop_locks(&ctx);
2228 	drm_modeset_acquire_fini(&ctx);
2229 	mutex_unlock(&dev->mode_config.mutex);
2230 
2231 	drm_sysfs_hotplug_event(dev);
2232 
2233 	return 0;
2234 }
2235 
2236 int vmw_du_crtc_gamma_set(struct drm_crtc *crtc,
2237 			  u16 *r, u16 *g, u16 *b,
2238 			  uint32_t size,
2239 			  struct drm_modeset_acquire_ctx *ctx)
2240 {
2241 	struct vmw_private *dev_priv = vmw_priv(crtc->dev);
2242 	int i;
2243 
2244 	for (i = 0; i < size; i++) {
2245 		DRM_DEBUG("%d r/g/b = 0x%04x / 0x%04x / 0x%04x\n", i,
2246 			  r[i], g[i], b[i]);
2247 		vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 0, r[i] >> 8);
2248 		vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 1, g[i] >> 8);
2249 		vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 2, b[i] >> 8);
2250 	}
2251 
2252 	return 0;
2253 }
2254 
2255 int vmw_du_connector_dpms(struct drm_connector *connector, int mode)
2256 {
2257 	return 0;
2258 }
2259 
2260 enum drm_connector_status
2261 vmw_du_connector_detect(struct drm_connector *connector, bool force)
2262 {
2263 	uint32_t num_displays;
2264 	struct drm_device *dev = connector->dev;
2265 	struct vmw_private *dev_priv = vmw_priv(dev);
2266 	struct vmw_display_unit *du = vmw_connector_to_du(connector);
2267 
2268 	num_displays = vmw_read(dev_priv, SVGA_REG_NUM_DISPLAYS);
2269 
2270 	return ((vmw_connector_to_du(connector)->unit < num_displays &&
2271 		 du->pref_active) ?
2272 		connector_status_connected : connector_status_disconnected);
2273 }
2274 
2275 static struct drm_display_mode vmw_kms_connector_builtin[] = {
2276 	/* 640x480@60Hz */
2277 	{ DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
2278 		   752, 800, 0, 480, 489, 492, 525, 0,
2279 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
2280 	/* 800x600@60Hz */
2281 	{ DRM_MODE("800x600", DRM_MODE_TYPE_DRIVER, 40000, 800, 840,
2282 		   968, 1056, 0, 600, 601, 605, 628, 0,
2283 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2284 	/* 1024x768@60Hz */
2285 	{ DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 65000, 1024, 1048,
2286 		   1184, 1344, 0, 768, 771, 777, 806, 0,
2287 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) },
2288 	/* 1152x864@75Hz */
2289 	{ DRM_MODE("1152x864", DRM_MODE_TYPE_DRIVER, 108000, 1152, 1216,
2290 		   1344, 1600, 0, 864, 865, 868, 900, 0,
2291 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2292 	/* 1280x720@60Hz */
2293 	{ DRM_MODE("1280x720", DRM_MODE_TYPE_DRIVER, 74500, 1280, 1344,
2294 		   1472, 1664, 0, 720, 723, 728, 748, 0,
2295 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2296 	/* 1280x768@60Hz */
2297 	{ DRM_MODE("1280x768", DRM_MODE_TYPE_DRIVER, 79500, 1280, 1344,
2298 		   1472, 1664, 0, 768, 771, 778, 798, 0,
2299 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2300 	/* 1280x800@60Hz */
2301 	{ DRM_MODE("1280x800", DRM_MODE_TYPE_DRIVER, 83500, 1280, 1352,
2302 		   1480, 1680, 0, 800, 803, 809, 831, 0,
2303 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
2304 	/* 1280x960@60Hz */
2305 	{ DRM_MODE("1280x960", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1376,
2306 		   1488, 1800, 0, 960, 961, 964, 1000, 0,
2307 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2308 	/* 1280x1024@60Hz */
2309 	{ DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 108000, 1280, 1328,
2310 		   1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
2311 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2312 	/* 1360x768@60Hz */
2313 	{ DRM_MODE("1360x768", DRM_MODE_TYPE_DRIVER, 85500, 1360, 1424,
2314 		   1536, 1792, 0, 768, 771, 777, 795, 0,
2315 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2316 	/* 1440x1050@60Hz */
2317 	{ DRM_MODE("1400x1050", DRM_MODE_TYPE_DRIVER, 121750, 1400, 1488,
2318 		   1632, 1864, 0, 1050, 1053, 1057, 1089, 0,
2319 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2320 	/* 1440x900@60Hz */
2321 	{ DRM_MODE("1440x900", DRM_MODE_TYPE_DRIVER, 106500, 1440, 1520,
2322 		   1672, 1904, 0, 900, 903, 909, 934, 0,
2323 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2324 	/* 1600x1200@60Hz */
2325 	{ DRM_MODE("1600x1200", DRM_MODE_TYPE_DRIVER, 162000, 1600, 1664,
2326 		   1856, 2160, 0, 1200, 1201, 1204, 1250, 0,
2327 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
2328 	/* 1680x1050@60Hz */
2329 	{ DRM_MODE("1680x1050", DRM_MODE_TYPE_DRIVER, 146250, 1680, 1784,
2330 		   1960, 2240, 0, 1050, 1053, 1059, 1089, 0,
2331 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2332 	/* 1792x1344@60Hz */
2333 	{ DRM_MODE("1792x1344", DRM_MODE_TYPE_DRIVER, 204750, 1792, 1920,
2334 		   2120, 2448, 0, 1344, 1345, 1348, 1394, 0,
2335 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2336 	/* 1853x1392@60Hz */
2337 	{ DRM_MODE("1856x1392", DRM_MODE_TYPE_DRIVER, 218250, 1856, 1952,
2338 		   2176, 2528, 0, 1392, 1393, 1396, 1439, 0,
2339 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2340 	/* 1920x1080@60Hz */
2341 	{ DRM_MODE("1920x1080", DRM_MODE_TYPE_DRIVER, 173000, 1920, 2048,
2342 		   2248, 2576, 0, 1080, 1083, 1088, 1120, 0,
2343 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2344 	/* 1920x1200@60Hz */
2345 	{ DRM_MODE("1920x1200", DRM_MODE_TYPE_DRIVER, 193250, 1920, 2056,
2346 		   2256, 2592, 0, 1200, 1203, 1209, 1245, 0,
2347 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2348 	/* 1920x1440@60Hz */
2349 	{ DRM_MODE("1920x1440", DRM_MODE_TYPE_DRIVER, 234000, 1920, 2048,
2350 		   2256, 2600, 0, 1440, 1441, 1444, 1500, 0,
2351 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2352 	/* 2560x1440@60Hz */
2353 	{ DRM_MODE("2560x1440", DRM_MODE_TYPE_DRIVER, 241500, 2560, 2608,
2354 		   2640, 2720, 0, 1440, 1443, 1448, 1481, 0,
2355 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
2356 	/* 2560x1600@60Hz */
2357 	{ DRM_MODE("2560x1600", DRM_MODE_TYPE_DRIVER, 348500, 2560, 2752,
2358 		   3032, 3504, 0, 1600, 1603, 1609, 1658, 0,
2359 		   DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC) },
2360 	/* 2880x1800@60Hz */
2361 	{ DRM_MODE("2880x1800", DRM_MODE_TYPE_DRIVER, 337500, 2880, 2928,
2362 		   2960, 3040, 0, 1800, 1803, 1809, 1852, 0,
2363 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
2364 	/* 3840x2160@60Hz */
2365 	{ DRM_MODE("3840x2160", DRM_MODE_TYPE_DRIVER, 533000, 3840, 3888,
2366 		   3920, 4000, 0, 2160, 2163, 2168, 2222, 0,
2367 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
2368 	/* 3840x2400@60Hz */
2369 	{ DRM_MODE("3840x2400", DRM_MODE_TYPE_DRIVER, 592250, 3840, 3888,
2370 		   3920, 4000, 0, 2400, 2403, 2409, 2469, 0,
2371 		   DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_NVSYNC) },
2372 	/* Terminate */
2373 	{ DRM_MODE("", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0) },
2374 };
2375 
2376 /**
2377  * vmw_guess_mode_timing - Provide fake timings for a
2378  * 60Hz vrefresh mode.
2379  *
2380  * @mode: Pointer to a struct drm_display_mode with hdisplay and vdisplay
2381  * members filled in.
2382  */
2383 void vmw_guess_mode_timing(struct drm_display_mode *mode)
2384 {
2385 	mode->hsync_start = mode->hdisplay + 50;
2386 	mode->hsync_end = mode->hsync_start + 50;
2387 	mode->htotal = mode->hsync_end + 50;
2388 
2389 	mode->vsync_start = mode->vdisplay + 50;
2390 	mode->vsync_end = mode->vsync_start + 50;
2391 	mode->vtotal = mode->vsync_end + 50;
2392 
2393 	mode->clock = (u32)mode->htotal * (u32)mode->vtotal / 100 * 6;
2394 }
2395 
2396 
2397 int vmw_du_connector_fill_modes(struct drm_connector *connector,
2398 				uint32_t max_width, uint32_t max_height)
2399 {
2400 	struct vmw_display_unit *du = vmw_connector_to_du(connector);
2401 	struct drm_device *dev = connector->dev;
2402 	struct vmw_private *dev_priv = vmw_priv(dev);
2403 	struct drm_display_mode *mode = NULL;
2404 	struct drm_display_mode *bmode;
2405 	struct drm_display_mode prefmode = { DRM_MODE("preferred",
2406 		DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
2407 		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2408 		DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC)
2409 	};
2410 	int i;
2411 	u32 assumed_bpp = 4;
2412 
2413 	if (dev_priv->assume_16bpp)
2414 		assumed_bpp = 2;
2415 
2416 	max_width  = min(max_width,  dev_priv->texture_max_width);
2417 	max_height = min(max_height, dev_priv->texture_max_height);
2418 
2419 	/*
2420 	 * For STDU extra limit for a mode on SVGA_REG_SCREENTARGET_MAX_WIDTH/
2421 	 * HEIGHT registers.
2422 	 */
2423 	if (dev_priv->active_display_unit == vmw_du_screen_target) {
2424 		max_width  = min(max_width,  dev_priv->stdu_max_width);
2425 		max_height = min(max_height, dev_priv->stdu_max_height);
2426 	}
2427 
2428 	/* Add preferred mode */
2429 	mode = drm_mode_duplicate(dev, &prefmode);
2430 	if (!mode)
2431 		return 0;
2432 	mode->hdisplay = du->pref_width;
2433 	mode->vdisplay = du->pref_height;
2434 	vmw_guess_mode_timing(mode);
2435 	drm_mode_set_name(mode);
2436 
2437 	if (vmw_kms_validate_mode_vram(dev_priv,
2438 					mode->hdisplay * assumed_bpp,
2439 					mode->vdisplay)) {
2440 		drm_mode_probed_add(connector, mode);
2441 	} else {
2442 		drm_mode_destroy(dev, mode);
2443 		mode = NULL;
2444 	}
2445 
2446 	if (du->pref_mode) {
2447 		list_del_init(&du->pref_mode->head);
2448 		drm_mode_destroy(dev, du->pref_mode);
2449 	}
2450 
2451 	/* mode might be null here, this is intended */
2452 	du->pref_mode = mode;
2453 
2454 	for (i = 0; vmw_kms_connector_builtin[i].type != 0; i++) {
2455 		bmode = &vmw_kms_connector_builtin[i];
2456 		if (bmode->hdisplay > max_width ||
2457 		    bmode->vdisplay > max_height)
2458 			continue;
2459 
2460 		if (!vmw_kms_validate_mode_vram(dev_priv,
2461 						bmode->hdisplay * assumed_bpp,
2462 						bmode->vdisplay))
2463 			continue;
2464 
2465 		mode = drm_mode_duplicate(dev, bmode);
2466 		if (!mode)
2467 			return 0;
2468 
2469 		drm_mode_probed_add(connector, mode);
2470 	}
2471 
2472 	drm_connector_list_update(connector);
2473 	/* Move the prefered mode first, help apps pick the right mode. */
2474 	drm_mode_sort(&connector->modes);
2475 
2476 	return 1;
2477 }
2478 
2479 /**
2480  * vmw_kms_update_layout_ioctl - Handler for DRM_VMW_UPDATE_LAYOUT ioctl
2481  * @dev: drm device for the ioctl
2482  * @data: data pointer for the ioctl
2483  * @file_priv: drm file for the ioctl call
2484  *
2485  * Update preferred topology of display unit as per ioctl request. The topology
2486  * is expressed as array of drm_vmw_rect.
2487  * e.g.
2488  * [0 0 640 480] [640 0 800 600] [0 480 640 480]
2489  *
2490  * NOTE:
2491  * The x and y offset (upper left) in drm_vmw_rect cannot be less than 0. Beside
2492  * device limit on topology, x + w and y + h (lower right) cannot be greater
2493  * than INT_MAX. So topology beyond these limits will return with error.
2494  *
2495  * Returns:
2496  * Zero on success, negative errno on failure.
2497  */
2498 int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
2499 				struct drm_file *file_priv)
2500 {
2501 	struct vmw_private *dev_priv = vmw_priv(dev);
2502 	struct drm_mode_config *mode_config = &dev->mode_config;
2503 	struct drm_vmw_update_layout_arg *arg =
2504 		(struct drm_vmw_update_layout_arg *)data;
2505 	void __user *user_rects;
2506 	struct drm_vmw_rect *rects;
2507 	struct drm_rect *drm_rects;
2508 	unsigned rects_size;
2509 	int ret, i;
2510 
2511 	if (!arg->num_outputs) {
2512 		struct drm_rect def_rect = {0, 0,
2513 					    VMWGFX_MIN_INITIAL_WIDTH,
2514 					    VMWGFX_MIN_INITIAL_HEIGHT};
2515 		vmw_du_update_layout(dev_priv, 1, &def_rect);
2516 		return 0;
2517 	}
2518 
2519 	rects_size = arg->num_outputs * sizeof(struct drm_vmw_rect);
2520 	rects = kcalloc(arg->num_outputs, sizeof(struct drm_vmw_rect),
2521 			GFP_KERNEL);
2522 	if (unlikely(!rects))
2523 		return -ENOMEM;
2524 
2525 	user_rects = (void __user *)(unsigned long)arg->rects;
2526 	ret = copy_from_user(rects, user_rects, rects_size);
2527 	if (unlikely(ret != 0)) {
2528 		DRM_ERROR("Failed to get rects.\n");
2529 		ret = -EFAULT;
2530 		goto out_free;
2531 	}
2532 
2533 	drm_rects = (struct drm_rect *)rects;
2534 
2535 	VMW_DEBUG_KMS("Layout count = %u\n", arg->num_outputs);
2536 	for (i = 0; i < arg->num_outputs; i++) {
2537 		struct drm_vmw_rect curr_rect;
2538 
2539 		/* Verify user-space for overflow as kernel use drm_rect */
2540 		if ((rects[i].x + rects[i].w > INT_MAX) ||
2541 		    (rects[i].y + rects[i].h > INT_MAX)) {
2542 			ret = -ERANGE;
2543 			goto out_free;
2544 		}
2545 
2546 		curr_rect = rects[i];
2547 		drm_rects[i].x1 = curr_rect.x;
2548 		drm_rects[i].y1 = curr_rect.y;
2549 		drm_rects[i].x2 = curr_rect.x + curr_rect.w;
2550 		drm_rects[i].y2 = curr_rect.y + curr_rect.h;
2551 
2552 		VMW_DEBUG_KMS("  x1 = %d y1 = %d x2 = %d y2 = %d\n",
2553 			      drm_rects[i].x1, drm_rects[i].y1,
2554 			      drm_rects[i].x2, drm_rects[i].y2);
2555 
2556 		/*
2557 		 * Currently this check is limiting the topology within
2558 		 * mode_config->max (which actually is max texture size
2559 		 * supported by virtual device). This limit is here to address
2560 		 * window managers that create a big framebuffer for whole
2561 		 * topology.
2562 		 */
2563 		if (drm_rects[i].x1 < 0 ||  drm_rects[i].y1 < 0 ||
2564 		    drm_rects[i].x2 > mode_config->max_width ||
2565 		    drm_rects[i].y2 > mode_config->max_height) {
2566 			VMW_DEBUG_KMS("Invalid layout %d %d %d %d\n",
2567 				      drm_rects[i].x1, drm_rects[i].y1,
2568 				      drm_rects[i].x2, drm_rects[i].y2);
2569 			ret = -EINVAL;
2570 			goto out_free;
2571 		}
2572 	}
2573 
2574 	ret = vmw_kms_check_display_memory(dev, arg->num_outputs, drm_rects);
2575 
2576 	if (ret == 0)
2577 		vmw_du_update_layout(dev_priv, arg->num_outputs, drm_rects);
2578 
2579 out_free:
2580 	kfree(rects);
2581 	return ret;
2582 }
2583 
2584 /**
2585  * vmw_kms_helper_dirty - Helper to build commands and perform actions based
2586  * on a set of cliprects and a set of display units.
2587  *
2588  * @dev_priv: Pointer to a device private structure.
2589  * @framebuffer: Pointer to the framebuffer on which to perform the actions.
2590  * @clips: A set of struct drm_clip_rect. Either this os @vclips must be NULL.
2591  * Cliprects are given in framebuffer coordinates.
2592  * @vclips: A set of struct drm_vmw_rect cliprects. Either this or @clips must
2593  * be NULL. Cliprects are given in source coordinates.
2594  * @dest_x: X coordinate offset for the crtc / destination clip rects.
2595  * @dest_y: Y coordinate offset for the crtc / destination clip rects.
2596  * @num_clips: Number of cliprects in the @clips or @vclips array.
2597  * @increment: Integer with which to increment the clip counter when looping.
2598  * Used to skip a predetermined number of clip rects.
2599  * @dirty: Closure structure. See the description of struct vmw_kms_dirty.
2600  */
2601 int vmw_kms_helper_dirty(struct vmw_private *dev_priv,
2602 			 struct vmw_framebuffer *framebuffer,
2603 			 const struct drm_clip_rect *clips,
2604 			 const struct drm_vmw_rect *vclips,
2605 			 s32 dest_x, s32 dest_y,
2606 			 int num_clips,
2607 			 int increment,
2608 			 struct vmw_kms_dirty *dirty)
2609 {
2610 	struct vmw_display_unit *units[VMWGFX_NUM_DISPLAY_UNITS];
2611 	struct drm_crtc *crtc;
2612 	u32 num_units = 0;
2613 	u32 i, k;
2614 
2615 	dirty->dev_priv = dev_priv;
2616 
2617 	/* If crtc is passed, no need to iterate over other display units */
2618 	if (dirty->crtc) {
2619 		units[num_units++] = vmw_crtc_to_du(dirty->crtc);
2620 	} else {
2621 		list_for_each_entry(crtc, &dev_priv->drm.mode_config.crtc_list,
2622 				    head) {
2623 			struct drm_plane *plane = crtc->primary;
2624 
2625 			if (plane->state->fb == &framebuffer->base)
2626 				units[num_units++] = vmw_crtc_to_du(crtc);
2627 		}
2628 	}
2629 
2630 	for (k = 0; k < num_units; k++) {
2631 		struct vmw_display_unit *unit = units[k];
2632 		s32 crtc_x = unit->crtc.x;
2633 		s32 crtc_y = unit->crtc.y;
2634 		s32 crtc_width = unit->crtc.mode.hdisplay;
2635 		s32 crtc_height = unit->crtc.mode.vdisplay;
2636 		const struct drm_clip_rect *clips_ptr = clips;
2637 		const struct drm_vmw_rect *vclips_ptr = vclips;
2638 
2639 		dirty->unit = unit;
2640 		if (dirty->fifo_reserve_size > 0) {
2641 			dirty->cmd = VMW_CMD_RESERVE(dev_priv,
2642 						      dirty->fifo_reserve_size);
2643 			if (!dirty->cmd)
2644 				return -ENOMEM;
2645 
2646 			memset(dirty->cmd, 0, dirty->fifo_reserve_size);
2647 		}
2648 		dirty->num_hits = 0;
2649 		for (i = 0; i < num_clips; i++, clips_ptr += increment,
2650 		       vclips_ptr += increment) {
2651 			s32 clip_left;
2652 			s32 clip_top;
2653 
2654 			/*
2655 			 * Select clip array type. Note that integer type
2656 			 * in @clips is unsigned short, whereas in @vclips
2657 			 * it's 32-bit.
2658 			 */
2659 			if (clips) {
2660 				dirty->fb_x = (s32) clips_ptr->x1;
2661 				dirty->fb_y = (s32) clips_ptr->y1;
2662 				dirty->unit_x2 = (s32) clips_ptr->x2 + dest_x -
2663 					crtc_x;
2664 				dirty->unit_y2 = (s32) clips_ptr->y2 + dest_y -
2665 					crtc_y;
2666 			} else {
2667 				dirty->fb_x = vclips_ptr->x;
2668 				dirty->fb_y = vclips_ptr->y;
2669 				dirty->unit_x2 = dirty->fb_x + vclips_ptr->w +
2670 					dest_x - crtc_x;
2671 				dirty->unit_y2 = dirty->fb_y + vclips_ptr->h +
2672 					dest_y - crtc_y;
2673 			}
2674 
2675 			dirty->unit_x1 = dirty->fb_x + dest_x - crtc_x;
2676 			dirty->unit_y1 = dirty->fb_y + dest_y - crtc_y;
2677 
2678 			/* Skip this clip if it's outside the crtc region */
2679 			if (dirty->unit_x1 >= crtc_width ||
2680 			    dirty->unit_y1 >= crtc_height ||
2681 			    dirty->unit_x2 <= 0 || dirty->unit_y2 <= 0)
2682 				continue;
2683 
2684 			/* Clip right and bottom to crtc limits */
2685 			dirty->unit_x2 = min_t(s32, dirty->unit_x2,
2686 					       crtc_width);
2687 			dirty->unit_y2 = min_t(s32, dirty->unit_y2,
2688 					       crtc_height);
2689 
2690 			/* Clip left and top to crtc limits */
2691 			clip_left = min_t(s32, dirty->unit_x1, 0);
2692 			clip_top = min_t(s32, dirty->unit_y1, 0);
2693 			dirty->unit_x1 -= clip_left;
2694 			dirty->unit_y1 -= clip_top;
2695 			dirty->fb_x -= clip_left;
2696 			dirty->fb_y -= clip_top;
2697 
2698 			dirty->clip(dirty);
2699 		}
2700 
2701 		dirty->fifo_commit(dirty);
2702 	}
2703 
2704 	return 0;
2705 }
2706 
2707 /**
2708  * vmw_kms_helper_validation_finish - Helper for post KMS command submission
2709  * cleanup and fencing
2710  * @dev_priv: Pointer to the device-private struct
2711  * @file_priv: Pointer identifying the client when user-space fencing is used
2712  * @ctx: Pointer to the validation context
2713  * @out_fence: If non-NULL, returned refcounted fence-pointer
2714  * @user_fence_rep: If non-NULL, pointer to user-space address area
2715  * in which to copy user-space fence info
2716  */
2717 void vmw_kms_helper_validation_finish(struct vmw_private *dev_priv,
2718 				      struct drm_file *file_priv,
2719 				      struct vmw_validation_context *ctx,
2720 				      struct vmw_fence_obj **out_fence,
2721 				      struct drm_vmw_fence_rep __user *
2722 				      user_fence_rep)
2723 {
2724 	struct vmw_fence_obj *fence = NULL;
2725 	uint32_t handle = 0;
2726 	int ret = 0;
2727 
2728 	if (file_priv || user_fence_rep || vmw_validation_has_bos(ctx) ||
2729 	    out_fence)
2730 		ret = vmw_execbuf_fence_commands(file_priv, dev_priv, &fence,
2731 						 file_priv ? &handle : NULL);
2732 	vmw_validation_done(ctx, fence);
2733 	if (file_priv)
2734 		vmw_execbuf_copy_fence_user(dev_priv, vmw_fpriv(file_priv),
2735 					    ret, user_fence_rep, fence,
2736 					    handle, -1);
2737 	if (out_fence)
2738 		*out_fence = fence;
2739 	else
2740 		vmw_fence_obj_unreference(&fence);
2741 }
2742 
2743 /**
2744  * vmw_kms_update_proxy - Helper function to update a proxy surface from
2745  * its backing MOB.
2746  *
2747  * @res: Pointer to the surface resource
2748  * @clips: Clip rects in framebuffer (surface) space.
2749  * @num_clips: Number of clips in @clips.
2750  * @increment: Integer with which to increment the clip counter when looping.
2751  * Used to skip a predetermined number of clip rects.
2752  *
2753  * This function makes sure the proxy surface is updated from its backing MOB
2754  * using the region given by @clips. The surface resource @res and its backing
2755  * MOB needs to be reserved and validated on call.
2756  */
2757 int vmw_kms_update_proxy(struct vmw_resource *res,
2758 			 const struct drm_clip_rect *clips,
2759 			 unsigned num_clips,
2760 			 int increment)
2761 {
2762 	struct vmw_private *dev_priv = res->dev_priv;
2763 	struct drm_vmw_size *size = &vmw_res_to_srf(res)->metadata.base_size;
2764 	struct {
2765 		SVGA3dCmdHeader header;
2766 		SVGA3dCmdUpdateGBImage body;
2767 	} *cmd;
2768 	SVGA3dBox *box;
2769 	size_t copy_size = 0;
2770 	int i;
2771 
2772 	if (!clips)
2773 		return 0;
2774 
2775 	cmd = VMW_CMD_RESERVE(dev_priv, sizeof(*cmd) * num_clips);
2776 	if (!cmd)
2777 		return -ENOMEM;
2778 
2779 	for (i = 0; i < num_clips; ++i, clips += increment, ++cmd) {
2780 		box = &cmd->body.box;
2781 
2782 		cmd->header.id = SVGA_3D_CMD_UPDATE_GB_IMAGE;
2783 		cmd->header.size = sizeof(cmd->body);
2784 		cmd->body.image.sid = res->id;
2785 		cmd->body.image.face = 0;
2786 		cmd->body.image.mipmap = 0;
2787 
2788 		if (clips->x1 > size->width || clips->x2 > size->width ||
2789 		    clips->y1 > size->height || clips->y2 > size->height) {
2790 			DRM_ERROR("Invalid clips outsize of framebuffer.\n");
2791 			return -EINVAL;
2792 		}
2793 
2794 		box->x = clips->x1;
2795 		box->y = clips->y1;
2796 		box->z = 0;
2797 		box->w = clips->x2 - clips->x1;
2798 		box->h = clips->y2 - clips->y1;
2799 		box->d = 1;
2800 
2801 		copy_size += sizeof(*cmd);
2802 	}
2803 
2804 	vmw_cmd_commit(dev_priv, copy_size);
2805 
2806 	return 0;
2807 }
2808 
2809 /**
2810  * vmw_kms_create_implicit_placement_property - Set up the implicit placement
2811  * property.
2812  *
2813  * @dev_priv: Pointer to a device private struct.
2814  *
2815  * Sets up the implicit placement property unless it's already set up.
2816  */
2817 void
2818 vmw_kms_create_implicit_placement_property(struct vmw_private *dev_priv)
2819 {
2820 	if (dev_priv->implicit_placement_property)
2821 		return;
2822 
2823 	dev_priv->implicit_placement_property =
2824 		drm_property_create_range(&dev_priv->drm,
2825 					  DRM_MODE_PROP_IMMUTABLE,
2826 					  "implicit_placement", 0, 1);
2827 }
2828 
2829 /**
2830  * vmw_kms_suspend - Save modesetting state and turn modesetting off.
2831  *
2832  * @dev: Pointer to the drm device
2833  * Return: 0 on success. Negative error code on failure.
2834  */
2835 int vmw_kms_suspend(struct drm_device *dev)
2836 {
2837 	struct vmw_private *dev_priv = vmw_priv(dev);
2838 
2839 	dev_priv->suspend_state = drm_atomic_helper_suspend(dev);
2840 	if (IS_ERR(dev_priv->suspend_state)) {
2841 		int ret = PTR_ERR(dev_priv->suspend_state);
2842 
2843 		DRM_ERROR("Failed kms suspend: %d\n", ret);
2844 		dev_priv->suspend_state = NULL;
2845 
2846 		return ret;
2847 	}
2848 
2849 	return 0;
2850 }
2851 
2852 
2853 /**
2854  * vmw_kms_resume - Re-enable modesetting and restore state
2855  *
2856  * @dev: Pointer to the drm device
2857  * Return: 0 on success. Negative error code on failure.
2858  *
2859  * State is resumed from a previous vmw_kms_suspend(). It's illegal
2860  * to call this function without a previous vmw_kms_suspend().
2861  */
2862 int vmw_kms_resume(struct drm_device *dev)
2863 {
2864 	struct vmw_private *dev_priv = vmw_priv(dev);
2865 	int ret;
2866 
2867 	if (WARN_ON(!dev_priv->suspend_state))
2868 		return 0;
2869 
2870 	ret = drm_atomic_helper_resume(dev, dev_priv->suspend_state);
2871 	dev_priv->suspend_state = NULL;
2872 
2873 	return ret;
2874 }
2875 
2876 /**
2877  * vmw_kms_lost_device - Notify kms that modesetting capabilities will be lost
2878  *
2879  * @dev: Pointer to the drm device
2880  */
2881 void vmw_kms_lost_device(struct drm_device *dev)
2882 {
2883 	drm_atomic_helper_shutdown(dev);
2884 }
2885 
2886 /**
2887  * vmw_du_helper_plane_update - Helper to do plane update on a display unit.
2888  * @update: The closure structure.
2889  *
2890  * Call this helper after setting callbacks in &vmw_du_update_plane to do plane
2891  * update on display unit.
2892  *
2893  * Return: 0 on success or a negative error code on failure.
2894  */
2895 int vmw_du_helper_plane_update(struct vmw_du_update_plane *update)
2896 {
2897 	struct drm_plane_state *state = update->plane->state;
2898 	struct drm_plane_state *old_state = update->old_state;
2899 	struct drm_atomic_helper_damage_iter iter;
2900 	struct drm_rect clip;
2901 	struct drm_rect bb;
2902 	DECLARE_VAL_CONTEXT(val_ctx, NULL, 0);
2903 	uint32_t reserved_size = 0;
2904 	uint32_t submit_size = 0;
2905 	uint32_t curr_size = 0;
2906 	uint32_t num_hits = 0;
2907 	void *cmd_start;
2908 	char *cmd_next;
2909 	int ret;
2910 
2911 	/*
2912 	 * Iterate in advance to check if really need plane update and find the
2913 	 * number of clips that actually are in plane src for fifo allocation.
2914 	 */
2915 	drm_atomic_helper_damage_iter_init(&iter, old_state, state);
2916 	drm_atomic_for_each_plane_damage(&iter, &clip)
2917 		num_hits++;
2918 
2919 	if (num_hits == 0)
2920 		return 0;
2921 
2922 	if (update->vfb->bo) {
2923 		struct vmw_framebuffer_bo *vfbbo =
2924 			container_of(update->vfb, typeof(*vfbbo), base);
2925 
2926 		/*
2927 		 * For screen targets we want a mappable bo, for everything else we want
2928 		 * accelerated i.e. host backed (vram or gmr) bo. If the display unit
2929 		 * is not screen target then mob's shouldn't be available.
2930 		 */
2931 		if (update->dev_priv->active_display_unit == vmw_du_screen_target) {
2932 			vmw_bo_placement_set(vfbbo->buffer,
2933 					     VMW_BO_DOMAIN_SYS | VMW_BO_DOMAIN_MOB | VMW_BO_DOMAIN_GMR,
2934 					     VMW_BO_DOMAIN_SYS | VMW_BO_DOMAIN_MOB | VMW_BO_DOMAIN_GMR);
2935 		} else {
2936 			WARN_ON(update->dev_priv->has_mob);
2937 			vmw_bo_placement_set_default_accelerated(vfbbo->buffer);
2938 		}
2939 		ret = vmw_validation_add_bo(&val_ctx, vfbbo->buffer);
2940 	} else {
2941 		struct vmw_framebuffer_surface *vfbs =
2942 			container_of(update->vfb, typeof(*vfbs), base);
2943 
2944 		ret = vmw_validation_add_resource(&val_ctx, &vfbs->surface->res,
2945 						  0, VMW_RES_DIRTY_NONE, NULL,
2946 						  NULL);
2947 	}
2948 
2949 	if (ret)
2950 		return ret;
2951 
2952 	ret = vmw_validation_prepare(&val_ctx, update->mutex, update->intr);
2953 	if (ret)
2954 		goto out_unref;
2955 
2956 	reserved_size = update->calc_fifo_size(update, num_hits);
2957 	cmd_start = VMW_CMD_RESERVE(update->dev_priv, reserved_size);
2958 	if (!cmd_start) {
2959 		ret = -ENOMEM;
2960 		goto out_revert;
2961 	}
2962 
2963 	cmd_next = cmd_start;
2964 
2965 	if (update->post_prepare) {
2966 		curr_size = update->post_prepare(update, cmd_next);
2967 		cmd_next += curr_size;
2968 		submit_size += curr_size;
2969 	}
2970 
2971 	if (update->pre_clip) {
2972 		curr_size = update->pre_clip(update, cmd_next, num_hits);
2973 		cmd_next += curr_size;
2974 		submit_size += curr_size;
2975 	}
2976 
2977 	bb.x1 = INT_MAX;
2978 	bb.y1 = INT_MAX;
2979 	bb.x2 = INT_MIN;
2980 	bb.y2 = INT_MIN;
2981 
2982 	drm_atomic_helper_damage_iter_init(&iter, old_state, state);
2983 	drm_atomic_for_each_plane_damage(&iter, &clip) {
2984 		uint32_t fb_x = clip.x1;
2985 		uint32_t fb_y = clip.y1;
2986 
2987 		vmw_du_translate_to_crtc(state, &clip);
2988 		if (update->clip) {
2989 			curr_size = update->clip(update, cmd_next, &clip, fb_x,
2990 						 fb_y);
2991 			cmd_next += curr_size;
2992 			submit_size += curr_size;
2993 		}
2994 		bb.x1 = min_t(int, bb.x1, clip.x1);
2995 		bb.y1 = min_t(int, bb.y1, clip.y1);
2996 		bb.x2 = max_t(int, bb.x2, clip.x2);
2997 		bb.y2 = max_t(int, bb.y2, clip.y2);
2998 	}
2999 
3000 	curr_size = update->post_clip(update, cmd_next, &bb);
3001 	submit_size += curr_size;
3002 
3003 	if (reserved_size < submit_size)
3004 		submit_size = 0;
3005 
3006 	vmw_cmd_commit(update->dev_priv, submit_size);
3007 
3008 	vmw_kms_helper_validation_finish(update->dev_priv, NULL, &val_ctx,
3009 					 update->out_fence, NULL);
3010 	return ret;
3011 
3012 out_revert:
3013 	vmw_validation_revert(&val_ctx);
3014 
3015 out_unref:
3016 	vmw_validation_unref_lists(&val_ctx);
3017 	return ret;
3018 }
3019