1 /********************************************************** 2 * Copyright 2008-2009 VMware, Inc. All rights reserved. 3 * 4 * Permission is hereby granted, free of charge, to any person 5 * obtaining a copy of this software and associated documentation 6 * files (the "Software"), to deal in the Software without 7 * restriction, including without limitation the rights to use, copy, 8 * modify, merge, publish, distribute, sublicense, and/or sell copies 9 * of the Software, and to permit persons to whom the Software is 10 * furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be 13 * included in all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 16 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 17 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 18 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 19 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 20 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 21 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 22 * SOFTWARE. 23 * 24 **********************************************************/ 25 26 /** 27 * @file 28 * VMware SVGA specific winsys interface. 29 * 30 * @author Jose Fonseca <jfonseca@vmware.com> 31 * 32 * Documentation taken from the VMware SVGA DDK. 33 */ 34 35 #ifndef SVGA_WINSYS_H_ 36 #define SVGA_WINSYS_H_ 37 38 #include "svga_types.h" 39 #include "svga3d_types.h" 40 #include "svga_reg.h" 41 #include "svga3d_reg.h" 42 43 #include "pipe/p_compiler.h" 44 #include "pipe/p_defines.h" 45 46 #include "svga_mksstats.h" 47 48 struct svga_winsys_screen; 49 struct svga_winsys_buffer; 50 struct pipe_screen; 51 struct pipe_context; 52 struct pipe_debug_callback; 53 struct pipe_fence_handle; 54 struct pipe_resource; 55 struct svga_region; 56 struct winsys_handle; 57 58 59 #define SVGA_BUFFER_USAGE_PINNED (1 << 0) 60 #define SVGA_BUFFER_USAGE_WRAPPED (1 << 1) 61 #define SVGA_BUFFER_USAGE_SHADER (1 << 2) 62 63 /** 64 * Relocation flags to help with dirty tracking 65 * SVGA_RELOC_WRITE - The command will cause a GPU write to this 66 * resource. 67 * SVGA_RELOC_READ - The command will cause a GPU read from this 68 * resource. 69 * SVGA_RELOC_INTERNAL The command will only transfer data internally 70 * within the resource, and optionally clear 71 * dirty bits 72 * SVGA_RELOC_DMA - Only set for resource buffer DMA uploads for winsys 73 * implementations that want to track the amount 74 * of such data referenced in the command stream. 75 */ 76 #define SVGA_RELOC_WRITE (1 << 0) 77 #define SVGA_RELOC_READ (1 << 1) 78 #define SVGA_RELOC_INTERNAL (1 << 2) 79 #define SVGA_RELOC_DMA (1 << 3) 80 81 #define SVGA_FENCE_FLAG_EXEC (1 << 0) 82 #define SVGA_FENCE_FLAG_QUERY (1 << 1) 83 84 #define SVGA_SURFACE_USAGE_SHARED (1 << 0) 85 #define SVGA_SURFACE_USAGE_SCANOUT (1 << 1) 86 #define SVGA_SURFACE_USAGE_COHERENT (1 << 2) 87 88 #define SVGA_QUERY_FLAG_SET (1 << 0) 89 #define SVGA_QUERY_FLAG_REF (1 << 1) 90 91 #define SVGA_HINT_FLAG_CAN_PRE_FLUSH (1 << 0) /* Can preemptively flush */ 92 #define SVGA_HINT_FLAG_EXPORT_FENCE_FD (1 << 1) /* Export a Fence FD */ 93 94 /** 95 * SVGA mks statistics info 96 */ 97 struct svga_winsys_stats_timeframe { 98 void *counterTime; 99 uint64 startTime; 100 uint64 adjustedStartTime; 101 struct svga_winsys_stats_timeframe *enclosing; 102 }; 103 104 enum svga_stats_count { 105 SVGA_STATS_COUNT_BLENDSTATE, 106 SVGA_STATS_COUNT_BLITBLITTERCOPY, 107 SVGA_STATS_COUNT_DEPTHSTENCILSTATE, 108 SVGA_STATS_COUNT_RASTERIZERSTATE, 109 SVGA_STATS_COUNT_SAMPLER, 110 SVGA_STATS_COUNT_SAMPLERVIEW, 111 SVGA_STATS_COUNT_SURFACEWRITEFLUSH, 112 SVGA_STATS_COUNT_TEXREADBACK, 113 SVGA_STATS_COUNT_VERTEXELEMENT, 114 SVGA_STATS_COUNT_MAX 115 }; 116 117 enum svga_stats_time { 118 SVGA_STATS_TIME_BLIT, 119 SVGA_STATS_TIME_BLITBLITTER, 120 SVGA_STATS_TIME_BLITFALLBACK, 121 SVGA_STATS_TIME_BUFFERSFLUSH, 122 SVGA_STATS_TIME_BUFFERTRANSFERMAP, 123 SVGA_STATS_TIME_BUFFERTRANSFERUNMAP, 124 SVGA_STATS_TIME_CONTEXTFINISH, 125 SVGA_STATS_TIME_CONTEXTFLUSH, 126 SVGA_STATS_TIME_COPYREGION, 127 SVGA_STATS_TIME_COPYREGIONFALLBACK, 128 SVGA_STATS_TIME_CREATEBACKEDSURFACEVIEW, 129 SVGA_STATS_TIME_CREATEBUFFER, 130 SVGA_STATS_TIME_CREATECONTEXT, 131 SVGA_STATS_TIME_CREATEFS, 132 SVGA_STATS_TIME_CREATEGS, 133 SVGA_STATS_TIME_CREATESURFACE, 134 SVGA_STATS_TIME_CREATESURFACEVIEW, 135 SVGA_STATS_TIME_CREATETCS, 136 SVGA_STATS_TIME_CREATETES, 137 SVGA_STATS_TIME_CREATETEXTURE, 138 SVGA_STATS_TIME_CREATEVS, 139 SVGA_STATS_TIME_DEFINESHADER, 140 SVGA_STATS_TIME_DESTROYSURFACE, 141 SVGA_STATS_TIME_DRAWVBO, 142 SVGA_STATS_TIME_DRAWARRAYS, 143 SVGA_STATS_TIME_DRAWELEMENTS, 144 SVGA_STATS_TIME_EMITFS, 145 SVGA_STATS_TIME_EMITGS, 146 SVGA_STATS_TIME_EMITTCS, 147 SVGA_STATS_TIME_EMITTES, 148 SVGA_STATS_TIME_EMITVS, 149 SVGA_STATS_TIME_EMULATESURFACEVIEW, 150 SVGA_STATS_TIME_FENCEFINISH, 151 SVGA_STATS_TIME_GENERATEINDICES, 152 SVGA_STATS_TIME_HWTNLDRAWARRAYS, 153 SVGA_STATS_TIME_HWTNLDRAWELEMENTS, 154 SVGA_STATS_TIME_HWTNLFLUSH, 155 SVGA_STATS_TIME_HWTNLPRIM, 156 SVGA_STATS_TIME_PROPAGATESURFACE, 157 SVGA_STATS_TIME_SETSAMPLERVIEWS, 158 SVGA_STATS_TIME_SURFACEFLUSH, 159 SVGA_STATS_TIME_SWTNLDRAWVBO, 160 SVGA_STATS_TIME_SWTNLUPDATEDRAW, 161 SVGA_STATS_TIME_SWTNLUPDATEVDECL, 162 SVGA_STATS_TIME_TEXTRANSFERMAP, 163 SVGA_STATS_TIME_TEXTRANSFERUNMAP, 164 SVGA_STATS_TIME_TGSIVGPU10TRANSLATE, 165 SVGA_STATS_TIME_TGSIVGPU9TRANSLATE, 166 SVGA_STATS_TIME_UPDATESTATE, 167 SVGA_STATS_TIME_VALIDATESURFACEVIEW, 168 SVGA_STATS_TIME_VBUFDRAWARRAYS, 169 SVGA_STATS_TIME_VBUFDRAWELEMENTS, 170 SVGA_STATS_TIME_VBUFRENDERALLOCVERT, 171 SVGA_STATS_TIME_VBUFRENDERMAPVERT, 172 SVGA_STATS_TIME_VBUFRENDERUNMAPVERT, 173 SVGA_STATS_TIME_VBUFSUBMITSTATE, 174 SVGA_STATS_TIME_MAX 175 }; 176 177 #define SVGA_STATS_PREFIX "GuestGL_" 178 179 #define SVGA_STATS_COUNT_NAMES \ 180 SVGA_STATS_PREFIX "BlendState", \ 181 SVGA_STATS_PREFIX "BlitBlitterCopy", \ 182 SVGA_STATS_PREFIX "DepthStencilState", \ 183 SVGA_STATS_PREFIX "RasterizerState", \ 184 SVGA_STATS_PREFIX "Sampler", \ 185 SVGA_STATS_PREFIX "SamplerView", \ 186 SVGA_STATS_PREFIX "SurfaceWriteFlush", \ 187 SVGA_STATS_PREFIX "TextureReadback", \ 188 SVGA_STATS_PREFIX "VertexElement" \ 189 190 #define SVGA_STATS_TIME_NAMES \ 191 SVGA_STATS_PREFIX "Blit", \ 192 SVGA_STATS_PREFIX "BlitBlitter", \ 193 SVGA_STATS_PREFIX "BlitFallback", \ 194 SVGA_STATS_PREFIX "BuffersFlush", \ 195 SVGA_STATS_PREFIX "BufferTransferMap", \ 196 SVGA_STATS_PREFIX "BufferTransferUnmap", \ 197 SVGA_STATS_PREFIX "ContextFinish", \ 198 SVGA_STATS_PREFIX "ContextFlush", \ 199 SVGA_STATS_PREFIX "CopyRegion", \ 200 SVGA_STATS_PREFIX "CopyRegionFallback", \ 201 SVGA_STATS_PREFIX "CreateBackedSurfaceView", \ 202 SVGA_STATS_PREFIX "CreateBuffer", \ 203 SVGA_STATS_PREFIX "CreateContext", \ 204 SVGA_STATS_PREFIX "CreateFS", \ 205 SVGA_STATS_PREFIX "CreateGS", \ 206 SVGA_STATS_PREFIX "CreateSurface", \ 207 SVGA_STATS_PREFIX "CreateSurfaceView", \ 208 SVGA_STATS_PREFIX "CreateTCS", \ 209 SVGA_STATS_PREFIX "CreateTES", \ 210 SVGA_STATS_PREFIX "CreateTexture", \ 211 SVGA_STATS_PREFIX "CreateVS", \ 212 SVGA_STATS_PREFIX "DefineShader", \ 213 SVGA_STATS_PREFIX "DestroySurface", \ 214 SVGA_STATS_PREFIX "DrawVBO", \ 215 SVGA_STATS_PREFIX "DrawArrays", \ 216 SVGA_STATS_PREFIX "DrawElements", \ 217 SVGA_STATS_PREFIX "EmitFS", \ 218 SVGA_STATS_PREFIX "EmitGS", \ 219 SVGA_STATS_PREFIX "EmitTCS", \ 220 SVGA_STATS_PREFIX "EmitTES", \ 221 SVGA_STATS_PREFIX "EmitVS", \ 222 SVGA_STATS_PREFIX "EmulateSurfaceView", \ 223 SVGA_STATS_PREFIX "FenceFinish", \ 224 SVGA_STATS_PREFIX "GenerateIndices", \ 225 SVGA_STATS_PREFIX "HWtnlDrawArrays", \ 226 SVGA_STATS_PREFIX "HWtnlDrawElements", \ 227 SVGA_STATS_PREFIX "HWtnlFlush", \ 228 SVGA_STATS_PREFIX "HWtnlPrim", \ 229 SVGA_STATS_PREFIX "PropagateSurface", \ 230 SVGA_STATS_PREFIX "SetSamplerViews", \ 231 SVGA_STATS_PREFIX "SurfaceFlush", \ 232 SVGA_STATS_PREFIX "SwtnlDrawVBO", \ 233 SVGA_STATS_PREFIX "SwtnlUpdateDraw", \ 234 SVGA_STATS_PREFIX "SwtnlUpdateVDecl", \ 235 SVGA_STATS_PREFIX "TextureTransferMap", \ 236 SVGA_STATS_PREFIX "TextureTransferUnmap", \ 237 SVGA_STATS_PREFIX "TGSIVGPU10Translate", \ 238 SVGA_STATS_PREFIX "TGSIVGPU9Translate", \ 239 SVGA_STATS_PREFIX "UpdateState", \ 240 SVGA_STATS_PREFIX "ValidateSurfaceView", \ 241 SVGA_STATS_PREFIX "VbufDrawArrays", \ 242 SVGA_STATS_PREFIX "VbufDrawElements", \ 243 SVGA_STATS_PREFIX "VbufRenderAllocVertices", \ 244 SVGA_STATS_PREFIX "VbufRenderMapVertices", \ 245 SVGA_STATS_PREFIX "VbufRenderUnmapVertices", \ 246 SVGA_STATS_PREFIX "VbufSubmitState" 247 248 249 /** Opaque surface handle */ 250 struct svga_winsys_surface; 251 252 /** Opaque guest-backed objects */ 253 struct svga_winsys_gb_shader; 254 struct svga_winsys_gb_query; 255 256 257 /** 258 * SVGA per-context winsys interface. 259 */ 260 struct svga_winsys_context 261 { 262 void 263 (*destroy)(struct svga_winsys_context *swc); 264 265 void * 266 (*reserve)(struct svga_winsys_context *swc, 267 uint32_t nr_bytes, uint32_t nr_relocs ); 268 269 /** 270 * Returns current size of command buffer, in bytes. 271 */ 272 unsigned 273 (*get_command_buffer_size)(struct svga_winsys_context *swc); 274 275 /** 276 * Emit a relocation for a host surface. 277 * 278 * @param flags bitmask of SVGA_RELOC_* flags 279 * 280 * NOTE: Order of this call does matter. It should be the same order 281 * as relocations appear in the command buffer. 282 */ 283 void 284 (*surface_relocation)(struct svga_winsys_context *swc, 285 uint32 *sid, 286 uint32 *mobid, 287 struct svga_winsys_surface *surface, 288 unsigned flags); 289 290 /** 291 * Emit a relocation for a guest memory region. 292 * 293 * @param flags bitmask of SVGA_RELOC_* flags 294 * 295 * NOTE: Order of this call does matter. It should be the same order 296 * as relocations appear in the command buffer. 297 */ 298 void 299 (*region_relocation)(struct svga_winsys_context *swc, 300 struct SVGAGuestPtr *ptr, 301 struct svga_winsys_buffer *buffer, 302 uint32 offset, 303 unsigned flags); 304 305 /** 306 * Emit a relocation for a guest-backed shader object. 307 * 308 * NOTE: Order of this call does matter. It should be the same order 309 * as relocations appear in the command buffer. 310 */ 311 void 312 (*shader_relocation)(struct svga_winsys_context *swc, 313 uint32 *shid, 314 uint32 *mobid, 315 uint32 *offset, 316 struct svga_winsys_gb_shader *shader, 317 unsigned flags); 318 319 /** 320 * Emit a relocation for a guest-backed context. 321 * 322 * NOTE: Order of this call does matter. It should be the same order 323 * as relocations appear in the command buffer. 324 */ 325 void 326 (*context_relocation)(struct svga_winsys_context *swc, uint32 *cid); 327 328 /** 329 * Emit a relocation for a guest Memory OBject. 330 * 331 * @param flags bitmask of SVGA_RELOC_* flags 332 * @param offset_into_mob Buffer starts at this offset into the MOB. 333 * 334 * Note that not all commands accept an offset into the MOB and 335 * those commands can't use suballocated buffer pools. To trap 336 * errors from improper buffer pool usage, set the offset_into_mob 337 * pointer to NULL. 338 */ 339 void 340 (*mob_relocation)(struct svga_winsys_context *swc, 341 SVGAMobId *id, 342 uint32 *offset_into_mob, 343 struct svga_winsys_buffer *buffer, 344 uint32 offset, 345 unsigned flags); 346 347 /** 348 * Emit a relocation for a guest-backed query object. 349 * 350 * NOTE: Order of this call does matter. It should be the same order 351 * as relocations appear in the command buffer. 352 */ 353 void 354 (*query_relocation)(struct svga_winsys_context *swc, 355 SVGAMobId *id, 356 struct svga_winsys_gb_query *query); 357 358 /** 359 * Bind queries to context. 360 * \param flags exactly one of SVGA_QUERY_FLAG_SET/REF 361 */ 362 enum pipe_error 363 (*query_bind)(struct svga_winsys_context *sws, 364 struct svga_winsys_gb_query *query, 365 unsigned flags); 366 367 void 368 (*commit)(struct svga_winsys_context *swc); 369 370 enum pipe_error 371 (*flush)(struct svga_winsys_context *swc, 372 struct pipe_fence_handle **pfence); 373 374 /** 375 * Context ID used to fill in the commands 376 * 377 * Context IDs are arbitrary small non-negative integers, 378 * global to the entire SVGA device. 379 */ 380 uint32 cid; 381 382 /** 383 * Flags to hint the current context state 384 */ 385 uint32 hints; 386 387 /** 388 * File descriptor for imported fence 389 */ 390 int32 imported_fence_fd; 391 392 /** 393 ** BEGIN new functions for guest-backed surfaces. 394 **/ 395 396 boolean have_gb_objects; 397 boolean force_coherent; 398 399 /** 400 * Map a guest-backed surface. 401 * \param swc The winsys context 402 * \param surface The surface to map 403 * \param flags bitmaks of PIPE_MAP_x flags 404 * \param retry Whether to flush and retry the map 405 * \param rebind Whether to issue an immediate rebind and flush. 406 * 407 * The surface_map() member is allowed to fail due to a 408 * shortage of command buffer space, if the 409 * PIPE_MAP_DISCARD_WHOLE_RESOURCE bit is set in flags. 410 * In that case, the caller must flush the current command 411 * buffer and reissue the map. 412 */ 413 void * 414 (*surface_map)(struct svga_winsys_context *swc, 415 struct svga_winsys_surface *surface, 416 unsigned flags, boolean *retry, 417 boolean *rebind); 418 419 /** 420 * Unmap a guest-backed surface. 421 * \param rebind returns a flag indicating whether the caller should 422 * issue a SVGA3D_BindGBSurface() call. 423 */ 424 void 425 (*surface_unmap)(struct svga_winsys_context *swc, 426 struct svga_winsys_surface *surface, 427 boolean *rebind); 428 429 /** 430 * Create and define a DX GB shader that resides in the device COTable. 431 * Caller of this function will issue the DXDefineShader command. 432 */ 433 struct svga_winsys_gb_shader * 434 (*shader_create)(struct svga_winsys_context *swc, 435 uint32 shaderId, 436 SVGA3dShaderType shaderType, 437 const uint32 *bytecode, 438 uint32 bytecodeLen, 439 const SVGA3dDXShaderSignatureHeader *sgnInfo, 440 uint32 sgnLen); 441 442 /** 443 * Destroy a DX GB shader. 444 * This function will issue the DXDestroyShader command. 445 */ 446 void 447 (*shader_destroy)(struct svga_winsys_context *swc, 448 struct svga_winsys_gb_shader *shader); 449 450 /** 451 * Rebind a DX GB resource to a context. 452 * This is called to reference a DX GB resource in the command stream in 453 * order to page in the associated resource in case the memory has been 454 * paged out, and to fence it if necessary after command submission. 455 */ 456 enum pipe_error 457 (*resource_rebind)(struct svga_winsys_context *swc, 458 struct svga_winsys_surface *surface, 459 struct svga_winsys_gb_shader *shader, 460 unsigned flags); 461 462 /** To report perf/conformance/etc issues to the gallium frontend */ 463 struct pipe_debug_callback *debug_callback; 464 465 /** The more recent command issued to command buffer */ 466 SVGAFifo3dCmdId last_command; 467 468 /** For HUD queries */ 469 uint64_t num_commands; 470 uint64_t num_command_buffers; 471 uint64_t num_draw_commands; 472 uint64_t num_shader_reloc; 473 uint64_t num_surf_reloc; 474 475 /* Whether we are in retry processing */ 476 unsigned int in_retry; 477 }; 478 479 480 /** 481 * SVGA per-screen winsys interface. 482 */ 483 struct svga_winsys_screen 484 { 485 void 486 (*destroy)(struct svga_winsys_screen *sws); 487 488 SVGA3dHardwareVersion 489 (*get_hw_version)(struct svga_winsys_screen *sws); 490 491 boolean 492 (*get_cap)(struct svga_winsys_screen *sws, 493 SVGA3dDevCapIndex index, 494 SVGA3dDevCapResult *result); 495 496 /** 497 * Create a new context. 498 * 499 * Context objects encapsulate all render state, and shader 500 * objects are per-context. 501 * 502 * Surfaces are not per-context. The same surface can be shared 503 * between multiple contexts, and surface operations can occur 504 * without a context. 505 */ 506 struct svga_winsys_context * 507 (*context_create)(struct svga_winsys_screen *sws); 508 509 /** 510 * This creates a "surface" object in the SVGA3D device. 511 * 512 * \param sws Pointer to an svga_winsys_context 513 * \param flags Device surface create flags 514 * \param format Format Device surface format 515 * \param usage Winsys usage: bitmask of SVGA_SURFACE_USAGE_x flags 516 * \param size Surface size given in device format 517 * \param numLayers Number of layers of the surface (or cube faces) 518 * \param numMipLevels Number of mipmap levels for each face 519 * 520 * Returns the surface ID (sid). Surfaces are generic 521 * containers for host VRAM objects like textures, vertex 522 * buffers, and depth/stencil buffers. 523 * 524 * Surfaces are hierarchial: 525 * 526 * - Surface may have multiple faces (for cube maps) 527 * 528 * - Each face has a list of mipmap levels 529 * 530 * - Each mipmap image may have multiple volume 531 * slices for 3D image, or multiple 2D slices for texture array. 532 * 533 * - Each slice is a 2D array of 'blocks' 534 * 535 * - Each block may be one or more pixels. 536 * (Usually 1, more for DXT or YUV formats.) 537 * 538 * Surfaces are generic host VRAM objects. The SVGA3D device 539 * may optimize surfaces according to the format they were 540 * created with, but this format does not limit the ways in 541 * which the surface may be used. For example, a depth surface 542 * can be used as a texture, or a floating point image may 543 * be used as a vertex buffer. Some surface usages may be 544 * lower performance, due to software emulation, but any 545 * usage should work with any surface. 546 */ 547 struct svga_winsys_surface * 548 (*surface_create)(struct svga_winsys_screen *sws, 549 SVGA3dSurfaceAllFlags flags, 550 SVGA3dSurfaceFormat format, 551 unsigned usage, 552 SVGA3dSize size, 553 uint32 numLayers, 554 uint32 numMipLevels, 555 unsigned sampleCount); 556 557 /** 558 * Creates a surface from a winsys handle. 559 * Used to implement pipe_screen::resource_from_handle. 560 */ 561 struct svga_winsys_surface * 562 (*surface_from_handle)(struct svga_winsys_screen *sws, 563 struct winsys_handle *whandle, 564 SVGA3dSurfaceFormat *format); 565 566 /** 567 * Get a winsys_handle from a surface. 568 * Used to implement pipe_screen::resource_get_handle. 569 */ 570 boolean 571 (*surface_get_handle)(struct svga_winsys_screen *sws, 572 struct svga_winsys_surface *surface, 573 unsigned stride, 574 struct winsys_handle *whandle); 575 576 /** 577 * Whether this surface is sitting in a validate list 578 */ 579 boolean 580 (*surface_is_flushed)(struct svga_winsys_screen *sws, 581 struct svga_winsys_surface *surface); 582 583 /** 584 * Reference a SVGA3D surface object. This allows sharing of a 585 * surface between different objects. 586 */ 587 void 588 (*surface_reference)(struct svga_winsys_screen *sws, 589 struct svga_winsys_surface **pdst, 590 struct svga_winsys_surface *src); 591 592 /** 593 * Check if a resource (texture, buffer) of the given size 594 * and format can be created. 595 * \Return TRUE if OK, FALSE if too large. 596 */ 597 boolean 598 (*surface_can_create)(struct svga_winsys_screen *sws, 599 SVGA3dSurfaceFormat format, 600 SVGA3dSize size, 601 uint32 numLayers, 602 uint32 numMipLevels, 603 uint32 numSamples); 604 605 void 606 (*surface_init)(struct svga_winsys_screen *sws, 607 struct svga_winsys_surface *surface, 608 unsigned surf_size, SVGA3dSurfaceAllFlags flags); 609 610 /** 611 * Buffer management. Buffer attributes are mostly fixed over its lifetime. 612 * 613 * @param usage bitmask of SVGA_BUFFER_USAGE_* flags. 614 * 615 * alignment indicates the client's alignment requirements, eg for 616 * SSE instructions. 617 */ 618 struct svga_winsys_buffer * 619 (*buffer_create)( struct svga_winsys_screen *sws, 620 unsigned alignment, 621 unsigned usage, 622 unsigned size ); 623 624 /** 625 * Map the entire data store of a buffer object into the client's address. 626 * usage is a bitmask of PIPE_MAP_* 627 */ 628 void * 629 (*buffer_map)( struct svga_winsys_screen *sws, 630 struct svga_winsys_buffer *buf, 631 unsigned usage ); 632 633 void 634 (*buffer_unmap)( struct svga_winsys_screen *sws, 635 struct svga_winsys_buffer *buf ); 636 637 void 638 (*buffer_destroy)( struct svga_winsys_screen *sws, 639 struct svga_winsys_buffer *buf ); 640 641 642 /** 643 * Reference a fence object. 644 */ 645 void 646 (*fence_reference)( struct svga_winsys_screen *sws, 647 struct pipe_fence_handle **pdst, 648 struct pipe_fence_handle *src ); 649 650 /** 651 * Checks whether the fence has been signalled. 652 * \param flags driver-specific meaning 653 * \return zero on success. 654 */ 655 int (*fence_signalled)( struct svga_winsys_screen *sws, 656 struct pipe_fence_handle *fence, 657 unsigned flag ); 658 659 /** 660 * Wait for the fence to finish. 661 * \param timeout in nanoseconds (may be PIPE_TIMEOUT_INFINITE). 662 * 0 to return immediately, if the API suports it. 663 * \param flags driver-specific meaning 664 * \return zero on success. 665 */ 666 int (*fence_finish)( struct svga_winsys_screen *sws, 667 struct pipe_fence_handle *fence, 668 uint64_t timeout, 669 unsigned flag ); 670 671 /** 672 * Get the file descriptor associated with the fence 673 * \param duplicate duplicate the fd before returning it 674 * \return zero on success. 675 */ 676 int (*fence_get_fd)( struct svga_winsys_screen *sws, 677 struct pipe_fence_handle *fence, 678 boolean duplicate ); 679 680 /** 681 * Create a fence using the given file descriptor 682 * \return zero on success. 683 */ 684 void (*fence_create_fd)( struct svga_winsys_screen *sws, 685 struct pipe_fence_handle **fence, 686 int32_t fd ); 687 688 /** 689 * Accumulates fence FD from other devices into the current context 690 * \param context_fd FD the context will be waiting on 691 * \return zero on success 692 */ 693 int (*fence_server_sync)( struct svga_winsys_screen *sws, 694 int32_t *context_fd, 695 struct pipe_fence_handle *fence ); 696 697 /** 698 ** BEGIN new functions for guest-backed surfaces. 699 **/ 700 701 /** Are guest-backed objects enabled? */ 702 bool have_gb_objects; 703 704 /** Can we do DMA with guest-backed objects enabled? */ 705 bool have_gb_dma; 706 707 /** Do we support coherent surface memory? */ 708 bool have_coherent; 709 /** 710 * Create and define a GB shader. 711 */ 712 struct svga_winsys_gb_shader * 713 (*shader_create)(struct svga_winsys_screen *sws, 714 SVGA3dShaderType shaderType, 715 const uint32 *bytecode, 716 uint32 bytecodeLen); 717 718 /** 719 * Destroy a GB shader. It's safe to call this function even 720 * if the shader is referenced in a context's command stream. 721 */ 722 void 723 (*shader_destroy)(struct svga_winsys_screen *sws, 724 struct svga_winsys_gb_shader *shader); 725 726 /** 727 * Create and define a GB query. 728 */ 729 struct svga_winsys_gb_query * 730 (*query_create)(struct svga_winsys_screen *sws, uint32 len); 731 732 /** 733 * Destroy a GB query. 734 */ 735 void 736 (*query_destroy)(struct svga_winsys_screen *sws, 737 struct svga_winsys_gb_query *query); 738 739 /** 740 * Initialize the query state of the query that resides in the slot 741 * specified in offset 742 * \return zero on success. 743 */ 744 int 745 (*query_init)(struct svga_winsys_screen *sws, 746 struct svga_winsys_gb_query *query, 747 unsigned offset, 748 SVGA3dQueryState queryState); 749 750 /** 751 * Inquire for the query state and result of the query that resides 752 * in the slot specified in offset 753 */ 754 void 755 (*query_get_result)(struct svga_winsys_screen *sws, 756 struct svga_winsys_gb_query *query, 757 unsigned offset, 758 SVGA3dQueryState *queryState, 759 void *result, uint32 resultLen); 760 761 /** 762 * Increment a statistic counter 763 */ 764 void 765 (*stats_inc)(enum svga_stats_count); 766 767 /** 768 * Push a time frame onto the stack 769 */ 770 void 771 (*stats_time_push)(enum svga_stats_time, struct svga_winsys_stats_timeframe *); 772 773 /** 774 * Pop a time frame. 775 */ 776 void 777 (*stats_time_pop)(); 778 779 /** 780 * Send a host log message 781 */ 782 void 783 (*host_log)(struct svga_winsys_screen *sws, const char *message); 784 785 /** Have VGPU v10 hardware? */ 786 boolean have_vgpu10; 787 788 /** Have SM4_1 hardware? */ 789 boolean have_sm4_1; 790 791 /** Have SM5 hardware? */ 792 boolean have_sm5; 793 794 /** To rebind resources at the beginnning of a new command buffer */ 795 boolean need_to_rebind_resources; 796 797 boolean have_generate_mipmap_cmd; 798 boolean have_set_predication_cmd; 799 boolean have_transfer_from_buffer_cmd; 800 boolean have_fence_fd; 801 boolean have_intra_surface_copy; 802 boolean have_constant_buffer_offset_cmd; 803 }; 804 805 806 struct svga_winsys_screen * 807 svga_winsys_screen(struct pipe_screen *screen); 808 809 struct svga_winsys_context * 810 svga_winsys_context(struct pipe_context *context); 811 812 struct pipe_resource * 813 svga_screen_buffer_wrap_surface(struct pipe_screen *screen, 814 enum SVGA3dSurfaceFormat format, 815 struct svga_winsys_surface *srf); 816 817 struct svga_winsys_surface * 818 svga_screen_buffer_get_winsys_surface(struct pipe_resource *buffer); 819 820 #endif /* SVGA_WINSYS_H_ */ 821