static void ffb_clear(struct vc_data *conp, struct display *p, int sy, int sx,
int height, int width)
{
struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)p->fb_info;
register struct ffb_fbc *fbc = fb->s.ffb.fbc;
unsigned long flags;
u64 yx, hw;
int fg;
spin_lock_irqsave(&fb->lock, flags);
fg = ((u32 *)p->dispsw_data)[attr_bgcol_ec(p,conp)];
if (fg != fb->s.ffb.fg_cache) {
FFBFifo(fb, 5);
upa_writel(fg, &fbc->fg);
fb->s.ffb.fg_cache = fg;
} else
FFBFifo(fb, 4);
if (fontheightlog(p)) {
yx = (u64)sy << (fontheightlog(p) + 32); hw = (u64)height << (fontheightlog(p) + 32);
} else {
yx = (u64)(sy * fontheight(p)) << 32; hw = (u64)(height * fontheight(p)) << 32;
}
if (fontwidthlog(p)) {
yx += sx << fontwidthlog(p); hw += width << fontwidthlog(p);
} else {
yx += sx * fontwidth(p); hw += width * fontwidth(p);
}
upa_writeq(yx + fb->s.ffb.yx_margin, &fbc->by);
upa_writeq(hw, &fbc->bh);
spin_unlock_irqrestore(&fb->lock, flags);
}
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_putc(struct vc_data *conp, struct display *p, int c, int yy, int xx)
{
struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)p->fb_info;
register struct ffb_fbc *fbc = fb->s.ffb.fbc;
unsigned long flags;
int i, xy;
u8 *fd;
u64 fgbg;
spin_lock_irqsave(&fb->lock, flags);
if (fontheightlog(p)) {
xy = (yy << (16 + fontheightlog(p)));
i = ((c & p->charmask) << fontheightlog(p));
} else {
xy = ((yy * fontheight(p)) << 16);
i = (c & p->charmask) * fontheight(p);
}
if (fontwidth(p) <= 8)
fd = p->fontdata + i;
else
fd = p->fontdata + (i << 1);
if (fontwidthlog(p))
xy += (xx << fontwidthlog(p)) + fb->s.ffb.xy_margin;
else
xy += (xx * fontwidth(p)) + fb->s.ffb.xy_margin;
fgbg = (((u64)(((u32 *)p->dispsw_data)[attr_fgcol(p,c)])) << 32) |
((u32 *)p->dispsw_data)[attr_bgcol(p,c)];
if (fgbg != *(u64 *)&fb->s.ffb.fg_cache) {
FFBFifo(fb, 2);
upa_writeq(fgbg, &fbc->fg);
*(u64 *)&fb->s.ffb.fg_cache = fgbg;
}
FFBFifo(fb, 2 + fontheight(p));
upa_writel(xy, &fbc->fontxy);
upa_writel(fontwidth(p), &fbc->fontw);
if (fontwidth(p) <= 8) {
for (i = 0; i < fontheight(p); i++) {
u32 val = *fd++ << 24;
upa_writel(val, &fbc->font);
}
} else {
for (i = 0; i < fontheight(p); i++) {
u32 val = *(u16 *)fd << 16;
upa_writel(val, &fbc->font);
fd += 2;
}
}
spin_unlock_irqrestore(&fb->lock, flags);
}
/* Wheee, circles... */
static void
CreatorFillEllipseSolid(DrawablePtr pDrawable, GCPtr pGC, xArc *arc)
{
WindowPtr pWin = (WindowPtr) pDrawable;
FFBPtr pFfb = GET_FFB_FROM_SCREEN(pDrawable->pScreen);
CreatorPrivGCPtr gcPriv = CreatorGetGCPrivate (pGC);
ffb_fbcPtr ffb = pFfb->regs;
miFillArcRec info;
int x, y, e, yk, xk, ym, xm, dx, dy, xorg, yorg, slw;
/* Get the RP ready. */
if(gcPriv->stipple == NULL) {
FFB_ATTR_GC(pFfb, pGC, pWin,
FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST,
FFB_DRAWOP_RECTANGLE);
} else {
unsigned int fbc;
FFBSetStipple(pFfb, ffb, gcPriv->stipple,
FFB_PPC_CS_CONST, FFB_PPC_CS_MASK);
FFB_WRITE_PMASK(pFfb, ffb, pGC->planemask);
FFB_WRITE_DRAWOP(pFfb, ffb, FFB_DRAWOP_RECTANGLE);
fbc = FFB_FBC_WIN(pWin);
fbc = (fbc & ~FFB_FBC_XE_MASK) | FFB_FBC_XE_OFF;
FFB_WRITE_FBC(pFfb, ffb, fbc);
}
/* Start computing the rects. */
miFillArcSetup(arc, &info);
MIFILLARCSETUP();
if(pGC->miTranslate) {
xorg += pDrawable->x;
yorg += pDrawable->y;
}
while(y > 0) {
MIFILLARCSTEP(slw);
if(slw > 0) {
/* Render. */
FFBFifo(pFfb, 4);
FFB_WRITE64(&ffb->by, yorg - y, xorg - x);
FFB_WRITE64_2(&ffb->bh, 1, slw);
if(miFillArcLower(slw)) {
FFBFifo(pFfb, 4);
FFB_WRITE64(&ffb->by, yorg + y + dy, xorg - x);
FFB_WRITE64_2(&ffb->bh, 1, slw);
}
}
}
pFfb->rp_active = 1;
FFBSync(pFfb, ffb);
}
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);
}
static void ffb_fill(struct fb_info_sbusfb *fb, struct display *p, int s,
int count, unsigned short *boxes)
{
register struct ffb_fbc *fbc = fb->s.ffb.fbc;
unsigned long flags;
int fg;
spin_lock_irqsave(&fb->lock, flags);
fg = ((u32 *)p->dispsw_data)[attr_bgcol(p,s)];
if (fg != fb->s.ffb.fg_cache) {
FFBFifo(fb, 1);
upa_writel(fg, &fbc->fg);
fb->s.ffb.fg_cache = fg;
}
while (count-- > 0) {
FFBFifo(fb, 4);
upa_writel(boxes[1], &fbc->by);
upa_writel(boxes[0], &fbc->bx);
upa_writel(boxes[3] - boxes[1], &fbc->bh);
upa_writel(boxes[2] - boxes[0], &fbc->bw);
boxes += 4;
}
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);
}
void ffbDDClear(GLcontext *ctx, GLbitfield mask)
{
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
__DRIdrawablePrivate *dPriv = fmesa->driDrawable;
unsigned int stcmask = BUFFER_BIT_STENCIL;
#ifdef CLEAR_TRACE
fprintf(stderr, "ffbDDClear: mask(%08x) \n", mask);
#endif
if (!(fmesa->ffb_sarea->flags & FFB_DRI_FFB2PLUS))
stcmask = 0;
if (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT | BUFFER_BIT_DEPTH | stcmask)) {
ffb_fbcPtr ffb = fmesa->regs;
unsigned int fbc, ppc;
fbc = (FFB_FBC_XE_ON);
ppc = (FFB_PPC_ACE_DISABLE | FFB_PPC_DCE_DISABLE |
FFB_PPC_ABE_DISABLE | FFB_PPC_VCE_DISABLE |
FFB_PPC_APE_DISABLE | FFB_PPC_XS_WID |
FFB_PPC_ZS_CONST | FFB_PPC_CS_CONST);
/* Y/X enables must be both on or both off. */
if (mask & (BUFFER_BIT_DEPTH | stcmask)) {
fbc |= (FFB_FBC_ZE_ON | FFB_FBC_YE_ON | FFB_FBC_WB_C);
} else
fbc |= FFB_FBC_ZE_OFF | FFB_FBC_YE_OFF;
/* All RGB enables must be both on or both off. */
if (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT)) {
if (mask & BUFFER_BIT_FRONT_LEFT) {
if (fmesa->back_buffer == 0)
fbc |= FFB_FBC_WB_B;
else
fbc |= FFB_FBC_WB_A;
}
if (mask & BUFFER_BIT_BACK_LEFT) {
if (fmesa->back_buffer == 0)
fbc |= FFB_FBC_WB_A;
else
fbc |= FFB_FBC_WB_B;
}
fbc |= FFB_FBC_RGBE_ON;
} else
fbc |= FFB_FBC_RGBE_OFF;
LOCK_HARDWARE(fmesa);
if (dPriv->numClipRects) {
FFBFifo(fmesa, 8);
ffb->fbc = fbc;
ffb->ppc = ppc;
ffb->xclip = FFB_XCLIP_TEST_ALWAYS;
ffb->cmp = 0x80808080;
ffb->rop = FFB_ROP_NEW;
if (mask & (BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT))
ffb->fg = fmesa->clear_pixel;
if (mask & BUFFER_BIT_DEPTH)
ffb->constz = fmesa->clear_depth;
if (mask & stcmask)
ffb->consty = fmesa->clear_stencil;
ffb_do_clear(ctx, dPriv);
FFBFifo(fmesa, 6);
ffb->ppc = fmesa->ppc;
ffb->fbc = fmesa->fbc;
ffb->xclip = fmesa->xclip;
ffb->cmp = fmesa->cmp;
ffb->rop = fmesa->rop;
ffb->drawop = fmesa->drawop;
if (mask & stcmask)
ffb->consty = fmesa->consty;
fmesa->ffbScreen->rp_active = 1;
}
UNLOCK_HARDWARE(fmesa);
mask &= ~(BUFFER_BIT_FRONT_LEFT | BUFFER_BIT_BACK_LEFT |
BUFFER_BIT_DEPTH | stcmask);
}
if (mask)
_swrast_Clear(ctx, mask);
}
static void
ffb_do_clear(GLcontext *ctx, __DRIdrawablePrivate *dPriv)
{
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
FFBDRIPtr gDRIPriv = (FFBDRIPtr) fmesa->driScreen->pDevPriv;
ffb_fbcPtr ffb = fmesa->regs;
drm_clip_rect_t *box = dPriv->pClipRects;
int nc = dPriv->numClipRects;
GLint cx, cy, cw, ch;
/* compute region after locking: */
cx = ctx->DrawBuffer->_Xmin;
cy = ctx->DrawBuffer->_Ymin;
cw = ctx->DrawBuffer->_Xmax - cx;
ch = ctx->DrawBuffer->_Ymax - cy;
cy = dPriv->h - cy - ch;
cx += dPriv->x;
cy += dPriv->y;
while (nc--) {
GLint x = box[nc].x1;
GLint y = box[nc].y1;
GLint width = box[nc].x2 - x;
GLint height = box[nc].y2 - y;
int paligned_y, paligned_x;
int paligned_h, paligned_w = 0;
int extra_work;
if (BOX_AREA(width, height) < gDRIPriv->fastfill_small_area) {
FFBFifo(fmesa, 5);
ffb->drawop = FFB_DRAWOP_RECTANGLE;
ffb->by = y;
ffb->bx = x;
ffb->bh = height;
ffb->bw = width;
continue;
}
FFBFifo(fmesa, 1);
ffb->drawop = FFB_DRAWOP_FASTFILL;
if (gDRIPriv->disable_pagefill ||
(width < (gDRIPriv->pagefill_width<<1)) ||
(height < (gDRIPriv->pagefill_height<<1)))
goto do_fastfill;
CreatorPageFillParms(gDRIPriv,
x, y, width, height,
paligned_x, paligned_y,
paligned_w, paligned_h, extra_work);
if (extra_work < 0 ||
BOX_AREA(paligned_w, paligned_h) < gDRIPriv->pagefill_small_area) {
do_fastfill:
FFBFifo(fmesa, 10);
ffb->by = FFB_FASTFILL_COLOR_BLK;
ffb->dy = 0;
ffb->dx = 0;
ffb->bh = gDRIPriv->fastfill_height;
ffb->bw = (gDRIPriv->fastfill_width * 4);
ffb->by = FFB_FASTFILL_BLOCK;
ffb->dy = y;
ffb->dx = x;
ffb->bh = (height + (y & (gDRIPriv->fastfill_height - 1)));
ffb->bx = (width + (x & (gDRIPriv->fastfill_width - 1)));
continue;
}
/* Ok, page fill is possible and worth it. */
FFBFifo(fmesa, 15);
ffb->by = FFB_FASTFILL_COLOR_BLK;
ffb->dy = 0;
ffb->dx = 0;
ffb->bh = gDRIPriv->fastfill_height;
ffb->bw = gDRIPriv->fastfill_width * 4;
ffb->by = FFB_FASTFILL_BLOCK_X;
ffb->dy = 0;
ffb->dx = 0;
ffb->bh = gDRIPriv->pagefill_height;
ffb->bw = gDRIPriv->pagefill_width * 4;
ffb->by = FFB_FASTFILL_PAGE;
ffb->dy = paligned_y;
ffb->dx = paligned_x;
ffb->bh = paligned_h;
ffb->bx = paligned_w;
if (extra_work) {
struct ff_fixups local_fixups[4];
int nfixups;
nfixups = CreatorComputePageFillFixups(local_fixups,
x, y, width, height,
paligned_x, paligned_y,
paligned_w, paligned_h);
FFBFifo(fmesa, 5 + (nfixups * 5));
ffb->by = FFB_FASTFILL_COLOR_BLK;
ffb->dy = 0;
ffb->dx = 0;
ffb->bh = gDRIPriv->fastfill_height;
ffb->bw = gDRIPriv->fastfill_width * 4;
while (--nfixups >= 0) {
int xx, yy, ww, hh;
xx = local_fixups[nfixups].x;
yy = local_fixups[nfixups].y;
ffb->dy = yy;
ffb->dx = xx;
ww = (local_fixups[nfixups].width +
(xx & (gDRIPriv->fastfill_width - 1)));
hh = (local_fixups[nfixups].height +
(yy & (gDRIPriv->fastfill_height - 1)));
if (nfixups != 0) {
ffb->by = FFB_FASTFILL_BLOCK;
ffb->bh = hh;
ffb->bw = ww;
} else {
ffb->bh = hh;
ffb->by = FFB_FASTFILL_BLOCK;
ffb->bx = ww;
}
}
}
}
}
/* 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
CreatorFillPolygon (DrawablePtr pDrawable, GCPtr pGC, int shape, int mode, int count, DDXPointPtr ppt)
{
WindowPtr pWin = (WindowPtr) pDrawable;
CreatorPrivGCPtr gcPriv = CreatorGetGCPrivate (pGC);
FFBPtr pFfb = GET_FFB_FROM_SCREEN (pGC->pScreen);
ffb_fbcPtr ffb = pFfb->regs;
BoxRec box;
int lx, rx, ty, by;
int t, b, i, j, k, l, tt;
int xy[12] FFB_ALIGN64;
int xOrg, yOrg;
FFBLOG(("CreatorFillPolygon: ALU(%x) PMSK(%08x) shape(%d) mode(%d) count(%d)\n",
pGC->alu, pGC->planemask, shape, mode, count));
if (count < 3)
return;
if (shape != Convex && count > 3) {
miFillPolygon (pDrawable, pGC, shape, mode, count, ppt);
return;
}
xOrg = pDrawable->x;
yOrg = pDrawable->y;
ppt->x += xOrg;
ppt->y += yOrg;
lx = ppt->x;
rx = ppt->x;
ty = ppt->y;
by = ppt->y;
t = b = 0;
tt = 1;
for (i = 1; i < count; i++) {
if (mode == CoordModeOrigin) {
ppt[i].x += xOrg;
ppt[i].y += yOrg;
} else {
ppt[i].x += ppt[i-1].x;
ppt[i].y += ppt[i-1].y;
}
if (ppt[i].x < lx)
lx = ppt[i].x;
if (ppt[i].x > rx)
rx = ppt[i].x;
if (ppt[i].y < ty) {
ty = ppt[i].y;
t = i;
tt = 1;
} else if (ppt[i].y == ty)
tt++;
if (ppt[i].y > by) {
by = ppt[i].y;
b = i;
}
}
if (tt > 2) {
miFillConvexPoly(pDrawable, pGC, count, ppt);
return;
} else if (tt == 2) {
i = t - 1;
if (i < 0)
i = count - 1;
if (ppt[i].y == ppt[t].y)
t = i;
}
box.x1 = lx;
box.x2 = rx + 1;
box.y1 = ty;
box.y2 = by + 1;
switch (RECT_IN_REGION(pGC->pScreen, cfbGetCompositeClip(pGC), &box)) {
case rgnPART:
miFillConvexPoly(pDrawable, pGC, count, ppt);
case rgnOUT:
return;
}
if(gcPriv->stipple == NULL) {
FFB_ATTR_GC(pFfb, pGC, pWin,
FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST,
FFB_DRAWOP_POLYGON);
} else {
unsigned int fbc;
FFBSetStipple(pFfb, ffb, gcPriv->stipple,
FFB_PPC_CS_CONST, FFB_PPC_CS_MASK);
FFB_WRITE_PMASK(pFfb, ffb, pGC->planemask);
FFB_WRITE_DRAWOP(pFfb, ffb, FFB_DRAWOP_POLYGON);
fbc = FFB_FBC_WIN(pWin);
fbc = (fbc & ~FFB_FBC_XE_MASK) | FFB_FBC_XE_OFF;
FFB_WRITE_FBC(pFfb, ffb, fbc);
}
xy[0] = ppt[t].y;
xy[1] = ppt[t].x;
j = t + 1;
if (j == count) j = 0;
xy[2] = ppt[j].y;
xy[3] = ppt[j].x;
j = t + 2;
if (j >= count)
j -= count;
for (i = 2 * count - 4; i; i -= k) {
b = 2;
for (k = 0; k < i && k < 8; k+=2) {
xy[4 + k] = ppt[j].y;
xy[4 + k + 1] = ppt[j].x;
if (xy[4 + k] > xy[b])
b = 4 + k;
j++; if (j == count) j = 0;
}
FFBFifo(pFfb, 4 + k);
for (l = 0; l < b - 2; l+=2)
FFB_WRITE64P(&ffb->by, &xy[l]);
FFB_WRITE64P(&ffb->bh, &xy[l]);
for (l+=2; l <= k; l+=2)
FFB_WRITE64P(&ffb->by, &xy[l]);
FFB_WRITE64P(&ffb->ebyi, &xy[l]);
xy[2] = xy[l];
xy[3] = xy[l+1];
}
pFfb->rp_active = 1;
FFBSync(pFfb, ffb);
}
static void ffb_putcs(struct vc_data *conp, struct display *p, const unsigned short *s,
int count, int yy, int xx)
{
struct fb_info_sbusfb *fb = (struct fb_info_sbusfb *)p->fb_info;
register struct ffb_fbc *fbc = fb->s.ffb.fbc;
unsigned long flags;
int i, xy;
u8 *fd1, *fd2, *fd3, *fd4;
u16 c;
u64 fgbg;
spin_lock_irqsave(&fb->lock, flags);
c = scr_readw(s);
fgbg = (((u64)(((u32 *)p->dispsw_data)[attr_fgcol(p, c)])) << 32) |
((u32 *)p->dispsw_data)[attr_bgcol(p, c)];
if (fgbg != *(u64 *)&fb->s.ffb.fg_cache) {
FFBFifo(fb, 2);
upa_writeq(fgbg, &fbc->fg);
*(u64 *)&fb->s.ffb.fg_cache = fgbg;
}
xy = fb->s.ffb.xy_margin;
if (fontwidthlog(p))
xy += (xx << fontwidthlog(p));
else
xy += xx * fontwidth(p);
if (fontheightlog(p))
xy += (yy << (16 + fontheightlog(p)));
else
xy += ((yy * fontheight(p)) << 16);
if (fontwidth(p) <= 8) {
while (count >= 4) {
count -= 4;
FFBFifo(fb, 2 + fontheight(p));
upa_writel(4 * fontwidth(p), &fbc->fontw);
upa_writel(xy, &fbc->fontxy);
if (fontheightlog(p)) {
fd1 = p->fontdata + ((scr_readw(s++) & p->charmask) << fontheightlog(p));
fd2 = p->fontdata + ((scr_readw(s++) & p->charmask) << fontheightlog(p));
fd3 = p->fontdata + ((scr_readw(s++) & p->charmask) << fontheightlog(p));
fd4 = p->fontdata + ((scr_readw(s++) & p->charmask) << fontheightlog(p));
} else {
fd1 = p->fontdata + ((scr_readw(s++) & p->charmask) * fontheight(p));
fd2 = p->fontdata + ((scr_readw(s++) & p->charmask) * fontheight(p));
fd3 = p->fontdata + ((scr_readw(s++) & p->charmask) * fontheight(p));
fd4 = p->fontdata + ((scr_readw(s++) & p->charmask) * fontheight(p));
}
if (fontwidth(p) == 8) {
for (i = 0; i < fontheight(p); i++) {
u32 val;
val = ((u32)*fd4++) | ((((u32)*fd3++) | ((((u32)*fd2++) | (((u32)*fd1++)
<< 8)) << 8)) << 8);
upa_writel(val, &fbc->font);
}
xy += 32;
} else {
for (i = 0; i < fontheight(p); i++) {
u32 val = (((u32)*fd4++) | ((((u32)*fd3++) | ((((u32)*fd2++) | (((u32)*fd1++)
<< fontwidth(p))) << fontwidth(p))) << fontwidth(p))) << (24 - 3 * fontwidth(p));
upa_writel(val, &fbc->font);
}
xy += 4 * fontwidth(p);
}
}
} else {
while (count >= 2) {
count -= 2;
FFBFifo(fb, 2 + fontheight(p));
upa_writel(2 * fontwidth(p), &fbc->fontw);
upa_writel(xy, &fbc->fontxy);
if (fontheightlog(p)) {
fd1 = p->fontdata + ((scr_readw(s++) & p->charmask) << (fontheightlog(p) + 1));
fd2 = p->fontdata + ((scr_readw(s++) & p->charmask) << (fontheightlog(p) + 1));
} else {
fd1 = p->fontdata + (((scr_readw(s++) & p->charmask) * fontheight(p)) << 1);
fd2 = p->fontdata + (((scr_readw(s++) & p->charmask) * fontheight(p)) << 1);
}
for (i = 0; i < fontheight(p); i++) {
u32 val = ((((u32)*(u16 *)fd1) << fontwidth(p)) | ((u32)*(u16 *)fd2)) << (16 - fontwidth(p));
upa_writel(val, &fbc->font);
fd1 += 2; fd2 += 2;
}
xy += 2 * fontwidth(p);
}
}
while (count) {
count--;
FFBFifo(fb, 2 + fontheight(p));
upa_writel(fontwidth(p), &fbc->fontw);
upa_writel(xy, &fbc->fontxy);
if (fontheightlog(p))
i = ((scr_readw(s++) & p->charmask) << fontheightlog(p));
else
i = ((scr_readw(s++) & p->charmask) * fontheight(p));
if (fontwidth(p) <= 8) {
fd1 = p->fontdata + i;
for (i = 0; i < fontheight(p); i++) {
u32 val = *fd1++ << 24;
upa_writel(val, &fbc->font);
}
} else {
fd1 = p->fontdata + (i << 1);
for (i = 0; i < fontheight(p); i++) {
u32 val = *(u16 *)fd1 << 16;
upa_writel(val, &fbc->font);
fd1 += 2;
}
}
xy += fontwidth(p);
}
spin_unlock_irqrestore(&fb->lock, flags);
}
void
CreatorDoHWBitblt(DrawablePtr pSrc, DrawablePtr pDst, int alu, RegionPtr prgnDst,
DDXPointPtr pptSrc, unsigned long planemask)
{
FFBPtr pFfb = GET_FFB_FROM_SCREEN (pSrc->pScreen);
ffb_fbcPtr ffb = pFfb->regs;
BoxPtr pboxTmp;
DDXPointPtr pptTmp;
int nbox;
BoxPtr pboxNext, pboxBase, pbox;
nbox = REGION_NUM_RECTS(prgnDst);
pbox = REGION_RECTS(prgnDst);
FFB_WRITE_ATTRIBUTES(pFfb,
FFB_PPC_ACE_DISABLE|FFB_PPC_APE_DISABLE|FFB_PPC_CS_CONST,
FFB_PPC_ACE_MASK|FFB_PPC_APE_MASK|FFB_PPC_CS_MASK,
planemask,
FFB_ROP_NEW,
FFB_DRAWOP_BCOPY, pFfb->fg_cache,
FFB_FBC_DEFAULT);
/* need to blit rectangles in different orders, depending on the direction of copy
so that an area isnt overwritten before it is blitted */
if (pptSrc->y < pbox->y1 && nbox > 1) {
if (pptSrc->x < pbox->x1) {
pboxTmp = pbox + nbox;
pptTmp = pptSrc + nbox;
while(nbox--) {
pboxTmp--;
pptTmp--;
FFBFifo(pFfb, 6);
FFB_WRITE64(&ffb->by, pptTmp->y, pptTmp->x);
FFB_WRITE64_2(&ffb->dy, pboxTmp->y1, pboxTmp->x1);
FFB_WRITE64_3(&ffb->bh,
(pboxTmp->y2 - pboxTmp->y1),
(pboxTmp->x2 - pboxTmp->x1));
}
} 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 */
while (pboxTmp <= pboxBase) { /* for each box in band */
FFBFifo(pFfb, 6);
FFB_WRITE64(&ffb->by, pptTmp->y, pptTmp->x);
FFB_WRITE64_2(&ffb->dy, pboxTmp->y1, pboxTmp->x1);
FFB_WRITE64_3(&ffb->bh,
(pboxTmp->y2 - pboxTmp->y1),
(pboxTmp->x2 - pboxTmp->x1));
++pboxTmp;
++pptTmp;
}
pboxBase = pboxNext;
}
}
} else {
if((pptSrc->x < pbox->x1) && (nbox > 1)) {
pboxBase = pboxNext = pbox;
while(pboxBase < pbox+nbox) {
while((pboxNext<pbox+nbox) &&
(pboxNext->y1 == pboxBase->y1))
pboxNext++;
pboxTmp = pboxNext;
pptTmp = pptSrc + (pboxTmp - pbox);
while(pboxTmp != pboxBase) {
--pboxTmp;
--pptTmp;
FFBFifo(pFfb, 6);
FFB_WRITE64(&ffb->by, pptTmp->y, pptTmp->x);
FFB_WRITE64_2(&ffb->dy, pboxTmp->y1, pboxTmp->x1);
FFB_WRITE64_3(&ffb->bh,
(pboxTmp->y2 - pboxTmp->y1),
(pboxTmp->x2 - pboxTmp->x1));
}
pboxBase = pboxNext;
}
} else {
/* dont need to change order of anything */
pptTmp = pptSrc;
pboxTmp = pbox;
while (nbox--) {
FFBFifo(pFfb, 6);
FFB_WRITE64(&ffb->by, pptTmp->y, pptTmp->x);
FFB_WRITE64_2(&ffb->dy, pboxTmp->y1, pboxTmp->x1);
FFB_WRITE64_3(&ffb->bh,
(pboxTmp->y2 - pboxTmp->y1),
(pboxTmp->x2 - pboxTmp->x1));
pboxTmp++;
pptTmp++;
}
}
}
pFfb->rp_active = 1;
FFBSync(pFfb, ffb);
}
static void
ffb_bitmap(GLcontext *ctx, GLint px, GLint py,
GLsizei width, GLsizei height,
const struct gl_pixelstore_attrib *unpack,
const GLubyte *bitmap)
{
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
ffb_fbcPtr ffb = fmesa->regs;
__DRIdrawablePrivate *dPriv = fmesa->driDrawable;
unsigned int ppc, pixel;
GLint row, col, row_stride;
const GLubyte *src;
char *buf;
if (fmesa->bad_fragment_attrs != 0)
_swrast_Bitmap(ctx, px, py, width,
height, unpack, bitmap);
pixel = (((((GLuint)(ctx->Current.RasterColor[0] * 255.0f)) & 0xff) << 0) |
((((GLuint)(ctx->Current.RasterColor[1] * 255.0f)) & 0xff) << 8) |
((((GLuint)(ctx->Current.RasterColor[2] * 255.0f)) & 0xff) << 16) |
((((GLuint)(ctx->Current.RasterColor[3] * 255.0f)) & 0xff) << 24));
#ifdef FFB_BITMAP_TRACE
fprintf(stderr, "ffb_bitmap: ppc(%08x) fbc(%08x) cmp(%08x) pixel(%08x)\n",
fmesa->ppc, fmesa->fbc, fmesa->cmp, pixel);
#endif
LOCK_HARDWARE(fmesa);
fmesa->hw_locked = 1;
if (fmesa->state_dirty)
ffbSyncHardware(fmesa);
ppc = fmesa->ppc;
FFBFifo(fmesa, 4);
ffb->ppc = ((ppc &
~(FFB_PPC_TBE_MASK | FFB_PPC_ZS_MASK | FFB_PPC_CS_MASK | FFB_PPC_XS_MASK))
| (FFB_PPC_TBE_TRANSPARENT | FFB_PPC_ZS_CONST | FFB_PPC_CS_CONST |
(ctx->Color.BlendEnabled ? FFB_PPC_XS_CONST : FFB_PPC_XS_WID)));
ffb->constz = ((GLuint) (ctx->Current.RasterPos[2] * 0x0fffffff));
ffb->fg = pixel;
ffb->fontinc = (0 << 16) | 32;
buf = (char *)(fmesa->sfb32 + (dPriv->x << 2) + (dPriv->y << 13));
row_stride = (unpack->Alignment * CEILING(width, 8 * unpack->Alignment));
src = (const GLubyte *) (bitmap +
(unpack->SkipRows * row_stride) +
(unpack->SkipPixels / 8));
if (unpack->LsbFirst == GL_TRUE) {
for (row = 0; row < height; row++, src += row_stride) {
const GLubyte *row_src = src;
GLuint base_x, base_y;
base_x = dPriv->x + px;
base_y = dPriv->y + (dPriv->h - (py + row));
FFBFifo(fmesa, 1);
ffb->fontxy = (base_y << 16) | base_x;
for (col = 0; col < width; col += 32, row_src += 4) {
GLint bitnum, font_w = (width - col);
GLuint font_data;
if (font_w > 32)
font_w = 32;
font_data = 0;
for (bitnum = 0; bitnum < 32; bitnum++) {
const GLubyte val = row_src[bitnum >> 3];
if (val & (1 << (bitnum & (8 - 1))))
font_data |= (1 << (31 - bitnum));
}
FFBFifo(fmesa, 2);
ffb->fontw = font_w;
ffb->font = font_data;
}
}
} else {
for (row = 0; row < height; row++, src += row_stride) {
static void ffbRasterPrimitive(GLcontext *ctx, GLenum rprim)
{
ffbContextPtr fmesa = FFB_CONTEXT(ctx);
GLuint drawop, fbc, ppc;
int do_sw = 0;
fmesa->raster_primitive = rprim;
drawop = fmesa->drawop;
fbc = fmesa->fbc;
ppc = fmesa->ppc & ~(FFB_PPC_ZS_MASK | FFB_PPC_CS_MASK);
#ifdef STATE_TRACE
fprintf(stderr,
"ffbReducedPrimitiveChange: rprim(%d) ", rprim);
#endif
switch(rprim) {
case GL_POINTS:
#ifdef STATE_TRACE
fprintf(stderr, "GL_POINTS ");
#endif
if (fmesa->draw_point == ffb_fallback_point) {
do_sw = 1;
break;
}
if (ctx->Point.SmoothFlag) {
ppc |= (FFB_PPC_ZS_VAR | FFB_PPC_CS_CONST);
drawop = FFB_DRAWOP_AADOT;
} else {
ppc |= (FFB_PPC_ZS_CONST | FFB_PPC_CS_CONST);
drawop = FFB_DRAWOP_DOT;
}
break;
case GL_LINES:
#ifdef STATE_TRACE
fprintf(stderr, "GL_LINES ");
#endif
if (fmesa->draw_line == ffb_fallback_line) {
do_sw = 1;
break;
}
if (ctx->_TriangleCaps & DD_FLATSHADE) {
ppc |= FFB_PPC_ZS_VAR | FFB_PPC_CS_CONST;
} else {
ppc |= FFB_PPC_ZS_VAR | FFB_PPC_CS_VAR;
}
if (ctx->Line.SmoothFlag)
drawop = FFB_DRAWOP_AALINE;
else
drawop = FFB_DRAWOP_DDLINE;
break;
case GL_TRIANGLES:
#ifdef STATE_TRACE
fprintf(stderr, "GL_POLYGON ");
#endif
if (fmesa->draw_tri == ffb_fallback_triangle) {
do_sw = 1;
break;
}
ppc &= ~FFB_PPC_APE_MASK;
if (ctx->Polygon.StippleFlag)
ppc |= FFB_PPC_APE_ENABLE;
else
ppc |= FFB_PPC_APE_DISABLE;
if (ctx->_TriangleCaps & DD_FLATSHADE) {
ppc |= FFB_PPC_ZS_VAR | FFB_PPC_CS_CONST;
} else {
ppc |= FFB_PPC_ZS_VAR | FFB_PPC_CS_VAR;
}
drawop = FFB_DRAWOP_TRIANGLE;
break;
default:
#ifdef STATE_TRACE
fprintf(stderr, "unknown %d!\n", rprim);
#endif
return;
};
#ifdef STATE_TRACE
fprintf(stderr, "do_sw(%d) ", do_sw);
#endif
if (do_sw != 0) {
fbc &= ~(FFB_FBC_WB_C);
fbc &= ~(FFB_FBC_ZE_MASK | FFB_FBC_RGBE_MASK);
fbc |= FFB_FBC_ZE_OFF | FFB_FBC_RGBE_MASK;
ppc &= ~(FFB_PPC_XS_MASK | FFB_PPC_ABE_MASK |
FFB_PPC_DCE_MASK | FFB_PPC_APE_MASK);
ppc |= (FFB_PPC_ZS_VAR | FFB_PPC_CS_VAR | FFB_PPC_XS_WID |
FFB_PPC_ABE_DISABLE | FFB_PPC_DCE_DISABLE |
FFB_PPC_APE_DISABLE);
} else {
fbc |= FFB_FBC_WB_C;
fbc &= ~(FFB_FBC_RGBE_MASK);
fbc |= FFB_FBC_RGBE_MASK;
ppc &= ~(FFB_PPC_ABE_MASK | FFB_PPC_XS_MASK);
if (ctx->Color.BlendEnabled) {
if ((rprim == GL_POINTS && !ctx->Point.SmoothFlag) ||
(rprim != GL_POINTS && ctx->_TriangleCaps & DD_FLATSHADE))
ppc |= FFB_PPC_ABE_ENABLE | FFB_PPC_XS_CONST;
else
ppc |= FFB_PPC_ABE_ENABLE | FFB_PPC_XS_VAR;
} else {
ppc |= FFB_PPC_ABE_DISABLE | FFB_PPC_XS_WID;
}
}
#ifdef STATE_TRACE
fprintf(stderr, "fbc(%08x) ppc(%08x)\n", fbc, ppc);
#endif
FFBFifo(fmesa, 4);
if (fmesa->drawop != drawop)
fmesa->regs->drawop = fmesa->drawop = drawop;
if (fmesa->fbc != fbc)
fmesa->regs->fbc = fmesa->fbc = fbc;
if (fmesa->ppc != ppc)
fmesa->regs->ppc = fmesa->ppc = ppc;
if (do_sw != 0) {
fmesa->regs->cmp =
(fmesa->cmp & ~(0xff<<16)) | (0x80 << 16);
} else
fmesa->regs->cmp = fmesa->cmp;
}
void
CreatorPolySegment (DrawablePtr pDrawable, GCPtr pGC, int nseg, xSegment *pSeg)
{
WindowPtr pWin = (WindowPtr) pDrawable;
CreatorPrivGCPtr gcPriv = CreatorGetGCPrivate (pGC);
FFBPtr pFfb = GET_FFB_FROM_SCREEN (pGC->pScreen);
ffb_fbcPtr ffb = pFfb->regs;
BoxPtr extent;
int xorg, yorg, lpat;
if (nseg == 0)
return;
FFBLOG(("CreatorPolySegment: ALU(%x) PMSK(%08x) nseg(%d) lpat(%08x)\n",
pGC->alu, pGC->planemask, nseg, gcPriv->linepat));
if (gcPriv->stipple == NULL) {
FFB_ATTR_GC(pFfb, pGC, pWin,
FFB_PPC_APE_DISABLE | FFB_PPC_CS_CONST,
SEG_DRAWOP(pGC));
} else {
unsigned int fbc;
FFBSetStipple(pFfb, ffb, gcPriv->stipple,
FFB_PPC_CS_CONST, FFB_PPC_CS_MASK);
FFB_WRITE_PMASK(pFfb, ffb, pGC->planemask);
FFB_WRITE_DRAWOP(pFfb, ffb, SEG_DRAWOP(pGC));
fbc = FFB_FBC_WIN(pWin);
fbc = (fbc & ~FFB_FBC_XE_MASK) | FFB_FBC_XE_OFF;
FFB_WRITE_FBC(pFfb, ffb, fbc);
}
pFfb->rp_active = 1;
xorg = pDrawable->x;
yorg = pDrawable->y;
extent = REGION_RECTS(cfbGetCompositeClip(pGC));
lpat = gcPriv->linepat;
if (lpat == 0) {
FFBFifo(pFfb, 1);
ffb->lpat = 0;
if (pFfb->has_brline_bug) {
while (nseg--) {
register int x1 = pSeg->x1 + xorg;
register int y1 = pSeg->y1 + yorg;
register int x2 = pSeg->x2 + xorg;
register int y2 = pSeg->y2 + yorg;
if (x1 >= extent->x1 &&
x2 >= extent->x1 &&
x1 < extent->x2 &&
x2 < extent->x2 &&
y1 >= extent->y1 &&
y2 >= extent->y1 &&
y1 < extent->y2 &&
y2 < extent->y2) {
FFBFifo(pFfb, 5);
ffb->ppc = 0;
FFB_WRITE64(&ffb->by, y1, x1);
FFB_WRITE64_2(&ffb->bh, y2, x2);
} else {
gcPriv->PolySegment(pDrawable, pGC, 1, pSeg);
ReloadSegmentAttrs(pFfb, gcPriv, pGC, pWin);
pFfb->rp_active = 1;
}
pSeg++;
}
} else {
while (nseg--) {
register int x1 = pSeg->x1 + xorg;
register int y1 = pSeg->y1 + yorg;
register int x2 = pSeg->x2 + xorg;
register int y2 = pSeg->y2 + yorg;
if (x1 >= extent->x1 &&
x2 >= extent->x1 &&
x1 < extent->x2 &&
x2 < extent->x2 &&
y1 >= extent->y1 &&
y2 >= extent->y1 &&
y1 < extent->y2 &&
y2 < extent->y2) {
FFBFifo(pFfb, 4);
FFB_WRITE64(&ffb->by, y1, x1);
FFB_WRITE64_2(&ffb->bh, y2, x2);
} else {
gcPriv->PolySegment(pDrawable, pGC, 1, pSeg);
ReloadSegmentAttrs(pFfb, gcPriv, pGC, pWin);
pFfb->rp_active = 1;
}
pSeg++;
}
}
} else {
/* No reason to optimize the non-brline bug case since
* we have to write the line pattern register each loop
* anyways.
*/
while (nseg--) {
register int x1 = pSeg->x1 + xorg;
register int y1 = pSeg->y1 + yorg;
register int x2 = pSeg->x2 + xorg;
register int y2 = pSeg->y2 + yorg;
if (x1 >= extent->x1 && x2 >= extent->x1 &&
x1 < extent->x2 && x2 < extent->x2 &&
y1 >= extent->y1 && y2 >= extent->y1 &&
y1 < extent->y2 && y2 < extent->y2) {
FFBFifo(pFfb, 5);
ffb->lpat = lpat;
FFB_WRITE64(&ffb->by, y1, x1);
FFB_WRITE64_2(&ffb->bh, y2, x2);
} else {
gcPriv->PolySegment(pDrawable, pGC, 1, pSeg);
ReloadSegmentAttrs(pFfb, gcPriv, pGC, pWin);
pFfb->rp_active = 1;
}
pSeg++;
}
}
FFBSync(pFfb, ffb);
}
/* We know here that only y is changing and that the hw attributes
* have been set higher up in the call chain.
*/
void
CreatorDoVertBitblt(DrawablePtr pSrc, DrawablePtr pDst, int alu, RegionPtr prgnDst,
DDXPointPtr pptSrc, unsigned long planemask)
{
FFBPtr pFfb = GET_FFB_FROM_SCREEN (pSrc->pScreen);
ffb_fbcPtr ffb = pFfb->regs;
BoxPtr pbox;
int nbox;
pbox = REGION_RECTS(prgnDst);
nbox = REGION_NUM_RECTS(prgnDst);
/* No garbage please. */
if(nbox <= 0)
return;
FFBLOG(("VSCROLL(%d): ", nbox));
/* Need to blit rectangles in different orders, depending
* on the direction of copy so that an area isnt overwritten
* before it is blitted.
*/
if (nbox > 1 && pptSrc->y < pbox->y1) {
BoxPtr pboxBase = pbox + nbox - 1;
BoxPtr pboxNext = pboxBase;
/* Keep ordering in each band, reverse order of bands. */
while (pboxBase >= pbox) { /* for each band */
BoxPtr pboxTmp;
DDXPointPtr pptTmp;
/* 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 */
while (pboxTmp <= pboxBase) {
FFBLOG(("1[%08x:%08x:%08x:%08x:%08x:%08x] ",
pptTmp->x, pptTmp->y, pboxTmp->x1, pboxTmp->y1,
pboxTmp->x2, pboxTmp->y2));
FFBFifo(pFfb, 7);
ffb->drawop = FFB_DRAWOP_VSCROLL;
FFB_WRITE64(&ffb->by, pptTmp->y, pptTmp->x);
FFB_WRITE64_2(&ffb->dy, pboxTmp->y1, pboxTmp->x1);
FFB_WRITE64_3(&ffb->bh, (pboxTmp->y2 - pboxTmp->y1),
(pboxTmp->x2 - pboxTmp->x1));
pboxTmp++;
pptTmp++;
}
pboxBase = pboxNext;
}
} else {
/* Dont need to change order of anything. */
while (nbox--) {
FFBLOG(("2[%08x:%08x:%08x:%08x:%08x:%08x] ",
pptSrc->x, pptSrc->y, pbox->x1, pbox->y1,
pbox->x2, pbox->y2));
FFBFifo(pFfb, 7);
ffb->drawop = FFB_DRAWOP_VSCROLL;
FFB_WRITE64(&ffb->by, pptSrc->y, pptSrc->x);
FFB_WRITE64_2(&ffb->dy, pbox->y1, pbox->x1);
FFB_WRITE64_3(&ffb->bh, (pbox->y2 - pbox->y1),
(pbox->x2 - pbox->x1));
pbox++;
pptSrc++;
}
}
pFfb->rp_active = 1;
FFBLOG(("done\n"));
FFBSync(pFfb, ffb);
}
