src/gallium/drivers/freedreno/a6xx/fd6_image.c

   1 /*
   2  * Copyright (C) 2017 Rob Clark <robclark@freedesktop.org>
   3  * Copyright © 2018 Google, Inc.
   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  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   9  * and/or sell copies of the Software, and to permit persons to whom the
  10  * 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 NONINFRINGEMENT.  IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  22  * SOFTWARE.
  23  *
  24  * Authors:
  25  *    Rob Clark <robclark@freedesktop.org>
  26  */
  27
  28 #include "pipe/p_state.h"
  29
  30 #include "freedreno_resource.h"
  31 #include "freedreno_state.h"
  32
  33 #include "fd6_image.h"
  34 #include "fd6_format.h"
  35 #include "fd6_resource.h"
  36 #include "fd6_texture.h"
  37
  38 struct fd6_image {
  39         struct pipe_resource *prsc;
  40         enum pipe_format pfmt;
  41         enum a6xx_tex_fmt fmt;
  42         enum a6xx_tex_fetchsize fetchsize;
  43         enum a6xx_tex_type type;
  44         bool srgb;
  45         uint32_t cpp;
  46         uint32_t level;
  47         uint32_t width;
  48         uint32_t height;
  49         uint32_t depth;
  50         uint32_t pitch;
  51         uint32_t array_pitch;
  52         struct fd_bo *bo;
  53         uint32_t ubwc_offset;
  54         uint32_t offset;
  55         bool buffer;
  56 };
  57
  58 static void translate_image(struct fd6_image *img, const struct pipe_image_view *pimg)
  59 {
  60         enum pipe_format format = pimg->format;
  61         struct pipe_resource *prsc = pimg->resource;
  62         struct fd_resource *rsc = fd_resource(prsc);
  63
  64         if (!prsc) {
  65                 memset(img, 0, sizeof(*img));
  66                 return;
  67         }
  68
  69         img->prsc      = prsc;
  70         img->pfmt      = format;
  71         img->fmt       = fd6_pipe2tex(format);
  72         img->fetchsize = fd6_pipe2fetchsize(format);
  73         img->type      = fd6_tex_type(prsc->target);
  74         img->srgb      = util_format_is_srgb(format);
  75         img->cpp       = rsc->cpp;
  76         img->bo        = rsc->bo;
  77
  78         /* Treat cube textures as 2d-array: */
  79         if (img->type == A6XX_TEX_CUBE)
  80                 img->type = A6XX_TEX_2D;
  81
  82         if (prsc->target == PIPE_BUFFER) {
  83                 img->buffer = true;
  84                 img->ubwc_offset = 0;    /* not valid for buffers */
  85                 img->offset = pimg->u.buf.offset;
  86                 img->pitch  = 0;
  87                 img->array_pitch = 0;
  88
  89                 /* size is encoded with low 15b in WIDTH and high bits in
  90                  * HEIGHT, in units of elements:
  91                  */
  92                 unsigned sz = prsc->width0;
  93                 img->width  = sz & MASK(15);
  94                 img->height = sz >> 15;
  95                 img->depth  = 0;
  96         } else {
  97                 img->buffer = false;
  98
  99                 unsigned lvl = pimg->u.tex.level;
 100                 struct fd_resource_slice *slice = fd_resource_slice(rsc, lvl);
 101                 unsigned layers = pimg->u.tex.last_layer - pimg->u.tex.first_layer + 1;
 102
 103                 img->ubwc_offset = fd_resource_ubwc_offset(rsc, lvl, pimg->u.tex.first_layer);
 104                 img->offset = fd_resource_offset(rsc, lvl, pimg->u.tex.first_layer);
 105                 img->pitch  = slice->pitch * rsc->cpp;
 106
 107                 switch (prsc->target) {
 108                 case PIPE_TEXTURE_RECT:
 109                 case PIPE_TEXTURE_1D:
 110                 case PIPE_TEXTURE_2D:
 111                         img->array_pitch = rsc->layer_size;
 112                         img->depth = 1;
 113                         break;
 114                 case PIPE_TEXTURE_1D_ARRAY:
 115                 case PIPE_TEXTURE_2D_ARRAY:
 116                 case PIPE_TEXTURE_CUBE:
 117                 case PIPE_TEXTURE_CUBE_ARRAY:
 118                         img->array_pitch = rsc->layer_size;
 119                         // TODO the CUBE/CUBE_ARRAY might need to be layers/6 for tex state,
 120                         // but empirically for ibo state it shouldn't be divided.
 121                         img->depth = layers;
 122                         break;
 123                 case PIPE_TEXTURE_3D:
 124                         img->array_pitch = slice->size0;
 125                         img->depth  = u_minify(prsc->depth0, lvl);
 126                         break;
 127                 default:
 128                         break;
 129                 }
 130
 131                 img->level  = lvl;
 132                 img->width  = u_minify(prsc->width0, lvl);
 133                 img->height = u_minify(prsc->height0, lvl);
 134         }
 135 }
 136
 137 static void translate_buf(struct fd6_image *img, const struct pipe_shader_buffer *pimg)
 138 {
 139         enum pipe_format format = PIPE_FORMAT_R32_UINT;
 140         struct pipe_resource *prsc = pimg->buffer;
 141         struct fd_resource *rsc = fd_resource(prsc);
 142
 143         if (!prsc) {
 144                 memset(img, 0, sizeof(*img));
 145                 return;
 146         }
 147
 148         img->prsc      = prsc;
 149         img->pfmt      = format;
 150         img->fmt       = fd6_pipe2tex(format);
 151         img->fetchsize = fd6_pipe2fetchsize(format);
 152         img->type      = fd6_tex_type(prsc->target);
 153         img->srgb      = util_format_is_srgb(format);
 154         img->cpp       = rsc->cpp;
 155         img->bo        = rsc->bo;
 156         img->buffer    = true;
 157
 158         img->ubwc_offset = 0;    /* not valid for buffers */
 159         img->offset = pimg->buffer_offset;
 160         img->pitch  = 0;
 161         img->array_pitch = 0;
 162
 163         /* size is encoded with low 15b in WIDTH and high bits in HEIGHT,
 164          * in units of elements:
 165          */
 166         unsigned sz = pimg->buffer_size / 4;
 167         img->width  = sz & MASK(15);
 168         img->height = sz >> 15;
 169         img->depth  = 0;
 170 }
 171
 172 static void emit_image_tex(struct fd_ringbuffer *ring, struct fd6_image *img)
 173 {
 174         struct fd_resource *rsc = fd_resource(img->prsc);
 175         bool ubwc_enabled = fd_resource_ubwc_enabled(rsc, img->level);
 176
 177         OUT_RING(ring, fd6_tex_const_0(img->prsc, img->level, img->pfmt,
 178                         PIPE_SWIZZLE_X, PIPE_SWIZZLE_Y,
 179                         PIPE_SWIZZLE_Z, PIPE_SWIZZLE_W));
 180         OUT_RING(ring, A6XX_TEX_CONST_1_WIDTH(img->width) |
 181                 A6XX_TEX_CONST_1_HEIGHT(img->height));
 182         OUT_RING(ring, A6XX_TEX_CONST_2_FETCHSIZE(img->fetchsize) |
 183                 COND(img->buffer, A6XX_TEX_CONST_2_UNK4 | A6XX_TEX_CONST_2_UNK31) |
 184                 A6XX_TEX_CONST_2_TYPE(img->type) |
 185                 A6XX_TEX_CONST_2_PITCH(img->pitch));
 186         OUT_RING(ring, A6XX_TEX_CONST_3_ARRAY_PITCH(img->array_pitch) |
 187                 COND(ubwc_enabled, A6XX_TEX_CONST_3_FLAG | A6XX_TEX_CONST_3_TILE_ALL));
 188         if (img->bo) {
 189                 OUT_RELOC(ring, img->bo, img->offset,
 190                                 (uint64_t)A6XX_TEX_CONST_5_DEPTH(img->depth) << 32, 0);
 191         } else {
 192                 OUT_RING(ring, 0x00000000);
 193                 OUT_RING(ring, A6XX_TEX_CONST_5_DEPTH(img->depth));
 194         }
 195
 196         OUT_RING(ring, 0x00000000);   /* texconst6 */
 197
 198         if (ubwc_enabled) {
 199                 OUT_RELOC(ring, rsc->bo, img->ubwc_offset, 0, 0);
 200                 OUT_RING(ring, A6XX_TEX_CONST_9_FLAG_BUFFER_ARRAY_PITCH(rsc->ubwc_size));
 201                 OUT_RING(ring, A6XX_TEX_CONST_10_FLAG_BUFFER_PITCH(rsc->ubwc_pitch));
 202         } else {
 203                 OUT_RING(ring, 0x00000000);   /* texconst7 */
 204                 OUT_RING(ring, 0x00000000);   /* texconst8 */
 205                 OUT_RING(ring, 0x00000000);   /* texconst9 */
 206                 OUT_RING(ring, 0x00000000);   /* texconst10 */
 207         }
 208
 209         OUT_RING(ring, 0x00000000);   /* texconst11 */
 210         OUT_RING(ring, 0x00000000);   /* texconst12 */
 211         OUT_RING(ring, 0x00000000);   /* texconst13 */
 212         OUT_RING(ring, 0x00000000);   /* texconst14 */
 213         OUT_RING(ring, 0x00000000);   /* texconst15 */
 214 }
 215
 216 void
 217 fd6_emit_image_tex(struct fd_ringbuffer *ring, const struct pipe_image_view *pimg)
 218 {
 219         struct fd6_image img;
 220         translate_image(&img, pimg);
 221         emit_image_tex(ring, &img);
 222 }
 223
 224 void
 225 fd6_emit_ssbo_tex(struct fd_ringbuffer *ring, const struct pipe_shader_buffer *pbuf)
 226 {
 227         struct fd6_image img;
 228         translate_buf(&img, pbuf);
 229         emit_image_tex(ring, &img);
 230 }
 231
 232 static void emit_image_ssbo(struct fd_ringbuffer *ring, struct fd6_image *img)
 233 {
 234         struct fd_resource *rsc = fd_resource(img->prsc);
 235         enum a6xx_tile_mode tile_mode = fd_resource_tile_mode(img->prsc, img->level);
 236         bool ubwc_enabled = fd_resource_ubwc_enabled(rsc, img->level);
 237
 238         OUT_RING(ring, A6XX_IBO_0_FMT(img->fmt) |
 239                 A6XX_IBO_0_TILE_MODE(tile_mode));
 240         OUT_RING(ring, A6XX_IBO_1_WIDTH(img->width) |
 241                 A6XX_IBO_1_HEIGHT(img->height));
 242         OUT_RING(ring, A6XX_IBO_2_PITCH(img->pitch) |
 243                 COND(img->buffer, A6XX_IBO_2_UNK4 | A6XX_IBO_2_UNK31) |
 244                 A6XX_IBO_2_TYPE(img->type));
 245         OUT_RING(ring, A6XX_IBO_3_ARRAY_PITCH(img->array_pitch) |
 246                 COND(ubwc_enabled, A6XX_IBO_3_FLAG | A6XX_IBO_3_UNK27));
 247         if (img->bo) {
 248                 OUT_RELOCW(ring, img->bo, img->offset,
 249                         (uint64_t)A6XX_IBO_5_DEPTH(img->depth) << 32, 0);
 250         } else {
 251                 OUT_RING(ring, 0x00000000);
 252                 OUT_RING(ring, A6XX_IBO_5_DEPTH(img->depth));
 253         }
 254         OUT_RING(ring, 0x00000000);
 255
 256         if (ubwc_enabled) {
 257                 OUT_RELOCW(ring, rsc->bo, img->ubwc_offset, 0, 0);
 258                 OUT_RING(ring, A6XX_IBO_9_FLAG_BUFFER_ARRAY_PITCH(rsc->ubwc_size));
 259                 OUT_RING(ring, A6XX_IBO_10_FLAG_BUFFER_PITCH(rsc->ubwc_pitch));
 260         } else {
 261                 OUT_RING(ring, 0x00000000);
 262                 OUT_RING(ring, 0x00000000);
 263                 OUT_RING(ring, 0x00000000);
 264                 OUT_RING(ring, 0x00000000);
 265         }
 266
 267         OUT_RING(ring, 0x00000000);
 268         OUT_RING(ring, 0x00000000);
 269         OUT_RING(ring, 0x00000000);
 270         OUT_RING(ring, 0x00000000);
 271         OUT_RING(ring, 0x00000000);
 272 }
 273
 274 /* Build combined image/SSBO "IBO" state, returns ownership of state reference */
 275 struct fd_ringbuffer *
 276 fd6_build_ibo_state(struct fd_context *ctx, const struct ir3_shader_variant *v,
 277                 enum pipe_shader_type shader)
 278 {
 279         struct fd_shaderbuf_stateobj *bufso = &ctx->shaderbuf[shader];
 280         struct fd_shaderimg_stateobj *imgso = &ctx->shaderimg[shader];
 281         const struct ir3_ibo_mapping *mapping = &v->image_mapping;
 282
 283         struct fd_ringbuffer *state =
 284                 fd_submit_new_ringbuffer(ctx->batch->submit,
 285                         mapping->num_ibo * 16 * 4, FD_RINGBUFFER_STREAMING);
 286
 287         assert(shader == PIPE_SHADER_COMPUTE || shader == PIPE_SHADER_FRAGMENT);
 288
 289         for (unsigned i = 0; i < mapping->num_ibo; i++) {
 290                 struct fd6_image img;
 291                 unsigned idx = mapping->ibo_to_image[i];
 292
 293                 if (idx & IBO_SSBO) {
 294                         translate_buf(&img, &bufso->sb[idx & ~IBO_SSBO]);
 295                 } else {
 296                         translate_image(&img, &imgso->si[idx]);
 297                 }
 298
 299                 emit_image_ssbo(state, &img);
 300         }
 301
 302         return state;
 303 }
 304
 305 static void fd6_set_shader_images(struct pipe_context *pctx,
 306                 enum pipe_shader_type shader,
 307                 unsigned start, unsigned count,
 308                 const struct pipe_image_view *images)
 309 {
 310         struct fd_context *ctx = fd_context(pctx);
 311         struct fd_shaderimg_stateobj *so = &ctx->shaderimg[shader];
 312
 313         fd_set_shader_images(pctx, shader, start, count, images);
 314
 315         if (!images)
 316                 return;
 317
 318         for (unsigned i = 0; i < count; i++) {
 319                 unsigned n = i + start;
 320                 struct pipe_image_view *buf = &so->si[n];
 321
 322                 if (!buf->resource)
 323                         continue;
 324
 325                 fd6_validate_format(ctx, fd_resource(buf->resource), buf->format);
 326         }
 327 }
 328
 329 void
 330 fd6_image_init(struct pipe_context *pctx)
 331 {
 332         pctx->set_shader_images = fd6_set_shader_images;
 333 }