able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/drivers/video/ms/cirrus/disp/bltmm.c

2291 lines
72 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/******************************************************************************\
*
* $Workfile: bltmm.c $
*
* Contains the low-level MM blt functions.
*
* Hopefully, if you're basing your display driver on this code, to support all
* of DrvBitBlt and DrvCopyBits, you'll only have to implement the following
* routines. You shouldn't have to modify much in 'bitblt.c'. I've tried to make
* these routines as few, modular, simple, and efficient as I could, while still
* accelerating as many calls as possible that would be cost-effective in terms
* of performance wins versus size and effort.
*
* Note: In the following, 'relative' coordinates refers to coordinates that
* haven't yet had the offscreen bitmap (DFB) offset applied. 'Absolute'
* coordinates have had the offset applied. For example, we may be told to
* blt to (1, 1) of the bitmap, but the bitmap may be sitting in offscreen
* memory starting at coordinate (0, 768) -- (1, 1) would be the
* 'relative' start coordinate, and (1, 769) would be the 'absolute' start
* coordinate'.
*
* Copyright (c) 1992-1995 Microsoft Corporation
* Copyright (c) 1996 Cirrus Logic, Inc.
*
* $Log: S:/projects/drivers/ntsrc/display/bltmm.c_v $
*
* Rev 1.4 Jan 14 1997 15:16:14 unknown
* take out GR33 clearing after 80 blt.
*
* Rev 1.2 Nov 07 1996 16:47:52 unknown
*
*
* Rev 1.1 Oct 10 1996 15:36:14 unknown
*
*
* Rev 1.4 12 Aug 1996 16:58:56 frido
* Removed unaccessed local variables.
* Renamed vMmPatternBlt into vMmFillPat36.
*
* Rev 1.3 08 Aug 1996 16:55:10 frido
* Added new vMmCopyBlt36 routine.
*
* Rev 1.2 08 Aug 1996 12:59:28 frido
* bank#1 - Removed banking code since MMIO is always linear.
*
* Rev 1.1 31 Jul 1996 15:43:14 frido
* Added new pattern blit.
*
* jl01 10-08-96 Do Transparent BLT w/o Solid Fill. Refer to PDRs#5511/6817.
* chu01 01-09-97 Make sure to reset GR33.
*
\******************************************************************************/
#include "precomp.h"
/**************************************************************************
* VOID vMmFastPatRealize
*
* Realizes a pattern into offscreen memory.
*
**************************************************************************/
VOID vMmFastPatRealize(
PDEV* ppdev,
RBRUSH* prb) // Points to brush realization structure
{
BRUSHENTRY* pbe;
LONG iBrushCache;
BYTE* pjPattern;
LONG cjPattern;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
LONG lDeltaPat;
LONG lDeltaSrc;
LONG xCnt;
LONG yCnt;
ULONG ulDst;
DISPDBG((10,"vFastPatRealize called"));
pbe = prb->pbe;
if ((pbe == NULL) || (pbe->prbVerify != prb))
{
// We have to allocate a new offscreen cache brush entry for
// the brush:
iBrushCache = ppdev->iBrushCache;
pbe = &ppdev->abe[iBrushCache];
iBrushCache++;
if (iBrushCache >= ppdev->cBrushCache)
iBrushCache = 0;
ppdev->iBrushCache = iBrushCache;
// Update our links:
pbe->prbVerify = prb;
prb->pbe = pbe;
}
//
// Download brush into cache
//
pjPattern = (PBYTE) &prb->aulPattern[0]; // Copy from brush buffer
cjPattern = PELS_TO_BYTES(TOTAL_BRUSH_SIZE);
lDeltaPat = PELS_TO_BYTES(8);
xCnt = PELS_TO_BYTES(8);
yCnt = 8;
if (ppdev->cBitsPerPixel == 24)
{
lDeltaSrc = 32; // same as PELS_TO_BYTES(8) for 32bpp
}
else
{
lDeltaSrc = lDeltaPat; // PELS_TO_BYTES(8)
}
ulDst = (pbe->y * ppdev->lDelta) + PELS_TO_BYTES(pbe->x);
#if BANKING //bank#1
ppdev->pfnBankMap(ppdev, ppdev->lXferBank);
#endif
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, (lDeltaSrc * 2));
CP_MM_XCNT(ppdev, pjBase, (xCnt - 1));
CP_MM_YCNT(ppdev, pjBase, (yCnt - 1));
#if 1 // D5480
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, CL_PACKED_SRC_COPY | SRC_CPU_DATA);
#else
CP_MM_BLT_MODE(ppdev, pjBase, SRC_CPU_DATA);
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0);
CP_MM_ROP(ppdev, pjBase, CL_SRC_COPY);
#endif // D5480
CP_MM_DST_ADDR_ABS(ppdev, pjBase, ulDst);
CP_MM_START_BLT(ppdev, pjBase);
vImageTransfer(ppdev, pjPattern, lDeltaPat, xCnt, yCnt);
//
// Duplicate brush horizontally
//
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_XCNT(ppdev, pjBase, (xCnt - 1));
CP_MM_YCNT(ppdev, pjBase, (yCnt - 1));
CP_MM_BLT_MODE(ppdev, pjBase, 0);
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, (lDeltaSrc * 2));
CP_MM_SRC_ADDR(ppdev, pjBase, ulDst);
CP_MM_DST_ADDR_ABS(ppdev, pjBase, (ulDst + lDeltaPat));
CP_MM_START_BLT(ppdev, pjBase);
//
// Duplicate brush vertically
//
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, (lDeltaSrc * 2));
CP_MM_DST_Y_OFFSET(ppdev, pjBase, (lDeltaSrc * 2));
CP_MM_BLT_MODE(ppdev, pjBase, 0);
CP_MM_XCNT(ppdev, pjBase, ((lDeltaSrc * 2) - 1));
CP_MM_YCNT(ppdev, pjBase, (yCnt - 1));
CP_MM_SRC_ADDR(ppdev, pjBase, ulDst);
if (ppdev->cBitsPerPixel == 24)
{
CP_MM_DST_ADDR_ABS(ppdev, pjBase, (ulDst + 512)); // 128 * 4
}
else
{
CP_MM_DST_ADDR_ABS(ppdev, pjBase, (ulDst + PELS_TO_BYTES(128)));
}
CP_MM_START_BLT(ppdev, pjBase);
#if 0
{
////////////////////////////////////////////////////////////////
// DEBUG TILED PATTERNS
//
// The following code helps to debug patterns if you break the
// realization code. It copies the 2x2 tiled copy of the brush
// to the visible screen.
//
POINTL ptl;
RECTL rcl;
ptl.x = pbe->x;
ptl.y = pbe->y;
rcl.left = 10;
rcl.right = 10 + 16;
rcl.top = ppdev->cyScreen - 10 - 16;
rcl.bottom = ppdev->cyScreen - 10;
{
LONG lDelta = ppdev->lDelta;
BYTE jHwRop;
BYTE jMode;
//
// Make sure we can write to the video registers.
//
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_ROP(ppdev, pjBase, CL_SRC_COPY);
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, PELS_TO_BYTES(16));
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
{
//
// Top to Bottom - Left to Right
//
jMode |= DIR_TBLR;
CP_MM_BLT_MODE(ppdev, pjBase, ppdev->jModeColor);
{
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_XCNT(ppdev, pjBase, (PELS_TO_BYTES(rcl.right - rcl.left) - 1));
CP_MM_YCNT(ppdev, pjBase, (rcl.bottom - rcl.top - 1));
CP_MM_SRC_ADDR(ppdev, pjBase, (0 + ((ptl.y) * lDelta) + PELS_TO_BYTES(ptl.x)));
CP_MM_DST_ADDR_ABS(ppdev, pjBase, ((rcl.top * lDelta) + PELS_TO_BYTES(rcl.left)));
CP_MM_START_BLT(ppdev, pjBase);
}
}
}
}
#endif
}
/**************************************************************************
* VOID vMmFillPat
*
* This routine uses the pattern hardware to draw a patterned list of
* rectangles.
*
**************************************************************************/
VOID vMmFillPat(
PDEV* ppdev,
LONG c, // Can't be zero
RECTL* prcl, // Array of relative coordinate destination rects
ROP4 rop4, // Obvious?
RBRUSH_COLOR rbc, // Drawing color is rbc.iSolidColor
POINTL* pptlBrush) //
{
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
ULONG ulAlignedPatternOffset = ppdev->ulAlignedPatternOffset;
ULONG ulPatternAddrBase;
BYTE jHwRop;
BYTE jMode;
BRUSHENTRY* pbe; // Pointer to brush entry data, which is used
// for keeping track of the location and status
// of the pattern bits cached in off-screen
// memory
DISPDBG((10,"vFillPat called"));
ASSERTDD(c > 0, "Can't handle zero rectangles");
ASSERTDD(ppdev->cBpp < 4, "vFillPat only works at 8bpp, 16bpp, and 24bpp");
if ((rbc.prb->pbe == NULL) ||
(rbc.prb->pbe->prbVerify != rbc.prb))
{
vMmFastPatRealize(ppdev, rbc.prb);
DISPDBG((5, " -- Brush cache miss, put it at (%d,%d)", rbc.prb->pbe->x, rbc.prb->pbe->y));
}
else
{
DISPDBG((5, " -- Brush cache hit on brush at (%d,%d)", rbc.prb->pbe->x, rbc.prb->pbe->y));
}
pbe = rbc.prb->pbe;
//
// Fill the list of rectangles
//
ulPatternAddrBase = pbe->xy;
jHwRop = gajHwMixFromRop2[(rop4 >> 2) & 0xf];
jMode = ppdev->jModeColor | ENABLE_8x8_PATTERN_COPY;
do {
ULONG offset = 0;
ULONG XOffset, YOffset;
YOffset = ((prcl->top - pptlBrush->y) & 7) << 4;
XOffset = (prcl->left - pptlBrush->x) & 7;
// align the pattern to a new location
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
#if 1 // D5480
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, CL_PACKED_SRC_COPY);
#else
CP_MM_BLT_MODE(ppdev, pjBase, 0);
CP_MM_ROP(ppdev, pjBase, CL_SRC_COPY);
#endif // D5480
if (ppdev->cBitsPerPixel == 24)
{
offset = (YOffset * 4) + (XOffset * 3);
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, 64);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, 32);
}
else
{
offset = PELS_TO_BYTES(YOffset + XOffset);
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, PELS_TO_BYTES(16));
CP_MM_DST_Y_OFFSET(ppdev, pjBase, PELS_TO_BYTES(8));
}
CP_MM_SRC_ADDR(ppdev, pjBase, (ulPatternAddrBase + offset));
CP_MM_XCNT(ppdev, pjBase, (PELS_TO_BYTES(8) - 1));
CP_MM_YCNT(ppdev, pjBase, (8 - 1));
CP_MM_DST_ADDR_ABS(ppdev, pjBase, ulAlignedPatternOffset);
CP_MM_START_BLT(ppdev, pjBase);
// fill using aligned pattern
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_BLT_MODE(ppdev, pjBase, jMode);
CP_MM_ROP(ppdev, pjBase, jHwRop);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_SRC_ADDR(ppdev, pjBase, ulAlignedPatternOffset);
CP_MM_XCNT(ppdev, pjBase, (PELS_TO_BYTES(prcl->right - prcl->left) - 1));
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top - 1));
CP_MM_DST_ADDR(ppdev, pjBase, ((prcl->top * lDelta) + PELS_TO_BYTES(prcl->left)));
CP_MM_START_BLT(ppdev, pjBase);
prcl++;
} while (--c != 0);
}
/**************************************************************************
* VOID vMmFillSolid
*
* Does a solid fill to a list of rectangles.
*
**************************************************************************/
VOID vMmFillSolid(
PDEV* ppdev,
LONG c, // Can't be zero
RECTL* prcl, // Array of relative coordinate destination rects
ROP4 rop4, // Obvious?
RBRUSH_COLOR rbc, // Drawing color is rbc.iSolidColor
POINTL* pptlBrush) // Not used
{
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
LONG cBpp = ppdev->cBpp;
ULONG ulSolidColor;
BYTE jHwRop;
DISPDBG((10,"vFillSolid called"));
ASSERTDD(c > 0, "Can't handle zero rectangles");
ulSolidColor = rbc.iSolidColor;
if (cBpp == 1)
{
ulSolidColor |= ulSolidColor << 8;
ulSolidColor |= ulSolidColor << 16;
}
else if (cBpp == 2)
{
ulSolidColor |= ulSolidColor << 16;
}
jHwRop = gajHwMixFromRop2[(rop4 >> 2) & 0xf];
//
// Make sure we can write to the video registers.
//
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_ROP(ppdev, pjBase, jHwRop);
CP_MM_SRC_ADDR(ppdev, pjBase, ppdev->ulSolidColorOffset);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_BLT_MODE(ppdev, pjBase, ENABLE_COLOR_EXPAND |
ENABLE_8x8_PATTERN_COPY |
ppdev->jModeColor);
CP_MM_FG_COLOR(ppdev, pjBase, ulSolidColor);
if (ppdev->flCaps & CAPS_AUTOSTART)
{
CP_MM_BLT_EXT_MODE(ppdev, pjBase, ENABLE_SOLID_FILL);
}
//
// Fill the list of rectangles
//
while (TRUE)
{
CP_MM_XCNT(ppdev, pjBase, (PELS_TO_BYTES(prcl->right - prcl->left) - 1));
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top - 1));
CP_MM_DST_ADDR(ppdev, pjBase, ((prcl->top * lDelta) + PELS_TO_BYTES(prcl->left)));
CP_MM_START_BLT(ppdev, pjBase);
if (--c == 0)
return;
prcl++;
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
}
}
/**************************************************************************
* VOID vMmCopyBlt
*
* Does a screen-to-screen blt of a list of rectangles.
*
**************************************************************************/
VOID vMmCopyBlt(
PDEV* ppdev,
LONG c, // Can't be zero
RECTL* prcl, // Array of relative coordinates destination rectangles
ROP4 rop4, // Obvious?
POINTL* pptlSrc, // Original unclipped source point
RECTL* prclDst) // Original unclipped destination rectangle
{
LONG dx;
LONG dy; // Add delta to destination to get source
LONG xyOffset = ppdev->xyOffset;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
BYTE jHwRop;
DISPDBG((10,"vCopyBlt called"));
ASSERTDD(c > 0, "Can't handle zero rectangles");
//
// The src-dst delta will be the same for all rectangles
//
dx = pptlSrc->x - prclDst->left;
dy = pptlSrc->y - prclDst->top;
//
// Make sure we can write to the video registers.
//
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
jHwRop = gajHwMixFromRop2[rop4 & 0xf];
CP_MM_ROP(ppdev, pjBase, jHwRop);
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
//
// The accelerator may not be as fast at doing right-to-left copies, so
// only do them when the rectangles truly overlap:
//
if (!OVERLAP(prclDst, pptlSrc) ||
(prclDst->top < pptlSrc->y) ||
((prclDst->top == pptlSrc->y) && (prclDst->left <= pptlSrc->x))
)
{
//
// Top to Bottom - Left to Right
//
DISPDBG((12,"Top to Bottom - Left to Right"));
CP_MM_BLT_MODE(ppdev, pjBase, DIR_TBLR);
while (TRUE)
{
CP_MM_XCNT(ppdev, pjBase, (PELS_TO_BYTES(prcl->right - prcl->left) - 1));
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top - 1));
CP_MM_SRC_ADDR(ppdev, pjBase, (xyOffset + ((prcl->top + dy) * lDelta) + PELS_TO_BYTES(prcl->left + dx)));
CP_MM_DST_ADDR(ppdev, pjBase, ((prcl->top * lDelta) + PELS_TO_BYTES(prcl->left)));
CP_MM_START_BLT(ppdev, pjBase);
if (--c == 0)
return;
prcl++;
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
}
}
else
{
//
// Bottom to Top - Right to Left
//
DISPDBG((12,"Bottom to Top - Right to Left"));
CP_MM_BLT_MODE(ppdev, pjBase, DIR_BTRL);
while (TRUE)
{
CP_MM_XCNT(ppdev, pjBase, (PELS_TO_BYTES(prcl->right - prcl->left) - 1));
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top - 1));
CP_MM_SRC_ADDR(ppdev, pjBase, (xyOffset + ((prcl->bottom - 1 + dy) * lDelta) + PELS_TO_BYTES(prcl->right + dx) - 1));
CP_MM_DST_ADDR(ppdev, pjBase, (((prcl->bottom - 1) * lDelta) + PELS_TO_BYTES(prcl->right) - 1));
CP_MM_START_BLT(ppdev, pjBase);
if (--c == 0)
return;
prcl++;
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
}
}
}
/******************************Public*Routine******************************\
* VOID vMmXfer1bpp
*
* Low-level routine used to transfer monochrome data to the screen using
* DWORD writes to the blt engine.
*
* This can handle opaque or transparent expansions. It does opaque
* expansions by drawing the opaque rectangle first and then transparently
* expands the foreground bits.
*
\**************************************************************************/
VOID vMmXfer1bpp(
PDEV* ppdev,
LONG c, // Count of rectangles, can't be zero
RECTL* prcl, // List of destination rectangles, in relative
// coordinates
ROP4 rop4, // Actually had better be a rop3
SURFOBJ* psoSrc, // Source surface
POINTL* pptlSrc, // Original unclipped source point
RECTL* prclDst, // Original unclipped destination rectangle
XLATEOBJ* pxlo) // Translate that provides color-expansion information
{
ULONG* pulXfer;
ULONG* pul;
LONG ix;
LONG iy;
LONG cxWidthInBytes;
BYTE* pjBits;
POINTL ptlDst;
POINTL ptlSrc;
SIZEL sizlDst;
LONG cxLeftMask;
LONG cxRightMask;
ULONG ulDstAddr;
INT nDwords;
ULONG ulLeftMask;
ULONG ulRightMask;
LONG dx;
LONG dy;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
LONG lDeltaSrc = psoSrc->lDelta;
LONG cBpp = ppdev->cBpp;
ULONG ulFgColor = pxlo->pulXlate[1];
ULONG ulBgColor = pxlo->pulXlate[0];
// Since the hardware clipping on some of the Cirrus chips is broken, we
// do the clipping by rounding out the edges to dword boundaries and then
// doing the blt transparently. In the event that we want the expansion
// to be opaque, we do the opaquing blt in advance. One side effect of
// this is that the destination bits are no longer valid for processing
// the rop. This could probably be optimized by doing the edges seperately
// and then doing the middle section in one pass. However, this is
// complicated by a 5434 bug that breaks blts less than 10 pixels wide.
ASSERTDD(c > 0, "Can't handle zero rectangles");
ASSERTDD(((rop4 & 0xff00) == 0xcc00), "Expected foreground rop of 0xcc");
//
// The src-dst delta will be the same for all rectangles
//
dx = pptlSrc->x - prclDst->left;
dy = pptlSrc->y - prclDst->top;
if (cBpp == 1)
{
ulFgColor = (ulFgColor << 8) | (ulFgColor & 0xff);
ulBgColor = (ulBgColor << 8) | (ulBgColor & 0xff);
ulFgColor = (ulFgColor << 16) | (ulFgColor & 0xffff);
ulBgColor = (ulBgColor << 16) | (ulBgColor & 0xffff);
}
else if (cBpp == 2)
{
ulFgColor = (ulFgColor << 16) | (ulFgColor & 0xffff);
ulBgColor = (ulBgColor << 16) | (ulBgColor & 0xffff);
}
pulXfer = ppdev->pulXfer;
#if BANKING //bank#1
ppdev->pfnBankMap(ppdev, ppdev->lXferBank);
#endif
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
if (rop4 != 0xCCAA)
{
LONG lCnt = c;
RECTL* prclTmp = prcl;
BYTE jHwBgRop = gajHwMixFromRop2[rop4 & 0xf];
CP_MM_ROP(ppdev, pjBase, jHwBgRop);
CP_MM_FG_COLOR(ppdev, pjBase, ulBgColor);
CP_MM_SRC_ADDR(ppdev, pjBase, ppdev->ulSolidColorOffset);
CP_MM_BLT_MODE(ppdev, pjBase, ppdev->jModeColor |
ENABLE_COLOR_EXPAND |
ENABLE_8x8_PATTERN_COPY);
do
{
// calculate the size of the blt
ptlDst.x = prclTmp->left;
ptlDst.y = prclTmp->top;
sizlDst.cx = prclTmp->right - ptlDst.x;
sizlDst.cy = prclTmp->bottom - ptlDst.y;
//
// Fill the background rectangle with the background color
//
// Set the dest addresses
ulDstAddr = (ptlDst.y * lDelta) + PELS_TO_BYTES(ptlDst.x);
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_XCNT(ppdev, pjBase, PELS_TO_BYTES(sizlDst.cx) - 1);
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy - 1);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstAddr);
// Start the blt operation
CP_MM_START_BLT(ppdev, pjBase);
prclTmp++;
} while (--lCnt != 0);
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
}
CP_MM_FG_COLOR(ppdev, pjBase, ulFgColor);
CP_MM_BG_COLOR(ppdev, pjBase, ~ulFgColor);
CP_IO_XPAR_COLOR(ppdev, pjBase, ~ulFgColor);
CP_MM_ROP(ppdev, pjBase, CL_SRC_COPY);
CP_MM_BLT_MODE(ppdev, pjBase, ppdev->jModeColor |
ENABLE_COLOR_EXPAND |
ENABLE_TRANSPARENCY_COMPARE |
SRC_CPU_DATA);
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0); // jl01
do
{
// calculate the size of the blt
ptlDst.x = prcl->left;
ptlDst.y = prcl->top;
sizlDst.cx = prcl->right - ptlDst.x;
sizlDst.cy = prcl->bottom - ptlDst.y;
// calculate the number of dwords per scan line
ptlSrc.x = prcl->left + dx;
ptlSrc.y = prcl->top + dy;
// Floor the source.
// Extend the width by the amount required to floor to a dword boundary.
// Set the size of the left mask.
// Floor the dest, so it aligns with the floored source.
if ((cxLeftMask = (ptlSrc.x & 31)))
{
sizlDst.cx += cxLeftMask;
ptlSrc.x &= ~31;
ptlDst.x -= cxLeftMask;
}
ulLeftMask = gaulLeftClipMask[cxLeftMask];
// Ceil the cx to a dword boundary.
if (cxRightMask = (sizlDst.cx & 31))
{
cxRightMask = 32 - cxRightMask;
sizlDst.cx = (sizlDst.cx + 31) & ~31;
}
ulRightMask = gaulRightClipMask[cxRightMask];
if (sizlDst.cx == 32)
{
ulLeftMask &= ulRightMask;
ulRightMask = 0;
}
// Note: At this point sizlDst.cx is the width of the blt in pixels,
// floored to a dword boundary, and ceiled to a dword boundary.
// Calculate the width in Bytes
cxWidthInBytes = sizlDst.cx >> 3;
// Calculate the number of Dwords and any remaining bytes
nDwords = cxWidthInBytes >> 2;
ASSERTDD(((cxWidthInBytes & 0x03) == 0),
"cxWidthInBytes is not a DWORD multiple");
// Calculate the address of the source bitmap
// This is to a byte boundary.
pjBits = (PBYTE) psoSrc->pvScan0;
pjBits += ptlSrc.y * lDeltaSrc;
pjBits += ptlSrc.x >> 3;
ASSERTDD((((ULONG_PTR)pjBits & 0x03) == 0),
"pjBits not DWORD aligned like it should be");
//
// Blt the 1 bpp bitmap
//
ulDstAddr = (ptlDst.y * lDelta) + PELS_TO_BYTES(ptlDst.x);
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
//
// Tell the hardware that we want to write (sizlDst.cx) X amd (sizlDst.cy) Y bytes
//
CP_MM_XCNT(ppdev, pjBase, PELS_TO_BYTES(sizlDst.cx) - 1);
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy - 1);
//
// The 542x chips require a write to the Src Address Register when
// doing a host transfer with color expansion. The value is
// irrelevant, but the write is crucial. This is documented in
// the manual, not the errata. Go figure.
//
CP_MM_SRC_ADDR(ppdev, pjBase, 0);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstAddr);
CP_MM_START_BLT(ppdev, pjBase);
//
// Transfer the host bitmap.
//
if (ulRightMask)
{
//
// Blt is > 1 DWORD wide (nDwords > 1)
//
for (iy = 0; iy < sizlDst.cy; iy++)
{
pul = (ULONG*) pjBits;
//*pulXfer++ = *(((ULONG*)pul)++) & ulLeftMask;
WRITE_REGISTER_ULONG(pulXfer, (*((ULONG*)pul) & ulLeftMask));
pul++;
for (ix = 0; ix < (nDwords-2); ix++)
{
//*pulXfer++ = *(((ULONG*)pul)++);
WRITE_REGISTER_ULONG(pulXfer, (*((ULONG*)pul)));
pul++;
}
//*pulXfer++ = *(((ULONG*)pul)++) & ulRightMask;
WRITE_REGISTER_ULONG(pulXfer, (*((ULONG*)pul) & ulRightMask));
pul++;
pjBits += lDeltaSrc;
//pulXfer = ppdev->pulXfer;
CP_MEMORY_BARRIER(); // Flush memory cache when we reset the address
}
}
else
{
//
// Blt is 1 DWORD wide (nDwords == 1)
//
for (iy = 0; iy < sizlDst.cy; iy++)
{
//*pulXfer = *((ULONG*)pjBits) & ulLeftMask;
WRITE_REGISTER_ULONG(pulXfer, (*((ULONG*)pjBits) & ulLeftMask));
pjBits += lDeltaSrc;
CP_MEMORY_BARRIER(); // Flush memory cache
}
}
prcl++;
} while (--c != 0);
}
/******************************Public*Routine******************************\
* VOID vMmXfer4bpp
*
* Does a 4bpp transfer from a bitmap to the screen.
*
* NOTE: The screen must be 8bpp for this function to be called!
*
* The reason we implement this is that a lot of resources are kept as 4bpp,
* and used to initialize DFBs, some of which we of course keep off-screen.
*
\**************************************************************************/
// XLATE_BUFFER_SIZE defines the size of the stack-based buffer we use
// for doing the translate. Note that in general stack buffers should
// be kept as small as possible. The OS guarantees us only 8k for stack
// from GDI down to the display driver in low memory situations; if we
// ask for more, we'll access violate. Note also that at any time the
// stack buffer cannot be larger than a page (4k) -- otherwise we may
// miss touching the 'guard page' and access violate then too.
#define XLATE_BUFFER_SIZE 256
VOID vMmXfer4bpp(
PDEV* ppdev,
LONG c, // Count of rectangles, can't be zero
RECTL* prcl, // List of destination rectangles, in relative coordinates
ULONG rop4, // rop4
SURFOBJ* psoSrc, // Source surface
POINTL* pptlSrc, // Original unclipped source point
RECTL* prclDst, // Original unclipped destination rectangle
XLATEOBJ* pxlo) // Translate that provides colour-expansion information
{
ULONG ulDstAddr;
LONG dx;
LONG dy;
LONG cx;
LONG cy;
LONG lSrcDelta;
BYTE* pjSrcScan0;
BYTE* pjScan;
BYTE* pjSrc;
BYTE* pjDst;
LONG cxThis;
LONG cxToGo;
LONG xSrc;
LONG iLoop;
BYTE jSrc;
ULONG* pulXlate;
LONG cdwThis;
BYTE* pjBuf;
BYTE ajBuf[XLATE_BUFFER_SIZE];
ULONG* pulXfer = ppdev->pulXfer;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
ASSERTDD(ppdev->iBitmapFormat == BMF_8BPP, "Screen must be 8bpp");
ASSERTDD(psoSrc->iBitmapFormat == BMF_4BPP, "Source must be 4bpp");
ASSERTDD(c > 0, "Can't handle zero rectangles");
ASSERTDD(((rop4 & 0xff00) >> 8) == (rop4 & 0xff),
"Expect only a rop2");
DISPDBG((5, "vXfer4bpp: entry"));
dx = pptlSrc->x - prclDst->left;
dy = pptlSrc->y - prclDst->top; // Add to destination to get source
lSrcDelta = psoSrc->lDelta;
pjSrcScan0 = psoSrc->pvScan0;
#if BANKING //bank#1
ppdev->pfnBankMap(ppdev, ppdev->lXferBank);
#endif
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
#if 1 // D5480
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, gajHwPackedMixFromRop2[rop4 & 0xf] | SRC_CPU_DATA);
#else
CP_MM_ROP(ppdev, pjBase, gajHwMixFromRop2[rop4 & 0xf]);
CP_MM_BLT_MODE(ppdev, pjBase, SRC_CPU_DATA);
#endif
while(TRUE)
{
ulDstAddr = (prcl->top * lDelta) + PELS_TO_BYTES(prcl->left);
cx = prcl->right - prcl->left;
cy = prcl->bottom - prcl->top;
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_XCNT(ppdev, pjBase, PELS_TO_BYTES(cx) - 1);
CP_MM_YCNT(ppdev, pjBase, cy - 1);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstAddr);
pulXlate = pxlo->pulXlate;
xSrc = prcl->left + dx;
pjScan = pjSrcScan0 + (prcl->top + dy) * lSrcDelta + (xSrc >> 1);
CP_MM_START_BLT(ppdev, pjBase);
do {
pjSrc = pjScan;
cxToGo = cx; // # of pels per scan in 4bpp source
do {
cxThis = XLATE_BUFFER_SIZE;
// We can handle XLATE_BUFFER_SIZE number
// of pels in this xlate batch
cxToGo -= cxThis; // cxThis will be the actual number of
// pels we'll do in this xlate batch
if (cxToGo < 0)
cxThis += cxToGo;
pjDst = ajBuf; // Points to our temporary batch buffer
// We handle alignment ourselves because it's easy to
// do, rather than pay the cost of setting/resetting
// the scissors register:
if (xSrc & 1)
{
// When unaligned, we have to be careful not to read
// past the end of the 4bpp bitmap (that could
// potentially cause us to access violate):
iLoop = cxThis >> 1; // Each loop handles 2 pels;
// we'll handle odd pel
// separately
jSrc = *pjSrc;
while (iLoop-- != 0)
{
*pjDst++ = (BYTE) pulXlate[jSrc & 0xf];
jSrc = *(++pjSrc);
*pjDst++ = (BYTE) pulXlate[jSrc >> 4];
}
if (cxThis & 1)
*pjDst = (BYTE) pulXlate[jSrc & 0xf];
}
else
{
iLoop = (cxThis + 1) >> 1; // Each loop handles 2 pels
do {
jSrc = *pjSrc++;
*pjDst++ = (BYTE) pulXlate[jSrc >> 4];
*pjDst++ = (BYTE) pulXlate[jSrc & 0xf];
} while (--iLoop != 0);
}
// The number of bytes we'll transfer is equal to the number
// of pels we've processed in the batch. Since we're
// transferring words, we have to round up to get the word
// count:
cdwThis = (cxThis + 3) >> 2;
pjBuf = ajBuf;
TRANSFER_DWORD_ALIGNED(ppdev, pulXfer, pjBuf, cdwThis);
} while (cxToGo > 0);
pjScan += lSrcDelta; // Advance to next source scan. Note
// that we could have computed the
// value to advance 'pjSrc' directly,
// but this method is less
// error-prone.
} while (--cy != 0);
if (--c == 0)
return;
prcl++;
}
}
/******************************Public*Routine******************************\
* VOID vMmXferNative
*
* Transfers a bitmap that is the same color depth as the display to
* the screen via the data transfer register, with no translation.
*
\**************************************************************************/
VOID vMmXferNative(
PDEV* ppdev,
LONG c, // Count of rectangles, can't be zero
RECTL* prcl, // Array of relative coordinates destination rectangles
ULONG rop4, // rop4
SURFOBJ* psoSrc, // Source surface
POINTL* pptlSrc, // Original unclipped source point
RECTL* prclDst, // Original unclipped destination rectangle
XLATEOBJ* pxlo) // Not used
{
ULONG ulDstAddr;
LONG dx;
LONG dy;
LONG cx;
LONG cy;
LONG lSrcDelta;
BYTE* pjSrcScan0;
BYTE* pjSrc;
LONG cjSrc;
ULONG* pulXfer = ppdev->pulXfer;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
ASSERTDD((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL),
"Can handle trivial xlate only");
ASSERTDD(psoSrc->iBitmapFormat == ppdev->iBitmapFormat,
"Source must be same color depth as screen");
ASSERTDD(c > 0, "Can't handle zero rectangles");
ASSERTDD(((rop4 & 0xff00) >> 8) == (rop4 & 0xff),
"Expect only a rop2");
dx = pptlSrc->x - prclDst->left;
dy = pptlSrc->y - prclDst->top; // Add to destination to get source
lSrcDelta = psoSrc->lDelta;
pjSrcScan0 = psoSrc->pvScan0;
#if BANKING //bank#1
ppdev->pfnBankMap(ppdev, ppdev->lXferBank);
#endif
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
#if 1 // D5480
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, gajHwPackedMixFromRop2[rop4 & 0xf] | SRC_CPU_DATA);
#else
CP_MM_ROP(ppdev, pjBase, gajHwMixFromRop2[rop4 & 0xf]);
CP_MM_BLT_MODE(ppdev, pjBase, SRC_CPU_DATA);
#endif
while(TRUE)
{
ulDstAddr = (prcl->top * lDelta) + PELS_TO_BYTES(prcl->left);
cx = prcl->right - prcl->left;
cy = prcl->bottom - prcl->top;
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_XCNT(ppdev, pjBase, PELS_TO_BYTES(cx) - 1);
CP_MM_YCNT(ppdev, pjBase, cy - 1);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstAddr);
cjSrc = PELS_TO_BYTES(cx);
pjSrc = pjSrcScan0 + (prcl->top + dy) * lSrcDelta
+ (PELS_TO_BYTES(prcl->left + dx));
CP_MM_START_BLT(ppdev, pjBase);
vImageTransfer(ppdev, pjSrc, lSrcDelta, cjSrc, cy);
if (--c == 0)
return;
prcl++;
}
}
////////////////////////////////////////////////////////////////////////////////
// //
// N E W B L T R O U T I N E S F O R B R U S H C A C H E //
// //
////////////////////////////////////////////////////////////////////////////////
VOID vMmFillSolid36(
PDEV* ppdev,
LONG c,
RECTL* prcl,
ROP4 rop4,
RBRUSH_COLOR rbc,
POINTL* pptlBrush)
{
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
BYTE jHwRop = gajHwMixFromRop2[(rop4 >> 2) & 0x0F];
BYTE jMode = ppdev->jModeColor
| ENABLE_8x8_PATTERN_COPY
| ENABLE_COLOR_EXPAND;
while (c-- > 0)
{
ULONG ulDstOffset;
SIZEL sizlDst;
// Calculate the destination address and size.
ulDstOffset = (prcl->top * lDelta) + PELS_TO_BYTES(prcl->left);
sizlDst.cx = PELS_TO_BYTES(prcl->right - prcl->left) - 1;
sizlDst.cy = (prcl->bottom - prcl->top) - 1;
// Wait for the bitblt engine.
WAIT_BUSY_BLT(ppdev, pjBase);
// Setup the bitblt registers.
CP_MM_FG_COLOR(ppdev, pjBase, rbc.iSolidColor);
CP_MM_XCNT(ppdev, pjBase, sizlDst.cx);
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_DST_WRITE_MASK(ppdev, pjBase, 0); // Disable clipping.
CP_MM_BLT_MODE(ppdev, pjBase, jMode);
CP_MM_ROP(ppdev, pjBase, jHwRop);
CP_MM_BLT_EXT_MODE(ppdev, pjBase, ENABLE_SOLID_FILL);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
// Next rectangle.
prcl++;
}
}
VOID vMmFillPat36(
PDEV* ppdev,
LONG c,
RECTL* prcl,
ROP4 rop4,
RBRUSH_COLOR rbc,
POINTL* pptlBrush)
{
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
BYTE jHwRop = gajHwMixFromRop2[(rop4 >> 2) & 0x0F];
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0) ; // chu01
// Dithered brush...
if (rbc.prb->fl == RBRUSH_DITHER)
{
DITHERCACHE* pdc;
pdc = (DITHERCACHE*) ((ULONG_PTR)ppdev + rbc.prb->ulSlot);
if (pdc->ulColor != rbc.prb->ulUniq)
{
// Cache entry is invalid, realize the brush again.
bCacheDither(ppdev, rbc.prb);
}
while (c-- > 0)
{
ULONG ulDstOffset, ulSrcOffset;
SIZEL sizlDst;
LONG xOffset, yOffset;
LONG x;
// Calculate the brush rotation.
xOffset = (prcl->left - pptlBrush->x) & 7;
yOffset = (prcl->top - pptlBrush->y) & 7;
ulSrcOffset = rbc.prb->ulBrush | yOffset;
// Calculate the destination and size.
x = prcl->left - xOffset;
ulDstOffset = (prcl->top * lDelta) + x;
sizlDst.cx = (prcl->right - x) - 1;
sizlDst.cy = (prcl->bottom - prcl->top) - 1;
// Wait for the bitblt engine.
WAIT_BUSY_BLT(ppdev, pjBase);
// Setup the bitblt registers.
CP_MM_XCNT(ppdev, pjBase, sizlDst.cx);
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
CP_MM_DST_WRITE_MASK(ppdev, pjBase, xOffset);
CP_MM_BLT_MODE(ppdev, pjBase, ENABLE_8x8_PATTERN_COPY);
CP_MM_ROP(ppdev, pjBase, jHwRop);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
// Next rectangle.
prcl++;
}
}
// Monochrome brush...
else if (rbc.prb->fl == RBRUSH_MONOCHROME)
{
MONOCACHE* pmc;
BYTE jMode;
ULONG ulBgColor, ulFgColor;
pmc = (MONOCACHE*) ((ULONG_PTR)ppdev + rbc.prb->ulSlot);
if (pmc->ulUniq != rbc.prb->ulUniq)
{
// Cache entry is invalid, realize the brush again.
bCacheMonochrome(ppdev, rbc.prb);
}
// Setup the common parameters.
jMode = ppdev->jModeColor
| ENABLE_8x8_PATTERN_COPY
| ENABLE_COLOR_EXPAND;
ulBgColor = rbc.prb->ulBackColor;
ulFgColor = rbc.prb->ulForeColor;
// Monochrome brushes in 24-bpp are already cached expanded.
if (ppdev->cBpp == 3)
{
jMode = ppdev->jModeColor
| ENABLE_8x8_PATTERN_COPY;
}
// Walk through all rectangles.
while (c-- > 0)
{
ULONG ulDstOffset, ulSrcOffset;
SIZEL sizlDst;
LONG xOffset, yOffset;
LONG x;
// Calculate the brush rotation.
xOffset = (prcl->left - pptlBrush->x) & 7;
yOffset = (prcl->top - pptlBrush->y) & 7;
ulSrcOffset = rbc.prb->ulBrush | yOffset;
// Calculate the destination and size.
x = prcl->left - xOffset;
ulDstOffset = (prcl->top * lDelta) + PELS_TO_BYTES(x);
sizlDst.cx = PELS_TO_BYTES(prcl->right - x) - 1;
sizlDst.cy = (prcl->bottom - prcl->top) - 1;
if (ppdev->cBpp == 3)
{
xOffset *= 3;
}
// Wait for the bitblt engine.
WAIT_BUSY_BLT(ppdev, pjBase);
// Setup the bitblt registers.
CP_MM_BG_COLOR(ppdev, pjBase, ulBgColor);
CP_MM_FG_COLOR(ppdev, pjBase, ulFgColor);
CP_MM_XCNT(ppdev, pjBase, sizlDst.cx);
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
CP_MM_DST_WRITE_MASK(ppdev, pjBase, xOffset);
CP_MM_BLT_MODE(ppdev, pjBase, jMode);
CP_MM_ROP(ppdev, pjBase, jHwRop);
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
// Next rectangle.
prcl++;
}
}
// Patterned brush...
else if (ppdev->flStatus & STAT_PATTERN_CACHE)
{
PATTERNCACHE* ppc;
BYTE jMode = ppdev->jModeColor
| ENABLE_8x8_PATTERN_COPY;
ppc = (PATTERNCACHE*) ((ULONG_PTR)ppdev + rbc.prb->ulSlot);
if (ppc->prbUniq != rbc.prb)
{
// Cache entry is invalid, realize the brush again.
bCachePattern(ppdev, rbc.prb);
}
while (c-- > 0)
{
ULONG ulDstOffset, ulSrcOffset;
SIZEL sizlDst;
LONG xOffset, yOffset;
LONG x;
// Calculate the brush rotation.
xOffset = (prcl->left - pptlBrush->x) & 7;
yOffset = (prcl->top - pptlBrush->y) & 7;
ulSrcOffset = rbc.prb->ulBrush | yOffset;
// Calculate the destination and size.
x = prcl->left - xOffset;
ulDstOffset = (prcl->top * lDelta) + PELS_TO_BYTES(x);
sizlDst.cx = PELS_TO_BYTES(prcl->right - x) - 1;
sizlDst.cy = (prcl->bottom - prcl->top) - 1;
if (ppdev->cBpp == 3)
{
xOffset *= 3;
}
// Wait for the bitblt engine.
WAIT_BUSY_BLT(ppdev, pjBase);
// Setup the bitblt registers.
CP_MM_XCNT(ppdev, pjBase, sizlDst.cx);
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
CP_MM_DST_WRITE_MASK(ppdev, pjBase, xOffset);
CP_MM_BLT_MODE(ppdev, pjBase, jMode);
CP_MM_ROP(ppdev, pjBase, jHwRop);
CP_MM_BLT_EXT_MODE(ppdev, pjBase, 0);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
// Next rectangle.
prcl++;
}
}
// Old-style brush cache.
else
{
vMmFillPat(ppdev, c, prcl, rop4, rbc, pptlBrush);
}
}
VOID vMmCopyBlt36(
PDEV* ppdev,
LONG c,
RECTL* prcl,
ROP4 rop4,
POINTL* pptlSrc,
RECTL* prclDst)
{
LONG xy;
LONG cx, cy;
ULONG ulSrc, ulDst;
BYTE jHwRop = gajHwMixFromRop2[rop4 & 0x0F];
LONG xyOffset = ppdev->xyOffset;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
DISPDBG((10, "vMmCopyBlt36 called"));
// The src-dst delta will be the same for all rectangles.
xy = ((pptlSrc->y - prclDst->top) * lDelta)
+ PELS_TO_BYTES(pptlSrc->x - prclDst->left);
// Determine the direction of the blit.
if ((xy >= 0) || !OVERLAP(prclDst, pptlSrc))
{
DISPDBG((12, "Top to Bottom - Left to Right"));
while (c-- > 0)
{
// Calculate the blit size and offsets.
cx = PELS_TO_BYTES(prcl->right - prcl->left) - 1;
cy = (prcl->bottom - prcl->top) - 1;
ulDst = xyOffset + (prcl->top * lDelta) + PELS_TO_BYTES(prcl->left);
ulSrc = ulDst + xy;
// Wait for the bitblt engine.
WAIT_BUSY_BLT(ppdev, pjBase);
// Perform the move.
CP_MM_XCNT(ppdev, pjBase, cx);
CP_MM_YCNT(ppdev, pjBase, cy);
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrc);
CP_MM_BLT_MODE(ppdev, pjBase, DIR_TBLR);
CP_MM_ROP(ppdev, pjBase, jHwRop);
CP_MM_DST_ADDR_ABS(ppdev, pjBase, ulDst);
// Next rectangle.
prcl++;
}
}
else
{
DISPDBG((12, "Bottom to Top - Right to Left"));
while (c-- > 0)
{
// Calculate the blit size and offsets.
cx = PELS_TO_BYTES(prcl->right - prcl->left) - 1;
cy = (prcl->bottom - prcl->top) - 1;
ulDst = xyOffset + ((prcl->bottom - 1) * lDelta)
+ (PELS_TO_BYTES(prcl->right) - 1);
ulSrc = ulDst + xy;
// Wait for the bitblt engine.
WAIT_BUSY_BLT(ppdev, pjBase);
// Perform the move.
CP_MM_XCNT(ppdev, pjBase, cx);
CP_MM_YCNT(ppdev, pjBase, cy);
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrc);
CP_MM_BLT_MODE(ppdev, pjBase, DIR_BTRL);
CP_MM_ROP(ppdev, pjBase, jHwRop);
CP_MM_DST_ADDR_ABS(ppdev, pjBase, ulDst);
// Next rectangle.
prcl++;
}
}
}
#if 1 // D5480
VOID vMmFillSolid80(
PDEV* ppdev,
LONG c,
RECTL* prcl,
ROP4 rop4,
RBRUSH_COLOR rbc,
POINTL* pptlBrush)
{
ULONG_PTR* ulCLStart;
ULONG ulWidthHeight;
ULONG xCLOffset;
ULONG ulDstOffset = 0;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
DWORD jHwRop = gajHwPackedMixFromRop2[(rop4 >> 2) & 0x0F];
DWORD jExtMode = ENABLE_SOLID_FILL_PACKED
| ENABLE_XY_POSITION_PACKED
| ppdev->jModeColor
| ENABLE_8x8_PATTERN_COPY
| ENABLE_COLOR_EXPAND;
//
// Make sure we can write to the video registers.
//
// We need to change to wait for buffer ready
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
// Setup the bitblt registers.
CP_MM_FG_COLOR(ppdev, pjBase, rbc.iSolidColor);
// Do we really need to set it every time?
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
// Do we need to clear Source XY?
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
CP_MM_DST_WRITE_MASK(ppdev, pjBase, 0); // Disable clipping.
// Setup first set registers
xCLOffset = prcl->left;
CP_MM_DST_Y(ppdev, pjBase, prcl->top);
CP_MM_XCNT(ppdev, pjBase, (prcl->right - prcl->left) - 1);
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top) - 1);
if (--c)
{
// There are more than one rectangle
prcl++;
jExtMode |= ENABLE_COMMAND_LIST_PACKED;
ulCLStart = ppdev->pCommandList;
ulDstOffset |= ((ULONG)((ULONG_PTR)ulCLStart
- (ULONG_PTR)ppdev->pjScreen) << 14);
CP_MM_CL_SWITCH(ppdev);
while (TRUE)
{
// Command List
// Calculate the destination address and size.
ulWidthHeight = PACKXY_FAST((prcl->right - prcl->left) - 1,
(prcl->bottom - prcl->top) - 1);
ulWidthHeight |= COMMAND_NOSRC_NOTHING;
// XY
*(ulCLStart + 1) = PACKXY_FAST(prcl->left, prcl->top);
// Source Start address
*(ulCLStart + 2) = 0;
if (c == 1)
{
ulWidthHeight |= COMMAND_LAST_PACKET;
*ulCLStart = ulWidthHeight;
// Last Command
break;
}
*ulCLStart = ulWidthHeight;
// Next rectangle.
prcl++;
c--;
ulCLStart += 4;
}
}
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode | jHwRop );
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
CP_MM_DST_X(ppdev, pjBase, xCLOffset);
}
VOID vMmFillPat80(
PDEV* ppdev,
LONG c,
RECTL* prcl,
ROP4 rop4,
RBRUSH_COLOR rbc,
POINTL* pptlBrush)
{
ULONG xOffset, yOffset;
ULONG ulSrcOffset;
ULONG_PTR* ulCLStart;
ULONG ulWidthHeight;
ULONG xCLOffset;
ULONG ulDstOffset = 0;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
DWORD jHwRop = gajHwPackedMixFromRop2[(rop4 >> 2) & 0x0F];
DWORD jExtMode = ENABLE_XY_POSITION_PACKED
| ENABLE_8x8_PATTERN_COPY;
// Dithered brush...
if (rbc.prb->fl == RBRUSH_DITHER)
{
DITHERCACHE* pdc;
pdc = (DITHERCACHE*) ((ULONG_PTR)ppdev + rbc.prb->ulSlot);
if (pdc->ulColor != rbc.prb->ulUniq)
{
// Cache entry is invalid, realize the brush again.
bCacheDither(ppdev, rbc.prb);
}
// Calculate the brush rotation.
xOffset = (prcl->left - pptlBrush->x) & 7;
yOffset = (prcl->top - pptlBrush->y) & 7;
ulSrcOffset = rbc.prb->ulBrush | yOffset | (xOffset << 24);
// Calculate the destination and size.
xCLOffset = prcl->left - xOffset;
//
// Make sure we can write to the video registers.
//
// We need to change to wait for buffer ready
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
// Do we really need to set it every time?
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
// Do we need to clear Source XY?
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
// Setup first set registers
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
CP_MM_DST_Y(ppdev, pjBase, prcl->top);
CP_MM_XCNT(ppdev, pjBase, (prcl->right - xCLOffset) - 1);
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top) - 1);
if (--c)
{
// There are more than one rectangle
prcl++;
jExtMode |= ENABLE_COMMAND_LIST_PACKED;
ulCLStart = ppdev->pCommandList;
ulDstOffset |= ((ULONG)((ULONG_PTR)ulCLStart
- (ULONG_PTR)ppdev->pjScreen) << 14);
CP_MM_CL_SWITCH(ppdev);
while (TRUE)
{
// Command List
// Calculate the brush rotation.
xOffset = (prcl->left - pptlBrush->x) & 7;
yOffset = (prcl->top - pptlBrush->y) & 7;
// Calculate the destination address and size.
ulWidthHeight = PACKXY_FAST((prcl->right - prcl->left + xOffset ) - 1,
(prcl->bottom - prcl->top) - 1);
ulWidthHeight |= COMMAND_FOURTH_NOTHING;
// XY
*(ulCLStart + 1) = PACKXY_FAST(prcl->left - xOffset, prcl->top);
// Source Start address
*(ulCLStart + 2) = rbc.prb->ulBrush | yOffset | (xOffset << 24);
if (c == 1)
{
ulWidthHeight |= COMMAND_LAST_PACKET;
*ulCLStart = ulWidthHeight;
// Last Command
break;
}
*ulCLStart = ulWidthHeight;
// Next rectangle.
prcl++;
c--;
ulCLStart += 4;
}
}
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode | jHwRop );
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
CP_MM_DST_X(ppdev, pjBase, xCLOffset);
}
// Monochrome brush...
else if (rbc.prb->fl == RBRUSH_MONOCHROME)
{
MONOCACHE* pmc;
BYTE jMode;
ULONG ulBgColor, ulFgColor;
pmc = (MONOCACHE*) ((ULONG_PTR) ppdev + rbc.prb->ulSlot);
if (pmc->ulUniq != rbc.prb->ulUniq)
{
// Cache entry is invalid, realize the brush again.
bCacheMonochrome(ppdev, rbc.prb);
}
ulBgColor = rbc.prb->ulBackColor;
ulFgColor = rbc.prb->ulForeColor;
// Calculate the brush rotation.
xOffset = (prcl->left - pptlBrush->x) & 7;
yOffset = (prcl->top - pptlBrush->y) & 7;
// Monochrome brushes in 24-bpp are already cached expanded.
if (ppdev->cBpp == 3)
{
jExtMode |= ppdev->jModeColor;
ulSrcOffset = rbc.prb->ulBrush | yOffset | ((xOffset * 3) << 24);
}
else
{
jExtMode |= (ppdev->jModeColor | ENABLE_COLOR_EXPAND);
ulSrcOffset = rbc.prb->ulBrush | yOffset | (xOffset << 24);
}
// Calculate the destination and size.
xCLOffset = prcl->left - xOffset;
//
// Make sure we can write to the video registers.
//
// We need to change to wait for buffer ready
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
// Do we really need to set it every time?
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
// Do we need to clear Source XY?
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
// Setup first set registers
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
CP_MM_DST_Y(ppdev, pjBase, prcl->top);
CP_MM_XCNT(ppdev, pjBase, (prcl->right - xCLOffset) - 1);
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top) - 1);
CP_MM_BG_COLOR(ppdev, pjBase, ulBgColor);
CP_MM_FG_COLOR(ppdev, pjBase, ulFgColor);
if (--c)
{
// There are more than one rectangle
prcl++;
jExtMode |= ENABLE_COMMAND_LIST_PACKED;
ulCLStart = ppdev->pCommandList;
ulDstOffset
|= (ULONG)(((ULONG_PTR)ulCLStart - (ULONG_PTR)ppdev->pjScreen)<<14);
CP_MM_CL_SWITCH(ppdev);
while (TRUE)
{
// Command List
// Calculate the brush rotation.
xOffset = (prcl->left - pptlBrush->x) & 7;
yOffset = (prcl->top - pptlBrush->y) & 7;
// Calculate the destination address and size.
ulWidthHeight = PACKXY_FAST((prcl->right - prcl->left + xOffset ) - 1,
(prcl->bottom - prcl->top) - 1);
ulWidthHeight |= COMMAND_FOURTH_NOTHING;
// XY
*(ulCLStart + 1) = PACKXY_FAST(prcl->left - xOffset, prcl->top);
// Source Start address
if(ppdev->cBpp == 3)
*(ulCLStart + 2) = rbc.prb->ulBrush | yOffset | ((xOffset * 3) << 24);
else
*(ulCLStart + 2) = rbc.prb->ulBrush | yOffset | (xOffset << 24);
if (c == 1)
{
ulWidthHeight |= COMMAND_LAST_PACKET;
*ulCLStart = ulWidthHeight;
// Last Command
break;
}
*ulCLStart = ulWidthHeight;
// Next rectangle.
prcl++;
c--;
ulCLStart += 4;
}
}
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode | jHwRop );
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
CP_MM_DST_X(ppdev, pjBase, xCLOffset);
}
// Patterned brush...
else if (ppdev->flStatus & STAT_PATTERN_CACHE)
{
PATTERNCACHE* ppc;
ppc = (PATTERNCACHE*) ((ULONG_PTR) ppdev + rbc.prb->ulSlot);
if (ppc->prbUniq != rbc.prb)
{
// Cache entry is invalid, realize the brush again.
bCachePattern(ppdev, rbc.prb);
}
// Calculate the brush rotation.
xOffset = (prcl->left - pptlBrush->x) & 7;
yOffset = (prcl->top - pptlBrush->y) & 7;
// Monochrome brushes in 24-bpp are already cached expanded.
jExtMode |= ppdev->jModeColor;
if (ppdev->cBpp == 3)
{
ulSrcOffset = rbc.prb->ulBrush | yOffset | ((xOffset * 3) << 24);
}
else
{
ulSrcOffset = rbc.prb->ulBrush | yOffset | (xOffset << 24);
}
// Calculate the destination and size.
xCLOffset = prcl->left - xOffset;
//
// Make sure we can write to the video registers.
//
// We need to change to wait for buffer ready
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
// Do we really need to set it every time?
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
// Do we need to clear Source XY?
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
// Setup first set registers
CP_MM_SRC_ADDR(ppdev, pjBase, ulSrcOffset);
CP_MM_DST_Y(ppdev, pjBase, prcl->top);
CP_MM_XCNT(ppdev, pjBase, (prcl->right - xCLOffset) - 1);
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top) - 1);
if (--c)
{
// There are more than one rectangle
prcl++;
jExtMode |= ENABLE_COMMAND_LIST_PACKED;
ulCLStart = ppdev->pCommandList;
ulDstOffset
|= (ULONG)(((ULONG_PTR)ulCLStart-(ULONG_PTR)ppdev->pjScreen)<<14);
CP_MM_CL_SWITCH(ppdev);
while (TRUE)
{
// Command List
// Calculate the brush rotation.
xOffset = (prcl->left - pptlBrush->x) & 7;
yOffset = (prcl->top - pptlBrush->y) & 7;
// Calculate the destination address and size.
ulWidthHeight = PACKXY_FAST((prcl->right - prcl->left + xOffset ) - 1,
(prcl->bottom - prcl->top) - 1);
ulWidthHeight |= COMMAND_FOURTH_NOTHING;
// XY
*(ulCLStart + 1) = PACKXY_FAST(prcl->left - xOffset, prcl->top);
// Source Start address
if(ppdev->cBpp == 3)
*(ulCLStart + 2) = rbc.prb->ulBrush | yOffset | ((xOffset * 3) << 24);
else
*(ulCLStart + 2) = rbc.prb->ulBrush | yOffset | (xOffset << 24);
if (c == 1)
{
ulWidthHeight |= COMMAND_LAST_PACKET;
*ulCLStart = ulWidthHeight;
// Last Command
break;
}
*ulCLStart = ulWidthHeight;
// Next rectangle.
prcl++;
c--;
ulCLStart += 4;
}
}
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode | jHwRop );
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
CP_MM_DST_X(ppdev, pjBase, xCLOffset);
}
// Old-style brush cache.
else
{
vMmFillPat(ppdev, c, prcl, rop4, rbc, pptlBrush);
}
}
VOID vMmCopyBlt80(
PDEV* ppdev,
LONG c, // Can't be zero
RECTL* prcl, // Array of relative coordinates destination rectangles
ROP4 rop4, // Obvious?
POINTL* pptlSrc, // Original unclipped source point
RECTL* prclDst) // Original unclipped destination rectangle
{
LONG dx;
LONG dy; // Add delta to destination to get source
ULONG jHwRop;
ULONG_PTR* ulCLStart;
ULONG ulWidthHeight;
ULONG xCLOffset;
ULONG ulDstOffset = 0;
LONG xyOffset = ppdev->xyOffset;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
DWORD jExtMode = ENABLE_XY_POSITION_PACKED |
ppdev->jModeColor;
DISPDBG((10,"vCopyBlt called"));
ASSERTDD(c > 0, "Can't handle zero rectangles");
//
// The src-dst delta will be the same for all rectangles
//
dx = pptlSrc->x - prclDst->left;
dy = pptlSrc->y - prclDst->top;
//
// Make sure we can write to the video registers.
//
// We need to change to wait for buffer ready
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
jHwRop = gajHwPackedMixFromRop2[rop4 & 0xf];
CP_MM_SRC_Y_OFFSET(ppdev, pjBase, lDelta);
// Do we really need to set it every time?
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
//
// The accelerator may not be as fast at doing right-to-left copies, so
// only do them when the rectangles truly overlap:
//
if (!OVERLAP(prclDst, pptlSrc) ||
(prclDst->top < pptlSrc->y) ||
((prclDst->top == pptlSrc->y) && (prclDst->left <= pptlSrc->x))
)
{
//
// Top to Bottom - Left to Right
//
DISPDBG((12,"Top to Bottom - Left to Right"));
// Setup first set registers
xCLOffset = prcl->left;
CP_MM_DST_Y(ppdev, pjBase, prcl->top);
CP_MM_XCNT(ppdev, pjBase, (prcl->right - prcl->left) - 1);
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top) - 1);
CP_MM_SRC_ADDR(ppdev, pjBase, (xyOffset + ((prcl->top + dy) * lDelta) + PELS_TO_BYTES(prcl->left + dx)));
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
if (--c)
{
// There are more than one rectangle
prcl++;
jExtMode |= ENABLE_COMMAND_LIST_PACKED;
ulCLStart = ppdev->pCommandList;
ulDstOffset
|= (ULONG)(((ULONG_PTR)ulCLStart - (ULONG_PTR)ppdev->pjScreen)<<14);
CP_MM_CL_SWITCH(ppdev);
while (TRUE)
{
// Command List
// Calculate the destination address and size.
ulWidthHeight = PACKXY_FAST((prcl->right - prcl->left) - 1,
(prcl->bottom - prcl->top) - 1);
ulWidthHeight |= COMMAND_FOURTH_NOTHING;
// XY
*(ulCLStart + 1) = PACKXY_FAST(prcl->left, prcl->top);
// Source Start address
*(ulCLStart + 2) = xyOffset + (prcl->top + dy) * lDelta + PELS_TO_BYTES(prcl->left + dx);
if (c == 1)
{
ulWidthHeight |= COMMAND_LAST_PACKET;
*ulCLStart = ulWidthHeight;
// Last Command
break;
}
*ulCLStart = ulWidthHeight;
// Next rectangle.
prcl++;
c--;
ulCLStart += 4;
}
}
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode | jHwRop);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
CP_MM_DST_X(ppdev, pjBase, xCLOffset);
}
else
{
//
// Bottom to Top - Right to Left
//
DISPDBG((12,"Bottom to Top - Right to Left"));
// Setup first set registers
xCLOffset = prcl->right - 1;
CP_MM_DST_Y(ppdev, pjBase, prcl->bottom - 1);
CP_MM_XCNT(ppdev, pjBase, (prcl->right - prcl->left) - 1);
CP_MM_YCNT(ppdev, pjBase, (prcl->bottom - prcl->top) - 1);
CP_MM_SRC_ADDR(ppdev, pjBase, (xyOffset + ((prcl->bottom - 1 + dy) * lDelta) + PELS_TO_BYTES(prcl->right + dx - 1)));
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
if (--c)
{
// There are more than one rectangle
prcl++;
jExtMode |= ENABLE_COMMAND_LIST_PACKED;
ulCLStart = ppdev->pCommandList;
ulDstOffset
|=(ULONG)(((ULONG_PTR)ulCLStart - (ULONG_PTR)ppdev->pjScreen) << 14);
CP_MM_CL_SWITCH(ppdev);
while (TRUE)
{
// Command List
// Calculate the destination address and size.
ulWidthHeight = PACKXY_FAST((prcl->right - prcl->left) - 1,
(prcl->bottom - prcl->top) - 1);
ulWidthHeight |= COMMAND_FOURTH_NOTHING;
// XY
*(ulCLStart + 1) = PACKXY_FAST(prcl->right - 1, prcl->bottom - 1);
// Source Start address
*(ulCLStart + 2) = xyOffset + (prcl->bottom - 1 + dy) * lDelta + PELS_TO_BYTES(prcl->right + dx - 1);
if (c == 1)
{
ulWidthHeight |= COMMAND_LAST_PACKET;
*ulCLStart = ulWidthHeight;
// Last Command
break;
}
*ulCLStart = ulWidthHeight;
// Next rectangle.
prcl++;
c--;
ulCLStart += 4;
}
}
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jExtMode | jHwRop | DIR_BTRL);
CP_MM_DST_ADDR(ppdev, pjBase, ulDstOffset);
CP_MM_DST_X(ppdev, pjBase, xCLOffset);
}
}
/******************************Public*Routine******************************\
* VOID vMmXfer1bpp80
*
* Low-level routine used to transfer monochrome data to the screen using
* DWORD writes to the blt engine.
*
* This can handle opaque or transparent expansions. It does opaque
* expansions by drawing the opaque rectangle first and then transparently
* expands the foreground bits.
*
\**************************************************************************/
VOID vMmXfer1bpp80(
PDEV* ppdev,
LONG c, // Count of rectangles, can't be zero
RECTL* prcl, // List of destination rectangles, in relative
// coordinates
ROP4 rop4, // Actually had better be a rop3
SURFOBJ* psoSrc, // Source surface
POINTL* pptlSrc, // Original unclipped source point
RECTL* prclDst, // Original unclipped destination rectangle
XLATEOBJ* pxlo) // Translate that provides color-expansion information
{
ULONG* pulXfer;
ULONG* pul;
LONG ix;
LONG iy;
LONG cxWidthInBytes;
BYTE* pjBits;
POINTL ptlDst;
POINTL ptlSrc;
SIZEL sizlDst;
LONG cxLeftMask;
LONG cxRightMask;
ULONG ulDstAddr;
INT nDwords;
ULONG ulLeftMask;
ULONG ulRightMask;
LONG dx;
LONG dy;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
LONG lDeltaSrc = psoSrc->lDelta;
LONG cBpp = ppdev->cBpp;
ULONG ulFgColor = pxlo->pulXlate[1];
ULONG ulBgColor = pxlo->pulXlate[0];
// Since the hardware clipping on some of the Cirrus chips is broken, we
// do the clipping by rounding out the edges to dword boundaries and then
// doing the blt transparently. In the event that we want the expansion
// to be opaque, we do the opaquing blt in advance. One side effect of
// this is that the destination bits are no longer valid for processing
// the rop. This could probably be optimized by doing the edges seperately
// and then doing the middle section in one pass. However, this is
// complicated by a 5434 bug that breaks blts less than 10 pixels wide.
ASSERTDD(c > 0, "Can't handle zero rectangles");
ASSERTDD(((rop4 & 0xff00) == 0xcc00), "Expected foreground rop of 0xcc");
//
// The src-dst delta will be the same for all rectangles
//
dx = pptlSrc->x - prclDst->left;
dy = pptlSrc->y - prclDst->top;
#if 0
if (cBpp == 1)
{
ulFgColor = (ulFgColor << 8) | (ulFgColor & 0xff);
ulBgColor = (ulBgColor << 8) | (ulBgColor & 0xff);
ulFgColor = (ulFgColor << 16) | (ulFgColor & 0xffff);
ulBgColor = (ulBgColor << 16) | (ulBgColor & 0xffff);
}
else if (cBpp == 2)
{
ulFgColor = (ulFgColor << 16) | (ulFgColor & 0xffff);
ulBgColor = (ulBgColor << 16) | (ulBgColor & 0xffff);
}
#endif
pulXfer = ppdev->pulXfer;
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
if (rop4 != 0xCCAA)
{
LONG lCnt = c;
RECTL* prclTmp = prcl;
DWORD jHwBgRop = gajHwPackedMixFromRop2[rop4 & 0xf];
CP_MM_FG_COLOR(ppdev, pjBase, ulBgColor);
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, ENABLE_XY_POSITION_PACKED |
ENABLE_SOLID_FILL_PACKED |
jHwBgRop |
ppdev->jModeColor |
ENABLE_COLOR_EXPAND |
ENABLE_8x8_PATTERN_COPY);
CP_MM_DST_ADDR(ppdev, pjBase, 0);
do
{
// calculate the size of the blt
ptlDst.x = prclTmp->left;
ptlDst.y = prclTmp->top;
//
// Fill the background rectangle with the background color
//
// Set the dest addresses
ulDstAddr = (ptlDst.y * lDelta) + PELS_TO_BYTES(ptlDst.x);
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_XCNT(ppdev, pjBase, prclTmp->right - ptlDst.x - 1);
CP_MM_YCNT(ppdev, pjBase, prclTmp->bottom - ptlDst.y - 1);
CP_MM_DST_Y(ppdev, pjBase, ptlDst.y);
CP_MM_DST_X(ppdev, pjBase, ptlDst.x);
prclTmp++;
} while (--lCnt != 0);
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
}
CP_MM_FG_COLOR(ppdev, pjBase, ulFgColor);
CP_MM_BG_COLOR(ppdev, pjBase, ~ulFgColor);
// CP_IO_XPAR_COLOR(ppdev, pjBase, ~ulFgColor);
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, ENABLE_XY_POSITION_PACKED |
ENABLE_CLIP_RECT_PACKED |
CL_PACKED_SRC_COPY |
ppdev->jModeColor |
ENABLE_COLOR_EXPAND |
ENABLE_TRANSPARENCY_COMPARE |
SRC_CPU_DATA |
SOURCE_GRANULARITY_PACKED);
CP_MM_DST_ADDR(ppdev, pjBase, 0);
do
{
// calculate the size of the blt
ptlDst.x = prcl->left;
ptlDst.y = prcl->top;
sizlDst.cx = prcl->right - ptlDst.x;
sizlDst.cy = prcl->bottom - ptlDst.y;
// calculate the number of dwords per scan line
ptlSrc.x = prcl->left + dx;
ptlSrc.y = prcl->top + dy;
// Floor the source.
// Extend the width by the amount required to floor to a dword boundary.
// Set the size of the left mask.
// Floor the dest, so it aligns with the floored source.
if ((cxLeftMask = (ptlSrc.x & 31)))
{
sizlDst.cx += cxLeftMask;
ptlSrc.x &= ~31;
ptlDst.x -= cxLeftMask;
}
// Calculate the width in Bytes
cxWidthInBytes = (sizlDst.cx + 7) >> 3;
// Calculate the address of the source bitmap
// This is to a byte boundary.
pjBits = (PBYTE) psoSrc->pvScan0;
pjBits += ptlSrc.y * lDeltaSrc;
pjBits += ptlSrc.x >> 3;
ASSERTDD((((ULONG_PTR)pjBits & 0x03) == 0),
"pjBits not DWORD aligned like it should be");
//
// Blt the 1 bpp bitmap
//
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
// set clipping register
CP_MM_CLIP_ULXY(ppdev, pjBase, prcl->left, prcl->top);
CP_MM_CLIP_LRXY(ppdev, pjBase, prcl->right - 1, prcl->bottom - 1);
CP_MM_DST_Y(ppdev, pjBase, ptlDst.y);
CP_MM_XCNT(ppdev, pjBase, sizlDst.cx - 1);
CP_MM_YCNT(ppdev, pjBase, sizlDst.cy - 1);
CP_MM_DST_X(ppdev, pjBase, ptlDst.x);
//
// Transfer the host bitmap.
//
vImageTransfer(ppdev, pjBits, lDeltaSrc, cxWidthInBytes, sizlDst.cy);
prcl++;
} while (--c != 0);
}
/******************************Public*Routine******************************\
* VOID vMmXferNative80
*
* Transfers a bitmap that is the same color depth as the display to
* the screen via the data transfer register, with no translation.
*
\**************************************************************************/
VOID vMmXferNative80(
PDEV* ppdev,
LONG c, // Count of rectangles, can't be zero
RECTL* prcl, // Array of relative coordinates destination rectangles
ULONG rop4, // rop4
SURFOBJ* psoSrc, // Source surface
POINTL* pptlSrc, // Original unclipped source point
RECTL* prclDst, // Original unclipped destination rectangle
XLATEOBJ* pxlo) // Not used
{
LONG dx;
LONG dy;
LONG cx;
LONG cy;
LONG lSrcDelta;
BYTE* pjSrcScan0;
BYTE* pjSrc;
LONG cjSrc;
BYTE* pjBase = ppdev->pjBase;
LONG lDelta = ppdev->lDelta;
DWORD jHwRop = gajHwPackedMixFromRop2[rop4 & 0x0F];
DWORD jExtMode= ENABLE_XY_POSITION_PACKED |
SRC_CPU_DATA |
ppdev->jModeColor;
ASSERTDD((pxlo == NULL) || (pxlo->flXlate & XO_TRIVIAL),
"Can handle trivial xlate only");
ASSERTDD(psoSrc->iBitmapFormat == ppdev->iBitmapFormat,
"Source must be same color depth as screen");
ASSERTDD(c > 0, "Can't handle zero rectangles");
ASSERTDD(((rop4 & 0xff00) >> 8) == (rop4 & 0xff),
"Expect only a rop2");
dx = pptlSrc->x - prclDst->left;
dy = pptlSrc->y - prclDst->top; // Add to destination to get source
lSrcDelta = psoSrc->lDelta;
pjSrcScan0 = psoSrc->pvScan0;
//
// Make sure we can write to the video registers.
//
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_DST_Y_OFFSET(ppdev, pjBase, lDelta);
CP_MM_BLT_MODE_PACKED(ppdev, pjBase, jHwRop | jExtMode);
CP_MM_SRC_XY_PACKED(ppdev, pjBase, 0);
while(TRUE)
{
cx = prcl->right - prcl->left;
cy = prcl->bottom - prcl->top;
cjSrc = PELS_TO_BYTES(cx);
pjSrc = pjSrcScan0 + (prcl->top + dy) * lSrcDelta
+ (PELS_TO_BYTES(prcl->left + dx));
CP_MM_WAIT_FOR_BLT_COMPLETE(ppdev, pjBase);
CP_MM_XCNT(ppdev, pjBase, cx - 1);
CP_MM_YCNT(ppdev, pjBase, cy - 1);
CP_MM_DST_Y(ppdev, pjBase, prcl->top);
CP_MM_DST_ADDR(ppdev, pjBase, 0);
CP_MM_DST_X(ppdev, pjBase, prcl->left);
vImageTransfer(ppdev, pjSrc, lSrcDelta, cjSrc, cy);
if (--c == 0)
break;
prcl++;
}
}
#endif // endif D5480
Reference in a new issue Copy permalink