drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

   1 /* SPDX-License-Identifier: GPL-2.0 OR MIT */
   2 /**************************************************************************
   3  *
   4  * Copyright (c) 2009-2024 Broadcom. All Rights Reserved. The term
   5  * “Broadcom” refers to Broadcom Inc. and/or its subsidiaries.
   6  *
   7  * Permission is hereby granted, free of charge, to any person obtaining a
   8  * copy of this software and associated documentation files (the
   9  * "Software"), to deal in the Software without restriction, including
  10  * without limitation the rights to use, copy, modify, merge, publish,
  11  * distribute, sub license, and/or sell copies of the Software, and to
  12  * permit persons to whom the Software is furnished to do so, subject to
  13  * the following conditions:
  14  *
  15  * The above copyright notice and this permission notice (including the
  16  * next paragraph) shall be included in all copies or substantial portions
  17  * of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  22  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
  23  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  24  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  25  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  26  *
  27  **************************************************************************/
  28
  29 #ifndef _VMWGFX_DRV_H_
  30 #define _VMWGFX_DRV_H_
  31
  32 #include <linux/suspend.h>
  33 #include <linux/sync_file.h>
  34 #include <linux/hashtable.h>
  35
  36 #include <drm/drm_auth.h>
  37 #include <drm/drm_device.h>
  38 #include <drm/drm_file.h>
  39 #include <drm/drm_rect.h>
  40
  41 #include <drm/ttm/ttm_execbuf_util.h>
  42 #include <drm/ttm/ttm_tt.h>
  43 #include <drm/ttm/ttm_placement.h>
  44 #include <drm/ttm/ttm_bo.h>
  45
  46 #include "ttm_object.h"
  47
  48 #include "vmwgfx_fence.h"
  49 #include "vmwgfx_reg.h"
  50 #include "vmwgfx_validation.h"
  51
  52 /*
  53  * FIXME: vmwgfx_drm.h needs to be last due to dependencies.
  54  * uapi headers should not depend on header files outside uapi/.
  55  */
  56 #include <drm/vmwgfx_drm.h>
  57
  58
  59 #define VMWGFX_DRIVER_NAME "vmwgfx"
  60 #define VMWGFX_DRIVER_DATE "20211206"
  61 #define VMWGFX_DRIVER_MAJOR 2
  62 #define VMWGFX_DRIVER_MINOR 20
  63 #define VMWGFX_DRIVER_PATCHLEVEL 0
  64 #define VMWGFX_FIFO_STATIC_SIZE (1024*1024)
  65 #define VMWGFX_NUM_DISPLAY_UNITS 8
  66 #define VMWGFX_CMD_BOUNCE_INIT_SIZE 32768
  67
  68 #define VMWGFX_MIN_INITIAL_WIDTH 1280
  69 #define VMWGFX_MIN_INITIAL_HEIGHT 800
  70
  71 #define VMWGFX_PCI_ID_SVGA2              0x0405
  72 #define VMWGFX_PCI_ID_SVGA3              0x0406
  73
  74 /*
  75  * This has to match get_count_order(SVGA_IRQFLAG_MAX)
  76  */
  77 #define VMWGFX_MAX_NUM_IRQS 6
  78
  79 /*
  80  * Perhaps we should have sysfs entries for these.
  81  */
  82 #define VMWGFX_NUM_GB_CONTEXT 256
  83 #define VMWGFX_NUM_GB_SHADER 20000
  84 #define VMWGFX_NUM_GB_SURFACE 32768
  85 #define VMWGFX_NUM_GB_SCREEN_TARGET VMWGFX_NUM_DISPLAY_UNITS
  86 #define VMWGFX_NUM_DXCONTEXT 256
  87 #define VMWGFX_NUM_DXQUERY 512
  88 #define VMWGFX_NUM_MOB (VMWGFX_NUM_GB_CONTEXT +\
  89                         VMWGFX_NUM_GB_SHADER +\
  90                         VMWGFX_NUM_GB_SURFACE +\
  91                         VMWGFX_NUM_GB_SCREEN_TARGET)
  92
  93 #define VMW_PL_GMR      (TTM_PL_PRIV + 0)
  94 #define VMW_PL_MOB      (TTM_PL_PRIV + 1)
  95 #define VMW_PL_SYSTEM   (TTM_PL_PRIV + 2)
  96
  97 #define VMW_RES_CONTEXT ttm_driver_type0
  98 #define VMW_RES_SURFACE ttm_driver_type1
  99 #define VMW_RES_STREAM ttm_driver_type2
 100 #define VMW_RES_FENCE ttm_driver_type3
 101 #define VMW_RES_SHADER ttm_driver_type4
 102 #define VMW_RES_HT_ORDER 12
 103
 104 #define VMW_CURSOR_SNOOP_FORMAT SVGA3D_A8R8G8B8
 105 #define VMW_CURSOR_SNOOP_WIDTH 64
 106 #define VMW_CURSOR_SNOOP_HEIGHT 64
 107
 108 #define MKSSTAT_CAPACITY_LOG2 5U
 109 #define MKSSTAT_CAPACITY (1U << MKSSTAT_CAPACITY_LOG2)
 110
 111 struct vmw_fpriv {
 112         struct ttm_object_file *tfile;
 113         bool gb_aware; /* user-space is guest-backed aware */
 114 };
 115
 116 struct vmwgfx_hash_item {
 117         struct hlist_node head;
 118         unsigned long key;
 119 };
 120
 121 struct vmw_res_func;
 122
 123 /**
 124  * struct vmw-resource - base class for hardware resources
 125  *
 126  * @kref: For refcounting.
 127  * @dev_priv: Pointer to the device private for this resource. Immutable.
 128  * @id: Device id. Protected by @dev_priv::resource_lock.
 129  * @guest_memory_size: Guest memory buffer size. Immutable.
 130  * @res_dirty: Resource contains data not yet in the guest memory buffer.
 131  * Protected by resource reserved.
 132  * @guest_memory_dirty: Guest memory buffer contains data not yet in the HW
 133  * resource. Protected by resource reserved.
 134  * @coherent: Emulate coherency by tracking vm accesses.
 135  * @guest_memory_bo: The guest memory buffer if any. Protected by resource
 136  * reserved.
 137  * @guest_memory_offset: Offset into the guest memory buffer if any. Protected
 138  * by resource reserved. Note that only a few resource types can have a
 139  * @guest_memory_offset different from zero.
 140  * @pin_count: The pin count for this resource. A pinned resource has a
 141  * pin-count greater than zero. It is not on the resource LRU lists and its
 142  * guest memory buffer is pinned. Hence it can't be evicted.
 143  * @func: Method vtable for this resource. Immutable.
 144  * @mob_node; Node for the MOB guest memory rbtree. Protected by
 145  * @guest_memory_bo reserved.
 146  * @lru_head: List head for the LRU list. Protected by @dev_priv::resource_lock.
 147  * @binding_head: List head for the context binding list. Protected by
 148  * the @dev_priv::binding_mutex
 149  * @res_free: The resource destructor.
 150  * @hw_destroy: Callback to destroy the resource on the device, as part of
 151  * resource destruction.
 152  */
 153 struct vmw_bo;
 154 struct vmw_bo;
 155 struct vmw_resource_dirty;
 156 struct vmw_resource {
 157         struct kref kref;
 158         struct vmw_private *dev_priv;
 159         int id;
 160         u32 used_prio;
 161         unsigned long guest_memory_size;
 162         u32 res_dirty : 1;
 163         u32 guest_memory_dirty : 1;
 164         u32 coherent : 1;
 165         struct vmw_bo *guest_memory_bo;
 166         unsigned long guest_memory_offset;
 167         unsigned long pin_count;
 168         const struct vmw_res_func *func;
 169         struct rb_node mob_node;
 170         struct list_head lru_head;
 171         struct list_head binding_head;
 172         struct vmw_resource_dirty *dirty;
 173         void (*res_free) (struct vmw_resource *res);
 174         void (*hw_destroy) (struct vmw_resource *res);
 175 };
 176
 177
 178 /*
 179  * Resources that are managed using ioctls.
 180  */
 181 enum vmw_res_type {
 182         vmw_res_context,
 183         vmw_res_surface,
 184         vmw_res_stream,
 185         vmw_res_shader,
 186         vmw_res_dx_context,
 187         vmw_res_cotable,
 188         vmw_res_view,
 189         vmw_res_streamoutput,
 190         vmw_res_max
 191 };
 192
 193 /*
 194  * Resources that are managed using command streams.
 195  */
 196 enum vmw_cmdbuf_res_type {
 197         vmw_cmdbuf_res_shader,
 198         vmw_cmdbuf_res_view,
 199         vmw_cmdbuf_res_streamoutput
 200 };
 201
 202 struct vmw_cmdbuf_res_manager;
 203
 204 struct vmw_cursor_snooper {
 205         size_t age;
 206         uint32_t *image;
 207 };
 208
 209 struct vmw_framebuffer;
 210 struct vmw_surface_offset;
 211
 212 /**
 213  * struct vmw_surface_metadata - Metadata describing a surface.
 214  *
 215  * @flags: Device flags.
 216  * @format: Surface SVGA3D_x format.
 217  * @mip_levels: Mip level for each face. For GB first index is used only.
 218  * @multisample_count: Sample count.
 219  * @multisample_pattern: Sample patterns.
 220  * @quality_level: Quality level.
 221  * @autogen_filter: Filter for automatically generated mipmaps.
 222  * @array_size: Number of array elements for a 1D/2D texture. For cubemap
 223                 texture number of faces * array_size. This should be 0 for pre
 224                 SM4 device.
 225  * @buffer_byte_stride: Buffer byte stride.
 226  * @num_sizes: Size of @sizes. For GB surface this should always be 1.
 227  * @base_size: Surface dimension.
 228  * @sizes: Array representing mip sizes. Legacy only.
 229  * @scanout: Whether this surface will be used for scanout.
 230  *
 231  * This tracks metadata for both legacy and guest backed surface.
 232  */
 233 struct vmw_surface_metadata {
 234         u64 flags;
 235         u32 format;
 236         u32 mip_levels[DRM_VMW_MAX_SURFACE_FACES];
 237         u32 multisample_count;
 238         u32 multisample_pattern;
 239         u32 quality_level;
 240         u32 autogen_filter;
 241         u32 array_size;
 242         u32 num_sizes;
 243         u32 buffer_byte_stride;
 244         struct drm_vmw_size base_size;
 245         struct drm_vmw_size *sizes;
 246         bool scanout;
 247 };
 248
 249 /**
 250  * struct vmw_surface: Resource structure for a surface.
 251  *
 252  * @res: The base resource for this surface.
 253  * @metadata: Metadata for this surface resource.
 254  * @snooper: Cursor data. Legacy surface only.
 255  * @offsets: Legacy surface only.
 256  * @view_list: List of views bound to this surface.
 257  */
 258 struct vmw_surface {
 259         struct vmw_resource res;
 260         struct vmw_surface_metadata metadata;
 261         struct vmw_cursor_snooper snooper;
 262         struct vmw_surface_offset *offsets;
 263         struct list_head view_list;
 264 };
 265
 266 struct vmw_fifo_state {
 267         unsigned long reserved_size;
 268         u32 *dynamic_buffer;
 269         u32 *static_buffer;
 270         unsigned long static_buffer_size;
 271         bool using_bounce_buffer;
 272         uint32_t capabilities;
 273         struct mutex fifo_mutex;
 274         struct rw_semaphore rwsem;
 275 };
 276
 277 /**
 278  * struct vmw_res_cache_entry - resource information cache entry
 279  * @handle: User-space handle of a resource.
 280  * @res: Non-ref-counted pointer to the resource.
 281  * @valid_handle: Whether the @handle member is valid.
 282  * @valid: Whether the entry is valid, which also implies that the execbuf
 283  * code holds a reference to the resource, and it's placed on the
 284  * validation list.
 285  *
 286  * Used to avoid frequent repeated user-space handle lookups of the
 287  * same resource.
 288  */
 289 struct vmw_res_cache_entry {
 290         uint32_t handle;
 291         struct vmw_resource *res;
 292         void *private;
 293         unsigned short valid_handle;
 294         unsigned short valid;
 295 };
 296
 297 /**
 298  * enum vmw_dma_map_mode - indicate how to perform TTM page dma mappings.
 299  */
 300 enum vmw_dma_map_mode {
 301         vmw_dma_alloc_coherent, /* Use TTM coherent pages */
 302         vmw_dma_map_populate,   /* Unmap from DMA just after unpopulate */
 303         vmw_dma_map_bind,       /* Unmap from DMA just before unbind */
 304         vmw_dma_map_max
 305 };
 306
 307 /**
 308  * struct vmw_sg_table - Scatter/gather table for binding, with additional
 309  * device-specific information.
 310  *
 311  * @sgt: Pointer to a struct sg_table with binding information
 312  * @num_regions: Number of regions with device-address contiguous pages
 313  */
 314 struct vmw_sg_table {
 315         enum vmw_dma_map_mode mode;
 316         struct page **pages;
 317         const dma_addr_t *addrs;
 318         struct sg_table *sgt;
 319         unsigned long num_pages;
 320 };
 321
 322 /**
 323  * struct vmw_piter - Page iterator that iterates over a list of pages
 324  * and DMA addresses that could be either a scatter-gather list or
 325  * arrays
 326  *
 327  * @pages: Array of page pointers to the pages.
 328  * @addrs: DMA addresses to the pages if coherent pages are used.
 329  * @iter: Scatter-gather page iterator. Current position in SG list.
 330  * @i: Current position in arrays.
 331  * @num_pages: Number of pages total.
 332  * @next: Function to advance the iterator. Returns false if past the list
 333  * of pages, true otherwise.
 334  * @dma_address: Function to return the DMA address of the current page.
 335  */
 336 struct vmw_piter {
 337         struct page **pages;
 338         const dma_addr_t *addrs;
 339         struct sg_dma_page_iter iter;
 340         unsigned long i;
 341         unsigned long num_pages;
 342         bool (*next)(struct vmw_piter *);
 343         dma_addr_t (*dma_address)(struct vmw_piter *);
 344 };
 345
 346
 347 struct vmw_ttm_tt {
 348         struct ttm_tt dma_ttm;
 349         struct vmw_private *dev_priv;
 350         int gmr_id;
 351         struct vmw_mob *mob;
 352         int mem_type;
 353         struct sg_table sgt;
 354         struct vmw_sg_table vsgt;
 355         bool mapped;
 356         bool bound;
 357 };
 358
 359 /*
 360  * enum vmw_display_unit_type - Describes the display unit
 361  */
 362 enum vmw_display_unit_type {
 363         vmw_du_invalid = 0,
 364         vmw_du_legacy,
 365         vmw_du_screen_object,
 366         vmw_du_screen_target,
 367         vmw_du_max
 368 };
 369
 370 struct vmw_validation_context;
 371 struct vmw_ctx_validation_info;
 372
 373 /**
 374  * struct vmw_sw_context - Command submission context
 375  * @res_ht: Pointer hash table used to find validation duplicates
 376  * @kernel: Whether the command buffer originates from kernel code rather
 377  * than from user-space
 378  * @fp: If @kernel is false, points to the file of the client. Otherwise
 379  * NULL
 380  * @cmd_bounce: Command bounce buffer used for command validation before
 381  * copying to fifo space
 382  * @cmd_bounce_size: Current command bounce buffer size
 383  * @cur_query_bo: Current buffer object used as query result buffer
 384  * @bo_relocations: List of buffer object relocations
 385  * @res_relocations: List of resource relocations
 386  * @buf_start: Pointer to start of memory where command validation takes
 387  * place
 388  * @res_cache: Cache of recently looked up resources
 389  * @last_query_ctx: Last context that submitted a query
 390  * @needs_post_query_barrier: Whether a query barrier is needed after
 391  * command submission
 392  * @staged_bindings: Cached per-context binding tracker
 393  * @staged_bindings_inuse: Whether the cached per-context binding tracker
 394  * is in use
 395  * @staged_cmd_res: List of staged command buffer managed resources in this
 396  * command buffer
 397  * @ctx_list: List of context resources referenced in this command buffer
 398  * @dx_ctx_node: Validation metadata of the current DX context
 399  * @dx_query_mob: The MOB used for DX queries
 400  * @dx_query_ctx: The DX context used for the last DX query
 401  * @man: Pointer to the command buffer managed resource manager
 402  * @ctx: The validation context
 403  */
 404 struct vmw_sw_context{
 405         DECLARE_HASHTABLE(res_ht, VMW_RES_HT_ORDER);
 406         bool kernel;
 407         struct vmw_fpriv *fp;
 408         struct drm_file *filp;
 409         uint32_t *cmd_bounce;
 410         uint32_t cmd_bounce_size;
 411         struct vmw_bo *cur_query_bo;
 412         struct list_head bo_relocations;
 413         struct list_head res_relocations;
 414         uint32_t *buf_start;
 415         struct vmw_res_cache_entry res_cache[vmw_res_max];
 416         struct vmw_resource *last_query_ctx;
 417         bool needs_post_query_barrier;
 418         struct vmw_ctx_binding_state *staged_bindings;
 419         bool staged_bindings_inuse;
 420         struct list_head staged_cmd_res;
 421         struct list_head ctx_list;
 422         struct vmw_ctx_validation_info *dx_ctx_node;
 423         struct vmw_bo *dx_query_mob;
 424         struct vmw_resource *dx_query_ctx;
 425         struct vmw_cmdbuf_res_manager *man;
 426         struct vmw_validation_context *ctx;
 427 };
 428
 429 struct vmw_legacy_display;
 430 struct vmw_overlay;
 431
 432 /*
 433  * struct vmw_otable - Guest Memory OBject table metadata
 434  *
 435  * @size:           Size of the table (page-aligned).
 436  * @page_table:     Pointer to a struct vmw_mob holding the page table.
 437  */
 438 struct vmw_otable {
 439         unsigned long size;
 440         struct vmw_mob *page_table;
 441         bool enabled;
 442 };
 443
 444 struct vmw_otable_batch {
 445         unsigned num_otables;
 446         struct vmw_otable *otables;
 447         struct vmw_resource *context;
 448         struct vmw_bo *otable_bo;
 449 };
 450
 451 enum {
 452         VMW_IRQTHREAD_FENCE,
 453         VMW_IRQTHREAD_CMDBUF,
 454         VMW_IRQTHREAD_MAX
 455 };
 456
 457 /**
 458  * enum vmw_sm_type - Graphics context capability supported by device.
 459  * @VMW_SM_LEGACY: Pre DX context.
 460  * @VMW_SM_4: Context support upto SM4.
 461  * @VMW_SM_4_1: Context support upto SM4_1.
 462  * @VMW_SM_5: Context support up to SM5.
 463  * @VMW_SM_5_1X: Adds support for sm5_1 and gl43 extensions.
 464  * @VMW_SM_MAX: Should be the last.
 465  */
 466 enum vmw_sm_type {
 467         VMW_SM_LEGACY = 0,
 468         VMW_SM_4,
 469         VMW_SM_4_1,
 470         VMW_SM_5,
 471         VMW_SM_5_1X,
 472         VMW_SM_MAX
 473 };
 474
 475 struct vmw_private {
 476         struct drm_device drm;
 477         struct ttm_device bdev;
 478
 479         u32 pci_id;
 480         resource_size_t io_start;
 481         resource_size_t vram_start;
 482         resource_size_t vram_size;
 483         resource_size_t max_primary_mem;
 484         u32 __iomem *rmmio;
 485         u32 *fifo_mem;
 486         resource_size_t fifo_mem_size;
 487         uint32_t fb_max_width;
 488         uint32_t fb_max_height;
 489         uint32_t texture_max_width;
 490         uint32_t texture_max_height;
 491         uint32_t stdu_max_width;
 492         uint32_t stdu_max_height;
 493         uint32_t initial_width;
 494         uint32_t initial_height;
 495         uint32_t capabilities;
 496         uint32_t capabilities2;
 497         uint32_t max_gmr_ids;
 498         uint32_t max_gmr_pages;
 499         uint32_t max_mob_pages;
 500         uint32_t max_mob_size;
 501         uint32_t memory_size;
 502         bool has_gmr;
 503         bool has_mob;
 504         spinlock_t hw_lock;
 505         bool assume_16bpp;
 506         u32 irqs[VMWGFX_MAX_NUM_IRQS];
 507         u32 num_irq_vectors;
 508
 509         enum vmw_sm_type sm_type;
 510
 511         /*
 512          * Framebuffer info.
 513          */
 514
 515         enum vmw_display_unit_type active_display_unit;
 516         struct vmw_legacy_display *ldu_priv;
 517         struct vmw_overlay *overlay_priv;
 518         struct drm_property *hotplug_mode_update_property;
 519         struct drm_property *implicit_placement_property;
 520         spinlock_t cursor_lock;
 521         struct drm_atomic_state *suspend_state;
 522
 523         /*
 524          * Context and surface management.
 525          */
 526
 527         spinlock_t resource_lock;
 528         struct idr res_idr[vmw_res_max];
 529
 530         /*
 531          * A resource manager for kernel-only surfaces and
 532          * contexts.
 533          */
 534
 535         struct ttm_object_device *tdev;
 536
 537         /*
 538          * Fencing and IRQs.
 539          */
 540
 541         atomic_t marker_seq;
 542         wait_queue_head_t fence_queue;
 543         wait_queue_head_t fifo_queue;
 544         spinlock_t waiter_lock;
 545         int fence_queue_waiters; /* Protected by waiter_lock */
 546         int goal_queue_waiters; /* Protected by waiter_lock */
 547         int cmdbuf_waiters; /* Protected by waiter_lock */
 548         int error_waiters; /* Protected by waiter_lock */
 549         int fifo_queue_waiters; /* Protected by waiter_lock */
 550         uint32_t last_read_seqno;
 551         struct vmw_fence_manager *fman;
 552         uint32_t irq_mask; /* Updates protected by waiter_lock */
 553
 554         /*
 555          * Device state
 556          */
 557
 558         uint32_t traces_state;
 559         uint32_t enable_state;
 560         uint32_t config_done_state;
 561
 562         /**
 563          * Execbuf
 564          */
 565         /**
 566          * Protected by the cmdbuf mutex.
 567          */
 568
 569         struct vmw_sw_context ctx;
 570         struct mutex cmdbuf_mutex;
 571         struct mutex binding_mutex;
 572
 573         /**
 574          * PM management.
 575          */
 576         struct notifier_block pm_nb;
 577         bool refuse_hibernation;
 578         bool suspend_locked;
 579
 580         atomic_t num_fifo_resources;
 581
 582         /*
 583          * Query processing. These members
 584          * are protected by the cmdbuf mutex.
 585          */
 586
 587         struct vmw_bo *dummy_query_bo;
 588         struct vmw_bo *pinned_bo;
 589         uint32_t query_cid;
 590         uint32_t query_cid_valid;
 591         bool dummy_query_bo_pinned;
 592
 593         /*
 594          * Surface swapping. The "surface_lru" list is protected by the
 595          * resource lock in order to be able to destroy a surface and take
 596          * it off the lru atomically. "used_memory_size" is currently
 597          * protected by the cmdbuf mutex for simplicity.
 598          */
 599
 600         struct list_head res_lru[vmw_res_max];
 601         uint32_t used_memory_size;
 602
 603         /*
 604          * DMA mapping stuff.
 605          */
 606         enum vmw_dma_map_mode map_mode;
 607
 608         /*
 609          * Guest Backed stuff
 610          */
 611         struct vmw_otable_batch otable_batch;
 612
 613         struct vmw_fifo_state *fifo;
 614         struct vmw_cmdbuf_man *cman;
 615         DECLARE_BITMAP(irqthread_pending, VMW_IRQTHREAD_MAX);
 616
 617         uint32 *devcaps;
 618
 619         bool vkms_enabled;
 620         struct workqueue_struct *crc_workq;
 621
 622         /*
 623          * mksGuestStat instance-descriptor and pid arrays
 624          */
 625         struct page *mksstat_user_pages[MKSSTAT_CAPACITY];
 626         atomic_t mksstat_user_pids[MKSSTAT_CAPACITY];
 627
 628 #if IS_ENABLED(CONFIG_DRM_VMWGFX_MKSSTATS)
 629         struct page *mksstat_kern_pages[MKSSTAT_CAPACITY];
 630         u8 mksstat_kern_top_timer[MKSSTAT_CAPACITY];
 631         atomic_t mksstat_kern_pids[MKSSTAT_CAPACITY];
 632 #endif
 633 };
 634
 635 static inline struct vmw_surface *vmw_res_to_srf(struct vmw_resource *res)
 636 {
 637         return container_of(res, struct vmw_surface, res);
 638 }
 639
 640 static inline struct vmw_private *vmw_priv(struct drm_device *dev)
 641 {
 642         return container_of(dev, struct vmw_private, drm);
 643 }
 644
 645 static inline struct vmw_private *vmw_priv_from_ttm(struct ttm_device *bdev)
 646 {
 647         return container_of(bdev, struct vmw_private, bdev);
 648 }
 649
 650 static inline struct vmw_fpriv *vmw_fpriv(struct drm_file *file_priv)
 651 {
 652         return (struct vmw_fpriv *)file_priv->driver_priv;
 653 }
 654
 655 /*
 656  * SVGA v3 has mmio register access and lacks fifo cmds
 657  */
 658 static inline bool vmw_is_svga_v3(const struct vmw_private *dev)
 659 {
 660         return dev->pci_id == VMWGFX_PCI_ID_SVGA3;
 661 }
 662
 663 /*
 664  * The locking here is fine-grained, so that it is performed once
 665  * for every read- and write operation. This is of course costly, but we
 666  * don't perform much register access in the timing critical paths anyway.
 667  * Instead we have the extra benefit of being sure that we don't forget
 668  * the hw lock around register accesses.
 669  */
 670 static inline void vmw_write(struct vmw_private *dev_priv,
 671                              unsigned int offset, uint32_t value)
 672 {
 673         if (vmw_is_svga_v3(dev_priv)) {
 674                 iowrite32(value, dev_priv->rmmio + offset);
 675         } else {
 676                 spin_lock(&dev_priv->hw_lock);
 677                 outl(offset, dev_priv->io_start + SVGA_INDEX_PORT);
 678                 outl(value, dev_priv->io_start + SVGA_VALUE_PORT);
 679                 spin_unlock(&dev_priv->hw_lock);
 680         }
 681 }
 682
 683 static inline uint32_t vmw_read(struct vmw_private *dev_priv,
 684                                 unsigned int offset)
 685 {
 686         u32 val;
 687
 688         if (vmw_is_svga_v3(dev_priv)) {
 689                 val = ioread32(dev_priv->rmmio + offset);
 690         } else {
 691                 spin_lock(&dev_priv->hw_lock);
 692                 outl(offset, dev_priv->io_start + SVGA_INDEX_PORT);
 693                 val = inl(dev_priv->io_start + SVGA_VALUE_PORT);
 694                 spin_unlock(&dev_priv->hw_lock);
 695         }
 696
 697         return val;
 698 }
 699
 700 /**
 701  * has_sm4_context - Does the device support SM4 context.
 702  * @dev_priv: Device private.
 703  *
 704  * Return: Bool value if device support SM4 context or not.
 705  */
 706 static inline bool has_sm4_context(const struct vmw_private *dev_priv)
 707 {
 708         return (dev_priv->sm_type >= VMW_SM_4);
 709 }
 710
 711 /**
 712  * has_sm4_1_context - Does the device support SM4_1 context.
 713  * @dev_priv: Device private.
 714  *
 715  * Return: Bool value if device support SM4_1 context or not.
 716  */
 717 static inline bool has_sm4_1_context(const struct vmw_private *dev_priv)
 718 {
 719         return (dev_priv->sm_type >= VMW_SM_4_1);
 720 }
 721
 722 /**
 723  * has_sm5_context - Does the device support SM5 context.
 724  * @dev_priv: Device private.
 725  *
 726  * Return: Bool value if device support SM5 context or not.
 727  */
 728 static inline bool has_sm5_context(const struct vmw_private *dev_priv)
 729 {
 730         return (dev_priv->sm_type >= VMW_SM_5);
 731 }
 732
 733 /**
 734  * has_gl43_context - Does the device support GL43 context.
 735  * @dev_priv: Device private.
 736  *
 737  * Return: Bool value if device support SM5 context or not.
 738  */
 739 static inline bool has_gl43_context(const struct vmw_private *dev_priv)
 740 {
 741         return (dev_priv->sm_type >= VMW_SM_5_1X);
 742 }
 743
 744
 745 static inline u32 vmw_max_num_uavs(struct vmw_private *dev_priv)
 746 {
 747         return (has_gl43_context(dev_priv) ?
 748                         SVGA3D_DX11_1_MAX_UAVIEWS : SVGA3D_MAX_UAVIEWS);
 749 }
 750
 751 extern void vmw_svga_enable(struct vmw_private *dev_priv);
 752 extern void vmw_svga_disable(struct vmw_private *dev_priv);
 753 bool vmwgfx_supported(struct vmw_private *vmw);
 754
 755
 756 /**
 757  * GMR utilities - vmwgfx_gmr.c
 758  */
 759
 760 extern int vmw_gmr_bind(struct vmw_private *dev_priv,
 761                         const struct vmw_sg_table *vsgt,
 762                         unsigned long num_pages,
 763                         int gmr_id);
 764 extern void vmw_gmr_unbind(struct vmw_private *dev_priv, int gmr_id);
 765
 766 /**
 767  * User handles
 768  */
 769 struct vmw_user_object {
 770         struct vmw_surface *surface;
 771         struct vmw_bo *buffer;
 772 };
 773
 774 int vmw_user_object_lookup(struct vmw_private *dev_priv, struct drm_file *filp,
 775                            u32 handle, struct vmw_user_object *uo);
 776 struct vmw_user_object *vmw_user_object_ref(struct vmw_user_object *uo);
 777 void vmw_user_object_unref(struct vmw_user_object *uo);
 778 bool vmw_user_object_is_null(struct vmw_user_object *uo);
 779 struct vmw_surface *vmw_user_object_surface(struct vmw_user_object *uo);
 780 struct vmw_bo *vmw_user_object_buffer(struct vmw_user_object *uo);
 781 void *vmw_user_object_map(struct vmw_user_object *uo);
 782 void *vmw_user_object_map_size(struct vmw_user_object *uo, size_t size);
 783 void vmw_user_object_unmap(struct vmw_user_object *uo);
 784 bool vmw_user_object_is_mapped(struct vmw_user_object *uo);
 785
 786 /**
 787  * Resource utilities - vmwgfx_resource.c
 788  */
 789 struct vmw_user_resource_conv;
 790
 791 extern void vmw_resource_unreference(struct vmw_resource **p_res);
 792 extern struct vmw_resource *vmw_resource_reference(struct vmw_resource *res);
 793 extern struct vmw_resource *
 794 vmw_resource_reference_unless_doomed(struct vmw_resource *res);
 795 extern int vmw_resource_validate(struct vmw_resource *res, bool intr,
 796                                  bool dirtying);
 797 extern int vmw_resource_reserve(struct vmw_resource *res, bool interruptible,
 798                                 bool no_backup);
 799 extern bool vmw_resource_needs_backup(const struct vmw_resource *res);
 800 extern int vmw_user_resource_lookup_handle(
 801         struct vmw_private *dev_priv,
 802         struct ttm_object_file *tfile,
 803         uint32_t handle,
 804         const struct vmw_user_resource_conv *converter,
 805         struct vmw_resource **p_res);
 806
 807 extern int vmw_stream_claim_ioctl(struct drm_device *dev, void *data,
 808                                   struct drm_file *file_priv);
 809 extern int vmw_stream_unref_ioctl(struct drm_device *dev, void *data,
 810                                   struct drm_file *file_priv);
 811 extern int vmw_user_stream_lookup(struct vmw_private *dev_priv,
 812                                   struct ttm_object_file *tfile,
 813                                   uint32_t *inout_id,
 814                                   struct vmw_resource **out);
 815 extern void vmw_resource_unreserve(struct vmw_resource *res,
 816                                    bool dirty_set,
 817                                    bool dirty,
 818                                    bool switch_guest_memory,
 819                                    struct vmw_bo *new_guest_memory,
 820                                    unsigned long new_guest_memory_offset);
 821 extern void vmw_query_move_notify(struct ttm_buffer_object *bo,
 822                                   struct ttm_resource *old_mem,
 823                                   struct ttm_resource *new_mem);
 824 int vmw_query_readback_all(struct vmw_bo *dx_query_mob);
 825 void vmw_resource_evict_all(struct vmw_private *dev_priv);
 826 void vmw_resource_unbind_list(struct vmw_bo *vbo);
 827 void vmw_resource_mob_attach(struct vmw_resource *res);
 828 void vmw_resource_mob_detach(struct vmw_resource *res);
 829 void vmw_resource_dirty_update(struct vmw_resource *res, pgoff_t start,
 830                                pgoff_t end);
 831 int vmw_resource_clean(struct vmw_resource *res);
 832 int vmw_resources_clean(struct vmw_bo *vbo, pgoff_t start,
 833                         pgoff_t end, pgoff_t *num_prefault);
 834
 835 /**
 836  * vmw_resource_mob_attached - Whether a resource currently has a mob attached
 837  * @res: The resource
 838  *
 839  * Return: true if the resource has a mob attached, false otherwise.
 840  */
 841 static inline bool vmw_resource_mob_attached(const struct vmw_resource *res)
 842 {
 843         return !RB_EMPTY_NODE(&res->mob_node);
 844 }
 845
 846 /**
 847  * GEM related functionality - vmwgfx_gem.c
 848  */
 849 struct vmw_bo_params;
 850 int vmw_gem_object_create(struct vmw_private *vmw,
 851                           struct vmw_bo_params *params,
 852                           struct vmw_bo **p_vbo);
 853 extern int vmw_gem_object_create_with_handle(struct vmw_private *dev_priv,
 854                                              struct drm_file *filp,
 855                                              uint32_t size,
 856                                              uint32_t *handle,
 857                                              struct vmw_bo **p_vbo);
 858 extern int vmw_gem_object_create_ioctl(struct drm_device *dev, void *data,
 859                                        struct drm_file *filp);
 860 extern void vmw_debugfs_gem_init(struct vmw_private *vdev);
 861
 862 /**
 863  * Misc Ioctl functionality - vmwgfx_ioctl.c
 864  */
 865
 866 extern int vmw_getparam_ioctl(struct drm_device *dev, void *data,
 867                               struct drm_file *file_priv);
 868 extern int vmw_get_cap_3d_ioctl(struct drm_device *dev, void *data,
 869                                 struct drm_file *file_priv);
 870 extern int vmw_present_ioctl(struct drm_device *dev, void *data,
 871                              struct drm_file *file_priv);
 872 extern int vmw_present_readback_ioctl(struct drm_device *dev, void *data,
 873                                       struct drm_file *file_priv);
 874
 875 /**
 876  * Fifo utilities - vmwgfx_fifo.c
 877  */
 878
 879 extern struct vmw_fifo_state *vmw_fifo_create(struct vmw_private *dev_priv);
 880 extern void vmw_fifo_destroy(struct vmw_private *dev_priv);
 881 extern bool vmw_cmd_supported(struct vmw_private *vmw);
 882 extern void *
 883 vmw_cmd_ctx_reserve(struct vmw_private *dev_priv, uint32_t bytes, int ctx_id);
 884 extern void vmw_cmd_commit(struct vmw_private *dev_priv, uint32_t bytes);
 885 extern void vmw_cmd_commit_flush(struct vmw_private *dev_priv, uint32_t bytes);
 886 extern int vmw_cmd_send_fence(struct vmw_private *dev_priv, uint32_t *seqno);
 887 extern bool vmw_supports_3d(struct vmw_private *dev_priv);
 888 extern void vmw_fifo_ping_host(struct vmw_private *dev_priv, uint32_t reason);
 889 extern bool vmw_fifo_have_pitchlock(struct vmw_private *dev_priv);
 890 extern int vmw_cmd_emit_dummy_query(struct vmw_private *dev_priv,
 891                                     uint32_t cid);
 892 extern int vmw_cmd_flush(struct vmw_private *dev_priv,
 893                          bool interruptible);
 894
 895 #define VMW_CMD_CTX_RESERVE(__priv, __bytes, __ctx_id)                        \
 896 ({                                                                            \
 897         vmw_cmd_ctx_reserve(__priv, __bytes, __ctx_id) ? : ({                 \
 898                 DRM_ERROR("FIFO reserve failed at %s for %u bytes\n",         \
 899                           __func__, (unsigned int) __bytes);                  \
 900                 NULL;                                                         \
 901         });                                                                   \
 902 })
 903
 904 #define VMW_CMD_RESERVE(__priv, __bytes)                                     \
 905         VMW_CMD_CTX_RESERVE(__priv, __bytes, SVGA3D_INVALID_ID)
 906
 907
 908 /**
 909  * vmw_fifo_caps - Returns the capabilities of the FIFO command
 910  * queue or 0 if fifo memory isn't present.
 911  * @dev_priv: The device private context
 912  */
 913 static inline uint32_t vmw_fifo_caps(const struct vmw_private *dev_priv)
 914 {
 915         if (!dev_priv->fifo_mem || !dev_priv->fifo)
 916                 return 0;
 917         return dev_priv->fifo->capabilities;
 918 }
 919
 920
 921 /**
 922  * vmw_is_cursor_bypass3_enabled - Returns TRUE iff Cursor Bypass 3
 923  * is enabled in the FIFO.
 924  * @dev_priv: The device private context
 925  */
 926 static inline bool
 927 vmw_is_cursor_bypass3_enabled(const struct vmw_private *dev_priv)
 928 {
 929         return (vmw_fifo_caps(dev_priv) & SVGA_FIFO_CAP_CURSOR_BYPASS_3) != 0;
 930 }
 931
 932 /**
 933  * TTM buffer object driver - vmwgfx_ttm_buffer.c
 934  */
 935
 936 extern const size_t vmw_tt_size;
 937 extern struct ttm_placement vmw_vram_placement;
 938 extern struct ttm_placement vmw_sys_placement;
 939 extern struct ttm_device_funcs vmw_bo_driver;
 940 extern const struct vmw_sg_table *
 941 vmw_bo_sg_table(struct ttm_buffer_object *bo);
 942 int vmw_bo_create_and_populate(struct vmw_private *dev_priv,
 943                                size_t bo_size,
 944                                u32 domain,
 945                                struct vmw_bo **bo_p);
 946
 947 extern void vmw_piter_start(struct vmw_piter *viter,
 948                             const struct vmw_sg_table *vsgt,
 949                             unsigned long p_offs);
 950
 951 /**
 952  * vmw_piter_next - Advance the iterator one page.
 953  *
 954  * @viter: Pointer to the iterator to advance.
 955  *
 956  * Returns false if past the list of pages, true otherwise.
 957  */
 958 static inline bool vmw_piter_next(struct vmw_piter *viter)
 959 {
 960         return viter->next(viter);
 961 }
 962
 963 /**
 964  * vmw_piter_dma_addr - Return the DMA address of the current page.
 965  *
 966  * @viter: Pointer to the iterator
 967  *
 968  * Returns the DMA address of the page pointed to by @viter.
 969  */
 970 static inline dma_addr_t vmw_piter_dma_addr(struct vmw_piter *viter)
 971 {
 972         return viter->dma_address(viter);
 973 }
 974
 975 /**
 976  * vmw_piter_page - Return a pointer to the current page.
 977  *
 978  * @viter: Pointer to the iterator
 979  *
 980  * Returns the DMA address of the page pointed to by @viter.
 981  */
 982 static inline struct page *vmw_piter_page(struct vmw_piter *viter)
 983 {
 984         return viter->pages[viter->i];
 985 }
 986
 987 /**
 988  * Command submission - vmwgfx_execbuf.c
 989  */
 990
 991 extern int vmw_execbuf_ioctl(struct drm_device *dev, void *data,
 992                              struct drm_file *file_priv);
 993 extern int vmw_execbuf_process(struct drm_file *file_priv,
 994                                struct vmw_private *dev_priv,
 995                                void __user *user_commands,
 996                                void *kernel_commands,
 997                                uint32_t command_size,
 998                                uint64_t throttle_us,
 999                                uint32_t dx_context_handle,
1000                                struct drm_vmw_fence_rep __user
1001                                *user_fence_rep,
1002                                struct vmw_fence_obj **out_fence,
1003                                uint32_t flags);
1004 extern void __vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv,
1005                                             struct vmw_fence_obj *fence);
1006 extern void vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv);
1007
1008 extern int vmw_execbuf_fence_commands(struct drm_file *file_priv,
1009                                       struct vmw_private *dev_priv,
1010                                       struct vmw_fence_obj **p_fence,
1011                                       uint32_t *p_handle);
1012 extern int vmw_execbuf_copy_fence_user(struct vmw_private *dev_priv,
1013                                         struct vmw_fpriv *vmw_fp,
1014                                         int ret,
1015                                         struct drm_vmw_fence_rep __user
1016                                         *user_fence_rep,
1017                                         struct vmw_fence_obj *fence,
1018                                         uint32_t fence_handle,
1019                                         int32_t out_fence_fd);
1020 bool vmw_cmd_describe(const void *buf, u32 *size, char const **cmd);
1021
1022 /**
1023  * IRQs and wating - vmwgfx_irq.c
1024  */
1025
1026 extern int vmw_irq_install(struct vmw_private *dev_priv);
1027 extern void vmw_irq_uninstall(struct drm_device *dev);
1028 extern bool vmw_seqno_passed(struct vmw_private *dev_priv,
1029                                 uint32_t seqno);
1030 extern int vmw_fallback_wait(struct vmw_private *dev_priv,
1031                              bool lazy,
1032                              bool fifo_idle,
1033                              uint32_t seqno,
1034                              bool interruptible,
1035                              unsigned long timeout);
1036 extern void vmw_update_seqno(struct vmw_private *dev_priv);
1037 extern void vmw_seqno_waiter_add(struct vmw_private *dev_priv);
1038 extern void vmw_seqno_waiter_remove(struct vmw_private *dev_priv);
1039 extern void vmw_goal_waiter_add(struct vmw_private *dev_priv);
1040 extern void vmw_goal_waiter_remove(struct vmw_private *dev_priv);
1041 extern void vmw_generic_waiter_add(struct vmw_private *dev_priv, u32 flag,
1042                                    int *waiter_count);
1043 extern void vmw_generic_waiter_remove(struct vmw_private *dev_priv,
1044                                       u32 flag, int *waiter_count);
1045
1046 /**
1047  * Kernel modesetting - vmwgfx_kms.c
1048  */
1049
1050 int vmw_kms_init(struct vmw_private *dev_priv);
1051 int vmw_kms_close(struct vmw_private *dev_priv);
1052 int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,
1053                                 struct drm_file *file_priv);
1054 void vmw_kms_cursor_post_execbuf(struct vmw_private *dev_priv);
1055 void vmw_kms_cursor_snoop(struct vmw_surface *srf,
1056                           struct ttm_object_file *tfile,
1057                           struct ttm_buffer_object *bo,
1058                           SVGA3dCmdHeader *header);
1059 int vmw_kms_write_svga(struct vmw_private *vmw_priv,
1060                        unsigned width, unsigned height, unsigned pitch,
1061                        unsigned bpp, unsigned depth);
1062 int vmw_kms_present(struct vmw_private *dev_priv,
1063                     struct drm_file *file_priv,
1064                     struct vmw_framebuffer *vfb,
1065                     struct vmw_surface *surface,
1066                     uint32_t sid, int32_t destX, int32_t destY,
1067                     struct drm_vmw_rect *clips,
1068                     uint32_t num_clips);
1069 int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
1070                                 struct drm_file *file_priv);
1071 void vmw_kms_legacy_hotspot_clear(struct vmw_private *dev_priv);
1072 int vmw_kms_suspend(struct drm_device *dev);
1073 int vmw_kms_resume(struct drm_device *dev);
1074 void vmw_kms_lost_device(struct drm_device *dev);
1075
1076 extern int vmw_resource_pin(struct vmw_resource *res, bool interruptible);
1077 extern void vmw_resource_unpin(struct vmw_resource *res);
1078 extern enum vmw_res_type vmw_res_type(const struct vmw_resource *res);
1079
1080 /**
1081  * Overlay control - vmwgfx_overlay.c
1082  */
1083
1084 int vmw_overlay_init(struct vmw_private *dev_priv);
1085 int vmw_overlay_close(struct vmw_private *dev_priv);
1086 int vmw_overlay_ioctl(struct drm_device *dev, void *data,
1087                       struct drm_file *file_priv);
1088 int vmw_overlay_resume_all(struct vmw_private *dev_priv);
1089 int vmw_overlay_pause_all(struct vmw_private *dev_priv);
1090 int vmw_overlay_claim(struct vmw_private *dev_priv, uint32_t *out);
1091 int vmw_overlay_unref(struct vmw_private *dev_priv, uint32_t stream_id);
1092 int vmw_overlay_num_overlays(struct vmw_private *dev_priv);
1093 int vmw_overlay_num_free_overlays(struct vmw_private *dev_priv);
1094
1095 /**
1096  * GMR Id manager
1097  */
1098
1099 int vmw_gmrid_man_init(struct vmw_private *dev_priv, int type);
1100 void vmw_gmrid_man_fini(struct vmw_private *dev_priv, int type);
1101
1102 /**
1103  * System memory manager
1104  */
1105 int vmw_sys_man_init(struct vmw_private *dev_priv);
1106 void vmw_sys_man_fini(struct vmw_private *dev_priv);
1107
1108 /**
1109  * Prime - vmwgfx_prime.c
1110  */
1111
1112 extern const struct dma_buf_ops vmw_prime_dmabuf_ops;
1113 extern int vmw_prime_fd_to_handle(struct drm_device *dev,
1114                                   struct drm_file *file_priv,
1115                                   int fd, u32 *handle);
1116 extern int vmw_prime_handle_to_fd(struct drm_device *dev,
1117                                   struct drm_file *file_priv,
1118                                   uint32_t handle, uint32_t flags,
1119                                   int *prime_fd);
1120 struct drm_gem_object *vmw_prime_import_sg_table(struct drm_device *dev,
1121                                                  struct dma_buf_attachment *attach,
1122                                                  struct sg_table *table);
1123
1124 /*
1125  * MemoryOBject management -  vmwgfx_mob.c
1126  */
1127 struct vmw_mob;
1128 extern int vmw_mob_bind(struct vmw_private *dev_priv, struct vmw_mob *mob,
1129                         const struct vmw_sg_table *vsgt,
1130                         unsigned long num_data_pages, int32_t mob_id);
1131 extern void vmw_mob_unbind(struct vmw_private *dev_priv,
1132                            struct vmw_mob *mob);
1133 extern void vmw_mob_destroy(struct vmw_mob *mob);
1134 extern struct vmw_mob *vmw_mob_create(unsigned long data_pages);
1135 extern int vmw_otables_setup(struct vmw_private *dev_priv);
1136 extern void vmw_otables_takedown(struct vmw_private *dev_priv);
1137
1138 /*
1139  * Context management - vmwgfx_context.c
1140  */
1141
1142 extern const struct vmw_user_resource_conv *user_context_converter;
1143
1144 extern int vmw_context_define_ioctl(struct drm_device *dev, void *data,
1145                                     struct drm_file *file_priv);
1146 extern int vmw_extended_context_define_ioctl(struct drm_device *dev, void *data,
1147                                              struct drm_file *file_priv);
1148 extern int vmw_context_destroy_ioctl(struct drm_device *dev, void *data,
1149                                      struct drm_file *file_priv);
1150 extern struct list_head *vmw_context_binding_list(struct vmw_resource *ctx);
1151 extern struct vmw_cmdbuf_res_manager *
1152 vmw_context_res_man(struct vmw_resource *ctx);
1153 extern struct vmw_resource *vmw_context_cotable(struct vmw_resource *ctx,
1154                                                 SVGACOTableType cotable_type);
1155 struct vmw_ctx_binding_state;
1156 extern struct vmw_ctx_binding_state *
1157 vmw_context_binding_state(struct vmw_resource *ctx);
1158 extern void vmw_dx_context_scrub_cotables(struct vmw_resource *ctx,
1159                                           bool readback);
1160 extern int vmw_context_bind_dx_query(struct vmw_resource *ctx_res,
1161                                      struct vmw_bo *mob);
1162 extern struct vmw_bo *
1163 vmw_context_get_dx_query_mob(struct vmw_resource *ctx_res);
1164
1165
1166 /*
1167  * Surface management - vmwgfx_surface.c
1168  */
1169
1170 extern const struct vmw_user_resource_conv *user_surface_converter;
1171
1172 extern int vmw_surface_destroy_ioctl(struct drm_device *dev, void *data,
1173                                      struct drm_file *file_priv);
1174 extern int vmw_surface_define_ioctl(struct drm_device *dev, void *data,
1175                                     struct drm_file *file_priv);
1176 extern int vmw_surface_reference_ioctl(struct drm_device *dev, void *data,
1177                                        struct drm_file *file_priv);
1178 extern int vmw_gb_surface_define_ioctl(struct drm_device *dev, void *data,
1179                                        struct drm_file *file_priv);
1180 extern int vmw_gb_surface_reference_ioctl(struct drm_device *dev, void *data,
1181                                           struct drm_file *file_priv);
1182 extern int vmw_gb_surface_define_ext_ioctl(struct drm_device *dev,
1183                                            void *data,
1184                                            struct drm_file *file_priv);
1185 extern int vmw_gb_surface_reference_ext_ioctl(struct drm_device *dev,
1186                                               void *data,
1187                                               struct drm_file *file_priv);
1188
1189 int vmw_gb_surface_define(struct vmw_private *dev_priv,
1190                           const struct vmw_surface_metadata *req,
1191                           struct vmw_surface **srf_out);
1192 struct vmw_surface *vmw_lookup_surface_for_buffer(struct vmw_private *vmw,
1193                                                   struct vmw_bo *bo,
1194                                                   u32 handle);
1195 u32 vmw_lookup_surface_handle_for_buffer(struct vmw_private *vmw,
1196                                          struct vmw_bo *bo,
1197                                          u32 handle);
1198 int vmw_dumb_create(struct drm_file *file_priv,
1199                     struct drm_device *dev,
1200                     struct drm_mode_create_dumb *args);
1201
1202 /*
1203  * Shader management - vmwgfx_shader.c
1204  */
1205
1206 extern const struct vmw_user_resource_conv *user_shader_converter;
1207
1208 extern int vmw_shader_define_ioctl(struct drm_device *dev, void *data,
1209                                    struct drm_file *file_priv);
1210 extern int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data,
1211                                     struct drm_file *file_priv);
1212 extern int vmw_compat_shader_add(struct vmw_private *dev_priv,
1213                                  struct vmw_cmdbuf_res_manager *man,
1214                                  u32 user_key, const void *bytecode,
1215                                  SVGA3dShaderType shader_type,
1216                                  size_t size,
1217                                  struct list_head *list);
1218 extern int vmw_shader_remove(struct vmw_cmdbuf_res_manager *man,
1219                              u32 user_key, SVGA3dShaderType shader_type,
1220                              struct list_head *list);
1221 extern int vmw_dx_shader_add(struct vmw_cmdbuf_res_manager *man,
1222                              struct vmw_resource *ctx,
1223                              u32 user_key,
1224                              SVGA3dShaderType shader_type,
1225                              struct list_head *list);
1226 extern void vmw_dx_shader_cotable_list_scrub(struct vmw_private *dev_priv,
1227                                              struct list_head *list,
1228                                              bool readback);
1229
1230 extern struct vmw_resource *
1231 vmw_shader_lookup(struct vmw_cmdbuf_res_manager *man,
1232                   u32 user_key, SVGA3dShaderType shader_type);
1233
1234 /*
1235  * Streamoutput management
1236  */
1237 struct vmw_resource *
1238 vmw_dx_streamoutput_lookup(struct vmw_cmdbuf_res_manager *man,
1239                            u32 user_key);
1240 int vmw_dx_streamoutput_add(struct vmw_cmdbuf_res_manager *man,
1241                             struct vmw_resource *ctx,
1242                             SVGA3dStreamOutputId user_key,
1243                             struct list_head *list);
1244 void vmw_dx_streamoutput_set_size(struct vmw_resource *res, u32 size);
1245 int vmw_dx_streamoutput_remove(struct vmw_cmdbuf_res_manager *man,
1246                                SVGA3dStreamOutputId user_key,
1247                                struct list_head *list);
1248 void vmw_dx_streamoutput_cotable_list_scrub(struct vmw_private *dev_priv,
1249                                             struct list_head *list,
1250                                             bool readback);
1251
1252 /*
1253  * Command buffer managed resources - vmwgfx_cmdbuf_res.c
1254  */
1255
1256 extern struct vmw_cmdbuf_res_manager *
1257 vmw_cmdbuf_res_man_create(struct vmw_private *dev_priv);
1258 extern void vmw_cmdbuf_res_man_destroy(struct vmw_cmdbuf_res_manager *man);
1259 extern struct vmw_resource *
1260 vmw_cmdbuf_res_lookup(struct vmw_cmdbuf_res_manager *man,
1261                       enum vmw_cmdbuf_res_type res_type,
1262                       u32 user_key);
1263 extern void vmw_cmdbuf_res_revert(struct list_head *list);
1264 extern void vmw_cmdbuf_res_commit(struct list_head *list);
1265 extern int vmw_cmdbuf_res_add(struct vmw_cmdbuf_res_manager *man,
1266                               enum vmw_cmdbuf_res_type res_type,
1267                               u32 user_key,
1268                               struct vmw_resource *res,
1269                               struct list_head *list);
1270 extern int vmw_cmdbuf_res_remove(struct vmw_cmdbuf_res_manager *man,
1271                                  enum vmw_cmdbuf_res_type res_type,
1272                                  u32 user_key,
1273                                  struct list_head *list,
1274                                  struct vmw_resource **res);
1275
1276 /*
1277  * COTable management - vmwgfx_cotable.c
1278  */
1279 extern const SVGACOTableType vmw_cotable_scrub_order[];
1280 extern struct vmw_resource *vmw_cotable_alloc(struct vmw_private *dev_priv,
1281                                               struct vmw_resource *ctx,
1282                                               u32 type);
1283 extern int vmw_cotable_notify(struct vmw_resource *res, int id);
1284 extern int vmw_cotable_scrub(struct vmw_resource *res, bool readback);
1285 extern void vmw_cotable_add_resource(struct vmw_resource *ctx,
1286                                      struct list_head *head);
1287
1288 /*
1289  * Command buffer managerment vmwgfx_cmdbuf.c
1290  */
1291 struct vmw_cmdbuf_man;
1292 struct vmw_cmdbuf_header;
1293
1294 extern struct vmw_cmdbuf_man *
1295 vmw_cmdbuf_man_create(struct vmw_private *dev_priv);
1296 extern int vmw_cmdbuf_set_pool_size(struct vmw_cmdbuf_man *man, size_t size);
1297 extern void vmw_cmdbuf_remove_pool(struct vmw_cmdbuf_man *man);
1298 extern void vmw_cmdbuf_man_destroy(struct vmw_cmdbuf_man *man);
1299 extern int vmw_cmdbuf_idle(struct vmw_cmdbuf_man *man, bool interruptible,
1300                            unsigned long timeout);
1301 extern void *vmw_cmdbuf_reserve(struct vmw_cmdbuf_man *man, size_t size,
1302                                 int ctx_id, bool interruptible,
1303                                 struct vmw_cmdbuf_header *header);
1304 extern void vmw_cmdbuf_commit(struct vmw_cmdbuf_man *man, size_t size,
1305                               struct vmw_cmdbuf_header *header,
1306                               bool flush);
1307 extern void *vmw_cmdbuf_alloc(struct vmw_cmdbuf_man *man,
1308                               size_t size, bool interruptible,
1309                               struct vmw_cmdbuf_header **p_header);
1310 extern void vmw_cmdbuf_header_free(struct vmw_cmdbuf_header *header);
1311 extern int vmw_cmdbuf_cur_flush(struct vmw_cmdbuf_man *man,
1312                                 bool interruptible);
1313 extern void vmw_cmdbuf_irqthread(struct vmw_cmdbuf_man *man);
1314
1315 /* CPU blit utilities - vmwgfx_blit.c */
1316
1317 /**
1318  * struct vmw_diff_cpy - CPU blit information structure
1319  *
1320  * @rect: The output bounding box rectangle.
1321  * @line: The current line of the blit.
1322  * @line_offset: Offset of the current line segment.
1323  * @cpp: Bytes per pixel (granularity information).
1324  * @memcpy: Which memcpy function to use.
1325  */
1326 struct vmw_diff_cpy {
1327         struct drm_rect rect;
1328         size_t line;
1329         size_t line_offset;
1330         int cpp;
1331         void (*do_cpy)(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src,
1332                        size_t n);
1333 };
1334
1335 #define VMW_CPU_BLIT_INITIALIZER {      \
1336         .do_cpy = vmw_memcpy,           \
1337 }
1338
1339 #define VMW_CPU_BLIT_DIFF_INITIALIZER(_cpp) {     \
1340         .line = 0,                                \
1341         .line_offset = 0,                         \
1342         .rect = { .x1 = INT_MAX/2,                \
1343                   .y1 = INT_MAX/2,                \
1344                   .x2 = INT_MIN/2,                \
1345                   .y2 = INT_MIN/2                 \
1346         },                                        \
1347         .cpp = _cpp,                              \
1348         .do_cpy = vmw_diff_memcpy,                \
1349 }
1350
1351 void vmw_diff_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src,
1352                      size_t n);
1353
1354 void vmw_memcpy(struct vmw_diff_cpy *diff, u8 *dest, const u8 *src, size_t n);
1355
1356 int vmw_bo_cpu_blit(struct vmw_bo *dst,
1357                     u32 dst_offset, u32 dst_stride,
1358                     struct vmw_bo *src,
1359                     u32 src_offset, u32 src_stride,
1360                     u32 w, u32 h,
1361                     struct vmw_diff_cpy *diff);
1362
1363 /* Host messaging -vmwgfx_msg.c: */
1364 void vmw_disable_backdoor(void);
1365 int vmw_host_get_guestinfo(const char *guest_info_param,
1366                            char *buffer, size_t *length);
1367 __printf(1, 2) int vmw_host_printf(const char *fmt, ...);
1368 int vmw_msg_ioctl(struct drm_device *dev, void *data,
1369                   struct drm_file *file_priv);
1370
1371 /* Host mksGuestStats -vmwgfx_msg.c: */
1372 int vmw_mksstat_get_kern_slot(pid_t pid, struct vmw_private *dev_priv);
1373
1374 int vmw_mksstat_reset_ioctl(struct drm_device *dev, void *data,
1375                       struct drm_file *file_priv);
1376 int vmw_mksstat_add_ioctl(struct drm_device *dev, void *data,
1377                       struct drm_file *file_priv);
1378 int vmw_mksstat_remove_ioctl(struct drm_device *dev, void *data,
1379                       struct drm_file *file_priv);
1380 int vmw_mksstat_remove_all(struct vmw_private *dev_priv);
1381
1382 /* VMW logging */
1383
1384 /**
1385  * VMW_DEBUG_USER - Debug output for user-space debugging.
1386  *
1387  * @fmt: printf() like format string.
1388  *
1389  * This macro is for logging user-space error and debugging messages for e.g.
1390  * command buffer execution errors due to malformed commands, invalid context,
1391  * etc.
1392  */
1393 #define VMW_DEBUG_USER(fmt, ...)                                              \
1394         DRM_DEBUG_DRIVER(fmt, ##__VA_ARGS__)
1395
1396 /* Resource dirtying - vmwgfx_page_dirty.c */
1397 void vmw_bo_dirty_scan(struct vmw_bo *vbo);
1398 int vmw_bo_dirty_add(struct vmw_bo *vbo);
1399 void vmw_bo_dirty_transfer_to_res(struct vmw_resource *res);
1400 void vmw_bo_dirty_clear_res(struct vmw_resource *res);
1401 void vmw_bo_dirty_release(struct vmw_bo *vbo);
1402 void vmw_bo_dirty_unmap(struct vmw_bo *vbo,
1403                         pgoff_t start, pgoff_t end);
1404 vm_fault_t vmw_bo_vm_fault(struct vm_fault *vmf);
1405 vm_fault_t vmw_bo_vm_mkwrite(struct vm_fault *vmf);
1406
1407
1408 /**
1409  * VMW_DEBUG_KMS - Debug output for kernel mode-setting
1410  *
1411  * This macro is for debugging vmwgfx mode-setting code.
1412  */
1413 #define VMW_DEBUG_KMS(fmt, ...)                                               \
1414         DRM_DEBUG_DRIVER(fmt, ##__VA_ARGS__)
1415
1416 /**
1417  * Inline helper functions
1418  */
1419
1420 static inline void vmw_surface_unreference(struct vmw_surface **srf)
1421 {
1422         struct vmw_surface *tmp_srf = *srf;
1423         struct vmw_resource *res = &tmp_srf->res;
1424         *srf = NULL;
1425
1426         vmw_resource_unreference(&res);
1427 }
1428
1429 static inline struct vmw_surface *vmw_surface_reference(struct vmw_surface *srf)
1430 {
1431         (void) vmw_resource_reference(&srf->res);
1432         return srf;
1433 }
1434
1435 static inline void vmw_fifo_resource_inc(struct vmw_private *dev_priv)
1436 {
1437         atomic_inc(&dev_priv->num_fifo_resources);
1438 }
1439
1440 static inline void vmw_fifo_resource_dec(struct vmw_private *dev_priv)
1441 {
1442         atomic_dec(&dev_priv->num_fifo_resources);
1443 }
1444
1445 /**
1446  * vmw_fifo_mem_read - Perform a MMIO read from the fifo memory
1447  *
1448  * @fifo_reg: The fifo register to read from
1449  *
1450  * This function is intended to be equivalent to ioread32() on
1451  * memremap'd memory, but without byteswapping.
1452  */
1453 static inline u32 vmw_fifo_mem_read(struct vmw_private *vmw, uint32 fifo_reg)
1454 {
1455         BUG_ON(vmw_is_svga_v3(vmw));
1456         return READ_ONCE(*(vmw->fifo_mem + fifo_reg));
1457 }
1458
1459 /**
1460  * vmw_fifo_mem_write - Perform a MMIO write to volatile memory
1461  *
1462  * @addr: The fifo register to write to
1463  *
1464  * This function is intended to be equivalent to iowrite32 on
1465  * memremap'd memory, but without byteswapping.
1466  */
1467 static inline void vmw_fifo_mem_write(struct vmw_private *vmw, u32 fifo_reg,
1468                                       u32 value)
1469 {
1470         BUG_ON(vmw_is_svga_v3(vmw));
1471         WRITE_ONCE(*(vmw->fifo_mem + fifo_reg), value);
1472 }
1473
1474 static inline u32 vmw_fence_read(struct vmw_private *dev_priv)
1475 {
1476         u32 fence;
1477         if (vmw_is_svga_v3(dev_priv))
1478                 fence = vmw_read(dev_priv, SVGA_REG_FENCE);
1479         else
1480                 fence = vmw_fifo_mem_read(dev_priv, SVGA_FIFO_FENCE);
1481         return fence;
1482 }
1483
1484 static inline void vmw_fence_write(struct vmw_private *dev_priv,
1485                                   u32 fence)
1486 {
1487         BUG_ON(vmw_is_svga_v3(dev_priv));
1488         vmw_fifo_mem_write(dev_priv, SVGA_FIFO_FENCE, fence);
1489 }
1490
1491 static inline u32 vmw_irq_status_read(struct vmw_private *vmw)
1492 {
1493         u32 status;
1494         if (vmw_is_svga_v3(vmw))
1495                 status = vmw_read(vmw, SVGA_REG_IRQ_STATUS);
1496         else
1497                 status = inl(vmw->io_start + SVGA_IRQSTATUS_PORT);
1498         return status;
1499 }
1500
1501 static inline void vmw_irq_status_write(struct vmw_private *vmw,
1502                                         uint32 status)
1503 {
1504         if (vmw_is_svga_v3(vmw))
1505                 vmw_write(vmw, SVGA_REG_IRQ_STATUS, status);
1506         else
1507                 outl(status, vmw->io_start + SVGA_IRQSTATUS_PORT);
1508 }
1509
1510 static inline bool vmw_has_fences(struct vmw_private *vmw)
1511 {
1512         if ((vmw->capabilities & (SVGA_CAP_COMMAND_BUFFERS |
1513                                   SVGA_CAP_CMD_BUFFERS_2)) != 0)
1514                 return true;
1515         return (vmw_fifo_caps(vmw) & SVGA_FIFO_CAP_FENCE) != 0;
1516 }
1517
1518 static inline bool vmw_shadertype_is_valid(enum vmw_sm_type shader_model,
1519                                            u32 shader_type)
1520 {
1521         SVGA3dShaderType max_allowed = SVGA3D_SHADERTYPE_PREDX_MAX;
1522
1523         if (shader_model >= VMW_SM_5)
1524                 max_allowed = SVGA3D_SHADERTYPE_MAX;
1525         else if (shader_model >= VMW_SM_4)
1526                 max_allowed = SVGA3D_SHADERTYPE_DX10_MAX;
1527         return shader_type >= SVGA3D_SHADERTYPE_MIN && shader_type < max_allowed;
1528 }
1529
1530 #endif