src/gallium/drivers/freedreno/freedreno_resource.c

   1 /* -*- mode: C; c-file-style: "k&r"; tab-width 4; indent-tabs-mode: t; -*- */
   2
   3 /*
   4  * Copyright (C) 2012 Rob Clark <robclark@freedesktop.org>
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the "Software"),
   8  * to deal in the Software without restriction, including without limitation
   9  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10  * and/or sell copies of the Software, and to permit persons to whom the
  11  * Software is furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice (including the next
  14  * paragraph) shall be included in all copies or substantial portions of the
  15  * Software.
  16  *
  17  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23  * SOFTWARE.
  24  *
  25  * Authors:
  26  *    Rob Clark <robclark@freedesktop.org>
  27  */
  28
  29 #include "util/u_format.h"
  30 #include "util/u_inlines.h"
  31 #include "util/u_transfer.h"
  32 #include "util/u_string.h"
  33 #include "util/u_surface.h"
  34
  35 #include "freedreno_resource.h"
  36 #include "freedreno_screen.h"
  37 #include "freedreno_surface.h"
  38 #include "freedreno_context.h"
  39 #include "freedreno_query_hw.h"
  40 #include "freedreno_util.h"
  41
  42 #include <errno.h>
  43
  44 static void
  45 realloc_bo(struct fd_resource *rsc, uint32_t size)
  46 {
  47         struct fd_screen *screen = fd_screen(rsc->base.b.screen);
  48         uint32_t flags = DRM_FREEDRENO_GEM_CACHE_WCOMBINE |
  49                         DRM_FREEDRENO_GEM_TYPE_KMEM; /* TODO */
  50
  51         /* if we start using things other than write-combine,
  52          * be sure to check for PIPE_RESOURCE_FLAG_MAP_COHERENT
  53          */
  54
  55         if (rsc->bo)
  56                 fd_bo_del(rsc->bo);
  57
  58         rsc->bo = fd_bo_new(screen->dev, size, flags);
  59         rsc->timestamp = 0;
  60         rsc->dirty = false;
  61 }
  62
  63 static void fd_resource_transfer_flush_region(struct pipe_context *pctx,
  64                 struct pipe_transfer *ptrans,
  65                 const struct pipe_box *box)
  66 {
  67         struct fd_context *ctx = fd_context(pctx);
  68         struct fd_resource *rsc = fd_resource(ptrans->resource);
  69
  70         if (rsc->dirty)
  71                 fd_context_render(pctx);
  72
  73         if (rsc->timestamp) {
  74                 fd_pipe_wait(ctx->screen->pipe, rsc->timestamp);
  75                 rsc->timestamp = 0;
  76         }
  77 }
  78
  79 static void
  80 fd_resource_transfer_unmap(struct pipe_context *pctx,
  81                 struct pipe_transfer *ptrans)
  82 {
  83         struct fd_context *ctx = fd_context(pctx);
  84         struct fd_resource *rsc = fd_resource(ptrans->resource);
  85         if (!(ptrans->usage & PIPE_TRANSFER_UNSYNCHRONIZED))
  86                 fd_bo_cpu_fini(rsc->bo);
  87         pipe_resource_reference(&ptrans->resource, NULL);
  88         util_slab_free(&ctx->transfer_pool, ptrans);
  89 }
  90
  91 static void *
  92 fd_resource_transfer_map(struct pipe_context *pctx,
  93                 struct pipe_resource *prsc,
  94                 unsigned level, unsigned usage,
  95                 const struct pipe_box *box,
  96                 struct pipe_transfer **pptrans)
  97 {
  98         struct fd_context *ctx = fd_context(pctx);
  99         struct fd_resource *rsc = fd_resource(prsc);
 100         struct fd_resource_slice *slice = fd_resource_slice(rsc, level);
 101         struct pipe_transfer *ptrans;
 102         enum pipe_format format = prsc->format;
 103         uint32_t op = 0;
 104         uint32_t offset;
 105         char *buf;
 106         int ret = 0;
 107
 108         DBG("prsc=%p, level=%u, usage=%x", prsc, level, usage);
 109
 110         ptrans = util_slab_alloc(&ctx->transfer_pool);
 111         if (!ptrans)
 112                 return NULL;
 113
 114         /* util_slab_alloc() doesn't zero: */
 115         memset(ptrans, 0, sizeof(*ptrans));
 116
 117         pipe_resource_reference(&ptrans->resource, prsc);
 118         ptrans->level = level;
 119         ptrans->usage = usage;
 120         ptrans->box = *box;
 121         ptrans->stride = slice->pitch * rsc->cpp;
 122         ptrans->layer_stride = slice->size0;
 123
 124         if (usage & PIPE_TRANSFER_READ)
 125                 op |= DRM_FREEDRENO_PREP_READ;
 126
 127         if (usage & PIPE_TRANSFER_WRITE)
 128                 op |= DRM_FREEDRENO_PREP_WRITE;
 129
 130         /* some state trackers (at least XA) don't do this.. */
 131         if (!(usage & (PIPE_TRANSFER_FLUSH_EXPLICIT | PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE)))
 132                 fd_resource_transfer_flush_region(pctx, ptrans, box);
 133
 134         if (usage & PIPE_TRANSFER_DISCARD_WHOLE_RESOURCE) {
 135                 realloc_bo(rsc, fd_bo_size(rsc->bo));
 136         } else if (!(usage & PIPE_TRANSFER_UNSYNCHRONIZED)) {
 137                 ret = fd_bo_cpu_prep(rsc->bo, ctx->screen->pipe, op);
 138                 if (ret)
 139                         goto fail;
 140         }
 141
 142         buf = fd_bo_map(rsc->bo);
 143         if (!buf) {
 144                 fd_resource_transfer_unmap(pctx, ptrans);
 145                 return NULL;
 146         }
 147
 148         *pptrans = ptrans;
 149
 150         if (rsc->layer_first) {
 151                 offset = slice->offset +
 152                         box->y / util_format_get_blockheight(format) * ptrans->stride +
 153                         box->x / util_format_get_blockwidth(format) * rsc->cpp +
 154                         box->z * rsc->layer_size;
 155         } else {
 156                 offset = slice->offset +
 157                         box->y / util_format_get_blockheight(format) * ptrans->stride +
 158                         box->x / util_format_get_blockwidth(format) * rsc->cpp +
 159                         box->z * slice->size0;
 160         }
 161
 162         return buf + offset;
 163
 164 fail:
 165         fd_resource_transfer_unmap(pctx, ptrans);
 166         return NULL;
 167 }
 168
 169 static void
 170 fd_resource_destroy(struct pipe_screen *pscreen,
 171                 struct pipe_resource *prsc)
 172 {
 173         struct fd_resource *rsc = fd_resource(prsc);
 174         if (rsc->bo)
 175                 fd_bo_del(rsc->bo);
 176         FREE(rsc);
 177 }
 178
 179 static boolean
 180 fd_resource_get_handle(struct pipe_screen *pscreen,
 181                 struct pipe_resource *prsc,
 182                 struct winsys_handle *handle)
 183 {
 184         struct fd_resource *rsc = fd_resource(prsc);
 185
 186         return fd_screen_bo_get_handle(pscreen, rsc->bo,
 187                         rsc->slices[0].pitch * rsc->cpp, handle);
 188 }
 189
 190
 191 static const struct u_resource_vtbl fd_resource_vtbl = {
 192                 .resource_get_handle      = fd_resource_get_handle,
 193                 .resource_destroy         = fd_resource_destroy,
 194                 .transfer_map             = fd_resource_transfer_map,
 195                 .transfer_flush_region    = fd_resource_transfer_flush_region,
 196                 .transfer_unmap           = fd_resource_transfer_unmap,
 197                 .transfer_inline_write    = u_default_transfer_inline_write,
 198 };
 199
 200 static uint32_t
 201 setup_slices(struct fd_resource *rsc, uint32_t alignment)
 202 {
 203         struct pipe_resource *prsc = &rsc->base.b;
 204         uint32_t level, size = 0;
 205         uint32_t width = prsc->width0;
 206         uint32_t height = prsc->height0;
 207         uint32_t depth = prsc->depth0;
 208         /* in layer_first layout, the level (slice) contains just one
 209          * layer (since in fact the layer contains the slices)
 210          */
 211         uint32_t layers_in_level = rsc->layer_first ? 1 : prsc->array_size;
 212
 213         for (level = 0; level <= prsc->last_level; level++) {
 214                 struct fd_resource_slice *slice = fd_resource_slice(rsc, level);
 215
 216                 slice->pitch = width = align(width, 32);
 217                 slice->offset = size;
 218                 /* 1d array and 2d array textures must all have the same layer size
 219                  * for each miplevel on a3xx. 3d textures can have different layer
 220                  * sizes for high levels, but the hw auto-sizer is buggy (or at least
 221                  * different than what this code does), so as soon as the layer size
 222                  * range gets into range, we stop reducing it.
 223                  */
 224                 if (prsc->target == PIPE_TEXTURE_3D && (
 225                                         level == 1 ||
 226                                         (level > 1 && rsc->slices[level - 1].size0 > 0xf000)))
 227                         slice->size0 = align(slice->pitch * height * rsc->cpp, alignment);
 228                 else if (level == 0 || rsc->layer_first || alignment == 1)
 229                         slice->size0 = align(slice->pitch * height * rsc->cpp, alignment);
 230                 else
 231                         slice->size0 = rsc->slices[level - 1].size0;
 232
 233                 size += slice->size0 * depth * layers_in_level;
 234
 235                 width = u_minify(width, 1);
 236                 height = u_minify(height, 1);
 237                 depth = u_minify(depth, 1);
 238         }
 239
 240         return size;
 241 }
 242
 243 static uint32_t
 244 slice_alignment(struct pipe_screen *pscreen, const struct pipe_resource *tmpl)
 245 {
 246         /* on a3xx, 2d array and 3d textures seem to want their
 247          * layers aligned to page boundaries:
 248          */
 249         switch (tmpl->target) {
 250         case PIPE_TEXTURE_3D:
 251         case PIPE_TEXTURE_1D_ARRAY:
 252         case PIPE_TEXTURE_2D_ARRAY:
 253                 return 4096;
 254         default:
 255                 return 1;
 256         }
 257 }
 258
 259 /**
 260  * Create a new texture object, using the given template info.
 261  */
 262 static struct pipe_resource *
 263 fd_resource_create(struct pipe_screen *pscreen,
 264                 const struct pipe_resource *tmpl)
 265 {
 266         struct fd_resource *rsc = CALLOC_STRUCT(fd_resource);
 267         struct pipe_resource *prsc = &rsc->base.b;
 268         uint32_t size;
 269
 270         DBG("target=%d, format=%s, %ux%ux%u, array_size=%u, last_level=%u, "
 271                         "nr_samples=%u, usage=%u, bind=%x, flags=%x",
 272                         tmpl->target, util_format_name(tmpl->format),
 273                         tmpl->width0, tmpl->height0, tmpl->depth0,
 274                         tmpl->array_size, tmpl->last_level, tmpl->nr_samples,
 275                         tmpl->usage, tmpl->bind, tmpl->flags);
 276
 277         if (!rsc)
 278                 return NULL;
 279
 280         *prsc = *tmpl;
 281
 282         pipe_reference_init(&prsc->reference, 1);
 283         prsc->screen = pscreen;
 284
 285         rsc->base.vtbl = &fd_resource_vtbl;
 286         rsc->cpp = util_format_get_blocksize(tmpl->format);
 287
 288         assert(rsc->cpp);
 289
 290         if (is_a4xx(fd_screen(pscreen))) {
 291                 switch (tmpl->target) {
 292                 case PIPE_TEXTURE_3D:
 293                         /* TODO 3D_ARRAY? */
 294                         rsc->layer_first = false;
 295                         break;
 296                 default:
 297                         rsc->layer_first = true;
 298                         break;
 299                 }
 300         }
 301
 302         size = setup_slices(rsc, slice_alignment(pscreen, tmpl));
 303
 304         if (rsc->layer_first) {
 305                 rsc->layer_size = align(size, 4096);
 306                 size = rsc->layer_size * prsc->array_size;
 307         }
 308
 309         realloc_bo(rsc, size);
 310         if (!rsc->bo)
 311                 goto fail;
 312
 313         return prsc;
 314 fail:
 315         fd_resource_destroy(pscreen, prsc);
 316         return NULL;
 317 }
 318
 319 /**
 320  * Create a texture from a winsys_handle. The handle is often created in
 321  * another process by first creating a pipe texture and then calling
 322  * resource_get_handle.
 323  */
 324 static struct pipe_resource *
 325 fd_resource_from_handle(struct pipe_screen *pscreen,
 326                 const struct pipe_resource *tmpl,
 327                 struct winsys_handle *handle)
 328 {
 329         struct fd_resource *rsc = CALLOC_STRUCT(fd_resource);
 330         struct fd_resource_slice *slice = &rsc->slices[0];
 331         struct pipe_resource *prsc = &rsc->base.b;
 332
 333         DBG("target=%d, format=%s, %ux%ux%u, array_size=%u, last_level=%u, "
 334                         "nr_samples=%u, usage=%u, bind=%x, flags=%x",
 335                         tmpl->target, util_format_name(tmpl->format),
 336                         tmpl->width0, tmpl->height0, tmpl->depth0,
 337                         tmpl->array_size, tmpl->last_level, tmpl->nr_samples,
 338                         tmpl->usage, tmpl->bind, tmpl->flags);
 339
 340         if (!rsc)
 341                 return NULL;
 342
 343         *prsc = *tmpl;
 344
 345         pipe_reference_init(&prsc->reference, 1);
 346         prsc->screen = pscreen;
 347
 348         rsc->bo = fd_screen_bo_from_handle(pscreen, handle, &slice->pitch);
 349         if (!rsc->bo)
 350                 goto fail;
 351
 352         rsc->base.vtbl = &fd_resource_vtbl;
 353         rsc->cpp = util_format_get_blocksize(tmpl->format);
 354         slice->pitch /= rsc->cpp;
 355
 356         assert(rsc->cpp);
 357
 358         return prsc;
 359
 360 fail:
 361         fd_resource_destroy(pscreen, prsc);
 362         return NULL;
 363 }
 364
 365 static void fd_blitter_pipe_begin(struct fd_context *ctx);
 366 static void fd_blitter_pipe_end(struct fd_context *ctx);
 367
 368 /**
 369  * _copy_region using pipe (3d engine)
 370  */
 371 static bool
 372 fd_blitter_pipe_copy_region(struct fd_context *ctx,
 373                 struct pipe_resource *dst,
 374                 unsigned dst_level,
 375                 unsigned dstx, unsigned dsty, unsigned dstz,
 376                 struct pipe_resource *src,
 377                 unsigned src_level,
 378                 const struct pipe_box *src_box)
 379 {
 380         /* not until we allow rendertargets to be buffers */
 381         if (dst->target == PIPE_BUFFER || src->target == PIPE_BUFFER)
 382                 return false;
 383
 384         if (!util_blitter_is_copy_supported(ctx->blitter, dst, src))
 385                 return false;
 386
 387         fd_blitter_pipe_begin(ctx);
 388         util_blitter_copy_texture(ctx->blitter,
 389                         dst, dst_level, dstx, dsty, dstz,
 390                         src, src_level, src_box);
 391         fd_blitter_pipe_end(ctx);
 392
 393         return true;
 394 }
 395
 396 /**
 397  * Copy a block of pixels from one resource to another.
 398  * The resource must be of the same format.
 399  * Resources with nr_samples > 1 are not allowed.
 400  */
 401 static void
 402 fd_resource_copy_region(struct pipe_context *pctx,
 403                 struct pipe_resource *dst,
 404                 unsigned dst_level,
 405                 unsigned dstx, unsigned dsty, unsigned dstz,
 406                 struct pipe_resource *src,
 407                 unsigned src_level,
 408                 const struct pipe_box *src_box)
 409 {
 410         struct fd_context *ctx = fd_context(pctx);
 411
 412         /* TODO if we have 2d core, or other DMA engine that could be used
 413          * for simple copies and reasonably easily synchronized with the 3d
 414          * core, this is where we'd plug it in..
 415          */
 416
 417         /* try blit on 3d pipe: */
 418         if (fd_blitter_pipe_copy_region(ctx,
 419                         dst, dst_level, dstx, dsty, dstz,
 420                         src, src_level, src_box))
 421                 return;
 422
 423         /* else fallback to pure sw: */
 424         util_resource_copy_region(pctx,
 425                         dst, dst_level, dstx, dsty, dstz,
 426                         src, src_level, src_box);
 427 }
 428
 429 /**
 430  * Optimal hardware path for blitting pixels.
 431  * Scaling, format conversion, up- and downsampling (resolve) are allowed.
 432  */
 433 static void
 434 fd_blit(struct pipe_context *pctx, const struct pipe_blit_info *blit_info)
 435 {
 436         struct fd_context *ctx = fd_context(pctx);
 437         struct pipe_blit_info info = *blit_info;
 438
 439         if (info.src.resource->nr_samples > 1 &&
 440                         info.dst.resource->nr_samples <= 1 &&
 441                         !util_format_is_depth_or_stencil(info.src.resource->format) &&
 442                         !util_format_is_pure_integer(info.src.resource->format)) {
 443                 DBG("color resolve unimplemented");
 444                 return;
 445         }
 446
 447         if (util_try_blit_via_copy_region(pctx, &info)) {
 448                 return; /* done */
 449         }
 450
 451         if (info.mask & PIPE_MASK_S) {
 452                 DBG("cannot blit stencil, skipping");
 453                 info.mask &= ~PIPE_MASK_S;
 454         }
 455
 456         if (!util_blitter_is_blit_supported(ctx->blitter, &info)) {
 457                 DBG("blit unsupported %s -> %s",
 458                                 util_format_short_name(info.src.resource->format),
 459                                 util_format_short_name(info.dst.resource->format));
 460                 return;
 461         }
 462
 463         fd_blitter_pipe_begin(ctx);
 464         util_blitter_blit(ctx->blitter, &info);
 465         fd_blitter_pipe_end(ctx);
 466 }
 467
 468 static void
 469 fd_blitter_pipe_begin(struct fd_context *ctx)
 470 {
 471         util_blitter_save_vertex_buffer_slot(ctx->blitter, ctx->vtx.vertexbuf.vb);
 472         util_blitter_save_vertex_elements(ctx->blitter, ctx->vtx.vtx);
 473         util_blitter_save_vertex_shader(ctx->blitter, ctx->prog.vp);
 474         util_blitter_save_rasterizer(ctx->blitter, ctx->rasterizer);
 475         util_blitter_save_viewport(ctx->blitter, &ctx->viewport);
 476         util_blitter_save_scissor(ctx->blitter, &ctx->scissor);
 477         util_blitter_save_fragment_shader(ctx->blitter, ctx->prog.fp);
 478         util_blitter_save_blend(ctx->blitter, ctx->blend);
 479         util_blitter_save_depth_stencil_alpha(ctx->blitter, ctx->zsa);
 480         util_blitter_save_stencil_ref(ctx->blitter, &ctx->stencil_ref);
 481         util_blitter_save_sample_mask(ctx->blitter, ctx->sample_mask);
 482         util_blitter_save_framebuffer(ctx->blitter, &ctx->framebuffer);
 483         util_blitter_save_fragment_sampler_states(ctx->blitter,
 484                         ctx->fragtex.num_samplers,
 485                         (void **)ctx->fragtex.samplers);
 486         util_blitter_save_fragment_sampler_views(ctx->blitter,
 487                         ctx->fragtex.num_textures, ctx->fragtex.textures);
 488
 489         fd_hw_query_set_stage(ctx, ctx->ring, FD_STAGE_BLIT);
 490 }
 491
 492 static void
 493 fd_blitter_pipe_end(struct fd_context *ctx)
 494 {
 495         fd_hw_query_set_stage(ctx, ctx->ring, FD_STAGE_NULL);
 496 }
 497
 498 static void
 499 fd_flush_resource(struct pipe_context *pctx, struct pipe_resource *prsc)
 500 {
 501         struct fd_resource *rsc = fd_resource(prsc);
 502
 503         if (rsc->dirty)
 504                 fd_context_render(pctx);
 505 }
 506
 507 void
 508 fd_resource_screen_init(struct pipe_screen *pscreen)
 509 {
 510         pscreen->resource_create = fd_resource_create;
 511         pscreen->resource_from_handle = fd_resource_from_handle;
 512         pscreen->resource_get_handle = u_resource_get_handle_vtbl;
 513         pscreen->resource_destroy = u_resource_destroy_vtbl;
 514 }
 515
 516 void
 517 fd_resource_context_init(struct pipe_context *pctx)
 518 {
 519         pctx->transfer_map = u_transfer_map_vtbl;
 520         pctx->transfer_flush_region = u_transfer_flush_region_vtbl;
 521         pctx->transfer_unmap = u_transfer_unmap_vtbl;
 522         pctx->transfer_inline_write = u_transfer_inline_write_vtbl;
 523         pctx->create_surface = fd_create_surface;
 524         pctx->surface_destroy = fd_surface_destroy;
 525         pctx->resource_copy_region = fd_resource_copy_region;
 526         pctx->blit = fd_blit;
 527         pctx->flush_resource = fd_flush_resource;
 528 }