Bool KdSaveScreen(ScreenPtr pScreen, int on) { KdScreenPriv(pScreen); int dpmsState; if (!pScreenPriv->card->cfuncs->dpms) return FALSE; dpmsState = pScreenPriv->dpmsState; switch (on) { case SCREEN_SAVER_OFF: dpmsState = KD_DPMS_NORMAL; break; case SCREEN_SAVER_ON: if (dpmsState == KD_DPMS_NORMAL) dpmsState = KD_DPMS_NORMAL + 1; break; case SCREEN_SAVER_CYCLE: if (dpmsState < KD_DPMS_MAX) dpmsState++; break; case SCREEN_SAVER_FORCER: break; } if (dpmsState != pScreenPriv->dpmsState) { if (pScreenPriv->enabled) (*pScreenPriv->card->cfuncs->dpms) (pScreen, dpmsState); pScreenPriv->dpmsState = dpmsState; } return TRUE; }
Bool KdOffscreenInit (ScreenPtr pScreen) { KdScreenPriv (pScreen); KdOffscreenArea *area; /* Allocate a big free area */ area = xalloc (sizeof (KdOffscreenArea)); if (!area) return FALSE; area->state = KdOffscreenAvail; area->offset = pScreenPriv->screen->off_screen_base; area->size = pScreenPriv->screen->memory_size - area->offset; area->save = 0; area->next = NULL; area->score = 0; /* Add it to the free areas */ pScreenPriv->off_screen_areas = area; KdOffscreenValidate (pScreen); return TRUE; }
static GCOps * s3MatchCommon (DrawablePtr pDraw, GCPtr pGC, FbGCPrivPtr fbPriv) { KdScreenPriv (pDraw->pScreen); if (!REGION_NOTEMPTY(pDraw->pScreen,fbGetCompositeClip(pGC))) { DRAW_DEBUG ((DEBUG_CLIP, "Empty composite clip, clipping all ops")); return &kdNoopOps; } if (pDraw->type != DRAWABLE_WINDOW) return (GCOps *) &kdAsyncPixmapGCOps; if (pGC->lineWidth != 0) return 0; if (pGC->lineStyle != LineSolid) return 0; if (pGC->fillStyle != FillSolid) return 0; if (fbPriv->and != 0) return 0; if (pGC->font) { if (TERMINALFONT(pGC->font)) return (GCOps *) &s3TEOps; else return (GCOps *) &s3NonTEOps; } return 0; }
void r128DrawEnable (ScreenPtr pScreen) { KdScreenPriv (pScreen); r128ScreenInfo (pScreenPriv); r128s->pitch = pScreenPriv->screen->width >> 3; switch (pScreenPriv->screen->fb[0].depth) { case 8: r128s->datatype = 2; break; case 15: r128s->datatype = 3; break; case 16: r128s->datatype = 4; break; case 24: r128s->datatype = 5; break; case 32: r128s->datatype = 6; break; default: FatalError ("unsupported pixel format"); } r128s->dp_gui_master_cntl = ((r128s->datatype << R128_GMC_DST_DATATYPE_SHIFT) | R128_GMC_CLR_CMP_CNTL_DIS | R128_GMC_AUX_CLIP_DIS); kaaMarkSync (pScreen); }
static void ephyrInternalDamageRedisplay(ScreenPtr pScreen) { KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; EphyrScrPriv *scrpriv = screen->driver; RegionPtr pRegion; if (!scrpriv || !scrpriv->pDamage) return; pRegion = DamageRegion(scrpriv->pDamage); if (RegionNotEmpty(pRegion)) { int nbox; BoxPtr pbox; if (ephyr_glamor) { ephyr_glamor_damage_redisplay(scrpriv->glamor, pRegion); } else { nbox = RegionNumRects(pRegion); pbox = RegionRects(pRegion); while (nbox--) { hostx_paint_rect(screen, pbox->x1, pbox->y1, pbox->x1, pbox->y1, pbox->x2 - pbox->x1, pbox->y2 - pbox->y1); pbox++; } } DamageEmpty(scrpriv->pDamage); } }
static Bool r128Setup (ScreenPtr pScreen, int wait) { KdScreenPriv (pScreen); r128ScreenInfo (pScreenPriv); r128CardInfo (pScreenPriv); fifo_size = 0; mmio = r128c->reg_base; if (!mmio) return FALSE; r128WaitAvail (2); R128_OUT32 (mmio, R128_REG_DEFAULT_OFFSET, 0); R128_OUT32 (mmio, R128_REG_DEFAULT_PITCH, r128s->pitch); r128WaitAvail (4); R128_OUT32 (mmio, R128_AUX_SC_CNTL, 0); R128_OUT32 (mmio, R128_DEFAULT_SC_BOTTOM_RIGHT, (R128_DEFAULT_SC_RIGHT_MAX | R128_DEFAULT_SC_BOTTOM_MAX)); R128_OUT32 (mmio, R128_SC_TOP_LEFT, 0); R128_OUT32 (mmio, R128_SC_BOTTOM_RIGHT, (R128_DEFAULT_SC_RIGHT_MAX | R128_DEFAULT_SC_BOTTOM_MAX)); r128WaitAvail (wait); return TRUE; }
Bool tridentPrepareCopy (DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, int dx, int dy, int alu, Pixel pm) { FbBits depthMask = FbFullMask(pDstDrawable->depth); if ((pm & depthMask) == depthMask) { KdScreenPriv(pDstDrawable->pScreen); tridentCardInfo(pScreenPriv); cop = tridentc->cop; _tridentInit(cop,tridentc); cop->multi = COP_MULTI_PATTERN; cop->multi = COP_MULTI_ROP | tridentRop[alu]; cmd = COP_OP_BLT | COP_SCL_OPAQUE | COP_OP_ROP | COP_OP_FB; if (dx < 0 || dy < 0) cmd |= COP_X_REVERSE; return TRUE; } else return FALSE; }
Bool ephyrInitScreen(ScreenPtr pScreen) { KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; EPHYR_LOG("pScreen->myNum:%d\n", pScreen->myNum); hostx_set_screen_number(screen, pScreen->myNum); if (EphyrWantNoHostGrab) { hostx_set_win_title(screen, "xephyr"); } else { hostx_set_win_title(screen, "(ctrl+shift grabs mouse and keyboard)"); } pScreen->CreateColormap = ephyrCreateColormap; #ifdef XV if (!ephyrNoXV) { if (ephyr_glamor) ephyr_glamor_xv_init(pScreen); else if (!ephyrInitVideo(pScreen)) { EPHYR_LOG_ERROR("failed to initialize xvideo\n"); } else { EPHYR_LOG("initialized xvideo okay\n"); } } #endif /*XV*/ return TRUE; }
static Bool smiSetup (ScreenPtr pScreen, int wait) { KdScreenPriv(pScreen); smis = getSmiScreenInfo (pScreenPriv); smic = getSmiCardInfo(pScreenPriv); dpr = smic->dpr; if (!dpr) return FALSE; /* enable DPR/VPR registers */ smiSetIndex (smic, VGA_SEQ_INDEX, VGA_SEQ_DATA, 0x21, smis->dpr_vpr_enable); smiWaitAvail (smic, wait + 9); dpr->src_stride = (smis->stride << 16) | smis->stride; dpr->data_format = smis->data_format; dpr->mask1 = 0xffffffff; dpr->mask2 = 0xffffffff; dpr->dst_stride = (smis->stride << 16) | smis->stride; dpr->unknown_40 = 0x0; dpr->unknown_44 = 0x0; dpr->scissors_ul = 0x0; dpr->scissors_lr = SMI_XY(4095,4095); return TRUE; }
/** * Sets up a scratch GC for fbCopyArea, and saves other parameters for the * ephyrCopy implementation. */ static Bool ephyrPrepareCopy(PixmapPtr pSrc, PixmapPtr pDst, int dx, int dy, int alu, Pixel pm) { ScreenPtr pScreen = pDst->drawable.pScreen; KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; EphyrScrPriv *scrpriv = screen->driver; EphyrFakexaPriv *fakexa = scrpriv->fakexa; CARD32 tmpval[2]; ephyrPreparePipelinedAccess(pDst, EXA_PREPARE_DEST); ephyrPreparePipelinedAccess(pSrc, EXA_PREPARE_SRC); fakexa->pSrc = pSrc; fakexa->pDst = pDst; fakexa->pGC = GetScratchGC(pDst->drawable.depth, pScreen); tmpval[0] = alu; tmpval[1] = pm; ChangeGC (fakexa->pGC, GCFunction | GCPlaneMask, tmpval); ValidateGC(&pDst->drawable, fakexa->pGC); TRACE_DRAW(); return TRUE; }
/** * Saves off the parameters for ephyrComposite. */ static Bool ephyrPrepareComposite(int op, PicturePtr pSrcPicture, PicturePtr pMaskPicture, PicturePtr pDstPicture, PixmapPtr pSrc, PixmapPtr pMask, PixmapPtr pDst) { KdScreenPriv(pDst->drawable.pScreen); KdScreenInfo *screen = pScreenPriv->screen; EphyrScrPriv *scrpriv = screen->driver; EphyrFakexaPriv *fakexa = scrpriv->fakexa; ephyrPreparePipelinedAccess(pDst, EXA_PREPARE_DEST); ephyrPreparePipelinedAccess(pSrc, EXA_PREPARE_SRC); if (pMask != NULL) ephyrPreparePipelinedAccess(pMask, EXA_PREPARE_MASK); fakexa->op = op; fakexa->pSrcPicture = pSrcPicture; fakexa->pMaskPicture = pMaskPicture; fakexa->pDstPicture = pDstPicture; fakexa->pSrc = pSrc; fakexa->pMask = pMask; fakexa->pDst = pDst; TRACE_DRAW(); return TRUE; }
Bool fakeRandRGetInfo (ScreenPtr pScreen, Rotation *rotations) { KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; FakeScrPriv *scrpriv = screen->driver; RRScreenSizePtr pSize; Rotation randr; int n; *rotations = RR_Rotate_All|RR_Reflect_All; for (n = 0; n < pScreen->numDepths; n++) if (pScreen->allowedDepths[n].numVids) break; if (n == pScreen->numDepths) return FALSE; pSize = RRRegisterSize (pScreen, screen->width, screen->height, screen->width_mm, screen->height_mm); randr = KdSubRotation (scrpriv->randr, screen->randr); RRSetCurrentConfig (pScreen, randr, 0, pSize); return TRUE; }
Bool ephyrInitScreen(ScreenPtr pScreen) { KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; EPHYR_LOG("pScreen->myNum:%d\n", pScreen->myNum); hostx_set_screen_number(screen, pScreen->myNum); hostx_set_win_title(screen, "(ctrl+shift grabs mouse and keyboard)"); pScreen->CreateColormap = ephyrCreateColormap; #ifdef XV if (!ephyrNoXV) { if (!ephyrInitVideo(pScreen)) { EPHYR_LOG_ERROR("failed to initialize xvideo\n"); } else { EPHYR_LOG("initialized xvideo okay\n"); } } #endif /*XV*/ #ifdef XF86DRI if (!ephyrNoDRI && !host_has_extension(&xcb_xf86dri_id)) { EPHYR_LOG("host x does not support DRI. Disabling DRI forwarding\n"); ephyrNoDRI = TRUE; } if (!ephyrNoDRI) { ephyrDRIExtensionInit(pScreen); ephyrHijackGLXExtension(); } #endif return TRUE; }
Bool KdCloseScreen (int index, ScreenPtr pScreen) { KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; KdCardInfo *card = pScreenPriv->card; Bool ret; pScreenPriv->closed = TRUE; pScreen->CloseScreen = pScreenPriv->CloseScreen; ret = (*pScreen->CloseScreen) (index, pScreen); if (pScreenPriv->dpmsState != KD_DPMS_NORMAL) (*card->cfuncs->dpms) (pScreen, KD_DPMS_NORMAL); if (screen->mynum == card->selected) KdDisableScreen (pScreen); /* * Restore video hardware when last screen is closed */ if (screen == card->screenList) { if (kdEnabled) (*card->cfuncs->restore) (card); } if (!pScreenPriv->screen->dumb) (*card->cfuncs->finiAccel) (pScreen); if (!pScreenPriv->screen->softCursor) (*card->cfuncs->finiCursor) (pScreen); (*card->cfuncs->scrfini) (screen); /* * Clean up card when last screen is closed, DIX closes them in * reverse order, thus we check for when the first in the list is closed */ if (screen == card->screenList) { (*card->cfuncs->cardfini) (card); /* * Clean up OS when last card is closed */ if (card == kdCardInfo) { if (kdEnabled) { kdEnabled = FALSE; (*kdOsFuncs->Disable) (); } } } pScreenPriv->screen->pScreen = 0; xfree ((pointer) pScreenPriv); return ret; }
/** * Sets up a scratch GC for fbFill, and saves other parameters for the * ephyrSolid implementation. */ static Bool ephyrPrepareSolid(PixmapPtr pPix, int alu, Pixel pm, Pixel fg) { ScreenPtr pScreen = pPix->drawable.pScreen; KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; EphyrScrPriv *scrpriv = screen->driver; EphyrFakexaPriv *fakexa = scrpriv->fakexa; CARD32 tmpval[3]; ephyrPreparePipelinedAccess(pPix, EXA_PREPARE_DEST); fakexa->pDst = pPix; fakexa->pGC = GetScratchGC(pPix->drawable.depth, pScreen); tmpval[0] = alu; tmpval[1] = pm; tmpval[2] = fg; ChangeGC(fakexa->pGC, GCFunction | GCPlaneMask | GCForeground, tmpval); ValidateGC(&pPix->drawable, fakexa->pGC); TRACE_DRAW(); return TRUE; }
/** * Does fake acceleration of UploadToScreen using memcpy. */ static Bool ephyrUploadToScreen(PixmapPtr pDst, int x, int y, int w, int h, char *src, int src_pitch) { KdScreenPriv(pDst->drawable.pScreen); KdScreenInfo *screen = pScreenPriv->screen; EphyrScrPriv *scrpriv = screen->driver; EphyrFakexaPriv *fakexa = scrpriv->fakexa; unsigned char *dst; int dst_pitch, cpp; if (pDst->drawable.bitsPerPixel < 8) return FALSE; ephyrPreparePipelinedAccess(pDst, EXA_PREPARE_DEST); cpp = pDst->drawable.bitsPerPixel / 8; dst_pitch = exaGetPixmapPitch(pDst); dst = fakexa->exa->memoryBase + exaGetPixmapOffset(pDst); dst += y * dst_pitch + x * cpp; for (; h > 0; h--) { memcpy(dst, src, w * cpp); dst += dst_pitch; src += src_pitch; } exaMarkSync(pDst->drawable.pScreen); ephyrFinishPipelinedAccess(pDst, EXA_PREPARE_DEST); return TRUE; }
void KdOffscreenSwapOut (ScreenPtr pScreen) { KdScreenPriv (pScreen); KdOffscreenValidate (pScreen); /* loop until a single free area spans the space */ for (;;) { KdOffscreenArea *area = pScreenPriv->off_screen_areas; if (!area) break; if (area->state == KdOffscreenAvail) { area = area->next; if (!area) break; } assert (area->state != KdOffscreenAvail); (void) KdOffscreenKickOut (pScreen, area); KdOffscreenValidate (pScreen); } KdOffscreenValidate (pScreen); KdOffscreenFini (pScreen); }
Bool ephyrInitVideo(ScreenPtr pScreen) { Bool is_ok = FALSE; KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; static EphyrXVPriv *xv_priv; EPHYR_LOG("enter\n"); if (screen->fb.bitsPerPixel == 8) { EPHYR_LOG_ERROR("8 bits depth not supported\n"); return FALSE; } if (!xv_priv) { xv_priv = ephyrXVPrivNew(); } if (!xv_priv) { EPHYR_LOG_ERROR("failed to create xv_priv\n"); goto out; } if (!ephyrXVPrivRegisterAdaptors(xv_priv, pScreen)) { EPHYR_LOG_ERROR("failed to register adaptors\n"); goto out; } is_ok = TRUE; out: return is_ok; }
static void kaaFillRegionSolid (DrawablePtr pDrawable, RegionPtr pRegion, Pixel pixel) { KdScreenPriv(pDrawable->pScreen); KaaScreenPriv(pDrawable->pScreen); PixmapPtr pPixmap; int xoff, yoff; if (pScreenPriv->enabled && (pPixmap = kaaGetOffscreenPixmap (pDrawable, &xoff, &yoff)) && (*pKaaScr->info->PrepareSolid) (pPixmap, GXcopy, FB_ALLONES, pixel)) { int nbox = REGION_NUM_RECTS (pRegion); BoxPtr pBox = REGION_RECTS (pRegion); while (nbox--) { (*pKaaScr->info->Solid) (pBox->x1 + xoff, pBox->y1 + yoff, pBox->x2 + xoff, pBox->y2 + yoff); pBox++; } (*pKaaScr->info->DoneSolid) (); kaaMarkSync (pDrawable->pScreen); } else { kaaWaitSync (pDrawable->pScreen); fbFillRegionSolid (pDrawable, pRegion, 0, fbReplicatePixel (pixel, pDrawable->bitsPerPixel)); } kaaDrawableDirty (pDrawable); }
static PixmapPtr kaaCreatePixmap(ScreenPtr pScreen, int w, int h, int depth) { PixmapPtr pPixmap; KaaPixmapPrivPtr pKaaPixmap; int bpp; bpp = BitsPerPixel (depth); if (bpp == 32 && depth == 24) { int fb; KdScreenPriv (pScreen); for (fb = 0; fb < KD_MAX_FB && pScreenPriv->screen->fb[fb].depth; fb++) if (pScreenPriv->screen->fb[fb].depth == 24) { bpp = pScreenPriv->screen->fb[fb].bitsPerPixel; break; } } pPixmap = fbCreatePixmapBpp (pScreen, w, h, depth, bpp); if (!pPixmap) return NULL; pKaaPixmap = KaaGetPixmapPriv(pPixmap); if (!w || !h) pKaaPixmap->score = KAA_PIXMAP_SCORE_PINNED; else pKaaPixmap->score = KAA_PIXMAP_SCORE_INIT; pKaaPixmap->area = NULL; pKaaPixmap->dirty = FALSE; return pPixmap; }
static void smiWaitMarker (ScreenPtr pScreen, int marker) { KdScreenPriv(pScreen); smic = getSmiCardInfo(pScreenPriv); smiWaitIdle (smic); }
static void nvidiaWaitMarker (ScreenPtr pScreen, int marker) { KdScreenPriv(pScreen); nvidiaCardInfo(pScreenPriv); nvidiaWaitIdle (nvidiac); }
Bool ephyrRandRGetInfo(ScreenPtr pScreen, Rotation * rotations) { KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; EphyrScrPriv *scrpriv = screen->driver; RRScreenSizePtr pSize; Rotation randr; int n = 0; struct { int width, height; } sizes[] = { {1600, 1200}, {1400, 1050}, {1280, 960}, {1280, 1024}, {1152, 864}, {1024, 768}, {832, 624}, {800, 600}, {720, 400}, {480, 640}, {640, 480}, {640, 400}, {320, 240}, {240, 320}, {160, 160}, {0, 0} }; EPHYR_LOG("mark"); *rotations = RR_Rotate_All | RR_Reflect_All; if (!hostx_want_preexisting_window(screen) && !hostx_want_fullscreen()) { /* only if no -parent switch */ while (sizes[n].width != 0 && sizes[n].height != 0) { RRRegisterSize(pScreen, sizes[n].width, sizes[n].height, (sizes[n].width * screen->width_mm) / screen->width, (sizes[n].height * screen->height_mm) / screen->height); n++; } } pSize = RRRegisterSize(pScreen, screen->width, screen->height, screen->width_mm, screen->height_mm); randr = KdSubRotation(scrpriv->randr, screen->randr); RRSetCurrentConfig(pScreen, randr, 0, pSize); return TRUE; }
void kaaCopyNtoN (DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable, GCPtr pGC, BoxPtr pbox, int nbox, int dx, int dy, Bool reverse, Bool upsidedown, Pixel bitplane, void *closure) { KdScreenPriv (pDstDrawable->pScreen); KaaScreenPriv (pDstDrawable->pScreen); PixmapPtr pSrcPixmap, pDstPixmap; int src_off_x, src_off_y; int dst_off_x, dst_off_y; /* Migrate pixmaps to same place as destination */ if (pScreenPriv->enabled && pSrcDrawable->type == DRAWABLE_PIXMAP) { if (kaaDrawableIsOffscreen (pDstDrawable)) kaaPixmapUseScreen ((PixmapPtr) pSrcDrawable); else kaaPixmapUseMemory ((PixmapPtr) pSrcDrawable); } if (pScreenPriv->enabled && (pSrcPixmap = kaaGetOffscreenPixmap (pSrcDrawable, &src_off_x, &src_off_y)) && (pDstPixmap = kaaGetOffscreenPixmap (pDstDrawable, &dst_off_x, &dst_off_y)) && (*pKaaScr->info->PrepareCopy) (pSrcPixmap, pDstPixmap, dx, dy, pGC ? pGC->alu : GXcopy, pGC ? pGC->planemask : FB_ALLONES)) { while (nbox--) { (*pKaaScr->info->Copy) (pbox->x1 + dx + src_off_x, pbox->y1 + dy + src_off_y, pbox->x1 + dst_off_x, pbox->y1 + dst_off_y, pbox->x2 - pbox->x1, pbox->y2 - pbox->y1); pbox++; } (*pKaaScr->info->DoneCopy) (); kaaMarkSync (pDstDrawable->pScreen); } else { kaaWaitSync (pDstDrawable->pScreen); fbCopyNtoN (pSrcDrawable, pDstDrawable, pGC, pbox, nbox, dx, dy, reverse, upsidedown, bitplane, closure); } kaaDrawableDirty (pDstDrawable); }
void itsyEnable (ScreenPtr pScreen) { KdScreenPriv(pScreen); fprintf (stderr, "Enabling LCD display\n"); /* display it on the LCD */ ioctl(fb_d, FB_LCD_SHOW, 0); }
int KdDepthToFb(ScreenPtr pScreen, int depth) { KdScreenPriv(pScreen); for (fb = 0; fb <= KD_MAX_FB && pScreenPriv->screen->fb.frameBuffer; fb++) if (pScreenPriv->screen->fb.depth == depth) return fb; }
void KdSetSubpixelOrder (ScreenPtr pScreen, Rotation randr) { KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; int subpixel_order = screen->subpixel_order; Rotation subpixel_dir; int i; static struct { int subpixel_order; Rotation direction; } orders[] = { { SubPixelHorizontalRGB, RR_Rotate_0 }, { SubPixelHorizontalBGR, RR_Rotate_180 }, { SubPixelVerticalRGB, RR_Rotate_270 }, { SubPixelVerticalBGR, RR_Rotate_90 }, }; static struct { int bit; int normal; int reflect; } reflects[] = { { RR_Reflect_X, SubPixelHorizontalRGB, SubPixelHorizontalBGR }, { RR_Reflect_X, SubPixelHorizontalBGR, SubPixelHorizontalRGB }, { RR_Reflect_Y, SubPixelVerticalRGB, SubPixelVerticalBGR }, { RR_Reflect_Y, SubPixelVerticalRGB, SubPixelVerticalRGB }, }; /* map subpixel to direction */ for (i = 0; i < 4; i++) if (orders[i].subpixel_order == subpixel_order) break; if (i < 4) { subpixel_dir = KdAddRotation (randr & RR_Rotate_All, orders[i].direction); /* map back to subpixel order */ for (i = 0; i < 4; i++) if (orders[i].direction & subpixel_dir) { subpixel_order = orders[i].subpixel_order; break; } /* reflect */ for (i = 0; i < 4; i++) if ((randr & reflects[i].bit) && reflects[i].normal == subpixel_order) { subpixel_order = reflects[i].reflect; break; } } PictureSetSubpixelOrder (pScreen, subpixel_order); }
/** * Assumes that we're waiting on the latest marker. When EXA gets smarter and * starts using markers in a fine-grained way (for example, waiting on drawing * to required pixmaps to complete, rather than waiting for all drawing to * complete), we'll want to make the ephyrMarkSync/ephyrWaitMarker * implementation fine-grained as well. */ static void ephyrWaitMarker(ScreenPtr pScreen, int marker) { KdScreenPriv(pScreen); KdScreenInfo *screen = pScreenPriv->screen; EphyrScrPriv *scrpriv = screen->driver; EphyrFakexaPriv *fakexa = scrpriv->fakexa; fakexa->is_synced = TRUE; }
Bool tridentDPMS (ScreenPtr pScreen, int mode) { KdScreenPriv(pScreen); TridentCardInfo *tridentc = pScreenPriv->card->driver; tridentWriteIndex (tridentc, 0x3ce, 0x21, tridentDPMSModes[mode]); tridentPause (); return TRUE; }
Bool kaaPixmapIsOffscreen(PixmapPtr p) { ScreenPtr pScreen = p->drawable.pScreen; KdScreenPriv(pScreen); return ((unsigned long) ((CARD8 *) p->devPrivate.ptr - (CARD8 *) pScreenPriv->screen->memory_base) < pScreenPriv->screen->memory_size); }