src/gallium/drivers/zink/zink_fence.c

@@ -117,8 +117,8 @@ tc_fence_finish(struct zink_context *ctx, struct zink_tc_fence *mfence, uint64_t
    return true;
 }
 
-bool
-zink_vkfence_wait(struct zink_screen *screen, struct zink_fence *fence, uint64_t timeout_ns)
+static bool
+fence_wait(struct zink_screen *screen, struct zink_fence *fence, uint64_t timeout_ns)
 {
    if (screen->device_lost)
       return true;
@@ -128,14 +128,7 @@ zink_vkfence_wait(struct zink_screen *screen, struct zink_fence *fence, uint64_t
    assert(fence->batch_id);
    assert(fence->submitted);
 
-   bool success = false;
-
-   VkResult ret;
-   if (timeout_ns)
-      ret = VKSCR(WaitForFences)(screen->dev, 1, &fence->fence, VK_TRUE, timeout_ns);
-   else
-      ret = VKSCR(GetFenceStatus)(screen->dev, fence->fence);
-   success = zink_screen_handle_vkresult(screen, ret);
+   bool success = zink_screen_timeline_wait(screen, fence->batch_id, timeout_ns);
 
    if (success) {
       p_atomic_set(&fence->completed, true);
@@ -186,7 +179,7 @@ zink_fence_finish(struct zink_screen *screen, struct pipe_context *pctx, struct
    if (fence->submitted && zink_screen_check_last_finished(screen, fence->batch_id))
       return true;
 
-   return zink_vkfence_wait(screen, fence, timeout_ns);
+   return fence_wait(screen, fence, timeout_ns);
 }
 
 static bool

src/gallium/drivers/zink/zink_fence.h

@@ -50,7 +50,6 @@ struct zink_tc_fence {
 };
 
 struct zink_fence {
-   VkFence fence;
    uint32_t batch_id;
    bool submitted;
    bool completed;
@@ -89,9 +88,6 @@ zink_fence_server_sync(struct pipe_context *pctx, struct pipe_fence_handle *pfen
 void
 zink_screen_fence_init(struct pipe_screen *pscreen);
 
-bool
-zink_vkfence_wait(struct zink_screen *screen, struct zink_fence *fence, uint64_t timeout_ns);
-
 void
 zink_fence_clear_resources(struct zink_screen *screen, struct zink_fence *fence);
 #endif

src/gallium/drivers/zink/zink_framebuffer.c

@@ -49,7 +49,7 @@ zink_destroy_framebuffer(struct zink_screen *screen,
 }
 
 void
-zink_init_framebuffer_imageless(struct zink_screen *screen, struct zink_framebuffer *fb, struct zink_render_pass *rp)
+zink_init_framebuffer(struct zink_screen *screen, struct zink_framebuffer *fb, struct zink_render_pass *rp)
 {
    VkFramebuffer ret;
 
@@ -144,7 +144,7 @@ zink_use_dummy_attachments(const struct zink_context *ctx)
 }
 
 struct zink_framebuffer *
-zink_get_framebuffer_imageless(struct zink_context *ctx)
+zink_get_framebuffer(struct zink_context *ctx)
 {
    assert(zink_screen(ctx->base.screen)->info.have_KHR_imageless_framebuffer);
 
@@ -202,179 +202,8 @@ zink_get_framebuffer_imageless(struct zink_context *ctx)
    return fb;
 }
 
-void
-zink_init_framebuffer(struct zink_screen *screen, struct zink_framebuffer *fb, struct zink_render_pass *rp)
-{
-   VkFramebuffer ret;
-
-   if (fb->rp == rp)
-      return;
-
-   uint32_t hash = _mesa_hash_pointer(rp);
-
-   struct hash_entry *he = _mesa_hash_table_search_pre_hashed(&fb->objects, hash, rp);
-   if (he) {
-#if defined(_WIN64) || defined(__x86_64__)
-      ret = (VkFramebuffer)he->data;
-#else
-      VkFramebuffer *ptr = he->data;
-      ret = *ptr;
-#endif
-      goto out;
-   }
-
-   assert(rp->state.num_cbufs + rp->state.have_zsbuf + rp->state.num_cresolves + rp->state.num_zsresolves == fb->state.num_attachments);
-
-   VkFramebufferCreateInfo fci = {0};
-   fci.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
-   fci.renderPass = rp->render_pass;
-   fci.attachmentCount = fb->state.num_attachments;
-   fci.pAttachments = fb->state.attachments;
-   fci.width = fb->state.width;
-   fci.height = fb->state.height;
-   fci.layers = fb->state.layers + 1;
-
-   if (VKSCR(CreateFramebuffer)(screen->dev, &fci, NULL, &ret) != VK_SUCCESS)
-      return;
-#if defined(_WIN64) || defined(__x86_64__)
-   _mesa_hash_table_insert_pre_hashed(&fb->objects, hash, rp, ret);
-#else
-   VkFramebuffer *ptr = ralloc(fb, VkFramebuffer);
-   if (!ptr) {
-      VKSCR(DestroyFramebuffer)(screen->dev, ret, NULL);
-      return;
-   }
-   *ptr = ret;
-   _mesa_hash_table_insert_pre_hashed(&fb->objects, hash, rp, ptr);
-#endif
-out:
-   fb->rp = rp;
-   fb->fb = ret;
-}
-
-static struct zink_framebuffer *
-create_framebuffer(struct zink_context *ctx,
-                   struct zink_framebuffer_state *state,
-                   struct pipe_surface **attachments)
-{
-   struct zink_screen *screen = zink_screen(ctx->base.screen);
-   struct zink_framebuffer *fb = rzalloc(NULL, struct zink_framebuffer);
-   if (!fb)
-      return NULL;
-
-   unsigned num_attachments = 0;
-   for (int i = 0; i < state->num_attachments; i++) {
-      struct zink_surface *surf;
-      if (state->attachments[i]) {
-         surf = zink_csurface(attachments[i]);
-         /* no ref! */
-         fb->surfaces[i] = attachments[i];
-         num_attachments++;
-         util_dynarray_append(&surf->framebuffer_refs, struct zink_framebuffer*, fb);
-      } else {
-         surf = zink_csurface(ctx->dummy_surface[util_logbase2_ceil(state->samples+1)]);
-         state->attachments[i] = surf->image_view;
-      }
-   }
-   pipe_reference_init(&fb->reference, 1 + num_attachments);
-
-   if (!_mesa_hash_table_init(&fb->objects, fb, _mesa_hash_pointer, _mesa_key_pointer_equal))
-      goto fail;
-   memcpy(&fb->state, state, sizeof(struct zink_framebuffer_state));
-
-   return fb;
-fail:
-   zink_destroy_framebuffer(screen, fb);
-   return NULL;
-}
-
 void
 debug_describe_zink_framebuffer(char* buf, const struct zink_framebuffer *ptr)
 {
    sprintf(buf, "zink_framebuffer");
 }
-
-struct zink_framebuffer *
-zink_get_framebuffer(struct zink_context *ctx)
-{
-   struct zink_screen *screen = zink_screen(ctx->base.screen);
-
-   assert(!screen->info.have_KHR_imageless_framebuffer);
-
-   struct pipe_surface *attachments[2 * (PIPE_MAX_COLOR_BUFS + 1)] = {0};
-   const unsigned cresolve_offset = ctx->fb_state.nr_cbufs + !!ctx->fb_state.zsbuf;
-   unsigned num_resolves = 0;
-
-   struct zink_framebuffer_state state = {0};
-   if (!zink_use_dummy_attachments(ctx)) {
-      for (int i = 0; i < ctx->fb_state.nr_cbufs; i++) {
-         struct pipe_surface *psurf = ctx->fb_state.cbufs[i];
-         if (psurf) {
-            struct zink_surface *surf = zink_csurface(psurf);
-            struct zink_surface *transient = zink_transient_surface(psurf);
-            if (transient) {
-               state.attachments[i] = transient->image_view;
-               state.attachments[cresolve_offset + i] = surf->image_view;
-               attachments[cresolve_offset + i] = psurf;
-               psurf = &transient->base;
-               num_resolves++;
-            } else {
-               state.attachments[i] = surf->image_view;
-            }
-         } else {
-            state.attachments[i] = VK_NULL_HANDLE;
-         }
-         attachments[i] = psurf;
-      }
-   }
-
-   state.num_attachments = ctx->fb_state.nr_cbufs;
-   const unsigned zsresolve_offset = cresolve_offset + num_resolves;
-   if (ctx->fb_state.zsbuf) {
-      struct pipe_surface *psurf = ctx->fb_state.zsbuf;
-      if (psurf) {
-         struct zink_surface *surf = zink_csurface(psurf);
-         struct zink_surface *transient = zink_transient_surface(psurf);
-         if (transient) {
-            state.attachments[state.num_attachments] = transient->image_view;
-            state.attachments[zsresolve_offset] = surf->image_view;
-            attachments[zsresolve_offset] = psurf;
-            psurf = &transient->base;
-            num_resolves++;
-         } else {
-            state.attachments[state.num_attachments] = surf->image_view;
-         }
-      } else {
-         state.attachments[state.num_attachments] = VK_NULL_HANDLE;
-      }
-      attachments[state.num_attachments++] = psurf;
-   }
-
-   /* avoid bitfield explosion */
-   assert(state.num_attachments + num_resolves < 16);
-   state.num_attachments += num_resolves;
-   state.width = MAX2(ctx->fb_state.width, 1);
-   state.height = MAX2(ctx->fb_state.height, 1);
-   state.layers = MAX2(util_framebuffer_get_num_layers(&ctx->fb_state), 1) - 1;
-   state.samples = ctx->fb_state.samples - 1;
-
-   struct zink_framebuffer *fb;
-   simple_mtx_lock(&screen->framebuffer_mtx);
-   struct hash_entry *entry = _mesa_hash_table_search(&screen->framebuffer_cache, &state);
-   if (entry) {
-      fb = (void*)entry->data;
-      struct zink_framebuffer *fb_ref = NULL;
-      /* this gains 1 ref every time we reuse it */
-      zink_framebuffer_reference(screen, &fb_ref, fb);
-   } else {
-      /* this adds 1 extra ref on creation because all newly-created framebuffers are
-       * going to be bound; necessary to handle framebuffers which have no "real" attachments
-       * and are only using null surfaces since the only ref they get is the extra one here
-       */
-      fb = create_framebuffer(ctx, &state, attachments);
-      _mesa_hash_table_insert(&screen->framebuffer_cache, &fb->state, fb);
-   }
-   simple_mtx_unlock(&screen->framebuffer_mtx);
-
-   return fb;
-}

src/gallium/drivers/zink/zink_framebuffer.h

@@ -40,10 +40,7 @@ struct zink_framebuffer_state {
    uint32_t layers:6;
    uint32_t samples:6;
    uint32_t num_attachments:4;
-   union {
-      VkImageView attachments[PIPE_MAX_COLOR_BUFS + 1];
-      struct zink_surface_info infos[PIPE_MAX_COLOR_BUFS + 1];
-   };
+   struct zink_surface_info infos[PIPE_MAX_COLOR_BUFS + 1];
 };
 
 struct zink_framebuffer {
@@ -54,17 +51,12 @@ struct zink_framebuffer {
    struct zink_render_pass *rp;
 
    struct zink_framebuffer_state state;
-   union {
-      struct pipe_surface *surfaces[PIPE_MAX_COLOR_BUFS + 1];
-      VkFramebufferAttachmentImageInfo infos[PIPE_MAX_COLOR_BUFS + 1];
-   };
+   VkFramebufferAttachmentImageInfo infos[PIPE_MAX_COLOR_BUFS + 1];
    struct hash_table objects;
 };
 
 void
 zink_init_framebuffer(struct zink_screen *screen, struct zink_framebuffer *fb, struct zink_render_pass *rp);
-void
-zink_init_framebuffer_imageless(struct zink_screen *screen, struct zink_framebuffer *fb, struct zink_render_pass *rp);
 
 void
 zink_destroy_framebuffer(struct zink_screen *screen,
@@ -90,9 +82,6 @@ zink_framebuffer_reference(struct zink_screen *screen,
    return ret;
 }
 
-struct zink_framebuffer *
-zink_get_framebuffer_imageless(struct zink_context *ctx);
-
 struct zink_framebuffer *
 zink_get_framebuffer(struct zink_context *ctx);
 #endif

src/gallium/drivers/zink/zink_pipeline.c

@@ -86,12 +86,17 @@ zink_create_gfx_pipeline(struct zink_screen *screen,
       switch (primitive_topology) {
       case VK_PRIMITIVE_TOPOLOGY_POINT_LIST:
       case VK_PRIMITIVE_TOPOLOGY_LINE_LIST:
-      case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
       case VK_PRIMITIVE_TOPOLOGY_LINE_LIST_WITH_ADJACENCY:
+      case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST:
       case VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST_WITH_ADJACENCY:
+         if (screen->info.have_EXT_primitive_topology_list_restart) {
+            primitive_state.primitiveRestartEnable = state->dyn_state2.primitive_restart ? VK_TRUE : VK_FALSE;
+            break;
+         }
+         FALLTHROUGH;
       case VK_PRIMITIVE_TOPOLOGY_PATCH_LIST:
          if (state->dyn_state2.primitive_restart)
-            debug_printf("restart_index set with unsupported primitive topology %u\n", primitive_topology);
+            mesa_loge("zink: restart_index set with unsupported primitive topology %u\n", primitive_topology);
          primitive_state.primitiveRestartEnable = VK_FALSE;
          break;
       default:

src/gallium/drivers/zink/zink_query.c

@@ -73,7 +73,7 @@ struct zink_query {
    struct list_head stats_list; /* when active, statistics queries are added to ctx->primitives_generated_queries */
    bool has_draws; /* have_gs and have_xfb are valid for idx=curr_query */
 
-   struct zink_batch_usage *batch_id; //batch that the query was started in
+   struct zink_batch_usage *batch_uses; //batch that the query was started in
 
    struct list_head buffers;
    union {
@@ -353,7 +353,7 @@ fail:
 static void
 destroy_query(struct zink_screen *screen, struct zink_query *query)
 {
-   assert(zink_screen_usage_check_completion(screen, query->batch_id));
+   assert(zink_screen_usage_check_completion(screen, query->batch_uses));
    struct zink_query_buffer *qbo, *next;
 
    util_dynarray_foreach(&query->starts, struct zink_query_start, start) {
@@ -496,7 +496,7 @@ zink_destroy_query(struct pipe_context *pctx,
    /* only destroy if this query isn't active on any batches,
     * otherwise just mark dead and wait
     */
-   if (query->batch_id) {
+   if (query->batch_uses) {
       p_atomic_set(&query->dead, true);
       return;
    }
@@ -507,9 +507,9 @@ zink_destroy_query(struct pipe_context *pctx,
 void
 zink_prune_query(struct zink_screen *screen, struct zink_batch_state *bs, struct zink_query *query)
 {
-   if (!zink_batch_usage_matches(query->batch_id, bs))
+   if (!zink_batch_usage_matches(query->batch_uses, bs))
       return;
-   query->batch_id = NULL;
+   query->batch_uses = NULL;
    if (p_atomic_read(&query->dead))
       destroy_query(screen, query);
 }
@@ -795,7 +795,7 @@ begin_query(struct zink_context *ctx, struct zink_batch *batch, struct zink_quer
    if (q->type == PIPE_QUERY_TIME_ELAPSED) {
       VKCTX(CmdWriteTimestamp)(batch->state->cmdbuf, VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, start->vkq[0]->pool->query_pool, start->vkq[0]->query_id);
       update_qbo(ctx, q);
-      zink_batch_usage_set(&q->batch_id, batch->state);
+      zink_batch_usage_set(&q->batch_uses, batch->state);
       _mesa_set_add(batch->state->active_queries, q);
    }
    /* ignore the rest of begin_query for timestamps */
@@ -828,7 +828,7 @@ begin_query(struct zink_context *ctx, struct zink_batch *batch, struct zink_quer
    }
    if (needs_stats_list(q))
       list_addtail(&q->stats_list, &ctx->primitives_generated_queries);
-   zink_batch_usage_set(&q->batch_id, batch->state);
+   zink_batch_usage_set(&q->batch_uses, batch->state);
    _mesa_set_add(batch->state->active_queries, q);
    if (q->type == PIPE_QUERY_PRIMITIVES_GENERATED) {
       ctx->primitives_generated_active = true;
@@ -940,7 +940,7 @@ zink_end_query(struct pipe_context *pctx,
       struct zink_query_start *start = util_dynarray_top_ptr(&query->starts, struct zink_query_start);
       VKCTX(CmdWriteTimestamp)(batch->state->cmdbuf, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
                                start->vkq[0]->pool->query_pool, start->vkq[0]->query_id);
-      zink_batch_usage_set(&query->batch_id, batch->state);
+      zink_batch_usage_set(&query->batch_uses, batch->state);
       _mesa_set_add(batch->state->active_queries, query);
       check_update(ctx, query);
    } else if (query->active)
@@ -969,15 +969,12 @@ zink_get_query_result(struct pipe_context *pctx,
    if (query->needs_update)
       update_qbo(ctx, query);
 
-   if (zink_batch_usage_is_unflushed(query->batch_id)) {
+   if (zink_batch_usage_is_unflushed(query->batch_uses)) {
       if (!threaded_query(q)->flushed)
          pctx->flush(pctx, NULL, 0);
       if (!wait)
          return false;
-   } else if (!threaded_query(q)->flushed &&
-              /* timeline drivers can wait during buffer map */
-              !zink_screen(pctx->screen)->info.have_KHR_timeline_semaphore)
-      zink_batch_usage_check_completion(ctx, query->batch_id);
+   }
 
    return get_query_result(pctx, q, wait, result);
 }
@@ -1213,7 +1210,7 @@ zink_get_query_result_resource(struct pipe_context *pctx,
 
       VkQueryResultFlags flag = is_time_query(query) ? 0 : VK_QUERY_RESULT_PARTIAL_BIT;
       unsigned src_offset = result_size * get_num_results(query->type);
-      if (zink_batch_usage_check_completion(ctx, query->batch_id)) {
+      if (zink_batch_usage_check_completion(ctx, query->batch_uses)) {
          uint64_t u64[4] = {0};
          if (VKCTX(GetQueryPoolResults)(screen->dev, start->vkq[0]->pool->query_pool, query_id, 1, sizeof(u64), u64,
                                    0, size_flags | VK_QUERY_RESULT_WITH_AVAILABILITY_BIT | flag) == VK_SUCCESS) {

src/gallium/drivers/zink/zink_render_pass.c

@@ -28,123 +28,6 @@
 #include "util/u_memory.h"
 #include "util/u_string.h"
 
-static VkRenderPass
-create_render_pass(struct zink_screen *screen, struct zink_render_pass_state *state, struct zink_render_pass_pipeline_state *pstate)
-{
-
-   VkAttachmentReference color_refs[PIPE_MAX_COLOR_BUFS], zs_ref;
-   VkAttachmentReference input_attachments[PIPE_MAX_COLOR_BUFS];
-   VkAttachmentDescription attachments[PIPE_MAX_COLOR_BUFS + 1];
-   VkPipelineStageFlags dep_pipeline = 0;
-   VkAccessFlags dep_access = 0;
-   unsigned input_count = 0;
-
-   pstate->num_attachments = state->num_cbufs;
-   for (int i = 0; i < state->num_cbufs; i++) {
-      struct zink_rt_attrib *rt = state->rts + i;
-      attachments[i].flags = 0;
-      pstate->attachments[i].format = attachments[i].format = rt->format;
-      pstate->attachments[i].samples = attachments[i].samples = rt->samples;
-      attachments[i].loadOp = rt->clear_color ? VK_ATTACHMENT_LOAD_OP_CLEAR :
-                                                state->swapchain_init && rt->swapchain ?
-                                                VK_ATTACHMENT_LOAD_OP_DONT_CARE :
-                                                VK_ATTACHMENT_LOAD_OP_LOAD;
-      attachments[i].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-      attachments[i].stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE;
-      attachments[i].stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE;
-      /* if layout changes are ever handled here, need VkAttachmentSampleLocationsEXT */
-      VkImageLayout layout = rt->fbfetch ? VK_IMAGE_LAYOUT_GENERAL : VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
-      attachments[i].initialLayout = layout;
-      attachments[i].finalLayout = layout;
-      color_refs[i].attachment = i;
-      color_refs[i].layout = layout;
-      dep_pipeline |= VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT;
-      if (rt->fbfetch) {
-         memcpy(&input_attachments[input_count++], &color_refs[i], sizeof(VkAttachmentReference));
-         dep_pipeline |= VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-         dep_access |= VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
-      }
-      dep_access |= VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
-      if (attachments[i].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD)
-         dep_access |= VK_ACCESS_COLOR_ATTACHMENT_READ_BIT;
-   }
-
-   int num_attachments = state->num_cbufs;
-   if (state->have_zsbuf)  {
-      struct zink_rt_attrib *rt = state->rts + state->num_cbufs;
-      bool has_clear = rt->clear_color || rt->clear_stencil;
-      VkImageLayout layout;
-      if (rt->mixed_zs)
-         layout = VK_IMAGE_LAYOUT_GENERAL;
-      else
-         layout = rt->needs_write || has_clear ? VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL : VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL;
-      attachments[num_attachments].flags = 0;
-      pstate->attachments[num_attachments].format = attachments[num_attachments].format = rt->format;
-      pstate->attachments[num_attachments].samples = attachments[num_attachments].samples = rt->samples;
-      attachments[num_attachments].loadOp = rt->clear_color ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
-      if (rt->mixed_zs)
-         attachments[num_attachments].storeOp = VK_ATTACHMENT_STORE_OP_NONE;
-      else
-         attachments[num_attachments].storeOp = VK_ATTACHMENT_STORE_OP_STORE;
-      attachments[num_attachments].stencilLoadOp = rt->clear_stencil ? VK_ATTACHMENT_LOAD_OP_CLEAR : VK_ATTACHMENT_LOAD_OP_LOAD;
-      attachments[num_attachments].stencilStoreOp = VK_ATTACHMENT_STORE_OP_STORE;
-      /* if layout changes are ever handled here, need VkAttachmentSampleLocationsEXT */
-      attachments[num_attachments].initialLayout = layout;
-      attachments[num_attachments].finalLayout = layout;
-
-      dep_pipeline |= VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT;
-      if (layout == VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL)
-         dep_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
-      if (attachments[num_attachments].loadOp == VK_ATTACHMENT_LOAD_OP_LOAD ||
-          attachments[num_attachments].stencilLoadOp == VK_ATTACHMENT_LOAD_OP_LOAD)
-         dep_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
-
-      zs_ref.attachment = num_attachments++;
-      zs_ref.layout = layout;
-      pstate->num_attachments++;
-   }
-
-   if (!screen->info.have_KHR_synchronization2)
-      dep_pipeline = MAX2(dep_pipeline, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
-   VkSubpassDependency deps[] = {
-      {VK_SUBPASS_EXTERNAL, 0, dep_pipeline, dep_pipeline, 0, dep_access, VK_DEPENDENCY_BY_REGION_BIT},
-      {0, VK_SUBPASS_EXTERNAL, dep_pipeline, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, dep_access, 0, VK_DEPENDENCY_BY_REGION_BIT}
-   };
-   VkPipelineStageFlags input_dep = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-   //if (zs_fbfetch) input_dep |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
-   VkAccessFlags input_access = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
-   //if (zs_fbfetch) input_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
-   VkSubpassDependency fbfetch_deps[] = {
-      {VK_SUBPASS_EXTERNAL, 0, dep_pipeline, dep_pipeline, 0, dep_access, VK_DEPENDENCY_BY_REGION_BIT},
-      {0, 0, dep_pipeline, input_dep, dep_access, input_access, VK_DEPENDENCY_BY_REGION_BIT},
-      {0, VK_SUBPASS_EXTERNAL, dep_pipeline, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, dep_access, 0, VK_DEPENDENCY_BY_REGION_BIT}
-   };
-
-   VkSubpassDescription subpass = {0};
-   subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS;
-   subpass.colorAttachmentCount = state->num_cbufs;
-   subpass.pColorAttachments = color_refs;
-   subpass.pDepthStencilAttachment = state->have_zsbuf ? &zs_ref : NULL;
-   subpass.inputAttachmentCount = input_count;
-   subpass.pInputAttachments = input_attachments;
-
-   VkRenderPassCreateInfo rpci = {0};
-   rpci.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
-   rpci.attachmentCount = num_attachments;
-   rpci.pAttachments = attachments;
-   rpci.subpassCount = 1;
-   rpci.pSubpasses = &subpass;
-   rpci.dependencyCount = input_count ? 3 : 2;
-   rpci.pDependencies = input_count ? fbfetch_deps : deps;
-
-   VkRenderPass render_pass;
-   if (VKSCR(CreateRenderPass)(screen->dev, &rpci, NULL, &render_pass) != VK_SUCCESS) {
-      mesa_loge("ZINK: vkCreateRenderPass failed");
-      return VK_NULL_HANDLE;
-   }
-
-   return render_pass;
-}
 
 static VkRenderPass
 create_render_pass2(struct zink_screen *screen, struct zink_render_pass_state *state, struct zink_render_pass_pipeline_state *pstate)
@@ -270,18 +153,19 @@ create_render_pass2(struct zink_screen *screen, struct zink_render_pass_state *s
    if (!screen->info.have_KHR_synchronization2)
       dep_pipeline = MAX2(dep_pipeline, VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT);
 
+   VkDependencyFlags flag = screen->info.have_KHR_synchronization2 ? VK_DEPENDENCY_BY_REGION_BIT : 0;
    VkSubpassDependency2 deps[] = {
-      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, VK_SUBPASS_EXTERNAL, 0, dep_pipeline, dep_pipeline, 0, dep_access, VK_DEPENDENCY_BY_REGION_BIT, 0},
-      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, 0, VK_SUBPASS_EXTERNAL, dep_pipeline, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, dep_access, 0, VK_DEPENDENCY_BY_REGION_BIT, 0}
+      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, VK_SUBPASS_EXTERNAL, 0, dep_pipeline, dep_pipeline, 0, dep_access, flag, 0},
+      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, 0, VK_SUBPASS_EXTERNAL, dep_pipeline, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, dep_access, 0, flag, 0}
    };
    VkPipelineStageFlags input_dep = VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    //if (zs_fbfetch) input_dep |= VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT, VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT;
    VkAccessFlags input_access = VK_ACCESS_INPUT_ATTACHMENT_READ_BIT;
    //if (zs_fbfetch) input_access |= VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
    VkSubpassDependency2 fbfetch_deps[] = {
-      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, VK_SUBPASS_EXTERNAL, 0, dep_pipeline, dep_pipeline, 0, dep_access, VK_DEPENDENCY_BY_REGION_BIT, 0},
-      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, 0, 0, dep_pipeline, input_dep, dep_access, input_access, VK_DEPENDENCY_BY_REGION_BIT, 0},
-      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, 0, VK_SUBPASS_EXTERNAL, dep_pipeline, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, dep_access, 0, VK_DEPENDENCY_BY_REGION_BIT, 0}
+      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, VK_SUBPASS_EXTERNAL, 0, dep_pipeline, dep_pipeline, 0, dep_access, flag, 0},
+      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, 0, 0, dep_pipeline, input_dep, dep_access, input_access, flag, 0},
+      {VK_STRUCTURE_TYPE_SUBPASS_DEPENDENCY_2, NULL, 0, VK_SUBPASS_EXTERNAL, dep_pipeline, VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT, dep_access, 0, flag, 0}
    };
 
    VkSubpassDescription2 subpass = {0};
@@ -332,8 +216,7 @@ zink_create_render_pass(struct zink_screen *screen,
    if (!rp)
       goto fail;
 
-   rp->render_pass = screen->vk_version >= VK_MAKE_VERSION(1,2,0) ?
-                     create_render_pass2(screen, state, pstate) : create_render_pass(screen, state, pstate);
+   rp->render_pass = create_render_pass2(screen, state, pstate);
    if (!rp->render_pass)
       goto fail;
    memcpy(&rp->state, state, sizeof(struct zink_render_pass_state));

src/gallium/drivers/zink/zink_resource.c

@@ -260,7 +260,7 @@ get_image_usage_for_feats(struct zink_screen *screen, VkFormatFeatureFlags feats
          usage |= VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
          if ((bind & (PIPE_BIND_LINEAR | PIPE_BIND_SHARED)) != (PIPE_BIND_LINEAR | PIPE_BIND_SHARED))
             usage |= VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT;
-      } else if (templ->nr_samples)
+      } else if (templ->nr_samples || !(feats & VK_FORMAT_FEATURE_BLIT_DST_BIT))
          /* this can't be populated, so we can't do it */
          return 0;
    }

src/gallium/drivers/zink/zink_screen.c

@@ -138,20 +138,6 @@ zink_get_device_uuid(struct pipe_screen *pscreen, char *uuid)
    }
 }
 
-static uint32_t
-hash_framebuffer_state(const void *key)
-{
-   struct zink_framebuffer_state* s = (struct zink_framebuffer_state*)key;
-   return _mesa_hash_data(key, offsetof(struct zink_framebuffer_state, attachments) + sizeof(s->attachments[0]) * s->num_attachments);
-}
-
-static bool
-equals_framebuffer_state(const void *a, const void *b)
-{
-   struct zink_framebuffer_state *s = (struct zink_framebuffer_state*)a;
-   return memcmp(a, b, offsetof(struct zink_framebuffer_state, attachments) + sizeof(s->attachments[0]) * s->num_attachments) == 0;
-}
-
 static VkDeviceSize
 get_video_mem(struct zink_screen *screen)
 {
@@ -349,6 +335,7 @@ zink_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
       if (screen->info.have_EXT_primitive_topology_list_restart) {
          modes |= BITFIELD_BIT(PIPE_PRIM_POINTS) |
                   BITFIELD_BIT(PIPE_PRIM_LINES) |
+                  BITFIELD_BIT(PIPE_PRIM_LINES_ADJACENCY) |
                   BITFIELD_BIT(PIPE_PRIM_TRIANGLES) |
                   BITFIELD_BIT(PIPE_PRIM_TRIANGLES_ADJACENCY);
          if (screen->info.list_restart_feats.primitiveTopologyPatchListRestart)
@@ -975,8 +962,8 @@ zink_get_shader_param(struct pipe_screen *pscreen,
                        screen->info.props.limits.maxPerStageDescriptorSampledImages),
                   PIPE_MAX_SAMPLERS);
 
-   case PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED:
-   case PIPE_SHADER_CAP_TGSI_DFRACEXP_DLDEXP_SUPPORTED:
+   case PIPE_SHADER_CAP_DROUND_SUPPORTED:
+   case PIPE_SHADER_CAP_DFRACEXP_DLDEXP_SUPPORTED:
    case PIPE_SHADER_CAP_TGSI_FMA_SUPPORTED:
       return 0; /* not implemented */
 
@@ -1015,18 +1002,18 @@ zink_get_shader_param(struct pipe_screen *pscreen,
       if (screen->info.feats.features.shaderStorageImageExtendedFormats &&
           screen->info.feats.features.shaderStorageImageWriteWithoutFormat)
          return MIN2(screen->info.props.limits.maxPerStageDescriptorStorageImages,
-                     PIPE_MAX_SHADER_IMAGES);
+                     ZINK_MAX_SHADER_IMAGES);
       return 0;
 
    case PIPE_SHADER_CAP_LOWER_IF_THRESHOLD:
    case PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS:
       return 0; /* unsure */
 
-   case PIPE_SHADER_CAP_TGSI_LDEXP_SUPPORTED:
+   case PIPE_SHADER_CAP_LDEXP_SUPPORTED:
    case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS:
    case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS:
       return 0; /* not implemented */
-   case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
+   case PIPE_SHADER_CAP_CONT_SUPPORTED:
       return 1;
    }
 
@@ -1219,14 +1206,6 @@ zink_destroy_screen(struct pipe_screen *pscreen)
       VKSCR(DestroyDebugUtilsMessengerEXT)(screen->instance, screen->debugUtilsCallbackHandle, NULL);
    }
 
-   if (!screen->info.have_KHR_imageless_framebuffer) {
-      hash_table_foreach(&screen->framebuffer_cache, entry) {
-         struct zink_framebuffer* fb = (struct zink_framebuffer*)entry->data;
-         zink_destroy_framebuffer(screen, fb);
-      }
-      simple_mtx_destroy(&screen->framebuffer_mtx);
-   }
-
    u_transfer_helper_destroy(pscreen->transfer_helper);
 #ifdef ENABLE_SHADER_CACHE
    if (screen->disk_cache) {
@@ -1730,7 +1709,6 @@ zink_screen_init_semaphore(struct zink_screen *screen)
    } else {
       mesa_loge("ZINK: vkCreateSemaphore failed");
    }
-   screen->info.have_KHR_timeline_semaphore = false;
    return false;
 }
 
@@ -1760,81 +1738,6 @@ zink_screen_timeline_wait(struct zink_screen *screen, uint32_t batch_id, uint64_
    return success;
 }
 
-struct noop_submit_info {
-   struct zink_screen *screen;
-   VkFence fence;
-};
-
-static void
-noop_submit(void *data, void *gdata, int thread_index)
-{
-   struct noop_submit_info *n = data;
-   VkSubmitInfo si = {0};
-   si.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
-   simple_mtx_lock(&n->screen->queue_lock);
-   if (n->VKSCR(QueueSubmit)(n->screen->threaded ? n->screen->thread_queue : n->screen->queue,
-                     1, &si, n->fence) != VK_SUCCESS) {
-      mesa_loge("ZINK: vkQueueSubmit failed");
-      n->screen->device_lost = true;
-   }
-   simple_mtx_unlock(&n->screen->queue_lock);
-}
-
-bool
-zink_screen_batch_id_wait(struct zink_screen *screen, uint32_t batch_id, uint64_t timeout)
-{
-   if (zink_screen_check_last_finished(screen, batch_id))
-      return true;
-
-   if (screen->info.have_KHR_timeline_semaphore)
-      return zink_screen_timeline_wait(screen, batch_id, timeout);
-
-   if (!timeout)
-      return false;
-
-   uint32_t new_id = 0;
-   while (!new_id)
-      new_id = p_atomic_inc_return(&screen->curr_batch);
-   VkResult ret;
-   struct noop_submit_info n;
-   uint64_t abs_timeout = os_time_get_absolute_timeout(timeout);
-   uint64_t remaining = PIPE_TIMEOUT_INFINITE;
-   VkFenceCreateInfo fci = {0};
-   struct util_queue_fence fence;
-   util_queue_fence_init(&fence);
-   fci.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
-
-   if (VKSCR(CreateFence)(screen->dev, &fci, NULL, &n.fence) != VK_SUCCESS) {
-      mesa_loge("ZINK: vkCreateFence failed");
-      return false;
-   }
-
-   n.screen = screen;
-   if (screen->threaded) {
-      /* must use thread dispatch for sanity */
-      util_queue_add_job(&screen->flush_queue, &n, &fence, noop_submit, NULL, 0);
-      util_queue_fence_wait(&fence);
-   } else {
-      noop_submit(&n, NULL, 0);
-   }
-   if (timeout != PIPE_TIMEOUT_INFINITE) {
-      int64_t time_ns = os_time_get_nano();
-      remaining = abs_timeout > time_ns ? abs_timeout - time_ns : 0;
-   }
-
-   if (remaining)
-      ret = VKSCR(WaitForFences)(screen->dev, 1, &n.fence, VK_TRUE, remaining);
-   else
-      ret = VKSCR(GetFenceStatus)(screen->dev, n.fence);
-   VKSCR(DestroyFence)(screen->dev, n.fence, NULL);
-   bool success = zink_screen_handle_vkresult(screen, ret);
-
-   if (success)
-      zink_screen_update_last_finished(screen, new_id);
-
-   return success;
-}
-
 static uint32_t
 zink_get_loader_version(void)
 {
@@ -2111,6 +2014,9 @@ init_driver_workarounds(struct zink_screen *screen)
 {
    screen->driver_workarounds.color_write_missing = !screen->info.have_EXT_color_write_enable;
    screen->driver_workarounds.depth_clip_control_missing = !screen->info.have_EXT_depth_clip_control;
+   if (screen->info.driver_props.driverID == VK_DRIVER_ID_AMD_PROPRIETARY)
+      /* this completely breaks xfb somehow */
+      screen->info.have_EXT_extended_dynamic_state2 = false;
    if (screen->info.driver_props.driverID == VK_DRIVER_ID_INTEL_OPEN_SOURCE_MESA) {
       /* #6186 */
       screen->driver_workarounds.depth_clip_control_missing = true;
@@ -2183,6 +2089,10 @@ zink_internal_create_screen(const struct pipe_screen_config *config)
       util_queue_init(&screen->flush_queue, "zfq", 8, 1, UTIL_QUEUE_INIT_RESIZE_IF_FULL, screen);
 
    zink_internal_setup_moltenvk(screen);
+   if (!screen->info.have_KHR_timeline_semaphore) {
+      mesa_loge("zink: KHR_timeline_semaphore is required");
+      goto fail;
+   }
 
    screen->dev = zink_create_logical_device(screen);
    if (!screen->dev)
@@ -2270,20 +2180,11 @@ zink_internal_create_screen(const struct pipe_screen_config *config)
    if (!os_get_total_physical_memory(&screen->total_mem))
       goto fail;
 
-   switch (screen->info.driver_props.driverID) {
-   case VK_DRIVER_ID_NVIDIA_PROPRIETARY:
-      screen->max_fences = 500;
-      break;
-   default:
-      screen->max_fences = 5000;
-      break;
+   if (!zink_screen_init_semaphore(screen)) {
+      mesa_loge("zink: failed to create timeline semaphore");
+      goto fail;
    }
 
-   if (debug_get_bool_option("ZINK_NO_TIMELINES", false))
-      screen->info.have_KHR_timeline_semaphore = false;
-   if (screen->info.have_KHR_timeline_semaphore)
-      zink_screen_init_semaphore(screen);
-
    memset(&screen->heap_map, UINT8_MAX, sizeof(screen->heap_map));
    for (enum zink_heap i = 0; i < ZINK_HEAP_MAX; i++) {
       for (unsigned j = 0; j < screen->info.mem_props.memoryTypeCount; j++) {
@@ -2315,11 +2216,6 @@ zink_internal_create_screen(const struct pipe_screen_config *config)
          screen->resizable_bar = true;
    }
 
-   if (!screen->info.have_KHR_imageless_framebuffer) {
-      simple_mtx_init(&screen->framebuffer_mtx, mtx_plain);
-      _mesa_hash_table_init(&screen->framebuffer_cache, screen, hash_framebuffer_state, equals_framebuffer_state);
-   }
-
    simple_mtx_init(&screen->dt_lock, mtx_plain);
 
    zink_screen_init_descriptor_funcs(screen, false);

src/gallium/drivers/zink/zink_screen.h

@@ -144,7 +144,6 @@ struct zink_screen {
    uint32_t gfx_queue;
    uint32_t max_queues;
    uint32_t timestamp_valid_bits;
-   unsigned max_fences;
    VkDevice dev;
    VkQueue queue; //gfx+compute
    VkQueue thread_queue; //gfx+compute
@@ -263,9 +262,6 @@ struct mem_cache_entry {
 VkFormat
 zink_get_format(struct zink_screen *screen, enum pipe_format format);
 
-bool
-zink_screen_batch_id_wait(struct zink_screen *screen, uint32_t batch_id, uint64_t timeout);
-
 bool
 zink_screen_timeline_wait(struct zink_screen *screen, uint32_t batch_id, uint64_t timeout);
 

src/gallium/drivers/zink/zink_surface.c

@@ -165,7 +165,6 @@ create_surface(struct pipe_context *pctx,
    surface->base.u.tex.first_layer = templ->u.tex.first_layer;
    surface->base.u.tex.last_layer = templ->u.tex.last_layer;
    surface->obj = zink_resource(pres)->obj;
-   util_dynarray_init(&surface->framebuffer_refs, NULL);
    util_dynarray_init(&surface->desc_set_refs.refs, NULL);
 
    init_surface_info(surface, res, ivci);
@@ -291,33 +290,6 @@ zink_create_surface(struct pipe_context *pctx,
    return &csurf->base;
 }
 
-/* framebuffers are owned by their surfaces, so each time a surface that's part of a cached fb
- * is destroyed, it has to unref all the framebuffers it's attached to in order to avoid leaking
- * all the framebuffers
- *
- * surfaces are always batch-tracked, so it is impossible for a framebuffer to be destroyed
- * while it is in use
- */
-static void
-surface_clear_fb_refs(struct zink_screen *screen, struct pipe_surface *psurface)
-{
-   struct zink_surface *surface = zink_surface(psurface);
-   util_dynarray_foreach(&surface->framebuffer_refs, struct zink_framebuffer*, fb_ref) {
-      struct zink_framebuffer *fb = *fb_ref;
-      for (unsigned i = 0; i < fb->state.num_attachments; i++) {
-         if (fb->surfaces[i] == psurface) {
-            simple_mtx_lock(&screen->framebuffer_mtx);
-            fb->surfaces[i] = NULL;
-            _mesa_hash_table_remove_key(&screen->framebuffer_cache, &fb->state);
-            zink_framebuffer_reference(screen, &fb, NULL);
-            simple_mtx_unlock(&screen->framebuffer_mtx);
-            break;
-         }
-      }
-   }
-   util_dynarray_fini(&surface->framebuffer_refs);
-}
-
 void
 zink_destroy_surface(struct zink_screen *screen, struct pipe_surface *psurface)
 {
@@ -336,10 +308,7 @@ zink_destroy_surface(struct zink_screen *screen, struct pipe_surface *psurface)
       _mesa_hash_table_remove(&res->surface_cache, he);
       simple_mtx_unlock(&res->surface_mtx);
    }
-   if (!screen->info.have_KHR_imageless_framebuffer)
-      surface_clear_fb_refs(screen, psurface);
    zink_descriptor_set_refs_clear(&surface->desc_set_refs, surface);
-   util_dynarray_fini(&surface->framebuffer_refs);
    if (surface->simage_view)
       VKSCR(DestroyImageView)(screen->dev, surface->simage_view, NULL);
    if (surface->is_swapchain) {
@@ -381,7 +350,6 @@ zink_rebind_surface(struct zink_context *ctx, struct pipe_surface **psurface)
    struct hash_entry *new_entry = _mesa_hash_table_search_pre_hashed(&res->surface_cache, hash, &ivci);
    if (zink_batch_usage_exists(surface->batch_uses))
       zink_batch_reference_surface(&ctx->batch, surface);
-   surface_clear_fb_refs(screen, *psurface);
    zink_descriptor_set_refs_clear(&surface->desc_set_refs, surface);
    if (new_entry) {
       /* reuse existing surface; old one will be cleaned up naturally */

src/gallium/drivers/zink/zink_surface.h

@@ -55,7 +55,6 @@ struct zink_surface {
    void *obj; //backing resource object
    uint32_t hash;
    struct zink_batch_usage *batch_uses;
-   struct util_dynarray framebuffer_refs;
    struct zink_descriptor_refs desc_set_refs;
 };
 

src/gallium/include/pipe/p_defines.h

@@ -1081,7 +1081,7 @@ enum pipe_shader_cap
    PIPE_SHADER_CAP_MAX_CONST_BUFFERS,
    PIPE_SHADER_CAP_MAX_TEMPS,
    /* boolean caps */
-   PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED,
+   PIPE_SHADER_CAP_CONT_SUPPORTED,
    PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR,
    PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR,
    PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR,
@@ -1098,8 +1098,8 @@ enum pipe_shader_cap
    PIPE_SHADER_CAP_PREFERRED_IR,
    PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED,
    PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS,
-   PIPE_SHADER_CAP_TGSI_DROUND_SUPPORTED, /* all rounding modes */
-   PIPE_SHADER_CAP_TGSI_DFRACEXP_DLDEXP_SUPPORTED,
+   PIPE_SHADER_CAP_DROUND_SUPPORTED, /* all rounding modes */
+   PIPE_SHADER_CAP_DFRACEXP_DLDEXP_SUPPORTED,
    PIPE_SHADER_CAP_TGSI_FMA_SUPPORTED,
    PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE,
    PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT,
@@ -1108,7 +1108,7 @@ enum pipe_shader_cap
    PIPE_SHADER_CAP_MAX_SHADER_IMAGES,
    PIPE_SHADER_CAP_LOWER_IF_THRESHOLD,
    PIPE_SHADER_CAP_TGSI_SKIP_MERGE_REGISTERS,
-   PIPE_SHADER_CAP_TGSI_LDEXP_SUPPORTED,
+   PIPE_SHADER_CAP_LDEXP_SUPPORTED,
    PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS,
    PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTER_BUFFERS,
 };

src/gallium/drivers/radeon/radeon_winsys.h → src/gallium/include/winsys/radeon_winsys.h

@@ -890,4 +890,15 @@ static inline int radeon_get_heap_index(enum radeon_bo_domain domain, enum radeo
    return -1;
 }
 
+typedef struct pipe_screen *(*radeon_screen_create_t)(struct radeon_winsys *,
+                                                      const struct pipe_screen_config *);
+
+/* These functions create the radeon_winsys instance for the corresponding kernel driver. */
+struct radeon_winsys *
+amdgpu_winsys_create(int fd, const struct pipe_screen_config *config,
+		     radeon_screen_create_t screen_create);
+struct radeon_winsys *
+radeon_drm_winsys_create(int fd, const struct pipe_screen_config *config,
+			 radeon_screen_create_t screen_create);
+
 #endif

src/gallium/targets/pipe-loader/pipe_r300.c

 #include "target-helpers/drm_helper.h"
 #include "target-helpers/inline_debug_helper.h"
 #include "frontend/drm_driver.h"
-#include "radeon/drm/radeon_drm_public.h"
-#include "radeon/radeon_winsys.h"
+#include "winsys/radeon_winsys.h"
 #include "r300/r300_public.h"

src/gallium/targets/pipe-loader/pipe_r600.c

 #include "frontend/drm_driver.h"
 #include "target-helpers/drm_helper.h"
 #include "target-helpers/inline_debug_helper.h"
-#include "radeon/drm/radeon_drm_public.h"
-#include "radeon/radeon_winsys.h"
+#include "winsys/radeon_winsys.h"
 #include "r600/r600_public.h"

src/gallium/winsys/amdgpu/drm/amdgpu_public.h

-/*
- * Copyright © 2015 Advanced Micro Devices, Inc.
- * All Rights Reserved.
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files (the
- * "Software"), to deal in the Software without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sub license, and/or sell copies of the Software, and to
- * permit persons to whom the Software is furnished to do so, subject to
- * the following conditions:
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS, AUTHORS
- * AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
- * USE OR OTHER DEALINGS IN THE SOFTWARE.
- *
- * The above copyright notice and this permission notice (including the
- * next paragraph) shall be included in all copies or substantial portions
- * of the Software.
- */
-
-#ifndef AMDGPU_PUBLIC_H
-#define AMDGPU_PUBLIC_H
-
-#include "pipe/p_defines.h"
-#include "gallium/winsys/radeon/drm/radeon_drm_public.h"
-
-struct radeon_winsys;
-struct pipe_screen;
-struct pipe_screen_config;
-
-struct radeon_winsys *
-amdgpu_winsys_create(int fd, const struct pipe_screen_config *config,
-		     radeon_screen_create_t screen_create);
-
-#endif

src/gallium/winsys/amdgpu/drm/amdgpu_winsys.c

@@ -28,7 +28,6 @@
  */
 
 #include "amdgpu_cs.h"
-#include "amdgpu_public.h"
 
 #include "util/os_file.h"
 #include "util/os_misc.h"

src/gallium/winsys/amdgpu/drm/amdgpu_winsys.h

@@ -30,7 +30,7 @@
 
 #include "pipebuffer/pb_cache.h"
 #include "pipebuffer/pb_slab.h"
-#include "gallium/drivers/radeon/radeon_winsys.h"
+#include "winsys/radeon_winsys.h"
 #include "util/simple_mtx.h"
 #include "util/u_queue.h"
 #include <amdgpu.h>

src/gallium/winsys/amdgpu/drm/meson.build

@@ -22,7 +22,7 @@ libamdgpuwinsys = static_library(
   'amdgpuwinsys',
   files(
     'amdgpu_bo.c', 'amdgpu_bo.h', 'amdgpu_cs.c', 'amdgpu_cs.h',
-    'amdgpu_public.h', 'amdgpu_surface.c', 'amdgpu_winsys.c',
+    'amdgpu_surface.c', 'amdgpu_winsys.c',
     'amdgpu_winsys.h',
   ),
   include_directories : [