static void FFB_BlitRect(ScrnInfoPtr pScrn, int srcx, int srcy,
int w, int h, int dstx, int dsty)
{
FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
ffb_fbcPtr ffb = pFfb->regs;
if (!pFfb->disable_vscroll &&
dstx == srcx &&
dsty != dsty) {
FFB_WRITE_ATTRIBUTES_VSCROLL(pFfb, 0x00ffffff);
FFBFifo(pFfb, 7);
ffb->drawop = FFB_DRAWOP_VSCROLL;
FFB_WRITE64(&ffb->by, srcy, srcx);
FFB_WRITE64_2(&ffb->dy, dsty, dstx);
FFB_WRITE64_3(&ffb->bh, h, w);
pFfb->rp_active = 1;
} else {
unsigned char *base = (unsigned char *)pFfb->fb;
int use_prefetch = pFfb->use_blkread_prefetch;
FFB_WRITE_ATTRIBUTES_SFB_VAR(pFfb, 0x00ffffff, GXcopy);
FFBWait(pFfb, ffb);
if (use_prefetch) {
FFBFifo(pFfb, 1);
ffb->mer = FFB_MER_EIRA;
pFfb->rp_active = 1;
FFBWait(pFfb, ffb);
}
if (srcx < dstx) {
VISmoveImageRL((base +
((srcy + h - 1) * (2048 * 4)) +
(srcx * (32 / 8))),
(base +
((dsty + h - 1) * (2048 * 4)) +
(dstx * (32 / 8))),
(w * (32 / 8)),
h,
-(2048 * 4), - (2048 * 4));
} else {
VISmoveImageLR((base +
((srcy + h - 1) * (2048 * 4)) +
(srcx * (32 / 8))),
(base +
((dsty + h - 1) * (2048 * 4)) +
(dstx * (32 / 8))),
(w * (32 / 8)),
h,
-(2048 * 4), - (2048 * 4));
}
if (use_prefetch) {
FFBFifo(pFfb, 1);
ffb->mer = FFB_MER_DRA;
pFfb->rp_active = 1;
FFBWait(pFfb, pFfb->regs);
}
}
}
static void FFB_Flush(ScrnInfoPtr pScrn)
{
FFBPtr pFfb = GET_FFB_FROM_SCRN(pScrn);
ffb_fbcPtr ffb = pFfb->regs;
FFBWait(pFfb, ffb);
}
static void ffbDDFinish(GLcontext *ctx)
{
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
LOCK_HARDWARE(fmesa);
FFBWait(fmesa, fmesa->regs);
UNLOCK_HARDWARE(fmesa);
}
static void ffb_margins (struct fb_info_sbusfb *fb, struct display *p, int x_margin, int y_margin)
{
register struct ffb_fbc *fbc = fb->s.ffb.fbc;
unsigned long flags;
spin_lock_irqsave(&fb->lock, flags);
fb->s.ffb.xy_margin = (y_margin << 16) + x_margin;
fb->s.ffb.yx_margin = (((u64)y_margin) << 32) + x_margin;
p->screen_base += 8192 * (y_margin - fb->y_margin) + 4 * (x_margin - fb->x_margin);
FFBWait(fbc);
spin_unlock_irqrestore(&fb->lock, flags);
}
static void ffb_switch_from_graph (struct fb_info_sbusfb *fb)
{
register struct ffb_fbc *fbc = fb->s.ffb.fbc;
unsigned long flags;
spin_lock_irqsave(&fb->lock, flags);
FFBWait(fbc);
fb->s.ffb.fifo_cache = 0;
FFBFifo(fb, 8);
upa_writel(FFB_PPC_VCE_DISABLE|FFB_PPC_TBE_OPAQUE|
FFB_PPC_APE_DISABLE|FFB_PPC_CS_CONST,
&fbc->ppc);
upa_writel(0x2000707f, &fbc->fbc);
upa_writel(FFB_ROP_NEW, &fbc->rop);
upa_writel(FFB_DRAWOP_RECTANGLE, &fbc->drawop);
upa_writel(0xffffffff, &fbc->pmask);
upa_writel(0x10000, &fbc->fontinc);
upa_writel(fb->s.ffb.fg_cache, &fbc->fg);
upa_writel(fb->s.ffb.bg_cache, &fbc->bg);
FFBWait(fbc);
spin_unlock_irqrestore(&fb->lock, flags);
}
static void FFBWriteDepthPixels( GLcontext *ctx,
struct gl_renderbuffer *rb,
GLuint n,
const GLint x[],
const GLint y[],
const void *values,
const GLubyte mask[] )
{
const GLuint *depth = (const GLuint *) values;
#ifdef DEPTH_TRACE
fprintf(stderr, "FFBWriteDepthPixels: n(%d)\n", (int) n);
#endif
if (ctx->Depth.Mask) {
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
__DRIdrawablePrivate *dPriv = fmesa->driDrawable;
char *zbase;
GLuint i;
if (!fmesa->hw_locked)
LOCK_HARDWARE(fmesa);
FFBFifo(fmesa, 2);
fmesa->regs->fbc = (FFB_FBC_WB_C | FFB_FBC_ZE_ON |
FFB_FBC_YE_OFF | FFB_FBC_RGBE_OFF);
fmesa->regs->ppc = FFB_PPC_ZS_VAR;
fmesa->ffbScreen->rp_active = 1;
FFBWait(fmesa, fmesa->regs);
zbase = ((char *)fmesa->sfb32 +
(dPriv->x << 2) + (dPriv->y << 13));
for (i = 0; i < n; i++) {
GLint y1 = (dPriv->h - y[i]);
GLint x1 = x[i];
GLuint *zptr;
zptr = (GLuint *)
(zbase + (x1 << 2) + (y1 << 13));
if (mask[i])
*zptr = Z_FROM_MESA(depth[i]);
}
FFBFifo(fmesa, 2);
fmesa->regs->fbc = fmesa->fbc;
fmesa->regs->ppc = fmesa->ppc;
fmesa->ffbScreen->rp_active = 1;
if (!fmesa->hw_locked)
UNLOCK_HARDWARE(fmesa);
}
}
static void FFBWriteDepthSpan( GLcontext *ctx,
struct gl_renderbuffer *rb,
GLuint n, GLint x, GLint y,
const void *values,
const GLubyte mask[] )
{
const GLuint *depth = (const GLuint *) values;
#ifdef DEPTH_TRACE
fprintf(stderr, "FFBWriteDepthSpan: n(%d) x(%d) y(%d)\n",
(int) n, x, y);
#endif
if (ctx->Depth.Mask) {
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
__DRIdrawablePrivate *dPriv = fmesa->driDrawable;
GLuint *zptr;
GLuint i;
if (!fmesa->hw_locked)
LOCK_HARDWARE(fmesa);
FFBFifo(fmesa, 2);
fmesa->regs->fbc = (FFB_FBC_WB_C | FFB_FBC_ZE_ON |
FFB_FBC_YE_OFF | FFB_FBC_RGBE_OFF);
fmesa->regs->ppc = FFB_PPC_ZS_VAR;
FFBWait(fmesa, fmesa->regs);
y = (dPriv->h - y);
zptr = (GLuint *)
((char *)fmesa->sfb32 +
((dPriv->x + x) << 2) +
((dPriv->y + y) << 13));
for (i = 0; i < n; i++) {
if (mask[i]) {
*zptr = Z_FROM_MESA(depth[i]);
}
zptr++;
}
FFBFifo(fmesa, 2);
fmesa->regs->fbc = fmesa->fbc;
fmesa->regs->ppc = fmesa->ppc;
fmesa->ffbScreen->rp_active = 1;
if (!fmesa->hw_locked)
UNLOCK_HARDWARE(fmesa);
}
}
static void FFBReadDepthPixels( GLcontext *ctx,
struct gl_renderbuffer *rb,
GLuint n,
const GLint x[], const GLint y[],
void *values )
{
GLuint *depth = (GLuint *) values;
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
__DRIdrawablePrivate *dPriv = fmesa->driDrawable;
char *zbase;
GLuint i;
#ifdef DEPTH_TRACE
fprintf(stderr, "FFBReadDepthPixels: n(%d)\n", (int) n);
#endif
if (!fmesa->hw_locked)
LOCK_HARDWARE(fmesa);
FFBFifo(fmesa, 1);
fmesa->regs->fbc = FFB_FBC_RB_C;
fmesa->ffbScreen->rp_active = 1;
FFBWait(fmesa, fmesa->regs);
zbase = ((char *)fmesa->sfb32 +
(dPriv->x << 2) + (dPriv->y << 13));
for (i = 0; i < n; i++) {
GLint y1 = (dPriv->h - y[i]);
GLint x1 = x[i];
GLuint *zptr;
zptr = (GLuint *)
(zbase + (x1 << 2) + (y1 << 13));
depth[i] = Z_TO_MESA(*zptr);
}
FFBFifo(fmesa, 1);
fmesa->regs->fbc = fmesa->fbc;
fmesa->ffbScreen->rp_active = 1;
if (!fmesa->hw_locked)
UNLOCK_HARDWARE(fmesa);
}
static void FFBReadDepthSpan( GLcontext *ctx,
struct gl_renderbuffer *rb,
GLuint n, GLint x, GLint y,
void *values )
{
GLuint *depth = (GLuint *) values;
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
__DRIdrawablePrivate *dPriv = fmesa->driDrawable;
GLuint *zptr;
GLuint i;
#ifdef DEPTH_TRACE
fprintf(stderr, "FFBReadDepthSpan: n(%d) x(%d) y(%d)\n",
(int) n, x, y);
#endif
if (!fmesa->hw_locked)
LOCK_HARDWARE(fmesa);
FFBFifo(fmesa, 1);
fmesa->regs->fbc = FFB_FBC_RB_C;
fmesa->ffbScreen->rp_active = 1;
FFBWait(fmesa, fmesa->regs);
y = (dPriv->h - y);
zptr = (GLuint *)
((char *)fmesa->sfb32 +
((dPriv->x + x) << 2) +
((dPriv->y + y) << 13));
for (i = 0; i < n; i++) {
depth[i] = Z_TO_MESA(*zptr);
zptr++;
}
FFBFifo(fmesa, 1);
fmesa->regs->fbc = fmesa->fbc;
fmesa->ffbScreen->rp_active = 1;
if (!fmesa->hw_locked)
UNLOCK_HARDWARE(fmesa);
}
RegionPtr
CreatorCopyArea(DrawablePtr pSrcDrawable, DrawablePtr pDstDrawable,
GCPtr pGC, int srcx, int srcy, int width, int height, int dstx, int dsty)
{
FFBPtr pFfb = GET_FFB_FROM_SCREEN (pDstDrawable->pScreen);
ffb_fbcPtr ffb = pFfb->regs;
RegionPtr ret;
unsigned char *dptr, *sptr, *sfb;
int garbage, all_planes;
cfbGetByteWidthAndPointer (pDstDrawable, garbage, dptr);
cfbGetByteWidthAndPointer (pSrcDrawable, garbage, sptr);
if (pSrcDrawable->bitsPerPixel == 8) {
sfb = (unsigned char *) pFfb->sfb8r;
all_planes = 0xff;
} else {
sfb = (unsigned char *) pFfb->sfb32;
all_planes = 0xffffff;
}
FFBLOG(("CreatorCopyArea: SFB(%p) s(%p) d(%p) alu(%x) pmsk(%08x) "
"src(%08x:%08x) dst(%08x:%08x)\n",
sfb, sptr, dptr, pGC->alu, pGC->planemask,
srcx, srcy, dstx, dsty));
if (((pGC->planemask & all_planes) != all_planes || pGC->alu != GXcopy) &&
dptr != sfb) {
if(sptr == sfb) {
WindowPtr pWin = (WindowPtr) pSrcDrawable;
FFB_ATTR_SFB_VAR_WIN(pFfb, pGC->planemask, pGC->alu, pWin);
FFBWait(pFfb, ffb);
}
if (pSrcDrawable->bitsPerPixel == 8)
return cfbCopyArea (pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height, dstx, dsty);
else
return cfb32CopyArea (pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height, dstx, dsty);
}
/* Try to use hw VSCROLL if possible */
if (!pFfb->disable_vscroll && /* must not be ffb1 in hires */
pGC->alu == GXcopy && /* it must be a copy */
dstx == srcx && /* X must be unchanging */
dsty != srcy && /* Y must be changing */
sptr == dptr && /* src and dst must be the framebuffer */
dptr == sfb) {
WindowPtr pWin = (WindowPtr) pSrcDrawable;
CreatorPrivWinPtr pFfbPrivWin = CreatorGetWindowPrivate(pWin);
unsigned int fbc = pFfbPrivWin->fbc_base;
int same_buffer;
/* One last check, the read buffer and the write buffer
* must be the same. VSCROLL only allows to move pixels
* within the same buffer.
*/
if (!pFfb->has_double_buffer) {
same_buffer = 1;
} else {
same_buffer = 0;
if ((((fbc & FFB_FBC_WB_MASK) == FFB_FBC_WB_A) &&
((fbc & FFB_FBC_RB_MASK) == FFB_FBC_RB_A)) ||
(((fbc & FFB_FBC_WB_MASK) == FFB_FBC_WB_B) &&
((fbc & FFB_FBC_RB_MASK) == FFB_FBC_RB_B)))
same_buffer = 1;
}
if (same_buffer != 0) {
FFB_ATTR_VSCROLL_WIN(pFfb, pGC->planemask, pWin);
if (pSrcDrawable->bitsPerPixel == 8)
ret = cfbBitBlt (pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height,
dstx, dsty,
(void (*)())CreatorDoVertBitblt, 0);
else
ret = cfb32BitBlt (pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height,
dstx, dsty,
(void (*)())CreatorDoVertBitblt, 0);
FFBLOG(("CreatorCopyArea: Done, returning %p\n", ret));
return ret;
}
}
/* OK, we have to use GCOPY. */
/* Even when we are only reading from the framebuffer, we must
* set the SFB_VAR attributes to handle double-buffering correctly.
*/
if(dptr == sfb || sptr == sfb) {
WindowPtr pWin;
if (dptr == sfb)
pWin = (WindowPtr) pDstDrawable;
else
pWin = (WindowPtr) pSrcDrawable;
FFB_ATTR_SFB_VAR_WIN(pFfb, pGC->planemask, pGC->alu, pWin);
FFBWait(pFfb, ffb);
}
if (pSrcDrawable->bitsPerPixel == 8)
ret = cfbBitBlt (pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height,
dstx, dsty, (void (*)())CreatorDoBitblt, 0);
else
ret = cfb32BitBlt (pSrcDrawable, pDstDrawable,
pGC, srcx, srcy, width, height,
dstx, dsty, (void (*)())CreatorDoBitblt, 0);
FFBLOG(("CreatorCopyArea: Done, returning %p\n", ret));
return ret;
}
/* The hw attributes have been set by someone higher up in the call
* chain.
*/
void
CreatorDoBitblt(DrawablePtr pSrc, DrawablePtr pDst, int alu, RegionPtr prgnDst,
DDXPointPtr pptSrc, unsigned long planemask)
{
FFBPtr pFfb = GET_FFB_FROM_SCREEN (pDst->pScreen);
BoxPtr pboxTmp, pboxNext, pboxBase, pbox;
DDXPointPtr pptTmp;
unsigned char *psrcBase, *pdstBase;
int nbox, widthSrc, widthDst, careful, use_prefetch;
int psz_shift;
cfbGetByteWidthAndPointer (pSrc, widthSrc, psrcBase)
cfbGetByteWidthAndPointer (pDst, widthDst, pdstBase)
careful = ((pSrc == pDst) ||
((pSrc->type == DRAWABLE_WINDOW) &&
(pDst->type == DRAWABLE_WINDOW)));
use_prefetch = (pFfb->use_blkread_prefetch &&
(psrcBase == (unsigned char *)pFfb->sfb32 ||
psrcBase == (unsigned char *)pFfb->sfb8r));
pbox = REGION_RECTS(prgnDst);
nbox = REGION_NUM_RECTS(prgnDst);
pptTmp = pptSrc;
pboxTmp = pbox;
FFBLOG(("GCOPY(%d): ", nbox));
if (pSrc->bitsPerPixel == 8)
psz_shift = 0;
else
psz_shift = 2;
if (careful && pptSrc->y < pbox->y1) {
if (pptSrc->x < pbox->x1) {
/* reverse order of bands and rects in each band */
pboxTmp=pbox+nbox;
pptTmp=pptSrc+nbox;
while (nbox--){
pboxTmp--;
pptTmp--;
FFBLOG(("[%08x:%08x:%08x:%08x:%08x:%08x] ",
pptTmp->x, pptTmp->y, pboxTmp->x1, pboxTmp->y1,
pboxTmp->x2, pboxTmp->y2));
if (pptTmp->x < pbox->x2) {
if (use_prefetch) {
FFBFifo(pFfb, 1);
pFfb->regs->mer = FFB_MER_EDRA;
pFfb->rp_active = 1;
FFBWait(pFfb, pFfb->regs);
}
VISmoveImageRL ((psrcBase +
((pptTmp->y + pboxTmp->y2 - pboxTmp->y1 - 1) *
widthSrc) +
(pptTmp->x << psz_shift)),
(pdstBase +
((pboxTmp->y2 - 1) * widthDst) +
(pboxTmp->x1 << psz_shift)),
(pboxTmp->x2 - pboxTmp->x1) << psz_shift,
(pboxTmp->y2 - pboxTmp->y1),
-widthSrc, -widthDst);
} else {
if (use_prefetch) {
FFBFifo(pFfb, 1);
pFfb->regs->mer = FFB_MER_EIRA;
pFfb->rp_active = 1;
FFBWait(pFfb, pFfb->regs);
}
VISmoveImageLR ((psrcBase +
((pptTmp->y + pboxTmp->y2 - pboxTmp->y1 - 1) *
widthSrc) +
(pptTmp->x << psz_shift)),
(pdstBase +
((pboxTmp->y2 - 1) * widthDst) +
(pboxTmp->x1 << psz_shift)),
(pboxTmp->x2 - pboxTmp->x1) << psz_shift,
(pboxTmp->y2 - pboxTmp->y1),
-widthSrc, -widthDst);
}
}
} else {
/* keep ordering in each band, reverse order of bands */
pboxBase = pboxNext = pbox+nbox-1;
while (pboxBase >= pbox) { /* for each band */
/* find first box in band */
while (pboxNext >= pbox &&
pboxBase->y1 == pboxNext->y1)
pboxNext--;
pboxTmp = pboxNext+1; /* first box in band */
pptTmp = pptSrc + (pboxTmp - pbox); /* first point in band */
FFBLOG(("[%08x:%08x:%08x:%08x:%08x:%08x] ",
pptTmp->x, pptTmp->y, pboxTmp->x1, pboxTmp->y1,
pboxTmp->x2, pboxTmp->y2));
while (pboxTmp <= pboxBase) { /* for each box in band */
if (use_prefetch) {
FFBFifo(pFfb, 1);
pFfb->regs->mer = FFB_MER_EIRA;
pFfb->rp_active = 1;
FFBWait(pFfb, pFfb->regs);
}
VISmoveImageLR ((psrcBase +
((pptTmp->y + pboxTmp->y2 - pboxTmp->y1 - 1) *
widthSrc) +
(pptTmp->x << psz_shift)),
(pdstBase +
((pboxTmp->y2 - 1) * widthDst) +
(pboxTmp->x1 << psz_shift)),
(pboxTmp->x2 - pboxTmp->x1) << psz_shift,
(pboxTmp->y2 - pboxTmp->y1),
-widthSrc, -widthDst);
++pboxTmp;
++pptTmp;
}
pboxBase = pboxNext;
}
}
} else {
if (careful && pptSrc->x < pbox->x1) {
/* reverse order of rects in each band */
pboxBase = pboxNext = pbox;
while (pboxBase < pbox+nbox) { /* for each band */
/* find last box in band */
while (pboxNext < pbox+nbox &&
pboxNext->y1 == pboxBase->y1)
pboxNext++;
pboxTmp = pboxNext; /* last box in band */
pptTmp = pptSrc + (pboxTmp - pbox); /* last point in band */
while (pboxTmp != pboxBase) { /* for each box in band */
--pboxTmp;
--pptTmp;
FFBLOG(("[%08x:%08x:%08x:%08x:%08x:%08x] ",
pptTmp->x, pptTmp->y, pboxTmp->x1, pboxTmp->y1,
pboxTmp->x2, pboxTmp->y2));
if (pptTmp->x < pbox->x2) {
if (use_prefetch) {
FFBFifo(pFfb, 1);
pFfb->regs->mer = FFB_MER_EDRA;
pFfb->regs->mer = FFB_MER_EIRA;
pFfb->rp_active = 1;
}
VISmoveImageRL ((psrcBase +
(pptTmp->y * widthSrc) +
(pptTmp->x << psz_shift)),
(pdstBase +
(pboxTmp->y1 * widthDst) +
(pboxTmp->x1 << psz_shift)),
(pboxTmp->x2 - pboxTmp->x1) << psz_shift,
(pboxTmp->y2 - pboxTmp->y1),
widthSrc, widthDst);
} else {
if (use_prefetch) {
FFBFifo(pFfb, 1);
pFfb->regs->mer = FFB_MER_EIRA;
pFfb->rp_active = 1;
FFBWait(pFfb, pFfb->regs);
}
VISmoveImageLR ((psrcBase +
(pptTmp->y * widthSrc) +
(pptTmp->x << psz_shift)),
(pdstBase +
(pboxTmp->y1 * widthDst) +
(pboxTmp->x1 << psz_shift)),
(pboxTmp->x2 - pboxTmp->x1) << psz_shift,
(pboxTmp->y2 - pboxTmp->y1),
widthSrc, widthDst);
}
}
pboxBase = pboxNext;
}
} else {
while (nbox--) {
FFBLOG(("[%08x:%08x:%08x:%08x:%08x:%08x] ",
pptTmp->x, pptTmp->y, pboxTmp->x1, pboxTmp->y1,
pboxTmp->x2, pboxTmp->y2));
if (use_prefetch) {
FFBFifo(pFfb, 1);
pFfb->regs->mer = FFB_MER_EIRA;
pFfb->rp_active = 1;
FFBWait(pFfb, pFfb->regs);
}
VISmoveImageLR ((psrcBase +
(pptTmp->y * widthSrc) +
(pptTmp->x << psz_shift)),
(pdstBase +
(pboxTmp->y1 * widthDst) +
(pboxTmp->x1 << psz_shift)),
(pboxTmp->x2 - pboxTmp->x1) << psz_shift,
(pboxTmp->y2 - pboxTmp->y1),
widthSrc, widthDst);
pboxTmp++;
pptTmp++;
}
}
}
if (use_prefetch) {
FFBFifo(pFfb, 1);
pFfb->regs->mer = FFB_MER_DRA;
pFfb->rp_active = 1;
FFBWait(pFfb, pFfb->regs);
}
FFBLOG(("done\n"));
}
void
CreatorGetSpans(DrawablePtr pDrawable, int wMax, DDXPointPtr ppt,
int *pwidth, int nspans, char *pchardstStart)
{
FFBPtr pFfb = GET_FFB_FROM_SCREEN (pDrawable->pScreen);
ffb_fbcPtr ffb = pFfb->regs;
char *addrp;
FFBLOG(("CreatorGetSpans: wmax(%d) nspans(%d)\n", wMax, nspans));
/* Punt early for this case. */
if(pDrawable->bitsPerPixel == 1) {
mfbGetSpans(pDrawable, wMax, ppt, pwidth,
nspans, pchardstStart);
return;
}
/* This code only works when sucking bits directly from
* the framebuffer.
*/
if(pDrawable->type != DRAWABLE_WINDOW) {
if (pDrawable->bitsPerPixel == 8)
cfbGetSpans(pDrawable, wMax, ppt, pwidth,
nspans, pchardstStart);
else
cfb32GetSpans(pDrawable, wMax, ppt, pwidth,
nspans, pchardstStart);
return;
}
/*
* XFree86 DDX empties the root borderClip when the VT is
* switched away; this checks for that case
*/
if (!cfbDrawableEnabled(pDrawable))
return;
/* We're just reading pixels from SFB, but we could be using
* a different read buffer when double-buffering.
*/
FFB_ATTR_SFB_VAR_WIN(pFfb, 0x00ffffff, GXcopy, (WindowPtr)pDrawable);
FFBWait(pFfb, ffb);
if (pDrawable->bitsPerPixel == 32) {
unsigned int *pdst = (unsigned int *)pchardstStart;
addrp = (char *) pFfb->sfb32;
if ((nspans == 1) && (*pwidth == 1)) {
*pdst = *(unsigned int *)(addrp + (ppt->y << 13) + (ppt->x << 2));
return;
}
while(nspans--) {
int w = min(ppt->x + *pwidth, 2048) - ppt->x;
unsigned int *psrc = (unsigned int *) (addrp +
(ppt->y << 13) +
(ppt->x << 2));
unsigned int *pdstNext = pdst + w;
while (w--)
*psrc++ = *pdst++;
pdst = pdstNext;
ppt++;
pwidth++;
}
} else {
unsigned char *pdst = (unsigned char *)pchardstStart;
addrp = (char *) pFfb->sfb8r;
if ((nspans == 1) && (*pwidth == 1)) {
*pdst = *(unsigned char *)(addrp + (ppt->y << 11) + (ppt->x << 0));
return;
}
while(nspans--) {
int w = min(ppt->x + *pwidth, 2048) - ppt->x;
unsigned char *psrc = (unsigned char *) (addrp +
(ppt->y << 11) +
(ppt->x << 0));
unsigned char *pdstNext = pdst + w;
while (w--)
*psrc++ = *pdst++;
pdst = pdstNext;
ppt++;
pwidth++;
}
}
}
void
CreatorSetSpans(DrawablePtr pDrawable, GCPtr pGC, char *pcharsrc,
DDXPointPtr ppt, int *pwidth, int nspans, int fSorted)
{
WindowPtr pWin = (WindowPtr) pDrawable;
FFBPtr pFfb = GET_FFB_FROM_SCREEN (pDrawable->pScreen);
ffb_fbcPtr ffb = pFfb->regs;
unsigned int *psrc = (unsigned int *)pcharsrc;
BoxPtr pbox, pboxLast, pboxTest;
DDXPointPtr pptLast;
RegionPtr prgnDst;
char *addrp;
int xStart, xEnd, yMax;
if(pDrawable->type != DRAWABLE_WINDOW) {
if (pDrawable->bitsPerPixel == 8)
cfbSetSpans(pDrawable, pGC, pcharsrc, ppt,
pwidth, nspans, fSorted);
else
cfb32SetSpans(pDrawable, pGC, pcharsrc, ppt,
pwidth, nspans, fSorted);
return;
}
FFBLOG(("CreatorSetSpans: ALU(%x) PMSK(%08x) nspans(%d) fsorted(%d)\n",
pGC->alu, pGC->planemask, nspans, fSorted));
if (pGC->alu == GXnoop)
return;
/* Get SFB ready. */
FFB_ATTR_SFB_VAR_WIN(pFfb, pGC->planemask, pGC->alu, pWin);
FFBWait(pFfb, ffb);
if (pGC->depth == 8)
addrp = (char *) pFfb->sfb8r;
else
addrp = (char *) pFfb->sfb32;
yMax = (int) pDrawable->y + (int) pDrawable->height;
prgnDst = cfbGetCompositeClip(pGC);
pbox = REGION_RECTS(prgnDst);
pboxLast = pbox + REGION_NUM_RECTS(prgnDst);
pptLast = ppt + nspans;
if(fSorted) {
pboxTest = pbox;
while(ppt < pptLast) {
pbox = pboxTest;
if(ppt->y >= yMax)
break;
while(pbox < pboxLast) {
if(pbox->y1 > ppt->y) {
break;
} else if(pbox->y2 <= ppt->y) {
pboxTest = ++pbox;
continue;
} else if(pbox->x1 > ppt->x + *pwidth) {
break;
} else if(pbox->x2 <= ppt->x) {
pbox++;
continue;
}
xStart = max(pbox->x1, ppt->x);
xEnd = min(ppt->x + *pwidth, pbox->x2);
CreatorSetScanline(ppt->y, ppt->x, xStart, xEnd,
psrc, addrp, pGC->depth);
if(ppt->x + *pwidth <= pbox->x2)
break;
else
pbox++;
}
ppt++;
psrc += *pwidth++;
}
} else {
while(ppt < pptLast) {
if(ppt->y >= 0 && ppt->y < yMax) {
for(pbox = REGION_RECTS(prgnDst); pbox < pboxLast; pbox++) {
if(pbox->y1 > ppt->y) {
break;
} else if(pbox->y2 <= ppt->y) {
pbox++;
break;
}
if(pbox->x1 <= ppt->x + *pwidth &&
pbox->x2 > ppt->x) {
xStart = max(pbox->x1, ppt->x);
xEnd = min(pbox->x2, ppt->x + *pwidth);
CreatorSetScanline(ppt->y, ppt->x,
xStart, xEnd,
psrc, addrp, pGC->depth);
}
}
}
ppt++;
psrc += *pwidth++;
}
}
}
