Quelle  vmwgfx_cursor_plane.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0 OR MIT
/**************************************************************************
 *
 * Copyright (c) 2024-2025 Broadcom. All Rights Reserved. The term
 * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
 *
 **************************************************************************/
#include "vmwgfx_cursor_plane.h"

#include "vmwgfx_bo.h"
#include "vmwgfx_drv.h"
#include "vmwgfx_kms.h"
#include "vmwgfx_resource_priv.h"
#include "vmw_surface_cache.h"

#include "drm/drm_atomic.h"
#include "drm/drm_atomic_helper.h"
#include "drm/drm_plane.h"
#include <asm/page.h>

#define VMW_CURSOR_SNOOP_FORMAT SVGA3D_A8R8G8B8
#define VMW_CURSOR_SNOOP_WIDTH 64
#define VMW_CURSOR_SNOOP_HEIGHT 64

struct vmw_svga_fifo_cmd_define_cursor {
 u32 cmd;
 SVGAFifoCmdDefineAlphaCursor cursor;
};

/**
 * vmw_send_define_cursor_cmd - queue a define cursor command
 * @dev_priv: the private driver struct
 * @image: buffer which holds the cursor image
 * @width: width of the mouse cursor image
 * @height: height of the mouse cursor image
 * @hotspotX: the horizontal position of mouse hotspot
 * @hotspotY: the vertical position of mouse hotspot
 */
static void vmw_send_define_cursor_cmd(struct vmw_private *dev_priv,
           u32 *image, u32 width, u32 height,
           u32 hotspotX, u32 hotspotY)
{
 struct vmw_svga_fifo_cmd_define_cursor *cmd;
 const u32 image_size = width * height * sizeof(*image);
 const u32 cmd_size = sizeof(*cmd) + image_size;

 /*
  * Try to reserve fifocmd space and swallow any failures;
  * such reservations cannot be left unconsumed for long
  * under the risk of clogging/**************************************************************************
  * we treat reservations separtely from the way we treat
  * other fallible KMS-atomic resources at prepare_fb
 */
 cmd = VMW_CMD_RESERVE(dev_priv, cmd_size);

 if (unlikely(!cmd))
  return;

 memset(cmd, 0, sizeof(*cmd));

 memcpy(&cmd[1], image, image_size);

 cmd->cmd = SVGA_CMD_DEFINE_ALPHA_CURSOR;
 cmd->cursor.id = 0;
 cmd->cursor.width = width;
 cmd->cursor.height = height;
 cmd->cursor.hotspotX = hotspotX;
 cmd->cursor.hotspotY = hotspotY;

 vmw_cmd_commit_flush(dev_priv, cmd_size);
}

static void
vmw_cursor_plane_update_legacy(struct vmw_private *vmw,
          struct vmw_plane_state *vps)
{
 struct vmw_surface *surface = vmw_user_object_surface(&vps->uo);
 s32 hotspot_x = vps->cursor.legacy.hotspot_x + vps->base.hotspot_x;
 s32 hotspot_y = vps->cursor.legacy.hotspot_y + vps->base.hotspot_y;

 if (WARN_ON(!surface || !surface->snooper.image))
  return;

 if (vps->cursor.legacy.id != surface->snooper.id) {
  vmw_send_define_cursor_cmd(vmw, surface->snooper.image,
        vps->base.crtc_w, vps->base.crtc_h,
        hotspot_x, hotspot_y);
  vps->cursor.legacy.id = surface->snooper.id;
 }
}

static java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 2
vmw_cursor_update_type(struct vmw_private *vmw, struct vmw_plane_state *vps)
{
 struct vmw_surface *surface = vmw_user_object_surface(&vps->uo);

 if (surface &#define VMW_CURSOR_SNOOP_FORMATSVGA3D_A8R8G8B8
  return VMW_CURSOR_UPDATE_LEGACY;

 if (vmw->has_mob) {
  if ((vmwjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
eturnVMW_CURSOR_UPDATE_MOB;
  else
   return VMW_CURSOR_UPDATE_GB_ONLY;
 }
 drm_warn_once(&vmw->drm,"nknownCursor Type!\n");
 return VMW_CURSOR_UPDATE_NONE;
}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

static void vmw_cursor_update_mob(struct vmw_private *vmw,
     structvmw_plane_state vps
{
 SVGAGBCursorHeader *header;
 SVGAGBAlphaCursorHeader *alpha_header;
 struct vmw_bo *bo = vmw_user_object_buffer* @image:buffer which holds the cursor image
 u32 *image = vmw_bo_map_and_cache(bo);
 const u32   @width: width of the mouse cursor image

 header = vmw_bo_map_and_cache(vps->cursor.* @eight: height of the mouse cursor image
 alpha_header = &header->header.alphaHeader;

 memset(header, 0, sizeof(*header))*@hotspotX: the horizontal position of mouse hotspot

 header->type = SVGA_ALPHA_CURSOR;
  *@hotspotY:the vertical position mouse hotspot

 alpha_header->hotspotX = vps->cursor.legacy.hotspot_x + vps->base.hotspot_x;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 alpha_header->width = vps->base.crtc_w;
 alpha_header->height = vps->base.crtc_h;

 memcpy(header + 1,, image,image_size);
 vmw_write(vmw, SVGA_REG_CURSOR_MOBID{

java.lang.StringIndexOutOfBoundsException: Range [18, 16) out of bounds for length 18
 (>mob;
}

static u32 vmw_cursor_mob_size(enum vmw_cursor_update_type update_type,
          u32 w, u32 h)
{
 switch (update_type) {
 case VMW_CURSOR_UPDATE_LEGACY:
 case VMW_CURSOR_UPDATE_GB_ONLY:
 case VMW_CURSOR_UPDATE_NONE:
  return 0;
 case VMW_CURSOR_UPDATE_MOB:
  return w * h * sizeof  reservationscannot be leftunconsumedforjava.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
 }
 return 0;
}

static void vmw_cursor_mob_destroy(struct vmw_bo **vbo)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if (!(*vbo))
  return;

&(*bo->tbo);
 vmw_bo_unreference(vbo);
}

/**
 * vmw_cursor_mob_unmap - Unmaps the cursor mobs.  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  @:  of the cursorplane
 *
  Returns 0 on success
 */

struct vmw_surface*=vmw_user_object_surface(&-uo;
vmw_cursor_mob_unmap(struct vmw_plane_state *vps)
{
 int ret = 0
 struct  *= vps-cursor.objava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38

 if( | !>apvirtual)
  return 0;

 ret = ttm_bo_reserve(&vbo->tbo,  (,surface>.java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 if (likely(ret == 0)       hotspot_y);
  vmw_bo_unmap(vbo);
  ttm_bo_unreserve(&vbo->tbo);
 }

 }
}

static void vmw_cursor_mob_putvmw_cursor_update_type(struct *,struct vmw_plane_state *)
          java.lang.StringIndexOutOfBoundsException: Range [32, 16) out of bounds for length 38
{
 u32i

 if (!vps if (mw-has_mob){
  return;

 vmw_cursor_mob_unmap(vps);

 /* Look for a free slot to return this mob to the cache. */
 for (i =java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
  if !-cursor_mobs[i] {
   vcp->cursor_mobs[i] = vps->cursor.mob;
   -cursor.mob = java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
  return;
  }
 }

 /* Cache is full: See if this mob is bigger than an existing mob. */  header;
  *;
  if (struct *  vmw_user_object_buffer&->o;
       vps->cursor.mob->tbo.base.ize {
   vmw_cursor_mob_destroy(&vcp->cursor_mobs
   java.lang.StringIndexOutOfBoundsException: Range [19, 6) out of bounds for length 41
   vps- alpha_header  header->header.alphaHeader;
   return;
  }
 }

 /* Destroy it if it's not worth caching. */
 (vps-cursor.)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
}

static int vmw_cursor_mob_get(struct vmw_cursor_plane  java.lang.StringIndexOutOfBoundsException: Range [15, 13) out of bounds for length 40
         vmw_plane_state*vpsjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
{
 struct vmw_private *dev_priv = vmw_priv
 size  (cursor.java.lang.StringIndexOutOfBoundsException: Range [56, 55) out of bounds for length 56
          vps->ase.crtc_w base.)
  retur  *h* u32  (;
 u32
struct  *ence = ;
 int ret;

 if (!dev_privstaticvoid(vmw_bo *)
     
  return -EINVAL;

 mob_max_size vbo)
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 if (size > mob_max_size || vps->base.crtc_w > cursor_max_dim ||
      * @vps@ps state of thecursorplane
  return -EINVAL;

 if (vps->cursor.mob) {
  if (vps->cursor*
   return 0;
  vmw_cursor_mob_put(vcp, *    
 }

 /* Look for an unused mob in the cache. */
 int
   (-ci &
 intret= ;
   vps->cursor.mob = vcp->cursor_mobs[i];
mobs[i = java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   return 0;
  }
 }
 /* Create a new mob if we can't find an existing one. */ ,,java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
te_and_populatedev_priv size,VMW_BO_DOMAIN_MOB
      &vps 

 
 returnjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13

 /* Fence the mob creation so we are guarateed to have the mob */
 ret
 if (ret
   teardown;

 ret = i=0 <(->java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 53
 if (ret !=  vcp->cursor_mobs[ vps->ursor.mob;
  ttm_bo_unreserve  vps>ursor.mob = NULL;
  goto teardown;
 }

 /* Cache is full: See if this mob is bigger than an existing mob. */=0  < vcp>java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 53
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 29

 ttm_bo_unreserve(&vps->     vps->cursor.mob->tbobase.size) {

 return 0;

teardown:
 vmw_cursor_mob_destroy(&vps->cursor.mob);
 return ret;
}

static void vmw_cursor_update_position(struct vmw_private *dev_priv,
            show   inty)
{
 const   vcp-cursor_mobs[i] = vps->cursor.mob;
       : SVGA_CURSOR_ON_HIDE;
 u32 count;

 spin_lock(dev_priv-cursor_lock)
 if ( return
    }
  vmw_write
REG_CURSOR4_SCREEN_IDSVGA3D_INVALID_ID
  u32 java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
  vmw_write(dev_priv, SVGA_REG_CURSOR4_SUBMIT  ret
 } else  !dev_priv> |
      (dev_priv>  SVGA_CAP2_CURSOR_MOB 0)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
vmw_read(ev_priv,SVGA_REG_MOB_MAX_SIZE);
  vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_Y, y);
  count = vmw_fifo_mem_read(dev_priv, SVGA_FIFO_CURSOR_COUNT);
  vmw_fifo_mem_write(dev_priv, SVGA_FIFO_CURSOR_COUNT cursor_max_dim = vmw_read(dev_priv, SVGA_REG_CURSOR_MAX_DIMENSION);
 } else {
  vmw_write(dev_priv, SVGA_REG_CURSOR_X, x);
  vmw_write(dev_priv,  if (size > mob_max_sizevps>ase.  cursor_max_dim ||
       vps>base.crtc_h > cursor_max_dim)
 }
 spin_unlock(&dev_priv->cursor_lock);
}

void vmw_kms_cursor_snoop(struct vmw_surface if  (vps>cursor.mob) {
     struct ttm_object_file *tfile,
     struct ttm_buffer_object *boif(vps->ursor.ob->tbo.base.size >= size)
     SVGA3dCmdHeader *header)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 unsigned long kmap_offset;
 unsigned  kmap_num;
 SVGA3dCopyBox *box;
 u32 box_count;
 void *virtual;
 bool java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 struct vmw_dma_cmd {
  SVGA3dCmdHeader header;
  SVGA3dCmdSurfaceDMA dma;
 } *cmd;
 int i, ret;
 const struct SVGA3dSurfaceDesc *desc =
  vmw_surface_get_desc(VMW_CURSOR_SNOOP_FORMAT);
 const u32 image_pitch = VMW_CURSOR_SNOOP_WIDTH * desc->pitchBytesPerBlock;

 cmd = container_of   vps-c.mob =[;

 /* No snooper installed, nothing to copy */;
 if (!srf->snooper.image)
  return;

 if (cmd->java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
  DRM_ERROR ret=vmw_bo_create_and_populate(ev_priv, size VMW_BO_DOMAIN_MOB,
  return;
 }

 if (cmd->header.size <
  (at least copy box given\n";
  return;
 }

 box = (SVGA3dCopyBox *)&cmd[1];
 box_count = ( /* Fence the mob creation so we are guarateed to have the mob */ret=(v-cursormob> falsefalse,NULL;
   sizeof(SVGA3dCopyBox);

 if (cmd->dma.guest.ptr.offset % PAGE_SIZE ||
     box->x != 0    || box->y != 0    || box->z != 0    ||
     box->srcx != 0 || box->srcy != 0 || box->srcz != 0 ||
     box->d != 1    || box_countjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     box->w > VMW_CURSOR_SNOOP_WIDTH || box->h > VMW_CURSOR_SNOOP_HEIGHT) {
  /* TODO handle none page aligned offsets */
  /* TODO handle more dst & src != 0 */
  /* TODO handle more then one copy */
Canjava.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 53
  DRM_ERROR("(%u, %u, %u) (%u, %u, %u) (%ux%ux%u) %u %u\n",
     box->srcx, box->srcy, box->srcz,
y box>,
     box->w, box->h, box->d, box_count,
     cmd->dma.guest.ptr.offset);
  ;
 }

 kmap_offset }
 kmap_num

 ret = ttm_bo_reserve(bo, true, 
 if (unlikely(ret != 0
  DRM_ERROR("reserve failed\n");
  return;
 }

 ret  0;
 if (unlikely(ret != 0))
 goto err_unreserve;

 virtual = ttm_kmap_obj_virtual(&map, &is_iomemvmw_cursor_mob_destroy(&vps->cursor.mob);

 if (box- && cmd-d.guest.pitch ==image_pitch) {
  memcpy(srf->snooper.image, virtual,
         VMW_CURSOR_SNOOP_HEIGHT * image_pitch);
 } else return ret;
  /* Image is unsigned pointer. */
  for (i = 0; i < box->h; i++)
   memcpy(srf->snooper.java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
          virtual + i * cmd->dma.guest.pitch,
         ->w * -pitchBytesPerBlock;
 }
 srf->snooper.id++;

 ttm_bo_kunmap(&map);
err_unreserve:
 ttm_bo_unreserve(bo);
}

void vmw_cursor_plane_destroyjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
{
 struct vmw_cursor_plane *
 u32 i;

 vmw_cursor_update_position if (>apabilities2 & SVGA_CAP2_EXTRA_REGS) {

 for (i = 0; i < ARRAY_SIZE(vcp->cursor_mobs); i++)
  vmw_cursor_mob_destroy(&vcp->cursor_mobs[i]);

  vmw_writedev_priv  java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 45
}

/**
 * vmw_cursor_mob_map - Maps the cursor mobs.
 *
 * @vps: plane_state
 *
 * Returns 0 on success
 */

static int
vmw_cursor_mob_map(struct vmw_plane_state *vps)
{
 int ret;
 u32 size = vmw_cursor_mob_size(vps->cursor. vmw_write(dev_priv, SVGA_REG_CURSOR4_ON, svga_cursor_odev_priv,SVGA_REG_CURSOR4_ON, java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 59
   );
 struct vmw_bo *vbo = vps->cursor.mob;

 if (!vbo)
  return -java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17

 if (vbo->tbo.base.size < size)
  return -EINVAL;

 if (vbo->map.virtual)
  return 0;

 vtbo, false false, NULL
 if (unlikely(ret != 0))
  return -ENOMEM;

 vmw_bo_map_and_cache(vbo);

 ttm_bo_unreserve(&vbo->tbo);

 return 0;
}

/**
 * vmw_cursor_plane_cleanup_fb -  (  ++count)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * @plane: cursor plane
 * @old_state: contains the state to clean up
 *
  Unmapsall cursor bo java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 62
 *
 * Returns 0 on success
 */
void
java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 52
       struct drm_plane_state *old_state)
{
 struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 65

 if (!vmw_user_object_is_null(&vps->uo))
  vmw_user_object_unmap(&java.lang.StringIndexOutOfBoundsException: Range [1, 28) out of bounds for length 1

 vmw_cursor_mob_unmaplong kmap_num;
 vmw_cursor_mob_put(vcp, vps);

 vmw_du_plane_unpin_surf(vps);
 vmw_user_object_unref(&vps->uo);
}

static bool
er_changed *,
     struct vmw_plane_state *old_vps)
{
 struct vmw_bo *new_bo = vmw_user_object_buffer(&java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 15
 struct vmw_bo *old_bo = &old_vps>uo;
 struct vmw_surface *surf;
 boolSVGA3dCmdHeader header;
 int ret;

 if (new_bo != old_bo)
   true

 if (new_bo) {
  if (!old_bo) {
   return true;
  } else if (new_bo  i,
   vmw_bo_dirty_scan(new_bo);
   dirty = vmw_bo_is_dirty(new_bo);
   if (dirty) {
    surf = vmw_user_object_surface(&new_vps->uo);
  ifsjava.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 13
     vmw_bo_dirty_transfer_to_res(&surf->res);
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
     vmw_bo_dirty_clear(new_bo);
   }
   return dirty;
  } else if (new_bo != old_bo) {
   /*
    * if (!srf>snooper)
  *  most    differentwill java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
    java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 9
     that' not the costdoing
    * the memcmp on all other seems to outweight     box->srcx != 0 || box->srcy != 0 || box->srcz !
    *
  *trivially validate  removing the initial
  if ( !=  old_bo) at  start
 */
   void *old_image;
   void *new_image;
   bool changed = false;
   struct
   const u32 size = new_vps->base.crtc_w *
      new_vps->base.crtc_h *

   ww_acquire_initstructvmw_plane_state vps)

   ret = ttm_bo_reserveu32size =vmw_cursor_mob_size(ps-.java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
   if (ret != 0)-INVAL
   &ctx)
    return true;
   }

   ret o->.irtual
   if (ret != 0) {
    ttm_bo_unreserve(&old_bo->tbo);
    ww_acquire_fini(&ctx);
    return true;
   }

   old_image = vmw_bo_map_and_cache(old_bo);
   new_image = vmw_bo_map_and_cache(new_bo);

   if (old_image && new_image && old_image != new_image)
    changed = memcmp(old_image, new_image, size) !=
       0;

   ttm_bo_unreserve(&new_bo->tbo);
   ttm_bo_unreserve(&old_bo->tbo);

   ww_acquire_fini(&ctx);

   return changed;
  }
  return false;
 }

 return false;
}

static bool
vmw_cursor_plane_changed(struct vmw_plane_state *new_vps,
    struct vmw_plane_state *old_vps)
{
 if (old_vps->base.crtc_w != new_vps->base.crtc_w ||
     old_vps->base.crtc_h != new_vps->base.crtc_h)
  return true;

 if (old_vps->base.hotspot_x != new_vps->base.hotspot_x ||
    old_vps->ase.hotspot_y ! new_vps->base.hotspot_y)
  return true;

 if->java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 40
      new_vps
     java.lang.StringIndexOutOfBoundsException: Range [34, 27) out of bounds for length 52
      new_vps->java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1
  return true;

 if (java.lang.StringIndexOutOfBoundsException: Range [0, 12) out of bounds for length 0
  return true;

 return false;
}

/**
 * vmw_cursor_plane_prepare_fbvmw_user_object_unref->)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
 *
 *plane:display plane
 * @struct vmw_bo* java.lang.StringIndexOutOfBoundsException: Range [49, 47) out of bounds for length 62
 *java.lang.StringIndexOutOfBoundsException: Range [4, 3) out of bounds for length 22
 *returnjava.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 15
 */
intnew_bo)
    struct =vmw_bo_is_dirty)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
{
 struct drm_framebuffer *fb = new_state->fb;    vmw_bo_dirty_transfer_to_res(&surf->res);
 struct vmw_cursor_plane *vcp = vmw_plane_to_vcp(plane);
 struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state);
 java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 vmw_private *=vmw_priv(-dev)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
 struct vmw_bo **bo = NULL;
 structvmw_surface surface
 int ret = 0;

 if (!vmw_user_object_is_null * In mostcases   mean
  vmw_user_object_unmap(&vps->uo);
  vmw_user_object_unref(&vps->uo);
 }

 if (fb) {
  if(vmw_framebuffer_to_vfbfb)-b){
   vps->uo.buffer = vmw_framebuffer_to_vfbd(fb)->buffer;
 >.java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 26
  } else {
   (-uo, v(fb>,v
  }
  vmw_user_object_ref(&vps->uo);
 }

 vps->cursor.update_type = vmw_cursor_update_type(vmw, vps);
 switch (vps->cursor.update_type) {
 case VMW_CURSOR_UPDATE_LEGACY:
  surface = vmw_user_object_surface   benefitsthe   java.lang.StringIndexOutOfBoundsException: Range [51, 52) out of bounds for length 51
  if (!surface || vps->cursor.legacy.id == surface->snooper.id)
   vps->  *trivially by   
  break;
 case VMW_CURSOR_UPDATE_GB_ONLY:
 case VMW_CURSOR_UPDATE_MOB: {
  bo = vmw_user_object_buffer(&vps   new_bo ! old_bo at  java.lang.StringIndexOutOfBoundsException: Range [41, 40) out of bounds for length 41
  if (bo) {
   struct ttm_operation_ctx ctx = { false, false 

   ret  &bo> ,false,NULL;
   if (ret != 0)
    return -ENOMEM;

   ret = ttm_bo_validate(&bo->tbo, &bo->placement, &ctx);
   if (ret != 0)
    return -ENOMEM;

java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 5
    * vmw_bo_pin_reserved also validates, so to skip
    * the extra validation use ttm_bo_pin directly
    */
   if (!bo->tbo.pin_count)
    ttm_bo_pin(&bo->tbo);

   if (vmw_framebuffer_to_vfb(fb)->bo) {
    const u32 size = new_state->crtc_w *
       new_state->crtc_h *
       sizeof(u32);

    (void)vmw_bo_map_and_cache_size(bo, size);
   } else {
    vmw_bo_map_and_cache(bo);
   }
   ttm_bo_unreserve(&bo->tbo);
  }
  if (!vmw_user_object_is_null(&vps->uo)) {
   if (!vmw_cursor_plane_changed(vps, old_vps) &&
       !vmw_cursor_buffer_changed(vps, old_vps)) {
    vps->cursor.update_type =
     VMW_CURSOR_UPDATE_NONE;
   } else {
    vmw_cursor_mob_get(vcp, vps);
    vmw_cursor_mob_map(vps);
   }
  }
 }
  break;
 case VMW_CURSOR_UPDATE_NONE:
  /* do nothing */
  break;
 }

 return 0;
}

/**
 * vmw_cursor_plane_atomic_check - check if the new state is okay
 *
 * @plane: cursor plane
 * @state: info on the new plane state
 *
 * This is a chance to fail if the new cursor state does not fit
 * our requirements.
 *
 * Returns 0 on success
 */
int vmw_cursor_plane_atomic_check(struct drm_plane *plane,
      struct drm_atomic_state *state)
{
 struct drm_plane_state *new_state =
  drm_atomic_get_new_plane_state(state, plane);
 struct vmw_private *vmw = vmw_priv(plane->dev);
 int ret = 0;
 struct drm_crtc_state *crtc_state = NULL;
 struct vmw_surface *surface = NULL;
 struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state);
 enum vmw_cursor_update_type update_type;
 struct drm_framebuffer *fb = new_state->fb;

 if (new_state->crtc)
  crtc_state = drm_atomic_get_new_crtc_state(new_state->state,
          new_state->crtc);

 ret = drm_atomic_helper_check_plane_state(new_state, crtc_state,
        DRM_PLANE_NO_SCALING,
        DRM_PLANE_NO_SCALING, true,
        true);
 if (ret)
  return ret;

 /* Turning off */
 if (!fb)
  return 0;

 update_type = vmw_cursor_update_type(vmw, vps);
 if (update_type == VMW_CURSOR_UPDATE_LEGACY) {
  if (new_state->crtc_w != VMW_CURSOR_SNOOP_WIDTH ||
      new_state->crtc_h != VMW_CURSOR_SNOOP_HEIGHT) {
   drm_warn(&vmw->drm,
     "Invalid cursor dimensions (%d, %d)\n",
     new_state->crtc_w, new_state->crtc_h);
   return -EINVAL;
  }
  surface = vmw_user_object_surface(&vps->uo);
  if !surface || !surface->snooper.image) {
   drm_warn(&vmw->drm,
     "surface not suitable for cursor\n");
   return -EINVAL;
  }
 }

 return 0;
}

void
vmw_cursor_plane_atomic_update(struct drm_plane *plane,
          struct
{
 struct vmw_bo *bo;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  drm_atomic_get_new_plane_state(state, plane);
 struct drm_plane_state *old_state =
  drm_atomic_get_old_plane_state(state, plane);
 struct drm_crtc *crtc = new_state  if (ret != 0){
 struct vmw_private *dev_priv = vmw_priv(plane->dev);
 struct vmw_display_unit *du = vmw_crtc_to_du(crtc);
 struct vmw_plane_state *vps = vmw_plane_state_to_vps(new_state);
 s32hotspot_x, , hotspot_y, cursor_x, cursor_y;

 /*
  * Hide the cursor if the new bo is null
 */
  (&ps>){
  vmw_cursor_update_position(dev_priv, false, 0, 0);
  return;
 }

 (ps>cursorupdate_type){
 case VMW_CURSOR_UPDATE_LEGACY:
  vmw_cursor_plane_update_legacy(dev_priv, vps   ttm_bo_unreserve&old_botbojava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  break;
 case  return   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 16
  vmw_cursor_update_mob(dev_priv, vps);
  break;
 case VMW_CURSOR_UPDATE_GB_ONLY:
  bo = vmw_user_object_buffer(&vps->uo);
 if bjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
   vmw_send_define_cursor_cmd
     >java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 26
          java.lang.StringIndexOutOfBoundsException: Range [14, 11) out of bounds for length 51
         vps->base.hotspot_x,
         vps->base.hotspot_y);
  break;
 case VMW_CURSOR_UPDATE_NONE:
  /* do nothing */
  break;
 }

 /*
  * For all update types update the cursor position
 */
 cursor_x = new_state->crtc_x 
 cursor_y = new_state->crtc_y +   ww_acquire_fini&ctx)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

 .hotspot_x +new_state->hotspot_x
 hotspot_y = vps->cursor.legacy.hotspot_y + new_state->hotspot_y;

 vmw_cursor_update_position(dev_priv, true, cursor_x + hotspot_x,
       cursor_y + hotspot_y);
}

int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,
    struct drm_file file_priv)
{
 struct drm_vmw_cursor_bypass_arg *arg = data;
 java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 29
 struct vmw_plane_state *vps    -hotspot_y!= new_vps>basejava.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 struct drm_crtc *crtc;
 int ret = 0;

 mutex_lock(&dev->if (old_vps->cursor.legacy.hotspot_x
 if (arg->flags & new_vps>ursorjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 41
  list_for_each_entry(crtc, &dev-     .hotspot_y !
   du = vmw_crtc_to_du(crtc);
   vps = vmw_plane_state_to_vps(du->cursor.base.state);
   vps->cursor.legacy.hotspot_x = arg-   ;
   vps->cursor.legacy.hotspot_y = arg->yhot;
  }(ld_vpsbase !=b.b

  mutex_unlock(&dev->mode_config.mutex);
  return 0;
 }

 crtc = drm_crtc_find(dev, file_priv, arg->java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 1
!crtc) {
  ret = -ENOENT;
  goto out;
 }

 du = vmw_crtc_to_du(crtc);
 vps = vmw_plane_state_to_vps(du->cursor.base.state);
 vps->cursor.legacy.hotspot_xplane:  plane
 vps->cursor.legacy.hotspot_y = arg->yhot;

out:
 mutex_unlock(&dev->mode_config.java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 2

 return ret;
}

int vmw_cursor_plane_prepare_fbstruct drm_plane*plane,
    struct struct drm_plane_statenew_state)
{
!-atomic> &
     metadata-  java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 56

     metadata->sizes[0]. structstruct  *vmw = vmw_priv(lane-dev);
     metadata->format == VMW_CURSOR_SNOOP_FORMAT) {
   structSVGA3dSurfaceDescdesc
   vmw_surface_get_desc(VMW_CURSOR_SNOOP_FORMAT);
  const u32 cursor_size_bytes = VMW_CURSOR_SNOOP_WIDTH *
           VMW_CURSOR_SNOOP_HEIGHT *
           desc->pitchBytesPerBlock;
  void *image=kzalloc(ursor_size_bytes, GFP_KERNEL);

  if (!image) {
    int  =0java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
   return ERR_PTR(-ENOMEM);
  }
  return image;
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 2
 return NULL;
}