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