Home | History | Annotate | Line # | Download | only in vmwgfx
vmwgfx_drv.h revision 1.1.1.2
      1 /**************************************************************************
      2  *
      3  * Copyright  2009 VMware, Inc., Palo Alto, CA., USA
      4  * All Rights Reserved.
      5  *
      6  * Permission is hereby granted, free of charge, to any person obtaining a
      7  * copy of this software and associated documentation files (the
      8  * "Software"), to deal in the Software without restriction, including
      9  * without limitation the rights to use, copy, modify, merge, publish,
     10  * distribute, sub license, and/or sell copies of the Software, and to
     11  * permit persons to whom the Software is furnished to do so, subject to
     12  * the following conditions:
     13  *
     14  * The above copyright notice and this permission notice (including the
     15  * next paragraph) shall be included in all copies or substantial portions
     16  * of the Software.
     17  *
     18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     19  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     20  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
     21  * THE COPYRIGHT HOLDERS, AUTHORS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM,
     22  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
     23  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
     24  * USE OR OTHER DEALINGS IN THE SOFTWARE.
     25  *
     26  **************************************************************************/
     27 
     28 #ifndef _VMWGFX_DRV_H_
     29 #define _VMWGFX_DRV_H_
     30 
     31 #include "vmwgfx_reg.h"
     32 #include <drm/drmP.h>
     33 #include <drm/vmwgfx_drm.h>
     34 #include <drm/drm_hashtab.h>
     35 #include <linux/suspend.h>
     36 #include <drm/ttm/ttm_bo_driver.h>
     37 #include <drm/ttm/ttm_object.h>
     38 #include <drm/ttm/ttm_lock.h>
     39 #include <drm/ttm/ttm_execbuf_util.h>
     40 #include <drm/ttm/ttm_module.h>
     41 #include "vmwgfx_fence.h"
     42 
     43 #define VMWGFX_DRIVER_DATE "20140325"
     44 #define VMWGFX_DRIVER_MAJOR 2
     45 #define VMWGFX_DRIVER_MINOR 6
     46 #define VMWGFX_DRIVER_PATCHLEVEL 0
     47 #define VMWGFX_FILE_PAGE_OFFSET 0x00100000
     48 #define VMWGFX_FIFO_STATIC_SIZE (1024*1024)
     49 #define VMWGFX_MAX_RELOCATIONS 2048
     50 #define VMWGFX_MAX_VALIDATIONS 2048
     51 #define VMWGFX_MAX_DISPLAYS 16
     52 #define VMWGFX_CMD_BOUNCE_INIT_SIZE 32768
     53 #define VMWGFX_ENABLE_SCREEN_TARGET_OTABLE 0
     54 
     55 /*
     56  * Perhaps we should have sysfs entries for these.
     57  */
     58 #define VMWGFX_NUM_GB_CONTEXT 256
     59 #define VMWGFX_NUM_GB_SHADER 20000
     60 #define VMWGFX_NUM_GB_SURFACE 32768
     61 #define VMWGFX_NUM_GB_SCREEN_TARGET VMWGFX_MAX_DISPLAYS
     62 #define VMWGFX_NUM_MOB (VMWGFX_NUM_GB_CONTEXT +\
     63 			VMWGFX_NUM_GB_SHADER +\
     64 			VMWGFX_NUM_GB_SURFACE +\
     65 			VMWGFX_NUM_GB_SCREEN_TARGET)
     66 
     67 #define VMW_PL_GMR TTM_PL_PRIV0
     68 #define VMW_PL_FLAG_GMR TTM_PL_FLAG_PRIV0
     69 #define VMW_PL_MOB TTM_PL_PRIV1
     70 #define VMW_PL_FLAG_MOB TTM_PL_FLAG_PRIV1
     71 
     72 #define VMW_RES_CONTEXT ttm_driver_type0
     73 #define VMW_RES_SURFACE ttm_driver_type1
     74 #define VMW_RES_STREAM ttm_driver_type2
     75 #define VMW_RES_FENCE ttm_driver_type3
     76 #define VMW_RES_SHADER ttm_driver_type4
     77 
     78 struct vmw_compat_shader_manager;
     79 
     80 struct vmw_fpriv {
     81 	struct drm_master *locked_master;
     82 	struct ttm_object_file *tfile;
     83 	struct list_head fence_events;
     84 	bool gb_aware;
     85 	struct vmw_compat_shader_manager *shman;
     86 };
     87 
     88 struct vmw_dma_buffer {
     89 	struct ttm_buffer_object base;
     90 	struct list_head res_list;
     91 };
     92 
     93 /**
     94  * struct vmw_validate_buffer - Carries validation info about buffers.
     95  *
     96  * @base: Validation info for TTM.
     97  * @hash: Hash entry for quick lookup of the TTM buffer object.
     98  *
     99  * This structure contains also driver private validation info
    100  * on top of the info needed by TTM.
    101  */
    102 struct vmw_validate_buffer {
    103 	struct ttm_validate_buffer base;
    104 	struct drm_hash_item hash;
    105 	bool validate_as_mob;
    106 };
    107 
    108 struct vmw_res_func;
    109 struct vmw_resource {
    110 	struct kref kref;
    111 	struct vmw_private *dev_priv;
    112 	int id;
    113 	bool avail;
    114 	unsigned long backup_size;
    115 	bool res_dirty; /* Protected by backup buffer reserved */
    116 	bool backup_dirty; /* Protected by backup buffer reserved */
    117 	struct vmw_dma_buffer *backup;
    118 	unsigned long backup_offset;
    119 	const struct vmw_res_func *func;
    120 	struct list_head lru_head; /* Protected by the resource lock */
    121 	struct list_head mob_head; /* Protected by @backup reserved */
    122 	struct list_head binding_head; /* Protected by binding_mutex */
    123 	void (*res_free) (struct vmw_resource *res);
    124 	void (*hw_destroy) (struct vmw_resource *res);
    125 };
    126 
    127 enum vmw_res_type {
    128 	vmw_res_context,
    129 	vmw_res_surface,
    130 	vmw_res_stream,
    131 	vmw_res_shader,
    132 	vmw_res_max
    133 };
    134 
    135 struct vmw_cursor_snooper {
    136 	struct drm_crtc *crtc;
    137 	size_t age;
    138 	uint32_t *image;
    139 };
    140 
    141 struct vmw_framebuffer;
    142 struct vmw_surface_offset;
    143 
    144 struct vmw_surface {
    145 	struct vmw_resource res;
    146 	uint32_t flags;
    147 	uint32_t format;
    148 	uint32_t mip_levels[DRM_VMW_MAX_SURFACE_FACES];
    149 	struct drm_vmw_size base_size;
    150 	struct drm_vmw_size *sizes;
    151 	uint32_t num_sizes;
    152 	bool scanout;
    153 	/* TODO so far just a extra pointer */
    154 	struct vmw_cursor_snooper snooper;
    155 	struct vmw_surface_offset *offsets;
    156 	SVGA3dTextureFilter autogen_filter;
    157 	uint32_t multisample_count;
    158 };
    159 
    160 struct vmw_marker_queue {
    161 	struct list_head head;
    162 	struct timespec lag;
    163 	struct timespec lag_time;
    164 	spinlock_t lock;
    165 };
    166 
    167 struct vmw_fifo_state {
    168 	unsigned long reserved_size;
    169 	__le32 *dynamic_buffer;
    170 	__le32 *static_buffer;
    171 	unsigned long static_buffer_size;
    172 	bool using_bounce_buffer;
    173 	uint32_t capabilities;
    174 	struct mutex fifo_mutex;
    175 	struct rw_semaphore rwsem;
    176 	struct vmw_marker_queue marker_queue;
    177 };
    178 
    179 struct vmw_relocation {
    180 	SVGAMobId *mob_loc;
    181 	SVGAGuestPtr *location;
    182 	uint32_t index;
    183 };
    184 
    185 /**
    186  * struct vmw_res_cache_entry - resource information cache entry
    187  *
    188  * @valid: Whether the entry is valid, which also implies that the execbuf
    189  * code holds a reference to the resource, and it's placed on the
    190  * validation list.
    191  * @handle: User-space handle of a resource.
    192  * @res: Non-ref-counted pointer to the resource.
    193  *
    194  * Used to avoid frequent repeated user-space handle lookups of the
    195  * same resource.
    196  */
    197 struct vmw_res_cache_entry {
    198 	bool valid;
    199 	uint32_t handle;
    200 	struct vmw_resource *res;
    201 	struct vmw_resource_val_node *node;
    202 };
    203 
    204 /**
    205  * enum vmw_dma_map_mode - indicate how to perform TTM page dma mappings.
    206  */
    207 enum vmw_dma_map_mode {
    208 	vmw_dma_phys,           /* Use physical page addresses */
    209 	vmw_dma_alloc_coherent, /* Use TTM coherent pages */
    210 	vmw_dma_map_populate,   /* Unmap from DMA just after unpopulate */
    211 	vmw_dma_map_bind,       /* Unmap from DMA just before unbind */
    212 	vmw_dma_map_max
    213 };
    214 
    215 /**
    216  * struct vmw_sg_table - Scatter/gather table for binding, with additional
    217  * device-specific information.
    218  *
    219  * @sgt: Pointer to a struct sg_table with binding information
    220  * @num_regions: Number of regions with device-address contigous pages
    221  */
    222 struct vmw_sg_table {
    223 	enum vmw_dma_map_mode mode;
    224 	struct page **pages;
    225 	const dma_addr_t *addrs;
    226 	struct sg_table *sgt;
    227 	unsigned long num_regions;
    228 	unsigned long num_pages;
    229 };
    230 
    231 /**
    232  * struct vmw_piter - Page iterator that iterates over a list of pages
    233  * and DMA addresses that could be either a scatter-gather list or
    234  * arrays
    235  *
    236  * @pages: Array of page pointers to the pages.
    237  * @addrs: DMA addresses to the pages if coherent pages are used.
    238  * @iter: Scatter-gather page iterator. Current position in SG list.
    239  * @i: Current position in arrays.
    240  * @num_pages: Number of pages total.
    241  * @next: Function to advance the iterator. Returns false if past the list
    242  * of pages, true otherwise.
    243  * @dma_address: Function to return the DMA address of the current page.
    244  */
    245 struct vmw_piter {
    246 	struct page **pages;
    247 	const dma_addr_t *addrs;
    248 	struct sg_page_iter iter;
    249 	unsigned long i;
    250 	unsigned long num_pages;
    251 	bool (*next)(struct vmw_piter *);
    252 	dma_addr_t (*dma_address)(struct vmw_piter *);
    253 	struct page *(*page)(struct vmw_piter *);
    254 };
    255 
    256 /*
    257  * enum vmw_ctx_binding_type - abstract resource to context binding types
    258  */
    259 enum vmw_ctx_binding_type {
    260 	vmw_ctx_binding_shader,
    261 	vmw_ctx_binding_rt,
    262 	vmw_ctx_binding_tex,
    263 	vmw_ctx_binding_max
    264 };
    265 
    266 /**
    267  * struct vmw_ctx_bindinfo - structure representing a single context binding
    268  *
    269  * @ctx: Pointer to the context structure. NULL means the binding is not
    270  * active.
    271  * @res: Non ref-counted pointer to the bound resource.
    272  * @bt: The binding type.
    273  * @i1: Union of information needed to unbind.
    274  */
    275 struct vmw_ctx_bindinfo {
    276 	struct vmw_resource *ctx;
    277 	struct vmw_resource *res;
    278 	enum vmw_ctx_binding_type bt;
    279 	bool scrubbed;
    280 	union {
    281 		SVGA3dShaderType shader_type;
    282 		SVGA3dRenderTargetType rt_type;
    283 		uint32 texture_stage;
    284 	} i1;
    285 };
    286 
    287 /**
    288  * struct vmw_ctx_binding - structure representing a single context binding
    289  *                        - suitable for tracking in a context
    290  *
    291  * @ctx_list: List head for context.
    292  * @res_list: List head for bound resource.
    293  * @bi: Binding info
    294  */
    295 struct vmw_ctx_binding {
    296 	struct list_head ctx_list;
    297 	struct list_head res_list;
    298 	struct vmw_ctx_bindinfo bi;
    299 };
    300 
    301 
    302 /**
    303  * struct vmw_ctx_binding_state - context binding state
    304  *
    305  * @list: linked list of individual bindings.
    306  * @render_targets: Render target bindings.
    307  * @texture_units: Texture units/samplers bindings.
    308  * @shaders: Shader bindings.
    309  *
    310  * Note that this structure also provides storage space for the individual
    311  * struct vmw_ctx_binding objects, so that no dynamic allocation is needed
    312  * for individual bindings.
    313  *
    314  */
    315 struct vmw_ctx_binding_state {
    316 	struct list_head list;
    317 	struct vmw_ctx_binding render_targets[SVGA3D_RT_MAX];
    318 	struct vmw_ctx_binding texture_units[SVGA3D_NUM_TEXTURE_UNITS];
    319 	struct vmw_ctx_binding shaders[SVGA3D_SHADERTYPE_MAX];
    320 };
    321 
    322 struct vmw_sw_context{
    323 	struct drm_open_hash res_ht;
    324 	bool res_ht_initialized;
    325 	bool kernel; /**< is the called made from the kernel */
    326 	struct vmw_fpriv *fp;
    327 	struct list_head validate_nodes;
    328 	struct vmw_relocation relocs[VMWGFX_MAX_RELOCATIONS];
    329 	uint32_t cur_reloc;
    330 	struct vmw_validate_buffer val_bufs[VMWGFX_MAX_VALIDATIONS];
    331 	uint32_t cur_val_buf;
    332 	uint32_t *cmd_bounce;
    333 	uint32_t cmd_bounce_size;
    334 	struct list_head resource_list;
    335 	uint32_t fence_flags;
    336 	struct ttm_buffer_object *cur_query_bo;
    337 	struct list_head res_relocations;
    338 	uint32_t *buf_start;
    339 	struct vmw_res_cache_entry res_cache[vmw_res_max];
    340 	struct vmw_resource *last_query_ctx;
    341 	bool needs_post_query_barrier;
    342 	struct vmw_resource *error_resource;
    343 	struct vmw_ctx_binding_state staged_bindings;
    344 	struct list_head staged_shaders;
    345 };
    346 
    347 struct vmw_legacy_display;
    348 struct vmw_overlay;
    349 
    350 struct vmw_master {
    351 	struct ttm_lock lock;
    352 	struct mutex fb_surf_mutex;
    353 	struct list_head fb_surf;
    354 };
    355 
    356 struct vmw_vga_topology_state {
    357 	uint32_t width;
    358 	uint32_t height;
    359 	uint32_t primary;
    360 	uint32_t pos_x;
    361 	uint32_t pos_y;
    362 };
    363 
    364 struct vmw_private {
    365 	struct ttm_bo_device bdev;
    366 	struct ttm_bo_global_ref bo_global_ref;
    367 	struct drm_global_reference mem_global_ref;
    368 
    369 	struct vmw_fifo_state fifo;
    370 
    371 	struct drm_device *dev;
    372 	unsigned long vmw_chipset;
    373 	unsigned int io_start;
    374 	uint32_t vram_start;
    375 	uint32_t vram_size;
    376 	uint32_t prim_bb_mem;
    377 	uint32_t mmio_start;
    378 	uint32_t mmio_size;
    379 	uint32_t fb_max_width;
    380 	uint32_t fb_max_height;
    381 	uint32_t initial_width;
    382 	uint32_t initial_height;
    383 	__le32 __iomem *mmio_virt;
    384 	int mmio_mtrr;
    385 	uint32_t capabilities;
    386 	uint32_t max_gmr_ids;
    387 	uint32_t max_gmr_pages;
    388 	uint32_t max_mob_pages;
    389 	uint32_t max_mob_size;
    390 	uint32_t memory_size;
    391 	bool has_gmr;
    392 	bool has_mob;
    393 	struct mutex hw_mutex;
    394 
    395 	/*
    396 	 * VGA registers.
    397 	 */
    398 
    399 	struct vmw_vga_topology_state vga_save[VMWGFX_MAX_DISPLAYS];
    400 	uint32_t vga_width;
    401 	uint32_t vga_height;
    402 	uint32_t vga_bpp;
    403 	uint32_t vga_bpl;
    404 	uint32_t vga_pitchlock;
    405 
    406 	uint32_t num_displays;
    407 
    408 	/*
    409 	 * Framebuffer info.
    410 	 */
    411 
    412 	void *fb_info;
    413 	struct vmw_legacy_display *ldu_priv;
    414 	struct vmw_screen_object_display *sou_priv;
    415 	struct vmw_overlay *overlay_priv;
    416 
    417 	/*
    418 	 * Context and surface management.
    419 	 */
    420 
    421 	rwlock_t resource_lock;
    422 	struct idr res_idr[vmw_res_max];
    423 	/*
    424 	 * Block lastclose from racing with firstopen.
    425 	 */
    426 
    427 	struct mutex init_mutex;
    428 
    429 	/*
    430 	 * A resource manager for kernel-only surfaces and
    431 	 * contexts.
    432 	 */
    433 
    434 	struct ttm_object_device *tdev;
    435 
    436 	/*
    437 	 * Fencing and IRQs.
    438 	 */
    439 
    440 	atomic_t marker_seq;
    441 	wait_queue_head_t fence_queue;
    442 	wait_queue_head_t fifo_queue;
    443 	int fence_queue_waiters; /* Protected by hw_mutex */
    444 	int goal_queue_waiters; /* Protected by hw_mutex */
    445 	atomic_t fifo_queue_waiters;
    446 	uint32_t last_read_seqno;
    447 	spinlock_t irq_lock;
    448 	struct vmw_fence_manager *fman;
    449 	uint32_t irq_mask;
    450 
    451 	/*
    452 	 * Device state
    453 	 */
    454 
    455 	uint32_t traces_state;
    456 	uint32_t enable_state;
    457 	uint32_t config_done_state;
    458 
    459 	/**
    460 	 * Execbuf
    461 	 */
    462 	/**
    463 	 * Protected by the cmdbuf mutex.
    464 	 */
    465 
    466 	struct vmw_sw_context ctx;
    467 	struct mutex cmdbuf_mutex;
    468 	struct mutex binding_mutex;
    469 
    470 	/**
    471 	 * Operating mode.
    472 	 */
    473 
    474 	bool stealth;
    475 	bool enable_fb;
    476 
    477 	/**
    478 	 * Master management.
    479 	 */
    480 
    481 	struct vmw_master *active_master;
    482 	struct vmw_master fbdev_master;
    483 	struct notifier_block pm_nb;
    484 	bool suspended;
    485 
    486 	struct mutex release_mutex;
    487 	uint32_t num_3d_resources;
    488 
    489 	/*
    490 	 * Replace this with an rwsem as soon as we have down_xx_interruptible()
    491 	 */
    492 	struct ttm_lock reservation_sem;
    493 
    494 	/*
    495 	 * Query processing. These members
    496 	 * are protected by the cmdbuf mutex.
    497 	 */
    498 
    499 	struct ttm_buffer_object *dummy_query_bo;
    500 	struct ttm_buffer_object *pinned_bo;
    501 	uint32_t query_cid;
    502 	uint32_t query_cid_valid;
    503 	bool dummy_query_bo_pinned;
    504 
    505 	/*
    506 	 * Surface swapping. The "surface_lru" list is protected by the
    507 	 * resource lock in order to be able to destroy a surface and take
    508 	 * it off the lru atomically. "used_memory_size" is currently
    509 	 * protected by the cmdbuf mutex for simplicity.
    510 	 */
    511 
    512 	struct list_head res_lru[vmw_res_max];
    513 	uint32_t used_memory_size;
    514 
    515 	/*
    516 	 * DMA mapping stuff.
    517 	 */
    518 	enum vmw_dma_map_mode map_mode;
    519 
    520 	/*
    521 	 * Guest Backed stuff
    522 	 */
    523 	struct ttm_buffer_object *otable_bo;
    524 	struct vmw_otable *otables;
    525 };
    526 
    527 static inline struct vmw_surface *vmw_res_to_srf(struct vmw_resource *res)
    528 {
    529 	return container_of(res, struct vmw_surface, res);
    530 }
    531 
    532 static inline struct vmw_private *vmw_priv(struct drm_device *dev)
    533 {
    534 	return (struct vmw_private *)dev->dev_private;
    535 }
    536 
    537 static inline struct vmw_fpriv *vmw_fpriv(struct drm_file *file_priv)
    538 {
    539 	return (struct vmw_fpriv *)file_priv->driver_priv;
    540 }
    541 
    542 static inline struct vmw_master *vmw_master(struct drm_master *master)
    543 {
    544 	return (struct vmw_master *) master->driver_priv;
    545 }
    546 
    547 static inline void vmw_write(struct vmw_private *dev_priv,
    548 			     unsigned int offset, uint32_t value)
    549 {
    550 	outl(offset, dev_priv->io_start + VMWGFX_INDEX_PORT);
    551 	outl(value, dev_priv->io_start + VMWGFX_VALUE_PORT);
    552 }
    553 
    554 static inline uint32_t vmw_read(struct vmw_private *dev_priv,
    555 				unsigned int offset)
    556 {
    557 	uint32_t val;
    558 
    559 	outl(offset, dev_priv->io_start + VMWGFX_INDEX_PORT);
    560 	val = inl(dev_priv->io_start + VMWGFX_VALUE_PORT);
    561 	return val;
    562 }
    563 
    564 int vmw_3d_resource_inc(struct vmw_private *dev_priv, bool unhide_svga);
    565 void vmw_3d_resource_dec(struct vmw_private *dev_priv, bool hide_svga);
    566 
    567 /**
    568  * GMR utilities - vmwgfx_gmr.c
    569  */
    570 
    571 extern int vmw_gmr_bind(struct vmw_private *dev_priv,
    572 			const struct vmw_sg_table *vsgt,
    573 			unsigned long num_pages,
    574 			int gmr_id);
    575 extern void vmw_gmr_unbind(struct vmw_private *dev_priv, int gmr_id);
    576 
    577 /**
    578  * Resource utilities - vmwgfx_resource.c
    579  */
    580 struct vmw_user_resource_conv;
    581 
    582 extern void vmw_resource_unreference(struct vmw_resource **p_res);
    583 extern struct vmw_resource *vmw_resource_reference(struct vmw_resource *res);
    584 extern struct vmw_resource *
    585 vmw_resource_reference_unless_doomed(struct vmw_resource *res);
    586 extern int vmw_resource_validate(struct vmw_resource *res);
    587 extern int vmw_resource_reserve(struct vmw_resource *res, bool no_backup);
    588 extern bool vmw_resource_needs_backup(const struct vmw_resource *res);
    589 extern int vmw_user_lookup_handle(struct vmw_private *dev_priv,
    590 				  struct ttm_object_file *tfile,
    591 				  uint32_t handle,
    592 				  struct vmw_surface **out_surf,
    593 				  struct vmw_dma_buffer **out_buf);
    594 extern int vmw_user_resource_lookup_handle(
    595 	struct vmw_private *dev_priv,
    596 	struct ttm_object_file *tfile,
    597 	uint32_t handle,
    598 	const struct vmw_user_resource_conv *converter,
    599 	struct vmw_resource **p_res);
    600 extern void vmw_dmabuf_bo_free(struct ttm_buffer_object *bo);
    601 extern int vmw_dmabuf_init(struct vmw_private *dev_priv,
    602 			   struct vmw_dma_buffer *vmw_bo,
    603 			   size_t size, struct ttm_placement *placement,
    604 			   bool interuptable,
    605 			   void (*bo_free) (struct ttm_buffer_object *bo));
    606 extern int vmw_user_dmabuf_verify_access(struct ttm_buffer_object *bo,
    607 				  struct ttm_object_file *tfile);
    608 extern int vmw_user_dmabuf_alloc(struct vmw_private *dev_priv,
    609 				 struct ttm_object_file *tfile,
    610 				 uint32_t size,
    611 				 bool shareable,
    612 				 uint32_t *handle,
    613 				 struct vmw_dma_buffer **p_dma_buf);
    614 extern int vmw_user_dmabuf_reference(struct ttm_object_file *tfile,
    615 				     struct vmw_dma_buffer *dma_buf,
    616 				     uint32_t *handle);
    617 extern int vmw_dmabuf_alloc_ioctl(struct drm_device *dev, void *data,
    618 				  struct drm_file *file_priv);
    619 extern int vmw_dmabuf_unref_ioctl(struct drm_device *dev, void *data,
    620 				  struct drm_file *file_priv);
    621 extern int vmw_user_dmabuf_synccpu_ioctl(struct drm_device *dev, void *data,
    622 					 struct drm_file *file_priv);
    623 extern uint32_t vmw_dmabuf_validate_node(struct ttm_buffer_object *bo,
    624 					 uint32_t cur_validate_node);
    625 extern void vmw_dmabuf_validate_clear(struct ttm_buffer_object *bo);
    626 extern int vmw_user_dmabuf_lookup(struct ttm_object_file *tfile,
    627 				  uint32_t id, struct vmw_dma_buffer **out);
    628 extern int vmw_stream_claim_ioctl(struct drm_device *dev, void *data,
    629 				  struct drm_file *file_priv);
    630 extern int vmw_stream_unref_ioctl(struct drm_device *dev, void *data,
    631 				  struct drm_file *file_priv);
    632 extern int vmw_user_stream_lookup(struct vmw_private *dev_priv,
    633 				  struct ttm_object_file *tfile,
    634 				  uint32_t *inout_id,
    635 				  struct vmw_resource **out);
    636 extern void vmw_resource_unreserve(struct vmw_resource *res,
    637 				   struct vmw_dma_buffer *new_backup,
    638 				   unsigned long new_backup_offset);
    639 extern void vmw_resource_move_notify(struct ttm_buffer_object *bo,
    640 				     struct ttm_mem_reg *mem);
    641 extern void vmw_fence_single_bo(struct ttm_buffer_object *bo,
    642 				struct vmw_fence_obj *fence);
    643 extern void vmw_resource_evict_all(struct vmw_private *dev_priv);
    644 
    645 /**
    646  * DMA buffer helper routines - vmwgfx_dmabuf.c
    647  */
    648 extern int vmw_dmabuf_to_placement(struct vmw_private *vmw_priv,
    649 				   struct vmw_dma_buffer *bo,
    650 				   struct ttm_placement *placement,
    651 				   bool interruptible);
    652 extern int vmw_dmabuf_to_vram(struct vmw_private *dev_priv,
    653 			      struct vmw_dma_buffer *buf,
    654 			      bool pin, bool interruptible);
    655 extern int vmw_dmabuf_to_vram_or_gmr(struct vmw_private *dev_priv,
    656 				     struct vmw_dma_buffer *buf,
    657 				     bool pin, bool interruptible);
    658 extern int vmw_dmabuf_to_start_of_vram(struct vmw_private *vmw_priv,
    659 				       struct vmw_dma_buffer *bo,
    660 				       bool pin, bool interruptible);
    661 extern int vmw_dmabuf_unpin(struct vmw_private *vmw_priv,
    662 			    struct vmw_dma_buffer *bo,
    663 			    bool interruptible);
    664 extern void vmw_bo_get_guest_ptr(const struct ttm_buffer_object *buf,
    665 				 SVGAGuestPtr *ptr);
    666 extern void vmw_bo_pin(struct ttm_buffer_object *bo, bool pin);
    667 
    668 /**
    669  * Misc Ioctl functionality - vmwgfx_ioctl.c
    670  */
    671 
    672 extern int vmw_getparam_ioctl(struct drm_device *dev, void *data,
    673 			      struct drm_file *file_priv);
    674 extern int vmw_get_cap_3d_ioctl(struct drm_device *dev, void *data,
    675 				struct drm_file *file_priv);
    676 extern int vmw_present_ioctl(struct drm_device *dev, void *data,
    677 			     struct drm_file *file_priv);
    678 extern int vmw_present_readback_ioctl(struct drm_device *dev, void *data,
    679 				      struct drm_file *file_priv);
    680 extern unsigned int vmw_fops_poll(struct file *filp,
    681 				  struct poll_table_struct *wait);
    682 extern ssize_t vmw_fops_read(struct file *filp, char __user *buffer,
    683 			     size_t count, loff_t *offset);
    684 
    685 /**
    686  * Fifo utilities - vmwgfx_fifo.c
    687  */
    688 
    689 extern int vmw_fifo_init(struct vmw_private *dev_priv,
    690 			 struct vmw_fifo_state *fifo);
    691 extern void vmw_fifo_release(struct vmw_private *dev_priv,
    692 			     struct vmw_fifo_state *fifo);
    693 extern void *vmw_fifo_reserve(struct vmw_private *dev_priv, uint32_t bytes);
    694 extern void vmw_fifo_commit(struct vmw_private *dev_priv, uint32_t bytes);
    695 extern int vmw_fifo_send_fence(struct vmw_private *dev_priv,
    696 			       uint32_t *seqno);
    697 extern void vmw_fifo_ping_host(struct vmw_private *dev_priv, uint32_t reason);
    698 extern bool vmw_fifo_have_3d(struct vmw_private *dev_priv);
    699 extern bool vmw_fifo_have_pitchlock(struct vmw_private *dev_priv);
    700 extern int vmw_fifo_emit_dummy_query(struct vmw_private *dev_priv,
    701 				     uint32_t cid);
    702 
    703 /**
    704  * TTM glue - vmwgfx_ttm_glue.c
    705  */
    706 
    707 extern int vmw_ttm_global_init(struct vmw_private *dev_priv);
    708 extern void vmw_ttm_global_release(struct vmw_private *dev_priv);
    709 extern int vmw_mmap(struct file *filp, struct vm_area_struct *vma);
    710 
    711 /**
    712  * TTM buffer object driver - vmwgfx_buffer.c
    713  */
    714 
    715 extern const size_t vmw_tt_size;
    716 extern struct ttm_placement vmw_vram_placement;
    717 extern struct ttm_placement vmw_vram_ne_placement;
    718 extern struct ttm_placement vmw_vram_sys_placement;
    719 extern struct ttm_placement vmw_vram_gmr_placement;
    720 extern struct ttm_placement vmw_vram_gmr_ne_placement;
    721 extern struct ttm_placement vmw_sys_placement;
    722 extern struct ttm_placement vmw_sys_ne_placement;
    723 extern struct ttm_placement vmw_evictable_placement;
    724 extern struct ttm_placement vmw_srf_placement;
    725 extern struct ttm_placement vmw_mob_placement;
    726 extern struct ttm_bo_driver vmw_bo_driver;
    727 extern int vmw_dma_quiescent(struct drm_device *dev);
    728 extern int vmw_bo_map_dma(struct ttm_buffer_object *bo);
    729 extern void vmw_bo_unmap_dma(struct ttm_buffer_object *bo);
    730 extern const struct vmw_sg_table *
    731 vmw_bo_sg_table(struct ttm_buffer_object *bo);
    732 extern void vmw_piter_start(struct vmw_piter *viter,
    733 			    const struct vmw_sg_table *vsgt,
    734 			    unsigned long p_offs);
    735 
    736 /**
    737  * vmw_piter_next - Advance the iterator one page.
    738  *
    739  * @viter: Pointer to the iterator to advance.
    740  *
    741  * Returns false if past the list of pages, true otherwise.
    742  */
    743 static inline bool vmw_piter_next(struct vmw_piter *viter)
    744 {
    745 	return viter->next(viter);
    746 }
    747 
    748 /**
    749  * vmw_piter_dma_addr - Return the DMA address of the current page.
    750  *
    751  * @viter: Pointer to the iterator
    752  *
    753  * Returns the DMA address of the page pointed to by @viter.
    754  */
    755 static inline dma_addr_t vmw_piter_dma_addr(struct vmw_piter *viter)
    756 {
    757 	return viter->dma_address(viter);
    758 }
    759 
    760 /**
    761  * vmw_piter_page - Return a pointer to the current page.
    762  *
    763  * @viter: Pointer to the iterator
    764  *
    765  * Returns the DMA address of the page pointed to by @viter.
    766  */
    767 static inline struct page *vmw_piter_page(struct vmw_piter *viter)
    768 {
    769 	return viter->page(viter);
    770 }
    771 
    772 /**
    773  * Command submission - vmwgfx_execbuf.c
    774  */
    775 
    776 extern int vmw_execbuf_ioctl(struct drm_device *dev, void *data,
    777 			     struct drm_file *file_priv);
    778 extern int vmw_execbuf_process(struct drm_file *file_priv,
    779 			       struct vmw_private *dev_priv,
    780 			       void __user *user_commands,
    781 			       void *kernel_commands,
    782 			       uint32_t command_size,
    783 			       uint64_t throttle_us,
    784 			       struct drm_vmw_fence_rep __user
    785 			       *user_fence_rep,
    786 			       struct vmw_fence_obj **out_fence);
    787 extern void __vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv,
    788 					    struct vmw_fence_obj *fence);
    789 extern void vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv);
    790 
    791 extern int vmw_execbuf_fence_commands(struct drm_file *file_priv,
    792 				      struct vmw_private *dev_priv,
    793 				      struct vmw_fence_obj **p_fence,
    794 				      uint32_t *p_handle);
    795 extern void vmw_execbuf_copy_fence_user(struct vmw_private *dev_priv,
    796 					struct vmw_fpriv *vmw_fp,
    797 					int ret,
    798 					struct drm_vmw_fence_rep __user
    799 					*user_fence_rep,
    800 					struct vmw_fence_obj *fence,
    801 					uint32_t fence_handle);
    802 
    803 /**
    804  * IRQs and wating - vmwgfx_irq.c
    805  */
    806 
    807 extern irqreturn_t vmw_irq_handler(int irq, void *arg);
    808 extern int vmw_wait_seqno(struct vmw_private *dev_priv, bool lazy,
    809 			     uint32_t seqno, bool interruptible,
    810 			     unsigned long timeout);
    811 extern void vmw_irq_preinstall(struct drm_device *dev);
    812 extern int vmw_irq_postinstall(struct drm_device *dev);
    813 extern void vmw_irq_uninstall(struct drm_device *dev);
    814 extern bool vmw_seqno_passed(struct vmw_private *dev_priv,
    815 				uint32_t seqno);
    816 extern int vmw_fallback_wait(struct vmw_private *dev_priv,
    817 			     bool lazy,
    818 			     bool fifo_idle,
    819 			     uint32_t seqno,
    820 			     bool interruptible,
    821 			     unsigned long timeout);
    822 extern void vmw_update_seqno(struct vmw_private *dev_priv,
    823 				struct vmw_fifo_state *fifo_state);
    824 extern void vmw_seqno_waiter_add(struct vmw_private *dev_priv);
    825 extern void vmw_seqno_waiter_remove(struct vmw_private *dev_priv);
    826 extern void vmw_goal_waiter_add(struct vmw_private *dev_priv);
    827 extern void vmw_goal_waiter_remove(struct vmw_private *dev_priv);
    828 
    829 /**
    830  * Rudimentary fence-like objects currently used only for throttling -
    831  * vmwgfx_marker.c
    832  */
    833 
    834 extern void vmw_marker_queue_init(struct vmw_marker_queue *queue);
    835 extern void vmw_marker_queue_takedown(struct vmw_marker_queue *queue);
    836 extern int vmw_marker_push(struct vmw_marker_queue *queue,
    837 			  uint32_t seqno);
    838 extern int vmw_marker_pull(struct vmw_marker_queue *queue,
    839 			  uint32_t signaled_seqno);
    840 extern int vmw_wait_lag(struct vmw_private *dev_priv,
    841 			struct vmw_marker_queue *queue, uint32_t us);
    842 
    843 /**
    844  * Kernel framebuffer - vmwgfx_fb.c
    845  */
    846 
    847 int vmw_fb_init(struct vmw_private *vmw_priv);
    848 int vmw_fb_close(struct vmw_private *dev_priv);
    849 int vmw_fb_off(struct vmw_private *vmw_priv);
    850 int vmw_fb_on(struct vmw_private *vmw_priv);
    851 
    852 /**
    853  * Kernel modesetting - vmwgfx_kms.c
    854  */
    855 
    856 int vmw_kms_init(struct vmw_private *dev_priv);
    857 int vmw_kms_close(struct vmw_private *dev_priv);
    858 int vmw_kms_save_vga(struct vmw_private *vmw_priv);
    859 int vmw_kms_restore_vga(struct vmw_private *vmw_priv);
    860 int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data,
    861 				struct drm_file *file_priv);
    862 void vmw_kms_cursor_post_execbuf(struct vmw_private *dev_priv);
    863 void vmw_kms_cursor_snoop(struct vmw_surface *srf,
    864 			  struct ttm_object_file *tfile,
    865 			  struct ttm_buffer_object *bo,
    866 			  SVGA3dCmdHeader *header);
    867 int vmw_kms_write_svga(struct vmw_private *vmw_priv,
    868 		       unsigned width, unsigned height, unsigned pitch,
    869 		       unsigned bpp, unsigned depth);
    870 void vmw_kms_idle_workqueues(struct vmw_master *vmaster);
    871 bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv,
    872 				uint32_t pitch,
    873 				uint32_t height);
    874 u32 vmw_get_vblank_counter(struct drm_device *dev, int crtc);
    875 int vmw_enable_vblank(struct drm_device *dev, int crtc);
    876 void vmw_disable_vblank(struct drm_device *dev, int crtc);
    877 int vmw_kms_present(struct vmw_private *dev_priv,
    878 		    struct drm_file *file_priv,
    879 		    struct vmw_framebuffer *vfb,
    880 		    struct vmw_surface *surface,
    881 		    uint32_t sid, int32_t destX, int32_t destY,
    882 		    struct drm_vmw_rect *clips,
    883 		    uint32_t num_clips);
    884 int vmw_kms_readback(struct vmw_private *dev_priv,
    885 		     struct drm_file *file_priv,
    886 		     struct vmw_framebuffer *vfb,
    887 		     struct drm_vmw_fence_rep __user *user_fence_rep,
    888 		     struct drm_vmw_rect *clips,
    889 		     uint32_t num_clips);
    890 int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data,
    891 				struct drm_file *file_priv);
    892 
    893 int vmw_dumb_create(struct drm_file *file_priv,
    894 		    struct drm_device *dev,
    895 		    struct drm_mode_create_dumb *args);
    896 
    897 int vmw_dumb_map_offset(struct drm_file *file_priv,
    898 			struct drm_device *dev, uint32_t handle,
    899 			uint64_t *offset);
    900 int vmw_dumb_destroy(struct drm_file *file_priv,
    901 		     struct drm_device *dev,
    902 		     uint32_t handle);
    903 /**
    904  * Overlay control - vmwgfx_overlay.c
    905  */
    906 
    907 int vmw_overlay_init(struct vmw_private *dev_priv);
    908 int vmw_overlay_close(struct vmw_private *dev_priv);
    909 int vmw_overlay_ioctl(struct drm_device *dev, void *data,
    910 		      struct drm_file *file_priv);
    911 int vmw_overlay_stop_all(struct vmw_private *dev_priv);
    912 int vmw_overlay_resume_all(struct vmw_private *dev_priv);
    913 int vmw_overlay_pause_all(struct vmw_private *dev_priv);
    914 int vmw_overlay_claim(struct vmw_private *dev_priv, uint32_t *out);
    915 int vmw_overlay_unref(struct vmw_private *dev_priv, uint32_t stream_id);
    916 int vmw_overlay_num_overlays(struct vmw_private *dev_priv);
    917 int vmw_overlay_num_free_overlays(struct vmw_private *dev_priv);
    918 
    919 /**
    920  * GMR Id manager
    921  */
    922 
    923 extern const struct ttm_mem_type_manager_func vmw_gmrid_manager_func;
    924 
    925 /**
    926  * Prime - vmwgfx_prime.c
    927  */
    928 
    929 extern const struct dma_buf_ops vmw_prime_dmabuf_ops;
    930 extern int vmw_prime_fd_to_handle(struct drm_device *dev,
    931 				  struct drm_file *file_priv,
    932 				  int fd, u32 *handle);
    933 extern int vmw_prime_handle_to_fd(struct drm_device *dev,
    934 				  struct drm_file *file_priv,
    935 				  uint32_t handle, uint32_t flags,
    936 				  int *prime_fd);
    937 
    938 /*
    939  * MemoryOBject management -  vmwgfx_mob.c
    940  */
    941 struct vmw_mob;
    942 extern int vmw_mob_bind(struct vmw_private *dev_priv, struct vmw_mob *mob,
    943 			const struct vmw_sg_table *vsgt,
    944 			unsigned long num_data_pages, int32_t mob_id);
    945 extern void vmw_mob_unbind(struct vmw_private *dev_priv,
    946 			   struct vmw_mob *mob);
    947 extern void vmw_mob_destroy(struct vmw_mob *mob);
    948 extern struct vmw_mob *vmw_mob_create(unsigned long data_pages);
    949 extern int vmw_otables_setup(struct vmw_private *dev_priv);
    950 extern void vmw_otables_takedown(struct vmw_private *dev_priv);
    951 
    952 /*
    953  * Context management - vmwgfx_context.c
    954  */
    955 
    956 extern const struct vmw_user_resource_conv *user_context_converter;
    957 
    958 extern struct vmw_resource *vmw_context_alloc(struct vmw_private *dev_priv);
    959 
    960 extern int vmw_context_check(struct vmw_private *dev_priv,
    961 			     struct ttm_object_file *tfile,
    962 			     int id,
    963 			     struct vmw_resource **p_res);
    964 extern int vmw_context_define_ioctl(struct drm_device *dev, void *data,
    965 				    struct drm_file *file_priv);
    966 extern int vmw_context_destroy_ioctl(struct drm_device *dev, void *data,
    967 				     struct drm_file *file_priv);
    968 extern int vmw_context_binding_add(struct vmw_ctx_binding_state *cbs,
    969 				   const struct vmw_ctx_bindinfo *ci);
    970 extern void
    971 vmw_context_binding_state_transfer(struct vmw_resource *res,
    972 				   struct vmw_ctx_binding_state *cbs);
    973 extern void vmw_context_binding_res_list_kill(struct list_head *head);
    974 extern void vmw_context_binding_res_list_scrub(struct list_head *head);
    975 extern int vmw_context_rebind_all(struct vmw_resource *ctx);
    976 extern struct list_head *vmw_context_binding_list(struct vmw_resource *ctx);
    977 
    978 /*
    979  * Surface management - vmwgfx_surface.c
    980  */
    981 
    982 extern const struct vmw_user_resource_conv *user_surface_converter;
    983 
    984 extern void vmw_surface_res_free(struct vmw_resource *res);
    985 extern int vmw_surface_destroy_ioctl(struct drm_device *dev, void *data,
    986 				     struct drm_file *file_priv);
    987 extern int vmw_surface_define_ioctl(struct drm_device *dev, void *data,
    988 				    struct drm_file *file_priv);
    989 extern int vmw_surface_reference_ioctl(struct drm_device *dev, void *data,
    990 				       struct drm_file *file_priv);
    991 extern int vmw_gb_surface_define_ioctl(struct drm_device *dev, void *data,
    992 				       struct drm_file *file_priv);
    993 extern int vmw_gb_surface_reference_ioctl(struct drm_device *dev, void *data,
    994 					  struct drm_file *file_priv);
    995 extern int vmw_surface_check(struct vmw_private *dev_priv,
    996 			     struct ttm_object_file *tfile,
    997 			     uint32_t handle, int *id);
    998 extern int vmw_surface_validate(struct vmw_private *dev_priv,
    999 				struct vmw_surface *srf);
   1000 
   1001 /*
   1002  * Shader management - vmwgfx_shader.c
   1003  */
   1004 
   1005 extern const struct vmw_user_resource_conv *user_shader_converter;
   1006 
   1007 extern int vmw_shader_define_ioctl(struct drm_device *dev, void *data,
   1008 				   struct drm_file *file_priv);
   1009 extern int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data,
   1010 				    struct drm_file *file_priv);
   1011 extern int vmw_compat_shader_lookup(struct vmw_compat_shader_manager *man,
   1012 				    SVGA3dShaderType shader_type,
   1013 				    u32 *user_key);
   1014 extern void vmw_compat_shaders_commit(struct vmw_compat_shader_manager *man,
   1015 				      struct list_head *list);
   1016 extern void vmw_compat_shaders_revert(struct vmw_compat_shader_manager *man,
   1017 				      struct list_head *list);
   1018 extern int vmw_compat_shader_remove(struct vmw_compat_shader_manager *man,
   1019 				    u32 user_key,
   1020 				    SVGA3dShaderType shader_type,
   1021 				    struct list_head *list);
   1022 extern int vmw_compat_shader_add(struct vmw_compat_shader_manager *man,
   1023 				 u32 user_key, const void *bytecode,
   1024 				 SVGA3dShaderType shader_type,
   1025 				 size_t size,
   1026 				 struct ttm_object_file *tfile,
   1027 				 struct list_head *list);
   1028 extern struct vmw_compat_shader_manager *
   1029 vmw_compat_shader_man_create(struct vmw_private *dev_priv);
   1030 extern void
   1031 vmw_compat_shader_man_destroy(struct vmw_compat_shader_manager *man);
   1032 
   1033 
   1034 /**
   1035  * Inline helper functions
   1036  */
   1037 
   1038 static inline void vmw_surface_unreference(struct vmw_surface **srf)
   1039 {
   1040 	struct vmw_surface *tmp_srf = *srf;
   1041 	struct vmw_resource *res = &tmp_srf->res;
   1042 	*srf = NULL;
   1043 
   1044 	vmw_resource_unreference(&res);
   1045 }
   1046 
   1047 static inline struct vmw_surface *vmw_surface_reference(struct vmw_surface *srf)
   1048 {
   1049 	(void) vmw_resource_reference(&srf->res);
   1050 	return srf;
   1051 }
   1052 
   1053 static inline void vmw_dmabuf_unreference(struct vmw_dma_buffer **buf)
   1054 {
   1055 	struct vmw_dma_buffer *tmp_buf = *buf;
   1056 
   1057 	*buf = NULL;
   1058 	if (tmp_buf != NULL) {
   1059 		struct ttm_buffer_object *bo = &tmp_buf->base;
   1060 
   1061 		ttm_bo_unref(&bo);
   1062 	}
   1063 }
   1064 
   1065 static inline struct vmw_dma_buffer *vmw_dmabuf_reference(struct vmw_dma_buffer *buf)
   1066 {
   1067 	if (ttm_bo_reference(&buf->base))
   1068 		return buf;
   1069 	return NULL;
   1070 }
   1071 
   1072 static inline struct ttm_mem_global *vmw_mem_glob(struct vmw_private *dev_priv)
   1073 {
   1074 	return (struct ttm_mem_global *) dev_priv->mem_global_ref.object;
   1075 }
   1076 #endif
   1077