src/gallium/drivers/nv30/nv30_fragtex.c

   1 #include "nv30_context.h"
   2
   3 static INLINE int log2i(int i)
   4 {
   5         int r = 0;
   6
   7         if (i & 0xffff0000) {
   8                 i >>= 16;
   9                 r += 16;
  10         }
  11         if (i & 0x0000ff00) {
  12                 i >>= 8;
  13                 r += 8;
  14         }
  15         if (i & 0x000000f0) {
  16                 i >>= 4;
  17                 r += 4;
  18         }
  19         if (i & 0x0000000c) {
  20                 i >>= 2;
  21                 r += 2;
  22         }
  23         if (i & 0x00000002) {
  24                 r += 1;
  25         }
  26         return r;
  27 }
  28
  29 #define _(m,tf,ts0x,ts0y,ts0z,ts0w,ts1x,ts1y,ts1z,ts1w,swsurf)                 \
  30 {                                                                              \
  31   TRUE,                                                                        \
  32   PIPE_FORMAT_##m,                                                             \
  33   NV34TCL_TX_FORMAT_FORMAT_##tf,                                               \
  34   (NV34TCL_TX_SWIZZLE_S0_X_##ts0x | NV34TCL_TX_SWIZZLE_S0_Y_##ts0y |           \
  35    NV34TCL_TX_SWIZZLE_S0_Z_##ts0z | NV34TCL_TX_SWIZZLE_S0_W_##ts0w |           \
  36    NV34TCL_TX_SWIZZLE_S1_X_##ts1x | NV34TCL_TX_SWIZZLE_S1_Y_##ts1y |           \
  37    NV34TCL_TX_SWIZZLE_S1_Z_##ts1z | NV34TCL_TX_SWIZZLE_S1_W_##ts1w),           \
  38   swsurf                                                                       \
  39 }
  40
  41 struct nv30_texture_format {
  42         boolean defined;
  43         uint    pipe;
  44         int     format;
  45         int     swizzle;
  46         int     swizzled_surface;
  47 };
  48
  49 static struct nv30_texture_format
  50 nv30_texture_formats[] = {
  51         _(A8R8G8B8_UNORM, A8R8G8B8,   S1,   S1,   S1,   S1, X, Y, Z, W, 1),
  52         _(A1R5G5B5_UNORM, A1R5G5B5,   S1,   S1,   S1,   S1, X, Y, Z, W, 1),
  53         _(A4R4G4B4_UNORM, A4R4G4B4,   S1,   S1,   S1,   S1, X, Y, Z, W, 1),
  54         _(R5G6B5_UNORM  , R5G6B5  ,   S1,   S1,   S1,  ONE, X, Y, Z, W, 1),
  55         _(L8_UNORM      , L8      ,   S1,   S1,   S1,  ONE, X, X, X, X, 1),
  56         _(A8_UNORM      , L8      , ZERO, ZERO, ZERO,   S1, X, X, X, X, 1),
  57         _(I8_UNORM      , L8      ,   S1,   S1,   S1,   S1, X, X, X, X, 1),
  58         _(A8L8_UNORM    , A8L8    ,   S1,   S1,   S1,   S1, X, X, X, Y, 1),
  59 //      _(Z16_UNORM     , Z16     ,   S1,   S1,   S1,  ONE, X, X, X, X, 0),
  60 //      _(Z24S8_UNORM   , Z24     ,   S1,   S1,   S1,  ONE, X, X, X, X, 0),
  61         _(DXT1_RGB      , DXT1    ,   S1,   S1,   S1,  ONE, X, Y, Z, W, 0),
  62         _(DXT1_RGBA     , DXT1    ,   S1,   S1,   S1,   S1, X, Y, Z, W, 0),
  63         _(DXT3_RGBA     , DXT3    ,   S1,   S1,   S1,   S1, X, Y, Z, W, 0),
  64         _(DXT5_RGBA     , DXT5    ,   S1,   S1,   S1,   S1, X, Y, Z, W, 0),
  65         {},
  66 };
  67
  68 static struct nv30_texture_format *
  69 nv30_fragtex_format(uint pipe_format)
  70 {
  71         struct nv30_texture_format *tf = nv30_texture_formats;
  72         char fs[128];
  73
  74         while (tf->defined) {
  75                 if (tf->pipe == pipe_format)
  76                         return tf;
  77                 tf++;
  78         }
  79
  80         NOUVEAU_ERR("unknown texture format %s\n", pf_name(pipe_format));
  81         return NULL;
  82 }
  83
  84
  85 static struct nouveau_stateobj *
  86 nv30_fragtex_build(struct nv30_context *nv30, int unit)
  87 {
  88         struct nv30_sampler_state *ps = nv30->tex_sampler[unit];
  89         struct nv30_miptree *nv30mt = nv30->tex_miptree[unit];
  90         struct pipe_texture *pt = &nv30mt->base;
  91         struct nv30_texture_format *tf;
  92         struct nouveau_stateobj *so;
  93         uint32_t txf, txs /*, txp*/;
  94         /*int swizzled = 0;*/ /*XXX: implement in region code? */
  95         unsigned tex_flags = NOUVEAU_BO_VRAM | NOUVEAU_BO_GART | NOUVEAU_BO_RD;
  96
  97         tf = nv30_fragtex_format(pt->format);
  98         if (!tf)
  99                 assert(0);
 100
 101         tex_flags |= (tf->swizzled_surface ? NOUVEAU_BO_SWIZZLED : 0);
 102
 103         txf  = tf->format;
 104         txf |= ((pt->last_level>0) ? NV34TCL_TX_FORMAT_MIPMAP : 0);
 105         txf |= log2i(pt->width[0]) << 20;
 106         txf |= log2i(pt->height[0]) << 24;
 107         txf |= log2i(pt->depth[0]) << 28;
 108         txf |= NV34TCL_TX_FORMAT_NO_BORDER | 0x10000;
 109
 110         switch (pt->target) {
 111         case PIPE_TEXTURE_CUBE:
 112                 txf |= NV34TCL_TX_FORMAT_CUBIC;
 113                 /* fall-through */
 114         case PIPE_TEXTURE_2D:
 115                 txf |= NV34TCL_TX_FORMAT_DIMS_2D;
 116                 break;
 117         case PIPE_TEXTURE_3D:
 118                 txf |= NV34TCL_TX_FORMAT_DIMS_3D;
 119                 break;
 120         case PIPE_TEXTURE_1D:
 121                 txf |= NV34TCL_TX_FORMAT_DIMS_1D;
 122                 break;
 123         default:
 124                 NOUVEAU_ERR("Unknown target %d\n", pt->target);
 125                 return NULL;
 126         }
 127
 128         txs = tf->swizzle;
 129
 130         so = so_new(16, 2);
 131         so_method(so, nv30->screen->rankine, NV34TCL_TX_OFFSET(unit), 8);
 132         so_reloc (so, nv30mt->buffer, 0, tex_flags | NOUVEAU_BO_LOW, 0, 0);
 133         so_reloc (so, nv30mt->buffer, txf, tex_flags | NOUVEAU_BO_OR,
 134                   NV34TCL_TX_FORMAT_DMA0, NV34TCL_TX_FORMAT_DMA1);
 135         so_data  (so, ps->wrap);
 136         so_data  (so, NV34TCL_TX_ENABLE_ENABLE | ps->en);
 137         so_data  (so, txs);
 138         so_data  (so, ps->filt | 0x2000 /*voodoo*/);
 139         so_data  (so, (pt->width[0] << NV34TCL_TX_NPOT_SIZE_W_SHIFT) |
 140                        pt->height[0]);
 141         so_data  (so, ps->bcol);
 142
 143         return so;
 144 }
 145
 146 static boolean
 147 nv30_fragtex_validate(struct nv30_context *nv30)
 148 {
 149         struct nv30_fragment_program *fp = nv30->fragprog;
 150         struct nv30_state *state = &nv30->state;
 151         struct nouveau_stateobj *so;
 152         unsigned samplers, unit;
 153
 154         samplers = state->fp_samplers & ~fp->samplers;
 155         while (samplers) {
 156                 unit = ffs(samplers) - 1;
 157                 samplers &= ~(1 << unit);
 158
 159                 so = so_new(2, 0);
 160                 so_method(so, nv30->screen->rankine, NV34TCL_TX_ENABLE(unit), 1);
 161                 so_data  (so, 0);
 162                 so_ref(so, &nv30->state.hw[NV30_STATE_FRAGTEX0 + unit]);
 163                 state->dirty |= (1ULL << (NV30_STATE_FRAGTEX0 + unit));
 164         }
 165
 166         samplers = nv30->dirty_samplers & fp->samplers;
 167         while (samplers) {
 168                 unit = ffs(samplers) - 1;
 169                 samplers &= ~(1 << unit);
 170
 171                 so = nv30_fragtex_build(nv30, unit);
 172                 so_ref(so, &nv30->state.hw[NV30_STATE_FRAGTEX0 + unit]);
 173                 state->dirty |= (1ULL << (NV30_STATE_FRAGTEX0 + unit));
 174         }
 175
 176         nv30->state.fp_samplers = fp->samplers;
 177         return FALSE;
 178 }
 179
 180 struct nv30_state_entry nv30_state_fragtex = {
 181         .validate = nv30_fragtex_validate,
 182         .dirty = {
 183                 .pipe = NV30_NEW_SAMPLER | NV30_NEW_FRAGPROG,
 184                 .hw = 0
 185         }
 186 };