src/gallium/drivers/lima/lima_screen.c

   1 /*
   2  * Copyright (c) 2017-2019 Lima Project
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sub license,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the
  12  * next paragraph) shall be included in all copies or substantial portions
  13  * of the Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  21  * DEALINGS IN THE SOFTWARE.
  22  *
  23  */
  24
  25 #include <string.h>
  26
  27 #include "util/ralloc.h"
  28 #include "util/u_debug.h"
  29 #include "util/u_screen.h"
  30 #include "renderonly/renderonly.h"
  31
  32 #include "drm-uapi/drm_fourcc.h"
  33 #include "drm-uapi/lima_drm.h"
  34
  35 #include "lima_screen.h"
  36 #include "lima_context.h"
  37 #include "lima_resource.h"
  38 #include "lima_program.h"
  39 #include "lima_bo.h"
  40 #include "lima_fence.h"
  41 #include "lima_format.h"
  42 #include "ir/lima_ir.h"
  43
  44 #include "xf86drm.h"
  45
  46 int lima_plb_max_blk = 0;
  47 int lima_plb_pp_stream_cache_size = 0;
  48
  49 static void
  50 lima_screen_destroy(struct pipe_screen *pscreen)
  51 {
  52    struct lima_screen *screen = lima_screen(pscreen);
  53
  54    slab_destroy_parent(&screen->transfer_pool);
  55
  56    if (screen->ro)
  57       free(screen->ro);
  58
  59    if (screen->pp_buffer)
  60       lima_bo_unreference(screen->pp_buffer);
  61
  62    lima_bo_cache_fini(screen);
  63    lima_bo_table_fini(screen);
  64    ralloc_free(screen);
  65 }
  66
  67 static const char *
  68 lima_screen_get_name(struct pipe_screen *pscreen)
  69 {
  70    struct lima_screen *screen = lima_screen(pscreen);
  71
  72    switch (screen->gpu_type) {
  73    case DRM_LIMA_PARAM_GPU_ID_MALI400:
  74      return "Mali400";
  75    case DRM_LIMA_PARAM_GPU_ID_MALI450:
  76      return "Mali450";
  77    }
  78
  79    return NULL;
  80 }
  81
  82 static const char *
  83 lima_screen_get_vendor(struct pipe_screen *pscreen)
  84 {
  85    return "lima";
  86 }
  87
  88 static const char *
  89 lima_screen_get_device_vendor(struct pipe_screen *pscreen)
  90 {
  91    return "ARM";
  92 }
  93
  94 static int
  95 lima_screen_get_param(struct pipe_screen *pscreen, enum pipe_cap param)
  96 {
  97    switch (param) {
  98    case PIPE_CAP_NPOT_TEXTURES:
  99    case PIPE_CAP_BLEND_EQUATION_SEPARATE:
 100    case PIPE_CAP_ACCELERATED:
 101    case PIPE_CAP_UMA:
 102    case PIPE_CAP_NATIVE_FENCE_FD:
 103    case PIPE_CAP_FRAGMENT_SHADER_TEXTURE_LOD:
 104       return 1;
 105
 106    /* Unimplemented, but for exporting OpenGL 2.0 */
 107    case PIPE_CAP_OCCLUSION_QUERY:
 108    case PIPE_CAP_POINT_SPRITE:
 109       return 1;
 110
 111    /* not clear supported */
 112    case PIPE_CAP_TGSI_FS_COORD_ORIGIN_UPPER_LEFT:
 113    case PIPE_CAP_TGSI_FS_COORD_ORIGIN_LOWER_LEFT:
 114    case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_INTEGER:
 115    case PIPE_CAP_TGSI_FS_COORD_PIXEL_CENTER_HALF_INTEGER:
 116       return 1;
 117
 118    case PIPE_CAP_TGSI_FS_POSITION_IS_SYSVAL:
 119    case PIPE_CAP_TGSI_FS_POINT_IS_SYSVAL:
 120    case PIPE_CAP_TGSI_FS_FACE_IS_INTEGER_SYSVAL:
 121       return 1;
 122
 123    case PIPE_CAP_MAX_TEXTURE_2D_SIZE:
 124       return 1 << (LIMA_MAX_MIP_LEVELS - 1);
 125    case PIPE_CAP_MAX_TEXTURE_3D_LEVELS:
 126    case PIPE_CAP_MAX_TEXTURE_CUBE_LEVELS:
 127       return LIMA_MAX_MIP_LEVELS;
 128
 129    case PIPE_CAP_VENDOR_ID:
 130       return 0x13B5;
 131
 132    case PIPE_CAP_VIDEO_MEMORY:
 133       return 0;
 134
 135    case PIPE_CAP_PCI_GROUP:
 136    case PIPE_CAP_PCI_BUS:
 137    case PIPE_CAP_PCI_DEVICE:
 138    case PIPE_CAP_PCI_FUNCTION:
 139       return 0;
 140
 141    case PIPE_CAP_PREFER_BLIT_BASED_TEXTURE_TRANSFER:
 142       return 0;
 143
 144    case PIPE_CAP_ALPHA_TEST:
 145    case PIPE_CAP_FLATSHADE:
 146    case PIPE_CAP_TWO_SIDED_COLOR:
 147    case PIPE_CAP_CLIP_PLANES:
 148       return 0;
 149
 150    case PIPE_CAP_FRAGMENT_SHADER_DERIVATIVES:
 151       return 1;
 152
 153    default:
 154       return u_pipe_screen_get_param_defaults(pscreen, param);
 155    }
 156 }
 157
 158 static float
 159 lima_screen_get_paramf(struct pipe_screen *pscreen, enum pipe_capf param)
 160 {
 161    switch (param) {
 162    case PIPE_CAPF_MAX_LINE_WIDTH:
 163    case PIPE_CAPF_MAX_LINE_WIDTH_AA:
 164    case PIPE_CAPF_MAX_POINT_WIDTH:
 165    case PIPE_CAPF_MAX_POINT_WIDTH_AA:
 166       return 100.0f;
 167    case PIPE_CAPF_MAX_TEXTURE_ANISOTROPY:
 168       return 16.0f;
 169    case PIPE_CAPF_MAX_TEXTURE_LOD_BIAS:
 170       return 15.0f;
 171
 172    default:
 173       return 0.0f;
 174    }
 175 }
 176
 177 static int
 178 get_vertex_shader_param(struct lima_screen *screen,
 179                         enum pipe_shader_cap param)
 180 {
 181    switch (param) {
 182    case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
 183    case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
 184    case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
 185    case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
 186       return 16384; /* need investigate */
 187
 188    case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
 189       return 1024;
 190
 191    case PIPE_SHADER_CAP_MAX_INPUTS:
 192       return 16; /* attributes */
 193
 194    case PIPE_SHADER_CAP_MAX_OUTPUTS:
 195       return LIMA_MAX_VARYING_NUM; /* varying */
 196
 197    case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
 198       return 16 * 1024 * sizeof(float);
 199
 200    case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
 201       return 1;
 202
 203    case PIPE_SHADER_CAP_PREFERRED_IR:
 204       return PIPE_SHADER_IR_NIR;
 205
 206    case PIPE_SHADER_CAP_MAX_TEMPS:
 207       return 256; /* need investigate */
 208
 209    case PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT:
 210       return 32;
 211
 212    default:
 213       return 0;
 214    }
 215 }
 216
 217 static int
 218 get_fragment_shader_param(struct lima_screen *screen,
 219                           enum pipe_shader_cap param)
 220 {
 221    switch (param) {
 222    case PIPE_SHADER_CAP_MAX_INSTRUCTIONS:
 223    case PIPE_SHADER_CAP_MAX_ALU_INSTRUCTIONS:
 224    case PIPE_SHADER_CAP_MAX_TEX_INSTRUCTIONS:
 225    case PIPE_SHADER_CAP_MAX_TEX_INDIRECTIONS:
 226       return 16384; /* need investigate */
 227
 228    case PIPE_SHADER_CAP_MAX_INPUTS:
 229       return LIMA_MAX_VARYING_NUM - 1; /* varying, minus gl_Position */
 230
 231    case PIPE_SHADER_CAP_MAX_CONTROL_FLOW_DEPTH:
 232       return 1024;
 233
 234    case PIPE_SHADER_CAP_MAX_CONST_BUFFER_SIZE:
 235       return 16 * 1024 * sizeof(float);
 236
 237    case PIPE_SHADER_CAP_MAX_CONST_BUFFERS:
 238       return 1;
 239
 240    case PIPE_SHADER_CAP_MAX_TEXTURE_SAMPLERS:
 241       return 16; /* need investigate */
 242
 243    case PIPE_SHADER_CAP_PREFERRED_IR:
 244       return PIPE_SHADER_IR_NIR;
 245
 246    case PIPE_SHADER_CAP_MAX_TEMPS:
 247       return 256; /* need investigate */
 248
 249    case PIPE_SHADER_CAP_INDIRECT_INPUT_ADDR:
 250    case PIPE_SHADER_CAP_INDIRECT_CONST_ADDR:
 251       return 1;
 252
 253    case PIPE_SHADER_CAP_INDIRECT_TEMP_ADDR:
 254    case PIPE_SHADER_CAP_INDIRECT_OUTPUT_ADDR:
 255       return 0;
 256
 257    case PIPE_SHADER_CAP_MAX_UNROLL_ITERATIONS_HINT:
 258       return 32;
 259
 260    default:
 261       return 0;
 262    }
 263 }
 264
 265 static int
 266 lima_screen_get_shader_param(struct pipe_screen *pscreen,
 267                              enum pipe_shader_type shader,
 268                              enum pipe_shader_cap param)
 269 {
 270    struct lima_screen *screen = lima_screen(pscreen);
 271
 272    switch (shader) {
 273    case PIPE_SHADER_FRAGMENT:
 274       return get_fragment_shader_param(screen, param);
 275    case PIPE_SHADER_VERTEX:
 276       return get_vertex_shader_param(screen, param);
 277
 278    default:
 279       return 0;
 280    }
 281 }
 282
 283 static bool
 284 lima_screen_is_format_supported(struct pipe_screen *pscreen,
 285                                 enum pipe_format format,
 286                                 enum pipe_texture_target target,
 287                                 unsigned sample_count,
 288                                 unsigned storage_sample_count,
 289                                 unsigned usage)
 290 {
 291    switch (target) {
 292    case PIPE_BUFFER:
 293    case PIPE_TEXTURE_1D:
 294    case PIPE_TEXTURE_2D:
 295    case PIPE_TEXTURE_RECT:
 296    case PIPE_TEXTURE_CUBE:
 297       break;
 298    default:
 299       return false;
 300    }
 301
 302    if (MAX2(1, sample_count) != MAX2(1, storage_sample_count))
 303       return false;
 304
 305    /* be able to support 16, now limit to 4 */
 306    if (sample_count > 1 && sample_count != 4)
 307       return false;
 308
 309    if (usage & PIPE_BIND_RENDER_TARGET &&
 310        !lima_format_pixel_supported(format))
 311       return false;
 312
 313    if (usage & PIPE_BIND_DEPTH_STENCIL) {
 314       switch (format) {
 315       case PIPE_FORMAT_Z24_UNORM_S8_UINT:
 316       case PIPE_FORMAT_Z24X8_UNORM:
 317          break;
 318       default:
 319          return false;
 320       }
 321    }
 322
 323    if (usage & PIPE_BIND_VERTEX_BUFFER) {
 324       switch (format) {
 325       case PIPE_FORMAT_R32G32B32_FLOAT:
 326          break;
 327       default:
 328          return false;
 329       }
 330    }
 331
 332    if (usage & PIPE_BIND_INDEX_BUFFER) {
 333       switch (format) {
 334       case PIPE_FORMAT_I8_UINT:
 335       case PIPE_FORMAT_I16_UINT:
 336       case PIPE_FORMAT_I32_UINT:
 337          break;
 338       default:
 339          return false;
 340       }
 341    }
 342
 343    if (usage & PIPE_BIND_SAMPLER_VIEW)
 344       return lima_format_texel_supported(format);
 345
 346    return true;
 347 }
 348
 349 static const void *
 350 lima_screen_get_compiler_options(struct pipe_screen *pscreen,
 351                                  enum pipe_shader_ir ir,
 352                                  enum pipe_shader_type shader)
 353 {
 354    return lima_program_get_compiler_options(shader);
 355 }
 356
 357 static bool
 358 lima_screen_set_plb_max_blk(struct lima_screen *screen)
 359 {
 360    if (lima_plb_max_blk) {
 361       screen->plb_max_blk = lima_plb_max_blk;
 362       return true;
 363    }
 364
 365    if (screen->gpu_type == DRM_LIMA_PARAM_GPU_ID_MALI450)
 366       screen->plb_max_blk = 4096;
 367    else
 368       screen->plb_max_blk = 512;
 369
 370    drmDevicePtr devinfo;
 371
 372    if (drmGetDevice2(screen->fd, 0, &devinfo))
 373       return false;
 374
 375    if (devinfo->bustype == DRM_BUS_PLATFORM && devinfo->deviceinfo.platform) {
 376       char **compatible = devinfo->deviceinfo.platform->compatible;
 377
 378       if (compatible && *compatible)
 379          if (!strcmp("allwinner,sun50i-h5-mali", *compatible))
 380             screen->plb_max_blk = 2048;
 381    }
 382
 383    drmFreeDevice(&devinfo);
 384
 385    return true;
 386 }
 387
 388 static bool
 389 lima_screen_query_info(struct lima_screen *screen)
 390 {
 391    drmVersionPtr version = drmGetVersion(screen->fd);
 392    if (!version)
 393       return false;
 394
 395    if (version->version_major > 1 || version->version_minor > 0)
 396       screen->has_growable_heap_buffer = true;
 397
 398    drmFreeVersion(version);
 399
 400    if (lima_debug & LIMA_DEBUG_NO_GROW_HEAP)
 401       screen->has_growable_heap_buffer = false;
 402
 403    struct drm_lima_get_param param;
 404
 405    memset(&param, 0, sizeof(param));
 406    param.param = DRM_LIMA_PARAM_GPU_ID;
 407    if (drmIoctl(screen->fd, DRM_IOCTL_LIMA_GET_PARAM, &param))
 408       return false;
 409
 410    switch (param.value) {
 411    case DRM_LIMA_PARAM_GPU_ID_MALI400:
 412    case DRM_LIMA_PARAM_GPU_ID_MALI450:
 413       screen->gpu_type = param.value;
 414       break;
 415    default:
 416       return false;
 417    }
 418
 419    memset(&param, 0, sizeof(param));
 420    param.param = DRM_LIMA_PARAM_NUM_PP;
 421    if (drmIoctl(screen->fd, DRM_IOCTL_LIMA_GET_PARAM, &param))
 422       return false;
 423
 424    screen->num_pp = param.value;
 425
 426    lima_screen_set_plb_max_blk(screen);
 427
 428    return true;
 429 }
 430
 431 static void
 432 lima_screen_query_dmabuf_modifiers(struct pipe_screen *pscreen,
 433                                    enum pipe_format format, int max,
 434                                    uint64_t *modifiers,
 435                                    unsigned int *external_only,
 436                                    int *count)
 437 {
 438    uint64_t available_modifiers[] = {
 439       DRM_FORMAT_MOD_ARM_16X16_BLOCK_U_INTERLEAVED,
 440       DRM_FORMAT_MOD_LINEAR,
 441    };
 442
 443    int num_modifiers = ARRAY_SIZE(available_modifiers);
 444
 445    if (!modifiers) {
 446       *count = num_modifiers;
 447       return;
 448    }
 449
 450    *count = MIN2(max, num_modifiers);
 451    for (int i = 0; i < *count; i++) {
 452       modifiers[i] = available_modifiers[i];
 453       if (external_only)
 454          external_only[i] = false;
 455    }
 456 }
 457
 458 static const struct debug_named_value debug_options[] = {
 459         { "gp",       LIMA_DEBUG_GP,
 460           "print GP shader compiler result of each stage" },
 461         { "pp",       LIMA_DEBUG_PP,
 462           "print PP shader compiler result of each stage" },
 463         { "dump",     LIMA_DEBUG_DUMP,
 464           "dump GPU command stream to $PWD/lima.dump" },
 465         { "shaderdb", LIMA_DEBUG_SHADERDB,
 466           "print shader information for shaderdb" },
 467         { "nobocache", LIMA_DEBUG_NO_BO_CACHE,
 468           "disable BO cache" },
 469         { "bocache", LIMA_DEBUG_BO_CACHE,
 470           "print debug info for BO cache" },
 471         { "notiling", LIMA_DEBUG_NO_TILING,
 472           "don't use tiled buffers" },
 473         { "nogrowheap",   LIMA_DEBUG_NO_GROW_HEAP,
 474           "disable growable heap buffer" },
 475         { "singlejob", LIMA_DEBUG_SINGLE_JOB,
 476           "disable multi job optimization" },
 477         { NULL }
 478 };
 479
 480 DEBUG_GET_ONCE_FLAGS_OPTION(lima_debug, "LIMA_DEBUG", debug_options, 0)
 481 uint32_t lima_debug;
 482
 483 static void
 484 lima_screen_parse_env(void)
 485 {
 486    lima_debug = debug_get_option_lima_debug();
 487
 488    lima_ctx_num_plb = debug_get_num_option("LIMA_CTX_NUM_PLB", LIMA_CTX_PLB_DEF_NUM);
 489    if (lima_ctx_num_plb > LIMA_CTX_PLB_MAX_NUM ||
 490        lima_ctx_num_plb < LIMA_CTX_PLB_MIN_NUM) {
 491       fprintf(stderr, "lima: LIMA_CTX_NUM_PLB %d out of range [%d %d], "
 492               "reset to default %d\n", lima_ctx_num_plb, LIMA_CTX_PLB_MIN_NUM,
 493               LIMA_CTX_PLB_MAX_NUM, LIMA_CTX_PLB_DEF_NUM);
 494       lima_ctx_num_plb = LIMA_CTX_PLB_DEF_NUM;
 495    }
 496
 497    lima_plb_max_blk = debug_get_num_option("LIMA_PLB_MAX_BLK", 0);
 498    if (lima_plb_max_blk < 0 || lima_plb_max_blk > 65536) {
 499       fprintf(stderr, "lima: LIMA_PLB_MAX_BLK %d out of range [%d %d], "
 500               "reset to default %d\n", lima_plb_max_blk, 0, 65536, 0);
 501       lima_plb_max_blk = 0;
 502    }
 503
 504    lima_ppir_force_spilling = debug_get_num_option("LIMA_PPIR_FORCE_SPILLING", 0);
 505    if (lima_ppir_force_spilling < 0) {
 506       fprintf(stderr, "lima: LIMA_PPIR_FORCE_SPILLING %d less than 0, "
 507               "reset to default 0\n", lima_ppir_force_spilling);
 508       lima_ppir_force_spilling = 0;
 509    }
 510
 511    lima_plb_pp_stream_cache_size = debug_get_num_option("LIMA_PLB_PP_STREAM_CACHE_SIZE", 0);
 512    if (lima_plb_pp_stream_cache_size < 0) {
 513       fprintf(stderr, "lima: LIMA_PLB_PP_STREAM_CACHE_SIZE %d less than 0, "
 514               "reset to default 0\n", lima_plb_pp_stream_cache_size);
 515       lima_plb_pp_stream_cache_size = 0;
 516    }
 517 }
 518
 519 struct pipe_screen *
 520 lima_screen_create(int fd, struct renderonly *ro)
 521 {
 522    uint64_t system_memory;
 523    struct lima_screen *screen;
 524
 525    screen = rzalloc(NULL, struct lima_screen);
 526    if (!screen)
 527       return NULL;
 528
 529    screen->fd = fd;
 530
 531    lima_screen_parse_env();
 532
 533    /* Limit PP PLB stream cache size to 0.1% of system memory */
 534    if (!lima_plb_pp_stream_cache_size &&
 535        os_get_total_physical_memory(&system_memory))
 536       lima_plb_pp_stream_cache_size = system_memory >> 10;
 537
 538    /* Set lower limit on PP PLB cache size */
 539    lima_plb_pp_stream_cache_size = MAX2(128 * 1024 * lima_ctx_num_plb,
 540                                         lima_plb_pp_stream_cache_size);
 541
 542    if (!lima_screen_query_info(screen))
 543       goto err_out0;
 544
 545    if (!lima_bo_cache_init(screen))
 546       goto err_out0;
 547
 548    if (!lima_bo_table_init(screen))
 549       goto err_out1;
 550
 551    screen->pp_ra = ppir_regalloc_init(screen);
 552    if (!screen->pp_ra)
 553       goto err_out2;
 554
 555    screen->pp_buffer = lima_bo_create(screen, pp_buffer_size, 0);
 556    if (!screen->pp_buffer)
 557       goto err_out2;
 558    screen->pp_buffer->cacheable = false;
 559
 560    /* fs program for clear buffer?
 561     * const0 1 0 0 -1.67773, mov.v0 $0 ^const0.xxxx, stop
 562     */
 563    static const uint32_t pp_clear_program[] = {
 564       0x00020425, 0x0000000c, 0x01e007cf, 0xb0000000,
 565       0x000005f5, 0x00000000, 0x00000000, 0x00000000,
 566    };
 567    memcpy(lima_bo_map(screen->pp_buffer) + pp_clear_program_offset,
 568           pp_clear_program, sizeof(pp_clear_program));
 569
 570    /* copy texture to framebuffer, used to reload gpu tile buffer
 571     * load.v $1 0.xy, texld_2d 0, mov.v0 $0 ^tex_sampler, sync, stop
 572     */
 573    static const uint32_t pp_reload_program[] = {
 574       0x000005e6, 0xf1003c20, 0x00000000, 0x39001000,
 575       0x00000e4e, 0x000007cf, 0x00000000, 0x00000000,
 576    };
 577    memcpy(lima_bo_map(screen->pp_buffer) + pp_reload_program_offset,
 578           pp_reload_program, sizeof(pp_reload_program));
 579
 580    /* 0/1/2 vertex index for reload/clear draw */
 581    static const uint8_t pp_shared_index[] = { 0, 1, 2 };
 582    memcpy(lima_bo_map(screen->pp_buffer) + pp_shared_index_offset,
 583           pp_shared_index, sizeof(pp_shared_index));
 584
 585    /* 4096x4096 gl pos used for partial clear */
 586    static const float pp_clear_gl_pos[] = {
 587       4096, 0,    1, 1,
 588       0,    0,    1, 1,
 589       0,    4096, 1, 1,
 590    };
 591    memcpy(lima_bo_map(screen->pp_buffer) + pp_clear_gl_pos_offset,
 592           pp_clear_gl_pos, sizeof(pp_clear_gl_pos));
 593
 594    /* is pp frame render state static? */
 595    uint32_t *pp_frame_rsw = lima_bo_map(screen->pp_buffer) + pp_frame_rsw_offset;
 596    memset(pp_frame_rsw, 0, 0x40);
 597    pp_frame_rsw[8] = 0x0000f008;
 598    pp_frame_rsw[9] = screen->pp_buffer->va + pp_clear_program_offset;
 599    pp_frame_rsw[13] = 0x00000100;
 600
 601    if (ro) {
 602       screen->ro = renderonly_dup(ro);
 603       if (!screen->ro) {
 604          fprintf(stderr, "Failed to dup renderonly object\n");
 605          goto err_out3;
 606       }
 607    }
 608
 609    screen->base.destroy = lima_screen_destroy;
 610    screen->base.get_name = lima_screen_get_name;
 611    screen->base.get_vendor = lima_screen_get_vendor;
 612    screen->base.get_device_vendor = lima_screen_get_device_vendor;
 613    screen->base.get_param = lima_screen_get_param;
 614    screen->base.get_paramf = lima_screen_get_paramf;
 615    screen->base.get_shader_param = lima_screen_get_shader_param;
 616    screen->base.context_create = lima_context_create;
 617    screen->base.is_format_supported = lima_screen_is_format_supported;
 618    screen->base.get_compiler_options = lima_screen_get_compiler_options;
 619    screen->base.query_dmabuf_modifiers = lima_screen_query_dmabuf_modifiers;
 620
 621    lima_resource_screen_init(screen);
 622    lima_fence_screen_init(screen);
 623
 624    slab_create_parent(&screen->transfer_pool, sizeof(struct lima_transfer), 16);
 625
 626    screen->refcnt = 1;
 627
 628    return &screen->base;
 629
 630 err_out3:
 631    lima_bo_unreference(screen->pp_buffer);
 632 err_out2:
 633    lima_bo_table_fini(screen);
 634 err_out1:
 635    lima_bo_cache_fini(screen);
 636 err_out0:
 637    ralloc_free(screen);
 638    return NULL;
 639 }