vmwgfx_kms.c

   1// SPDX-License-Identifier: GPL-2.0 OR MIT
   2/**************************************************************************
   3 *
   4 * Copyright (c) 2009-2025 Broadcom. All Rights Reserved. The term
   5 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
   6 *
   7 **************************************************************************/
   8
   9#include "vmwgfx_kms.h"
  10
  11#include "vmwgfx_bo.h"
  12#include "vmwgfx_resource_priv.h"
  13#include "vmwgfx_vkms.h"
  14#include "vmw_surface_cache.h"
  15
  16#include <drm/drm_atomic.h>
  17#include <drm/drm_atomic_helper.h>
  18#include <drm/drm_damage_helper.h>
  19#include <drm/drm_fourcc.h>
  20#include <drm/drm_rect.h>
  21#include <drm/drm_sysfs.h>
  22#include <drm/drm_edid.h>
  23
  24void vmw_du_init(struct vmw_display_unit *du)
  25{
  26	vmw_vkms_crtc_init(&du->crtc);
  27}
  28
  29void vmw_du_cleanup(struct vmw_display_unit *du)
  30{
  31	struct vmw_private *dev_priv = vmw_priv(du->primary.dev);
  32
  33	vmw_vkms_crtc_cleanup(&du->crtc);
  34	drm_plane_cleanup(&du->primary);
  35	if (vmw_cmd_supported(dev_priv))
  36		drm_plane_cleanup(&du->cursor.base);
  37
  38	drm_connector_unregister(&du->connector);
  39	drm_crtc_cleanup(&du->crtc);
  40	drm_encoder_cleanup(&du->encoder);
  41	drm_connector_cleanup(&du->connector);
  42}
  43
  44
  45void vmw_du_primary_plane_destroy(struct drm_plane *plane)
  46{
  47	drm_plane_cleanup(plane);
  48
  49	/* Planes are static in our case so we don't free it */
  50}
  51
  52
  53/**
  54 * vmw_du_plane_unpin_surf - unpins resource associated with a framebuffer surface
  55 *
  56 * @vps: plane state associated with the display surface
  57 */
  58void vmw_du_plane_unpin_surf(struct vmw_plane_state *vps)
  59{
  60	struct vmw_surface *surf = vmw_user_object_surface(&vps->uo);
  61
  62	if (surf) {
  63		if (vps->pinned) {
  64			vmw_resource_unpin(&surf->res);
  65			vps->pinned--;
  66		}
  67	}
  68}
  69
  70
  71/**
  72 * vmw_du_plane_cleanup_fb - Unpins the plane surface
  73 *
  74 * @plane:  display plane
  75 * @old_state: Contains the FB to clean up
  76 *
  77 * Unpins the framebuffer surface
  78 *
  79 * Returns 0 on success
  80 */
  81void
  82vmw_du_plane_cleanup_fb(struct drm_plane *plane,
  83			struct drm_plane_state *old_state)
  84{
  85	struct vmw_plane_state *vps = vmw_plane_state_to_vps(old_state);
  86
  87	vmw_du_plane_unpin_surf(vps);
  88}
  89
  90
  91/**
  92 * vmw_du_primary_plane_atomic_check - check if the new state is okay
  93 *
  94 * @plane: display plane
  95 * @state: info on the new plane state, including the FB
  96 *
  97 * Check if the new state is settable given the current state.  Other
  98 * than what the atomic helper checks, we care about crtc fitting
  99 * the FB and maintaining one active framebuffer.
 100 *
 101 * Returns 0 on success
 102 */
 103int vmw_du_primary_plane_atomic_check(struct drm_plane *plane,
 104				      struct drm_atomic_state *state)
 105{
 106	struct drm_plane_state *new_state = drm_atomic_get_new_plane_state(state,
 107									   plane);
 108	struct drm_plane_state *old_state = drm_atomic_get_old_plane_state(state,
 109									   plane);
 110	struct drm_crtc_state *crtc_state = NULL;
 111	struct drm_framebuffer *new_fb = new_state->fb;
 112	struct drm_framebuffer *old_fb = old_state->fb;
 113	int ret;
 114
 115	/*
 116	 * Ignore damage clips if the framebuffer attached to the plane's state
 117	 * has changed since the last plane update (page-flip). In this case, a
 118	 * full plane update should happen because uploads are done per-buffer.
 119	 */
 120	if (old_fb != new_fb)
 121		new_state->ignore_damage_clips = true;
 122
 123	if (new_state->crtc)
 124		crtc_state = drm_atomic_get_new_crtc_state(state,
 125							   new_state->crtc);
 126
 127	ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
 128						  DRM_PLANE_NO_SCALING,
 129						  DRM_PLANE_NO_SCALING,
 130						  false, true);
 131	return ret;
 132}
 133
 134int vmw_du_crtc_atomic_check(struct drm_crtc *crtc,
 135			     struct drm_atomic_state *state)
 136{
 137	struct vmw_private *vmw = vmw_priv(crtc->dev);
 138	struct drm_crtc_state *new_state = drm_atomic_get_new_crtc_state(state,
 139									 crtc);
 140	struct vmw_display_unit *du = vmw_crtc_to_du(new_state->crtc);
 141	int connector_mask = drm_connector_mask(&du->connector);
 142	bool has_primary = new_state->plane_mask &
 143			   drm_plane_mask(crtc->primary);
 144
 145	/*
 146	 * This is fine in general, but broken userspace might expect
 147	 * some actual rendering so give a clue as why it's blank.
 148	 */
 149	if (new_state->enable && !has_primary)
 150		drm_dbg_driver(&vmw->drm,
 151			       "CRTC without a primary plane will be blank.\n");
 152
 153
 154	if (new_state->connector_mask != connector_mask &&
 155	    new_state->connector_mask != 0) {
 156		DRM_ERROR("Invalid connectors configuration\n");
 157		return -EINVAL;
 158	}
 159
 160	/*
 161	 * Our virtual device does not have a dot clock, so use the logical
 162	 * clock value as the dot clock.
 163	 */
 164	if (new_state->mode.crtc_clock == 0)
 165		new_state->adjusted_mode.crtc_clock = new_state->mode.clock;
 166
 167	return 0;
 168}
 169
 170
 171void vmw_du_crtc_atomic_begin(struct drm_crtc *crtc,
 172			      struct drm_atomic_state *state)
 173{
 174	vmw_vkms_crtc_atomic_begin(crtc, state);
 175}
 176
 177/**
 178 * vmw_du_crtc_duplicate_state - duplicate crtc state
 179 * @crtc: DRM crtc
 180 *
 181 * Allocates and returns a copy of the crtc state (both common and
 182 * vmw-specific) for the specified crtc.
 183 *
 184 * Returns: The newly allocated crtc state, or NULL on failure.
 185 */
 186struct drm_crtc_state *
 187vmw_du_crtc_duplicate_state(struct drm_crtc *crtc)
 188{
 189	struct drm_crtc_state *state;
 190	struct vmw_crtc_state *vcs;
 191
 192	if (WARN_ON(!crtc->state))
 193		return NULL;
 194
 195	vcs = kmemdup(crtc->state, sizeof(*vcs), GFP_KERNEL);
 196
 197	if (!vcs)
 198		return NULL;
 199
 200	state = &vcs->base;
 201
 202	__drm_atomic_helper_crtc_duplicate_state(crtc, state);
 203
 204	return state;
 205}
 206
 207
 208/**
 209 * vmw_du_crtc_reset - creates a blank vmw crtc state
 210 * @crtc: DRM crtc
 211 *
 212 * Resets the atomic state for @crtc by freeing the state pointer (which
 213 * might be NULL, e.g. at driver load time) and allocating a new empty state
 214 * object.
 215 */
 216void vmw_du_crtc_reset(struct drm_crtc *crtc)
 217{
 218	struct vmw_crtc_state *vcs;
 219
 220
 221	if (crtc->state) {
 222		__drm_atomic_helper_crtc_destroy_state(crtc->state);
 223
 224		kfree(vmw_crtc_state_to_vcs(crtc->state));
 225	}
 226
 227	vcs = kzalloc(sizeof(*vcs), GFP_KERNEL);
 228
 229	if (!vcs) {
 230		DRM_ERROR("Cannot allocate vmw_crtc_state\n");
 231		return;
 232	}
 233
 234	__drm_atomic_helper_crtc_reset(crtc, &vcs->base);
 235}
 236
 237
 238/**
 239 * vmw_du_crtc_destroy_state - destroy crtc state
 240 * @crtc: DRM crtc
 241 * @state: state object to destroy
 242 *
 243 * Destroys the crtc state (both common and vmw-specific) for the
 244 * specified plane.
 245 */
 246void
 247vmw_du_crtc_destroy_state(struct drm_crtc *crtc,
 248			  struct drm_crtc_state *state)
 249{
 250	drm_atomic_helper_crtc_destroy_state(crtc, state);
 251}
 252
 253
 254/**
 255 * vmw_du_plane_duplicate_state - duplicate plane state
 256 * @plane: drm plane
 257 *
 258 * Allocates and returns a copy of the plane state (both common and
 259 * vmw-specific) for the specified plane.
 260 *
 261 * Returns: The newly allocated plane state, or NULL on failure.
 262 */
 263struct drm_plane_state *
 264vmw_du_plane_duplicate_state(struct drm_plane *plane)
 265{
 266	struct drm_plane_state *state;
 267	struct vmw_plane_state *vps;
 268
 269	vps = kmemdup(plane->state, sizeof(*vps), GFP_KERNEL);
 270
 271	if (!vps)
 272		return NULL;
 273
 274	vps->pinned = 0;
 275	vps->cpp = 0;
 276
 277	vps->cursor.mob = NULL;
 278
 279	/* Each ref counted resource needs to be acquired again */
 280	vmw_user_object_ref(&vps->uo);
 281	state = &vps->base;
 282
 283	__drm_atomic_helper_plane_duplicate_state(plane, state);
 284
 285	return state;
 286}
 287
 288
 289/**
 290 * vmw_du_plane_reset - creates a blank vmw plane state
 291 * @plane: drm plane
 292 *
 293 * Resets the atomic state for @plane by freeing the state pointer (which might
 294 * be NULL, e.g. at driver load time) and allocating a new empty state object.
 295 */
 296void vmw_du_plane_reset(struct drm_plane *plane)
 297{
 298	struct vmw_plane_state *vps;
 299
 300	if (plane->state)
 301		vmw_du_plane_destroy_state(plane, plane->state);
 302
 303	vps = kzalloc(sizeof(*vps), GFP_KERNEL);
 304
 305	if (!vps) {
 306		DRM_ERROR("Cannot allocate vmw_plane_state\n");
 307		return;
 308	}
 309
 310	__drm_atomic_helper_plane_reset(plane, &vps->base);
 311}
 312
 313
 314/**
 315 * vmw_du_plane_destroy_state - destroy plane state
 316 * @plane: DRM plane
 317 * @state: state object to destroy
 318 *
 319 * Destroys the plane state (both common and vmw-specific) for the
 320 * specified plane.
 321 */
 322void
 323vmw_du_plane_destroy_state(struct drm_plane *plane,
 324			   struct drm_plane_state *state)
 325{
 326	struct vmw_plane_state *vps = vmw_plane_state_to_vps(state);
 327
 328	/* Should have been freed by cleanup_fb */
 329	vmw_user_object_unref(&vps->uo);
 330
 331	drm_atomic_helper_plane_destroy_state(plane, state);
 332}
 333
 334
 335/**
 336 * vmw_du_connector_duplicate_state - duplicate connector state
 337 * @connector: DRM connector
 338 *
 339 * Allocates and returns a copy of the connector state (both common and
 340 * vmw-specific) for the specified connector.
 341 *
 342 * Returns: The newly allocated connector state, or NULL on failure.
 343 */
 344struct drm_connector_state *
 345vmw_du_connector_duplicate_state(struct drm_connector *connector)
 346{
 347	struct drm_connector_state *state;
 348	struct vmw_connector_state *vcs;
 349
 350	if (WARN_ON(!connector->state))
 351		return NULL;
 352
 353	vcs = kmemdup(connector->state, sizeof(*vcs), GFP_KERNEL);
 354
 355	if (!vcs)
 356		return NULL;
 357
 358	state = &vcs->base;
 359
 360	__drm_atomic_helper_connector_duplicate_state(connector, state);
 361
 362	return state;
 363}
 364
 365
 366/**
 367 * vmw_du_connector_reset - creates a blank vmw connector state
 368 * @connector: DRM connector
 369 *
 370 * Resets the atomic state for @connector by freeing the state pointer (which
 371 * might be NULL, e.g. at driver load time) and allocating a new empty state
 372 * object.
 373 */
 374void vmw_du_connector_reset(struct drm_connector *connector)
 375{
 376	struct vmw_connector_state *vcs;
 377
 378
 379	if (connector->state) {
 380		__drm_atomic_helper_connector_destroy_state(connector->state);
 381
 382		kfree(vmw_connector_state_to_vcs(connector->state));
 383	}
 384
 385	vcs = kzalloc(sizeof(*vcs), GFP_KERNEL);
 386
 387	if (!vcs) {
 388		DRM_ERROR("Cannot allocate vmw_connector_state\n");
 389		return;
 390	}
 391
 392	__drm_atomic_helper_connector_reset(connector, &vcs->base);
 393}
 394
 395
 396/**
 397 * vmw_du_connector_destroy_state - destroy connector state
 398 * @connector: DRM connector
 399 * @state: state object to destroy
 400 *
 401 * Destroys the connector state (both common and vmw-specific) for the
 402 * specified plane.
 403 */
 404void
 405vmw_du_connector_destroy_state(struct drm_connector *connector,
 406			  struct drm_connector_state *state)
 407{
 408	drm_atomic_helper_connector_destroy_state(connector, state);
 409}
 410/*
 411 * Generic framebuffer code
 412 */
 413
 414/*
 415 * Surface framebuffer code
 416 */
 417
 418static void vmw_framebuffer_surface_destroy(struct drm_framebuffer *framebuffer)
 419{
 420	struct vmw_framebuffer_surface *vfbs =
 421		vmw_framebuffer_to_vfbs(framebuffer);
 422	struct vmw_bo *bo = vmw_user_object_buffer(&vfbs->uo);
 423	struct vmw_surface *surf = vmw_user_object_surface(&vfbs->uo);
 424
 425	if (bo) {
 426		vmw_bo_dirty_release(bo);
 427		/*
 428		 * bo->dirty is reference counted so it being NULL
 429		 * means that the surface wasn't coherent to begin
 430		 * with and so we have to free the dirty tracker
 431		 * in the vmw_resource
 432		 */
 433		if (!bo->dirty && surf && surf->res.dirty)
 434			surf->res.func->dirty_free(&surf->res);
 435	}
 436	drm_framebuffer_cleanup(framebuffer);
 437	vmw_user_object_unref(&vfbs->uo);
 438
 439	kfree(vfbs);
 440}
 441
 442/**
 443 * vmw_kms_readback - Perform a readback from the screen system to
 444 * a buffer-object backed framebuffer.
 445 *
 446 * @dev_priv: Pointer to the device private structure.
 447 * @file_priv: Pointer to a struct drm_file identifying the caller.
 448 * Must be set to NULL if @user_fence_rep is NULL.
 449 * @vfb: Pointer to the buffer-object backed framebuffer.
 450 * @user_fence_rep: User-space provided structure for fence information.
 451 * Must be set to non-NULL if @file_priv is non-NULL.
 452 * @vclips: Array of clip rects.
 453 * @num_clips: Number of clip rects in @vclips.
 454 *
 455 * Returns 0 on success, negative error code on failure. -ERESTARTSYS if
 456 * interrupted.
 457 */
 458int vmw_kms_readback(struct vmw_private *dev_priv,
 459		     struct drm_file *file_priv,
 460		     struct vmw_framebuffer *vfb,
 461		     struct drm_vmw_fence_rep __user *user_fence_rep,
 462		     struct drm_vmw_rect *vclips,
 463		     uint32_t num_clips)
 464{
 465	switch (dev_priv->active_display_unit) {
 466	case vmw_du_screen_object:
 467		return vmw_kms_sou_readback(dev_priv, file_priv, vfb,
 468					    user_fence_rep, vclips, num_clips,
 469					    NULL);
 470	case vmw_du_screen_target:
 471		return vmw_kms_stdu_readback(dev_priv, file_priv, vfb,
 472					     user_fence_rep, NULL, vclips, num_clips,
 473					     1, NULL);
 474	default:
 475		WARN_ONCE(true,
 476			  "Readback called with invalid display system.\n");
 477}
 478
 479	return -ENOSYS;
 480}
 481
 482static int vmw_framebuffer_surface_create_handle(struct drm_framebuffer *fb,
 483						 struct drm_file *file_priv,
 484						 unsigned int *handle)
 485{
 486	struct vmw_framebuffer_surface *vfbs = vmw_framebuffer_to_vfbs(fb);
 487	struct vmw_bo *bo = vmw_user_object_buffer(&vfbs->uo);
 488
 489	if (WARN_ON(!bo))
 490		return -EINVAL;
 491	return drm_gem_handle_create(file_priv, &bo->tbo.base, handle);
 492}
 493
 494static const struct drm_framebuffer_funcs vmw_framebuffer_surface_funcs = {
 495	.create_handle = vmw_framebuffer_surface_create_handle,
 496	.destroy = vmw_framebuffer_surface_destroy,
 497	.dirty = drm_atomic_helper_dirtyfb,
 498};
 499
 500static int vmw_kms_new_framebuffer_surface(struct vmw_private *dev_priv,
 501					   struct vmw_user_object *uo,
 502					   struct vmw_framebuffer **out,
 503					   const struct drm_format_info *info,
 504					   const struct drm_mode_fb_cmd2
 505					   *mode_cmd)
 506
 507{
 508	struct drm_device *dev = &dev_priv->drm;
 509	struct vmw_framebuffer_surface *vfbs;
 510	struct vmw_surface *surface;
 511	int ret;
 512
 513	/* 3D is only supported on HWv8 and newer hosts */
 514	if (dev_priv->active_display_unit == vmw_du_legacy)
 515		return -ENOSYS;
 516
 517	surface = vmw_user_object_surface(uo);
 518
 519	/*
 520	 * Sanity checks.
 521	 */
 522
 523	if (!drm_any_plane_has_format(&dev_priv->drm,
 524				      mode_cmd->pixel_format,
 525				      mode_cmd->modifier[0])) {
 526		drm_dbg(&dev_priv->drm,
 527			"unsupported pixel format %p4cc / modifier 0x%llx\n",
 528			&mode_cmd->pixel_format, mode_cmd->modifier[0]);
 529		return -EINVAL;
 530	}
 531
 532	/* Surface must be marked as a scanout. */
 533	if (unlikely(!surface->metadata.scanout))
 534		return -EINVAL;
 535
 536	if (unlikely(surface->metadata.mip_levels[0] != 1 ||
 537		     surface->metadata.num_sizes != 1 ||
 538		     surface->metadata.base_size.width < mode_cmd->width ||
 539		     surface->metadata.base_size.height < mode_cmd->height ||
 540		     surface->metadata.base_size.depth != 1)) {
 541		DRM_ERROR("Incompatible surface dimensions "
 542			  "for requested mode.\n");
 543		return -EINVAL;
 544	}
 545
 546	vfbs = kzalloc(sizeof(*vfbs), GFP_KERNEL);
 547	if (!vfbs) {
 548		ret = -ENOMEM;
 549		goto out_err1;
 550	}
 551
 552	drm_helper_mode_fill_fb_struct(dev, &vfbs->base.base, info, mode_cmd);
 553	memcpy(&vfbs->uo, uo, sizeof(vfbs->uo));
 554	vmw_user_object_ref(&vfbs->uo);
 555
 556	if (vfbs->uo.buffer)
 557		vfbs->base.base.obj[0] = &vfbs->uo.buffer->tbo.base;
 558
 559	*out = &vfbs->base;
 560
 561	ret = drm_framebuffer_init(dev, &vfbs->base.base,
 562				   &vmw_framebuffer_surface_funcs);
 563	if (ret)
 564		goto out_err2;
 565
 566	return 0;
 567
 568out_err2:
 569	vmw_user_object_unref(&vfbs->uo);
 570	kfree(vfbs);
 571out_err1:
 572	return ret;
 573}
 574
 575/*
 576 * Buffer-object framebuffer code
 577 */
 578
 579static int vmw_framebuffer_bo_create_handle(struct drm_framebuffer *fb,
 580					    struct drm_file *file_priv,
 581					    unsigned int *handle)
 582{
 583	struct vmw_framebuffer_bo *vfbd =
 584			vmw_framebuffer_to_vfbd(fb);
 585	return drm_gem_handle_create(file_priv, &vfbd->buffer->tbo.base, handle);
 586}
 587
 588static void vmw_framebuffer_bo_destroy(struct drm_framebuffer *framebuffer)
 589{
 590	struct vmw_framebuffer_bo *vfbd =
 591		vmw_framebuffer_to_vfbd(framebuffer);
 592
 593	vmw_bo_dirty_release(vfbd->buffer);
 594	drm_framebuffer_cleanup(framebuffer);
 595	vmw_bo_unreference(&vfbd->buffer);
 596
 597	kfree(vfbd);
 598}
 599
 600static const struct drm_framebuffer_funcs vmw_framebuffer_bo_funcs = {
 601	.create_handle = vmw_framebuffer_bo_create_handle,
 602	.destroy = vmw_framebuffer_bo_destroy,
 603	.dirty = drm_atomic_helper_dirtyfb,
 604};
 605
 606static int vmw_kms_new_framebuffer_bo(struct vmw_private *dev_priv,
 607				      struct vmw_bo *bo,
 608				      struct vmw_framebuffer **out,
 609				      const struct drm_format_info *info,
 610				      const struct drm_mode_fb_cmd2
 611				      *mode_cmd)
 612
 613{
 614	struct drm_device *dev = &dev_priv->drm;
 615	struct vmw_framebuffer_bo *vfbd;
 616	unsigned int requested_size;
 617	int ret;
 618
 619	requested_size = mode_cmd->height * mode_cmd->pitches[0];
 620	if (unlikely(requested_size > bo->tbo.base.size)) {
 621		DRM_ERROR("Screen buffer object size is too small "
 622			  "for requested mode.\n");
 623		return -EINVAL;
 624	}
 625
 626	if (!drm_any_plane_has_format(&dev_priv->drm,
 627				      mode_cmd->pixel_format,
 628				      mode_cmd->modifier[0])) {
 629		drm_dbg(&dev_priv->drm,
 630			"unsupported pixel format %p4cc / modifier 0x%llx\n",
 631			&mode_cmd->pixel_format, mode_cmd->modifier[0]);
 632		return -EINVAL;
 633	}
 634
 635	vfbd = kzalloc(sizeof(*vfbd), GFP_KERNEL);
 636	if (!vfbd) {
 637		ret = -ENOMEM;
 638		goto out_err1;
 639	}
 640
 641	vfbd->base.base.obj[0] = &bo->tbo.base;
 642	drm_helper_mode_fill_fb_struct(dev, &vfbd->base.base, info, mode_cmd);
 643	vfbd->base.bo = true;
 644	vfbd->buffer = vmw_bo_reference(bo);
 645	*out = &vfbd->base;
 646
 647	ret = drm_framebuffer_init(dev, &vfbd->base.base,
 648				   &vmw_framebuffer_bo_funcs);
 649	if (ret)
 650		goto out_err2;
 651
 652	return 0;
 653
 654out_err2:
 655	vmw_bo_unreference(&bo);
 656	kfree(vfbd);
 657out_err1:
 658	return ret;
 659}
 660
 661
 662/**
 663 * vmw_kms_srf_ok - check if a surface can be created
 664 *
 665 * @dev_priv: Pointer to device private struct.
 666 * @width: requested width
 667 * @height: requested height
 668 *
 669 * Surfaces need to be less than texture size
 670 */
 671static bool
 672vmw_kms_srf_ok(struct vmw_private *dev_priv, uint32_t width, uint32_t height)
 673{
 674	if (width  > dev_priv->texture_max_width ||
 675	    height > dev_priv->texture_max_height)
 676		return false;
 677
 678	return true;
 679}
 680
 681/**
 682 * vmw_kms_new_framebuffer - Create a new framebuffer.
 683 *
 684 * @dev_priv: Pointer to device private struct.
 685 * @uo: Pointer to user object to wrap the kms framebuffer around.
 686 * Either the buffer or surface inside the user object must be NULL.
 687 * @info: pixel format information.
 688 * @mode_cmd: Frame-buffer metadata.
 689 */
 690struct vmw_framebuffer *
 691vmw_kms_new_framebuffer(struct vmw_private *dev_priv,
 692			struct vmw_user_object *uo,
 693			const struct drm_format_info *info,
 694			const struct drm_mode_fb_cmd2 *mode_cmd)
 695{
 696	struct vmw_framebuffer *vfb = NULL;
 697	int ret;
 698
 699	/* Create the new framebuffer depending one what we have */
 700	if (vmw_user_object_surface(uo)) {
 701		ret = vmw_kms_new_framebuffer_surface(dev_priv, uo, &vfb,
 702						      info, mode_cmd);
 703	} else if (uo->buffer) {
 704		ret = vmw_kms_new_framebuffer_bo(dev_priv, uo->buffer, &vfb,
 705						 info, mode_cmd);
 706	} else {
 707		BUG();
 708	}
 709
 710	if (ret)
 711		return ERR_PTR(ret);
 712
 713	return vfb;
 714}
 715
 716/*
 717 * Generic Kernel modesetting functions
 718 */
 719
 720static struct drm_framebuffer *vmw_kms_fb_create(struct drm_device *dev,
 721						 struct drm_file *file_priv,
 722						 const struct drm_format_info *info,
 723						 const struct drm_mode_fb_cmd2 *mode_cmd)
 724{
 725	struct vmw_private *dev_priv = vmw_priv(dev);
 726	struct vmw_framebuffer *vfb = NULL;
 727	struct vmw_user_object uo = {0};
 728	struct vmw_bo *bo;
 729	struct vmw_surface *surface;
 730	int ret;
 731
 732	/* returns either a bo or surface */
 733	ret = vmw_user_object_lookup(dev_priv, file_priv, mode_cmd->handles[0],
 734				     &uo);
 735	if (ret) {
 736		DRM_ERROR("Invalid buffer object handle %u (0x%x).\n",
 737			  mode_cmd->handles[0], mode_cmd->handles[0]);
 738		goto err_out;
 739	}
 740
 741
 742	if (vmw_user_object_surface(&uo) &&
 743	    !vmw_kms_srf_ok(dev_priv, mode_cmd->width, mode_cmd->height)) {
 744		DRM_ERROR("Surface size cannot exceed %dx%d\n",
 745			dev_priv->texture_max_width,
 746			dev_priv->texture_max_height);
 747		ret = -EINVAL;
 748		goto err_out;
 749	}
 750
 751
 752	vfb = vmw_kms_new_framebuffer(dev_priv, &uo, info, mode_cmd);
 753	if (IS_ERR(vfb)) {
 754		ret = PTR_ERR(vfb);
 755		goto err_out;
 756	}
 757
 758err_out:
 759	bo = vmw_user_object_buffer(&uo);
 760	surface = vmw_user_object_surface(&uo);
 761	/* vmw_user_object_lookup takes one ref so does new_fb */
 762	vmw_user_object_unref(&uo);
 763
 764	if (ret) {
 765		DRM_ERROR("failed to create vmw_framebuffer: %i\n", ret);
 766		return ERR_PTR(ret);
 767	}
 768
 769	if (bo) {
 770		ttm_bo_reserve(&bo->tbo, false, false, NULL);
 771		ret = vmw_bo_dirty_add(bo);
 772		if (!ret && surface && surface->res.func->dirty_alloc) {
 773			surface->res.coherent = true;
 774			if (surface->res.dirty == NULL)
 775				ret = surface->res.func->dirty_alloc(&surface->res);
 776		}
 777		ttm_bo_unreserve(&bo->tbo);
 778	}
 779
 780	return &vfb->base;
 781}
 782
 783/**
 784 * vmw_kms_check_display_memory - Validates display memory required for a
 785 * topology
 786 * @dev: DRM device
 787 * @num_rects: number of drm_rect in rects
 788 * @rects: array of drm_rect representing the topology to validate indexed by
 789 * crtc index.
 790 *
 791 * Returns:
 792 * 0 on success otherwise negative error code
 793 */
 794static int vmw_kms_check_display_memory(struct drm_device *dev,
 795					uint32_t num_rects,
 796					struct drm_rect *rects)
 797{
 798	struct vmw_private *dev_priv = vmw_priv(dev);
 799	struct drm_rect bounding_box = {0};
 800	u64 total_pixels = 0, pixel_mem, bb_mem;
 801	int i;
 802
 803	for (i = 0; i < num_rects; i++) {
 804		/*
 805		 * For STDU only individual screen (screen target) is limited by
 806		 * SCREENTARGET_MAX_WIDTH/HEIGHT registers.
 807		 */
 808		if (dev_priv->active_display_unit == vmw_du_screen_target &&
 809		    (drm_rect_width(&rects[i]) > dev_priv->stdu_max_width ||
 810		     drm_rect_height(&rects[i]) > dev_priv->stdu_max_height)) {
 811			VMW_DEBUG_KMS("Screen size not supported.\n");
 812			return -EINVAL;
 813		}
 814
 815		/* Bounding box upper left is at (0,0). */
 816		if (rects[i].x2 > bounding_box.x2)
 817			bounding_box.x2 = rects[i].x2;
 818
 819		if (rects[i].y2 > bounding_box.y2)
 820			bounding_box.y2 = rects[i].y2;
 821
 822		total_pixels += (u64) drm_rect_width(&rects[i]) *
 823			(u64) drm_rect_height(&rects[i]);
 824	}
 825
 826	/* Virtual svga device primary limits are always in 32-bpp. */
 827	pixel_mem = total_pixels * 4;
 828
 829	/*
 830	 * For HV10 and below prim_bb_mem is vram size. When
 831	 * SVGA_REG_MAX_PRIMARY_BOUNDING_BOX_MEM is not present vram size is
 832	 * limit on primary bounding box
 833	 */
 834	if (pixel_mem > dev_priv->max_primary_mem) {
 835		VMW_DEBUG_KMS("Combined output size too large.\n");
 836		return -EINVAL;
 837	}
 838
 839	/* SVGA_CAP_NO_BB_RESTRICTION is available for STDU only. */
 840	if (dev_priv->active_display_unit != vmw_du_screen_target ||
 841	    !(dev_priv->capabilities & SVGA_CAP_NO_BB_RESTRICTION)) {
 842		bb_mem = (u64) bounding_box.x2 * bounding_box.y2 * 4;
 843
 844		if (bb_mem > dev_priv->max_primary_mem) {
 845			VMW_DEBUG_KMS("Topology is beyond supported limits.\n");
 846			return -EINVAL;
 847		}
 848	}
 849
 850	return 0;
 851}
 852
 853/**
 854 * vmw_crtc_state_and_lock - Return new or current crtc state with locked
 855 * crtc mutex
 856 * @state: The atomic state pointer containing the new atomic state
 857 * @crtc: The crtc
 858 *
 859 * This function returns the new crtc state if it's part of the state update.
 860 * Otherwise returns the current crtc state. It also makes sure that the
 861 * crtc mutex is locked.
 862 *
 863 * Returns: A valid crtc state pointer or NULL. It may also return a
 864 * pointer error, in particular -EDEADLK if locking needs to be rerun.
 865 */
 866static struct drm_crtc_state *
 867vmw_crtc_state_and_lock(struct drm_atomic_state *state, struct drm_crtc *crtc)
 868{
 869	struct drm_crtc_state *crtc_state;
 870
 871	crtc_state = drm_atomic_get_new_crtc_state(state, crtc);
 872	if (crtc_state) {
 873		lockdep_assert_held(&crtc->mutex.mutex.base);
 874	} else {
 875		int ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
 876
 877		if (ret != 0 && ret != -EALREADY)
 878			return ERR_PTR(ret);
 879
 880		crtc_state = crtc->state;
 881	}
 882
 883	return crtc_state;
 884}
 885
 886/**
 887 * vmw_kms_check_implicit - Verify that all implicit display units scan out
 888 * from the same fb after the new state is committed.
 889 * @dev: The drm_device.
 890 * @state: The new state to be checked.
 891 *
 892 * Returns:
 893 *   Zero on success,
 894 *   -EINVAL on invalid state,
 895 *   -EDEADLK if modeset locking needs to be rerun.
 896 */
 897static int vmw_kms_check_implicit(struct drm_device *dev,
 898				  struct drm_atomic_state *state)
 899{
 900	struct drm_framebuffer *implicit_fb = NULL;
 901	struct drm_crtc *crtc;
 902	struct drm_crtc_state *crtc_state;
 903	struct drm_plane_state *plane_state;
 904
 905	drm_for_each_crtc(crtc, dev) {
 906		struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
 907
 908		if (!du->is_implicit)
 909			continue;
 910
 911		crtc_state = vmw_crtc_state_and_lock(state, crtc);
 912		if (IS_ERR(crtc_state))
 913			return PTR_ERR(crtc_state);
 914
 915		if (!crtc_state || !crtc_state->enable)
 916			continue;
 917
 918		/*
 919		 * Can't move primary planes across crtcs, so this is OK.
 920		 * It also means we don't need to take the plane mutex.
 921		 */
 922		plane_state = du->primary.state;
 923		if (plane_state->crtc != crtc)
 924			continue;
 925
 926		if (!implicit_fb)
 927			implicit_fb = plane_state->fb;
 928		else if (implicit_fb != plane_state->fb)
 929			return -EINVAL;
 930	}
 931
 932	return 0;
 933}
 934
 935/**
 936 * vmw_kms_check_topology - Validates topology in drm_atomic_state
 937 * @dev: DRM device
 938 * @state: the driver state object
 939 *
 940 * Returns:
 941 * 0 on success otherwise negative error code
 942 */
 943static int vmw_kms_check_topology(struct drm_device *dev,
 944				  struct drm_atomic_state *state)
 945{
 946	struct drm_crtc_state *old_crtc_state, *new_crtc_state;
 947	struct drm_rect *rects;
 948	struct drm_crtc *crtc;
 949	uint32_t i;
 950	int ret = 0;
 951
 952	rects = kcalloc(dev->mode_config.num_crtc, sizeof(struct drm_rect),
 953			GFP_KERNEL);
 954	if (!rects)
 955		return -ENOMEM;
 956
 957	drm_for_each_crtc(crtc, dev) {
 958		struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
 959		struct drm_crtc_state *crtc_state;
 960
 961		i = drm_crtc_index(crtc);
 962
 963		crtc_state = vmw_crtc_state_and_lock(state, crtc);
 964		if (IS_ERR(crtc_state)) {
 965			ret = PTR_ERR(crtc_state);
 966			goto clean;
 967		}
 968
 969		if (!crtc_state)
 970			continue;
 971
 972		if (crtc_state->enable) {
 973			rects[i].x1 = du->gui_x;
 974			rects[i].y1 = du->gui_y;
 975			rects[i].x2 = du->gui_x + crtc_state->mode.hdisplay;
 976			rects[i].y2 = du->gui_y + crtc_state->mode.vdisplay;
 977		} else {
 978			rects[i].x1 = 0;
 979			rects[i].y1 = 0;
 980			rects[i].x2 = 0;
 981			rects[i].y2 = 0;
 982		}
 983	}
 984
 985	/* Determine change to topology due to new atomic state */
 986	for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state,
 987				      new_crtc_state, i) {
 988		struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
 989		struct drm_connector *connector;
 990		struct drm_connector_state *conn_state;
 991		struct vmw_connector_state *vmw_conn_state;
 992
 993		if (!du->pref_active && new_crtc_state->enable) {
 994			VMW_DEBUG_KMS("Enabling a disabled display unit\n");
 995			ret = -EINVAL;
 996			goto clean;
 997		}
 998
 999		/*
1000		 * For vmwgfx each crtc has only one connector attached and it
1001		 * is not changed so don't really need to check the
1002		 * crtc->connector_mask and iterate over it.
1003		 */
1004		connector = &du->connector;
1005		conn_state = drm_atomic_get_connector_state(state, connector);
1006		if (IS_ERR(conn_state)) {
1007			ret = PTR_ERR(conn_state);
1008			goto clean;
1009		}
1010
1011		vmw_conn_state = vmw_connector_state_to_vcs(conn_state);
1012		vmw_conn_state->gui_x = du->gui_x;
1013		vmw_conn_state->gui_y = du->gui_y;
1014	}
1015
1016	ret = vmw_kms_check_display_memory(dev, dev->mode_config.num_crtc,
1017					   rects);
1018
1019clean:
1020	kfree(rects);
1021	return ret;
1022}
1023
1024/**
1025 * vmw_kms_atomic_check_modeset- validate state object for modeset changes
1026 *
1027 * @dev: DRM device
1028 * @state: the driver state object
1029 *
1030 * This is a simple wrapper around drm_atomic_helper_check_modeset() for
1031 * us to assign a value to mode->crtc_clock so that
1032 * drm_calc_timestamping_constants() won't throw an error message
1033 *
1034 * Returns:
1035 * Zero for success or -errno
1036 */
1037static int
1038vmw_kms_atomic_check_modeset(struct drm_device *dev,
1039			     struct drm_atomic_state *state)
1040{
1041	struct drm_crtc *crtc;
1042	struct drm_crtc_state *crtc_state;
1043	bool need_modeset = false;
1044	int i, ret;
1045
1046	ret = drm_atomic_helper_check(dev, state);
1047	if (ret)
1048		return ret;
1049
1050	ret = vmw_kms_check_implicit(dev, state);
1051	if (ret) {
1052		VMW_DEBUG_KMS("Invalid implicit state\n");
1053		return ret;
1054	}
1055
1056	for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
1057		if (drm_atomic_crtc_needs_modeset(crtc_state))
1058			need_modeset = true;
1059	}
1060
1061	if (need_modeset)
1062		return vmw_kms_check_topology(dev, state);
1063
1064	return ret;
1065}
1066
1067static const struct drm_mode_config_funcs vmw_kms_funcs = {
1068	.fb_create = vmw_kms_fb_create,
1069	.atomic_check = vmw_kms_atomic_check_modeset,
1070	.atomic_commit = drm_atomic_helper_commit,
1071};
1072
1073static int vmw_kms_generic_present(struct vmw_private *dev_priv,
1074				   struct drm_file *file_priv,
1075				   struct vmw_framebuffer *vfb,
1076				   struct vmw_surface *surface,
1077				   uint32_t sid,
1078				   int32_t destX, int32_t destY,
1079				   struct drm_vmw_rect *clips,
1080				   uint32_t num_clips)
1081{
1082	return vmw_kms_sou_do_surface_dirty(dev_priv, vfb, NULL, clips,
1083					    &surface->res, destX, destY,
1084					    num_clips, 1, NULL, NULL);
1085}
1086
1087
1088int vmw_kms_present(struct vmw_private *dev_priv,
1089		    struct drm_file *file_priv,
1090		    struct vmw_framebuffer *vfb,
1091		    struct vmw_surface *surface,
1092		    uint32_t sid,
1093		    int32_t destX, int32_t destY,
1094		    struct drm_vmw_rect *clips,
1095		    uint32_t num_clips)
1096{
1097	int ret;
1098
1099	switch (dev_priv->active_display_unit) {
1100	case vmw_du_screen_target:
1101		ret = vmw_kms_stdu_surface_dirty(dev_priv, vfb, NULL, clips,
1102						 &surface->res, destX, destY,
1103						 num_clips, 1, NULL, NULL);
1104		break;
1105	case vmw_du_screen_object:
1106		ret = vmw_kms_generic_present(dev_priv, file_priv, vfb, surface,
1107					      sid, destX, destY, clips,
1108					      num_clips);
1109		break;
1110	default:
1111		WARN_ONCE(true,
1112			  "Present called with invalid display system.\n");
1113		ret = -ENOSYS;
1114		break;
1115	}
1116	if (ret)
1117		return ret;
1118
1119	vmw_cmd_flush(dev_priv, false);
1120
1121	return 0;
1122}
1123
1124static void
1125vmw_kms_create_hotplug_mode_update_property(struct vmw_private *dev_priv)
1126{
1127	if (dev_priv->hotplug_mode_update_property)
1128		return;
1129
1130	dev_priv->hotplug_mode_update_property =
1131		drm_property_create_range(&dev_priv->drm,
1132					  DRM_MODE_PROP_IMMUTABLE,
1133					  "hotplug_mode_update", 0, 1);
1134}
1135
1136static void
1137vmw_atomic_commit_tail(struct drm_atomic_state *old_state)
1138{
1139	struct vmw_private *vmw = vmw_priv(old_state->dev);
1140	struct drm_crtc *crtc;
1141	struct drm_crtc_state *old_crtc_state;
1142	int i;
1143
1144	drm_atomic_helper_commit_tail(old_state);
1145
1146	if (vmw->vkms_enabled) {
1147		for_each_old_crtc_in_state(old_state, crtc, old_crtc_state, i) {
1148			struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
1149			(void)old_crtc_state;
1150			flush_work(&du->vkms.crc_generator_work);
1151		}
1152	}
1153}
1154
1155static const struct drm_mode_config_helper_funcs vmw_mode_config_helpers = {
1156	.atomic_commit_tail = vmw_atomic_commit_tail,
1157};
1158
1159int vmw_kms_init(struct vmw_private *dev_priv)
1160{
1161	struct drm_device *dev = &dev_priv->drm;
1162	int ret;
1163	static const char *display_unit_names[] = {
1164		"Invalid",
1165		"Legacy",
1166		"Screen Object",
1167		"Screen Target",
1168		"Invalid (max)"
1169	};
1170
1171	drm_mode_config_init(dev);
1172	dev->mode_config.funcs = &vmw_kms_funcs;
1173	dev->mode_config.min_width = 1;
1174	dev->mode_config.min_height = 1;
1175	dev->mode_config.max_width = dev_priv->texture_max_width;
1176	dev->mode_config.max_height = dev_priv->texture_max_height;
1177	dev->mode_config.preferred_depth = dev_priv->assume_16bpp ? 16 : 32;
1178	dev->mode_config.helper_private = &vmw_mode_config_helpers;
1179
1180	drm_mode_create_suggested_offset_properties(dev);
1181	vmw_kms_create_hotplug_mode_update_property(dev_priv);
1182
1183	ret = vmw_kms_stdu_init_display(dev_priv);
1184	if (ret) {
1185		ret = vmw_kms_sou_init_display(dev_priv);
1186		if (ret) /* Fallback */
1187			ret = vmw_kms_ldu_init_display(dev_priv);
1188	}
1189	BUILD_BUG_ON(ARRAY_SIZE(display_unit_names) != (vmw_du_max + 1));
1190	drm_info(&dev_priv->drm, "%s display unit initialized\n",
1191		 display_unit_names[dev_priv->active_display_unit]);
1192
1193	return ret;
1194}
1195
1196int vmw_kms_close(struct vmw_private *dev_priv)
1197{
1198	int ret = 0;
1199
1200	/*
1201	 * Docs says we should take the lock before calling this function
1202	 * but since it destroys encoders and our destructor calls
1203	 * drm_encoder_cleanup which takes the lock we deadlock.
1204	 */
1205	drm_mode_config_cleanup(&dev_priv->drm);
1206	if (dev_priv->active_display_unit == vmw_du_legacy)
1207		ret = vmw_kms_ldu_close_display(dev_priv);
1208
1209	return ret;
1210}
1211
1212int vmw_kms_write_svga(struct vmw_private *vmw_priv,
1213			unsigned width, unsigned height, unsigned pitch,
1214			unsigned bpp, unsigned depth)
1215{
1216	if (vmw_priv->capabilities & SVGA_CAP_PITCHLOCK)
1217		vmw_write(vmw_priv, SVGA_REG_PITCHLOCK, pitch);
1218	else if (vmw_fifo_have_pitchlock(vmw_priv))
1219		vmw_fifo_mem_write(vmw_priv, SVGA_FIFO_PITCHLOCK, pitch);
1220	vmw_write(vmw_priv, SVGA_REG_WIDTH, width);
1221	vmw_write(vmw_priv, SVGA_REG_HEIGHT, height);
1222	if ((vmw_priv->capabilities & SVGA_CAP_8BIT_EMULATION) != 0)
1223		vmw_write(vmw_priv, SVGA_REG_BITS_PER_PIXEL, bpp);
1224
1225	if (vmw_read(vmw_priv, SVGA_REG_DEPTH) != depth) {
1226		DRM_ERROR("Invalid depth %u for %u bpp, host expects %u\n",
1227			  depth, bpp, vmw_read(vmw_priv, SVGA_REG_DEPTH));
1228		return -EINVAL;
1229	}
1230
1231	return 0;
1232}
1233
1234static
1235bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
1236				u64 pitch,
1237				u64 height)
1238{
1239	return (pitch * height) < (u64)dev_priv->vram_size;
1240}
1241
1242/**
1243 * vmw_du_update_layout - Update the display unit with topology from resolution
1244 * plugin and generate DRM uevent
1245 * @dev_priv: device private
1246 * @num_rects: number of drm_rect in rects
1247 * @rects: toplogy to update
1248 */
1249static int vmw_du_update_layout(struct vmw_private *dev_priv,
1250				unsigned int num_rects, struct drm_rect *rects)
1251{
1252	struct drm_device *dev = &dev_priv->drm;
1253	struct vmw_display_unit *du;
1254	struct drm_connector *con;
1255	struct drm_connector_list_iter conn_iter;
1256	struct drm_modeset_acquire_ctx ctx;
1257	struct drm_crtc *crtc;
1258	int ret;
1259
1260	/* Currently gui_x/y is protected with the crtc mutex */
1261	mutex_lock(&dev->mode_config.mutex);
1262	drm_modeset_acquire_init(&ctx, 0);
1263retry:
1264	drm_for_each_crtc(crtc, dev) {
1265		ret = drm_modeset_lock(&crtc->mutex, &ctx);
1266		if (ret < 0) {
1267			if (ret == -EDEADLK) {
1268				drm_modeset_backoff(&ctx);
1269				goto retry;
1270		}
1271			goto out_fini;
1272		}
1273	}
1274
1275	drm_connector_list_iter_begin(dev, &conn_iter);
1276	drm_for_each_connector_iter(con, &conn_iter) {
1277		du = vmw_connector_to_du(con);
1278		if (num_rects > du->unit) {
1279			du->pref_width = drm_rect_width(&rects[du->unit]);
1280			du->pref_height = drm_rect_height(&rects[du->unit]);
1281			du->pref_active = true;
1282			du->gui_x = rects[du->unit].x1;
1283			du->gui_y = rects[du->unit].y1;
1284		} else {
1285			du->pref_width  = VMWGFX_MIN_INITIAL_WIDTH;
1286			du->pref_height = VMWGFX_MIN_INITIAL_HEIGHT;
1287			du->pref_active = false;
1288			du->gui_x = 0;
1289			du->gui_y = 0;
1290		}
1291	}
1292	drm_connector_list_iter_end(&conn_iter);
1293
1294	list_for_each_entry(con, &dev->mode_config.connector_list, head) {
1295		du = vmw_connector_to_du(con);
1296		if (num_rects > du->unit) {
1297			drm_object_property_set_value
1298			  (&con->base, dev->mode_config.suggested_x_property,
1299			   du->gui_x);
1300			drm_object_property_set_value
1301			  (&con->base, dev->mode_config.suggested_y_property,
1302			   du->gui_y);
1303		} else {
1304			drm_object_property_set_value
1305			  (&con->base, dev->mode_config.suggested_x_property,
1306			   0);
1307			drm_object_property_set_value
1308			  (&con->base, dev->mode_config.suggested_y_property,
1309			   0);
1310		}
1311		con->status = vmw_du_connector_detect(con, true);
1312	}
1313out_fini:
1314	drm_modeset_drop_locks(&ctx);
1315	drm_modeset_acquire_fini(&ctx);
1316	mutex_unlock(&dev->mode_config.mutex);
1317
1318	drm_sysfs_hotplug_event(dev);
1319
1320	return 0;
1321}
1322
1323int vmw_du_crtc_gamma_set(struct drm_crtc *crtc,
1324			  u16 *r, u16 *g, u16 *b,
1325			  uint32_t size,
1326			  struct drm_modeset_acquire_ctx *ctx)
1327{
1328	struct vmw_private *dev_priv = vmw_priv(crtc->dev);
1329	int i;
1330
1331	for (i = 0; i < size; i++) {
1332		DRM_DEBUG("%d r/g/b = 0x%04x / 0x%04x / 0x%04x\n", i,
1333			  r[i], g[i], b[i]);
1334		vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 0, r[i] >> 8);
1335		vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 1, g[i] >> 8);
1336		vmw_write(dev_priv, SVGA_PALETTE_BASE + i * 3 + 2, b[i] >> 8);
1337	}
1338
1339	return 0;
1340}
1341
1342int vmw_du_connector_dpms(struct drm_connector *connector, int mode)
1343{
1344	return 0;
1345}
1346
1347enum drm_connector_status
1348vmw_du_connector_detect(struct drm_connector *connector, bool force)
1349{
1350	uint32_t num_displays;
1351	struct drm_device *dev = connector->dev;
1352	struct vmw_private *dev_priv = vmw_priv(dev);
1353	struct vmw_display_unit *du = vmw_connector_to_du(connector);
1354
1355	num_displays = vmw_read(dev_priv, SVGA_REG_NUM_DISPLAYS);
1356
1357	return ((vmw_connector_to_du(connector)->unit < num_displays &&
1358		 du->pref_active) ?
1359		connector_status_connected : connector_status_disconnected);
1360}
1361
1362/**
1363 * vmw_guess_mode_timing - Provide fake timings for a
1364 * 60Hz vrefresh mode.
1365 *
1366 * @mode: Pointer to a struct drm_display_mode with hdisplay and vdisplay
1367 * members filled in.
1368 */
1369void vmw_guess_mode_timing(struct drm_display_mode *mode)
1370{
1371	mode->hsync_start = mode->hdisplay + 50;
1372	mode->hsync_end = mode->hsync_start + 50;
1373	mode->htotal = mode->hsync_end + 50;
1374
1375	mode->vsync_start = mode->vdisplay + 50;
1376	mode->vsync_end = mode->vsync_start + 50;
1377	mode->vtotal = mode->vsync_end + 50;
1378
1379	mode->clock = (u32)mode->htotal * (u32)mode->vtotal / 100 * 6;
1380}
1381
1382
1383/**
1384 * vmw_kms_update_layout_ioctl - Handler for DRM_VMW_UPDATE_LAYOUT ioctl
1385 * @dev: drm device for the ioctl
1386 * @data: data pointer for the ioctl
1387 * @file_priv: drm file for the ioctl call
1388 *
1389 * Update preferred topology of display unit as per ioctl request. The topology
1390 * is expressed as array of drm_vmw_rect.
1391 * e.g.
1392 * [0 0 640 480] [640 0 800 600] [0 480 640 480]
1393 *
1394 * NOTE:
1395 * The x and y offset (upper left) in drm_vmw_rect cannot be less than 0. Beside
1396 * device limit on topology, x + w and y + h (lower right) cannot be greater
1397 * than INT_MAX. So topology beyond these limits will return with error.
1398 *
1399 * Returns:
1400 * Zero on success, negative errno on failure.
1401 */
1402int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
1403				struct drm_file *file_priv)
1404{
1405	struct vmw_private *dev_priv = vmw_priv(dev);
1406	struct drm_mode_config *mode_config = &dev->mode_config;
1407	struct drm_vmw_update_layout_arg *arg =
1408		(struct drm_vmw_update_layout_arg *)data;
1409	const void __user *user_rects;
1410	struct drm_vmw_rect *rects;
1411	struct drm_rect *drm_rects;
1412	unsigned rects_size;
1413	int ret, i;
1414
1415	if (!arg->num_outputs) {
1416		struct drm_rect def_rect = {0, 0,
1417					    VMWGFX_MIN_INITIAL_WIDTH,
1418					    VMWGFX_MIN_INITIAL_HEIGHT};
1419		vmw_du_update_layout(dev_priv, 1, &def_rect);
1420		return 0;
1421	} else if (arg->num_outputs > VMWGFX_NUM_DISPLAY_UNITS) {
1422		return -E2BIG;
1423	}
1424
1425	rects_size = arg->num_outputs * sizeof(struct drm_vmw_rect);
1426	rects = kcalloc(arg->num_outputs, sizeof(struct drm_vmw_rect),
1427			GFP_KERNEL);
1428	if (unlikely(!rects))
1429		return -ENOMEM;
1430
1431	user_rects = (void __user *)(unsigned long)arg->rects;
1432	ret = copy_from_user(rects, user_rects, rects_size);
1433	if (unlikely(ret != 0)) {
1434		DRM_ERROR("Failed to get rects.\n");
1435		ret = -EFAULT;
1436		goto out_free;
1437	}
1438
1439	drm_rects = (struct drm_rect *)rects;
1440
1441	VMW_DEBUG_KMS("Layout count = %u\n", arg->num_outputs);
1442	for (i = 0; i < arg->num_outputs; i++) {
1443		struct drm_vmw_rect curr_rect;
1444
1445		/* Verify user-space for overflow as kernel use drm_rect */
1446		if ((rects[i].x + rects[i].w > INT_MAX) ||
1447		    (rects[i].y + rects[i].h > INT_MAX)) {
1448			ret = -ERANGE;
1449			goto out_free;
1450		}
1451
1452		curr_rect = rects[i];
1453		drm_rects[i].x1 = curr_rect.x;
1454		drm_rects[i].y1 = curr_rect.y;
1455		drm_rects[i].x2 = curr_rect.x + curr_rect.w;
1456		drm_rects[i].y2 = curr_rect.y + curr_rect.h;
1457
1458		VMW_DEBUG_KMS("  x1 = %d y1 = %d x2 = %d y2 = %d\n",
1459			      drm_rects[i].x1, drm_rects[i].y1,
1460			      drm_rects[i].x2, drm_rects[i].y2);
1461
1462		/*
1463		 * Currently this check is limiting the topology within
1464		 * mode_config->max (which actually is max texture size
1465		 * supported by virtual device). This limit is here to address
1466		 * window managers that create a big framebuffer for whole
1467		 * topology.
1468		 */
1469		if (drm_rects[i].x1 < 0 ||  drm_rects[i].y1 < 0 ||
1470		    drm_rects[i].x2 > mode_config->max_width ||
1471		    drm_rects[i].y2 > mode_config->max_height) {
1472			VMW_DEBUG_KMS("Invalid layout %d %d %d %d\n",
1473				      drm_rects[i].x1, drm_rects[i].y1,
1474				      drm_rects[i].x2, drm_rects[i].y2);
1475			ret = -EINVAL;
1476			goto out_free;
1477		}
1478	}
1479
1480	ret = vmw_kms_check_display_memory(dev, arg->num_outputs, drm_rects);
1481
1482	if (ret == 0)
1483		vmw_du_update_layout(dev_priv, arg->num_outputs, drm_rects);
1484
1485out_free:
1486	kfree(rects);
1487	return ret;
1488}
1489
1490/**
1491 * vmw_kms_helper_dirty - Helper to build commands and perform actions based
1492 * on a set of cliprects and a set of display units.
1493 *
1494 * @dev_priv: Pointer to a device private structure.
1495 * @framebuffer: Pointer to the framebuffer on which to perform the actions.
1496 * @clips: A set of struct drm_clip_rect. Either this os @vclips must be NULL.
1497 * Cliprects are given in framebuffer coordinates.
1498 * @vclips: A set of struct drm_vmw_rect cliprects. Either this or @clips must
1499 * be NULL. Cliprects are given in source coordinates.
1500 * @dest_x: X coordinate offset for the crtc / destination clip rects.
1501 * @dest_y: Y coordinate offset for the crtc / destination clip rects.
1502 * @num_clips: Number of cliprects in the @clips or @vclips array.
1503 * @increment: Integer with which to increment the clip counter when looping.
1504 * Used to skip a predetermined number of clip rects.
1505 * @dirty: Closure structure. See the description of struct vmw_kms_dirty.
1506 */
1507int vmw_kms_helper_dirty(struct vmw_private *dev_priv,
1508			 struct vmw_framebuffer *framebuffer,
1509			 const struct drm_clip_rect *clips,
1510			 const struct drm_vmw_rect *vclips,
1511			 s32 dest_x, s32 dest_y,
1512			 int num_clips,
1513			 int increment,
1514			 struct vmw_kms_dirty *dirty)
1515{
1516	struct vmw_display_unit *units[VMWGFX_NUM_DISPLAY_UNITS];
1517	struct drm_crtc *crtc;
1518	u32 num_units = 0;
1519	u32 i, k;
1520
1521	dirty->dev_priv = dev_priv;
1522
1523	/* If crtc is passed, no need to iterate over other display units */
1524	if (dirty->crtc) {
1525		units[num_units++] = vmw_crtc_to_du(dirty->crtc);
1526	} else {
1527		list_for_each_entry(crtc, &dev_priv->drm.mode_config.crtc_list,
1528				    head) {
1529			struct drm_plane *plane = crtc->primary;
1530
1531			if (plane->state->fb == &framebuffer->base)
1532				units[num_units++] = vmw_crtc_to_du(crtc);
1533		}
1534	}
1535
1536	for (k = 0; k < num_units; k++) {
1537		struct vmw_display_unit *unit = units[k];
1538		s32 crtc_x = unit->crtc.x;
1539		s32 crtc_y = unit->crtc.y;
1540		s32 crtc_width = unit->crtc.mode.hdisplay;
1541		s32 crtc_height = unit->crtc.mode.vdisplay;
1542		const struct drm_clip_rect *clips_ptr = clips;
1543		const struct drm_vmw_rect *vclips_ptr = vclips;
1544
1545		dirty->unit = unit;
1546		if (dirty->fifo_reserve_size > 0) {
1547			dirty->cmd = VMW_CMD_RESERVE(dev_priv,
1548						      dirty->fifo_reserve_size);
1549			if (!dirty->cmd)
1550				return -ENOMEM;
1551
1552			memset(dirty->cmd, 0, dirty->fifo_reserve_size);
1553		}
1554		dirty->num_hits = 0;
1555		for (i = 0; i < num_clips; i++, clips_ptr += increment,
1556		       vclips_ptr += increment) {
1557			s32 clip_left;
1558			s32 clip_top;
1559
1560			/*
1561			 * Select clip array type. Note that integer type
1562			 * in @clips is unsigned short, whereas in @vclips
1563			 * it's 32-bit.
1564			 */
1565			if (clips) {
1566				dirty->fb_x = (s32) clips_ptr->x1;
1567				dirty->fb_y = (s32) clips_ptr->y1;
1568				dirty->unit_x2 = (s32) clips_ptr->x2 + dest_x -
1569					crtc_x;
1570				dirty->unit_y2 = (s32) clips_ptr->y2 + dest_y -
1571					crtc_y;
1572			} else {
1573				dirty->fb_x = vclips_ptr->x;
1574				dirty->fb_y = vclips_ptr->y;
1575				dirty->unit_x2 = dirty->fb_x + vclips_ptr->w +
1576					dest_x - crtc_x;
1577				dirty->unit_y2 = dirty->fb_y + vclips_ptr->h +
1578					dest_y - crtc_y;
1579			}
1580
1581			dirty->unit_x1 = dirty->fb_x + dest_x - crtc_x;
1582			dirty->unit_y1 = dirty->fb_y + dest_y - crtc_y;
1583
1584			/* Skip this clip if it's outside the crtc region */
1585			if (dirty->unit_x1 >= crtc_width ||
1586			    dirty->unit_y1 >= crtc_height ||
1587			    dirty->unit_x2 <= 0 || dirty->unit_y2 <= 0)
1588				continue;
1589
1590			/* Clip right and bottom to crtc limits */
1591			dirty->unit_x2 = min_t(s32, dirty->unit_x2,
1592					       crtc_width);
1593			dirty->unit_y2 = min_t(s32, dirty->unit_y2,
1594					       crtc_height);
1595
1596			/* Clip left and top to crtc limits */
1597			clip_left = min_t(s32, dirty->unit_x1, 0);
1598			clip_top = min_t(s32, dirty->unit_y1, 0);
1599			dirty->unit_x1 -= clip_left;
1600			dirty->unit_y1 -= clip_top;
1601			dirty->fb_x -= clip_left;
1602			dirty->fb_y -= clip_top;
1603
1604			dirty->clip(dirty);
1605		}
1606
1607		dirty->fifo_commit(dirty);
1608	}
1609
1610	return 0;
1611}
1612
1613/**
1614 * vmw_kms_helper_validation_finish - Helper for post KMS command submission
1615 * cleanup and fencing
1616 * @dev_priv: Pointer to the device-private struct
1617 * @file_priv: Pointer identifying the client when user-space fencing is used
1618 * @ctx: Pointer to the validation context
1619 * @out_fence: If non-NULL, returned refcounted fence-pointer
1620 * @user_fence_rep: If non-NULL, pointer to user-space address area
1621 * in which to copy user-space fence info
1622 */
1623void vmw_kms_helper_validation_finish(struct vmw_private *dev_priv,
1624				      struct drm_file *file_priv,
1625				      struct vmw_validation_context *ctx,
1626				      struct vmw_fence_obj **out_fence,
1627				      struct drm_vmw_fence_rep __user *
1628				      user_fence_rep)
1629{
1630	struct vmw_fence_obj *fence = NULL;
1631	uint32_t handle = 0;
1632	int ret = 0;
1633
1634	if (file_priv || user_fence_rep || vmw_validation_has_bos(ctx) ||
1635	    out_fence)
1636		ret = vmw_execbuf_fence_commands(file_priv, dev_priv, &fence,
1637						 file_priv ? &handle : NULL);
1638	vmw_validation_done(ctx, fence);
1639	if (file_priv)
1640		vmw_execbuf_copy_fence_user(dev_priv, vmw_fpriv(file_priv),
1641					    ret, user_fence_rep, fence,
1642					    handle, -1);
1643	if (out_fence)
1644		*out_fence = fence;
1645	else
1646		vmw_fence_obj_unreference(&fence);
1647}
1648
1649/**
1650 * vmw_kms_create_implicit_placement_property - Set up the implicit placement
1651 * property.
1652 *
1653 * @dev_priv: Pointer to a device private struct.
1654 *
1655 * Sets up the implicit placement property unless it's already set up.
1656 */
1657void
1658vmw_kms_create_implicit_placement_property(struct vmw_private *dev_priv)
1659{
1660	if (dev_priv->implicit_placement_property)
1661		return;
1662
1663	dev_priv->implicit_placement_property =
1664		drm_property_create_range(&dev_priv->drm,
1665					  DRM_MODE_PROP_IMMUTABLE,
1666					  "implicit_placement", 0, 1);
1667}
1668
1669/**
1670 * vmw_kms_suspend - Save modesetting state and turn modesetting off.
1671 *
1672 * @dev: Pointer to the drm device
1673 * Return: 0 on success. Negative error code on failure.
1674 */
1675int vmw_kms_suspend(struct drm_device *dev)
1676{
1677	struct vmw_private *dev_priv = vmw_priv(dev);
1678
1679	dev_priv->suspend_state = drm_atomic_helper_suspend(dev);
1680	if (IS_ERR(dev_priv->suspend_state)) {
1681		int ret = PTR_ERR(dev_priv->suspend_state);
1682
1683		DRM_ERROR("Failed kms suspend: %d\n", ret);
1684		dev_priv->suspend_state = NULL;
1685
1686		return ret;
1687	}
1688
1689	return 0;
1690}
1691
1692
1693/**
1694 * vmw_kms_resume - Re-enable modesetting and restore state
1695 *
1696 * @dev: Pointer to the drm device
1697 * Return: 0 on success. Negative error code on failure.
1698 *
1699 * State is resumed from a previous vmw_kms_suspend(). It's illegal
1700 * to call this function without a previous vmw_kms_suspend().
1701 */
1702int vmw_kms_resume(struct drm_device *dev)
1703{
1704	struct vmw_private *dev_priv = vmw_priv(dev);
1705	int ret;
1706
1707	if (WARN_ON(!dev_priv->suspend_state))
1708		return 0;
1709
1710	ret = drm_atomic_helper_resume(dev, dev_priv->suspend_state);
1711	dev_priv->suspend_state = NULL;
1712
1713	return ret;
1714}
1715
1716/**
1717 * vmw_kms_lost_device - Notify kms that modesetting capabilities will be lost
1718 *
1719 * @dev: Pointer to the drm device
1720 */
1721void vmw_kms_lost_device(struct drm_device *dev)
1722{
1723	drm_atomic_helper_shutdown(dev);
1724}
1725
1726/**
1727 * vmw_du_helper_plane_update - Helper to do plane update on a display unit.
1728 * @update: The closure structure.
1729 *
1730 * Call this helper after setting callbacks in &vmw_du_update_plane to do plane
1731 * update on display unit.
1732 *
1733 * Return: 0 on success or a negative error code on failure.
1734 */
1735int vmw_du_helper_plane_update(struct vmw_du_update_plane *update)
1736{
1737	struct drm_plane_state *state = update->plane->state;
1738	struct drm_plane_state *old_state = update->old_state;
1739	struct drm_atomic_helper_damage_iter iter;
1740	struct drm_rect clip;
1741	struct drm_rect bb;
1742	DECLARE_VAL_CONTEXT(val_ctx, NULL, 0);
1743	uint32_t reserved_size = 0;
1744	uint32_t submit_size = 0;
1745	uint32_t curr_size = 0;
1746	uint32_t num_hits = 0;
1747	void *cmd_start;
1748	char *cmd_next;
1749	int ret;
1750
1751	/*
1752	 * Iterate in advance to check if really need plane update and find the
1753	 * number of clips that actually are in plane src for fifo allocation.
1754	 */
1755	drm_atomic_helper_damage_iter_init(&iter, old_state, state);
1756	drm_atomic_for_each_plane_damage(&iter, &clip)
1757		num_hits++;
1758
1759	if (num_hits == 0)
1760		return 0;
1761
1762	if (update->vfb->bo) {
1763		struct vmw_framebuffer_bo *vfbbo =
1764			container_of(update->vfb, typeof(*vfbbo), base);
1765
1766		/*
1767		 * For screen targets we want a mappable bo, for everything else we want
1768		 * accelerated i.e. host backed (vram or gmr) bo. If the display unit
1769		 * is not screen target then mob's shouldn't be available.
1770		 */
1771		if (update->dev_priv->active_display_unit == vmw_du_screen_target) {
1772			vmw_bo_placement_set(vfbbo->buffer,
1773					     VMW_BO_DOMAIN_SYS | VMW_BO_DOMAIN_MOB | VMW_BO_DOMAIN_GMR,
1774					     VMW_BO_DOMAIN_SYS | VMW_BO_DOMAIN_MOB | VMW_BO_DOMAIN_GMR);
1775		} else {
1776			WARN_ON(update->dev_priv->has_mob);
1777			vmw_bo_placement_set_default_accelerated(vfbbo->buffer);
1778		}
1779		ret = vmw_validation_add_bo(&val_ctx, vfbbo->buffer);
1780	} else {
1781		struct vmw_framebuffer_surface *vfbs =
1782			container_of(update->vfb, typeof(*vfbs), base);
1783		struct vmw_surface *surf = vmw_user_object_surface(&vfbs->uo);
1784
1785		ret = vmw_validation_add_resource(&val_ctx, &surf->res,
1786						  0, VMW_RES_DIRTY_NONE, NULL,
1787						  NULL);
1788	}
1789
1790	if (ret)
1791		return ret;
1792
1793	ret = vmw_validation_prepare(&val_ctx, update->mutex, update->intr);
1794	if (ret)
1795		goto out_unref;
1796
1797	reserved_size = update->calc_fifo_size(update, num_hits);
1798	cmd_start = VMW_CMD_RESERVE(update->dev_priv, reserved_size);
1799	if (!cmd_start) {
1800		ret = -ENOMEM;
1801		goto out_revert;
1802	}
1803
1804	cmd_next = cmd_start;
1805
1806	if (update->post_prepare) {
1807		curr_size = update->post_prepare(update, cmd_next);
1808		cmd_next += curr_size;
1809		submit_size += curr_size;
1810	}
1811
1812	if (update->pre_clip) {
1813		curr_size = update->pre_clip(update, cmd_next, num_hits);
1814		cmd_next += curr_size;
1815		submit_size += curr_size;
1816	}
1817
1818	bb.x1 = INT_MAX;
1819	bb.y1 = INT_MAX;
1820	bb.x2 = INT_MIN;
1821	bb.y2 = INT_MIN;
1822
1823	drm_atomic_helper_damage_iter_init(&iter, old_state, state);
1824	drm_atomic_for_each_plane_damage(&iter, &clip) {
1825		uint32_t fb_x = clip.x1;
1826		uint32_t fb_y = clip.y1;
1827
1828		vmw_du_translate_to_crtc(state, &clip);
1829		if (update->clip) {
1830			curr_size = update->clip(update, cmd_next, &clip, fb_x,
1831						 fb_y);
1832			cmd_next += curr_size;
1833			submit_size += curr_size;
1834		}
1835		bb.x1 = min_t(int, bb.x1, clip.x1);
1836		bb.y1 = min_t(int, bb.y1, clip.y1);
1837		bb.x2 = max_t(int, bb.x2, clip.x2);
1838		bb.y2 = max_t(int, bb.y2, clip.y2);
1839	}
1840
1841	curr_size = update->post_clip(update, cmd_next, &bb);
1842	submit_size += curr_size;
1843
1844	if (reserved_size < submit_size)
1845		submit_size = 0;
1846
1847	vmw_cmd_commit(update->dev_priv, submit_size);
1848
1849	vmw_kms_helper_validation_finish(update->dev_priv, NULL, &val_ctx,
1850					 update->out_fence, NULL);
1851	return ret;
1852
1853out_revert:
1854	vmw_validation_revert(&val_ctx);
1855
1856out_unref:
1857	vmw_validation_unref_lists(&val_ctx);
1858	return ret;
1859}
1860
1861/**
1862 * vmw_connector_mode_valid - implements drm_connector_helper_funcs.mode_valid callback
1863 *
1864 * @connector: the drm connector, part of a DU container
1865 * @mode: drm mode to check
1866 *
1867 * Returns MODE_OK on success, or a drm_mode_status error code.
1868 */
1869enum drm_mode_status vmw_connector_mode_valid(struct drm_connector *connector,
1870					      const struct drm_display_mode *mode)
1871{
1872	enum drm_mode_status ret;
1873	struct drm_device *dev = connector->dev;
1874	struct vmw_private *dev_priv = vmw_priv(dev);
1875	u32 assumed_cpp = 4;
1876
1877	if (dev_priv->assume_16bpp)
1878		assumed_cpp = 2;
1879
1880	ret = drm_mode_validate_size(mode, dev_priv->texture_max_width,
1881				     dev_priv->texture_max_height);
1882	if (ret != MODE_OK)
1883		return ret;
1884
1885	if (!vmw_kms_validate_mode_vram(dev_priv,
1886					mode->hdisplay * assumed_cpp,
1887					mode->vdisplay))
1888		return MODE_MEM;
1889
1890	return MODE_OK;
1891}
1892
1893/**
1894 * vmw_connector_get_modes - implements drm_connector_helper_funcs.get_modes callback
1895 *
1896 * @connector: the drm connector, part of a DU container
1897 *
1898 * Returns the number of added modes.
1899 */
1900int vmw_connector_get_modes(struct drm_connector *connector)
1901{
1902	struct vmw_display_unit *du = vmw_connector_to_du(connector);
1903	struct drm_device *dev = connector->dev;
1904	struct vmw_private *dev_priv = vmw_priv(dev);
1905	struct drm_display_mode *mode = NULL;
1906	struct drm_display_mode prefmode = { DRM_MODE("preferred",
1907		DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED,
1908		0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1909		DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_PVSYNC)
1910	};
1911	u32 max_width;
1912	u32 max_height;
1913	u32 num_modes;
1914
1915	/* Add preferred mode */
1916	mode = drm_mode_duplicate(dev, &prefmode);
1917	if (!mode)
1918		return 0;
1919
1920	mode->hdisplay = du->pref_width;
1921	mode->vdisplay = du->pref_height;
1922	vmw_guess_mode_timing(mode);
1923	drm_mode_set_name(mode);
1924
1925	drm_mode_probed_add(connector, mode);
1926	drm_dbg_kms(dev, "preferred mode " DRM_MODE_FMT "\n", DRM_MODE_ARG(mode));
1927
1928	/* Probe connector for all modes not exceeding our geom limits */
1929	max_width  = dev_priv->texture_max_width;
1930	max_height = dev_priv->texture_max_height;
1931
1932	if (dev_priv->active_display_unit == vmw_du_screen_target) {
1933		max_width  = min(dev_priv->stdu_max_width,  max_width);
1934		max_height = min(dev_priv->stdu_max_height, max_height);
1935	}
1936
1937	num_modes = 1 + drm_add_modes_noedid(connector, max_width, max_height);
1938
1939	return num_modes;
1940}
1941
1942struct vmw_user_object *vmw_user_object_ref(struct vmw_user_object *uo)
1943{
1944	if (uo->buffer)
1945		vmw_user_bo_ref(uo->buffer);
1946	else if (uo->surface)
1947		vmw_surface_reference(uo->surface);
1948	return uo;
1949}
1950
1951void vmw_user_object_unref(struct vmw_user_object *uo)
1952{
1953	if (uo->buffer)
1954		vmw_user_bo_unref(&uo->buffer);
1955	else if (uo->surface)
1956		vmw_surface_unreference(&uo->surface);
1957}
1958
1959struct vmw_bo *
1960vmw_user_object_buffer(struct vmw_user_object *uo)
1961{
1962	if (uo->buffer)
1963		return uo->buffer;
1964	else if (uo->surface)
1965		return uo->surface->res.guest_memory_bo;
1966	return NULL;
1967}
1968
1969struct vmw_surface *
1970vmw_user_object_surface(struct vmw_user_object *uo)
1971{
1972	if (uo->buffer)
1973		return uo->buffer->dumb_surface;
1974	return uo->surface;
1975}
1976
1977void *vmw_user_object_map(struct vmw_user_object *uo)
1978{
1979	struct vmw_bo *bo = vmw_user_object_buffer(uo);
1980
1981	WARN_ON(!bo);
1982	return vmw_bo_map_and_cache(bo);
1983}
1984
1985void *vmw_user_object_map_size(struct vmw_user_object *uo, size_t size)
1986{
1987	struct vmw_bo *bo = vmw_user_object_buffer(uo);
1988
1989	WARN_ON(!bo);
1990	return vmw_bo_map_and_cache_size(bo, size);
1991}
1992
1993void vmw_user_object_unmap(struct vmw_user_object *uo)
1994{
1995	struct vmw_bo *bo = vmw_user_object_buffer(uo);
1996	int ret;
1997
1998	WARN_ON(!bo);
1999
2000	/* Fence the mob creation so we are guarateed to have the mob */
2001	ret = ttm_bo_reserve(&bo->tbo, false, false, NULL);
2002	if (ret != 0)
2003		return;
2004
2005	vmw_bo_unmap(bo);
2006	vmw_bo_pin_reserved(bo, false);
2007
2008	ttm_bo_unreserve(&bo->tbo);
2009}
2010
2011bool vmw_user_object_is_mapped(struct vmw_user_object *uo)
2012{
2013	struct vmw_bo *bo;
2014
2015	if (!uo || vmw_user_object_is_null(uo))
2016		return false;
2017
2018	bo = vmw_user_object_buffer(uo);
2019
2020	if (WARN_ON(!bo))
2021		return false;
2022
2023	WARN_ON(bo->map.bo && !bo->map.virtual);
2024	return bo->map.virtual;
2025}
2026
2027bool vmw_user_object_is_null(struct vmw_user_object *uo)
2028{
2029	return !uo->buffer && !uo->surface;
2030}