src/gallium/drivers/nv50/nv50_state_validate.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 "nouveau/nouveau_stateobj.h"
  25
  26 static void
  27 nv50_state_validate_fb(struct nv50_context *nv50)
  28 {
  29         struct nouveau_grobj *tesla = nv50->screen->tesla;
  30         struct nouveau_stateobj *so = so_new(128, 18);
  31         struct pipe_framebuffer_state *fb = &nv50->framebuffer;
  32         unsigned i, w, h, gw = 0;
  33
  34         for (i = 0; i < fb->nr_cbufs; i++) {
  35                 struct pipe_texture *pt = fb->cbufs[i]->texture;
  36                 struct nouveau_bo *bo = nv50_miptree(pt)->bo;
  37
  38                 if (!gw) {
  39                         w = fb->cbufs[i]->width;
  40                         h = fb->cbufs[i]->height;
  41                         gw = 1;
  42                 } else {
  43                         assert(w == fb->cbufs[i]->width);
  44                         assert(h == fb->cbufs[i]->height);
  45                 }
  46
  47                 so_method(so, tesla, NV50TCL_RT_HORIZ(i), 2);
  48                 so_data  (so, fb->cbufs[i]->width);
  49                 so_data  (so, fb->cbufs[i]->height);
  50
  51                 so_method(so, tesla, NV50TCL_RT_ADDRESS_HIGH(i), 5);
  52                 so_reloc (so, bo, fb->cbufs[i]->offset, NOUVEAU_BO_VRAM |
  53                               NOUVEAU_BO_HIGH | NOUVEAU_BO_RDWR, 0, 0);
  54                 so_reloc (so, bo, fb->cbufs[i]->offset, NOUVEAU_BO_VRAM |
  55                               NOUVEAU_BO_LOW | NOUVEAU_BO_RDWR, 0, 0);
  56                 switch (fb->cbufs[i]->format) {
  57                 case PIPE_FORMAT_A8R8G8B8_UNORM:
  58                         so_data(so, 0xcf);
  59                         break;
  60                 case PIPE_FORMAT_R5G6B5_UNORM:
  61                         so_data(so, 0xe8);
  62                         break;
  63                 default:
  64                         NOUVEAU_ERR("AIIII unknown format %s\n",
  65                                     pf_name(fb->cbufs[i]->format));
  66                         so_data(so, 0xe6);
  67                         break;
  68                 }
  69                 so_data(so, bo->tile_mode << 4);
  70                 so_data(so, 0x00000000);
  71
  72                 so_method(so, tesla, 0x1224, 1);
  73                 so_data  (so, 1);
  74         }
  75
  76         if (fb->zsbuf) {
  77                 struct pipe_texture *pt = fb->zsbuf->texture;
  78                 struct nouveau_bo *bo = nv50_miptree(pt)->bo;
  79
  80                 if (!gw) {
  81                         w = fb->zsbuf->width;
  82                         h = fb->zsbuf->height;
  83                         gw = 1;
  84                 } else {
  85                         assert(w == fb->zsbuf->width);
  86                         assert(h == fb->zsbuf->height);
  87                 }
  88
  89                 so_method(so, tesla, NV50TCL_ZETA_ADDRESS_HIGH, 5);
  90                 so_reloc (so, bo, fb->zsbuf->offset, NOUVEAU_BO_VRAM |
  91                               NOUVEAU_BO_HIGH | NOUVEAU_BO_RDWR, 0, 0);
  92                 so_reloc (so, bo, fb->zsbuf->offset, NOUVEAU_BO_VRAM |
  93                               NOUVEAU_BO_LOW | NOUVEAU_BO_RDWR, 0, 0);
  94                 switch (fb->zsbuf->format) {
  95                 case PIPE_FORMAT_Z24S8_UNORM:
  96                 case PIPE_FORMAT_Z24X8_UNORM:
  97                         so_data(so, 0x16);
  98                         break;
  99                 case PIPE_FORMAT_Z16_UNORM:
 100                         so_data(so, 0x15);
 101                         break;
 102                 default:
 103                         NOUVEAU_ERR("AIIII unknown format %s\n",
 104                                     pf_name(fb->zsbuf->format));
 105                         so_data(so, 0x16);
 106                         break;
 107                 }
 108                 so_data(so, bo->tile_mode << 4);
 109                 so_data(so, 0x00000000);
 110
 111                 so_method(so, tesla, 0x1538, 1);
 112                 so_data  (so, 1);
 113                 so_method(so, tesla, 0x1228, 3);
 114                 so_data  (so, fb->zsbuf->width);
 115                 so_data  (so, fb->zsbuf->height);
 116                 so_data  (so, 0x00010001);
 117         }
 118
 119         so_method(so, tesla, NV50TCL_VIEWPORT_HORIZ, 2);
 120         so_data  (so, w << 16);
 121         so_data  (so, h << 16);
 122         so_method(so, tesla, 0x0e04, 2);
 123         so_data  (so, w << 16);
 124         so_data  (so, h << 16);
 125         so_method(so, tesla, 0xdf8, 2);
 126         so_data  (so, 0);
 127         so_data  (so, h);
 128
 129         so_ref(so, &nv50->state.fb);
 130         so_ref(NULL, &so);
 131 }
 132
 133 static void
 134 nv50_state_emit(struct nv50_context *nv50)
 135 {
 136         struct nv50_screen *screen = nv50->screen;
 137         struct nouveau_channel *chan = screen->base.channel;
 138
 139         if (nv50->pctx_id != screen->cur_pctx) {
 140                 nv50->state.dirty |= 0xffffffff;
 141                 screen->cur_pctx = nv50->pctx_id;
 142         }
 143
 144         if (nv50->state.dirty & NV50_NEW_FRAMEBUFFER)
 145                 so_emit(chan, nv50->state.fb);
 146         if (nv50->state.dirty & NV50_NEW_BLEND)
 147                 so_emit(chan, nv50->state.blend);
 148         if (nv50->state.dirty & NV50_NEW_ZSA)
 149                 so_emit(chan, nv50->state.zsa);
 150         if (nv50->state.dirty & NV50_NEW_VERTPROG)
 151                 so_emit(chan, nv50->state.vertprog);
 152         if (nv50->state.dirty & NV50_NEW_FRAGPROG)
 153                 so_emit(chan, nv50->state.fragprog);
 154         if (nv50->state.dirty & NV50_NEW_RASTERIZER)
 155                 so_emit(chan, nv50->state.rast);
 156         if (nv50->state.dirty & NV50_NEW_BLEND_COLOUR)
 157                 so_emit(chan, nv50->state.blend_colour);
 158         if (nv50->state.dirty & NV50_NEW_STIPPLE)
 159                 so_emit(chan, nv50->state.stipple);
 160         if (nv50->state.dirty & NV50_NEW_SCISSOR)
 161                 so_emit(chan, nv50->state.scissor);
 162         if (nv50->state.dirty & NV50_NEW_VIEWPORT)
 163                 so_emit(chan, nv50->state.viewport);
 164         if (nv50->state.dirty & NV50_NEW_SAMPLER)
 165                 so_emit(chan, nv50->state.tsc_upload);
 166         if (nv50->state.dirty & NV50_NEW_TEXTURE)
 167                 so_emit(chan, nv50->state.tic_upload);
 168         if (nv50->state.dirty & NV50_NEW_ARRAYS) {
 169                 so_emit(chan, nv50->state.vtxfmt);
 170                 so_emit(chan, nv50->state.vtxbuf);
 171         }
 172         nv50->state.dirty = 0;
 173
 174         so_emit_reloc_markers(chan, nv50->state.fb);
 175         so_emit_reloc_markers(chan, nv50->state.vertprog);
 176         so_emit_reloc_markers(chan, nv50->state.fragprog);
 177         so_emit_reloc_markers(chan, nv50->state.vtxbuf);
 178         so_emit_reloc_markers(chan, nv50->screen->static_init);
 179 }
 180
 181 boolean
 182 nv50_state_validate(struct nv50_context *nv50)
 183 {
 184         struct nouveau_grobj *tesla = nv50->screen->tesla;
 185         struct nouveau_stateobj *so;
 186         unsigned i;
 187
 188         if (nv50->dirty & NV50_NEW_FRAMEBUFFER)
 189                 nv50_state_validate_fb(nv50);
 190
 191         if (nv50->dirty & NV50_NEW_BLEND)
 192                 so_ref(nv50->blend->so, &nv50->state.blend);
 193
 194         if (nv50->dirty & NV50_NEW_ZSA)
 195                 so_ref(nv50->zsa->so, &nv50->state.zsa);
 196
 197         if (nv50->dirty & (NV50_NEW_VERTPROG | NV50_NEW_VERTPROG_CB))
 198                 nv50_vertprog_validate(nv50);
 199
 200         if (nv50->dirty & (NV50_NEW_FRAGPROG | NV50_NEW_FRAGPROG_CB))
 201                 nv50_fragprog_validate(nv50);
 202
 203         if (nv50->dirty & NV50_NEW_RASTERIZER)
 204                 so_ref(nv50->rasterizer->so, &nv50->state.rast);
 205
 206         if (nv50->dirty & NV50_NEW_BLEND_COLOUR) {
 207                 so = so_new(5, 0);
 208                 so_method(so, tesla, NV50TCL_BLEND_COLOR(0), 4);
 209                 so_data  (so, fui(nv50->blend_colour.color[0]));
 210                 so_data  (so, fui(nv50->blend_colour.color[1]));
 211                 so_data  (so, fui(nv50->blend_colour.color[2]));
 212                 so_data  (so, fui(nv50->blend_colour.color[3]));
 213                 so_ref(so, &nv50->state.blend_colour);
 214                 so_ref(NULL, &so);
 215         }
 216
 217         if (nv50->dirty & NV50_NEW_STIPPLE) {
 218                 so = so_new(33, 0);
 219                 so_method(so, tesla, NV50TCL_POLYGON_STIPPLE_PATTERN(0), 32);
 220                 for (i = 0; i < 32; i++)
 221                         so_data(so, nv50->stipple.stipple[i]);
 222                 so_ref(so, &nv50->state.stipple);
 223                 so_ref(NULL, &so);
 224         }
 225
 226         if (nv50->dirty & (NV50_NEW_SCISSOR | NV50_NEW_RASTERIZER)) {
 227                 struct pipe_rasterizer_state *rast = &nv50->rasterizer->pipe;
 228                 struct pipe_scissor_state *s = &nv50->scissor;
 229
 230                 if (nv50->state.scissor &&
 231                     (rast->scissor == 0 && nv50->state.scissor_enabled == 0))
 232                         goto scissor_uptodate;
 233                 nv50->state.scissor_enabled = rast->scissor;
 234
 235                 so = so_new(3, 0);
 236                 so_method(so, tesla, 0x0ff4, 2);
 237                 if (nv50->state.scissor_enabled) {
 238                         so_data(so, ((s->maxx - s->minx) << 16) | s->minx);
 239                         so_data(so, ((s->maxy - s->miny) << 16) | s->miny);
 240                 } else {
 241                         so_data(so, (8192 << 16));
 242                         so_data(so, (8192 << 16));
 243                 }
 244                 so_ref(so, &nv50->state.scissor);
 245                 so_ref(NULL, &so);
 246                 nv50->state.dirty |= NV50_NEW_SCISSOR;
 247         }
 248 scissor_uptodate:
 249
 250         if (nv50->dirty & (NV50_NEW_VIEWPORT | NV50_NEW_RASTERIZER)) {
 251                 unsigned bypass;
 252
 253                 if (!nv50->rasterizer->pipe.bypass_vs_clip_and_viewport)
 254                         bypass = 0;
 255                 else
 256                         bypass = 1;
 257
 258                 if (nv50->state.viewport &&
 259                     (bypass || !(nv50->dirty & NV50_NEW_VIEWPORT)) &&
 260                     nv50->state.viewport_bypass == bypass)
 261                         goto viewport_uptodate;
 262                 nv50->state.viewport_bypass = bypass;
 263
 264                 so = so_new(12, 0);
 265                 if (!bypass) {
 266                         so_method(so, tesla, NV50TCL_VIEWPORT_UNK1(0), 3);
 267                         so_data  (so, fui(nv50->viewport.translate[0]));
 268                         so_data  (so, fui(nv50->viewport.translate[1]));
 269                         so_data  (so, fui(nv50->viewport.translate[2]));
 270                         so_method(so, tesla, NV50TCL_VIEWPORT_UNK0(0), 3);
 271                         so_data  (so, fui(nv50->viewport.scale[0]));
 272                         so_data  (so, fui(-nv50->viewport.scale[1]));
 273                         so_data  (so, fui(nv50->viewport.scale[2]));
 274                         so_method(so, tesla, 0x192c, 1);
 275                         so_data  (so, 1);
 276                         so_method(so, tesla, 0x0f90, 1);
 277                         so_data  (so, 0);
 278                 } else {
 279                         so_method(so, tesla, 0x192c, 1);
 280                         so_data  (so, 0);
 281                         so_method(so, tesla, 0x0f90, 1);
 282                         so_data  (so, 1);
 283                 }
 284
 285                 so_ref(so, &nv50->state.viewport);
 286                 so_ref(NULL, &so);
 287                 nv50->state.dirty |= NV50_NEW_VIEWPORT;
 288         }
 289 viewport_uptodate:
 290
 291         if (nv50->dirty & NV50_NEW_SAMPLER) {
 292                 int i;
 293
 294                 so = so_new(nv50->sampler_nr * 8 + 3, 0);
 295                 so_method(so, tesla, 0x0f00, 1);
 296                 so_data  (so, NV50_CB_TSC);
 297                 so_method(so, tesla, 0x40000f04, nv50->sampler_nr * 8);
 298                 for (i = 0; i < nv50->sampler_nr; i++)
 299                         so_datap (so, nv50->sampler[i]->tsc, 8);
 300                 so_ref(so, &nv50->state.tsc_upload);
 301                 so_ref(NULL, &so);
 302         }
 303
 304         if (nv50->dirty & (NV50_NEW_TEXTURE | NV50_NEW_SAMPLER))
 305                 nv50_tex_validate(nv50);
 306
 307         if (nv50->dirty & NV50_NEW_ARRAYS)
 308                 nv50_vbo_validate(nv50);
 309
 310         nv50->state.dirty |= nv50->dirty;
 311         nv50->dirty = 0;
 312         nv50_state_emit(nv50);
 313
 314         return TRUE;
 315 }
 316