src/gallium/drivers/virgl/virgl_context.c

   1 /*
   2  * Copyright 2014, 2015 Red Hat.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * on the rights to use, copy, modify, merge, publish, distribute, sub
   8  * license, and/or sell copies of the Software, and to permit persons to whom
   9  * the Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  19  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  20  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  21  * USE OR OTHER DEALINGS IN THE SOFTWARE.
  22  */
  23
  24 #include <libsync.h>
  25 #include "pipe/p_shader_tokens.h"
  26
  27 #include "pipe/p_context.h"
  28 #include "pipe/p_defines.h"
  29 #include "pipe/p_screen.h"
  30 #include "pipe/p_state.h"
  31 #include "util/u_inlines.h"
  32 #include "util/u_memory.h"
  33 #include "util/u_format.h"
  34 #include "util/u_prim.h"
  35 #include "util/u_transfer.h"
  36 #include "util/u_helpers.h"
  37 #include "util/slab.h"
  38 #include "util/u_upload_mgr.h"
  39 #include "util/u_blitter.h"
  40 #include "tgsi/tgsi_text.h"
  41 #include "indices/u_primconvert.h"
  42
  43 #include "pipebuffer/pb_buffer.h"
  44
  45 #include "virgl_encode.h"
  46 #include "virgl_context.h"
  47 #include "virgl_protocol.h"
  48 #include "virgl_resource.h"
  49 #include "virgl_screen.h"
  50
  51 struct virgl_vertex_elements_state {
  52    uint32_t handle;
  53    uint8_t binding_map[PIPE_MAX_ATTRIBS];
  54    uint8_t num_bindings;
  55 };
  56
  57 static uint32_t next_handle;
  58 uint32_t virgl_object_assign_handle(void)
  59 {
  60    return ++next_handle;
  61 }
  62
  63 static void virgl_attach_res_framebuffer(struct virgl_context *vctx)
  64 {
  65    struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
  66    struct pipe_surface *surf;
  67    struct virgl_resource *res;
  68    unsigned i;
  69
  70    surf = vctx->framebuffer.zsbuf;
  71    if (surf) {
  72       res = virgl_resource(surf->texture);
  73       if (res) {
  74          vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
  75          virgl_resource_dirty(res, surf->u.tex.level);
  76       }
  77    }
  78    for (i = 0; i < vctx->framebuffer.nr_cbufs; i++) {
  79       surf = vctx->framebuffer.cbufs[i];
  80       if (surf) {
  81          res = virgl_resource(surf->texture);
  82          if (res) {
  83             vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
  84             virgl_resource_dirty(res, surf->u.tex.level);
  85          }
  86       }
  87    }
  88 }
  89
  90 static void virgl_attach_res_sampler_views(struct virgl_context *vctx,
  91                                            enum pipe_shader_type shader_type)
  92 {
  93    struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
  94    struct virgl_textures_info *tinfo = &vctx->samplers[shader_type];
  95    struct virgl_resource *res;
  96    uint32_t remaining_mask = tinfo->enabled_mask;
  97    unsigned i;
  98    while (remaining_mask) {
  99       i = u_bit_scan(&remaining_mask);
 100       assert(tinfo->views[i]);
 101
 102       res = virgl_resource(tinfo->views[i]->base.texture);
 103       if (res)
 104          vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
 105    }
 106 }
 107
 108 static void virgl_attach_res_vertex_buffers(struct virgl_context *vctx)
 109 {
 110    struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
 111    struct virgl_resource *res;
 112    unsigned i;
 113
 114    for (i = 0; i < vctx->num_vertex_buffers; i++) {
 115       res = virgl_resource(vctx->vertex_buffer[i].buffer.resource);
 116       if (res)
 117          vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
 118    }
 119 }
 120
 121 static void virgl_attach_res_index_buffer(struct virgl_context *vctx,
 122                                           struct virgl_indexbuf *ib)
 123 {
 124    struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
 125    struct virgl_resource *res;
 126
 127    res = virgl_resource(ib->buffer);
 128    if (res)
 129       vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
 130 }
 131
 132 static void virgl_attach_res_so_targets(struct virgl_context *vctx)
 133 {
 134    struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
 135    struct virgl_resource *res;
 136    unsigned i;
 137
 138    for (i = 0; i < vctx->num_so_targets; i++) {
 139       res = virgl_resource(vctx->so_targets[i].base.buffer);
 140       if (res)
 141          vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
 142    }
 143 }
 144
 145 static void virgl_attach_res_uniform_buffers(struct virgl_context *vctx,
 146                                              enum pipe_shader_type shader_type)
 147 {
 148    struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
 149    struct virgl_resource *res;
 150    unsigned i;
 151    for (i = 0; i < PIPE_MAX_CONSTANT_BUFFERS; i++) {
 152       res = virgl_resource(vctx->ubos[shader_type][i]);
 153       if (res) {
 154          vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
 155       }
 156    }
 157 }
 158
 159 static void virgl_attach_res_shader_buffers(struct virgl_context *vctx,
 160                                             enum pipe_shader_type shader_type)
 161 {
 162    struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
 163    struct virgl_resource *res;
 164    unsigned i;
 165    for (i = 0; i < PIPE_MAX_SHADER_BUFFERS; i++) {
 166       res = virgl_resource(vctx->ssbos[shader_type][i]);
 167       if (res) {
 168          vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
 169       }
 170    }
 171 }
 172
 173 static void virgl_attach_res_shader_images(struct virgl_context *vctx,
 174                                            enum pipe_shader_type shader_type)
 175 {
 176    struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
 177    struct virgl_resource *res;
 178    unsigned i;
 179    for (i = 0; i < PIPE_MAX_SHADER_IMAGES; i++) {
 180       res = virgl_resource(vctx->images[shader_type][i]);
 181       if (res) {
 182          vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
 183       }
 184    }
 185 }
 186
 187 static void virgl_attach_res_atomic_buffers(struct virgl_context *vctx)
 188 {
 189    struct virgl_winsys *vws = virgl_screen(vctx->base.screen)->vws;
 190    struct virgl_resource *res;
 191    unsigned i;
 192    for (i = 0; i < PIPE_MAX_HW_ATOMIC_BUFFERS; i++) {
 193       res = virgl_resource(vctx->atomic_buffers[i]);
 194       if (res) {
 195          vws->emit_res(vws, vctx->cbuf, res->hw_res, FALSE);
 196       }
 197    }
 198 }
 199
 200 /*
 201  * after flushing, the hw context still has a bunch of
 202  * resources bound, so we need to rebind those here.
 203  */
 204 static void virgl_reemit_res(struct virgl_context *vctx)
 205 {
 206    enum pipe_shader_type shader_type;
 207
 208    /* reattach any flushed resources */
 209    /* framebuffer, sampler views, vertex/index/uniform/stream buffers */
 210    virgl_attach_res_framebuffer(vctx);
 211
 212    for (shader_type = 0; shader_type < PIPE_SHADER_TYPES; shader_type++) {
 213       virgl_attach_res_sampler_views(vctx, shader_type);
 214       virgl_attach_res_uniform_buffers(vctx, shader_type);
 215       virgl_attach_res_shader_buffers(vctx, shader_type);
 216       virgl_attach_res_shader_images(vctx, shader_type);
 217    }
 218    virgl_attach_res_atomic_buffers(vctx);
 219    virgl_attach_res_vertex_buffers(vctx);
 220    virgl_attach_res_so_targets(vctx);
 221 }
 222
 223 static struct pipe_surface *virgl_create_surface(struct pipe_context *ctx,
 224                                                 struct pipe_resource *resource,
 225                                                 const struct pipe_surface *templ)
 226 {
 227    struct virgl_context *vctx = virgl_context(ctx);
 228    struct virgl_surface *surf;
 229    struct virgl_resource *res = virgl_resource(resource);
 230    uint32_t handle;
 231
 232    surf = CALLOC_STRUCT(virgl_surface);
 233    if (!surf)
 234       return NULL;
 235
 236    assert(ctx->screen->get_param(ctx->screen,
 237                                  PIPE_CAP_DEST_SURFACE_SRGB_CONTROL) ||
 238           (util_format_is_srgb(templ->format) ==
 239            util_format_is_srgb(resource->format)));
 240
 241    virgl_resource_dirty(res, 0);
 242    handle = virgl_object_assign_handle();
 243    pipe_reference_init(&surf->base.reference, 1);
 244    pipe_resource_reference(&surf->base.texture, resource);
 245    surf->base.context = ctx;
 246    surf->base.format = templ->format;
 247    if (resource->target != PIPE_BUFFER) {
 248       surf->base.width = u_minify(resource->width0, templ->u.tex.level);
 249       surf->base.height = u_minify(resource->height0, templ->u.tex.level);
 250       surf->base.u.tex.level = templ->u.tex.level;
 251       surf->base.u.tex.first_layer = templ->u.tex.first_layer;
 252       surf->base.u.tex.last_layer = templ->u.tex.last_layer;
 253    } else {
 254       surf->base.width = templ->u.buf.last_element - templ->u.buf.first_element + 1;
 255       surf->base.height = resource->height0;
 256       surf->base.u.buf.first_element = templ->u.buf.first_element;
 257       surf->base.u.buf.last_element = templ->u.buf.last_element;
 258    }
 259    virgl_encoder_create_surface(vctx, handle, res, &surf->base);
 260    surf->handle = handle;
 261    return &surf->base;
 262 }
 263
 264 static void virgl_surface_destroy(struct pipe_context *ctx,
 265                                  struct pipe_surface *psurf)
 266 {
 267    struct virgl_context *vctx = virgl_context(ctx);
 268    struct virgl_surface *surf = virgl_surface(psurf);
 269
 270    pipe_resource_reference(&surf->base.texture, NULL);
 271    virgl_encode_delete_object(vctx, surf->handle, VIRGL_OBJECT_SURFACE);
 272    FREE(surf);
 273 }
 274
 275 static void *virgl_create_blend_state(struct pipe_context *ctx,
 276                                               const struct pipe_blend_state *blend_state)
 277 {
 278    struct virgl_context *vctx = virgl_context(ctx);
 279    uint32_t handle;
 280    handle = virgl_object_assign_handle();
 281
 282    virgl_encode_blend_state(vctx, handle, blend_state);
 283    return (void *)(unsigned long)handle;
 284
 285 }
 286
 287 static void virgl_bind_blend_state(struct pipe_context *ctx,
 288                                            void *blend_state)
 289 {
 290    struct virgl_context *vctx = virgl_context(ctx);
 291    uint32_t handle = (unsigned long)blend_state;
 292    virgl_encode_bind_object(vctx, handle, VIRGL_OBJECT_BLEND);
 293 }
 294
 295 static void virgl_delete_blend_state(struct pipe_context *ctx,
 296                                      void *blend_state)
 297 {
 298    struct virgl_context *vctx = virgl_context(ctx);
 299    uint32_t handle = (unsigned long)blend_state;
 300    virgl_encode_delete_object(vctx, handle, VIRGL_OBJECT_BLEND);
 301 }
 302
 303 static void *virgl_create_depth_stencil_alpha_state(struct pipe_context *ctx,
 304                                                    const struct pipe_depth_stencil_alpha_state *blend_state)
 305 {
 306    struct virgl_context *vctx = virgl_context(ctx);
 307    uint32_t handle;
 308    handle = virgl_object_assign_handle();
 309
 310    virgl_encode_dsa_state(vctx, handle, blend_state);
 311    return (void *)(unsigned long)handle;
 312 }
 313
 314 static void virgl_bind_depth_stencil_alpha_state(struct pipe_context *ctx,
 315                                                 void *blend_state)
 316 {
 317    struct virgl_context *vctx = virgl_context(ctx);
 318    uint32_t handle = (unsigned long)blend_state;
 319    virgl_encode_bind_object(vctx, handle, VIRGL_OBJECT_DSA);
 320 }
 321
 322 static void virgl_delete_depth_stencil_alpha_state(struct pipe_context *ctx,
 323                                                   void *dsa_state)
 324 {
 325    struct virgl_context *vctx = virgl_context(ctx);
 326    uint32_t handle = (unsigned long)dsa_state;
 327    virgl_encode_delete_object(vctx, handle, VIRGL_OBJECT_DSA);
 328 }
 329
 330 static void *virgl_create_rasterizer_state(struct pipe_context *ctx,
 331                                                    const struct pipe_rasterizer_state *rs_state)
 332 {
 333    struct virgl_context *vctx = virgl_context(ctx);
 334    struct virgl_rasterizer_state *vrs = CALLOC_STRUCT(virgl_rasterizer_state);
 335
 336    if (!vrs)
 337       return NULL;
 338    vrs->rs = *rs_state;
 339    vrs->handle = virgl_object_assign_handle();
 340
 341    virgl_encode_rasterizer_state(vctx, vrs->handle, rs_state);
 342    return (void *)vrs;
 343 }
 344
 345 static void virgl_bind_rasterizer_state(struct pipe_context *ctx,
 346                                                 void *rs_state)
 347 {
 348    struct virgl_context *vctx = virgl_context(ctx);
 349    uint32_t handle = 0;
 350    if (rs_state) {
 351       struct virgl_rasterizer_state *vrs = rs_state;
 352       vctx->rs_state = *vrs;
 353       handle = vrs->handle;
 354    }
 355    virgl_encode_bind_object(vctx, handle, VIRGL_OBJECT_RASTERIZER);
 356 }
 357
 358 static void virgl_delete_rasterizer_state(struct pipe_context *ctx,
 359                                          void *rs_state)
 360 {
 361    struct virgl_context *vctx = virgl_context(ctx);
 362    struct virgl_rasterizer_state *vrs = rs_state;
 363    virgl_encode_delete_object(vctx, vrs->handle, VIRGL_OBJECT_RASTERIZER);
 364    FREE(vrs);
 365 }
 366
 367 static void virgl_set_framebuffer_state(struct pipe_context *ctx,
 368                                                 const struct pipe_framebuffer_state *state)
 369 {
 370    struct virgl_context *vctx = virgl_context(ctx);
 371
 372    vctx->framebuffer = *state;
 373    virgl_encoder_set_framebuffer_state(vctx, state);
 374    virgl_attach_res_framebuffer(vctx);
 375 }
 376
 377 static void virgl_set_viewport_states(struct pipe_context *ctx,
 378                                      unsigned start_slot,
 379                                      unsigned num_viewports,
 380                                      const struct pipe_viewport_state *state)
 381 {
 382    struct virgl_context *vctx = virgl_context(ctx);
 383    virgl_encoder_set_viewport_states(vctx, start_slot, num_viewports, state);
 384 }
 385
 386 static void *virgl_create_vertex_elements_state(struct pipe_context *ctx,
 387                                                         unsigned num_elements,
 388                                                         const struct pipe_vertex_element *elements)
 389 {
 390    struct pipe_vertex_element new_elements[PIPE_MAX_ATTRIBS];
 391    struct virgl_context *vctx = virgl_context(ctx);
 392    struct virgl_vertex_elements_state *state =
 393       CALLOC_STRUCT(virgl_vertex_elements_state);
 394
 395    for (int i = 0; i < num_elements; ++i) {
 396       if (elements[i].instance_divisor) {
 397          /* Virglrenderer doesn't deal with instance_divisor correctly if
 398           * there isn't a 1:1 relationship between elements and bindings.
 399           * So let's make sure there is, by duplicating bindings.
 400           */
 401          for (int j = 0; j < num_elements; ++j) {
 402             new_elements[j] = elements[j];
 403             new_elements[j].vertex_buffer_index = j;
 404             state->binding_map[j] = elements[j].vertex_buffer_index;
 405          }
 406          elements = new_elements;
 407          state->num_bindings = num_elements;
 408          break;
 409       }
 410    }
 411
 412    state->handle = virgl_object_assign_handle();
 413    virgl_encoder_create_vertex_elements(vctx, state->handle,
 414                                        num_elements, elements);
 415    return state;
 416 }
 417
 418 static void virgl_delete_vertex_elements_state(struct pipe_context *ctx,
 419                                               void *ve)
 420 {
 421    struct virgl_context *vctx = virgl_context(ctx);
 422    struct virgl_vertex_elements_state *state =
 423       (struct virgl_vertex_elements_state *)ve;
 424    virgl_encode_delete_object(vctx, state->handle, VIRGL_OBJECT_VERTEX_ELEMENTS);
 425    FREE(state);
 426 }
 427
 428 static void virgl_bind_vertex_elements_state(struct pipe_context *ctx,
 429                                                      void *ve)
 430 {
 431    struct virgl_context *vctx = virgl_context(ctx);
 432    struct virgl_vertex_elements_state *state =
 433       (struct virgl_vertex_elements_state *)ve;
 434    vctx->vertex_elements = state;
 435    virgl_encode_bind_object(vctx, state ? state->handle : 0,
 436                             VIRGL_OBJECT_VERTEX_ELEMENTS);
 437    vctx->vertex_array_dirty = TRUE;
 438 }
 439
 440 static void virgl_set_vertex_buffers(struct pipe_context *ctx,
 441                                     unsigned start_slot,
 442                                     unsigned num_buffers,
 443                                     const struct pipe_vertex_buffer *buffers)
 444 {
 445    struct virgl_context *vctx = virgl_context(ctx);
 446
 447    util_set_vertex_buffers_count(vctx->vertex_buffer,
 448                                  &vctx->num_vertex_buffers,
 449                                  buffers, start_slot, num_buffers);
 450
 451    vctx->vertex_array_dirty = TRUE;
 452 }
 453
 454 static void virgl_hw_set_vertex_buffers(struct virgl_context *vctx)
 455 {
 456    if (vctx->vertex_array_dirty) {
 457       struct virgl_vertex_elements_state *ve = vctx->vertex_elements;
 458
 459       if (ve->num_bindings) {
 460          struct pipe_vertex_buffer vertex_buffers[PIPE_MAX_ATTRIBS];
 461          for (int i = 0; i < ve->num_bindings; ++i)
 462             vertex_buffers[i] = vctx->vertex_buffer[ve->binding_map[i]];
 463
 464          virgl_encoder_set_vertex_buffers(vctx, ve->num_bindings, vertex_buffers);
 465       } else
 466          virgl_encoder_set_vertex_buffers(vctx, vctx->num_vertex_buffers, vctx->vertex_buffer);
 467
 468       virgl_attach_res_vertex_buffers(vctx);
 469    }
 470 }
 471
 472 static void virgl_set_stencil_ref(struct pipe_context *ctx,
 473                                  const struct pipe_stencil_ref *ref)
 474 {
 475    struct virgl_context *vctx = virgl_context(ctx);
 476    virgl_encoder_set_stencil_ref(vctx, ref);
 477 }
 478
 479 static void virgl_set_blend_color(struct pipe_context *ctx,
 480                                  const struct pipe_blend_color *color)
 481 {
 482    struct virgl_context *vctx = virgl_context(ctx);
 483    virgl_encoder_set_blend_color(vctx, color);
 484 }
 485
 486 static void virgl_hw_set_index_buffer(struct virgl_context *vctx,
 487                                      struct virgl_indexbuf *ib)
 488 {
 489    virgl_encoder_set_index_buffer(vctx, ib);
 490    virgl_attach_res_index_buffer(vctx, ib);
 491 }
 492
 493 static void virgl_set_constant_buffer(struct pipe_context *ctx,
 494                                      enum pipe_shader_type shader, uint index,
 495                                      const struct pipe_constant_buffer *buf)
 496 {
 497    struct virgl_context *vctx = virgl_context(ctx);
 498
 499    if (buf) {
 500       if (!buf->user_buffer){
 501          struct virgl_resource *res = virgl_resource(buf->buffer);
 502          virgl_encoder_set_uniform_buffer(vctx, shader, index, buf->buffer_offset,
 503                                           buf->buffer_size, res);
 504          pipe_resource_reference(&vctx->ubos[shader][index], buf->buffer);
 505          return;
 506       }
 507       pipe_resource_reference(&vctx->ubos[shader][index], NULL);
 508       virgl_encoder_write_constant_buffer(vctx, shader, index, buf->buffer_size / 4, buf->user_buffer);
 509    } else {
 510       virgl_encoder_write_constant_buffer(vctx, shader, index, 0, NULL);
 511       pipe_resource_reference(&vctx->ubos[shader][index], NULL);
 512    }
 513 }
 514
 515 void virgl_transfer_inline_write(struct pipe_context *ctx,
 516                                 struct pipe_resource *res,
 517                                 unsigned level,
 518                                 unsigned usage,
 519                                 const struct pipe_box *box,
 520                                 const void *data,
 521                                 unsigned stride,
 522                                 unsigned layer_stride)
 523 {
 524    struct virgl_context *vctx = virgl_context(ctx);
 525    struct virgl_resource *grres = virgl_resource(res);
 526    struct virgl_transfer trans = { 0 };
 527
 528    trans.base.resource = res;
 529    trans.base.level = level;
 530    trans.base.usage = usage;
 531    trans.base.box = *box;
 532    trans.base.stride = stride;
 533    trans.base.layer_stride = layer_stride;
 534    trans.offset = box->x;
 535
 536    virgl_resource_dirty(grres, 0);
 537
 538    if (virgl_res_needs_flush(vctx, &trans))
 539       ctx->flush(ctx, NULL, 0);
 540
 541    virgl_encoder_inline_write(vctx, grres, level, usage,
 542                               box, data, stride, layer_stride);
 543 }
 544
 545 static void *virgl_shader_encoder(struct pipe_context *ctx,
 546                                   const struct pipe_shader_state *shader,
 547                                   unsigned type)
 548 {
 549    struct virgl_context *vctx = virgl_context(ctx);
 550    uint32_t handle;
 551    struct tgsi_token *new_tokens;
 552    int ret;
 553
 554    new_tokens = virgl_tgsi_transform(vctx, shader->tokens);
 555    if (!new_tokens)
 556       return NULL;
 557
 558    handle = virgl_object_assign_handle();
 559    /* encode VS state */
 560    ret = virgl_encode_shader_state(vctx, handle, type,
 561                                    &shader->stream_output, 0,
 562                                    new_tokens);
 563    if (ret) {
 564       return NULL;
 565    }
 566
 567    FREE(new_tokens);
 568    return (void *)(unsigned long)handle;
 569
 570 }
 571 static void *virgl_create_vs_state(struct pipe_context *ctx,
 572                                    const struct pipe_shader_state *shader)
 573 {
 574    return virgl_shader_encoder(ctx, shader, PIPE_SHADER_VERTEX);
 575 }
 576
 577 static void *virgl_create_tcs_state(struct pipe_context *ctx,
 578                                    const struct pipe_shader_state *shader)
 579 {
 580    return virgl_shader_encoder(ctx, shader, PIPE_SHADER_TESS_CTRL);
 581 }
 582
 583 static void *virgl_create_tes_state(struct pipe_context *ctx,
 584                                    const struct pipe_shader_state *shader)
 585 {
 586    return virgl_shader_encoder(ctx, shader, PIPE_SHADER_TESS_EVAL);
 587 }
 588
 589 static void *virgl_create_gs_state(struct pipe_context *ctx,
 590                                    const struct pipe_shader_state *shader)
 591 {
 592    return virgl_shader_encoder(ctx, shader, PIPE_SHADER_GEOMETRY);
 593 }
 594
 595 static void *virgl_create_fs_state(struct pipe_context *ctx,
 596                                    const struct pipe_shader_state *shader)
 597 {
 598    return virgl_shader_encoder(ctx, shader, PIPE_SHADER_FRAGMENT);
 599 }
 600
 601 static void
 602 virgl_delete_fs_state(struct pipe_context *ctx,
 603                      void *fs)
 604 {
 605    uint32_t handle = (unsigned long)fs;
 606    struct virgl_context *vctx = virgl_context(ctx);
 607
 608    virgl_encode_delete_object(vctx, handle, VIRGL_OBJECT_SHADER);
 609 }
 610
 611 static void
 612 virgl_delete_gs_state(struct pipe_context *ctx,
 613                      void *gs)
 614 {
 615    uint32_t handle = (unsigned long)gs;
 616    struct virgl_context *vctx = virgl_context(ctx);
 617
 618    virgl_encode_delete_object(vctx, handle, VIRGL_OBJECT_SHADER);
 619 }
 620
 621 static void
 622 virgl_delete_vs_state(struct pipe_context *ctx,
 623                      void *vs)
 624 {
 625    uint32_t handle = (unsigned long)vs;
 626    struct virgl_context *vctx = virgl_context(ctx);
 627
 628    virgl_encode_delete_object(vctx, handle, VIRGL_OBJECT_SHADER);
 629 }
 630
 631 static void
 632 virgl_delete_tcs_state(struct pipe_context *ctx,
 633                        void *tcs)
 634 {
 635    uint32_t handle = (unsigned long)tcs;
 636    struct virgl_context *vctx = virgl_context(ctx);
 637
 638    virgl_encode_delete_object(vctx, handle, VIRGL_OBJECT_SHADER);
 639 }
 640
 641 static void
 642 virgl_delete_tes_state(struct pipe_context *ctx,
 643                       void *tes)
 644 {
 645    uint32_t handle = (unsigned long)tes;
 646    struct virgl_context *vctx = virgl_context(ctx);
 647
 648    virgl_encode_delete_object(vctx, handle, VIRGL_OBJECT_SHADER);
 649 }
 650
 651 static void virgl_bind_vs_state(struct pipe_context *ctx,
 652                                         void *vss)
 653 {
 654    uint32_t handle = (unsigned long)vss;
 655    struct virgl_context *vctx = virgl_context(ctx);
 656
 657    virgl_encode_bind_shader(vctx, handle, PIPE_SHADER_VERTEX);
 658 }
 659
 660 static void virgl_bind_tcs_state(struct pipe_context *ctx,
 661                                void *vss)
 662 {
 663    uint32_t handle = (unsigned long)vss;
 664    struct virgl_context *vctx = virgl_context(ctx);
 665
 666    virgl_encode_bind_shader(vctx, handle, PIPE_SHADER_TESS_CTRL);
 667 }
 668
 669 static void virgl_bind_tes_state(struct pipe_context *ctx,
 670                                void *vss)
 671 {
 672    uint32_t handle = (unsigned long)vss;
 673    struct virgl_context *vctx = virgl_context(ctx);
 674
 675    virgl_encode_bind_shader(vctx, handle, PIPE_SHADER_TESS_EVAL);
 676 }
 677
 678 static void virgl_bind_gs_state(struct pipe_context *ctx,
 679                                void *vss)
 680 {
 681    uint32_t handle = (unsigned long)vss;
 682    struct virgl_context *vctx = virgl_context(ctx);
 683
 684    virgl_encode_bind_shader(vctx, handle, PIPE_SHADER_GEOMETRY);
 685 }
 686
 687
 688 static void virgl_bind_fs_state(struct pipe_context *ctx,
 689                                         void *vss)
 690 {
 691    uint32_t handle = (unsigned long)vss;
 692    struct virgl_context *vctx = virgl_context(ctx);
 693
 694    virgl_encode_bind_shader(vctx, handle, PIPE_SHADER_FRAGMENT);
 695 }
 696
 697 static void virgl_clear(struct pipe_context *ctx,
 698                                 unsigned buffers,
 699                                 const union pipe_color_union *color,
 700                                 double depth, unsigned stencil)
 701 {
 702    struct virgl_context *vctx = virgl_context(ctx);
 703
 704    virgl_encode_clear(vctx, buffers, color, depth, stencil);
 705 }
 706
 707 static void virgl_draw_vbo(struct pipe_context *ctx,
 708                                    const struct pipe_draw_info *dinfo)
 709 {
 710    struct virgl_context *vctx = virgl_context(ctx);
 711    struct virgl_screen *rs = virgl_screen(ctx->screen);
 712    struct virgl_indexbuf ib = {};
 713    struct pipe_draw_info info = *dinfo;
 714
 715    if (!dinfo->count_from_stream_output && !dinfo->indirect &&
 716        !dinfo->primitive_restart &&
 717        !u_trim_pipe_prim(dinfo->mode, (unsigned*)&dinfo->count))
 718       return;
 719
 720    if (!(rs->caps.caps.v1.prim_mask & (1 << dinfo->mode))) {
 721       util_primconvert_save_rasterizer_state(vctx->primconvert, &vctx->rs_state.rs);
 722       util_primconvert_draw_vbo(vctx->primconvert, dinfo);
 723       return;
 724    }
 725    if (info.index_size) {
 726            pipe_resource_reference(&ib.buffer, info.has_user_indices ? NULL : info.index.resource);
 727            ib.user_buffer = info.has_user_indices ? info.index.user : NULL;
 728            ib.index_size = dinfo->index_size;
 729            ib.offset = info.start * ib.index_size;
 730
 731            if (ib.user_buffer) {
 732                    u_upload_data(vctx->uploader, 0, info.count * ib.index_size, 4,
 733                                  ib.user_buffer, &ib.offset, &ib.buffer);
 734                    ib.user_buffer = NULL;
 735            }
 736    }
 737
 738    vctx->num_draws++;
 739    virgl_hw_set_vertex_buffers(vctx);
 740    if (info.index_size)
 741       virgl_hw_set_index_buffer(vctx, &ib);
 742
 743    virgl_encoder_draw_vbo(vctx, &info);
 744
 745    pipe_resource_reference(&ib.buffer, NULL);
 746
 747 }
 748
 749 static void virgl_flush_eq(struct virgl_context *ctx, void *closure,
 750                            struct pipe_fence_handle **fence)
 751 {
 752    struct virgl_screen *rs = virgl_screen(ctx->base.screen);
 753    int out_fence_fd = -1;
 754
 755    if (ctx->num_draws)
 756       u_upload_unmap(ctx->uploader);
 757
 758    /* send the buffer to the remote side for decoding */
 759    ctx->num_transfers = ctx->num_draws = ctx->num_compute = 0;
 760
 761    virgl_transfer_queue_clear(&ctx->queue, ctx->cbuf);
 762    rs->vws->submit_cmd(rs->vws, ctx->cbuf, ctx->cbuf->in_fence_fd,
 763                        ctx->cbuf->needs_out_fence_fd ? &out_fence_fd : NULL);
 764
 765    if (fence)
 766       *fence = rs->vws->cs_create_fence(rs->vws, out_fence_fd);
 767
 768    /* Reserve some space for transfers. */
 769    if (ctx->encoded_transfers)
 770       ctx->cbuf->cdw = VIRGL_MAX_TBUF_DWORDS;
 771
 772    virgl_encoder_set_sub_ctx(ctx, ctx->hw_sub_ctx_id);
 773
 774    /* add back current framebuffer resources to reference list? */
 775    virgl_reemit_res(ctx);
 776 }
 777
 778 static void virgl_flush_from_st(struct pipe_context *ctx,
 779                                struct pipe_fence_handle **fence,
 780                                enum pipe_flush_flags flags)
 781 {
 782    struct virgl_context *vctx = virgl_context(ctx);
 783
 784    if (flags & PIPE_FLUSH_FENCE_FD)
 785        vctx->cbuf->needs_out_fence_fd = true;
 786
 787    virgl_flush_eq(vctx, vctx, fence);
 788
 789    if (vctx->cbuf->in_fence_fd != -1) {
 790       close(vctx->cbuf->in_fence_fd);
 791       vctx->cbuf->in_fence_fd = -1;
 792    }
 793    vctx->cbuf->needs_out_fence_fd = false;
 794 }
 795
 796 static struct pipe_sampler_view *virgl_create_sampler_view(struct pipe_context *ctx,
 797                                       struct pipe_resource *texture,
 798                                       const struct pipe_sampler_view *state)
 799 {
 800    struct virgl_context *vctx = virgl_context(ctx);
 801    struct virgl_sampler_view *grview;
 802    uint32_t handle;
 803    struct virgl_resource *res;
 804
 805    if (!state)
 806       return NULL;
 807
 808    grview = CALLOC_STRUCT(virgl_sampler_view);
 809    if (!grview)
 810       return NULL;
 811
 812    res = virgl_resource(texture);
 813    handle = virgl_object_assign_handle();
 814    virgl_encode_sampler_view(vctx, handle, res, state);
 815
 816    grview->base = *state;
 817    grview->base.reference.count = 1;
 818
 819    grview->base.texture = NULL;
 820    grview->base.context = ctx;
 821    pipe_resource_reference(&grview->base.texture, texture);
 822    grview->handle = handle;
 823    return &grview->base;
 824 }
 825
 826 static void virgl_set_sampler_views(struct pipe_context *ctx,
 827                                    enum pipe_shader_type shader_type,
 828                                    unsigned start_slot,
 829                                    unsigned num_views,
 830                                    struct pipe_sampler_view **views)
 831 {
 832    struct virgl_context *vctx = virgl_context(ctx);
 833    int i;
 834    uint32_t disable_mask = ~((1ull << num_views) - 1);
 835    struct virgl_textures_info *tinfo = &vctx->samplers[shader_type];
 836    uint32_t new_mask = 0;
 837    uint32_t remaining_mask;
 838
 839    remaining_mask = tinfo->enabled_mask & disable_mask;
 840
 841    while (remaining_mask) {
 842       i = u_bit_scan(&remaining_mask);
 843       assert(tinfo->views[i]);
 844
 845       pipe_sampler_view_reference((struct pipe_sampler_view **)&tinfo->views[i], NULL);
 846    }
 847
 848    for (i = 0; i < num_views; i++) {
 849       struct virgl_sampler_view *grview = virgl_sampler_view(views[i]);
 850
 851       if (views[i] == (struct pipe_sampler_view *)tinfo->views[i])
 852          continue;
 853
 854       if (grview) {
 855          new_mask |= 1 << i;
 856          pipe_sampler_view_reference((struct pipe_sampler_view **)&tinfo->views[i], views[i]);
 857       } else {
 858          pipe_sampler_view_reference((struct pipe_sampler_view **)&tinfo->views[i], NULL);
 859          disable_mask |= 1 << i;
 860       }
 861    }
 862
 863    tinfo->enabled_mask &= ~disable_mask;
 864    tinfo->enabled_mask |= new_mask;
 865    virgl_encode_set_sampler_views(vctx, shader_type, start_slot, num_views, tinfo->views);
 866    virgl_attach_res_sampler_views(vctx, shader_type);
 867 }
 868
 869 static void
 870 virgl_texture_barrier(struct pipe_context *ctx, unsigned flags)
 871 {
 872    struct virgl_context *vctx = virgl_context(ctx);
 873    struct virgl_screen *rs = virgl_screen(ctx->screen);
 874
 875    if (!(rs->caps.caps.v2.capability_bits & VIRGL_CAP_TEXTURE_BARRIER))
 876       return;
 877    virgl_encode_texture_barrier(vctx, flags);
 878 }
 879
 880 static void virgl_destroy_sampler_view(struct pipe_context *ctx,
 881                                  struct pipe_sampler_view *view)
 882 {
 883    struct virgl_context *vctx = virgl_context(ctx);
 884    struct virgl_sampler_view *grview = virgl_sampler_view(view);
 885
 886    virgl_encode_delete_object(vctx, grview->handle, VIRGL_OBJECT_SAMPLER_VIEW);
 887    pipe_resource_reference(&view->texture, NULL);
 888    FREE(view);
 889 }
 890
 891 static void *virgl_create_sampler_state(struct pipe_context *ctx,
 892                                         const struct pipe_sampler_state *state)
 893 {
 894    struct virgl_context *vctx = virgl_context(ctx);
 895    uint32_t handle;
 896
 897    handle = virgl_object_assign_handle();
 898
 899    virgl_encode_sampler_state(vctx, handle, state);
 900    return (void *)(unsigned long)handle;
 901 }
 902
 903 static void virgl_delete_sampler_state(struct pipe_context *ctx,
 904                                       void *ss)
 905 {
 906    struct virgl_context *vctx = virgl_context(ctx);
 907    uint32_t handle = (unsigned long)ss;
 908
 909    virgl_encode_delete_object(vctx, handle, VIRGL_OBJECT_SAMPLER_STATE);
 910 }
 911
 912 static void virgl_bind_sampler_states(struct pipe_context *ctx,
 913                                      enum pipe_shader_type shader,
 914                                      unsigned start_slot,
 915                                      unsigned num_samplers,
 916                                      void **samplers)
 917 {
 918    struct virgl_context *vctx = virgl_context(ctx);
 919    uint32_t handles[32];
 920    int i;
 921    for (i = 0; i < num_samplers; i++) {
 922       handles[i] = (unsigned long)(samplers[i]);
 923    }
 924    virgl_encode_bind_sampler_states(vctx, shader, start_slot, num_samplers, handles);
 925 }
 926
 927 static void virgl_set_polygon_stipple(struct pipe_context *ctx,
 928                                      const struct pipe_poly_stipple *ps)
 929 {
 930    struct virgl_context *vctx = virgl_context(ctx);
 931    virgl_encoder_set_polygon_stipple(vctx, ps);
 932 }
 933
 934 static void virgl_set_scissor_states(struct pipe_context *ctx,
 935                                     unsigned start_slot,
 936                                     unsigned num_scissor,
 937                                    const struct pipe_scissor_state *ss)
 938 {
 939    struct virgl_context *vctx = virgl_context(ctx);
 940    virgl_encoder_set_scissor_state(vctx, start_slot, num_scissor, ss);
 941 }
 942
 943 static void virgl_set_sample_mask(struct pipe_context *ctx,
 944                                  unsigned sample_mask)
 945 {
 946    struct virgl_context *vctx = virgl_context(ctx);
 947    virgl_encoder_set_sample_mask(vctx, sample_mask);
 948 }
 949
 950 static void virgl_set_min_samples(struct pipe_context *ctx,
 951                                  unsigned min_samples)
 952 {
 953    struct virgl_context *vctx = virgl_context(ctx);
 954    struct virgl_screen *rs = virgl_screen(ctx->screen);
 955
 956    if (!(rs->caps.caps.v2.capability_bits & VIRGL_CAP_SET_MIN_SAMPLES))
 957       return;
 958    virgl_encoder_set_min_samples(vctx, min_samples);
 959 }
 960
 961 static void virgl_set_clip_state(struct pipe_context *ctx,
 962                                 const struct pipe_clip_state *clip)
 963 {
 964    struct virgl_context *vctx = virgl_context(ctx);
 965    virgl_encoder_set_clip_state(vctx, clip);
 966 }
 967
 968 static void virgl_set_tess_state(struct pipe_context *ctx,
 969                                  const float default_outer_level[4],
 970                                  const float default_inner_level[2])
 971 {
 972    struct virgl_context *vctx = virgl_context(ctx);
 973    struct virgl_screen *rs = virgl_screen(ctx->screen);
 974
 975    if (!rs->caps.caps.v1.bset.has_tessellation_shaders)
 976       return;
 977    virgl_encode_set_tess_state(vctx, default_outer_level, default_inner_level);
 978 }
 979
 980 static void virgl_resource_copy_region(struct pipe_context *ctx,
 981                                       struct pipe_resource *dst,
 982                                       unsigned dst_level,
 983                                       unsigned dstx, unsigned dsty, unsigned dstz,
 984                                       struct pipe_resource *src,
 985                                       unsigned src_level,
 986                                       const struct pipe_box *src_box)
 987 {
 988    struct virgl_context *vctx = virgl_context(ctx);
 989    struct virgl_resource *dres = virgl_resource(dst);
 990    struct virgl_resource *sres = virgl_resource(src);
 991
 992    virgl_resource_dirty(dres, dst_level);
 993    virgl_encode_resource_copy_region(vctx, dres,
 994                                     dst_level, dstx, dsty, dstz,
 995                                     sres, src_level,
 996                                     src_box);
 997 }
 998
 999 static void
1000 virgl_flush_resource(struct pipe_context *pipe,
1001                     struct pipe_resource *resource)
1002 {
1003 }
1004
1005 static void virgl_blit(struct pipe_context *ctx,
1006                       const struct pipe_blit_info *blit)
1007 {
1008    struct virgl_context *vctx = virgl_context(ctx);
1009    struct virgl_resource *dres = virgl_resource(blit->dst.resource);
1010    struct virgl_resource *sres = virgl_resource(blit->src.resource);
1011
1012    assert(ctx->screen->get_param(ctx->screen,
1013                                  PIPE_CAP_DEST_SURFACE_SRGB_CONTROL) ||
1014           (util_format_is_srgb(blit->dst.resource->format) ==
1015             util_format_is_srgb(blit->dst.format)));
1016
1017    virgl_resource_dirty(dres, blit->dst.level);
1018    virgl_encode_blit(vctx, dres, sres,
1019                     blit);
1020 }
1021
1022 static void virgl_set_hw_atomic_buffers(struct pipe_context *ctx,
1023                                         unsigned start_slot,
1024                                         unsigned count,
1025                                         const struct pipe_shader_buffer *buffers)
1026 {
1027    struct virgl_context *vctx = virgl_context(ctx);
1028
1029    for (unsigned i = 0; i < count; i++) {
1030       unsigned idx = start_slot + i;
1031
1032       if (buffers) {
1033          if (buffers[i].buffer) {
1034             pipe_resource_reference(&vctx->atomic_buffers[idx],
1035                                     buffers[i].buffer);
1036             continue;
1037          }
1038       }
1039       pipe_resource_reference(&vctx->atomic_buffers[idx], NULL);
1040    }
1041    virgl_encode_set_hw_atomic_buffers(vctx, start_slot, count, buffers);
1042 }
1043
1044 static void virgl_set_shader_buffers(struct pipe_context *ctx,
1045                                      enum pipe_shader_type shader,
1046                                      unsigned start_slot, unsigned count,
1047                                      const struct pipe_shader_buffer *buffers,
1048                                      unsigned writable_bitmask)
1049 {
1050    struct virgl_context *vctx = virgl_context(ctx);
1051    struct virgl_screen *rs = virgl_screen(ctx->screen);
1052
1053    for (unsigned i = 0; i < count; i++) {
1054       unsigned idx = start_slot + i;
1055
1056       if (buffers) {
1057          if (buffers[i].buffer) {
1058             pipe_resource_reference(&vctx->ssbos[shader][idx], buffers[i].buffer);
1059             continue;
1060          }
1061       }
1062       pipe_resource_reference(&vctx->ssbos[shader][idx], NULL);
1063    }
1064
1065    uint32_t max_shader_buffer = (shader == PIPE_SHADER_FRAGMENT || shader == PIPE_SHADER_COMPUTE) ?
1066       rs->caps.caps.v2.max_shader_buffer_frag_compute :
1067       rs->caps.caps.v2.max_shader_buffer_other_stages;
1068    if (!max_shader_buffer)
1069       return;
1070    virgl_encode_set_shader_buffers(vctx, shader, start_slot, count, buffers);
1071 }
1072
1073 static void virgl_create_fence_fd(struct pipe_context *ctx,
1074                                   struct pipe_fence_handle **fence,
1075                                   int fd,
1076                                   enum pipe_fd_type type)
1077 {
1078    assert(type == PIPE_FD_TYPE_NATIVE_SYNC);
1079    struct virgl_screen *rs = virgl_screen(ctx->screen);
1080
1081    if (rs->vws->cs_create_fence)
1082       *fence = rs->vws->cs_create_fence(rs->vws, fd);
1083 }
1084
1085 static void virgl_fence_server_sync(struct pipe_context *ctx,
1086                                     struct pipe_fence_handle *fence)
1087 {
1088    struct virgl_context *vctx = virgl_context(ctx);
1089    struct virgl_screen *rs = virgl_screen(ctx->screen);
1090
1091    if (rs->vws->fence_server_sync)
1092       rs->vws->fence_server_sync(rs->vws, vctx->cbuf, fence);
1093 }
1094
1095 static void virgl_set_shader_images(struct pipe_context *ctx,
1096                                     enum pipe_shader_type shader,
1097                                     unsigned start_slot, unsigned count,
1098                                     const struct pipe_image_view *images)
1099 {
1100    struct virgl_context *vctx = virgl_context(ctx);
1101    struct virgl_screen *rs = virgl_screen(ctx->screen);
1102
1103    for (unsigned i = 0; i < count; i++) {
1104       unsigned idx = start_slot + i;
1105
1106       if (images) {
1107          if (images[i].resource) {
1108             pipe_resource_reference(&vctx->images[shader][idx], images[i].resource);
1109             continue;
1110          }
1111       }
1112       pipe_resource_reference(&vctx->images[shader][idx], NULL);
1113    }
1114
1115    uint32_t max_shader_images = (shader == PIPE_SHADER_FRAGMENT || shader == PIPE_SHADER_COMPUTE) ?
1116      rs->caps.caps.v2.max_shader_image_frag_compute :
1117      rs->caps.caps.v2.max_shader_image_other_stages;
1118    if (!max_shader_images)
1119       return;
1120    virgl_encode_set_shader_images(vctx, shader, start_slot, count, images);
1121 }
1122
1123 static void virgl_memory_barrier(struct pipe_context *ctx,
1124                                  unsigned flags)
1125 {
1126    struct virgl_context *vctx = virgl_context(ctx);
1127    struct virgl_screen *rs = virgl_screen(ctx->screen);
1128
1129    if (!(rs->caps.caps.v2.capability_bits & VIRGL_CAP_MEMORY_BARRIER))
1130       return;
1131    virgl_encode_memory_barrier(vctx, flags);
1132 }
1133
1134 static void *virgl_create_compute_state(struct pipe_context *ctx,
1135                                         const struct pipe_compute_state *state)
1136 {
1137    struct virgl_context *vctx = virgl_context(ctx);
1138    uint32_t handle;
1139    const struct tgsi_token *new_tokens = state->prog;
1140    struct pipe_stream_output_info so_info = {};
1141    int ret;
1142
1143    handle = virgl_object_assign_handle();
1144    ret = virgl_encode_shader_state(vctx, handle, PIPE_SHADER_COMPUTE,
1145                                    &so_info,
1146                                    state->req_local_mem,
1147                                    new_tokens);
1148    if (ret) {
1149       return NULL;
1150    }
1151
1152    return (void *)(unsigned long)handle;
1153 }
1154
1155 static void virgl_bind_compute_state(struct pipe_context *ctx, void *state)
1156 {
1157    uint32_t handle = (unsigned long)state;
1158    struct virgl_context *vctx = virgl_context(ctx);
1159
1160    virgl_encode_bind_shader(vctx, handle, PIPE_SHADER_COMPUTE);
1161 }
1162
1163 static void virgl_delete_compute_state(struct pipe_context *ctx, void *state)
1164 {
1165    uint32_t handle = (unsigned long)state;
1166    struct virgl_context *vctx = virgl_context(ctx);
1167
1168    virgl_encode_delete_object(vctx, handle, VIRGL_OBJECT_SHADER);
1169 }
1170
1171 static void virgl_launch_grid(struct pipe_context *ctx,
1172                               const struct pipe_grid_info *info)
1173 {
1174    struct virgl_context *vctx = virgl_context(ctx);
1175    virgl_encode_launch_grid(vctx, info);
1176    vctx->num_compute++;
1177 }
1178
1179 static void
1180 virgl_context_destroy( struct pipe_context *ctx )
1181 {
1182    struct virgl_context *vctx = virgl_context(ctx);
1183    struct virgl_screen *rs = virgl_screen(ctx->screen);
1184
1185    vctx->framebuffer.zsbuf = NULL;
1186    vctx->framebuffer.nr_cbufs = 0;
1187    virgl_encoder_destroy_sub_ctx(vctx, vctx->hw_sub_ctx_id);
1188    virgl_flush_eq(vctx, vctx, NULL);
1189
1190    rs->vws->cmd_buf_destroy(vctx->cbuf);
1191    if (vctx->uploader)
1192       u_upload_destroy(vctx->uploader);
1193    util_primconvert_destroy(vctx->primconvert);
1194    virgl_transfer_queue_fini(&vctx->queue);
1195
1196    slab_destroy_child(&vctx->transfer_pool);
1197    FREE(vctx);
1198 }
1199
1200 static void virgl_get_sample_position(struct pipe_context *ctx,
1201                                       unsigned sample_count,
1202                                       unsigned index,
1203                                       float *out_value)
1204 {
1205    struct virgl_context *vctx = virgl_context(ctx);
1206    struct virgl_screen *vs = virgl_screen(vctx->base.screen);
1207
1208    if (sample_count > vs->caps.caps.v1.max_samples) {
1209       debug_printf("VIRGL: requested %d MSAA samples, but only %d supported\n",
1210                    sample_count, vs->caps.caps.v1.max_samples);
1211       return;
1212    }
1213
1214    /* The following is basically copied from dri/i965gen6_get_sample_position
1215     * The only addition is that we hold the msaa positions for all sample
1216     * counts in a flat array. */
1217    uint32_t bits = 0;
1218    if (sample_count == 1) {
1219       out_value[0] = out_value[1] = 0.5f;
1220       return;
1221    } else if (sample_count == 2) {
1222       bits = vs->caps.caps.v2.sample_locations[0] >> (8 * index);
1223    } else if (sample_count <= 4) {
1224       bits = vs->caps.caps.v2.sample_locations[1] >> (8 * index);
1225    } else if (sample_count <= 8) {
1226       bits = vs->caps.caps.v2.sample_locations[2 + (index >> 2)] >> (8 * (index & 3));
1227    } else if (sample_count <= 16) {
1228       bits = vs->caps.caps.v2.sample_locations[4 + (index >> 2)] >> (8 * (index & 3));
1229    }
1230    out_value[0] = ((bits >> 4) & 0xf) / 16.0f;
1231    out_value[1] = (bits & 0xf) / 16.0f;
1232
1233    if (virgl_debug & VIRGL_DEBUG_VERBOSE)
1234       debug_printf("VIRGL: sample postion [%2d/%2d] = (%f, %f)\n",
1235                    index, sample_count, out_value[0], out_value[1]);
1236 }
1237
1238 struct pipe_context *virgl_context_create(struct pipe_screen *pscreen,
1239                                           void *priv,
1240                                           unsigned flags)
1241 {
1242    struct virgl_context *vctx;
1243    struct virgl_screen *rs = virgl_screen(pscreen);
1244    vctx = CALLOC_STRUCT(virgl_context);
1245    const char *host_debug_flagstring;
1246
1247    vctx->cbuf = rs->vws->cmd_buf_create(rs->vws, VIRGL_MAX_CMDBUF_DWORDS);
1248    if (!vctx->cbuf) {
1249       FREE(vctx);
1250       return NULL;
1251    }
1252
1253    vctx->base.destroy = virgl_context_destroy;
1254    vctx->base.create_surface = virgl_create_surface;
1255    vctx->base.surface_destroy = virgl_surface_destroy;
1256    vctx->base.set_framebuffer_state = virgl_set_framebuffer_state;
1257    vctx->base.create_blend_state = virgl_create_blend_state;
1258    vctx->base.bind_blend_state = virgl_bind_blend_state;
1259    vctx->base.delete_blend_state = virgl_delete_blend_state;
1260    vctx->base.create_depth_stencil_alpha_state = virgl_create_depth_stencil_alpha_state;
1261    vctx->base.bind_depth_stencil_alpha_state = virgl_bind_depth_stencil_alpha_state;
1262    vctx->base.delete_depth_stencil_alpha_state = virgl_delete_depth_stencil_alpha_state;
1263    vctx->base.create_rasterizer_state = virgl_create_rasterizer_state;
1264    vctx->base.bind_rasterizer_state = virgl_bind_rasterizer_state;
1265    vctx->base.delete_rasterizer_state = virgl_delete_rasterizer_state;
1266
1267    vctx->base.set_viewport_states = virgl_set_viewport_states;
1268    vctx->base.create_vertex_elements_state = virgl_create_vertex_elements_state;
1269    vctx->base.bind_vertex_elements_state = virgl_bind_vertex_elements_state;
1270    vctx->base.delete_vertex_elements_state = virgl_delete_vertex_elements_state;
1271    vctx->base.set_vertex_buffers = virgl_set_vertex_buffers;
1272    vctx->base.set_constant_buffer = virgl_set_constant_buffer;
1273
1274    vctx->base.set_tess_state = virgl_set_tess_state;
1275    vctx->base.create_vs_state = virgl_create_vs_state;
1276    vctx->base.create_tcs_state = virgl_create_tcs_state;
1277    vctx->base.create_tes_state = virgl_create_tes_state;
1278    vctx->base.create_gs_state = virgl_create_gs_state;
1279    vctx->base.create_fs_state = virgl_create_fs_state;
1280
1281    vctx->base.bind_vs_state = virgl_bind_vs_state;
1282    vctx->base.bind_tcs_state = virgl_bind_tcs_state;
1283    vctx->base.bind_tes_state = virgl_bind_tes_state;
1284    vctx->base.bind_gs_state = virgl_bind_gs_state;
1285    vctx->base.bind_fs_state = virgl_bind_fs_state;
1286
1287    vctx->base.delete_vs_state = virgl_delete_vs_state;
1288    vctx->base.delete_tcs_state = virgl_delete_tcs_state;
1289    vctx->base.delete_tes_state = virgl_delete_tes_state;
1290    vctx->base.delete_gs_state = virgl_delete_gs_state;
1291    vctx->base.delete_fs_state = virgl_delete_fs_state;
1292
1293    vctx->base.create_compute_state = virgl_create_compute_state;
1294    vctx->base.bind_compute_state = virgl_bind_compute_state;
1295    vctx->base.delete_compute_state = virgl_delete_compute_state;
1296    vctx->base.launch_grid = virgl_launch_grid;
1297
1298    vctx->base.clear = virgl_clear;
1299    vctx->base.draw_vbo = virgl_draw_vbo;
1300    vctx->base.flush = virgl_flush_from_st;
1301    vctx->base.screen = pscreen;
1302    vctx->base.create_sampler_view = virgl_create_sampler_view;
1303    vctx->base.sampler_view_destroy = virgl_destroy_sampler_view;
1304    vctx->base.set_sampler_views = virgl_set_sampler_views;
1305    vctx->base.texture_barrier = virgl_texture_barrier;
1306
1307    vctx->base.create_sampler_state = virgl_create_sampler_state;
1308    vctx->base.delete_sampler_state = virgl_delete_sampler_state;
1309    vctx->base.bind_sampler_states = virgl_bind_sampler_states;
1310
1311    vctx->base.set_polygon_stipple = virgl_set_polygon_stipple;
1312    vctx->base.set_scissor_states = virgl_set_scissor_states;
1313    vctx->base.set_sample_mask = virgl_set_sample_mask;
1314    vctx->base.set_min_samples = virgl_set_min_samples;
1315    vctx->base.set_stencil_ref = virgl_set_stencil_ref;
1316    vctx->base.set_clip_state = virgl_set_clip_state;
1317
1318    vctx->base.set_blend_color = virgl_set_blend_color;
1319
1320    vctx->base.get_sample_position = virgl_get_sample_position;
1321
1322    vctx->base.resource_copy_region = virgl_resource_copy_region;
1323    vctx->base.flush_resource = virgl_flush_resource;
1324    vctx->base.blit =  virgl_blit;
1325    vctx->base.create_fence_fd = virgl_create_fence_fd;
1326    vctx->base.fence_server_sync = virgl_fence_server_sync;
1327
1328    vctx->base.set_shader_buffers = virgl_set_shader_buffers;
1329    vctx->base.set_hw_atomic_buffers = virgl_set_hw_atomic_buffers;
1330    vctx->base.set_shader_images = virgl_set_shader_images;
1331    vctx->base.memory_barrier = virgl_memory_barrier;
1332
1333    virgl_init_context_resource_functions(&vctx->base);
1334    virgl_init_query_functions(vctx);
1335    virgl_init_so_functions(vctx);
1336
1337    slab_create_child(&vctx->transfer_pool, &rs->transfer_pool);
1338    virgl_transfer_queue_init(&vctx->queue, rs, &vctx->transfer_pool);
1339    vctx->encoded_transfers = (rs->vws->supports_encoded_transfers &&
1340                        (rs->caps.caps.v2.capability_bits & VIRGL_CAP_TRANSFER));
1341
1342    /* Reserve some space for transfers. */
1343    if (vctx->encoded_transfers)
1344       vctx->cbuf->cdw = VIRGL_MAX_TBUF_DWORDS;
1345
1346    vctx->primconvert = util_primconvert_create(&vctx->base, rs->caps.caps.v1.prim_mask);
1347    vctx->uploader = u_upload_create(&vctx->base, 1024 * 1024,
1348                                      PIPE_BIND_INDEX_BUFFER, PIPE_USAGE_STREAM, 0);
1349    if (!vctx->uploader)
1350            goto fail;
1351    vctx->base.stream_uploader = vctx->uploader;
1352    vctx->base.const_uploader = vctx->uploader;
1353
1354    vctx->hw_sub_ctx_id = rs->sub_ctx_id++;
1355    virgl_encoder_create_sub_ctx(vctx, vctx->hw_sub_ctx_id);
1356
1357    virgl_encoder_set_sub_ctx(vctx, vctx->hw_sub_ctx_id);
1358
1359    if (rs->caps.caps.v2.capability_bits & VIRGL_CAP_GUEST_MAY_INIT_LOG) {
1360       host_debug_flagstring = getenv("VIRGL_HOST_DEBUG");
1361       if (host_debug_flagstring)
1362          virgl_encode_host_debug_flagstring(vctx, host_debug_flagstring);
1363    }
1364
1365    return &vctx->base;
1366 fail:
1367    return NULL;
1368 }