Linux Audio

Check our new training course

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