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 #include "os/os_time.h"
  28 #include "vl/vl_decoder.h"
  29 #include "vl/vl_video_buffer.h"
  30
  31 #include "r300_context.h"
  32 #include "r300_texture.h"
  33 #include "r300_screen_buffer.h"
  34 #include "r300_state_inlines.h"
  35 #include "r300_public.h"
  36
  37 #include "draw/draw_context.h"
  38
  39 /* Return the identifier behind whom the brave coders responsible for this
  40  * amalgamation of code, sweat, and duct tape, routinely obscure their names.
  41  *
  42  * ...I should have just put "Corbin Simpson", but I'm not that cool.
  43  *
  44  * (Or egotistical. Yet.) */
  45 static const char* r300_get_vendor(struct pipe_screen* pscreen)
  46 {
  47     return "X.Org R300 Project";
  48 }
  49
  50 static const char* chip_families[] = {
  51     "unknown",
  52     "ATI R300",
  53     "ATI R350",
  54     "ATI RV350",
  55     "ATI RV370",
  56     "ATI RV380",
  57     "ATI RS400",
  58     "ATI RC410",
  59     "ATI RS480",
  60     "ATI R420",
  61     "ATI R423",
  62     "ATI R430",
  63     "ATI R480",
  64     "ATI R481",
  65     "ATI RV410",
  66     "ATI RS600",
  67     "ATI RS690",
  68     "ATI RS740",
  69     "ATI RV515",
  70     "ATI R520",
  71     "ATI RV530",
  72     "ATI R580",
  73     "ATI RV560",
  74     "ATI RV570"
  75 };
  76
  77 static const char* r300_get_name(struct pipe_screen* pscreen)
  78 {
  79     struct r300_screen* r300screen = r300_screen(pscreen);
  80
  81     return chip_families[r300screen->caps.family];
  82 }
  83
  84 static int r300_get_param(struct pipe_screen* pscreen, enum pipe_cap param)
  85 {
  86     struct r300_screen* r300screen = r300_screen(pscreen);
  87     boolean is_r500 = r300screen->caps.is_r500;
  88
  89     switch (param) {
  90         /* Supported features (boolean caps). */
  91         case PIPE_CAP_NPOT_TEXTURES:
  92         case PIPE_CAP_MIXED_FRAMEBUFFER_SIZES:
  93         case PIPE_CAP_TWO_SIDED_STENCIL:
  94         case PIPE_CAP_ANISOTROPIC_FILTER:
  95         case PIPE_CAP_POINT_SPRITE:
  96         case PIPE_CAP_OCCLUSION_QUERY:
  97         case PIPE_CAP_TEXTURE_SHADOW_MAP:
  98         case PIPE_CAP_TEXTURE_MIRROR_CLAMP:
  99         case PIPE_CAP_BLEND_EQUATION_SEPARATE:
 100         case PIPE_CAP_VERTEX_ELEMENT_INSTANCE_DIVISOR:
 101         case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
 102         case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
 103         case PIPE_CAP_CONDITIONAL_RENDER:
 104         case PIPE_CAP_TEXTURE_BARRIER:
 105         case PIPE_CAP_TGSI_CAN_COMPACT_CONSTANTS:
 106         case PIPE_CAP_USER_INDEX_BUFFERS:
 107         case PIPE_CAP_USER_CONSTANT_BUFFERS:
 108         case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
 109         case PIPE_CAP_BUFFER_MAP_PERSISTENT_COHERENT:
 110             return 1;
 111
 112         case PIPE_CAP_MIN_MAP_BUFFER_ALIGNMENT:
 113             return R300_BUFFER_ALIGNMENT;
 114
 115         case PIPE_CAP_CONSTANT_BUFFER_OFFSET_ALIGNMENT:
 116             return 16;
 117
 118         case PIPE_CAP_GLSL_FEATURE_LEVEL:
 119             return 120;
 120
 121         /* r300 cannot do swizzling of compressed textures. Supported otherwise. */
 122         case PIPE_CAP_TEXTURE_SWIZZLE:
 123             return util_format_s3tc_enabled ? r300screen->caps.dxtc_swizzle : 1;
 124
 125         /* We don't support color clamping on r500, so that we can use color
 126          * intepolators for generic varyings. */
 127         case PIPE_CAP_VERTEX_COLOR_CLAMPED:
 128             return !is_r500;
 129
 130         /* Supported on r500 only. */
 131         case PIPE_CAP_VERTEX_COLOR_UNCLAMPED:
 132         case PIPE_CAP_MIXED_COLORBUFFER_FORMATS:
 133         case PIPE_CAP_SM3:
 134             return is_r500 ? 1 : 0;
 135
 136         /* Unsupported features. */
 137         case PIPE_CAP_QUERY_TIME_ELAPSED:
 138         case PIPE_CAP_QUERY_PIPELINE_STATISTICS:
 139         case PIPE_CAP_MAX_DUAL_SOURCE_RENDER_TARGETS:
 140         case PIPE_CAP_INDEP_BLEND_ENABLE:
 141         case PIPE_CAP_INDEP_BLEND_FUNC:
 142         case PIPE_CAP_DEPTH_CLIP_DISABLE:
 143         case PIPE_CAP_SHADER_STENCIL_EXPORT:
 144         case PIPE_CAP_MAX_TEXTURE_ARRAY_LAYERS:
 145         case PIPE_CAP_TGSI_INSTANCEID:
 146         case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
 147         case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
 148         case PIPE_CAP_SEAMLESS_CUBE_MAP:
 149         case PIPE_CAP_SEAMLESS_CUBE_MAP_PER_TEXTURE:
 150         case PIPE_CAP_MIN_TEXEL_OFFSET:
 151         case PIPE_CAP_MAX_TEXEL_OFFSET:
 152         case PIPE_CAP_MIN_TEXTURE_GATHER_OFFSET:
 153         case PIPE_CAP_MAX_TEXTURE_GATHER_OFFSET:
 154         case PIPE_CAP_MAX_STREAM_OUTPUT_BUFFERS:
 155         case PIPE_CAP_MAX_STREAM_OUTPUT_SEPARATE_COMPONENTS:
 156         case PIPE_CAP_MAX_STREAM_OUTPUT_INTERLEAVED_COMPONENTS:
 157         case PIPE_CAP_MAX_GEOMETRY_OUTPUT_VERTICES:
 158         case PIPE_CAP_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS:
 159         case PIPE_CAP_MAX_VERTEX_STREAMS:
 160         case PIPE_CAP_STREAM_OUTPUT_PAUSE_RESUME:
 161         case PIPE_CAP_FRAGMENT_COLOR_CLAMPED:
 162         case PIPE_CAP_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION:
 163         case PIPE_CAP_COMPUTE:
 164         case PIPE_CAP_START_INSTANCE:
 165         case PIPE_CAP_QUERY_TIMESTAMP:
 166         case PIPE_CAP_TEXTURE_MULTISAMPLE:
 167         case PIPE_CAP_CUBE_MAP_ARRAY:
 168         case PIPE_CAP_TEXTURE_BUFFER_OBJECTS:
 169         case PIPE_CAP_TEXTURE_BUFFER_OFFSET_ALIGNMENT:
 170         case PIPE_CAP_TEXTURE_BORDER_COLOR_QUIRK:
 171         case PIPE_CAP_MAX_TEXTURE_BUFFER_SIZE:
 172         case PIPE_CAP_TGSI_VS_LAYER_VIEWPORT:
 173         case PIPE_CAP_MAX_TEXTURE_GATHER_COMPONENTS:
 174         case PIPE_CAP_TEXTURE_GATHER_SM5:
 175         case PIPE_CAP_TEXTURE_QUERY_LOD:
 176         case PIPE_CAP_FAKE_SW_MSAA:
 177         case PIPE_CAP_SAMPLE_SHADING:
 178         case PIPE_CAP_TEXTURE_GATHER_OFFSETS:
 179         case PIPE_CAP_TGSI_VS_WINDOW_SPACE_POSITION:
 180         case PIPE_CAP_DRAW_INDIRECT:
 181             return 0;
 182
 183         /* SWTCL-only features. */
 184         case PIPE_CAP_PRIMITIVE_RESTART:
 185         case PIPE_CAP_USER_VERTEX_BUFFERS:
 186             return !r300screen->caps.has_tcl;
 187
 188         /* HWTCL-only features / limitations. */
 189         case PIPE_CAP_VERTEX_BUFFER_OFFSET_4BYTE_ALIGNED_ONLY:
 190         case PIPE_CAP_VERTEX_BUFFER_STRIDE_4BYTE_ALIGNED_ONLY:
 191         case PIPE_CAP_VERTEX_ELEMENT_SRC_OFFSET_4BYTE_ALIGNED_ONLY:
 192             return r300screen->caps.has_tcl;
 193         case PIPE_CAP_TGSI_TEXCOORD:
 194             return 0;
 195
 196         /* Texturing. */
 197         case PIPE_CAP_MAX_TEXTURE_2D_LEVELS:
 198         case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
 199         case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
 200             /* 13 == 4096, 12 == 2048 */
 201             return is_r500 ? 13 : 12;
 202
 203         /* Render targets. */
 204         case PIPE_CAP_MAX_RENDER_TARGETS:
 205             return 4;
 206         case PIPE_CAP_ENDIANNESS:
 207             return PIPE_ENDIAN_LITTLE;
 208
 209         case PIPE_CAP_MAX_VIEWPORTS:
 210             return 1;
 211     }
 212     return 0;
 213 }
 214
 215 static int r300_get_shader_param(struct pipe_screen *pscreen, unsigned shader, enum pipe_shader_cap param)
 216 {
 217    struct r300_screen* r300screen = r300_screen(pscreen);
 218    boolean is_r400 = r300screen->caps.is_r400;
 219    boolean is_r500 = r300screen->caps.is_r500;
 220
 221    switch (shader) {
 222     case PIPE_SHADER_FRAGMENT:
 223         switch (param)
 224         {
 225         case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
 226             return is_r500 || is_r400 ? 512 : 96;
 227         case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
 228             return is_r500 || is_r400 ? 512 : 64;
 229         case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
 230             return is_r500 || is_r400 ? 512 : 32;
 231         case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
 232             return is_r500 ? 511 : 4;
 233         case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
 234             return is_r500 ? 64 : 0; /* Actually unlimited on r500. */
 235             /* Fragment shader limits. */
 236         case PIPE_SHADER_CAP_MAX_INPUTS:
 237             /* 2 colors + 8 texcoords are always supported
 238              * (minus fog and wpos).
 239              *
 240              * R500 has the ability to turn 3rd and 4th color into
 241              * additional texcoords but there is no two-sided color
 242              * selection then. However the facing bit can be used instead. */
 243             return 10;
 244         case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
 245             return (is_r500 ? 256 : 32) * sizeof(float[4]);
 246         case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
 247             return 1;
 248         case PIPE_SHADER_CAP_MAX_TEMPS:
 249             return is_r500 ? 128 : is_r400 ? 64 : 32;
 250         case PIPE_SHADER_CAP_MAX_PREDS:
 251             return is_r500 ? 1 : 0;
 252         case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
 253         case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
 254            return r300screen->caps.num_tex_units;
 255         case PIPE_SHADER_CAP_MAX_ADDRS:
 256         case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
 257         case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
 258         case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
 259         case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
 260         case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
 261         case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
 262         case PIPE_SHADER_CAP_SUBROUTINES:
 263         case PIPE_SHADER_CAP_INTEGERS:
 264             return 0;
 265         case PIPE_SHADER_CAP_PREFERRED_IR:
 266             return PIPE_SHADER_IR_TGSI;
 267         }
 268         break;
 269     case PIPE_SHADER_VERTEX:
 270         switch (param)
 271         {
 272         case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
 273         case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
 274         case PIPE_SHADER_CAP_SUBROUTINES:
 275             return 0;
 276         default:;
 277         }
 278
 279         if (!r300screen->caps.has_tcl) {
 280             return draw_get_shader_param(shader, param);
 281         }
 282
 283         switch (param)
 284         {
 285         case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
 286         case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
 287             return is_r500 ? 1024 : 256;
 288         case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
 289             return is_r500 ? 4 : 0; /* For loops; not sure about conditionals. */
 290         case PIPE_SHADER_CAP_MAX_INPUTS:
 291             return 16;
 292         case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
 293             return 256 * sizeof(float[4]);
 294         case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
 295             return 1;
 296         case PIPE_SHADER_CAP_MAX_TEMPS:
 297             return 32;
 298         case PIPE_SHADER_CAP_MAX_ADDRS:
 299             return 1; /* XXX guessed */
 300         case PIPE_SHADER_CAP_MAX_PREDS:
 301             return is_r500 ? 4 : 0; /* XXX guessed. */
 302         case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
 303             return 1;
 304         case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
 305         case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
 306         case PIPE_SHADER_CAP_TGSI_CONT_SUPPORTED:
 307         case PIPE_SHADER_CAP_TGSI_SQRT_SUPPORTED:
 308         case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
 309         case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
 310         case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
 311         case PIPE_SHADER_CAP_SUBROUTINES:
 312         case PIPE_SHADER_CAP_INTEGERS:
 313         case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
 314         case PIPE_SHADER_CAP_MAX_SAMPLER_VIEWS:
 315             return 0;
 316         case PIPE_SHADER_CAP_PREFERRED_IR:
 317             return PIPE_SHADER_IR_TGSI;
 318         }
 319         break;
 320     }
 321     return 0;
 322 }
 323
 324 static float r300_get_paramf(struct pipe_screen* pscreen,
 325                              enum pipe_capf param)
 326 {
 327     struct r300_screen* r300screen = r300_screen(pscreen);
 328
 329     switch (param) {
 330         case PIPE_CAPF_MAX_LINE_WIDTH:
 331         case PIPE_CAPF_MAX_LINE_WIDTH_AA:
 332         case PIPE_CAPF_MAX_POINT_WIDTH:
 333         case PIPE_CAPF_MAX_POINT_WIDTH_AA:
 334             /* The maximum dimensions of the colorbuffer are our practical
 335              * rendering limits. 2048 pixels should be enough for anybody. */
 336             if (r300screen->caps.is_r500) {
 337                 return 4096.0f;
 338             } else if (r300screen->caps.is_r400) {
 339                 return 4021.0f;
 340             } else {
 341                 return 2560.0f;
 342             }
 343         case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
 344             return 16.0f;
 345         case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
 346             return 16.0f;
 347         case PIPE_CAPF_GUARD_BAND_LEFT:
 348         case PIPE_CAPF_GUARD_BAND_TOP:
 349         case PIPE_CAPF_GUARD_BAND_RIGHT:
 350         case PIPE_CAPF_GUARD_BAND_BOTTOM:
 351             /* XXX I don't know what these should be but the least we can do is
 352              * silence the potential error message */
 353             return 0.0f;
 354         default:
 355             debug_printf("r300: Warning: Unknown CAP %d in get_paramf.\n",
 356                          param);
 357             return 0.0f;
 358     }
 359 }
 360
 361 static int r300_get_video_param(struct pipe_screen *screen,
 362                                 enum pipe_video_profile profile,
 363                                 enum pipe_video_entrypoint entrypoint,
 364                                 enum pipe_video_cap param)
 365 {
 366    switch (param) {
 367       case PIPE_VIDEO_CAP_SUPPORTED:
 368          return vl_profile_supported(screen, profile, entrypoint);
 369       case PIPE_VIDEO_CAP_NPOT_TEXTURES:
 370          return 0;
 371       case PIPE_VIDEO_CAP_MAX_WIDTH:
 372       case PIPE_VIDEO_CAP_MAX_HEIGHT:
 373          return vl_video_buffer_max_size(screen);
 374       case PIPE_VIDEO_CAP_PREFERED_FORMAT:
 375          return PIPE_FORMAT_NV12;
 376       case PIPE_VIDEO_CAP_PREFERS_INTERLACED:
 377          return false;
 378       case PIPE_VIDEO_CAP_SUPPORTS_INTERLACED:
 379          return false;
 380       case PIPE_VIDEO_CAP_SUPPORTS_PROGRESSIVE:
 381          return true;
 382       case PIPE_VIDEO_CAP_MAX_LEVEL:
 383          return vl_level_supported(screen, profile);
 384       default:
 385          return 0;
 386    }
 387 }
 388
 389 /**
 390  * Whether the format matches:
 391  *   PIPE_FORMAT_?10?10?10?2_UNORM
 392  */
 393 static INLINE boolean
 394 util_format_is_rgba1010102_variant(const struct util_format_description *desc)
 395 {
 396    static const unsigned size[4] = {10, 10, 10, 2};
 397    unsigned chan;
 398
 399    if (desc->block.width != 1 ||
 400        desc->block.height != 1 ||
 401        desc->block.bits != 32)
 402       return FALSE;
 403
 404    for (chan = 0; chan < 4; ++chan) {
 405       if(desc->channel[chan].type != UTIL_FORMAT_TYPE_UNSIGNED &&
 406          desc->channel[chan].type != UTIL_FORMAT_TYPE_VOID)
 407          return FALSE;
 408       if (desc->channel[chan].size != size[chan])
 409          return FALSE;
 410    }
 411
 412    return TRUE;
 413 }
 414
 415 static boolean r300_is_format_supported(struct pipe_screen* screen,
 416                                         enum pipe_format format,
 417                                         enum pipe_texture_target target,
 418                                         unsigned sample_count,
 419                                         unsigned usage)
 420 {
 421     uint32_t retval = 0;
 422     boolean drm_2_8_0 = r300_screen(screen)->info.drm_minor >= 8;
 423     boolean is_r500 = r300_screen(screen)->caps.is_r500;
 424     boolean is_r400 = r300_screen(screen)->caps.is_r400;
 425     boolean is_color2101010 = format == PIPE_FORMAT_R10G10B10A2_UNORM ||
 426                               format == PIPE_FORMAT_R10G10B10X2_SNORM ||
 427                               format == PIPE_FORMAT_B10G10R10A2_UNORM ||
 428                               format == PIPE_FORMAT_B10G10R10X2_UNORM ||
 429                               format == PIPE_FORMAT_R10SG10SB10SA2U_NORM;
 430     boolean is_ati1n = format == PIPE_FORMAT_RGTC1_UNORM ||
 431                        format == PIPE_FORMAT_RGTC1_SNORM ||
 432                        format == PIPE_FORMAT_LATC1_UNORM ||
 433                        format == PIPE_FORMAT_LATC1_SNORM;
 434     boolean is_ati2n = format == PIPE_FORMAT_RGTC2_UNORM ||
 435                        format == PIPE_FORMAT_RGTC2_SNORM ||
 436                        format == PIPE_FORMAT_LATC2_UNORM ||
 437                        format == PIPE_FORMAT_LATC2_SNORM;
 438     boolean is_x16f_xy16f = format == PIPE_FORMAT_R16_FLOAT ||
 439                             format == PIPE_FORMAT_R16G16_FLOAT ||
 440                             format == PIPE_FORMAT_A16_FLOAT ||
 441                             format == PIPE_FORMAT_L16_FLOAT ||
 442                             format == PIPE_FORMAT_L16A16_FLOAT ||
 443                             format == PIPE_FORMAT_R16A16_FLOAT ||
 444                             format == PIPE_FORMAT_I16_FLOAT;
 445     boolean is_half_float = format == PIPE_FORMAT_R16_FLOAT ||
 446                             format == PIPE_FORMAT_R16G16_FLOAT ||
 447                             format == PIPE_FORMAT_R16G16B16_FLOAT ||
 448                             format == PIPE_FORMAT_R16G16B16A16_FLOAT ||
 449                             format == PIPE_FORMAT_R16G16B16X16_FLOAT;
 450     const struct util_format_description *desc;
 451
 452     if (!util_format_is_supported(format, usage))
 453        return FALSE;
 454
 455     /* Check multisampling support. */
 456     switch (sample_count) {
 457         case 0:
 458         case 1:
 459             break;
 460         case 2:
 461         case 4:
 462         case 6:
 463             /* We need DRM 2.8.0. */
 464             if (!drm_2_8_0) {
 465                 return FALSE;
 466             }
 467             /* No texturing and scanout. */
 468             if (usage & (PIPE_BIND_SAMPLER_VIEW |
 469                          PIPE_BIND_DISPLAY_TARGET |
 470                          PIPE_BIND_SCANOUT)) {
 471                 return FALSE;
 472             }
 473
 474             desc = util_format_description(format);
 475
 476             if (is_r500) {
 477                 /* Only allow depth/stencil, RGBA8, RGBA1010102, RGBA16F. */
 478                 if (!util_format_is_depth_or_stencil(format) &&
 479                     !util_format_is_rgba8_variant(desc) &&
 480                     !util_format_is_rgba1010102_variant(desc) &&
 481                     format != PIPE_FORMAT_R16G16B16A16_FLOAT &&
 482                     format != PIPE_FORMAT_R16G16B16X16_FLOAT) {
 483                     return FALSE;
 484                 }
 485             } else {
 486                 /* Only allow depth/stencil, RGBA8. */
 487                 if (!util_format_is_depth_or_stencil(format) &&
 488                     !util_format_is_rgba8_variant(desc)) {
 489                     return FALSE;
 490                 }
 491             }
 492             break;
 493         default:
 494             return FALSE;
 495     }
 496
 497     /* Check sampler format support. */
 498     if ((usage & PIPE_BIND_SAMPLER_VIEW) &&
 499         /* these two are broken for an unknown reason */
 500         format != PIPE_FORMAT_R8G8B8X8_SNORM &&
 501         format != PIPE_FORMAT_R16G16B16X16_SNORM &&
 502         /* ATI1N is r5xx-only. */
 503         (is_r500 || !is_ati1n) &&
 504         /* ATI2N is supported on r4xx-r5xx. */
 505         (is_r400 || is_r500 || !is_ati2n) &&
 506         /* R16F and RG16F texture support was added in as late as DRM 2.8.0 */
 507         (drm_2_8_0 || !is_x16f_xy16f) &&
 508         r300_is_sampler_format_supported(format)) {
 509         retval |= PIPE_BIND_SAMPLER_VIEW;
 510     }
 511
 512     /* Check colorbuffer format support. */
 513     if ((usage & (PIPE_BIND_RENDER_TARGET |
 514                   PIPE_BIND_DISPLAY_TARGET |
 515                   PIPE_BIND_SCANOUT |
 516                   PIPE_BIND_SHARED)) &&
 517         /* 2101010 cannot be rendered to on non-r5xx. */
 518         (!is_color2101010 || (is_r500 && drm_2_8_0)) &&
 519         r300_is_colorbuffer_format_supported(format)) {
 520         retval |= usage &
 521             (PIPE_BIND_RENDER_TARGET |
 522              PIPE_BIND_DISPLAY_TARGET |
 523              PIPE_BIND_SCANOUT |
 524              PIPE_BIND_SHARED);
 525     }
 526
 527     /* Check depth-stencil format support. */
 528     if (usage & PIPE_BIND_DEPTH_STENCIL &&
 529         r300_is_zs_format_supported(format)) {
 530         retval |= PIPE_BIND_DEPTH_STENCIL;
 531     }
 532
 533     /* Check vertex buffer format support. */
 534     if (usage & PIPE_BIND_VERTEX_BUFFER) {
 535         if (r300_screen(screen)->caps.has_tcl) {
 536             /* Half float is supported on >= R400. */
 537             if ((is_r400 || is_r500 || !is_half_float) &&
 538                 r300_translate_vertex_data_type(format) != R300_INVALID_FORMAT) {
 539                 retval |= PIPE_BIND_VERTEX_BUFFER;
 540             }
 541         } else {
 542             /* SW TCL */
 543             if (!util_format_is_pure_integer(format)) {
 544                 retval |= PIPE_BIND_VERTEX_BUFFER;
 545             }
 546         }
 547     }
 548
 549     /* Transfers are always supported. */
 550     if (usage & PIPE_BIND_TRANSFER_READ)
 551         retval |= PIPE_BIND_TRANSFER_READ;
 552     if (usage & PIPE_BIND_TRANSFER_WRITE)
 553         retval |= PIPE_BIND_TRANSFER_WRITE;
 554
 555     return retval == usage;
 556 }
 557
 558 static void r300_destroy_screen(struct pipe_screen* pscreen)
 559 {
 560     struct r300_screen* r300screen = r300_screen(pscreen);
 561     struct radeon_winsys *rws = radeon_winsys(pscreen);
 562
 563     if (rws && !rws->unref(rws))
 564       return;
 565
 566     pipe_mutex_destroy(r300screen->cmask_mutex);
 567
 568     if (rws)
 569       rws->destroy(rws);
 570
 571     FREE(r300screen);
 572 }
 573
 574 static void r300_fence_reference(struct pipe_screen *screen,
 575                                  struct pipe_fence_handle **ptr,
 576                                  struct pipe_fence_handle *fence)
 577 {
 578     struct radeon_winsys *rws = r300_screen(screen)->rws;
 579
 580     rws->fence_reference(ptr, fence);
 581 }
 582
 583 static boolean r300_fence_signalled(struct pipe_screen *screen,
 584                                     struct pipe_fence_handle *fence)
 585 {
 586     struct radeon_winsys *rws = r300_screen(screen)->rws;
 587
 588     return rws->fence_wait(rws, fence, 0);
 589 }
 590
 591 static boolean r300_fence_finish(struct pipe_screen *screen,
 592                                  struct pipe_fence_handle *fence,
 593                                  uint64_t timeout)
 594 {
 595     struct radeon_winsys *rws = r300_screen(screen)->rws;
 596
 597     return rws->fence_wait(rws, fence, timeout);
 598 }
 599
 600 struct pipe_screen* r300_screen_create(struct radeon_winsys *rws)
 601 {
 602     struct r300_screen *r300screen = CALLOC_STRUCT(r300_screen);
 603
 604     if (!r300screen) {
 605         FREE(r300screen);
 606         return NULL;
 607     }
 608
 609     rws->query_info(rws, &r300screen->info);
 610
 611     r300_init_debug(r300screen);
 612     r300_parse_chipset(r300screen->info.pci_id, &r300screen->caps);
 613
 614     if (SCREEN_DBG_ON(r300screen, DBG_NO_ZMASK))
 615         r300screen->caps.zmask_ram = 0;
 616     if (SCREEN_DBG_ON(r300screen, DBG_NO_HIZ))
 617         r300screen->caps.hiz_ram = 0;
 618
 619     if (r300screen->info.drm_minor < 8)
 620         r300screen->caps.has_us_format = FALSE;
 621
 622     r300screen->rws = rws;
 623     r300screen->screen.destroy = r300_destroy_screen;
 624     r300screen->screen.get_name = r300_get_name;
 625     r300screen->screen.get_vendor = r300_get_vendor;
 626     r300screen->screen.get_param = r300_get_param;
 627     r300screen->screen.get_shader_param = r300_get_shader_param;
 628     r300screen->screen.get_paramf = r300_get_paramf;
 629     r300screen->screen.get_video_param = r300_get_video_param;
 630     r300screen->screen.is_format_supported = r300_is_format_supported;
 631     r300screen->screen.is_video_format_supported = vl_video_buffer_is_format_supported;
 632     r300screen->screen.context_create = r300_create_context;
 633     r300screen->screen.fence_reference = r300_fence_reference;
 634     r300screen->screen.fence_signalled = r300_fence_signalled;
 635     r300screen->screen.fence_finish = r300_fence_finish;
 636
 637     r300_init_screen_resource_functions(r300screen);
 638
 639     util_format_s3tc_init();
 640     pipe_mutex_init(r300screen->cmask_mutex);
 641
 642     return &r300screen->screen;
 643 }