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_depthstencil.h"
  33 #include "intel_fbo.h"
  34 #include "intel_tris.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
  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][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
 201 /**
 202  * This will be called whenever the currently bound window is moved/resized.
 203  * XXX: actually, it seems to NOT be called when the window is only moved (BP).
 204  */
 205 void
 206 intelWindowMoved(struct intel_context *intel)
 207 {
 208    GLcontext *ctx = &intel->ctx;
 209    __DRIdrawablePrivate *dPriv = intel->driDrawable;
 210    struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
 211
 212    if (!intel->ctx.DrawBuffer) {
 213       /* when would this happen? -BP */
 214       intelSetFrontClipRects(intel);
 215    }
 216    else if (intel->ctx.DrawBuffer->Name != 0) {
 217       /* drawing to user-created FBO - do nothing */
 218       /* Cliprects would be set from intelDrawBuffer() */
 219    }
 220    else {
 221       /* drawing to a window */
 222       switch (intel_fb->Base._ColorDrawBufferMask[0]) {
 223       case BUFFER_BIT_FRONT_LEFT:
 224          intelSetFrontClipRects(intel);
 225          break;
 226       case BUFFER_BIT_BACK_LEFT:
 227          intelSetBackClipRects(intel);
 228          break;
 229       default:
 230          /* glDrawBuffer(GL_NONE or GL_FRONT_AND_BACK): software fallback */
 231          intelSetFrontClipRects(intel);
 232       }
 233    }
 234
 235    if (intel->intelScreen->driScrnPriv->ddx_version.minor >= 7) {
 236       drmI830Sarea *sarea = intel->sarea;
 237       drm_clip_rect_t drw_rect = { .x1 = dPriv->x, .x2 = dPriv->x + dPriv->w,
 238                                    .y1 = dPriv->y, .y2 = dPriv->y + dPriv->h };
 239       drm_clip_rect_t planeA_rect = { .x1 = sarea->planeA_x, .y1 = sarea->planeA_y,
 240                                      .x2 = sarea->planeA_x + sarea->planeA_w,
 241                                      .y2 = sarea->planeA_y + sarea->planeA_h };
 242       drm_clip_rect_t planeB_rect = { .x1 = sarea->planeB_x, .y1 = sarea->planeB_y,
 243                                      .x2 = sarea->planeB_x + sarea->planeB_w,
 244                                      .y2 = sarea->planeB_y + sarea->planeB_h };
 245       GLint areaA = driIntersectArea( drw_rect, planeA_rect );
 246       GLint areaB = driIntersectArea( drw_rect, planeB_rect );
 247       GLuint flags = dPriv->vblFlags;
 248       GLboolean pf_active;
 249       GLint pf_planes;
 250
 251       /* Update page flipping info
 252        */
 253       pf_planes = 0;
 254
 255       if (areaA > 0)
 256          pf_planes |= 1;
 257
 258       if (areaB > 0)
 259          pf_planes |= 2;
 260
 261       intel_fb->pf_current_page = (intel->sarea->pf_current_page >>
 262                                    (intel_fb->pf_planes & 0x2)) & 0x3;
 263
 264       intel_fb->pf_num_pages = intel->intelScreen->third.handle ? 3 : 2;
 265
 266       pf_active = pf_planes && (pf_planes & intel->sarea->pf_active) == pf_planes;
 267
 268       if (INTEL_DEBUG & DEBUG_LOCK)
 269          if (pf_active != intel_fb->pf_active)
 270             _mesa_printf("%s - Page flipping %sactive\n", __progname,
 271                          pf_active ? "" : "in");
 272
 273       if (pf_active) {
 274          /* Sync pages between planes if flipping on both at the same time */
 275          if (pf_planes == 0x3 && pf_planes != intel_fb->pf_planes &&
 276              (intel->sarea->pf_current_page & 0x3) !=
 277              (((intel->sarea->pf_current_page) >> 2) & 0x3)) {
 278             drm_i915_flip_t flip;
 279
 280             if (intel_fb->pf_current_page ==
 281                 (intel->sarea->pf_current_page & 0x3)) {
 282                /* XXX: This is ugly, but emitting two flips 'in a row' can cause
 283                 * lockups for unknown reasons.
 284                 */
 285                intel->sarea->pf_current_page =
 286                   intel->sarea->pf_current_page & 0x3;
 287                intel->sarea->pf_current_page |=
 288                   ((intel_fb->pf_current_page + intel_fb->pf_num_pages - 1) %
 289                    intel_fb->pf_num_pages) << 2;
 290
 291                flip.pipes = 0x2;
 292             } else {
 293                intel->sarea->pf_current_page =
 294                   intel->sarea->pf_current_page & (0x3 << 2);
 295                intel->sarea->pf_current_page |=
 296                   (intel_fb->pf_current_page + intel_fb->pf_num_pages - 1) %
 297                   intel_fb->pf_num_pages;
 298
 299                flip.pipes = 0x1;
 300             }
 301
 302             drmCommandWrite(intel->driFd, DRM_I915_FLIP, &flip, sizeof(flip));
 303          }
 304
 305          intel_fb->pf_planes = pf_planes;
 306       }
 307
 308       intel_fb->pf_active = pf_active;
 309       intel_flip_renderbuffers(intel_fb);
 310       intel_draw_buffer(&intel->ctx, intel->ctx.DrawBuffer);
 311
 312       /* Update vblank info
 313        */
 314       if (areaB > areaA || (areaA == areaB && areaB > 0)) {
 315          flags = dPriv->vblFlags | VBLANK_FLAG_SECONDARY;
 316       } else {
 317          flags = dPriv->vblFlags & ~VBLANK_FLAG_SECONDARY;
 318       }
 319
 320       /* Check to see if we changed pipes */
 321       if (flags != dPriv->vblFlags && dPriv->vblFlags &&
 322           !(dPriv->vblFlags & VBLANK_FLAG_NO_IRQ)) {
 323          int64_t count;
 324          drmVBlank vbl;
 325          int i;
 326
 327          /*
 328           * Deal with page flipping
 329           */
 330          vbl.request.type = DRM_VBLANK_ABSOLUTE;
 331
 332          if ( dPriv->vblFlags & VBLANK_FLAG_SECONDARY ) {
 333             vbl.request.type |= DRM_VBLANK_SECONDARY;
 334          }
 335
 336          for (i = 0; i < intel_fb->pf_num_pages; i++) {
 337             if (!intel_fb->color_rb[i] ||
 338                 (intel_fb->vbl_waited - intel_fb->color_rb[i]->vbl_pending) <=
 339                 (1<<23))
 340                continue;
 341
 342             vbl.request.sequence = intel_fb->color_rb[i]->vbl_pending;
 343             drmWaitVBlank(intel->driFd, &vbl);
 344          }
 345
 346          /*
 347           * Update msc_base from old pipe
 348           */
 349          driDrawableGetMSC32(dPriv->driScreenPriv, dPriv, &count);
 350          dPriv->msc_base = count;
 351          /*
 352           * Then get new vblank_base and vblSeq values
 353           */
 354          dPriv->vblFlags = flags;
 355          driGetCurrentVBlank(dPriv);
 356          dPriv->vblank_base = dPriv->vblSeq;
 357
 358          intel_fb->vbl_waited = dPriv->vblSeq;
 359
 360          for (i = 0; i < intel_fb->pf_num_pages; i++) {
 361             if (intel_fb->color_rb[i])
 362                intel_fb->color_rb[i]->vbl_pending = intel_fb->vbl_waited;
 363          }
 364       }
 365    } else {
 366       dPriv->vblFlags &= ~VBLANK_FLAG_SECONDARY;
 367    }
 368
 369    /* Update Mesa's notion of window size */
 370    driUpdateFramebufferSize(ctx, dPriv);
 371    intel_fb->Base.Initialized = GL_TRUE; /* XXX remove someday */
 372
 373    /* Update hardware scissor */
 374    ctx->Driver.Scissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,
 375                        ctx->Scissor.Width, ctx->Scissor.Height);
 376
 377    /* Re-calculate viewport related state */
 378    ctx->Driver.DepthRange( ctx, ctx->Viewport.Near, ctx->Viewport.Far );
 379 }
 380
 381
 382
 383 /* A true meta version of this would be very simple and additionally
 384  * machine independent.  Maybe we'll get there one day.
 385  */
 386 static void
 387 intelClearWithTris(struct intel_context *intel, GLbitfield mask)
 388 {
 389    GLcontext *ctx = &intel->ctx;
 390    struct gl_framebuffer *fb = ctx->DrawBuffer;
 391    GLuint buf;
 392
 393    intel->vtbl.install_meta_state(intel);
 394
 395    /* Back and stencil cliprects are the same.  Try and do both
 396     * buffers at once:
 397     */
 398    if (mask & (BUFFER_BIT_BACK_LEFT | BUFFER_BIT_STENCIL | BUFFER_BIT_DEPTH)) {
 399       struct intel_region *backRegion =
 400          intel_get_rb_region(fb, BUFFER_BACK_LEFT);
 401       struct intel_region *depthRegion =
 402          intel_get_rb_region(fb, BUFFER_DEPTH);
 403       const GLuint clearColor = (backRegion && backRegion->cpp == 4)
 404          ? intel->ClearColor8888 : intel->ClearColor565;
 405
 406       intel->vtbl.meta_draw_region(intel, backRegion, depthRegion);
 407
 408       if (mask & BUFFER_BIT_BACK_LEFT)
 409          intel->vtbl.meta_color_mask(intel, GL_TRUE);
 410       else
 411          intel->vtbl.meta_color_mask(intel, GL_FALSE);
 412
 413       if (mask & BUFFER_BIT_STENCIL)
 414          intel->vtbl.meta_stencil_replace(intel,
 415                                           intel->ctx.Stencil.WriteMask[0],
 416                                           intel->ctx.Stencil.Clear);
 417       else
 418          intel->vtbl.meta_no_stencil_write(intel);
 419
 420       if (mask & BUFFER_BIT_DEPTH)
 421          intel->vtbl.meta_depth_replace(intel);
 422       else
 423          intel->vtbl.meta_no_depth_write(intel);
 424
 425       intel_meta_draw_quad(intel,
 426                            fb->_Xmin,
 427                            fb->_Xmax,
 428                            fb->_Ymin,
 429                            fb->_Ymax,
 430                            intel->ctx.Depth.Clear, clearColor,
 431                            0, 0, 0, 0);   /* texcoords */
 432
 433       mask &= ~(BUFFER_BIT_BACK_LEFT | BUFFER_BIT_STENCIL | BUFFER_BIT_DEPTH);
 434    }
 435
 436    /* clear the remaining (color) renderbuffers */
 437    for (buf = 0; buf < BUFFER_COUNT && mask; buf++) {
 438       const GLuint bufBit = 1 << buf;
 439       if (mask & bufBit) {
 440          struct intel_renderbuffer *irbColor =
 441             intel_renderbuffer(fb->Attachment[buf].Renderbuffer);
 442          GLuint color = (irbColor->region->cpp == 4)
 443             ? intel->ClearColor8888 : intel->ClearColor565;
 444
 445          ASSERT(irbColor);
 446
 447          intel->vtbl.meta_no_depth_write(intel);
 448          intel->vtbl.meta_no_stencil_write(intel);
 449          intel->vtbl.meta_color_mask(intel, GL_TRUE);
 450          intel->vtbl.meta_draw_region(intel, irbColor->region, NULL);
 451
 452          /* XXX: Using INTEL_BATCH_NO_CLIPRECTS here is dangerous as the
 453           * drawing origin may not be correctly emitted.
 454           */
 455          intel_meta_draw_quad(intel,
 456                               fb->_Xmin,
 457                               fb->_Xmax,
 458                               fb->_Ymin,
 459                               fb->_Ymax,
 460                               0, color,
 461                               0, 0, 0, 0);   /* texcoords */
 462
 463          mask &= ~bufBit;
 464       }
 465    }
 466
 467    intel->vtbl.leave_meta_state(intel);
 468    intel_batchbuffer_flush(intel->batch);
 469 }
 470
 471 static const char *buffer_names[] = {
 472    [BUFFER_FRONT_LEFT] = "front",
 473    [BUFFER_BACK_LEFT] = "back",
 474    [BUFFER_FRONT_RIGHT] = "front right",
 475    [BUFFER_BACK_RIGHT] = "back right",
 476    [BUFFER_AUX0] = "aux0",
 477    [BUFFER_AUX1] = "aux1",
 478    [BUFFER_AUX2] = "aux2",
 479    [BUFFER_AUX3] = "aux3",
 480    [BUFFER_DEPTH] = "depth",
 481    [BUFFER_STENCIL] = "stencil",
 482    [BUFFER_ACCUM] = "accum",
 483    [BUFFER_COLOR0] = "color0",
 484    [BUFFER_COLOR1] = "color1",
 485    [BUFFER_COLOR2] = "color2",
 486    [BUFFER_COLOR3] = "color3",
 487    [BUFFER_COLOR4] = "color4",
 488    [BUFFER_COLOR5] = "color5",
 489    [BUFFER_COLOR6] = "color6",
 490    [BUFFER_COLOR7] = "color7",
 491 };
 492
 493 /**
 494  * Called by ctx->Driver.Clear.
 495  */
 496 static void
 497 intelClear(GLcontext *ctx, GLbitfield mask)
 498 {
 499    struct intel_context *intel = intel_context(ctx);
 500    const GLuint colorMask = *((GLuint *) & ctx->Color.ColorMask);
 501    GLbitfield tri_mask = 0;
 502    GLbitfield blit_mask = 0;
 503    GLbitfield swrast_mask = 0;
 504    struct gl_framebuffer *fb = ctx->DrawBuffer;
 505    GLuint i;
 506
 507    if (0)
 508       fprintf(stderr, "%s\n", __FUNCTION__);
 509
 510    /* HW color buffers (front, back, aux, generic FBO, etc) */
 511    if (colorMask == ~0) {
 512       /* clear all R,G,B,A */
 513       /* XXX FBO: need to check if colorbuffers are software RBOs! */
 514       blit_mask |= (mask & BUFFER_BITS_COLOR);
 515    }
 516    else {
 517       /* glColorMask in effect */
 518       tri_mask |= (mask & BUFFER_BITS_COLOR);
 519    }
 520
 521    /* HW stencil */
 522    if (mask & BUFFER_BIT_STENCIL) {
 523       const struct intel_region *stencilRegion
 524          = intel_get_rb_region(fb, BUFFER_STENCIL);
 525       if (stencilRegion) {
 526          /* have hw stencil */
 527          if ((ctx->Stencil.WriteMask[0] & 0xff) != 0xff) {
 528             /* not clearing all stencil bits, so use triangle clearing */
 529             tri_mask |= BUFFER_BIT_STENCIL;
 530          }
 531          else {
 532             /* clearing all stencil bits, use blitting */
 533             blit_mask |= BUFFER_BIT_STENCIL;
 534          }
 535       }
 536    }
 537
 538    /* HW depth */
 539    if (mask & BUFFER_BIT_DEPTH) {
 540       /* clear depth with whatever method is used for stencil (see above) */
 541       if (tri_mask & BUFFER_BIT_STENCIL)
 542          tri_mask |= BUFFER_BIT_DEPTH;
 543       else
 544          blit_mask |= BUFFER_BIT_DEPTH;
 545    }
 546
 547    /* SW fallback clearing */
 548    swrast_mask = mask & ~tri_mask & ~blit_mask;
 549
 550    for (i = 0; i < BUFFER_COUNT; i++) {
 551       GLuint bufBit = 1 << i;
 552       if ((blit_mask | tri_mask) & bufBit) {
 553          if (!fb->Attachment[i].Renderbuffer->ClassID) {
 554             blit_mask &= ~bufBit;
 555             tri_mask &= ~bufBit;
 556             swrast_mask |= bufBit;
 557          }
 558       }
 559    }
 560
 561    intelFlush(ctx);             /* XXX intelClearWithBlit also does this */
 562
 563    if (blit_mask) {
 564       if (INTEL_DEBUG & DEBUG_BLIT) {
 565          DBG("blit clear:");
 566          for (i = 0; i < BUFFER_COUNT; i++) {
 567             if (blit_mask & (1 << i))
 568                DBG(" %s", buffer_names[i]);
 569          }
 570          DBG("\n");
 571       }
 572       intelClearWithBlit(ctx, blit_mask);
 573    }
 574
 575    if (tri_mask) {
 576       if (INTEL_DEBUG & DEBUG_BLIT) {
 577          DBG("tri clear:");
 578          for (i = 0; i < BUFFER_COUNT; i++) {
 579             if (tri_mask & (1 << i))
 580                DBG(" %s", buffer_names[i]);
 581          }
 582          DBG("\n");
 583       }
 584       intelClearWithTris(intel, tri_mask);
 585    }
 586
 587    if (swrast_mask) {
 588       if (INTEL_DEBUG & DEBUG_BLIT) {
 589          DBG("swrast clear:");
 590          for (i = 0; i < BUFFER_COUNT; i++) {
 591             if (swrast_mask & (1 << i))
 592                DBG(" %s", buffer_names[i]);
 593          }
 594          DBG("\n");
 595       }
 596       _swrast_Clear(ctx, swrast_mask);
 597    }
 598 }
 599
 600
 601 /* Emit wait for pending flips */
 602 void
 603 intel_wait_flips(struct intel_context *intel, GLuint batch_flags)
 604 {
 605    struct intel_framebuffer *intel_fb =
 606       (struct intel_framebuffer *) intel->ctx.DrawBuffer;
 607    struct intel_renderbuffer *intel_rb =
 608       intel_get_renderbuffer(&intel_fb->Base,
 609                              intel_fb->Base._ColorDrawBufferMask[0] ==
 610                              BUFFER_BIT_FRONT_LEFT ? BUFFER_FRONT_LEFT :
 611                              BUFFER_BACK_LEFT);
 612
 613    if (intel_fb->Base.Name == 0 && intel_rb &&
 614        intel_rb->pf_pending == intel_fb->pf_seq) {
 615       GLint pf_planes = intel_fb->pf_planes;
 616       BATCH_LOCALS;
 617
 618       /* Wait for pending flips to take effect */
 619       BEGIN_BATCH(2, batch_flags);
 620       OUT_BATCH(pf_planes & 0x1 ? (MI_WAIT_FOR_EVENT | MI_WAIT_FOR_PLANE_A_FLIP)
 621                 : 0);
 622       OUT_BATCH(pf_planes & 0x2 ? (MI_WAIT_FOR_EVENT | MI_WAIT_FOR_PLANE_B_FLIP)
 623                 : 0);
 624       ADVANCE_BATCH();
 625
 626       intel_rb->pf_pending--;
 627    }
 628 }
 629
 630
 631 /* Flip the front & back buffers
 632  */
 633 static GLboolean
 634 intelPageFlip(const __DRIdrawablePrivate * dPriv)
 635 {
 636    struct intel_context *intel;
 637    int ret;
 638    struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
 639
 640    if (INTEL_DEBUG & DEBUG_IOCTL)
 641       fprintf(stderr, "%s\n", __FUNCTION__);
 642
 643    assert(dPriv);
 644    assert(dPriv->driContextPriv);
 645    assert(dPriv->driContextPriv->driverPrivate);
 646
 647    intel = (struct intel_context *) dPriv->driContextPriv->driverPrivate;
 648
 649    if (intel->intelScreen->drmMinor < 9)
 650       return GL_FALSE;
 651
 652    intelFlush(&intel->ctx);
 653
 654    ret = 0;
 655
 656    LOCK_HARDWARE(intel);
 657
 658    if (dPriv->numClipRects && intel_fb->pf_active) {
 659       drm_i915_flip_t flip;
 660
 661       flip.pipes = intel_fb->pf_planes;
 662
 663       ret = drmCommandWrite(intel->driFd, DRM_I915_FLIP, &flip, sizeof(flip));
 664    }
 665
 666    UNLOCK_HARDWARE(intel);
 667
 668    if (ret || !intel_fb->pf_active)
 669       return GL_FALSE;
 670
 671    if (!dPriv->numClipRects) {
 672       usleep(10000);    /* throttle invisible client 10ms */
 673    }
 674
 675    intel_fb->pf_current_page = (intel->sarea->pf_current_page >>
 676                                 (intel_fb->pf_planes & 0x2)) & 0x3;
 677
 678    if (dPriv->numClipRects != 0) {
 679       intel_get_renderbuffer(&intel_fb->Base, BUFFER_FRONT_LEFT)->pf_pending =
 680       intel_get_renderbuffer(&intel_fb->Base, BUFFER_BACK_LEFT)->pf_pending =
 681          ++intel_fb->pf_seq;
 682    }
 683
 684    intel_flip_renderbuffers(intel_fb);
 685    intel_draw_buffer(&intel->ctx, &intel_fb->Base);
 686
 687    return GL_TRUE;
 688 }
 689
 690 #if 0
 691 void
 692 intelSwapBuffers(__DRIdrawablePrivate * dPriv)
 693 {
 694    if (dPriv->driverPrivate) {
 695       const struct gl_framebuffer *fb
 696          = (struct gl_framebuffer *) dPriv->driverPrivate;
 697       if (fb->Visual.doubleBufferMode) {
 698          GET_CURRENT_CONTEXT(ctx);
 699          if (ctx && ctx->DrawBuffer == fb) {
 700             _mesa_notifySwapBuffers(ctx);       /* flush pending rendering */
 701          }
 702          if (intel->doPageFlip) {
 703             intelPageFlip(dPriv);
 704          }
 705          else {
 706             intelCopyBuffer(dPriv);
 707          }
 708       }
 709    }
 710    else {
 711       _mesa_problem(NULL,
 712                     "dPriv has no gl_framebuffer pointer in intelSwapBuffers");
 713    }
 714 }
 715 #else
 716 /* Trunk version:
 717  */
 718
 719 static GLboolean
 720 intelScheduleSwap(__DRIdrawablePrivate * dPriv, GLboolean *missed_target)
 721 {
 722    struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
 723    unsigned int interval;
 724    struct intel_context *intel =
 725       intelScreenContext(dPriv->driScreenPriv->private);
 726    const intelScreenPrivate *intelScreen = intel->intelScreen;
 727    unsigned int target;
 728    drm_i915_vblank_swap_t swap;
 729    GLboolean ret;
 730
 731    if (!dPriv->vblFlags ||
 732        (dPriv->vblFlags & VBLANK_FLAG_NO_IRQ) ||
 733        intelScreen->drmMinor < (intel_fb->pf_active ? 9 : 6))
 734       return GL_FALSE;
 735
 736    interval = driGetVBlankInterval(dPriv);
 737
 738    swap.seqtype = DRM_VBLANK_ABSOLUTE;
 739
 740    if (dPriv->vblFlags & VBLANK_FLAG_SYNC) {
 741       swap.seqtype |= DRM_VBLANK_NEXTONMISS;
 742    } else if (interval == 0) {
 743       return GL_FALSE;
 744    }
 745
 746    swap.drawable = dPriv->hHWDrawable;
 747    target = swap.sequence = dPriv->vblSeq + interval;
 748
 749    if ( dPriv->vblFlags & VBLANK_FLAG_SECONDARY ) {
 750       swap.seqtype |= DRM_VBLANK_SECONDARY;
 751    }
 752
 753    LOCK_HARDWARE(intel);
 754
 755    intel_batchbuffer_flush(intel->batch);
 756
 757    if ( intel_fb->pf_active ) {
 758       swap.seqtype |= DRM_VBLANK_FLIP;
 759
 760       intel_fb->pf_current_page = (((intel->sarea->pf_current_page >>
 761                                      (intel_fb->pf_planes & 0x2)) & 0x3) + 1) %
 762                                   intel_fb->pf_num_pages;
 763    }
 764
 765    if (!drmCommandWriteRead(intel->driFd, DRM_I915_VBLANK_SWAP, &swap,
 766                             sizeof(swap))) {
 767       dPriv->vblSeq = swap.sequence;
 768       swap.sequence -= target;
 769       *missed_target = swap.sequence > 0 && swap.sequence <= (1 << 23);
 770
 771       intel_get_renderbuffer(&intel_fb->Base, BUFFER_BACK_LEFT)->vbl_pending =
 772          intel_get_renderbuffer(&intel_fb->Base,
 773                                 BUFFER_FRONT_LEFT)->vbl_pending =
 774          dPriv->vblSeq;
 775
 776       if (swap.seqtype & DRM_VBLANK_FLIP) {
 777          intel_flip_renderbuffers(intel_fb);
 778          intel_draw_buffer(&intel->ctx, intel->ctx.DrawBuffer);
 779       }
 780
 781       ret = GL_TRUE;
 782    } else {
 783       if (swap.seqtype & DRM_VBLANK_FLIP) {
 784          intel_fb->pf_current_page = ((intel->sarea->pf_current_page >>
 785                                         (intel_fb->pf_planes & 0x2)) & 0x3) %
 786                                      intel_fb->pf_num_pages;
 787       }
 788
 789       ret = GL_FALSE;
 790    }
 791
 792    UNLOCK_HARDWARE(intel);
 793
 794    return ret;
 795 }
 796
 797 void
 798 intelSwapBuffers(__DRIdrawablePrivate * dPriv)
 799 {
 800    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 801       GET_CURRENT_CONTEXT(ctx);
 802       struct intel_context *intel;
 803
 804       if (ctx == NULL)
 805          return;
 806
 807       intel = intel_context(ctx);
 808
 809       if (ctx->Visual.doubleBufferMode) {
 810          GLboolean missed_target;
 811          struct intel_framebuffer *intel_fb = dPriv->driverPrivate;
 812          int64_t ust;
 813
 814          _mesa_notifySwapBuffers(ctx);  /* flush pending rendering comands */
 815
 816          if (!intelScheduleSwap(dPriv, &missed_target)) {
 817             driWaitForVBlank(dPriv, &missed_target);
 818
 819             if (!intelPageFlip(dPriv)) {
 820                intelCopyBuffer(dPriv, NULL);
 821             }
 822          }
 823
 824          intel_fb->swap_count++;
 825          (*dri_interface->getUST) (&ust);
 826          if (missed_target) {
 827             intel_fb->swap_missed_count++;
 828             intel_fb->swap_missed_ust = ust - intel_fb->swap_ust;
 829          }
 830
 831          intel_fb->swap_ust = ust;
 832       }
 833    }
 834    else {
 835       /* XXX this shouldn't be an error but we can't handle it for now */
 836       fprintf(stderr, "%s: drawable has no context!\n", __FUNCTION__);
 837    }
 838 }
 839 #endif
 840
 841 void
 842 intelCopySubBuffer(__DRIdrawablePrivate * dPriv, int x, int y, int w, int h)
 843 {
 844    if (dPriv->driContextPriv && dPriv->driContextPriv->driverPrivate) {
 845       struct intel_context *intel =
 846          (struct intel_context *) dPriv->driContextPriv->driverPrivate;
 847       GLcontext *ctx = &intel->ctx;
 848
 849       if (ctx->Visual.doubleBufferMode) {
 850          drm_clip_rect_t rect;
 851          rect.x1 = x + dPriv->x;
 852          rect.y1 = (dPriv->h - y - h) + dPriv->y;
 853          rect.x2 = rect.x1 + w;
 854          rect.y2 = rect.y1 + h;
 855          _mesa_notifySwapBuffers(ctx);  /* flush pending rendering comands */
 856          intelCopyBuffer(dPriv, &rect);
 857       }
 858    }
 859    else {
 860       /* XXX this shouldn't be an error but we can't handle it for now */
 861       fprintf(stderr, "%s: drawable has no context!\n", __FUNCTION__);
 862    }
 863 }
 864
 865
 866 /**
 867  * Update the hardware state for drawing into a window or framebuffer object.
 868  *
 869  * Called by glDrawBuffer, glBindFramebufferEXT, MakeCurrent, and other
 870  * places within the driver.
 871  *
 872  * Basically, this needs to be called any time the current framebuffer
 873  * changes, the renderbuffers change, or we need to draw into different
 874  * color buffers.
 875  */
 876 void
 877 intel_draw_buffer(GLcontext * ctx, struct gl_framebuffer *fb)
 878 {
 879    struct intel_context *intel = intel_context(ctx);
 880    struct intel_region *colorRegion, *depthRegion = NULL;
 881    struct intel_renderbuffer *irbDepth = NULL, *irbStencil = NULL;
 882    int front = 0;               /* drawing to front color buffer? */
 883
 884    if (!fb) {
 885       /* this can happen during the initial context initialization */
 886       return;
 887    }
 888
 889    /* Do this here, note core Mesa, since this function is called from
 890     * many places within the driver.
 891     */
 892    if (ctx->NewState & (_NEW_BUFFERS | _NEW_COLOR | _NEW_PIXEL)) {
 893       /* this updates the DrawBuffer->_NumColorDrawBuffers fields, etc */
 894       _mesa_update_framebuffer(ctx);
 895       /* this updates the DrawBuffer's Width/Height if it's a FBO */
 896       _mesa_update_draw_buffer_bounds(ctx);
 897    }
 898
 899    if (fb->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
 900       /* this may occur when we're called by glBindFrameBuffer() during
 901        * the process of someone setting up renderbuffers, etc.
 902        */
 903       /*_mesa_debug(ctx, "DrawBuffer: incomplete user FBO\n");*/
 904       return;
 905    }
 906
 907    if (fb->Name)
 908       intel_validate_paired_depth_stencil(ctx, fb);
 909
 910    /*
 911     * How many color buffers are we drawing into?
 912     */
 913    if (fb->_NumColorDrawBuffers[0] != 1) {
 914       /* writing to 0 or 2 or 4 color buffers */
 915       /*_mesa_debug(ctx, "Software rendering\n");*/
 916       FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_TRUE);
 917       colorRegion = NULL;
 918    }
 919    else {
 920       /* draw to exactly one color buffer */
 921       /*_mesa_debug(ctx, "Hardware rendering\n");*/
 922       FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_FALSE);
 923       if (fb->_ColorDrawBufferMask[0] == BUFFER_BIT_FRONT_LEFT) {
 924          front = 1;
 925       }
 926
 927       /*
 928        * Get the intel_renderbuffer for the colorbuffer we're drawing into.
 929        * And set up cliprects.
 930        */
 931       if (fb->Name == 0) {
 932          /* drawing to window system buffer */
 933          if (front) {
 934             intelSetFrontClipRects(intel);
 935             colorRegion = intel_get_rb_region(fb, BUFFER_FRONT_LEFT);
 936          }
 937          else {
 938             intelSetBackClipRects(intel);
 939             colorRegion = intel_get_rb_region(fb, BUFFER_BACK_LEFT);
 940          }
 941       }
 942       else {
 943          /* drawing to user-created FBO */
 944          struct intel_renderbuffer *irb;
 945          intelSetRenderbufferClipRects(intel);
 946          irb = intel_renderbuffer(fb->_ColorDrawBuffers[0][0]);
 947          colorRegion = (irb && irb->region) ? irb->region : NULL;
 948       }
 949    }
 950
 951    /* Update culling direction which changes depending on the
 952     * orientation of the buffer:
 953     */
 954    if (ctx->Driver.FrontFace)
 955       ctx->Driver.FrontFace(ctx, ctx->Polygon.FrontFace);
 956    else
 957       ctx->NewState |= _NEW_POLYGON;
 958
 959    if (!colorRegion) {
 960       FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_TRUE);
 961    }
 962    else {
 963       FALLBACK(intel, INTEL_FALLBACK_DRAW_BUFFER, GL_FALSE);
 964    }
 965
 966    /***
 967     *** Get depth buffer region and check if we need a software fallback.
 968     *** Note that the depth buffer is usually a DEPTH_STENCIL buffer.
 969     ***/
 970    if (fb->_DepthBuffer && fb->_DepthBuffer->Wrapped) {
 971       irbDepth = intel_renderbuffer(fb->_DepthBuffer->Wrapped);
 972       if (irbDepth && irbDepth->region) {
 973          FALLBACK(intel, INTEL_FALLBACK_DEPTH_BUFFER, GL_FALSE);
 974          depthRegion = irbDepth->region;
 975       }
 976       else {
 977          FALLBACK(intel, INTEL_FALLBACK_DEPTH_BUFFER, GL_TRUE);
 978          depthRegion = NULL;
 979       }
 980    }
 981    else {
 982       /* not using depth buffer */
 983       FALLBACK(intel, INTEL_FALLBACK_DEPTH_BUFFER, GL_FALSE);
 984       depthRegion = NULL;
 985    }
 986
 987    /***
 988     *** Stencil buffer
 989     *** This can only be hardware accelerated if we're using a
 990     *** combined DEPTH_STENCIL buffer (for now anyway).
 991     ***/
 992    if (fb->_StencilBuffer && fb->_StencilBuffer->Wrapped) {
 993       irbStencil = intel_renderbuffer(fb->_StencilBuffer->Wrapped);
 994       if (irbStencil && irbStencil->region) {
 995          ASSERT(irbStencil->Base._ActualFormat == GL_DEPTH24_STENCIL8_EXT);
 996          FALLBACK(intel, INTEL_FALLBACK_STENCIL_BUFFER, GL_FALSE);
 997          /* need to re-compute stencil hw state */
 998          ctx->Driver.Enable(ctx, GL_STENCIL_TEST, ctx->Stencil.Enabled);
 999          if (!depthRegion)
1000             depthRegion = irbStencil->region;
1001       }
1002       else {
1003          FALLBACK(intel, INTEL_FALLBACK_STENCIL_BUFFER, GL_TRUE);
1004       }
1005    }
1006    else {
1007       /* XXX FBO: instead of FALSE, pass ctx->Stencil.Enabled ??? */
1008       FALLBACK(intel, INTEL_FALLBACK_STENCIL_BUFFER, GL_FALSE);
1009       /* need to re-compute stencil hw state */
1010       ctx->Driver.Enable(ctx, GL_STENCIL_TEST, ctx->Stencil.Enabled);
1011    }
1012
1013    /*
1014     * Update depth test state
1015     */
1016    if (ctx->Depth.Test && fb->Visual.depthBits > 0) {
1017       ctx->Driver.Enable(ctx, GL_DEPTH_TEST, GL_TRUE);
1018    }
1019    else {
1020       ctx->Driver.Enable(ctx, GL_DEPTH_TEST, GL_FALSE);
1021    }
1022
1023    /**
1024     ** Release old regions, reference new regions
1025     **/
1026 #if 0                           /* XXX FBO: this seems to be redundant with i915_state_draw_region() */
1027    if (intel->draw_region != colorRegion) {
1028       intel_region_release(&intel->draw_region);
1029       intel_region_reference(&intel->draw_region, colorRegion);
1030    }
1031    if (intel->intelScreen->depth_region != depthRegion) {
1032       intel_region_release(&intel->intelScreen->depth_region);
1033       intel_region_reference(&intel->intelScreen->depth_region, depthRegion);
1034    }
1035 #endif
1036
1037    intel->vtbl.set_draw_region(intel, colorRegion, depthRegion);
1038
1039    /* update viewport since it depends on window size */
1040    ctx->Driver.Viewport(ctx, ctx->Viewport.X, ctx->Viewport.Y,
1041                         ctx->Viewport.Width, ctx->Viewport.Height);
1042
1043    /* Update hardware scissor */
1044    ctx->Driver.Scissor(ctx, ctx->Scissor.X, ctx->Scissor.Y,
1045                        ctx->Scissor.Width, ctx->Scissor.Height);
1046 }
1047
1048
1049 static void
1050 intelDrawBuffer(GLcontext * ctx, GLenum mode)
1051 {
1052    intel_draw_buffer(ctx, ctx->DrawBuffer);
1053 }
1054
1055
1056 static void
1057 intelReadBuffer(GLcontext * ctx, GLenum mode)
1058 {
1059    if (ctx->ReadBuffer == ctx->DrawBuffer) {
1060       /* This will update FBO completeness status.
1061        * A framebuffer will be incomplete if the GL_READ_BUFFER setting
1062        * refers to a missing renderbuffer.  Calling glReadBuffer can set
1063        * that straight and can make the drawing buffer complete.
1064        */
1065       intel_draw_buffer(ctx, ctx->DrawBuffer);
1066    }
1067    /* Generally, functions which read pixels (glReadPixels, glCopyPixels, etc)
1068     * reference ctx->ReadBuffer and do appropriate state checks.
1069     */
1070 }
1071
1072
1073 void
1074 intelInitBufferFuncs(struct dd_function_table *functions)
1075 {
1076    functions->Clear = intelClear;
1077    functions->DrawBuffer = intelDrawBuffer;
1078    functions->ReadBuffer = intelReadBuffer;
1079 }