src/mesa/drivers/dri/intel/intel_buffers.c

   1 /**************************************************************************
   2  *
   3  * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
   4  * All Rights Reserved.
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a
   7  * copy of this software and associated documentation files (the
   8  * "Software"), to deal in the Software without restriction, including
   9  * without limitation the rights to use, copy, modify, merge, publish,
  10  * distribute, sub license, and/or sell copies of the Software, and to
  11  * permit persons to whom the Software is furnished to do so, subject to
  12  * the following conditions:
  13  *
  14  * The above copyright notice and this permission notice (including the
  15  * next paragraph) shall be included in all copies or substantial portions
  16  * of the Software.
  17  *
  18  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  20  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  21  * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
  22  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  23  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  24  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  25  *
  26  **************************************************************************/
  27
  28 #include "intel_screen.h"
  29 #include "intel_context.h"
  30 #include "intel_blit.h"
  31 #include "intel_buffers.h"
  32 #include "intel_chipset.h"
  33 #include "intel_depthstencil.h"
  34 #include "intel_fbo.h"
  35 #include "intel_regions.h"
  36 #include "intel_batchbuffer.h"
  37 #include "intel_reg.h"
  38 #include "context.h"
  39 #include "utils.h"
  40 #include "drirenderbuffer.h"
  41 #include "framebuffer.h"
  42 #include "swrast/swrast.h"
  43 #include "vblank.h"
  44 #include "i915_drm.h"
  45
  46 /* This block can be removed when libdrm >= 2.3.1 is required */
  47
  48 #ifndef DRM_IOCTL_I915_FLIP
  49
  50 #define DRM_VBLANK_FLIP 0x8000000
  51
  52 typedef struct drm_i915_flip {
  53    int pipes;
  54 } drm_i915_flip_t;
  55
  56 #undef DRM_IOCTL_I915_FLIP
  57 #define DRM_IOCTL_I915_FLIP DRM_IOW(DRM_COMMAND_BASE + DRM_I915_FLIP, \
  58                                     drm_i915_flip_t)
  59
  60 #endif
  61
  62 #define FILE_DEBUG_FLAG DEBUG_BLIT
  63
  64 /**
  65  * XXX move this into a new dri/common/cliprects.c file.
  66  */
  67 GLboolean
  68 intel_intersect_cliprects(drm_clip_rect_t * dst,
  69                           const drm_clip_rect_t * a,
  70                           const drm_clip_rect_t * b)
  71 {
  72    GLint bx = b->x1;
  73    GLint by = b->y1;
  74    GLint bw = b->x2 - bx;
  75    GLint bh = b->y2 - by;
  76
  77    if (bx < a->x1)
  78       bw -= a->x1 - bx, bx = a->x1;
  79    if (by < a->y1)
  80       bh -= a->y1 - by, by = a->y1;
  81    if (bx + bw > a->x2)
  82       bw = a->x2 - bx;
  83    if (by + bh > a->y2)
  84       bh = a->y2 - by;
  85    if (bw <= 0)
  86       return GL_FALSE;
  87    if (bh <= 0)
  88       return GL_FALSE;
  89
  90    dst->x1 = bx;
  91    dst->y1 = by;
  92    dst->x2 = bx + bw;
  93    dst->y2 = by + bh;
  94
  95    return GL_TRUE;
  96 }
  97
  98 /**
  99  * Return pointer to current color drawing region, or NULL.
 100  */
 101 struct intel_region *
 102 intel_drawbuf_region(struct intel_context *intel)
 103 {
 104    struct intel_renderbuffer *irbColor =
 105       intel_renderbuffer(intel->ctx.DrawBuffer->_ColorDrawBuffers[0]);
 106    if (irbColor)
 107       return irbColor->region;
 108    else
 109       return NULL;
 110 }
 111
 112 /**
 113  * Return pointer to current color reading region, or NULL.
 114  */
 115 struct intel_region *
 116 intel_readbuf_region(struct intel_context *intel)
 117 {
 118    struct intel_renderbuffer *irb
 119       = intel_renderbuffer(intel->ctx.ReadBuffer->_ColorReadBuffer);
 120    if (irb)
 121       return irb->region;
 122    else
 123       return NULL;
 124 }
 125
 126
 127
 128 /**
 129  * Update the following fields for rendering to a user-created FBO:
 130  *   intel->numClipRects
 131  *   intel->pClipRects
 132  *   intel->drawX
 133  *   intel->drawY
 134  */
 135 static void
 136 intelSetRenderbufferClipRects(struct intel_context *intel)
 137 {
 138    assert(intel->ctx.DrawBuffer->Width > 0);
 139    assert(intel->ctx.DrawBuffer->Height > 0);
 140    intel->fboRect.x1 = 0;
 141    intel->fboRect.y1 = 0;
 142    intel->fboRect.x2 = intel->ctx.DrawBuffer->Width;
 143    intel->fboRect.y2 = intel->ctx.DrawBuffer->Height;
 144    intel->numClipRects = 1;
 145    intel->pClipRects = &intel->fboRect;
 146    intel->drawX = 0;
 147    intel->drawY = 0;
 148 }
 149
 150
 151 /**
 152  * As above, but for rendering to front buffer of a window.
 153  * \sa intelSetRenderbufferClipRects
 154  */
 155 static void
 156 intelSetFrontClipRects(struct intel_context *intel)
 157 {
 158    __DRIdrawablePrivate *dPriv = intel->driDrawable;
 159
 160    if (!dPriv)
 161       return;
 162
 163    intel->numClipRects = dPriv->numClipRects;
 164    intel->pClipRects = dPriv->pClipRects;
 165    intel->drawX = dPriv->x;
 166    intel->drawY = dPriv->y;
 167 }
 168
 169
 170 /**
 171  * As above, but for rendering to back buffer of a window.
 172  */
 173 static void
 174 intelSetBackClipRects(struct intel_context *intel)
 175 {
 176    __DRIdrawablePrivate *dPriv = intel->driDrawable;
 177    struct intel_framebuffer *intel_fb;
 178
 179    if (!dPriv)
 180       return;
 181
 182    intel_fb = dPriv->driverPrivate;
 183
 184    if (intel_fb->pf_active || dPriv->numBackClipRects == 0) {
 185       /* use the front clip rects */
 186       intel->numClipRects = dPriv->numClipRects;
 187       intel->pClipRects = dPriv->pClipRects;
 188       intel->drawX = dPriv->x;
 189       intel->drawY = dPriv->y;
 190    }
 191    else {
 192       /* use the back clip rects */
 193       intel->numClipRects = dPriv->numBackClipRects;
 194       intel->pClipRects = dPriv->pBackClipRects;
 195       intel->drawX = dPriv->backX;
 196       intel->drawY = dPriv->backY;
 197    }
 198 }
 199
 200 #ifdef I915
 201 static void
 202 intelUpdatePageFlipping(struct intel_context *intel,
 203                         GLint areaA, GLint areaB)
 204 {
 205    __DRIdrawablePrivate *dPriv = intel->driDrawable;
 206    struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
 207    GLboolean pf_active;
 208    GLint pf_planes;
 209
 210    /* Update page flipping info */
 211    pf_planes = 0;
 212
 213    if (areaA > 0)
 214       pf_planes |= 1;
 215
 216    if (areaB > 0)
 217       pf_planes |= 2;
 218
 219    intel_fb->pf_current_page = (intel->sarea->pf_current_page >>
 220                                 (intel_fb->pf_planes & 0x2)) & 0x3;
 221
 222    intel_fb->pf_num_pages = intel->intelScreen->third.handle ? 3 : 2;
 223
 224    pf_active = pf_planes && (pf_planes & intel->sarea->pf_active) == pf_planes;
 225
 226    if (INTEL_DEBUG & DEBUG_LOCK)
 227       if (pf_active != intel_fb->pf_active)
 228          _mesa_printf("%s - Page flipping %sactive\n", __progname,
 229                       pf_active ? "" : "in");
 230
 231    if (pf_active) {
 232       /* Sync pages between planes if flipping on both at the same time */
 233       if (pf_planes == 0x3 && pf_planes != intel_fb->pf_planes &&
 234           (intel->sarea->pf_current_page & 0x3) !=
 235           (((intel->sarea->pf_current_page) >> 2) & 0x3)) {
 236          drm_i915_flip_t flip;
 237
 238          if (intel_fb->pf_current_page ==
 239              (intel->sarea->pf_current_page & 0x3)) {
 240             /* XXX: This is ugly, but emitting two flips 'in a row' can cause
 241              * lockups for unknown reasons.
 242              */
 243             intel->sarea->pf_current_page =
 244                intel->sarea->pf_current_page & 0x3;
 245             intel->sarea->pf_current_page |=
 246                ((intel_fb->pf_current_page + intel_fb->pf_num_pages - 1) %
 247                 intel_fb->pf_num_pages) << 2;
 248
 249             flip.pipes = 0x2;
 250          } else {
 251             intel->sarea->pf_current_page =
 252                intel->sarea->pf_current_page & (0x3 << 2);
 253             intel->sarea->pf_current_page |=
 254                (intel_fb->pf_current_page + intel_fb->pf_num_pages - 1) %
 255                intel_fb->pf_num_pages;
 256
 257             flip.pipes = 0x1;
 258          }
 259
 260          drmCommandWrite(intel->driFd, DRM_I915_FLIP, &flip, sizeof(flip));
 261       }
 262
 263       intel_fb->pf_planes = pf_planes;
 264    }
 265
 266    intel_fb->pf_active = pf_active;
 267    intel_flip_renderbuffers(intel_fb);
 268    intel_draw_buffer(&intel->ctx, intel->ctx.DrawBuffer);
 269 }
 270 #endif /* I915 */
 271
 272 /**
 273  * This will be called whenever the currently bound window is moved/resized.
 274  * XXX: actually, it seems to NOT be called when the window is only moved (BP).
 275  */
 276 void
 277 intelWindowMoved(struct intel_context *intel)
 278 {
 279    GLcontext *ctx = &intel->ctx;
 280    __DRIdrawablePrivate *dPriv = intel->driDrawable;
 281    struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
 282
 283    if (!intel->ctx.DrawBuffer) {
 284       /* when would this happen? -BP */
 285       intelSetFrontClipRects(intel);
 286    }
 287    else if (intel->ctx.DrawBuffer->Name != 0) {
 288       /* drawing to user-created FBO - do nothing */
 289       /* Cliprects would be set from intelDrawBuffer() */
 290    }
 291    else {
 292       /* drawing to a window */
 293       switch (intel_fb->Base._ColorDrawBufferIndexes[0]) {
 294       case BUFFER_FRONT_LEFT:
 295          intelSetFrontClipRects(intel);
 296          break;
 297       case BUFFER_BACK_LEFT:
 298          intelSetBackClipRects(intel);
 299          break;
 300       default:
 301          intelSetFrontClipRects(intel);
 302       }
 303
 304    }
 305
 306    if (!intel->intelScreen->driScrnPriv->dri2.enabled &&
 307        intel->intelScreen->driScrnPriv->ddx_version.minor >= 7) {
 308       volatile struct drm_i915_sarea *sarea = intel->sarea;
 309       drm_clip_rect_t drw_rect = { .x1 = dPriv->x, .x2 = dPriv->x + dPriv->w,
 310                                    .y1 = dPriv->y, .y2 = dPriv->y + dPriv->h };
 311       drm_clip_rect_t planeA_rect = { .x1 = sarea->planeA_x, .y1 = sarea->planeA_y,
 312                                      .x2 = sarea->planeA_x + sarea->planeA_w,
 313                                      .y2 = sarea->planeA_y + sarea->planeA_h };
 314       drm_clip_rect_t planeB_rect = { .x1 = sarea->planeB_x, .y1 = sarea->planeB_y,
 315                                      .x2 = sarea->planeB_x + sarea->planeB_w,
 316                                      .y2 = sarea->planeB_y + sarea->planeB_h };
 317       GLint areaA = driIntersectArea( drw_rect, planeA_rect );
 318       GLint areaB = driIntersectArea( drw_rect, planeB_rect );
 319       GLuint flags = dPriv->vblFlags;
 320
 321 #ifdef I915
 322       intelUpdatePageFlipping(intel, areaA, areaB);
 323 #endif
 324
 325       /* Update vblank info
 326        */
 327       if (areaB > areaA || (areaA == areaB && areaB > 0)) {
 328          flags = dPriv->vblFlags | VBLANK_FLAG_SECONDARY;
 329       } else {
 330          flags = dPriv->vblFlags & ~VBLANK_FLAG_SECONDARY;
 331       }
 332
 333       /* Check to see if we changed pipes */
 334       if (flags != dPriv->vblFlags && dPriv->vblFlags &&
 335           !(dPriv->vblFlags & VBLANK_FLAG_NO_IRQ)) {
 336          int64_t count;
 337          drmVBlank vbl;
 338          int i;
 339
 340          /*
 341           * Deal with page flipping
 342           */
 343          vbl.request.type = DRM_VBLANK_ABSOLUTE;
 344
 345          if ( dPriv->vblFlags & VBLANK_FLAG_SECONDARY ) {
 346             vbl.request.type |= DRM_VBLANK_SECONDARY;
 347          }
 348
 349          for (i = 0; i < intel_fb->pf_num_pages; i++) {
 350             if (!intel_fb->color_rb[i] ||
 351                 (intel_fb->vbl_waited - intel_fb->color_rb[i]->vbl_pending) <=
 352                 (1<<23))
 353                continue;
 354
 355             vbl.request.sequence = intel_fb->color_rb[i]->vbl_pending;
 356             drmWaitVBlank(intel->driFd, &vbl);
 357          }
 358
 359          /*
 360           * Update msc_base from old pipe
 361           */
 362          driDrawableGetMSC32(dPriv->driScreenPriv, dPriv, &count);
 363          dPriv->msc_base = count;
 364          /*
 365           * Then get new vblank_base and vblSeq values
 366           */
 367          dPriv->vblFlags = flags;
 368          driGetCurrentVBlank(dPriv);
 369          dPriv->vblank_base = dPriv->vblSeq;
 370
 371          intel_fb->vbl_waited = dPriv->vblSeq;
 372
 373          for (i = 0; i < intel_fb->pf_num_pages; i++) {
 374             if (intel_fb->color_rb[i])
 375                intel_fb->color_rb[i]->vbl_pending = intel_fb->vbl_waited;
 376          }
 377       }
 378    } else {
 379       dPriv->vblFlags &= ~VBLANK_FLAG_SECONDARY;
 380    }
 381
 382    /* Update Mesa's notion of window size */
 383    driUpdateFramebufferSize(ctx, dPriv);
 384    intel_fb->Base.Initialized = GL_TRUE; /* XXX remove someday */
 385
 386    /* Update hardware scissor */
 387    if (ctx->Driver.Scissor != NULL) {
 388       ctx->Driver.Scissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,
 389                           ctx->Scissor.Width, ctx->Scissor.Height);
 390    }
 391
 392    /* Re-calculate viewport related state */
 393    if (ctx->Driver.DepthRange != NULL)
 394       ctx->Driver.DepthRange( ctx, ctx->Viewport.Near, ctx->Viewport.Far );
 395 }
 396
 397
 398
 399 /* A true meta version of this would be very simple and additionally
 400  * machine independent.  Maybe we'll get there one day.
 401  */
 402 static void
 403 intelClearWithTris(struct intel_context *intel, GLbitfield mask)
 404 {
 405    GLcontext *ctx = &intel->ctx;
 406    struct gl_framebuffer *fb = ctx->DrawBuffer;
 407    GLuint buf;
 408
 409    intel->vtbl.install_meta_state(intel);
 410
 411    /* Back and stencil cliprects are the same.  Try and do both
 412     * buffers at once:
 413     */
 414    if (mask & (BUFFER_BIT_BACK_LEFT | BUFFER_BIT_STENCIL | BUFFER_BIT_DEPTH)) {
 415       struct intel_region *backRegion =
 416          intel_get_rb_region(fb, BUFFER_BACK_LEFT);
 417       struct intel_region *depthRegion =
 418          intel_get_rb_region(fb, BUFFER_DEPTH);
 419
 420       intel->vtbl.meta_draw_region(intel, backRegion, depthRegion);
 421
 422       if (mask & BUFFER_BIT_BACK_LEFT)
 423          intel->vtbl.meta_color_mask(intel, GL_TRUE);
 424       else
 425          intel->vtbl.meta_color_mask(intel, GL_FALSE);
 426
 427       if (mask & BUFFER_BIT_STENCIL)
 428          intel->vtbl.meta_stencil_replace(intel,
 429                                           intel->ctx.Stencil.WriteMask[0],
 430                                           intel->ctx.Stencil.Clear);
 431       else
 432          intel->vtbl.meta_no_stencil_write(intel);
 433
 434       if (mask & BUFFER_BIT_DEPTH)
 435          intel->vtbl.meta_depth_replace(intel);
 436       else
 437          intel->vtbl.meta_no_depth_write(intel);
 438
 439       intel->vtbl.meta_draw_quad(intel,
 440                                  fb->_Xmin,
 441                                  fb->_Xmax,
 442                                  fb->_Ymin,
 443                                  fb->_Ymax,
 444                                  intel->ctx.Depth.Clear,
 445                                  intel->ClearColor8888,
 446                                  0, 0, 0, 0);   /* texcoords */
 447
 448       mask &= ~(BUFFER_BIT_BACK_LEFT | BUFFER_BIT_STENCIL | BUFFER_BIT_DEPTH);
 449    }
 450
 451    /* clear the remaining (color) renderbuffers */
 452    for (buf = 0; buf < BUFFER_COUNT && mask; buf++) {
 453       const GLuint bufBit = 1 << buf;
 454       if (mask & bufBit) {
 455          struct intel_renderbuffer *irbColor =
 456             intel_renderbuffer(fb->Attachment[buf].Renderbuffer);
 457
 458          ASSERT(irbColor);
 459
 460          intel->vtbl.meta_no_depth_write(intel);
 461          intel->vtbl.meta_no_stencil_write(intel);
 462          intel->vtbl.meta_color_mask(intel, GL_TRUE);
 463          intel->vtbl.meta_draw_region(intel, irbColor->region, NULL);
 464
 465          intel->vtbl.meta_draw_quad(intel,
 466                                     fb->_Xmin,
 467                                     fb->_Xmax,
 468                                     fb->_Ymin,
 469                                     fb->_Ymax,
 470                                     0, intel->ClearColor8888,
 471                                     0, 0, 0, 0);   /* texcoords */
 472
 473          mask &= ~bufBit;
 474       }
 475    }
 476
 477    intel->vtbl.leave_meta_state(intel);
 478 }
 479
 480 static const char *buffer_names[] = {
 481    [BUFFER_FRONT_LEFT] = "front",
 482    [BUFFER_BACK_LEFT] = "back",
 483    [BUFFER_FRONT_RIGHT] = "front right",
 484    [BUFFER_BACK_RIGHT] = "back right",
 485    [BUFFER_AUX0] = "aux0",
 486    [BUFFER_AUX1] = "aux1",
 487    [BUFFER_AUX2] = "aux2",
 488    [BUFFER_AUX3] = "aux3",
 489    [BUFFER_DEPTH] = "depth",
 490    [BUFFER_STENCIL] = "stencil",
 491    [BUFFER_ACCUM] = "accum",
 492    [BUFFER_COLOR0] = "color0",
 493    [BUFFER_COLOR1] = "color1",
 494    [BUFFER_COLOR2] = "color2",
 495    [BUFFER_COLOR3] = "color3",
 496    [BUFFER_COLOR4] = "color4",
 497    [BUFFER_COLOR5] = "color5",
 498    [BUFFER_COLOR6] = "color6",
 499    [BUFFER_COLOR7] = "color7",
 500 };
 501
 502 /**
 503  * Called by ctx->Driver.Clear.
 504  */
 505 static void
 506 intelClear(GLcontext *ctx, GLbitfield mask)
 507 {
 508    struct intel_context *intel = intel_context(ctx);
 509    const GLuint colorMask = *((GLuint *) & ctx->Color.ColorMask);
 510    GLbitfield tri_mask = 0;
 511    GLbitfield blit_mask = 0;
 512    GLbitfield swrast_mask = 0;
 513    struct gl_framebuffer *fb = ctx->DrawBuffer;
 514    GLuint i;
 515
 516    if (0)
 517       fprintf(stderr, "%s\n", __FUNCTION__);
 518
 519    /* HW color buffers (front, back, aux, generic FBO, etc) */
 520    if (colorMask == ~0) {
 521       /* clear all R,G,B,A */
 522       /* XXX FBO: need to check if colorbuffers are software RBOs! */
 523       blit_mask |= (mask & BUFFER_BITS_COLOR);
 524    }
 525    else {
 526       /* glColorMask in effect */
 527       tri_mask |= (mask & BUFFER_BITS_COLOR);
 528    }
 529
 530    /* HW stencil */
 531    if (mask & BUFFER_BIT_STENCIL) {
 532       const struct intel_region *stencilRegion
 533          = intel_get_rb_region(fb, BUFFER_STENCIL);
 534       if (stencilRegion) {
 535          /* have hw stencil */
 536          if (IS_965(intel->intelScreen->deviceID) ||
 537              (ctx->Stencil.WriteMask[0] & 0xff) != 0xff) {
 538             /* We have to use the 3D engine if we're clearing a partial mask
 539              * of the stencil buffer, or if we're on a 965 which has a tiled
 540              * depth/stencil buffer in a layout we can't blit to.
 541              */
 542             tri_mask |= BUFFER_BIT_STENCIL;
 543          }
 544          else {
 545             /* clearing all stencil bits, use blitting */
 546             blit_mask |= BUFFER_BIT_STENCIL;
 547          }
 548       }
 549    }
 550
 551    /* HW depth */
 552    if (mask & BUFFER_BIT_DEPTH) {
 553       /* clear depth with whatever method is used for stencil (see above) */
 554       if (IS_965(intel->intelScreen->deviceID) ||
 555           tri_mask & BUFFER_BIT_STENCIL)
 556          tri_mask |= BUFFER_BIT_DEPTH;
 557       else
 558          blit_mask |= BUFFER_BIT_DEPTH;
 559    }
 560
 561    /* SW fallback clearing */
 562    swrast_mask = mask & ~tri_mask & ~blit_mask;
 563
 564    for (i = 0; i < BUFFER_COUNT; i++) {
 565       GLuint bufBit = 1 << i;
 566       if ((blit_mask | tri_mask) & bufBit) {
 567          if (!fb->Attachment[i].Renderbuffer->ClassID) {
 568             blit_mask &= ~bufBit;
 569             tri_mask &= ~bufBit;
 570             swrast_mask |= bufBit;
 571          }
 572       }
 573    }
 574
 575    if (blit_mask) {
 576       if (INTEL_DEBUG & DEBUG_BLIT) {
 577          DBG("blit clear:");
 578          for (i = 0; i < BUFFER_COUNT; i++) {
 579             if (blit_mask & (1 << i))
 580                DBG(" %s", buffer_names[i]);
 581          }
 582          DBG("\n");
 583       }
 584       intelClearWithBlit(ctx, blit_mask);
 585    }
 586
 587    if (tri_mask) {
 588       if (INTEL_DEBUG & DEBUG_BLIT) {
 589          DBG("tri clear:");
 590          for (i = 0; i < BUFFER_COUNT; i++) {
 591             if (tri_mask & (1 << i))
 592                DBG(" %s", buffer_names[i]);
 593          }
 594          DBG("\n");
 595       }
 596       intelClearWithTris(intel, tri_mask);
 597    }
 598
 599    if (swrast_mask) {
 600       if (INTEL_DEBUG & DEBUG_BLIT) {
 601          DBG("swrast clear:");
 602          for (i = 0; i < BUFFER_COUNT; i++) {
 603             if (swrast_mask & (1 << i))
 604                DBG(" %s", buffer_names[i]);
 605          }
 606          DBG("\n");
 607       }
 608       _swrast_Clear(ctx, swrast_mask);
 609    }
 610 }
 611
 612
 613 /* Emit wait for pending flips */
 614 void
 615 intel_wait_flips(struct intel_context *intel)
 616 {
 617    struct intel_framebuffer *intel_fb =
 618       (struct intel_framebuffer *) intel->ctx.DrawBuffer;
 619    struct intel_renderbuffer *intel_rb =
 620       intel_get_renderbuffer(&intel_fb->Base,
 621                              intel_fb->Base._ColorDrawBufferIndexes[0] ==
 622                              BUFFER_FRONT_LEFT ? BUFFER_FRONT_LEFT :
 623                              BUFFER_BACK_LEFT);
 624
 625    if (intel_fb->Base.Name == 0 && intel_rb &&
 626        intel_rb->pf_pending == intel_fb->pf_seq) {
 627       GLint pf_planes = intel_fb->pf_planes;
 628       BATCH_LOCALS;
 629
 630       /* Wait for pending flips to take effect */
 631       BEGIN_BATCH(2, NO_LOOP_CLIPRECTS);
 632       OUT_BATCH(pf_planes & 0x1 ? (MI_WAIT_FOR_EVENT | MI_WAIT_FOR_PLANE_A_FLIP)
 633                 : 0);
 634       OUT_BATCH(pf_planes & 0x2 ? (MI_WAIT_FOR_EVENT | MI_WAIT_FOR_PLANE_B_FLIP)
 635                 : 0);
 636       ADVANCE_BATCH();
 637
 638       intel_rb->pf_pending--;
 639    }
 640 }
 641
 642
 643 /* Flip the front & back buffers
 644  */
 645 static GLboolean
 646 intelPageFlip(const __DRIdrawablePrivate * dPriv)
 647 {
 648 #ifdef I915
 649    struct intel_context *intel;
 650    int ret;
 651    struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
 652
 653    if (INTEL_DEBUG & DEBUG_IOCTL)
 654       fprintf(stderr, "%s\n", __FUNCTION__);
 655
 656    assert(dPriv);
 657    assert(dPriv->driContextPriv);
 658    assert(dPriv->driContextPriv->driverPrivate);
 659
 660    intel = (struct intel_context *) dPriv->driContextPriv->driverPrivate;
 661
 662    if (intel->intelScreen->drmMinor < 9)
 663       return GL_FALSE;
 664
 665    intelFlush(&intel->ctx);
 666
 667    ret = 0;
 668
 669    LOCK_HARDWARE(intel);
 670
 671    if (dPriv->numClipRects && intel_fb->pf_active) {
 672       drm_i915_flip_t flip;
 673
 674       flip.pipes = intel_fb->pf_planes;
 675
 676       ret = drmCommandWrite(intel->driFd, DRM_I915_FLIP, &flip, sizeof(flip));
 677    }
 678
 679    UNLOCK_HARDWARE(intel);
 680
 681    if (ret || !intel_fb->pf_active)
 682       return GL_FALSE;
 683
 684    if (!dPriv->numClipRects) {
 685       usleep(10000);    /* throttle invisible client 10ms */
 686    }
 687
 688    intel_fb->pf_current_page = (intel->sarea->pf_current_page >>
 689                                 (intel_fb->pf_planes & 0x2)) & 0x3;
 690
 691    if (dPriv->numClipRects != 0) {
 692       intel_get_renderbuffer(&intel_fb->Base, BUFFER_FRONT_LEFT)->pf_pending =
 693       intel_get_renderbuffer(&intel_fb->Base, BUFFER_BACK_LEFT)->pf_pending =
 694          ++intel_fb->pf_seq;
 695    }
 696
 697    intel_flip_renderbuffers(intel_fb);
 698    intel_draw_buffer(&intel->ctx, &intel_fb->Base);
 699
 700    return GL_TRUE;
 701 #else
 702    return GL_FALSE;
 703 #endif
 704 }
 705
 706 #if 0
 707 void
 708 intelSwapBuffers(__DRIdrawablePrivate * dPriv)
 709 {
 710    if (dPriv->driverPrivate) {
 711       const struct gl_framebuffer *fb
 712          = (struct gl_framebuffer *) dPriv->driverPrivate;
 713       if (fb->Visual.doubleBufferMode) {
 714          GET_CURRENT_CONTEXT(ctx);
 715          if (ctx && ctx->DrawBuffer == fb) {
 716             _mesa_notifySwapBuffers(ctx);       /* flush pending rendering */
 717          }
 718          if (intel->doPageFlip) {
 719             intelPageFlip(dPriv);
 720          }
 721          else {
 722             intelCopyBuffer(dPriv);
 723          }
 724       }
 725    }
 726    else {
 727       _mesa_problem(NULL,
 728                     "dPriv has no gl_framebuffer pointer in intelSwapBuffers");
 729    }
 730 }
 731 #else
 732 /* Trunk version:
 733  */
 734
 735 static GLboolean
 736 intelScheduleSwap(__DRIdrawablePrivate * dPriv, GLboolean *missed_target)
 737 {
 738    struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
 739    unsigned int interval;
 740    struct intel_context *intel =
 741       intelScreenContext(dPriv->driScreenPriv->private);
 742    const intelScreenPrivate *intelScreen = intel->intelScreen;
 743    unsigned int target;
 744    drm_i915_vblank_swap_t swap;
 745    GLboolean ret;
 746
 747    if (!dPriv->vblFlags ||
 748        (dPriv->vblFlags & VBLANK_FLAG_NO_IRQ) ||
 749        intelScreen->drmMinor < (intel_fb->pf_active ? 9 : 6))
 750       return GL_FALSE;
 751
 752    interval = driGetVBlankInterval(dPriv);
 753
 754    swap.seqtype = DRM_VBLANK_ABSOLUTE;
 755
 756    if (dPriv->vblFlags & VBLANK_FLAG_SYNC) {
 757       swap.seqtype |= DRM_VBLANK_NEXTONMISS;
 758    } else if (interval == 0) {
 759       return GL_FALSE;
 760    }
 761
 762    swap.drawable = dPriv->hHWDrawable;
 763    target = swap.sequence = dPriv->vblSeq + interval;
 764
 765    if ( dPriv->vblFlags & VBLANK_FLAG_SECONDARY ) {
 766       swap.seqtype |= DRM_VBLANK_SECONDARY;
 767    }
 768
 769    LOCK_HARDWARE(intel);
 770
 771    intel_batchbuffer_flush(intel->batch);
 772
 773    if ( intel_fb->pf_active ) {
 774       swap.seqtype |= DRM_VBLANK_FLIP;
 775
 776       intel_fb->pf_current_page = (((intel->sarea->pf_current_page >>
 777                                      (intel_fb->pf_planes & 0x2)) & 0x3) + 1) %
 778                                   intel_fb->pf_num_pages;
 779    }
 780
 781    if (!drmCommandWriteRead(intel->driFd, DRM_I915_VBLANK_SWAP, &swap,
 782                             sizeof(swap))) {
 783       dPriv->vblSeq = swap.sequence;
 784       swap.sequence -= target;
 785       *missed_target = swap.sequence > 0 && swap.sequence <= (1 << 23);
 786
 787       intel_get_renderbuffer(&intel_fb->Base, BUFFER_BACK_LEFT)->vbl_pending =
 788          intel_get_renderbuffer(&intel_fb->Base,
 789                                 BUFFER_FRONT_LEFT)->vbl_pending =
 790          dPriv->vblSeq;
 791
 792       if (swap.seqtype & DRM_VBLANK_FLIP) {
 793          intel_flip_renderbuffers(intel_fb);
 794          intel_draw_buffer(&intel->ctx, intel->ctx.DrawBuffer);
 795       }
 796
 797       ret = GL_TRUE;
 798    } else {
 799       if (swap.seqtype & DRM_VBLANK_FLIP) {
 800          intel_fb->pf_current_page = ((intel->sarea->pf_current_page >>
 801                                         (intel_fb->pf_planes & 0x2)) & 0x3) %
 802                                      intel_fb->pf_num_pages;
 803       }
 804
 805       ret = GL_FALSE;
 806    }
 807
 808    UNLOCK_HARDWARE(intel);
 809
 810    return ret;
 811 }
 812
 813 void
 814 intelSwapBuffers(__DRIdrawablePrivate * dPriv)
 815 {
 816    __DRIscreenPrivate *psp = dPriv->driScreenPriv;
 817
 818    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 819       GET_CURRENT_CONTEXT(ctx);
 820       struct intel_context *intel;
 821
 822       if (ctx == NULL)
 823          return;
 824
 825       intel = intel_context(ctx);
 826
 827       if (ctx->Visual.doubleBufferMode) {
 828          GLboolean missed_target;
 829          struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
 830          int64_t ust;
 831
 832          _mesa_notifySwapBuffers(ctx);  /* flush pending rendering comands */
 833
 834          if (!intelScheduleSwap(dPriv, &missed_target)) {
 835             driWaitForVBlank(dPriv, &missed_target);
 836
 837             if (!intelPageFlip(dPriv)) {
 838                intelCopyBuffer(dPriv, NULL);
 839             }
 840          }
 841
 842          intel_fb->swap_count++;
 843          (*psp->systemTime->getUST) (&ust);
 844          if (missed_target) {
 845             intel_fb->swap_missed_count++;
 846             intel_fb->swap_missed_ust = ust - intel_fb->swap_ust;
 847          }
 848
 849          intel_fb->swap_ust = ust;
 850       }
 851    }
 852    else {
 853       /* XXX this shouldn't be an error but we can't handle it for now */
 854       fprintf(stderr, "%s: drawable has no context!\n", __FUNCTION__);
 855    }
 856 }
 857 #endif
 858
 859 void
 860 intelCopySubBuffer(__DRIdrawablePrivate * dPriv, int x, int y, int w, int h)
 861 {
 862    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 863       struct intel_context *intel =
 864          (struct intel_context *) dPriv->driContextPriv->driverPrivate;
 865       GLcontext *ctx = &intel->ctx;
 866
 867       if (ctx->Visual.doubleBufferMode) {
 868          drm_clip_rect_t rect;
 869          rect.x1 = x + dPriv->x;
 870          rect.y1 = (dPriv->h - y - h) + dPriv->y;
 871          rect.x2 = rect.x1 + w;
 872          rect.y2 = rect.y1 + h;
 873          _mesa_notifySwapBuffers(ctx);  /* flush pending rendering comands */
 874          intelCopyBuffer(dPriv, &rect);
 875       }
 876    }
 877    else {
 878       /* XXX this shouldn't be an error but we can't handle it for now */
 879       fprintf(stderr, "%s: drawable has no context!\n", __FUNCTION__);
 880    }
 881 }
 882
 883
 884 /**
 885  * Update the hardware state for drawing into a window or framebuffer object.
 886  *
 887  * Called by glDrawBuffer, glBindFramebufferEXT, MakeCurrent, and other
 888  * places within the driver.
 889  *
 890  * Basically, this needs to be called any time the current framebuffer
 891  * changes, the renderbuffers change, or we need to draw into different
 892  * color buffers.
 893  */
 894 void
 895 intel_draw_buffer(GLcontext * ctx, struct gl_framebuffer *fb)
 896 {
 897    struct intel_context *intel = intel_context(ctx);
 898    struct intel_region *colorRegions[MAX_DRAW_BUFFERS], *depthRegion = NULL;
 899    struct intel_renderbuffer *irbDepth = NULL, *irbStencil = NULL;
 900    int front = 0;               /* drawing to front color buffer? */
 901
 902    if (!fb) {
 903       /* this can happen during the initial context initialization */
 904       return;
 905    }
 906
 907    /* Do this here, note core Mesa, since this function is called from
 908     * many places within the driver.
 909     */
 910    if (ctx->NewState & (_NEW_BUFFERS | _NEW_COLOR | _NEW_PIXEL)) {
 911       /* this updates the DrawBuffer->_NumColorDrawBuffers fields, etc */
 912       _mesa_update_framebuffer(ctx);
 913       /* this updates the DrawBuffer's Width/Height if it's a FBO */
 914       _mesa_update_draw_buffer_bounds(ctx);
 915    }
 916
 917    if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
 918       /* this may occur when we're called by glBindFrameBuffer() during
 919        * the process of someone setting up renderbuffers, etc.
 920        */
 921       /*_mesa_debug(ctx, "DrawBuffer: incomplete user FBO\n");*/
 922       return;
 923    }
 924
 925    if (fb->Name)
 926       intel_validate_paired_depth_stencil(ctx, fb);
 927
 928    /* If the batch contents require looping over cliprects, flush them before
 929     * we go changing which cliprects get referenced when that happens.
 930     */
 931    if (intel->batch->cliprect_mode == LOOP_CLIPRECTS)
 932       intel_batchbuffer_flush(intel->batch);
 933
 934    /*
 935     * How many color buffers are we drawing into?
 936     */
 937    if (fb->_NumColorDrawBuffers == 0) {
 938       /* writing to 0  */
 939       FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_TRUE);
 940       colorRegions[0] = NULL;
 941
 942       if (fb->Name != 0)
 943          intelSetRenderbufferClipRects(intel);
 944    } else if (fb->_NumColorDrawBuffers > 1) {
 945        int i;
 946        struct intel_renderbuffer *irb;
 947        FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_FALSE);
 948
 949        if (fb->Name != 0)
 950            intelSetRenderbufferClipRects(intel);
 951        for (i = 0; i < fb->_NumColorDrawBuffers; i++) {
 952            irb = intel_renderbuffer(fb->_ColorDrawBuffers[i]);
 953            colorRegions[i] = (irb && irb->region) ? irb->region : NULL;
 954        }
 955    }
 956    else {
 957       /* draw to exactly one color buffer */
 958       /*_mesa_debug(ctx, "Hardware rendering\n");*/
 959       FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_FALSE);
 960       if (fb->_ColorDrawBufferIndexes[0] == BUFFER_FRONT_LEFT) {
 961          front = 1;
 962       }
 963
 964       /*
 965        * Get the intel_renderbuffer for the colorbuffer we're drawing into.
 966        * And set up cliprects.
 967        */
 968       if (fb->Name == 0) {
 969          /* drawing to window system buffer */
 970          if (front) {
 971             intelSetFrontClipRects(intel);
 972             colorRegions[0] = intel_get_rb_region(fb, BUFFER_FRONT_LEFT);
 973          }
 974          else {
 975             intelSetBackClipRects(intel);
 976             colorRegions[0]= intel_get_rb_region(fb, BUFFER_BACK_LEFT);
 977          }
 978       }
 979       else {
 980          /* drawing to user-created FBO */
 981          struct intel_renderbuffer *irb;
 982          intelSetRenderbufferClipRects(intel);
 983          irb = intel_renderbuffer(fb->_ColorDrawBuffers[0]);
 984          colorRegions[0] = (irb && irb->region) ? irb->region : NULL;
 985       }
 986    }
 987
 988    /* Update culling direction which changes depending on the
 989     * orientation of the buffer:
 990     */
 991    if (ctx->Driver.FrontFace)
 992       ctx->Driver.FrontFace(ctx, ctx->Polygon.FrontFace);
 993    else
 994       ctx->NewState |= _NEW_POLYGON;
 995
 996    if (!colorRegions[0]) {
 997       FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_TRUE);
 998    }
 999    else {
1000       FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_FALSE);
1001    }
1002
1003    /***
1004     *** Get depth buffer region and check if we need a software fallback.
1005     *** Note that the depth buffer is usually a DEPTH_STENCIL buffer.
1006     ***/
1007    if (fb->_DepthBuffer && fb->_DepthBuffer->Wrapped) {
1008       irbDepth = intel_renderbuffer(fb->_DepthBuffer->Wrapped);
1009       if (irbDepth && irbDepth->region) {
1010          FALLBACK(intel, INTEL_FALLBACK_DEPTH_BUFFER, GL_FALSE);
1011          depthRegion = irbDepth->region;
1012       }
1013       else {
1014          FALLBACK(intel, INTEL_FALLBACK_DEPTH_BUFFER, GL_TRUE);
1015          depthRegion = NULL;
1016       }
1017    }
1018    else {
1019       /* not using depth buffer */
1020       FALLBACK(intel, INTEL_FALLBACK_DEPTH_BUFFER, GL_FALSE);
1021       depthRegion = NULL;
1022    }
1023
1024    /***
1025     *** Stencil buffer
1026     *** This can only be hardware accelerated if we're using a
1027     *** combined DEPTH_STENCIL buffer (for now anyway).
1028     ***/
1029    if (fb->_StencilBuffer && fb->_StencilBuffer->Wrapped) {
1030       irbStencil = intel_renderbuffer(fb->_StencilBuffer->Wrapped);
1031       if (irbStencil && irbStencil->region) {
1032          ASSERT(irbStencil->Base._ActualFormat == GL_DEPTH24_STENCIL8_EXT);
1033          FALLBACK(intel, INTEL_FALLBACK_STENCIL_BUFFER, GL_FALSE);
1034          /* need to re-compute stencil hw state */
1035          if (ctx->Driver.Enable != NULL)
1036             ctx->Driver.Enable(ctx, GL_STENCIL_TEST, ctx->Stencil.Enabled);
1037          else
1038             ctx->NewState |= _NEW_STENCIL;
1039          if (!depthRegion)
1040             depthRegion = irbStencil->region;
1041       }
1042       else {
1043          FALLBACK(intel, INTEL_FALLBACK_STENCIL_BUFFER, GL_TRUE);
1044       }
1045    }
1046    else {
1047       /* XXX FBO: instead of FALSE, pass ctx->Stencil.Enabled ??? */
1048       FALLBACK(intel, INTEL_FALLBACK_STENCIL_BUFFER, GL_FALSE);
1049       /* need to re-compute stencil hw state */
1050       if (ctx->Driver.Enable != NULL)
1051          ctx->Driver.Enable(ctx, GL_STENCIL_TEST, ctx->Stencil.Enabled);
1052       else
1053          ctx->NewState |= _NEW_STENCIL;
1054    }
1055
1056    /*
1057     * Update depth test state
1058     */
1059    if (ctx->Driver.Enable) {
1060       if (ctx->Depth.Test && fb->Visual.depthBits > 0) {
1061          ctx->Driver.Enable(ctx, GL_DEPTH_TEST, GL_TRUE);
1062       } else {
1063          ctx->Driver.Enable(ctx, GL_DEPTH_TEST, GL_FALSE);
1064       }
1065    } else {
1066       ctx->NewState |= _NEW_DEPTH;
1067    }
1068
1069    intel->vtbl.set_draw_region(intel, colorRegions, depthRegion,
1070         fb->_NumColorDrawBuffers);
1071
1072    /* update viewport since it depends on window size */
1073    if (ctx->Driver.Viewport) {
1074       ctx->Driver.Viewport(ctx, ctx->Viewport.X, ctx->Viewport.Y,
1075                            ctx->Viewport.Width, ctx->Viewport.Height);
1076    } else {
1077       ctx->NewState |= _NEW_VIEWPORT;
1078    }
1079
1080    /* Set state we know depends on drawable parameters:
1081     */
1082    if (ctx->Driver.Scissor)
1083       ctx->Driver.Scissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,
1084                           ctx->Scissor.Width, ctx->Scissor.Height);
1085    intel->NewGLState |= _NEW_SCISSOR;
1086
1087    if (ctx->Driver.DepthRange)
1088       ctx->Driver.DepthRange(ctx,
1089                              ctx->Viewport.Near,
1090                              ctx->Viewport.Far);
1091 }
1092
1093
1094 static void
1095 intelDrawBuffer(GLcontext * ctx, GLenum mode)
1096 {
1097    intel_draw_buffer(ctx, ctx->DrawBuffer);
1098 }
1099
1100
1101 static void
1102 intelReadBuffer(GLcontext * ctx, GLenum mode)
1103 {
1104    if (ctx->ReadBuffer == ctx->DrawBuffer) {
1105       /* This will update FBO completeness status.
1106        * A framebuffer will be incomplete if the GL_READ_BUFFER setting
1107        * refers to a missing renderbuffer.  Calling glReadBuffer can set
1108        * that straight and can make the drawing buffer complete.
1109        */
1110       intel_draw_buffer(ctx, ctx->DrawBuffer);
1111    }
1112    /* Generally, functions which read pixels (glReadPixels, glCopyPixels, etc)
1113     * reference ctx->ReadBuffer and do appropriate state checks.
1114     */
1115 }
1116
1117
1118 void
1119 intelInitBufferFuncs(struct dd_function_table *functions)
1120 {
1121    functions->Clear = intelClear;
1122    functions->DrawBuffer = intelDrawBuffer;
1123    functions->ReadBuffer = intelReadBuffer;
1124 }