src/gallium/drivers/nv50/nv50_tex.c

   1 /*
   2  * Copyright 2008 Ben Skeggs
   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, sublicense,
   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 shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  18  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  19  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  */
  22
  23 #include "nv50_context.h"
  24 #include "nv50_texture.h"
  25 #include "nv50_resource.h"
  26
  27 #include "nouveau/nouveau_stateobj.h"
  28 #include "nouveau/nouveau_reloc.h"
  29
  30 #include "util/u_format.h"
  31
  32 #define _MIXED(pf, t0, t1, t2, t3, cr, cg, cb, ca, f)           \
  33 [PIPE_FORMAT_##pf] = (                                          \
  34         NV50TIC_0_0_MAPR_##cr | NV50TIC_0_0_TYPER_##t0 |        \
  35         NV50TIC_0_0_MAPG_##cg | NV50TIC_0_0_TYPEG_##t1 |        \
  36         NV50TIC_0_0_MAPB_##cb | NV50TIC_0_0_TYPEB_##t2 |        \
  37         NV50TIC_0_0_MAPA_##ca | NV50TIC_0_0_TYPEA_##t3 |        \
  38         NV50TIC_0_0_FMT_##f)
  39
  40 #define _(pf, t, cr, cg, cb, ca, f) _MIXED(pf, t, t, t, t, cr, cg, cb, ca, f)
  41
  42 static const uint32_t nv50_texture_formats[PIPE_FORMAT_COUNT] =
  43 {
  44         _(B8G8R8A8_UNORM, UNORM, C2, C1, C0, C3,  8_8_8_8),
  45         _(B8G8R8A8_SRGB,  UNORM, C2, C1, C0, C3,  8_8_8_8),
  46         _(B8G8R8X8_UNORM, UNORM, C2, C1, C0, ONE, 8_8_8_8),
  47         _(B8G8R8X8_SRGB,  UNORM, C2, C1, C0, ONE, 8_8_8_8),
  48         _(B5G5R5A1_UNORM, UNORM, C2, C1, C0, C3,  1_5_5_5),
  49         _(B4G4R4A4_UNORM, UNORM, C2, C1, C0, C3,  4_4_4_4),
  50
  51         _(B5G6R5_UNORM, UNORM, C2, C1, C0, ONE, 5_6_5),
  52
  53         _(L8_UNORM, UNORM, C0, C0, C0, ONE, 8),
  54         _(L8_SRGB,  UNORM, C0, C0, C0, ONE, 8),
  55         _(A8_UNORM, UNORM, ZERO, ZERO, ZERO, C0, 8),
  56         _(I8_UNORM, UNORM, C0, C0, C0, C0, 8),
  57
  58         _(L8A8_UNORM, UNORM, C0, C0, C0, C1, 8_8),
  59         _(L8A8_SRGB,  UNORM, C0, C0, C0, C1, 8_8),
  60
  61         _(DXT1_RGB, UNORM, C0, C1, C2, ONE, DXT1),
  62         _(DXT1_RGBA, UNORM, C0, C1, C2, C3, DXT1),
  63         _(DXT3_RGBA, UNORM, C0, C1, C2, C3, DXT3),
  64         _(DXT5_RGBA, UNORM, C0, C1, C2, C3, DXT5),
  65
  66         _MIXED(S8_USCALED_Z24_UNORM, UINT, UNORM, UINT, UINT, C1, C1, C1, ONE, 24_8),
  67         _MIXED(Z24_UNORM_S8_USCALED, UNORM, UINT, UINT, UINT, C0, C0, C0, ONE, 8_24),
  68
  69         _(R16G16B16A16_SNORM, UNORM, C0, C1, C2, C3, 16_16_16_16),
  70         _(R16G16B16A16_UNORM, SNORM, C0, C1, C2, C3, 16_16_16_16),
  71         _(R32G32B32A32_FLOAT, FLOAT, C0, C1, C2, C3, 32_32_32_32),
  72
  73         _(R16G16_SNORM, SNORM, C0, C1, ZERO, ONE, 16_16),
  74         _(R16G16_UNORM, UNORM, C0, C1, ZERO, ONE, 16_16),
  75
  76         _MIXED(Z32_FLOAT, FLOAT, UINT, UINT, UINT, C0, C0, C0, ONE, 32_DEPTH)
  77 };
  78
  79 #undef _
  80 #undef _MIXED
  81
  82 static INLINE uint32_t
  83 nv50_tic_swizzle(uint32_t tc, unsigned swz)
  84 {
  85         switch (swz) {
  86         case PIPE_SWIZZLE_RED:
  87                 return (tc & NV50TIC_0_0_MAPR_MASK) >> NV50TIC_0_0_MAPR_SHIFT;
  88         case PIPE_SWIZZLE_GREEN:
  89                 return (tc & NV50TIC_0_0_MAPG_MASK) >> NV50TIC_0_0_MAPG_SHIFT;
  90         case PIPE_SWIZZLE_BLUE:
  91                 return (tc & NV50TIC_0_0_MAPB_MASK) >> NV50TIC_0_0_MAPB_SHIFT;
  92         case PIPE_SWIZZLE_ALPHA:
  93                 return (tc & NV50TIC_0_0_MAPA_MASK) >> NV50TIC_0_0_MAPA_SHIFT;
  94         case PIPE_SWIZZLE_ONE:
  95                 return 7;
  96         case PIPE_SWIZZLE_ZERO:
  97         default:
  98                 return 0;
  99         }
 100 }
 101
 102 boolean
 103 nv50_tex_construct(struct nv50_sampler_view *view)
 104 {
 105         const struct util_format_description *desc;
 106         struct nv50_miptree *mt = nv50_miptree(view->pipe.texture);
 107         uint32_t swz[4], *tic = view->tic;
 108
 109         tic[0] = nv50_texture_formats[view->pipe.format];
 110
 111         swz[0] = nv50_tic_swizzle(tic[0], view->pipe.swizzle_r);
 112         swz[1] = nv50_tic_swizzle(tic[0], view->pipe.swizzle_g);
 113         swz[2] = nv50_tic_swizzle(tic[0], view->pipe.swizzle_b);
 114         swz[3] = nv50_tic_swizzle(tic[0], view->pipe.swizzle_a);
 115         view->tic[0] = (tic[0] &  ~NV50TIC_0_0_SWIZZLE_MASK) |
 116                 (swz[0] << NV50TIC_0_0_MAPR_SHIFT) |
 117                 (swz[1] << NV50TIC_0_0_MAPG_SHIFT) |
 118                 (swz[2] << NV50TIC_0_0_MAPB_SHIFT) |
 119                 (swz[3] << NV50TIC_0_0_MAPA_SHIFT);
 120
 121         tic[2] = 0x50001000;
 122         tic[2] |= ((mt->base.bo->tile_mode & 0x0f) << 22) |
 123                   ((mt->base.bo->tile_mode & 0xf0) << 21);
 124
 125         desc = util_format_description(mt->base.base.format);
 126         if (desc->colorspace == UTIL_FORMAT_COLORSPACE_SRGB)
 127                 tic[2] |= NV50TIC_0_2_COLORSPACE_SRGB;
 128
 129         switch (mt->base.base.target) {
 130         case PIPE_TEXTURE_1D:
 131                 tic[2] |= NV50TIC_0_2_TARGET_1D;
 132                 break;
 133         case PIPE_TEXTURE_2D:
 134                 tic[2] |= NV50TIC_0_2_TARGET_2D;
 135                 break;
 136         case PIPE_TEXTURE_3D:
 137                 tic[2] |= NV50TIC_0_2_TARGET_3D;
 138                 break;
 139         case PIPE_TEXTURE_CUBE:
 140                 tic[2] |= NV50TIC_0_2_TARGET_CUBE;
 141                 break;
 142         default:
 143                 NOUVEAU_ERR("invalid texture target: %d\n",
 144                             mt->base.base.target);
 145                 return FALSE;
 146         }
 147
 148         tic[3] = 0x00300000;
 149
 150         tic[4] = (1 << 31) | mt->base.base.width0;
 151         tic[5] = (mt->base.base.last_level << 28) |
 152                 (mt->base.base.depth0 << 16) | mt->base.base.height0;
 153
 154         tic[6] = 0x03000000;
 155
 156         tic[7] = (view->pipe.last_level << 4) | view->pipe.first_level;
 157
 158         return TRUE;
 159 }
 160
 161 static int
 162 nv50_validate_textures(struct nv50_context *nv50, struct nouveau_stateobj *so,
 163                        unsigned p)
 164 {
 165         struct nouveau_grobj *eng2d = nv50->screen->eng2d;
 166         struct nouveau_grobj *tesla = nv50->screen->tesla;
 167         unsigned unit, j;
 168
 169         const unsigned rll = NOUVEAU_BO_VRAM | NOUVEAU_BO_RD | NOUVEAU_BO_LOW;
 170         const unsigned rlh = NOUVEAU_BO_VRAM | NOUVEAU_BO_RD | NOUVEAU_BO_HIGH
 171                 | NOUVEAU_BO_OR;
 172
 173         nv50_so_init_sifc(nv50, so, nv50->screen->tic, NOUVEAU_BO_VRAM,
 174                           p * (32 * 8 * 4), nv50->sampler_view_nr[p] * 8 * 4);
 175
 176         for (unit = 0; unit < nv50->sampler_view_nr[p]; ++unit) {
 177                 struct nv50_sampler_view *view =
 178                         nv50_sampler_view(nv50->sampler_views[p][unit]);
 179
 180                 so_method(so, eng2d, NV50_2D_SIFC_DATA | (2 << 29), 8);
 181                 if (view) {
 182                         uint32_t tic2 = view->tic[2];
 183                         struct nv50_miptree *mt =
 184                                 nv50_miptree(view->pipe.texture);
 185
 186                         tic2 &= ~NV50TIC_0_2_NORMALIZED_COORDS;
 187                         if (nv50->sampler[p][unit]->normalized)
 188                                 tic2 |= NV50TIC_0_2_NORMALIZED_COORDS;
 189                         view->tic[2] = tic2;
 190
 191                         so_data  (so, view->tic[0]);
 192                         so_reloc (so, mt->base.bo, 0, rll, 0, 0);
 193                         so_reloc (so, mt->base.bo, 0, rlh, tic2, tic2);
 194                         so_datap (so, &view->tic[3], 5);
 195
 196                         /* Set TEX insn $t src binding $unit in program type p
 197                          * to TIC, TSC entry (32 * p + unit), mark valid (1).
 198                          */
 199                         so_method(so, tesla, NV50TCL_BIND_TIC(p), 1);
 200                         so_data  (so, ((32 * p + unit) << 9) | (unit << 1) | 1);
 201                 } else {
 202                         for (j = 0; j < 8; ++j)
 203                                 so_data(so, 0);
 204                         so_method(so, tesla, NV50TCL_BIND_TIC(p), 1);
 205                         so_data  (so, (unit << 1) | 0);
 206                 }
 207         }
 208
 209         for (; unit < nv50->state.sampler_view_nr[p]; unit++) {
 210                 /* Make other bindings invalid. */
 211                 so_method(so, tesla, NV50TCL_BIND_TIC(p), 1);
 212                 so_data  (so, (unit << 1) | 0);
 213         }
 214
 215         nv50->state.sampler_view_nr[p] = nv50->sampler_view_nr[p];
 216         return TRUE;
 217 }
 218
 219 static void
 220 nv50_emit_texture_relocs(struct nv50_context *nv50, int prog)
 221 {
 222         struct nouveau_channel *chan = nv50->screen->base.channel;
 223         struct nouveau_bo *tic = nv50->screen->tic;
 224         int unit;
 225
 226         for (unit = 0; unit < nv50->sampler_view_nr[prog]; unit++) {
 227                 struct nv50_sampler_view *view;
 228                 struct nv50_miptree *mt;
 229                 const unsigned base = ((prog * 32) + unit) * 32;
 230
 231                 view = nv50_sampler_view(nv50->sampler_views[prog][unit]);
 232                 if (!view)
 233                         continue;
 234                 mt = nv50_miptree(view->pipe.texture);
 235
 236                 nouveau_reloc_emit(chan, tic, base + 4, NULL, mt->base.bo, 0, 0,
 237                                    NOUVEAU_BO_VRAM | NOUVEAU_BO_RD |
 238                                    NOUVEAU_BO_LOW, 0, 0);
 239                 nouveau_reloc_emit(chan, tic, base + 8, NULL, mt->base.bo, 0, 0,
 240                                    NOUVEAU_BO_VRAM | NOUVEAU_BO_RD |
 241                                    NOUVEAU_BO_HIGH, view->tic[2], view->tic[2]);
 242         }
 243 }
 244
 245 void
 246 nv50_tex_relocs(struct nv50_context *nv50)
 247 {
 248         nv50_emit_texture_relocs(nv50, 2); /* FP */
 249         nv50_emit_texture_relocs(nv50, 0); /* VP */
 250 }
 251
 252 struct nouveau_stateobj *
 253 nv50_tex_validate(struct nv50_context *nv50)
 254 {
 255         struct nouveau_stateobj *so;
 256         struct nouveau_grobj *tesla = nv50->screen->tesla;
 257         unsigned p, m = 0, d = 0, r = 0;
 258
 259         for (p = 0; p < 3; ++p) {
 260                 unsigned nr = MAX2(nv50->sampler_view_nr[p],
 261                                    nv50->state.sampler_view_nr[p]);
 262                 m += nr;
 263                 d += nr;
 264                 r += nv50->sampler_view_nr[p];
 265         }
 266         m = m * 2 + 3 * 4 + 1;
 267         d = d * 9 + 3 * 19 + 1;
 268         r = r * 2 + 3 * 2;
 269
 270         so = so_new(m, d, r);
 271
 272         if (nv50_validate_textures(nv50, so, 0) == FALSE ||
 273             nv50_validate_textures(nv50, so, 2) == FALSE) {
 274                 so_ref(NULL, &so);
 275
 276                 NOUVEAU_ERR("failed tex validate\n");
 277                 return NULL;
 278         }
 279
 280         so_method(so, tesla, 0x1330, 1); /* flush TIC */
 281         so_data  (so, 0);
 282
 283         return so;
 284 }