← Back to branch summary

~mmach/netext73/mesa-ryzen

« back to all changes in this revision

Viewing changes to src/gallium/drivers/nouveau/nv50/nv50_screen.c

  • Committer: mmach
  • Date: 2023-11-02 21:31:35 UTC
  • Revision ID: netbit73@gmail.com-20231102213135-18d4tzh7tj0uz752
2023-11-02 22:11:57

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/gallium/drivers/nouveau/nv50/nv50_screen.c
191
191
 
192
192
   case PIPE_CAP_SUPPORTED_PRIM_MODES_WITH_RESTART:
193
193
   case PIPE_CAP_SUPPORTED_PRIM_MODES:
194
 
      return BITFIELD_MASK(PIPE_PRIM_MAX);
 
194
      return BITFIELD_MASK(MESA_PRIM_COUNT);
195
195
 
196
196
   /* supported caps */
197
197
   case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
237
237
   case PIPE_CAP_DEPTH_BOUNDS_TEST:
238
238
   case PIPE_CAP_TEXTURE_QUERY_SAMPLES:
239
239
   case PIPE_CAP_COPY_BETWEEN_COMPRESSED_AND_PLAIN_FORMATS:
240
 
   case PIPE_CAP_CLEAR_TEXTURE:
241
240
   case PIPE_CAP_FS_FACE_IS_INTEGER_SYSVAL:
242
241
   case PIPE_CAP_INVALIDATE_BUFFER:
243
242
   case PIPE_CAP_STRING_MARKER:
255
254
      return 1;
256
255
 
257
256
   case PIPE_CAP_ALPHA_TEST:
258
 
      /* nvc0 has fixed function alpha test support, but nv50 doesn't.  The TGSI
259
 
       * backend emits the conditional discard code against a driver-uploaded
260
 
       * uniform, but with NIR we can have the st emit it for us.
 
257
      /* nvc0 has fixed function alpha test support, but nv50 doesn't.  If we
 
258
       * don't have it, then the frontend will lower it for us.
261
259
       */
262
 
      return class_3d >= NVC0_3D_CLASS || !screen->prefer_nir;
 
260
      return class_3d >= NVC0_3D_CLASS;
263
261
 
264
262
   case PIPE_CAP_TEXTURE_TRANSFER_MODES:
265
263
      return PIPE_TEXTURE_TRANSFER_BLIT;
316
314
                             enum pipe_shader_type shader,
317
315
                             enum pipe_shader_cap param)
318
316
{
319
 
   const struct nouveau_screen *screen = nouveau_screen(pscreen);
320
 
 
321
317
   switch (shader) {
322
318
   case PIPE_SHADER_VERTEX:
323
319
   case PIPE_SHADER_GEOMETRY:
376
372
      return shader == PIPE_SHADER_COMPUTE ? NV50_MAX_GLOBALS - 1 : 0;
377
373
   case PIPE_SHADER_CAP_MAX_SHADER_IMAGES:
378
374
      return shader == PIPE_SHADER_COMPUTE ? NV50_MAX_GLOBALS - 1 : 0;
379
 
   case PIPE_SHADER_CAP_PREFERRED_IR:
380
 
      return screen->prefer_nir ? PIPE_SHADER_IR_NIR : PIPE_SHADER_IR_TGSI;
381
375
   case PIPE_SHADER_CAP_SUPPORTED_IRS:
382
 
      return (1 << PIPE_SHADER_IR_TGSI) | (1 << PIPE_SHADER_IR_NIR);
 
376
      return 1 << PIPE_SHADER_IR_NIR;
383
377
   case PIPE_SHADER_CAP_DROUND_SUPPORTED:
384
378
   case PIPE_SHADER_CAP_TGSI_ANY_INOUT_DECL_RANGE:
385
379
   case PIPE_SHADER_CAP_MAX_HW_ATOMIC_COUNTERS:
454
448
      RET((uint64_t []) { 16 << 10 });
455
449
   case PIPE_COMPUTE_CAP_MAX_INPUT_SIZE: /* c[], arbitrary limit */
456
450
      RET((uint64_t []) { 4096 });
457
 
   case PIPE_COMPUTE_CAP_SUBGROUP_SIZE:
 
451
   case PIPE_COMPUTE_CAP_SUBGROUP_SIZES:
458
452
      RET((uint32_t []) { 32 });
 
453
   case PIPE_COMPUTE_CAP_MAX_SUBGROUPS:
 
454
      RET((uint32_t []) { 0 });
459
455
   case PIPE_COMPUTE_CAP_MAX_MEM_ALLOC_SIZE:
460
456
      RET((uint64_t []) { nouveau_device_get_global_mem_size(dev) });
461
457
   case PIPE_COMPUTE_CAP_IMAGES_SUPPORTED:
517
513
}
518
514
 
519
515
static void
520
 
nv50_screen_fence_emit(struct pipe_context *pcontext, u32 *sequence)
 
516
nv50_screen_fence_emit(struct pipe_context *pcontext, u32 *sequence,
 
517
                       struct nouveau_bo *wait)
521
518
{
522
519
   struct nv50_context *nv50 = nv50_context(pcontext);
523
520
   struct nv50_screen *screen = nv50->screen;
524
521
   struct nouveau_pushbuf *push = nv50->base.pushbuf;
 
522
   struct nouveau_pushbuf_refn ref = { wait, NOUVEAU_BO_GART | NOUVEAU_BO_RDWR };
525
523
 
526
524
   /* we need to do it after possible flush in MARK_RING */
527
525
   *sequence = ++screen->base.fence.sequence;
537
535
                    NV50_3D_QUERY_GET_TYPE_QUERY |
538
536
                    NV50_3D_QUERY_GET_QUERY_SELECT_ZERO |
539
537
                    NV50_3D_QUERY_GET_SHORT);
 
538
 
 
539
   nouveau_pushbuf_refn(push, &ref, 1);
540
540
}
541
541
 
542
542
static u32
787
787
   PUSH_DATA (push, 1);
788
788
   BEGIN_NV04(push, NV50_3D(UNK19C0), 1);
789
789
   PUSH_DATA (push, 1);
790
 
 
791
 
   PUSH_KICK (push);
792
790
}
793
791
 
794
792
static int nv50_tls_alloc(struct nv50_screen *screen, unsigned tls_space,
851
849
                                 enum pipe_shader_ir ir,
852
850
                                 enum pipe_shader_type shader)
853
851
{
854
 
   struct nouveau_screen *screen = nouveau_screen(pscreen);
855
852
   if (ir == PIPE_SHADER_IR_NIR)
856
 
      return nv50_ir_nir_shader_compiler_options(NVISA_G80_CHIPSET, shader, screen->prefer_nir);
 
853
      return nv50_ir_nir_shader_compiler_options(NVISA_G80_CHIPSET, shader);
857
854
   return NULL;
858
855
}
859
856
 
1072
1069
      goto fail;
1073
1070
   }
1074
1071
 
 
1072
   // submit all initial state
 
1073
   PUSH_KICK(screen->base.pushbuf);
 
1074
 
1075
1075
   return &screen->base;
1076
1076
 
1077
1077
fail: