src/gallium/drivers/r300/r300_screen.c

   1 /*
   2  * Copyright 2008 Corbin Simpson <MostAwesomeDude@gmail.com>
   3  * Copyright 2010 Marek Olšák <maraeo@gmail.com>
   4  *
   5  * Permission is hereby granted, free of charge, to any person obtaining a
   6  * copy of this software and associated documentation files (the "Software"),
   7  * to deal in the Software without restriction, including without limitation
   8  * on the rights to use, copy, modify, merge, publish, distribute, sub
   9  * license, and/or sell copies of the Software, and to permit persons to whom
  10  * the Software is furnished to do so, subject to the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the next
  13  * paragraph) shall be included in all copies or substantial portions of the
  14  * Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHOR(S) AND/OR THEIR SUPPLIERS BE LIABLE FOR ANY CLAIM,
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  22  * USE OR OTHER DEALINGS IN THE SOFTWARE. */
  23
  24 #include "util/u_format.h"
  25 #include "util/u_format_s3tc.h"
  26 #include "util/u_memory.h"
  27
  28 #include "r300_context.h"
  29 #include "r300_texture.h"
  30 #include "r300_screen_buffer.h"
  31 #include "r300_state_inlines.h"
  32 #include "r300_winsys.h"
  33 #include "r300_public.h"
  34
  35 #include "draw/draw_context.h"
  36
  37 #ifdef HAVE_LLVM
  38 #include "gallivm/lp_bld_init.h"
  39 #endif
  40
  41 /* Return the identifier behind whom the brave coders responsible for this
  42  * amalgamation of code, sweat, and duct tape, routinely obscure their names.
  43  *
  44  * ...I should have just put "Corbin Simpson", but I'm not that cool.
  45  *
  46  * (Or egotistical. Yet.) */
  47 static const char* r300_get_vendor(struct pipe_screen* pscreen)
  48 {
  49     return "X.Org R300 Project";
  50 }
  51
  52 static const char* chip_families[] = {
  53     "ATI R300",
  54     "ATI R350",
  55     "ATI R360",
  56     "ATI RV350",
  57     "ATI RV370",
  58     "ATI RV380",
  59     "ATI R420",
  60     "ATI R423",
  61     "ATI R430",
  62     "ATI R480",
  63     "ATI R481",
  64     "ATI RV410",
  65     "ATI RS400",
  66     "ATI RC410",
  67     "ATI RS480",
  68     "ATI RS482",
  69     "ATI RS600",
  70     "ATI RS690",
  71     "ATI RS740",
  72     "ATI RV515",
  73     "ATI R520",
  74     "ATI RV530",
  75     "ATI R580",
  76     "ATI RV560",
  77     "ATI RV570"
  78 };
  79
  80 static const char* r300_get_name(struct pipe_screen* pscreen)
  81 {
  82     struct r300_screen* r300screen = r300_screen(pscreen);
  83
  84     return chip_families[r300screen->caps.family];
  85 }
  86
  87 static int r300_get_param(struct pipe_screen* pscreen, enum pipe_cap param)
  88 {
  89     struct r300_screen* r300screen = r300_screen(pscreen);
  90     boolean is_r500 = r300screen->caps.is_r500;
  91
  92     switch (param) {
  93         /* Supported features (boolean caps). */
  94         case PIPE_CAP_NPOT_TEXTURES:
  95         case PIPE_CAP_TWO_SIDED_STENCIL:
  96         case PIPE_CAP_GLSL:
  97             /* I'll be frank. This is a lie.
  98              *
  99              * We don't truly support GLSL on any of this driver's chipsets.
 100              * To be fair, no chipset supports the full GLSL specification
 101              * to the best of our knowledge, but some of the less esoteric
 102              * features are still missing here.
 103              *
 104              * Rather than cripple ourselves intentionally, I'm going to set
 105              * this flag, and as Gallium's interface continues to change, I
 106              * hope that this single monolithic GLSL enable can slowly get
 107              * split down into many different pieces and the state tracker
 108              * will handle fallbacks transparently, like it should.
 109              *
 110              * ~ C.
 111              */
 112         case PIPE_CAP_ANISOTROPIC_FILTER:
 113         case PIPE_CAP_POINT_SPRITE:
 114         case PIPE_CAP_OCCLUSION_QUERY:
 115         case PIPE_CAP_TEXTURE_SHADOW_MAP:
 116         case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
 117         case PIPE_CAP_TEXTURE_MIRROR_REPEAT:
 118         case PIPE_CAP_BLEND_EQUATION_SEPARATE:
 119             return 1;
 120         case PIPE_CAP_TEXTURE_SWIZZLE:
 121             return util_format_s3tc_enabled ? r300screen->caps.dxtc_swizzle : 1;
 122
 123         /* Unsupported features (boolean caps). */
 124         case PIPE_CAP_TIMER_QUERY:
 125         case PIPE_CAP_DUAL_SOURCE_BLEND:
 126         case PIPE_CAP_INDEP_BLEND_ENABLE:
 127         case PIPE_CAP_INDEP_BLEND_FUNC:
 128         case PIPE_CAP_DEPTH_CLAMP: /* XXX implemented, but breaks Regnum Online */
 129         case PIPE_CAP_DEPTHSTENCIL_CLEAR_SEPARATE:
 130         case PIPE_CAP_SHADER_STENCIL_EXPORT:
 131         case PIPE_CAP_STREAM_OUTPUT:
 132         case PIPE_CAP_PRIMITIVE_RESTART:
 133             return 0;
 134
 135         /* Texturing. */
 136         case PIPE_CAP_MAX_TEXTURE_IMAGE_UNITS:
 137         case PIPE_CAP_MAX_COMBINED_SAMPLERS:
 138             return r300screen->caps.num_tex_units;
 139         case PIPE_CAP_MAX_VERTEX_TEXTURE_UNITS:
 140             return 0;
 141         case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
 142         case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
 143         case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
 144             /* 13 == 4096, 12 == 2048 */
 145             return is_r500 ? 13 : 12;
 146
 147         /* Render targets. */
 148         case PIPE_CAP_MAX_RENDER_TARGETS:
 149             return 4;
 150
 151         /* General shader limits and features. */
 152         case PIPE_CAP_SM3:
 153             return is_r500 ? 1 : 0;
 154         /* Fragment coordinate conventions. */
 155         case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
 156         case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
 157             return 1;
 158         case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
 159         case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
 160             return 0;
 161         default:
 162             debug_printf("r300: Warning: Unknown CAP %d in get_param.\n",
 163                          param);
 164             return 0;
 165     }
 166 }
 167
 168 static int r300_get_shader_param(struct pipe_screen *pscreen, unsigned shader, enum pipe_shader_cap param)
 169 {
 170    struct r300_screen* r300screen = r300_screen(pscreen);
 171    boolean is_r400 = r300screen->caps.is_r400;
 172    boolean is_r500 = r300screen->caps.is_r500;
 173
 174    switch (shader)
 175     {
 176     case PIPE_SHADER_FRAGMENT:
 177         switch (param)
 178         {
 179         case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
 180             return is_r500 || is_r400 ? 512 : 96;
 181         case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
 182             return is_r500 || is_r400 ? 512 : 64;
 183         case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
 184             return is_r500 || is_r400 ? 512 : 32;
 185         case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
 186             return is_r500 ? 511 : 4;
 187         case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
 188             return is_r500 ? 64 : 0; /* Actually unlimited on r500. */
 189             /* Fragment shader limits. */
 190         case PIPE_SHADER_CAP_MAX_INPUTS:
 191             /* 2 colors + 8 texcoords are always supported
 192              * (minus fog and wpos).
 193              *
 194              * R500 has the ability to turn 3rd and 4th color into
 195              * additional texcoords but there is no two-sided color
 196              * selection then. However the facing bit can be used instead. */
 197             return 10;
 198         case PIPE_SHADER_CAP_MAX_CONSTS:
 199             return is_r500 ? 256 : 32;
 200         case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
 201             return 1;
 202         case PIPE_SHADER_CAP_MAX_TEMPS:
 203             return is_r500 ? 128 : is_r400 ? 64 : 32;
 204         case PIPE_SHADER_CAP_MAX_ADDRS:
 205             return 0;
 206         case PIPE_SHADER_CAP_MAX_PREDS:
 207             return is_r500 ? 1 : 0;
 208         case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
 209             return 1;
 210         case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
 211         case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
 212         case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
 213         case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
 214             return 0;
 215         case PIPE_SHADER_CAP_SUBROUTINES:
 216             return 0;
 217         }
 218         break;
 219     case PIPE_SHADER_VERTEX:
 220         if (!r300screen->caps.has_tcl) {
 221             return draw_get_shader_param(shader, param);
 222         }
 223
 224         switch (param)
 225         {
 226         case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
 227         case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
 228             return is_r500 ? 1024 : 256;
 229         case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
 230         case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
 231             return 0;
 232         case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
 233             return is_r500 ? 4 : 0; /* For loops; not sure about conditionals. */
 234         case PIPE_SHADER_CAP_MAX_INPUTS:
 235             return 16;
 236         case PIPE_SHADER_CAP_MAX_CONSTS:
 237             return 256;
 238         case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
 239             return 1;
 240         case PIPE_SHADER_CAP_MAX_TEMPS:
 241             return 32;
 242         case PIPE_SHADER_CAP_MAX_ADDRS:
 243             return 1; /* XXX guessed */
 244         case PIPE_SHADER_CAP_MAX_PREDS:
 245             return is_r500 ? 4 : 0; /* XXX guessed. */
 246         case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
 247             return 1;
 248         case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
 249         case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
 250         case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
 251             return 0;
 252         case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
 253             return 1;
 254         case PIPE_SHADER_CAP_SUBROUTINES:
 255             return 0;
 256         default:
 257             break;
 258         }
 259         break;
 260     default:
 261         break;
 262     }
 263     return 0;
 264 }
 265
 266 static float r300_get_paramf(struct pipe_screen* pscreen, enum pipe_cap param)
 267 {
 268     struct r300_screen* r300screen = r300_screen(pscreen);
 269
 270     switch (param) {
 271         case PIPE_CAP_MAX_LINE_WIDTH:
 272         case PIPE_CAP_MAX_LINE_WIDTH_AA:
 273         case PIPE_CAP_MAX_POINT_WIDTH:
 274         case PIPE_CAP_MAX_POINT_WIDTH_AA:
 275             /* The maximum dimensions of the colorbuffer are our practical
 276              * rendering limits. 2048 pixels should be enough for anybody. */
 277             if (r300screen->caps.is_r500) {
 278                 return 4096.0f;
 279             } else if (r300screen->caps.is_r400) {
 280                 return 4021.0f;
 281             } else {
 282                 return 2560.0f;
 283             }
 284         case PIPE_CAP_MAX_TEXTURE_ANISOTROPY:
 285             return 16.0f;
 286         case PIPE_CAP_MAX_TEXTURE_LOD_BIAS:
 287             return 16.0f;
 288         case PIPE_CAP_GUARD_BAND_LEFT:
 289         case PIPE_CAP_GUARD_BAND_TOP:
 290         case PIPE_CAP_GUARD_BAND_RIGHT:
 291         case PIPE_CAP_GUARD_BAND_BOTTOM:
 292             /* XXX I don't know what these should be but the least we can do is
 293              * silence the potential error message */
 294             return 0.0f;
 295         default:
 296             debug_printf("r300: Warning: Unknown CAP %d in get_paramf.\n",
 297                          param);
 298             return 0.0f;
 299     }
 300 }
 301
 302 static boolean r300_is_format_supported(struct pipe_screen* screen,
 303                                         enum pipe_format format,
 304                                         enum pipe_texture_target target,
 305                                         unsigned sample_count,
 306                                         unsigned usage,
 307                                         unsigned geom_flags)
 308 {
 309     struct r300_winsys_screen *rws = r300_screen(screen)->rws;
 310     uint32_t retval = 0;
 311     boolean drm_2_8_0 = rws->get_value(rws, R300_VID_DRM_2_8_0);
 312     boolean is_r500 = r300_screen(screen)->caps.is_r500;
 313     boolean is_r400 = r300_screen(screen)->caps.is_r400;
 314     boolean is_color2101010 = format == PIPE_FORMAT_R10G10B10A2_UNORM ||
 315                               format == PIPE_FORMAT_R10G10B10X2_SNORM ||
 316                               format == PIPE_FORMAT_B10G10R10A2_UNORM ||
 317                               format == PIPE_FORMAT_R10SG10SB10SA2U_NORM;
 318     boolean is_ati1n = format == PIPE_FORMAT_RGTC1_UNORM ||
 319                        format == PIPE_FORMAT_RGTC1_SNORM;
 320     boolean is_ati2n = format == PIPE_FORMAT_RGTC2_UNORM ||
 321                        format == PIPE_FORMAT_RGTC2_SNORM;
 322     boolean is_half_float = format == PIPE_FORMAT_R16_FLOAT ||
 323                             format == PIPE_FORMAT_R16G16_FLOAT ||
 324                             format == PIPE_FORMAT_R16G16B16_FLOAT ||
 325                             format == PIPE_FORMAT_R16G16B16A16_FLOAT;
 326
 327     /* Check multisampling support. */
 328     switch (sample_count) {
 329         case 0:
 330         case 1:
 331             break;
 332         case 2:
 333         case 3:
 334         case 4:
 335         case 6:
 336             return FALSE;
 337 #if 0
 338             if (usage != PIPE_BIND_RENDER_TARGET ||
 339                 !util_format_is_rgba8_variant(
 340                     util_format_description(format))) {
 341                 return FALSE;
 342             }
 343 #endif
 344             break;
 345         default:
 346             return FALSE;
 347     }
 348
 349     /* Check sampler format support. */
 350     if ((usage & PIPE_BIND_SAMPLER_VIEW) &&
 351         /* ATI1N is r5xx-only. */
 352         (is_r500 || !is_ati1n) &&
 353         /* ATI2N is supported on r4xx-r5xx. */
 354         (is_r400 || is_r500 || !is_ati2n) &&
 355         r300_is_sampler_format_supported(format)) {
 356         retval |= PIPE_BIND_SAMPLER_VIEW;
 357     }
 358
 359     /* Check colorbuffer format support. */
 360     if ((usage & (PIPE_BIND_RENDER_TARGET |
 361                   PIPE_BIND_DISPLAY_TARGET |
 362                   PIPE_BIND_SCANOUT |
 363                   PIPE_BIND_SHARED)) &&
 364         /* 2101010 cannot be rendered to on non-r5xx. */
 365         (!is_color2101010 || (is_r500 && drm_2_8_0)) &&
 366         r300_is_colorbuffer_format_supported(format)) {
 367         retval |= usage &
 368             (PIPE_BIND_RENDER_TARGET |
 369              PIPE_BIND_DISPLAY_TARGET |
 370              PIPE_BIND_SCANOUT |
 371              PIPE_BIND_SHARED);
 372     }
 373
 374     /* Check depth-stencil format support. */
 375     if (usage & PIPE_BIND_DEPTH_STENCIL &&
 376         r300_is_zs_format_supported(format)) {
 377         retval |= PIPE_BIND_DEPTH_STENCIL;
 378     }
 379
 380     /* Check vertex buffer format support. */
 381     if (usage & PIPE_BIND_VERTEX_BUFFER &&
 382         /* Half float is supported on >= RV350. */
 383         (is_r400 || is_r500 || !is_half_float) &&
 384         r300_translate_vertex_data_type(format) != R300_INVALID_FORMAT) {
 385         retval |= PIPE_BIND_VERTEX_BUFFER;
 386     }
 387
 388     /* Transfers are always supported. */
 389     if (usage & PIPE_BIND_TRANSFER_READ)
 390         retval |= PIPE_BIND_TRANSFER_READ;
 391     if (usage & PIPE_BIND_TRANSFER_WRITE)
 392         retval |= PIPE_BIND_TRANSFER_WRITE;
 393
 394     return retval == usage;
 395 }
 396
 397 static void r300_destroy_screen(struct pipe_screen* pscreen)
 398 {
 399     struct r300_screen* r300screen = r300_screen(pscreen);
 400     struct r300_winsys_screen *rws = r300_winsys_screen(pscreen);
 401
 402     util_slab_destroy(&r300screen->pool_buffers);
 403
 404     if (rws)
 405       rws->destroy(rws);
 406
 407     FREE(r300screen);
 408 }
 409
 410 static void r300_fence_reference(struct pipe_screen *screen,
 411                                  struct pipe_fence_handle **ptr,
 412                                  struct pipe_fence_handle *fence)
 413 {
 414     struct r300_fence **oldf = (struct r300_fence**)ptr;
 415     struct r300_fence *newf = (struct r300_fence*)fence;
 416
 417     if (pipe_reference(&(*oldf)->reference, &newf->reference))
 418         FREE(*oldf);
 419
 420     *ptr = fence;
 421 }
 422
 423 static int r300_fence_signalled(struct pipe_screen *screen,
 424                                 struct pipe_fence_handle *fence,
 425                                 unsigned flags)
 426 {
 427     struct r300_fence *rfence = (struct r300_fence*)fence;
 428
 429     return rfence->signalled ? 0 : 1; /* 0 == success */
 430 }
 431
 432 static int r300_fence_finish(struct pipe_screen *screen,
 433                              struct pipe_fence_handle *fence,
 434                              unsigned flags)
 435 {
 436     struct r300_fence *rfence = (struct r300_fence*)fence;
 437
 438     r300_finish(rfence->ctx);
 439     rfence->signalled = TRUE;
 440     return 0; /* 0 == success */
 441 }
 442
 443 struct pipe_screen* r300_screen_create(struct r300_winsys_screen *rws)
 444 {
 445     struct r300_screen *r300screen = CALLOC_STRUCT(r300_screen);
 446
 447     if (!r300screen) {
 448         FREE(r300screen);
 449         return NULL;
 450     }
 451
 452     r300screen->caps.pci_id = rws->get_value(rws, R300_VID_PCI_ID);
 453     r300screen->caps.num_frag_pipes = rws->get_value(rws, R300_VID_GB_PIPES);
 454     r300screen->caps.num_z_pipes = rws->get_value(rws, R300_VID_Z_PIPES);
 455
 456     r300_init_debug(r300screen);
 457     r300_parse_chipset(&r300screen->caps);
 458
 459     r300screen->caps.index_bias_supported =
 460             r300screen->caps.is_r500 &&
 461             rws->get_value(rws, R300_VID_DRM_2_3_0);
 462
 463     util_slab_create(&r300screen->pool_buffers,
 464                      sizeof(struct r300_buffer), 64,
 465                      UTIL_SLAB_SINGLETHREADED);
 466
 467     r300screen->rws = rws;
 468     r300screen->screen.winsys = (struct pipe_winsys*)rws;
 469     r300screen->screen.destroy = r300_destroy_screen;
 470     r300screen->screen.get_name = r300_get_name;
 471     r300screen->screen.get_vendor = r300_get_vendor;
 472     r300screen->screen.get_param = r300_get_param;
 473     r300screen->screen.get_shader_param = r300_get_shader_param;
 474     r300screen->screen.get_paramf = r300_get_paramf;
 475     r300screen->screen.is_format_supported = r300_is_format_supported;
 476     r300screen->screen.context_create = r300_create_context;
 477
 478     r300screen->screen.fence_reference = r300_fence_reference;
 479     r300screen->screen.fence_signalled = r300_fence_signalled;
 480     r300screen->screen.fence_finish = r300_fence_finish;
 481
 482     r300_init_screen_resource_functions(r300screen);
 483
 484     util_format_s3tc_init();
 485
 486 #ifdef HAVE_LLVM
 487     lp_build_init();
 488 #endif
 489
 490     return &r300screen->screen;
 491 }