Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 1 | /************************************************************************** |
| 2 | * |
Sinclair Yeh | 54fbde8 | 2015-07-29 12:38:02 -0700 | [diff] [blame] | 3 | * Copyright © 2009-2015 VMware, Inc., Palo Alto, CA., USA |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 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" |
David Howells | 760285e | 2012-10-02 18:01:07 +0100 | [diff] [blame] | 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> |
Thomas Hellstrom | ae2a104 | 2011-09-01 20:18:44 +0000 | [diff] [blame] | 41 | #include "vmwgfx_fence.h" |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 42 | |
Sinclair Yeh | 54fbde8 | 2015-07-29 12:38:02 -0700 | [diff] [blame] | 43 | #define VMWGFX_DRIVER_DATE "20150810" |
Thomas Hellstrom | 2ae7b03 | 2011-09-01 20:18:45 +0000 | [diff] [blame] | 44 | #define VMWGFX_DRIVER_MAJOR 2 |
Sinclair Yeh | 54fbde8 | 2015-07-29 12:38:02 -0700 | [diff] [blame] | 45 | #define VMWGFX_DRIVER_MINOR 9 |
Sinclair Yeh | 35c0512 | 2015-06-26 01:42:06 -0700 | [diff] [blame] | 46 | #define VMWGFX_DRIVER_PATCHLEVEL 0 |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 47 | #define VMWGFX_FILE_PAGE_OFFSET 0x00100000 |
| 48 | #define VMWGFX_FIFO_STATIC_SIZE (1024*1024) |
| 49 | #define VMWGFX_MAX_RELOCATIONS 2048 |
Thomas Hellstrom | be38ab6 | 2011-08-31 07:42:54 +0000 | [diff] [blame] | 50 | #define VMWGFX_MAX_VALIDATIONS 2048 |
Thomas Hellstrom | 7c4f778 | 2010-06-01 11:38:17 +0200 | [diff] [blame] | 51 | #define VMWGFX_MAX_DISPLAYS 16 |
Thomas Hellstrom | be38ab6 | 2011-08-31 07:42:54 +0000 | [diff] [blame] | 52 | #define VMWGFX_CMD_BOUNCE_INIT_SIZE 32768 |
Sinclair Yeh | 35c0512 | 2015-06-26 01:42:06 -0700 | [diff] [blame] | 53 | #define VMWGFX_ENABLE_SCREEN_TARGET_OTABLE 1 |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 54 | |
Thomas Hellstrom | 3530bdc | 2012-11-21 10:49:52 +0100 | [diff] [blame] | 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 |
Thomas Hellstrom | 7cba906 | 2014-01-09 11:03:18 +0100 | [diff] [blame] | 61 | #define VMWGFX_NUM_GB_SCREEN_TARGET VMWGFX_MAX_DISPLAYS |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 62 | #define VMWGFX_NUM_DXCONTEXT 256 |
| 63 | #define VMWGFX_NUM_DXQUERY 512 |
Thomas Hellstrom | 3530bdc | 2012-11-21 10:49:52 +0100 | [diff] [blame] | 64 | #define VMWGFX_NUM_MOB (VMWGFX_NUM_GB_CONTEXT +\ |
| 65 | VMWGFX_NUM_GB_SHADER +\ |
Thomas Hellstrom | 7cba906 | 2014-01-09 11:03:18 +0100 | [diff] [blame] | 66 | VMWGFX_NUM_GB_SURFACE +\ |
| 67 | VMWGFX_NUM_GB_SCREEN_TARGET) |
Thomas Hellstrom | 3530bdc | 2012-11-21 10:49:52 +0100 | [diff] [blame] | 68 | |
Thomas Hellstrom | 135cba0 | 2010-10-26 21:21:47 +0200 | [diff] [blame] | 69 | #define VMW_PL_GMR TTM_PL_PRIV0 |
| 70 | #define VMW_PL_FLAG_GMR TTM_PL_FLAG_PRIV0 |
Thomas Hellstrom | 6da768a | 2012-11-21 11:06:22 +0100 | [diff] [blame] | 71 | #define VMW_PL_MOB TTM_PL_PRIV1 |
| 72 | #define VMW_PL_FLAG_MOB TTM_PL_FLAG_PRIV1 |
Thomas Hellstrom | 135cba0 | 2010-10-26 21:21:47 +0200 | [diff] [blame] | 73 | |
Thomas Hellstrom | ae2a104 | 2011-09-01 20:18:44 +0000 | [diff] [blame] | 74 | #define VMW_RES_CONTEXT ttm_driver_type0 |
| 75 | #define VMW_RES_SURFACE ttm_driver_type1 |
| 76 | #define VMW_RES_STREAM ttm_driver_type2 |
| 77 | #define VMW_RES_FENCE ttm_driver_type3 |
Thomas Hellstrom | c74c162 | 2012-11-21 12:10:26 +0100 | [diff] [blame] | 78 | #define VMW_RES_SHADER ttm_driver_type4 |
Thomas Hellstrom | ae2a104 | 2011-09-01 20:18:44 +0000 | [diff] [blame] | 79 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 80 | struct vmw_fpriv { |
| 81 | struct drm_master *locked_master; |
| 82 | struct ttm_object_file *tfile; |
Thomas Hellstrom | 6b82ef5 | 2012-02-09 16:56:42 +0100 | [diff] [blame] | 83 | struct list_head fence_events; |
Thomas Hellstrom | d5bde95 | 2014-01-31 10:12:10 +0100 | [diff] [blame] | 84 | bool gb_aware; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 85 | }; |
| 86 | |
| 87 | struct vmw_dma_buffer { |
| 88 | struct ttm_buffer_object base; |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 89 | struct list_head res_list; |
Thomas Hellstrom | 459d0fa | 2015-06-26 00:25:37 -0700 | [diff] [blame] | 90 | s32 pin_count; |
Sinclair Yeh | fd11a3c | 2015-08-10 10:56:15 -0700 | [diff] [blame] | 91 | /* Not ref-counted. Protected by binding_mutex */ |
| 92 | struct vmw_resource *dx_query_ctx; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 93 | }; |
| 94 | |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 95 | /** |
| 96 | * struct vmw_validate_buffer - Carries validation info about buffers. |
| 97 | * |
| 98 | * @base: Validation info for TTM. |
| 99 | * @hash: Hash entry for quick lookup of the TTM buffer object. |
| 100 | * |
| 101 | * This structure contains also driver private validation info |
| 102 | * on top of the info needed by TTM. |
| 103 | */ |
| 104 | struct vmw_validate_buffer { |
| 105 | struct ttm_validate_buffer base; |
| 106 | struct drm_hash_item hash; |
Thomas Hellstrom | 96c5f0d | 2012-11-21 11:19:53 +0100 | [diff] [blame] | 107 | bool validate_as_mob; |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 108 | }; |
| 109 | |
| 110 | struct vmw_res_func; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 111 | struct vmw_resource { |
| 112 | struct kref kref; |
| 113 | struct vmw_private *dev_priv; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 114 | int id; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 115 | bool avail; |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 116 | unsigned long backup_size; |
| 117 | bool res_dirty; /* Protected by backup buffer reserved */ |
| 118 | bool backup_dirty; /* Protected by backup buffer reserved */ |
| 119 | struct vmw_dma_buffer *backup; |
| 120 | unsigned long backup_offset; |
Thomas Hellstrom | ed93394 | 2015-03-02 23:26:06 -0800 | [diff] [blame] | 121 | unsigned long pin_count; /* Protected by resource reserved */ |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 122 | const struct vmw_res_func *func; |
| 123 | struct list_head lru_head; /* Protected by the resource lock */ |
| 124 | struct list_head mob_head; /* Protected by @backup reserved */ |
Thomas Hellstrom | 173fb7d | 2013-10-08 02:32:36 -0700 | [diff] [blame] | 125 | struct list_head binding_head; /* Protected by binding_mutex */ |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 126 | void (*res_free) (struct vmw_resource *res); |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 127 | void (*hw_destroy) (struct vmw_resource *res); |
| 128 | }; |
| 129 | |
Thomas Hellstrom | 18e4a46 | 2014-06-09 12:39:22 +0200 | [diff] [blame] | 130 | |
| 131 | /* |
| 132 | * Resources that are managed using ioctls. |
| 133 | */ |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 134 | enum vmw_res_type { |
| 135 | vmw_res_context, |
| 136 | vmw_res_surface, |
| 137 | vmw_res_stream, |
Thomas Hellstrom | c74c162 | 2012-11-21 12:10:26 +0100 | [diff] [blame] | 138 | vmw_res_shader, |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 139 | vmw_res_dx_context, |
| 140 | vmw_res_cotable, |
| 141 | vmw_res_view, |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 142 | vmw_res_max |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 143 | }; |
| 144 | |
Thomas Hellstrom | 18e4a46 | 2014-06-09 12:39:22 +0200 | [diff] [blame] | 145 | /* |
| 146 | * Resources that are managed using command streams. |
| 147 | */ |
| 148 | enum vmw_cmdbuf_res_type { |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 149 | vmw_cmdbuf_res_shader, |
| 150 | vmw_cmdbuf_res_view |
Thomas Hellstrom | 18e4a46 | 2014-06-09 12:39:22 +0200 | [diff] [blame] | 151 | }; |
| 152 | |
| 153 | struct vmw_cmdbuf_res_manager; |
| 154 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 155 | struct vmw_cursor_snooper { |
| 156 | struct drm_crtc *crtc; |
| 157 | size_t age; |
| 158 | uint32_t *image; |
| 159 | }; |
| 160 | |
Jakob Bornecrantz | 2fcd5a7 | 2011-10-04 20:13:26 +0200 | [diff] [blame] | 161 | struct vmw_framebuffer; |
Thomas Hellstrom | 5bb39e8 | 2011-10-04 20:13:33 +0200 | [diff] [blame] | 162 | struct vmw_surface_offset; |
Jakob Bornecrantz | 2fcd5a7 | 2011-10-04 20:13:26 +0200 | [diff] [blame] | 163 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 164 | struct vmw_surface { |
| 165 | struct vmw_resource res; |
| 166 | uint32_t flags; |
| 167 | uint32_t format; |
| 168 | uint32_t mip_levels[DRM_VMW_MAX_SURFACE_FACES]; |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 169 | struct drm_vmw_size base_size; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 170 | struct drm_vmw_size *sizes; |
| 171 | uint32_t num_sizes; |
Jakob Bornecrantz | 5ffdb65 | 2010-01-30 03:38:08 +0000 | [diff] [blame] | 172 | bool scanout; |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 173 | uint32_t array_size; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 174 | /* TODO so far just a extra pointer */ |
| 175 | struct vmw_cursor_snooper snooper; |
Thomas Hellstrom | 5bb39e8 | 2011-10-04 20:13:33 +0200 | [diff] [blame] | 176 | struct vmw_surface_offset *offsets; |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 177 | SVGA3dTextureFilter autogen_filter; |
| 178 | uint32_t multisample_count; |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 179 | struct list_head view_list; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 180 | }; |
| 181 | |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 182 | struct vmw_marker_queue { |
Thomas Hellstrom | 1925d45 | 2010-05-28 11:21:57 +0200 | [diff] [blame] | 183 | struct list_head head; |
Thomas Gleixner | f166e6d | 2014-07-16 21:05:07 +0000 | [diff] [blame] | 184 | u64 lag; |
| 185 | u64 lag_time; |
Thomas Hellstrom | 1925d45 | 2010-05-28 11:21:57 +0200 | [diff] [blame] | 186 | spinlock_t lock; |
| 187 | }; |
| 188 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 189 | struct vmw_fifo_state { |
| 190 | unsigned long reserved_size; |
Thomas Hellstrom | b9eb1a6 | 2015-04-02 02:39:45 -0700 | [diff] [blame] | 191 | u32 *dynamic_buffer; |
| 192 | u32 *static_buffer; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 193 | unsigned long static_buffer_size; |
| 194 | bool using_bounce_buffer; |
| 195 | uint32_t capabilities; |
Thomas Hellstrom | 85b9e48 | 2010-02-08 09:57:25 +0000 | [diff] [blame] | 196 | struct mutex fifo_mutex; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 197 | struct rw_semaphore rwsem; |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 198 | struct vmw_marker_queue marker_queue; |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 199 | bool dx; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 200 | }; |
| 201 | |
| 202 | struct vmw_relocation { |
Thomas Hellstrom | ddcda24 | 2012-11-21 11:26:55 +0100 | [diff] [blame] | 203 | SVGAMobId *mob_loc; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 204 | SVGAGuestPtr *location; |
| 205 | uint32_t index; |
| 206 | }; |
| 207 | |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 208 | /** |
| 209 | * struct vmw_res_cache_entry - resource information cache entry |
| 210 | * |
| 211 | * @valid: Whether the entry is valid, which also implies that the execbuf |
| 212 | * code holds a reference to the resource, and it's placed on the |
| 213 | * validation list. |
| 214 | * @handle: User-space handle of a resource. |
| 215 | * @res: Non-ref-counted pointer to the resource. |
| 216 | * |
| 217 | * Used to avoid frequent repeated user-space handle lookups of the |
| 218 | * same resource. |
| 219 | */ |
| 220 | struct vmw_res_cache_entry { |
| 221 | bool valid; |
| 222 | uint32_t handle; |
| 223 | struct vmw_resource *res; |
| 224 | struct vmw_resource_val_node *node; |
| 225 | }; |
| 226 | |
Thomas Hellstrom | d92d985 | 2013-10-24 01:49:26 -0700 | [diff] [blame] | 227 | /** |
| 228 | * enum vmw_dma_map_mode - indicate how to perform TTM page dma mappings. |
| 229 | */ |
| 230 | enum vmw_dma_map_mode { |
| 231 | vmw_dma_phys, /* Use physical page addresses */ |
| 232 | vmw_dma_alloc_coherent, /* Use TTM coherent pages */ |
| 233 | vmw_dma_map_populate, /* Unmap from DMA just after unpopulate */ |
| 234 | vmw_dma_map_bind, /* Unmap from DMA just before unbind */ |
| 235 | vmw_dma_map_max |
| 236 | }; |
| 237 | |
| 238 | /** |
| 239 | * struct vmw_sg_table - Scatter/gather table for binding, with additional |
| 240 | * device-specific information. |
| 241 | * |
| 242 | * @sgt: Pointer to a struct sg_table with binding information |
Masahiro Yamada | e1c0506 | 2015-07-07 10:14:59 +0900 | [diff] [blame] | 243 | * @num_regions: Number of regions with device-address contiguous pages |
Thomas Hellstrom | d92d985 | 2013-10-24 01:49:26 -0700 | [diff] [blame] | 244 | */ |
| 245 | struct vmw_sg_table { |
| 246 | enum vmw_dma_map_mode mode; |
| 247 | struct page **pages; |
| 248 | const dma_addr_t *addrs; |
| 249 | struct sg_table *sgt; |
| 250 | unsigned long num_regions; |
| 251 | unsigned long num_pages; |
| 252 | }; |
| 253 | |
| 254 | /** |
| 255 | * struct vmw_piter - Page iterator that iterates over a list of pages |
| 256 | * and DMA addresses that could be either a scatter-gather list or |
| 257 | * arrays |
| 258 | * |
| 259 | * @pages: Array of page pointers to the pages. |
| 260 | * @addrs: DMA addresses to the pages if coherent pages are used. |
| 261 | * @iter: Scatter-gather page iterator. Current position in SG list. |
| 262 | * @i: Current position in arrays. |
| 263 | * @num_pages: Number of pages total. |
| 264 | * @next: Function to advance the iterator. Returns false if past the list |
| 265 | * of pages, true otherwise. |
| 266 | * @dma_address: Function to return the DMA address of the current page. |
| 267 | */ |
| 268 | struct vmw_piter { |
| 269 | struct page **pages; |
| 270 | const dma_addr_t *addrs; |
| 271 | struct sg_page_iter iter; |
| 272 | unsigned long i; |
| 273 | unsigned long num_pages; |
| 274 | bool (*next)(struct vmw_piter *); |
| 275 | dma_addr_t (*dma_address)(struct vmw_piter *); |
| 276 | struct page *(*page)(struct vmw_piter *); |
| 277 | }; |
| 278 | |
Thomas Hellstrom | b5c3b1a6 | 2013-10-08 02:27:17 -0700 | [diff] [blame] | 279 | /* |
Sinclair Yeh | c8261a9 | 2015-06-26 01:23:42 -0700 | [diff] [blame] | 280 | * enum vmw_display_unit_type - Describes the display unit |
Thomas Hellstrom | b5c3b1a6 | 2013-10-08 02:27:17 -0700 | [diff] [blame] | 281 | */ |
Sinclair Yeh | c8261a9 | 2015-06-26 01:23:42 -0700 | [diff] [blame] | 282 | enum vmw_display_unit_type { |
| 283 | vmw_du_invalid = 0, |
| 284 | vmw_du_legacy, |
Sinclair Yeh | 35c0512 | 2015-06-26 01:42:06 -0700 | [diff] [blame] | 285 | vmw_du_screen_object, |
| 286 | vmw_du_screen_target |
Thomas Hellstrom | b5c3b1a6 | 2013-10-08 02:27:17 -0700 | [diff] [blame] | 287 | }; |
| 288 | |
Thomas Hellstrom | b5c3b1a6 | 2013-10-08 02:27:17 -0700 | [diff] [blame] | 289 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 290 | struct vmw_sw_context{ |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 291 | struct drm_open_hash res_ht; |
| 292 | bool res_ht_initialized; |
Thomas Hellstrom | 922ade0 | 2011-10-04 20:13:17 +0200 | [diff] [blame] | 293 | bool kernel; /**< is the called made from the kernel */ |
Thomas Hellstrom | d5bde95 | 2014-01-31 10:12:10 +0100 | [diff] [blame] | 294 | struct vmw_fpriv *fp; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 295 | struct list_head validate_nodes; |
| 296 | struct vmw_relocation relocs[VMWGFX_MAX_RELOCATIONS]; |
| 297 | uint32_t cur_reloc; |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 298 | struct vmw_validate_buffer val_bufs[VMWGFX_MAX_VALIDATIONS]; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 299 | uint32_t cur_val_buf; |
Thomas Hellstrom | be38ab6 | 2011-08-31 07:42:54 +0000 | [diff] [blame] | 300 | uint32_t *cmd_bounce; |
| 301 | uint32_t cmd_bounce_size; |
Thomas Hellstrom | f18c884 | 2011-10-04 20:13:31 +0200 | [diff] [blame] | 302 | struct list_head resource_list; |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 303 | struct list_head ctx_resource_list; /* For contexts and cotables */ |
Thomas Hellstrom | 459d0fa | 2015-06-26 00:25:37 -0700 | [diff] [blame] | 304 | struct vmw_dma_buffer *cur_query_bo; |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 305 | struct list_head res_relocations; |
| 306 | uint32_t *buf_start; |
| 307 | struct vmw_res_cache_entry res_cache[vmw_res_max]; |
| 308 | struct vmw_resource *last_query_ctx; |
| 309 | bool needs_post_query_barrier; |
| 310 | struct vmw_resource *error_resource; |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 311 | struct vmw_ctx_binding_state *staged_bindings; |
| 312 | bool staged_bindings_inuse; |
Thomas Hellstrom | 18e4a46 | 2014-06-09 12:39:22 +0200 | [diff] [blame] | 313 | struct list_head staged_cmd_res; |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 314 | struct vmw_resource_val_node *dx_ctx_node; |
| 315 | struct vmw_dma_buffer *dx_query_mob; |
| 316 | struct vmw_resource *dx_query_ctx; |
| 317 | struct vmw_cmdbuf_res_manager *man; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 318 | }; |
| 319 | |
| 320 | struct vmw_legacy_display; |
| 321 | struct vmw_overlay; |
| 322 | |
| 323 | struct vmw_master { |
| 324 | struct ttm_lock lock; |
| 325 | }; |
| 326 | |
Thomas Hellstrom | 7c4f778 | 2010-06-01 11:38:17 +0200 | [diff] [blame] | 327 | struct vmw_vga_topology_state { |
| 328 | uint32_t width; |
| 329 | uint32_t height; |
| 330 | uint32_t primary; |
| 331 | uint32_t pos_x; |
| 332 | uint32_t pos_y; |
| 333 | }; |
| 334 | |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 335 | |
| 336 | /* |
| 337 | * struct vmw_otable - Guest Memory OBject table metadata |
| 338 | * |
| 339 | * @size: Size of the table (page-aligned). |
| 340 | * @page_table: Pointer to a struct vmw_mob holding the page table. |
| 341 | */ |
| 342 | struct vmw_otable { |
| 343 | unsigned long size; |
| 344 | struct vmw_mob *page_table; |
| 345 | bool enabled; |
| 346 | }; |
| 347 | |
| 348 | struct vmw_otable_batch { |
| 349 | unsigned num_otables; |
| 350 | struct vmw_otable *otables; |
| 351 | struct vmw_resource *context; |
| 352 | struct ttm_buffer_object *otable_bo; |
| 353 | }; |
| 354 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 355 | struct vmw_private { |
| 356 | struct ttm_bo_device bdev; |
| 357 | struct ttm_bo_global_ref bo_global_ref; |
Dave Airlie | ba4420c | 2010-03-09 10:56:52 +1000 | [diff] [blame] | 358 | struct drm_global_reference mem_global_ref; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 359 | |
| 360 | struct vmw_fifo_state fifo; |
| 361 | |
| 362 | struct drm_device *dev; |
| 363 | unsigned long vmw_chipset; |
| 364 | unsigned int io_start; |
| 365 | uint32_t vram_start; |
| 366 | uint32_t vram_size; |
Thomas Hellstrom | bc2d650 | 2012-11-21 10:32:36 +0100 | [diff] [blame] | 367 | uint32_t prim_bb_mem; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 368 | uint32_t mmio_start; |
| 369 | uint32_t mmio_size; |
| 370 | uint32_t fb_max_width; |
| 371 | uint32_t fb_max_height; |
Sinclair Yeh | 35c0512 | 2015-06-26 01:42:06 -0700 | [diff] [blame] | 372 | uint32_t texture_max_width; |
| 373 | uint32_t texture_max_height; |
| 374 | uint32_t stdu_max_width; |
| 375 | uint32_t stdu_max_height; |
Jakob Bornecrantz | eb4f923 | 2012-02-09 16:56:46 +0100 | [diff] [blame] | 376 | uint32_t initial_width; |
| 377 | uint32_t initial_height; |
Thomas Hellstrom | b76ff5e | 2015-10-28 10:44:04 +0100 | [diff] [blame] | 378 | u32 *mmio_virt; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 379 | uint32_t capabilities; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 380 | uint32_t max_gmr_ids; |
Thomas Hellstrom | fb17f18 | 2011-08-31 07:42:53 +0000 | [diff] [blame] | 381 | uint32_t max_gmr_pages; |
Thomas Hellstrom | 6da768a | 2012-11-21 11:06:22 +0100 | [diff] [blame] | 382 | uint32_t max_mob_pages; |
Charmaine Lee | 857aea1 | 2014-02-12 12:07:38 +0100 | [diff] [blame] | 383 | uint32_t max_mob_size; |
Thomas Hellstrom | fb17f18 | 2011-08-31 07:42:53 +0000 | [diff] [blame] | 384 | uint32_t memory_size; |
Thomas Hellstrom | 135cba0 | 2010-10-26 21:21:47 +0200 | [diff] [blame] | 385 | bool has_gmr; |
Thomas Hellstrom | 3530bdc | 2012-11-21 10:49:52 +0100 | [diff] [blame] | 386 | bool has_mob; |
Thomas Hellstrom | 496eb6f | 2015-01-14 02:33:39 -0800 | [diff] [blame] | 387 | spinlock_t hw_lock; |
| 388 | spinlock_t cap_lock; |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 389 | bool has_dx; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 390 | |
| 391 | /* |
| 392 | * VGA registers. |
| 393 | */ |
| 394 | |
Thomas Hellstrom | 7c4f778 | 2010-06-01 11:38:17 +0200 | [diff] [blame] | 395 | struct vmw_vga_topology_state vga_save[VMWGFX_MAX_DISPLAYS]; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 396 | uint32_t vga_width; |
| 397 | uint32_t vga_height; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 398 | uint32_t vga_bpp; |
Thomas Hellstrom | 7c4f778 | 2010-06-01 11:38:17 +0200 | [diff] [blame] | 399 | uint32_t vga_bpl; |
Jakob Bornecrantz | d7e1958 | 2010-05-28 11:21:59 +0200 | [diff] [blame] | 400 | uint32_t vga_pitchlock; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 401 | |
Thomas Hellstrom | 7c4f778 | 2010-06-01 11:38:17 +0200 | [diff] [blame] | 402 | uint32_t num_displays; |
| 403 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 404 | /* |
| 405 | * Framebuffer info. |
| 406 | */ |
| 407 | |
| 408 | void *fb_info; |
Sinclair Yeh | c8261a9 | 2015-06-26 01:23:42 -0700 | [diff] [blame] | 409 | enum vmw_display_unit_type active_display_unit; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 410 | struct vmw_legacy_display *ldu_priv; |
Jakob Bornecrantz | 56d1c78 | 2011-10-04 20:13:22 +0200 | [diff] [blame] | 411 | struct vmw_screen_object_display *sou_priv; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 412 | struct vmw_overlay *overlay_priv; |
| 413 | |
| 414 | /* |
| 415 | * Context and surface management. |
| 416 | */ |
| 417 | |
| 418 | rwlock_t resource_lock; |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 419 | struct idr res_idr[vmw_res_max]; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 420 | /* |
| 421 | * Block lastclose from racing with firstopen. |
| 422 | */ |
| 423 | |
| 424 | struct mutex init_mutex; |
| 425 | |
| 426 | /* |
| 427 | * A resource manager for kernel-only surfaces and |
| 428 | * contexts. |
| 429 | */ |
| 430 | |
| 431 | struct ttm_object_device *tdev; |
| 432 | |
| 433 | /* |
| 434 | * Fencing and IRQs. |
| 435 | */ |
| 436 | |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 437 | atomic_t marker_seq; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 438 | wait_queue_head_t fence_queue; |
| 439 | wait_queue_head_t fifo_queue; |
Thomas Hellstrom | 496eb6f | 2015-01-14 02:33:39 -0800 | [diff] [blame] | 440 | spinlock_t waiter_lock; |
| 441 | int fence_queue_waiters; /* Protected by waiter_lock */ |
| 442 | int goal_queue_waiters; /* Protected by waiter_lock */ |
Thomas Hellstrom | d2e8851 | 2015-10-28 19:07:35 +0100 | [diff] [blame] | 443 | int cmdbuf_waiters; /* Protected by waiter_lock */ |
| 444 | int error_waiters; /* Protected by waiter_lock */ |
| 445 | int fifo_queue_waiters; /* Protected by waiter_lock */ |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 446 | uint32_t last_read_seqno; |
Thomas Hellstrom | ae2a104 | 2011-09-01 20:18:44 +0000 | [diff] [blame] | 447 | struct vmw_fence_manager *fman; |
Thomas Hellstrom | d2e8851 | 2015-10-28 19:07:35 +0100 | [diff] [blame] | 448 | uint32_t irq_mask; /* Updates protected by waiter_lock */ |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 449 | |
| 450 | /* |
| 451 | * Device state |
| 452 | */ |
| 453 | |
| 454 | uint32_t traces_state; |
| 455 | uint32_t enable_state; |
| 456 | uint32_t config_done_state; |
| 457 | |
| 458 | /** |
| 459 | * Execbuf |
| 460 | */ |
| 461 | /** |
| 462 | * Protected by the cmdbuf mutex. |
| 463 | */ |
| 464 | |
| 465 | struct vmw_sw_context ctx; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 466 | struct mutex cmdbuf_mutex; |
Thomas Hellstrom | 173fb7d | 2013-10-08 02:32:36 -0700 | [diff] [blame] | 467 | struct mutex binding_mutex; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 468 | |
| 469 | /** |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 470 | * Operating mode. |
| 471 | */ |
| 472 | |
| 473 | bool stealth; |
Thomas Hellstrom | 30c78bb | 2010-10-01 10:21:48 +0200 | [diff] [blame] | 474 | bool enable_fb; |
Thomas Hellstrom | 153b3d5 | 2015-06-25 10:47:43 -0700 | [diff] [blame] | 475 | spinlock_t svga_lock; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 476 | |
| 477 | /** |
| 478 | * Master management. |
| 479 | */ |
| 480 | |
| 481 | struct vmw_master *active_master; |
| 482 | struct vmw_master fbdev_master; |
Thomas Hellstrom | d9f36a0 | 2010-01-13 22:28:43 +0100 | [diff] [blame] | 483 | struct notifier_block pm_nb; |
Thomas Hellstrom | 094e0fa | 2010-10-05 12:43:00 +0200 | [diff] [blame] | 484 | bool suspended; |
Thomas Hellstrom | 153b3d5 | 2015-06-25 10:47:43 -0700 | [diff] [blame] | 485 | bool refuse_hibernation; |
Thomas Hellstrom | 30c78bb | 2010-10-01 10:21:48 +0200 | [diff] [blame] | 486 | |
| 487 | struct mutex release_mutex; |
Thomas Hellstrom | 153b3d5 | 2015-06-25 10:47:43 -0700 | [diff] [blame] | 488 | atomic_t num_fifo_resources; |
Thomas Hellstrom | e2fa3a7 | 2011-10-04 20:13:30 +0200 | [diff] [blame] | 489 | |
| 490 | /* |
Thomas Hellstrom | 294adf7 | 2014-02-27 12:34:51 +0100 | [diff] [blame] | 491 | * Replace this with an rwsem as soon as we have down_xx_interruptible() |
| 492 | */ |
| 493 | struct ttm_lock reservation_sem; |
| 494 | |
| 495 | /* |
Thomas Hellstrom | e2fa3a7 | 2011-10-04 20:13:30 +0200 | [diff] [blame] | 496 | * Query processing. These members |
| 497 | * are protected by the cmdbuf mutex. |
| 498 | */ |
| 499 | |
Thomas Hellstrom | 459d0fa | 2015-06-26 00:25:37 -0700 | [diff] [blame] | 500 | struct vmw_dma_buffer *dummy_query_bo; |
| 501 | struct vmw_dma_buffer *pinned_bo; |
Thomas Hellstrom | e2fa3a7 | 2011-10-04 20:13:30 +0200 | [diff] [blame] | 502 | uint32_t query_cid; |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 503 | uint32_t query_cid_valid; |
Thomas Hellstrom | e2fa3a7 | 2011-10-04 20:13:30 +0200 | [diff] [blame] | 504 | bool dummy_query_bo_pinned; |
Thomas Hellstrom | 5bb39e8 | 2011-10-04 20:13:33 +0200 | [diff] [blame] | 505 | |
| 506 | /* |
| 507 | * Surface swapping. The "surface_lru" list is protected by the |
| 508 | * resource lock in order to be able to destroy a surface and take |
| 509 | * it off the lru atomically. "used_memory_size" is currently |
| 510 | * protected by the cmdbuf mutex for simplicity. |
| 511 | */ |
| 512 | |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 513 | struct list_head res_lru[vmw_res_max]; |
Thomas Hellstrom | 5bb39e8 | 2011-10-04 20:13:33 +0200 | [diff] [blame] | 514 | uint32_t used_memory_size; |
Thomas Hellstrom | d92d985 | 2013-10-24 01:49:26 -0700 | [diff] [blame] | 515 | |
| 516 | /* |
| 517 | * DMA mapping stuff. |
| 518 | */ |
| 519 | enum vmw_dma_map_mode map_mode; |
Thomas Hellstrom | 3530bdc | 2012-11-21 10:49:52 +0100 | [diff] [blame] | 520 | |
| 521 | /* |
| 522 | * Guest Backed stuff |
| 523 | */ |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 524 | struct vmw_otable_batch otable_batch; |
Thomas Hellstrom | 3eab3d9 | 2015-06-25 11:57:56 -0700 | [diff] [blame] | 525 | |
| 526 | struct vmw_cmdbuf_man *cman; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 527 | }; |
| 528 | |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 529 | static inline struct vmw_surface *vmw_res_to_srf(struct vmw_resource *res) |
| 530 | { |
| 531 | return container_of(res, struct vmw_surface, res); |
| 532 | } |
| 533 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 534 | static inline struct vmw_private *vmw_priv(struct drm_device *dev) |
| 535 | { |
| 536 | return (struct vmw_private *)dev->dev_private; |
| 537 | } |
| 538 | |
| 539 | static inline struct vmw_fpriv *vmw_fpriv(struct drm_file *file_priv) |
| 540 | { |
| 541 | return (struct vmw_fpriv *)file_priv->driver_priv; |
| 542 | } |
| 543 | |
| 544 | static inline struct vmw_master *vmw_master(struct drm_master *master) |
| 545 | { |
| 546 | return (struct vmw_master *) master->driver_priv; |
| 547 | } |
| 548 | |
Thomas Hellstrom | 496eb6f | 2015-01-14 02:33:39 -0800 | [diff] [blame] | 549 | /* |
| 550 | * The locking here is fine-grained, so that it is performed once |
| 551 | * for every read- and write operation. This is of course costly, but we |
| 552 | * don't perform much register access in the timing critical paths anyway. |
| 553 | * Instead we have the extra benefit of being sure that we don't forget |
| 554 | * the hw lock around register accesses. |
| 555 | */ |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 556 | static inline void vmw_write(struct vmw_private *dev_priv, |
| 557 | unsigned int offset, uint32_t value) |
| 558 | { |
Thomas Hellstrom | 496eb6f | 2015-01-14 02:33:39 -0800 | [diff] [blame] | 559 | unsigned long irq_flags; |
| 560 | |
| 561 | spin_lock_irqsave(&dev_priv->hw_lock, irq_flags); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 562 | outl(offset, dev_priv->io_start + VMWGFX_INDEX_PORT); |
| 563 | outl(value, dev_priv->io_start + VMWGFX_VALUE_PORT); |
Thomas Hellstrom | 496eb6f | 2015-01-14 02:33:39 -0800 | [diff] [blame] | 564 | spin_unlock_irqrestore(&dev_priv->hw_lock, irq_flags); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 565 | } |
| 566 | |
| 567 | static inline uint32_t vmw_read(struct vmw_private *dev_priv, |
| 568 | unsigned int offset) |
| 569 | { |
Thomas Hellstrom | 496eb6f | 2015-01-14 02:33:39 -0800 | [diff] [blame] | 570 | unsigned long irq_flags; |
| 571 | u32 val; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 572 | |
Thomas Hellstrom | 496eb6f | 2015-01-14 02:33:39 -0800 | [diff] [blame] | 573 | spin_lock_irqsave(&dev_priv->hw_lock, irq_flags); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 574 | outl(offset, dev_priv->io_start + VMWGFX_INDEX_PORT); |
| 575 | val = inl(dev_priv->io_start + VMWGFX_VALUE_PORT); |
Thomas Hellstrom | 496eb6f | 2015-01-14 02:33:39 -0800 | [diff] [blame] | 576 | spin_unlock_irqrestore(&dev_priv->hw_lock, irq_flags); |
| 577 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 578 | return val; |
| 579 | } |
| 580 | |
Thomas Hellstrom | 153b3d5 | 2015-06-25 10:47:43 -0700 | [diff] [blame] | 581 | extern void vmw_svga_enable(struct vmw_private *dev_priv); |
| 582 | extern void vmw_svga_disable(struct vmw_private *dev_priv); |
| 583 | |
Thomas Hellstrom | 30c78bb | 2010-10-01 10:21:48 +0200 | [diff] [blame] | 584 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 585 | /** |
| 586 | * GMR utilities - vmwgfx_gmr.c |
| 587 | */ |
| 588 | |
| 589 | extern int vmw_gmr_bind(struct vmw_private *dev_priv, |
Thomas Hellstrom | d92d985 | 2013-10-24 01:49:26 -0700 | [diff] [blame] | 590 | const struct vmw_sg_table *vsgt, |
Thomas Hellstrom | 135cba0 | 2010-10-26 21:21:47 +0200 | [diff] [blame] | 591 | unsigned long num_pages, |
| 592 | int gmr_id); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 593 | extern void vmw_gmr_unbind(struct vmw_private *dev_priv, int gmr_id); |
| 594 | |
| 595 | /** |
| 596 | * Resource utilities - vmwgfx_resource.c |
| 597 | */ |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 598 | struct vmw_user_resource_conv; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 599 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 600 | extern void vmw_resource_unreference(struct vmw_resource **p_res); |
| 601 | extern struct vmw_resource *vmw_resource_reference(struct vmw_resource *res); |
Thomas Hellstrom | 30f82d81 | 2014-02-05 08:13:56 +0100 | [diff] [blame] | 602 | extern struct vmw_resource * |
| 603 | vmw_resource_reference_unless_doomed(struct vmw_resource *res); |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 604 | extern int vmw_resource_validate(struct vmw_resource *res); |
Thomas Hellstrom | 1a4b172 | 2015-06-26 02:03:53 -0700 | [diff] [blame] | 605 | extern int vmw_resource_reserve(struct vmw_resource *res, bool interruptible, |
| 606 | bool no_backup); |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 607 | extern bool vmw_resource_needs_backup(const struct vmw_resource *res); |
Jakob Bornecrantz | 551a669 | 2011-11-28 13:19:11 +0100 | [diff] [blame] | 608 | extern int vmw_user_lookup_handle(struct vmw_private *dev_priv, |
| 609 | struct ttm_object_file *tfile, |
| 610 | uint32_t handle, |
| 611 | struct vmw_surface **out_surf, |
| 612 | struct vmw_dma_buffer **out_buf); |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 613 | extern int vmw_user_resource_lookup_handle( |
| 614 | struct vmw_private *dev_priv, |
| 615 | struct ttm_object_file *tfile, |
| 616 | uint32_t handle, |
| 617 | const struct vmw_user_resource_conv *converter, |
| 618 | struct vmw_resource **p_res); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 619 | extern void vmw_dmabuf_bo_free(struct ttm_buffer_object *bo); |
| 620 | extern int vmw_dmabuf_init(struct vmw_private *dev_priv, |
| 621 | struct vmw_dma_buffer *vmw_bo, |
| 622 | size_t size, struct ttm_placement *placement, |
| 623 | bool interuptable, |
| 624 | void (*bo_free) (struct ttm_buffer_object *bo)); |
Thomas Hellstrom | d08a9b9 | 2012-11-21 16:04:18 +0100 | [diff] [blame] | 625 | extern int vmw_user_dmabuf_verify_access(struct ttm_buffer_object *bo, |
| 626 | struct ttm_object_file *tfile); |
Thomas Hellstrom | a97e219 | 2012-11-21 11:45:13 +0100 | [diff] [blame] | 627 | extern int vmw_user_dmabuf_alloc(struct vmw_private *dev_priv, |
| 628 | struct ttm_object_file *tfile, |
| 629 | uint32_t size, |
| 630 | bool shareable, |
| 631 | uint32_t *handle, |
Thomas Hellstrom | 54c12bc | 2015-09-14 01:13:11 -0700 | [diff] [blame] | 632 | struct vmw_dma_buffer **p_dma_buf, |
| 633 | struct ttm_base_object **p_base); |
Thomas Hellstrom | a97e219 | 2012-11-21 11:45:13 +0100 | [diff] [blame] | 634 | extern int vmw_user_dmabuf_reference(struct ttm_object_file *tfile, |
| 635 | struct vmw_dma_buffer *dma_buf, |
| 636 | uint32_t *handle); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 637 | extern int vmw_dmabuf_alloc_ioctl(struct drm_device *dev, void *data, |
| 638 | struct drm_file *file_priv); |
| 639 | extern int vmw_dmabuf_unref_ioctl(struct drm_device *dev, void *data, |
| 640 | struct drm_file *file_priv); |
Thomas Hellstrom | 1d7a5cb | 2012-11-21 12:32:19 +0100 | [diff] [blame] | 641 | extern int vmw_user_dmabuf_synccpu_ioctl(struct drm_device *dev, void *data, |
| 642 | struct drm_file *file_priv); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 643 | extern uint32_t vmw_dmabuf_validate_node(struct ttm_buffer_object *bo, |
| 644 | uint32_t cur_validate_node); |
| 645 | extern void vmw_dmabuf_validate_clear(struct ttm_buffer_object *bo); |
| 646 | extern int vmw_user_dmabuf_lookup(struct ttm_object_file *tfile, |
Thomas Hellstrom | 54c12bc | 2015-09-14 01:13:11 -0700 | [diff] [blame] | 647 | uint32_t id, struct vmw_dma_buffer **out, |
| 648 | struct ttm_base_object **base); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 649 | extern int vmw_stream_claim_ioctl(struct drm_device *dev, void *data, |
| 650 | struct drm_file *file_priv); |
| 651 | extern int vmw_stream_unref_ioctl(struct drm_device *dev, void *data, |
| 652 | struct drm_file *file_priv); |
| 653 | extern int vmw_user_stream_lookup(struct vmw_private *dev_priv, |
| 654 | struct ttm_object_file *tfile, |
| 655 | uint32_t *inout_id, |
| 656 | struct vmw_resource **out); |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 657 | extern void vmw_resource_unreserve(struct vmw_resource *res, |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 658 | bool switch_backup, |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 659 | struct vmw_dma_buffer *new_backup, |
| 660 | unsigned long new_backup_offset); |
| 661 | extern void vmw_resource_move_notify(struct ttm_buffer_object *bo, |
| 662 | struct ttm_mem_reg *mem); |
Sinclair Yeh | fd11a3c | 2015-08-10 10:56:15 -0700 | [diff] [blame] | 663 | extern void vmw_query_move_notify(struct ttm_buffer_object *bo, |
| 664 | struct ttm_mem_reg *mem); |
| 665 | extern int vmw_query_readback_all(struct vmw_dma_buffer *dx_query_mob); |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 666 | extern void vmw_fence_single_bo(struct ttm_buffer_object *bo, |
| 667 | struct vmw_fence_obj *fence); |
| 668 | extern void vmw_resource_evict_all(struct vmw_private *dev_priv); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 669 | |
Jakob Bornecrantz | d991ef0 | 2011-10-04 20:13:21 +0200 | [diff] [blame] | 670 | /** |
| 671 | * DMA buffer helper routines - vmwgfx_dmabuf.c |
| 672 | */ |
Thomas Hellstrom | 459d0fa | 2015-06-26 00:25:37 -0700 | [diff] [blame] | 673 | extern int vmw_dmabuf_pin_in_placement(struct vmw_private *vmw_priv, |
Jakob Bornecrantz | d991ef0 | 2011-10-04 20:13:21 +0200 | [diff] [blame] | 674 | struct vmw_dma_buffer *bo, |
Thomas Hellstrom | 459d0fa | 2015-06-26 00:25:37 -0700 | [diff] [blame] | 675 | struct ttm_placement *placement, |
| 676 | bool interruptible); |
| 677 | extern int vmw_dmabuf_pin_in_vram(struct vmw_private *dev_priv, |
| 678 | struct vmw_dma_buffer *buf, |
| 679 | bool interruptible); |
| 680 | extern int vmw_dmabuf_pin_in_vram_or_gmr(struct vmw_private *dev_priv, |
| 681 | struct vmw_dma_buffer *buf, |
| 682 | bool interruptible); |
| 683 | extern int vmw_dmabuf_pin_in_start_of_vram(struct vmw_private *vmw_priv, |
| 684 | struct vmw_dma_buffer *bo, |
| 685 | bool interruptible); |
Jakob Bornecrantz | d991ef0 | 2011-10-04 20:13:21 +0200 | [diff] [blame] | 686 | extern int vmw_dmabuf_unpin(struct vmw_private *vmw_priv, |
| 687 | struct vmw_dma_buffer *bo, |
| 688 | bool interruptible); |
Thomas Hellstrom | b37a6b9 | 2011-10-04 20:13:28 +0200 | [diff] [blame] | 689 | extern void vmw_bo_get_guest_ptr(const struct ttm_buffer_object *buf, |
| 690 | SVGAGuestPtr *ptr); |
Thomas Hellstrom | 459d0fa | 2015-06-26 00:25:37 -0700 | [diff] [blame] | 691 | extern void vmw_bo_pin_reserved(struct vmw_dma_buffer *bo, bool pin); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 692 | |
| 693 | /** |
| 694 | * Misc Ioctl functionality - vmwgfx_ioctl.c |
| 695 | */ |
| 696 | |
| 697 | extern int vmw_getparam_ioctl(struct drm_device *dev, void *data, |
| 698 | struct drm_file *file_priv); |
Thomas Hellstrom | f63f6a5 | 2011-09-01 20:18:41 +0000 | [diff] [blame] | 699 | extern int vmw_get_cap_3d_ioctl(struct drm_device *dev, void *data, |
| 700 | struct drm_file *file_priv); |
Jakob Bornecrantz | 2fcd5a7 | 2011-10-04 20:13:26 +0200 | [diff] [blame] | 701 | extern int vmw_present_ioctl(struct drm_device *dev, void *data, |
| 702 | struct drm_file *file_priv); |
| 703 | extern int vmw_present_readback_ioctl(struct drm_device *dev, void *data, |
| 704 | struct drm_file *file_priv); |
Thomas Hellstrom | 5438ae8 | 2011-10-10 12:23:27 +0200 | [diff] [blame] | 705 | extern unsigned int vmw_fops_poll(struct file *filp, |
| 706 | struct poll_table_struct *wait); |
| 707 | extern ssize_t vmw_fops_read(struct file *filp, char __user *buffer, |
| 708 | size_t count, loff_t *offset); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 709 | |
| 710 | /** |
| 711 | * Fifo utilities - vmwgfx_fifo.c |
| 712 | */ |
| 713 | |
| 714 | extern int vmw_fifo_init(struct vmw_private *dev_priv, |
| 715 | struct vmw_fifo_state *fifo); |
| 716 | extern void vmw_fifo_release(struct vmw_private *dev_priv, |
| 717 | struct vmw_fifo_state *fifo); |
| 718 | extern void *vmw_fifo_reserve(struct vmw_private *dev_priv, uint32_t bytes); |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 719 | extern void * |
| 720 | vmw_fifo_reserve_dx(struct vmw_private *dev_priv, uint32_t bytes, int ctx_id); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 721 | extern void vmw_fifo_commit(struct vmw_private *dev_priv, uint32_t bytes); |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 722 | extern void vmw_fifo_commit_flush(struct vmw_private *dev_priv, uint32_t bytes); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 723 | extern int vmw_fifo_send_fence(struct vmw_private *dev_priv, |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 724 | uint32_t *seqno); |
Maarten Lankhorst | 2298e80 | 2014-03-26 14:07:44 +0100 | [diff] [blame] | 725 | extern void vmw_fifo_ping_host_locked(struct vmw_private *, uint32_t reason); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 726 | extern void vmw_fifo_ping_host(struct vmw_private *dev_priv, uint32_t reason); |
Jakob Bornecrantz | 8e19a95 | 2010-01-30 03:38:06 +0000 | [diff] [blame] | 727 | extern bool vmw_fifo_have_3d(struct vmw_private *dev_priv); |
Jakob Bornecrantz | d7e1958 | 2010-05-28 11:21:59 +0200 | [diff] [blame] | 728 | extern bool vmw_fifo_have_pitchlock(struct vmw_private *dev_priv); |
Thomas Hellstrom | e2fa3a7 | 2011-10-04 20:13:30 +0200 | [diff] [blame] | 729 | extern int vmw_fifo_emit_dummy_query(struct vmw_private *dev_priv, |
| 730 | uint32_t cid); |
Thomas Hellstrom | 3eab3d9 | 2015-06-25 11:57:56 -0700 | [diff] [blame] | 731 | extern int vmw_fifo_flush(struct vmw_private *dev_priv, |
| 732 | bool interruptible); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 733 | |
| 734 | /** |
| 735 | * TTM glue - vmwgfx_ttm_glue.c |
| 736 | */ |
| 737 | |
| 738 | extern int vmw_ttm_global_init(struct vmw_private *dev_priv); |
| 739 | extern void vmw_ttm_global_release(struct vmw_private *dev_priv); |
| 740 | extern int vmw_mmap(struct file *filp, struct vm_area_struct *vma); |
| 741 | |
| 742 | /** |
| 743 | * TTM buffer object driver - vmwgfx_buffer.c |
| 744 | */ |
| 745 | |
Thomas Hellstrom | 308d17e | 2013-11-28 01:46:56 -0800 | [diff] [blame] | 746 | extern const size_t vmw_tt_size; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 747 | extern struct ttm_placement vmw_vram_placement; |
| 748 | extern struct ttm_placement vmw_vram_ne_placement; |
Thomas Hellstrom | 8ba5152 | 2010-01-16 16:05:05 +0100 | [diff] [blame] | 749 | extern struct ttm_placement vmw_vram_sys_placement; |
Thomas Hellstrom | 135cba0 | 2010-10-26 21:21:47 +0200 | [diff] [blame] | 750 | extern struct ttm_placement vmw_vram_gmr_placement; |
Jakob Bornecrantz | d991ef0 | 2011-10-04 20:13:21 +0200 | [diff] [blame] | 751 | extern struct ttm_placement vmw_vram_gmr_ne_placement; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 752 | extern struct ttm_placement vmw_sys_placement; |
Thomas Hellstrom | 3530bdc | 2012-11-21 10:49:52 +0100 | [diff] [blame] | 753 | extern struct ttm_placement vmw_sys_ne_placement; |
Jakob Bornecrantz | d991ef0 | 2011-10-04 20:13:21 +0200 | [diff] [blame] | 754 | extern struct ttm_placement vmw_evictable_placement; |
Thomas Hellstrom | 5bb39e8 | 2011-10-04 20:13:33 +0200 | [diff] [blame] | 755 | extern struct ttm_placement vmw_srf_placement; |
Thomas Hellstrom | 96c5f0d | 2012-11-21 11:19:53 +0100 | [diff] [blame] | 756 | extern struct ttm_placement vmw_mob_placement; |
Thomas Hellstrom | 3eab3d9 | 2015-06-25 11:57:56 -0700 | [diff] [blame] | 757 | extern struct ttm_placement vmw_mob_ne_placement; |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 758 | extern struct ttm_bo_driver vmw_bo_driver; |
| 759 | extern int vmw_dma_quiescent(struct drm_device *dev); |
Thomas Hellstrom | 0fd53cf | 2013-10-24 13:27:38 -0700 | [diff] [blame] | 760 | extern int vmw_bo_map_dma(struct ttm_buffer_object *bo); |
| 761 | extern void vmw_bo_unmap_dma(struct ttm_buffer_object *bo); |
| 762 | extern const struct vmw_sg_table * |
| 763 | vmw_bo_sg_table(struct ttm_buffer_object *bo); |
Thomas Hellstrom | d92d985 | 2013-10-24 01:49:26 -0700 | [diff] [blame] | 764 | extern void vmw_piter_start(struct vmw_piter *viter, |
| 765 | const struct vmw_sg_table *vsgt, |
| 766 | unsigned long p_offs); |
| 767 | |
| 768 | /** |
| 769 | * vmw_piter_next - Advance the iterator one page. |
| 770 | * |
| 771 | * @viter: Pointer to the iterator to advance. |
| 772 | * |
| 773 | * Returns false if past the list of pages, true otherwise. |
| 774 | */ |
| 775 | static inline bool vmw_piter_next(struct vmw_piter *viter) |
| 776 | { |
| 777 | return viter->next(viter); |
| 778 | } |
| 779 | |
| 780 | /** |
| 781 | * vmw_piter_dma_addr - Return the DMA address of the current page. |
| 782 | * |
| 783 | * @viter: Pointer to the iterator |
| 784 | * |
| 785 | * Returns the DMA address of the page pointed to by @viter. |
| 786 | */ |
| 787 | static inline dma_addr_t vmw_piter_dma_addr(struct vmw_piter *viter) |
| 788 | { |
| 789 | return viter->dma_address(viter); |
| 790 | } |
| 791 | |
| 792 | /** |
| 793 | * vmw_piter_page - Return a pointer to the current page. |
| 794 | * |
| 795 | * @viter: Pointer to the iterator |
| 796 | * |
| 797 | * Returns the DMA address of the page pointed to by @viter. |
| 798 | */ |
| 799 | static inline struct page *vmw_piter_page(struct vmw_piter *viter) |
| 800 | { |
| 801 | return viter->page(viter); |
| 802 | } |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 803 | |
| 804 | /** |
| 805 | * Command submission - vmwgfx_execbuf.c |
| 806 | */ |
| 807 | |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 808 | extern int vmw_execbuf_ioctl(struct drm_device *dev, unsigned long data, |
| 809 | struct drm_file *file_priv, size_t size); |
Thomas Hellstrom | 922ade0 | 2011-10-04 20:13:17 +0200 | [diff] [blame] | 810 | extern int vmw_execbuf_process(struct drm_file *file_priv, |
| 811 | struct vmw_private *dev_priv, |
| 812 | void __user *user_commands, |
| 813 | void *kernel_commands, |
| 814 | uint32_t command_size, |
| 815 | uint64_t throttle_us, |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 816 | uint32_t dx_context_handle, |
Thomas Hellstrom | 922ade0 | 2011-10-04 20:13:17 +0200 | [diff] [blame] | 817 | struct drm_vmw_fence_rep __user |
Jakob Bornecrantz | bb1bd2f | 2012-02-09 16:56:43 +0100 | [diff] [blame] | 818 | *user_fence_rep, |
| 819 | struct vmw_fence_obj **out_fence); |
Thomas Hellstrom | c0951b7 | 2012-11-20 12:19:35 +0000 | [diff] [blame] | 820 | extern void __vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv, |
| 821 | struct vmw_fence_obj *fence); |
| 822 | extern void vmw_execbuf_release_pinned_bo(struct vmw_private *dev_priv); |
Thomas Hellstrom | e2fa3a7 | 2011-10-04 20:13:30 +0200 | [diff] [blame] | 823 | |
Thomas Hellstrom | 5bb39e8 | 2011-10-04 20:13:33 +0200 | [diff] [blame] | 824 | extern int vmw_execbuf_fence_commands(struct drm_file *file_priv, |
| 825 | struct vmw_private *dev_priv, |
| 826 | struct vmw_fence_obj **p_fence, |
| 827 | uint32_t *p_handle); |
Thomas Hellstrom | 57c5ee7 | 2011-10-10 12:23:26 +0200 | [diff] [blame] | 828 | extern void vmw_execbuf_copy_fence_user(struct vmw_private *dev_priv, |
| 829 | struct vmw_fpriv *vmw_fp, |
| 830 | int ret, |
| 831 | struct drm_vmw_fence_rep __user |
| 832 | *user_fence_rep, |
| 833 | struct vmw_fence_obj *fence, |
| 834 | uint32_t fence_handle); |
Thomas Hellstrom | 1a4b172 | 2015-06-26 02:03:53 -0700 | [diff] [blame] | 835 | extern int vmw_validate_single_buffer(struct vmw_private *dev_priv, |
| 836 | struct ttm_buffer_object *bo, |
| 837 | bool interruptible, |
| 838 | bool validate_as_mob); |
| 839 | |
Thomas Hellstrom | 5bb39e8 | 2011-10-04 20:13:33 +0200 | [diff] [blame] | 840 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 841 | /** |
| 842 | * IRQs and wating - vmwgfx_irq.c |
| 843 | */ |
| 844 | |
Daniel Vetter | e9f0d76 | 2013-12-11 11:34:42 +0100 | [diff] [blame] | 845 | extern irqreturn_t vmw_irq_handler(int irq, void *arg); |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 846 | extern int vmw_wait_seqno(struct vmw_private *dev_priv, bool lazy, |
Sinclair Yeh | c8261a9 | 2015-06-26 01:23:42 -0700 | [diff] [blame] | 847 | uint32_t seqno, bool interruptible, |
| 848 | unsigned long timeout); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 849 | extern void vmw_irq_preinstall(struct drm_device *dev); |
| 850 | extern int vmw_irq_postinstall(struct drm_device *dev); |
| 851 | extern void vmw_irq_uninstall(struct drm_device *dev); |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 852 | extern bool vmw_seqno_passed(struct vmw_private *dev_priv, |
| 853 | uint32_t seqno); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 854 | extern int vmw_fallback_wait(struct vmw_private *dev_priv, |
| 855 | bool lazy, |
| 856 | bool fifo_idle, |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 857 | uint32_t seqno, |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 858 | bool interruptible, |
| 859 | unsigned long timeout); |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 860 | extern void vmw_update_seqno(struct vmw_private *dev_priv, |
Thomas Hellstrom | 1925d45 | 2010-05-28 11:21:57 +0200 | [diff] [blame] | 861 | struct vmw_fifo_state *fifo_state); |
Thomas Hellstrom | ae2a104 | 2011-09-01 20:18:44 +0000 | [diff] [blame] | 862 | extern void vmw_seqno_waiter_add(struct vmw_private *dev_priv); |
| 863 | extern void vmw_seqno_waiter_remove(struct vmw_private *dev_priv); |
Thomas Hellstrom | 57c5ee7 | 2011-10-10 12:23:26 +0200 | [diff] [blame] | 864 | extern void vmw_goal_waiter_add(struct vmw_private *dev_priv); |
| 865 | extern void vmw_goal_waiter_remove(struct vmw_private *dev_priv); |
Thomas Hellstrom | 3eab3d9 | 2015-06-25 11:57:56 -0700 | [diff] [blame] | 866 | extern void vmw_generic_waiter_add(struct vmw_private *dev_priv, u32 flag, |
| 867 | int *waiter_count); |
| 868 | extern void vmw_generic_waiter_remove(struct vmw_private *dev_priv, |
| 869 | u32 flag, int *waiter_count); |
Thomas Hellstrom | 1925d45 | 2010-05-28 11:21:57 +0200 | [diff] [blame] | 870 | |
| 871 | /** |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 872 | * Rudimentary fence-like objects currently used only for throttling - |
| 873 | * vmwgfx_marker.c |
Thomas Hellstrom | 1925d45 | 2010-05-28 11:21:57 +0200 | [diff] [blame] | 874 | */ |
| 875 | |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 876 | extern void vmw_marker_queue_init(struct vmw_marker_queue *queue); |
| 877 | extern void vmw_marker_queue_takedown(struct vmw_marker_queue *queue); |
| 878 | extern int vmw_marker_push(struct vmw_marker_queue *queue, |
Sinclair Yeh | c8261a9 | 2015-06-26 01:23:42 -0700 | [diff] [blame] | 879 | uint32_t seqno); |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 880 | extern int vmw_marker_pull(struct vmw_marker_queue *queue, |
Sinclair Yeh | c8261a9 | 2015-06-26 01:23:42 -0700 | [diff] [blame] | 881 | uint32_t signaled_seqno); |
Thomas Hellstrom | 1925d45 | 2010-05-28 11:21:57 +0200 | [diff] [blame] | 882 | extern int vmw_wait_lag(struct vmw_private *dev_priv, |
Thomas Hellstrom | 6bcd8d3c | 2011-09-01 20:18:42 +0000 | [diff] [blame] | 883 | struct vmw_marker_queue *queue, uint32_t us); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 884 | |
| 885 | /** |
| 886 | * Kernel framebuffer - vmwgfx_fb.c |
| 887 | */ |
| 888 | |
| 889 | int vmw_fb_init(struct vmw_private *vmw_priv); |
| 890 | int vmw_fb_close(struct vmw_private *dev_priv); |
| 891 | int vmw_fb_off(struct vmw_private *vmw_priv); |
| 892 | int vmw_fb_on(struct vmw_private *vmw_priv); |
| 893 | |
| 894 | /** |
| 895 | * Kernel modesetting - vmwgfx_kms.c |
| 896 | */ |
| 897 | |
| 898 | int vmw_kms_init(struct vmw_private *dev_priv); |
| 899 | int vmw_kms_close(struct vmw_private *dev_priv); |
| 900 | int vmw_kms_save_vga(struct vmw_private *vmw_priv); |
| 901 | int vmw_kms_restore_vga(struct vmw_private *vmw_priv); |
| 902 | int vmw_kms_cursor_bypass_ioctl(struct drm_device *dev, void *data, |
| 903 | struct drm_file *file_priv); |
| 904 | void vmw_kms_cursor_post_execbuf(struct vmw_private *dev_priv); |
| 905 | void vmw_kms_cursor_snoop(struct vmw_surface *srf, |
| 906 | struct ttm_object_file *tfile, |
| 907 | struct ttm_buffer_object *bo, |
| 908 | SVGA3dCmdHeader *header); |
Michel Dänzer | 0bef23f | 2011-08-31 07:42:50 +0000 | [diff] [blame] | 909 | int vmw_kms_write_svga(struct vmw_private *vmw_priv, |
| 910 | unsigned width, unsigned height, unsigned pitch, |
| 911 | unsigned bpp, unsigned depth); |
Thomas Hellstrom | 3a939a5 | 2010-10-05 12:43:03 +0200 | [diff] [blame] | 912 | void vmw_kms_idle_workqueues(struct vmw_master *vmaster); |
Thomas Hellstrom | e133e73 | 2010-10-05 12:43:04 +0200 | [diff] [blame] | 913 | bool vmw_kms_validate_mode_vram(struct vmw_private *dev_priv, |
| 914 | uint32_t pitch, |
| 915 | uint32_t height); |
Thierry Reding | 88e7271 | 2015-09-24 18:35:31 +0200 | [diff] [blame] | 916 | u32 vmw_get_vblank_counter(struct drm_device *dev, unsigned int pipe); |
| 917 | int vmw_enable_vblank(struct drm_device *dev, unsigned int pipe); |
| 918 | void vmw_disable_vblank(struct drm_device *dev, unsigned int pipe); |
Jakob Bornecrantz | 2fcd5a7 | 2011-10-04 20:13:26 +0200 | [diff] [blame] | 919 | int vmw_kms_present(struct vmw_private *dev_priv, |
| 920 | struct drm_file *file_priv, |
| 921 | struct vmw_framebuffer *vfb, |
| 922 | struct vmw_surface *surface, |
| 923 | uint32_t sid, int32_t destX, int32_t destY, |
| 924 | struct drm_vmw_rect *clips, |
| 925 | uint32_t num_clips); |
Thomas Hellstrom | cd2b89e | 2011-10-25 23:35:53 +0200 | [diff] [blame] | 926 | int vmw_kms_update_layout_ioctl(struct drm_device *dev, void *data, |
| 927 | struct drm_file *file_priv); |
Thomas Hellstrom | 8fbf9d9 | 2015-11-26 19:45:16 +0100 | [diff] [blame] | 928 | void vmw_kms_legacy_hotspot_clear(struct vmw_private *dev_priv); |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 929 | |
Dave Airlie | 5e1782d | 2012-08-28 01:53:54 +0000 | [diff] [blame] | 930 | int vmw_dumb_create(struct drm_file *file_priv, |
| 931 | struct drm_device *dev, |
| 932 | struct drm_mode_create_dumb *args); |
| 933 | |
| 934 | int vmw_dumb_map_offset(struct drm_file *file_priv, |
| 935 | struct drm_device *dev, uint32_t handle, |
| 936 | uint64_t *offset); |
| 937 | int vmw_dumb_destroy(struct drm_file *file_priv, |
| 938 | struct drm_device *dev, |
| 939 | uint32_t handle); |
Thomas Hellstrom | 1a4b172 | 2015-06-26 02:03:53 -0700 | [diff] [blame] | 940 | extern int vmw_resource_pin(struct vmw_resource *res, bool interruptible); |
Thomas Hellstrom | ed93394 | 2015-03-02 23:26:06 -0800 | [diff] [blame] | 941 | extern void vmw_resource_unpin(struct vmw_resource *res); |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 942 | extern enum vmw_res_type vmw_res_type(const struct vmw_resource *res); |
Thomas Hellstrom | ed93394 | 2015-03-02 23:26:06 -0800 | [diff] [blame] | 943 | |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 944 | /** |
| 945 | * Overlay control - vmwgfx_overlay.c |
| 946 | */ |
| 947 | |
| 948 | int vmw_overlay_init(struct vmw_private *dev_priv); |
| 949 | int vmw_overlay_close(struct vmw_private *dev_priv); |
| 950 | int vmw_overlay_ioctl(struct drm_device *dev, void *data, |
| 951 | struct drm_file *file_priv); |
| 952 | int vmw_overlay_stop_all(struct vmw_private *dev_priv); |
| 953 | int vmw_overlay_resume_all(struct vmw_private *dev_priv); |
| 954 | int vmw_overlay_pause_all(struct vmw_private *dev_priv); |
| 955 | int vmw_overlay_claim(struct vmw_private *dev_priv, uint32_t *out); |
| 956 | int vmw_overlay_unref(struct vmw_private *dev_priv, uint32_t stream_id); |
| 957 | int vmw_overlay_num_overlays(struct vmw_private *dev_priv); |
| 958 | int vmw_overlay_num_free_overlays(struct vmw_private *dev_priv); |
| 959 | |
| 960 | /** |
Thomas Hellstrom | 135cba0 | 2010-10-26 21:21:47 +0200 | [diff] [blame] | 961 | * GMR Id manager |
| 962 | */ |
| 963 | |
| 964 | extern const struct ttm_mem_type_manager_func vmw_gmrid_manager_func; |
| 965 | |
| 966 | /** |
Thomas Hellstrom | 69977ff | 2013-11-13 01:50:46 -0800 | [diff] [blame] | 967 | * Prime - vmwgfx_prime.c |
| 968 | */ |
| 969 | |
| 970 | extern const struct dma_buf_ops vmw_prime_dmabuf_ops; |
| 971 | extern int vmw_prime_fd_to_handle(struct drm_device *dev, |
| 972 | struct drm_file *file_priv, |
| 973 | int fd, u32 *handle); |
| 974 | extern int vmw_prime_handle_to_fd(struct drm_device *dev, |
| 975 | struct drm_file *file_priv, |
| 976 | uint32_t handle, uint32_t flags, |
| 977 | int *prime_fd); |
| 978 | |
Thomas Hellstrom | 3530bdc | 2012-11-21 10:49:52 +0100 | [diff] [blame] | 979 | /* |
| 980 | * MemoryOBject management - vmwgfx_mob.c |
| 981 | */ |
| 982 | struct vmw_mob; |
| 983 | extern int vmw_mob_bind(struct vmw_private *dev_priv, struct vmw_mob *mob, |
Thomas Hellstrom | 0fd53cf | 2013-10-24 13:27:38 -0700 | [diff] [blame] | 984 | const struct vmw_sg_table *vsgt, |
| 985 | unsigned long num_data_pages, int32_t mob_id); |
Thomas Hellstrom | 3530bdc | 2012-11-21 10:49:52 +0100 | [diff] [blame] | 986 | extern void vmw_mob_unbind(struct vmw_private *dev_priv, |
| 987 | struct vmw_mob *mob); |
| 988 | extern void vmw_mob_destroy(struct vmw_mob *mob); |
| 989 | extern struct vmw_mob *vmw_mob_create(unsigned long data_pages); |
| 990 | extern int vmw_otables_setup(struct vmw_private *dev_priv); |
| 991 | extern void vmw_otables_takedown(struct vmw_private *dev_priv); |
Thomas Hellstrom | 69977ff | 2013-11-13 01:50:46 -0800 | [diff] [blame] | 992 | |
Thomas Hellstrom | c74c162 | 2012-11-21 12:10:26 +0100 | [diff] [blame] | 993 | /* |
Thomas Hellstrom | 7086d09 | 2012-11-21 12:20:53 +0100 | [diff] [blame] | 994 | * Context management - vmwgfx_context.c |
| 995 | */ |
| 996 | |
| 997 | extern const struct vmw_user_resource_conv *user_context_converter; |
| 998 | |
Thomas Hellstrom | 7086d09 | 2012-11-21 12:20:53 +0100 | [diff] [blame] | 999 | extern int vmw_context_check(struct vmw_private *dev_priv, |
| 1000 | struct ttm_object_file *tfile, |
| 1001 | int id, |
| 1002 | struct vmw_resource **p_res); |
| 1003 | extern int vmw_context_define_ioctl(struct drm_device *dev, void *data, |
| 1004 | struct drm_file *file_priv); |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 1005 | extern int vmw_extended_context_define_ioctl(struct drm_device *dev, void *data, |
| 1006 | struct drm_file *file_priv); |
Thomas Hellstrom | 7086d09 | 2012-11-21 12:20:53 +0100 | [diff] [blame] | 1007 | extern int vmw_context_destroy_ioctl(struct drm_device *dev, void *data, |
| 1008 | struct drm_file *file_priv); |
Thomas Hellstrom | 30f82d81 | 2014-02-05 08:13:56 +0100 | [diff] [blame] | 1009 | extern struct list_head *vmw_context_binding_list(struct vmw_resource *ctx); |
Thomas Hellstrom | 18e4a46 | 2014-06-09 12:39:22 +0200 | [diff] [blame] | 1010 | extern struct vmw_cmdbuf_res_manager * |
| 1011 | vmw_context_res_man(struct vmw_resource *ctx); |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 1012 | extern struct vmw_resource *vmw_context_cotable(struct vmw_resource *ctx, |
| 1013 | SVGACOTableType cotable_type); |
| 1014 | extern struct list_head *vmw_context_binding_list(struct vmw_resource *ctx); |
| 1015 | struct vmw_ctx_binding_state; |
| 1016 | extern struct vmw_ctx_binding_state * |
| 1017 | vmw_context_binding_state(struct vmw_resource *ctx); |
| 1018 | extern void vmw_dx_context_scrub_cotables(struct vmw_resource *ctx, |
| 1019 | bool readback); |
Sinclair Yeh | fd11a3c | 2015-08-10 10:56:15 -0700 | [diff] [blame] | 1020 | extern int vmw_context_bind_dx_query(struct vmw_resource *ctx_res, |
| 1021 | struct vmw_dma_buffer *mob); |
| 1022 | extern struct vmw_dma_buffer * |
| 1023 | vmw_context_get_dx_query_mob(struct vmw_resource *ctx_res); |
| 1024 | |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 1025 | |
Thomas Hellstrom | 7086d09 | 2012-11-21 12:20:53 +0100 | [diff] [blame] | 1026 | /* |
| 1027 | * Surface management - vmwgfx_surface.c |
| 1028 | */ |
| 1029 | |
| 1030 | extern const struct vmw_user_resource_conv *user_surface_converter; |
| 1031 | |
| 1032 | extern void vmw_surface_res_free(struct vmw_resource *res); |
| 1033 | extern int vmw_surface_destroy_ioctl(struct drm_device *dev, void *data, |
| 1034 | struct drm_file *file_priv); |
| 1035 | extern int vmw_surface_define_ioctl(struct drm_device *dev, void *data, |
| 1036 | struct drm_file *file_priv); |
| 1037 | extern int vmw_surface_reference_ioctl(struct drm_device *dev, void *data, |
| 1038 | struct drm_file *file_priv); |
| 1039 | extern int vmw_gb_surface_define_ioctl(struct drm_device *dev, void *data, |
| 1040 | struct drm_file *file_priv); |
| 1041 | extern int vmw_gb_surface_reference_ioctl(struct drm_device *dev, void *data, |
| 1042 | struct drm_file *file_priv); |
| 1043 | extern int vmw_surface_check(struct vmw_private *dev_priv, |
| 1044 | struct ttm_object_file *tfile, |
| 1045 | uint32_t handle, int *id); |
| 1046 | extern int vmw_surface_validate(struct vmw_private *dev_priv, |
| 1047 | struct vmw_surface *srf); |
Sinclair Yeh | 233826a | 2015-03-05 01:06:13 -0800 | [diff] [blame] | 1048 | int vmw_surface_gb_priv_define(struct drm_device *dev, |
| 1049 | uint32_t user_accounting_size, |
| 1050 | uint32_t svga3d_flags, |
| 1051 | SVGA3dSurfaceFormat format, |
| 1052 | bool for_scanout, |
| 1053 | uint32_t num_mip_levels, |
| 1054 | uint32_t multisample_count, |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 1055 | uint32_t array_size, |
Sinclair Yeh | 233826a | 2015-03-05 01:06:13 -0800 | [diff] [blame] | 1056 | struct drm_vmw_size size, |
| 1057 | struct vmw_surface **srf_out); |
Thomas Hellstrom | 7086d09 | 2012-11-21 12:20:53 +0100 | [diff] [blame] | 1058 | |
| 1059 | /* |
Thomas Hellstrom | c74c162 | 2012-11-21 12:10:26 +0100 | [diff] [blame] | 1060 | * Shader management - vmwgfx_shader.c |
| 1061 | */ |
| 1062 | |
Thomas Hellstrom | 7086d09 | 2012-11-21 12:20:53 +0100 | [diff] [blame] | 1063 | extern const struct vmw_user_resource_conv *user_shader_converter; |
| 1064 | |
Thomas Hellstrom | c74c162 | 2012-11-21 12:10:26 +0100 | [diff] [blame] | 1065 | extern int vmw_shader_define_ioctl(struct drm_device *dev, void *data, |
| 1066 | struct drm_file *file_priv); |
| 1067 | extern int vmw_shader_destroy_ioctl(struct drm_device *dev, void *data, |
| 1068 | struct drm_file *file_priv); |
Thomas Hellstrom | 18e4a46 | 2014-06-09 12:39:22 +0200 | [diff] [blame] | 1069 | extern int vmw_compat_shader_add(struct vmw_private *dev_priv, |
| 1070 | struct vmw_cmdbuf_res_manager *man, |
Thomas Hellstrom | d5bde95 | 2014-01-31 10:12:10 +0100 | [diff] [blame] | 1071 | u32 user_key, const void *bytecode, |
| 1072 | SVGA3dShaderType shader_type, |
| 1073 | size_t size, |
Thomas Hellstrom | d5bde95 | 2014-01-31 10:12:10 +0100 | [diff] [blame] | 1074 | struct list_head *list); |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 1075 | extern int vmw_shader_remove(struct vmw_cmdbuf_res_manager *man, |
| 1076 | u32 user_key, SVGA3dShaderType shader_type, |
| 1077 | struct list_head *list); |
| 1078 | extern int vmw_dx_shader_add(struct vmw_cmdbuf_res_manager *man, |
| 1079 | struct vmw_resource *ctx, |
| 1080 | u32 user_key, |
| 1081 | SVGA3dShaderType shader_type, |
| 1082 | struct list_head *list); |
| 1083 | extern void vmw_dx_shader_cotable_list_scrub(struct vmw_private *dev_priv, |
| 1084 | struct list_head *list, |
| 1085 | bool readback); |
| 1086 | |
Thomas Hellstrom | 18e4a46 | 2014-06-09 12:39:22 +0200 | [diff] [blame] | 1087 | extern struct vmw_resource * |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 1088 | vmw_shader_lookup(struct vmw_cmdbuf_res_manager *man, |
| 1089 | u32 user_key, SVGA3dShaderType shader_type); |
Thomas Hellstrom | 18e4a46 | 2014-06-09 12:39:22 +0200 | [diff] [blame] | 1090 | |
| 1091 | /* |
| 1092 | * Command buffer managed resources - vmwgfx_cmdbuf_res.c |
| 1093 | */ |
| 1094 | |
| 1095 | extern struct vmw_cmdbuf_res_manager * |
| 1096 | vmw_cmdbuf_res_man_create(struct vmw_private *dev_priv); |
| 1097 | extern void vmw_cmdbuf_res_man_destroy(struct vmw_cmdbuf_res_manager *man); |
| 1098 | extern size_t vmw_cmdbuf_res_man_size(void); |
| 1099 | extern struct vmw_resource * |
| 1100 | vmw_cmdbuf_res_lookup(struct vmw_cmdbuf_res_manager *man, |
| 1101 | enum vmw_cmdbuf_res_type res_type, |
| 1102 | u32 user_key); |
| 1103 | extern void vmw_cmdbuf_res_revert(struct list_head *list); |
| 1104 | extern void vmw_cmdbuf_res_commit(struct list_head *list); |
| 1105 | extern int vmw_cmdbuf_res_add(struct vmw_cmdbuf_res_manager *man, |
| 1106 | enum vmw_cmdbuf_res_type res_type, |
| 1107 | u32 user_key, |
| 1108 | struct vmw_resource *res, |
| 1109 | struct list_head *list); |
| 1110 | extern int vmw_cmdbuf_res_remove(struct vmw_cmdbuf_res_manager *man, |
| 1111 | enum vmw_cmdbuf_res_type res_type, |
| 1112 | u32 user_key, |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 1113 | struct list_head *list, |
| 1114 | struct vmw_resource **res); |
Thomas Hellstrom | d5bde95 | 2014-01-31 10:12:10 +0100 | [diff] [blame] | 1115 | |
Thomas Hellstrom | d80efd5 | 2015-08-10 10:39:35 -0700 | [diff] [blame] | 1116 | /* |
| 1117 | * COTable management - vmwgfx_cotable.c |
| 1118 | */ |
| 1119 | extern const SVGACOTableType vmw_cotable_scrub_order[]; |
| 1120 | extern struct vmw_resource *vmw_cotable_alloc(struct vmw_private *dev_priv, |
| 1121 | struct vmw_resource *ctx, |
| 1122 | u32 type); |
| 1123 | extern int vmw_cotable_notify(struct vmw_resource *res, int id); |
| 1124 | extern int vmw_cotable_scrub(struct vmw_resource *res, bool readback); |
| 1125 | extern void vmw_cotable_add_resource(struct vmw_resource *ctx, |
| 1126 | struct list_head *head); |
Thomas Hellstrom | c74c162 | 2012-11-21 12:10:26 +0100 | [diff] [blame] | 1127 | |
Thomas Hellstrom | 3eab3d9 | 2015-06-25 11:57:56 -0700 | [diff] [blame] | 1128 | /* |
| 1129 | * Command buffer managerment vmwgfx_cmdbuf.c |
| 1130 | */ |
| 1131 | struct vmw_cmdbuf_man; |
| 1132 | struct vmw_cmdbuf_header; |
| 1133 | |
| 1134 | extern struct vmw_cmdbuf_man * |
| 1135 | vmw_cmdbuf_man_create(struct vmw_private *dev_priv); |
| 1136 | extern int vmw_cmdbuf_set_pool_size(struct vmw_cmdbuf_man *man, |
| 1137 | size_t size, size_t default_size); |
| 1138 | extern void vmw_cmdbuf_remove_pool(struct vmw_cmdbuf_man *man); |
| 1139 | extern void vmw_cmdbuf_man_destroy(struct vmw_cmdbuf_man *man); |
| 1140 | extern int vmw_cmdbuf_idle(struct vmw_cmdbuf_man *man, bool interruptible, |
| 1141 | unsigned long timeout); |
| 1142 | extern void *vmw_cmdbuf_reserve(struct vmw_cmdbuf_man *man, size_t size, |
| 1143 | int ctx_id, bool interruptible, |
| 1144 | struct vmw_cmdbuf_header *header); |
| 1145 | extern void vmw_cmdbuf_commit(struct vmw_cmdbuf_man *man, size_t size, |
| 1146 | struct vmw_cmdbuf_header *header, |
| 1147 | bool flush); |
| 1148 | extern void vmw_cmdbuf_tasklet_schedule(struct vmw_cmdbuf_man *man); |
| 1149 | extern void *vmw_cmdbuf_alloc(struct vmw_cmdbuf_man *man, |
| 1150 | size_t size, bool interruptible, |
| 1151 | struct vmw_cmdbuf_header **p_header); |
| 1152 | extern void vmw_cmdbuf_header_free(struct vmw_cmdbuf_header *header); |
| 1153 | extern int vmw_cmdbuf_cur_flush(struct vmw_cmdbuf_man *man, |
| 1154 | bool interruptible); |
Thomas Hellstrom | bf6f036 | 2012-11-09 12:26:15 +0000 | [diff] [blame] | 1155 | |
| 1156 | |
| 1157 | /** |
| 1158 | * Inline helper functions |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 1159 | */ |
| 1160 | |
| 1161 | static inline void vmw_surface_unreference(struct vmw_surface **srf) |
| 1162 | { |
| 1163 | struct vmw_surface *tmp_srf = *srf; |
| 1164 | struct vmw_resource *res = &tmp_srf->res; |
| 1165 | *srf = NULL; |
| 1166 | |
| 1167 | vmw_resource_unreference(&res); |
Thomas Hellstrom | ae2a104 | 2011-09-01 20:18:44 +0000 | [diff] [blame] | 1168 | } |
| 1169 | |
| 1170 | static inline struct vmw_surface *vmw_surface_reference(struct vmw_surface *srf) |
| 1171 | { |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 1172 | (void) vmw_resource_reference(&srf->res); |
| 1173 | return srf; |
| 1174 | } |
| 1175 | |
| 1176 | static inline void vmw_dmabuf_unreference(struct vmw_dma_buffer **buf) |
| 1177 | { |
| 1178 | struct vmw_dma_buffer *tmp_buf = *buf; |
| 1179 | |
| 1180 | *buf = NULL; |
| 1181 | if (tmp_buf != NULL) { |
| 1182 | struct ttm_buffer_object *bo = &tmp_buf->base; |
| 1183 | |
| 1184 | ttm_bo_unref(&bo); |
| 1185 | } |
| 1186 | } |
| 1187 | |
| 1188 | static inline struct vmw_dma_buffer *vmw_dmabuf_reference(struct vmw_dma_buffer *buf) |
| 1189 | { |
| 1190 | if (ttm_bo_reference(&buf->base)) |
| 1191 | return buf; |
| 1192 | return NULL; |
| 1193 | } |
| 1194 | |
| 1195 | static inline struct ttm_mem_global *vmw_mem_glob(struct vmw_private *dev_priv) |
| 1196 | { |
| 1197 | return (struct ttm_mem_global *) dev_priv->mem_global_ref.object; |
| 1198 | } |
Thomas Hellstrom | 153b3d5 | 2015-06-25 10:47:43 -0700 | [diff] [blame] | 1199 | |
| 1200 | static inline void vmw_fifo_resource_inc(struct vmw_private *dev_priv) |
| 1201 | { |
| 1202 | atomic_inc(&dev_priv->num_fifo_resources); |
| 1203 | } |
| 1204 | |
| 1205 | static inline void vmw_fifo_resource_dec(struct vmw_private *dev_priv) |
| 1206 | { |
| 1207 | atomic_dec(&dev_priv->num_fifo_resources); |
| 1208 | } |
Thomas Hellstrom | b76ff5e | 2015-10-28 10:44:04 +0100 | [diff] [blame] | 1209 | |
| 1210 | /** |
| 1211 | * vmw_mmio_read - Perform a MMIO read from volatile memory |
| 1212 | * |
| 1213 | * @addr: The address to read from |
| 1214 | * |
| 1215 | * This function is intended to be equivalent to ioread32() on |
| 1216 | * memremap'd memory, but without byteswapping. |
| 1217 | */ |
| 1218 | static inline u32 vmw_mmio_read(u32 *addr) |
| 1219 | { |
| 1220 | return READ_ONCE(*addr); |
| 1221 | } |
| 1222 | |
| 1223 | /** |
| 1224 | * vmw_mmio_write - Perform a MMIO write to volatile memory |
| 1225 | * |
| 1226 | * @addr: The address to write to |
| 1227 | * |
| 1228 | * This function is intended to be equivalent to iowrite32 on |
| 1229 | * memremap'd memory, but without byteswapping. |
| 1230 | */ |
| 1231 | static inline void vmw_mmio_write(u32 value, u32 *addr) |
| 1232 | { |
| 1233 | WRITE_ONCE(*addr, value); |
| 1234 | } |
Jakob Bornecrantz | fb1d973 | 2009-12-10 00:19:58 +0000 | [diff] [blame] | 1235 | #endif |