2185 lines
71 KiB
C
2185 lines
71 KiB
C
/**********************************************************
|
|
* Copyright (c) 1996-1997 Microsoft Corporation.
|
|
* Copyright (c) 1996-1997 Cirrus Logic, Inc.
|
|
***********************************************************
|
|
* File Name: 7555OVER.C
|
|
*
|
|
* Module Abstract:
|
|
* ----------------
|
|
* This contains functions needed to support overlay hardware.
|
|
*
|
|
* Functions:
|
|
* ----------
|
|
*
|
|
***********************************************************
|
|
* Author: Teresa Tao
|
|
* Date: 10/22/96
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
* myf31 :02-24-97 : Fixed enable HW Video, panning scrolling enable,screen move
|
|
* video window have follow moving
|
|
* myf34 :04-15-97 : Supported YUY2 format for NT.
|
|
***********************************************************/
|
|
|
|
|
|
/* #includes ---------------------------------------------*/
|
|
#include "PreComp.h"
|
|
|
|
#if DIRECTDRAW
|
|
#include "overlay.h"
|
|
#include "7555bw.h"
|
|
|
|
static int ScaleMultiply(DWORD dw1,
|
|
DWORD dw2,
|
|
LPDWORD pdwResult);
|
|
|
|
|
|
/**********************************************************
|
|
*
|
|
* Name: RegInit7555Video
|
|
*
|
|
* Module Abstract:
|
|
* ----------------
|
|
* This function is called to program the video format and
|
|
* the physicall offset of the video data in the frame buffer.
|
|
*
|
|
* Output Parameters:
|
|
* ------------------
|
|
* none
|
|
*
|
|
***********************************************************
|
|
* Author: Teresa Tao
|
|
* Date: 10/22/96
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
*
|
|
*********************************************************/
|
|
|
|
VOID RegInit7555Video (PDEV * ppdev,PDD_SURFACE_LOCAL lpSurface)
|
|
{
|
|
DWORD dwTemp;
|
|
DWORD dwFourcc;
|
|
WORD wBitCount;
|
|
|
|
LONG lPitch;
|
|
WORD wTemp;
|
|
RECTL rDest;
|
|
WORD wSrcWidth;
|
|
WORD wSrcWidth_clip;
|
|
WORD wDestWidth;
|
|
WORD wSrcHeight;
|
|
WORD wSrcHeight_clip;
|
|
WORD wDestHeight;
|
|
DWORD dwFBOffset;
|
|
BYTE bRegCR31;
|
|
BYTE bRegCR32;
|
|
BYTE bRegCR33;
|
|
BYTE bRegCR34;
|
|
BYTE bRegCR35;
|
|
BYTE bRegCR36;
|
|
BYTE bRegCR37;
|
|
BYTE bRegCR38;
|
|
BYTE bRegCR39;
|
|
BYTE bRegCR3A;
|
|
BYTE bRegCR3B;
|
|
BYTE bRegCR3C;
|
|
BYTE bRegCR3D;
|
|
BYTE bRegCR3E;
|
|
BYTE bRegCR3F;
|
|
BYTE bRegCR40;
|
|
BYTE bRegCR41;
|
|
BYTE bRegCR42;
|
|
BYTE bRegCR51;
|
|
BYTE bRegCR5D; //myf32
|
|
BYTE bRegCR5F; //myf32
|
|
BYTE bRegSR2F; //myf32
|
|
BYTE bRegSR32; //myf32
|
|
BYTE bRegSR34; //myf32
|
|
BYTE bTemp;
|
|
BYTE bVZoom;
|
|
WORD fTemp=0;
|
|
ULONG ulTemp=0;
|
|
BOOL bOverlayTooSmall = FALSE;
|
|
static DWORD giAdjustSource;
|
|
|
|
//myf32 added
|
|
bRegSR2F = Regs.bSR2F;
|
|
bRegSR32 = Regs.bSR32;
|
|
bRegSR34 = Regs.bSR34;
|
|
|
|
bRegCR5D = Regs.bCR5D;
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x5F);
|
|
bRegCR5F = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
bRegCR5F |= (Regs.bCR5F & 0x80);
|
|
//myf32 end
|
|
|
|
/*
|
|
* Init some values
|
|
*/
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x42);
|
|
// bRegCR42 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0xFC; //mask Chroma key
|
|
// & FIFO
|
|
bRegCR42 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0xF0; //mask Chroma key
|
|
// & FIFO, myf32
|
|
bRegCR42 |= (Regs.bCR42 & CR42_MVWTHRESH); //myf32
|
|
bRegCR42 |= 0x10;
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x36); //myf29
|
|
bRegCR36 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x40; //myf29
|
|
bRegCR36 |= 0x20; //set Excess 128 Data Format, myf29
|
|
|
|
/*
|
|
* Determine the format of the video data
|
|
*/
|
|
if (lpSurface->dwFlags & DDRAWISURF_HASPIXELFORMAT)
|
|
{
|
|
GetFormatInfo (ppdev,&(lpSurface->lpGbl->ddpfSurface),
|
|
&dwFourcc, &wBitCount);
|
|
}
|
|
else
|
|
{
|
|
// This needs to be changed when primary surface is RGB 5:6:5
|
|
dwFourcc = BI_RGB;
|
|
wBitCount = (WORD) ppdev->cBitsPerPixel;
|
|
}
|
|
|
|
/*
|
|
* Determine the rectangle for the video window
|
|
*/
|
|
PanOverlay1_Init(ppdev, lpSurface, &rDest, &ppdev->rOverlaySrc,
|
|
&ppdev->rOverlayDest, dwFourcc, wBitCount);
|
|
// rVideoRect is now adjusted and clipped to the panning viewport.
|
|
// disable overlay if totally clipped by viewport
|
|
|
|
if (((rDest.right - rDest.left) <= 0) ||
|
|
((rDest.bottom - rDest.top) <= 0))
|
|
{
|
|
bOverlayTooSmall = TRUE;
|
|
}
|
|
dwTemp = (DWORD)(ppdev->min_Yscreen - ppdev->rOverlayDest.top);
|
|
if ((ppdev->rOverlaySrc.bottom - ppdev->rOverlaySrc.top -(LONG)dwTemp) <=0)
|
|
bOverlayTooSmall = TRUE;
|
|
|
|
lPitch = lpSurface->lpGbl->lPitch;
|
|
|
|
wSrcWidth_clip = (WORD)(LONG)(ppdev->rOverlaySrc.right - srcLeft_clip);
|
|
wSrcHeight_clip = (WORD)(LONG)(ppdev->rOverlaySrc.bottom - srcTop_clip);
|
|
|
|
wSrcWidth = (WORD)(LONG)(ppdev->rOverlaySrc.right - ppdev->rOverlaySrc.left);
|
|
wDestWidth = (WORD)(LONG)(ppdev->rOverlayDest.right - ppdev->rOverlayDest.left);
|
|
wSrcHeight = (WORD)(LONG)(ppdev->rOverlaySrc.bottom - ppdev->rOverlaySrc.top);
|
|
wDestHeight = (WORD)(LONG)(ppdev->rOverlayDest.bottom - ppdev->rOverlayDest.top);
|
|
|
|
// Determine horizontal upscale coefficient (CR31[7:0],CR39[7:4])
|
|
wTemp = ((WORD)(((DWORD)wSrcWidth << 12) / (DWORD)wDestWidth)) & 0x0FFF;
|
|
if (wTemp != 0 && bLeft_clip)
|
|
{
|
|
srcLeft_clip = srcLeft_clip *(LONG)wTemp/4096 + ppdev->rOverlaySrc.left;
|
|
wSrcWidth_clip = (WORD)(LONG)(ppdev->rOverlaySrc.right - srcLeft_clip);
|
|
}
|
|
else if (bLeft_clip)
|
|
{
|
|
srcLeft_clip = srcLeft_clip + ppdev->rOverlaySrc.left;
|
|
wSrcWidth_clip = (WORD)(LONG)(ppdev->rOverlaySrc.right - srcLeft_clip);
|
|
}
|
|
|
|
bRegCR39 = (BYTE)((wTemp & 0x0F) << 4);
|
|
bRegCR31 = (BYTE)(wTemp >> 4) & 0xFF;
|
|
|
|
// Determine vertical upscale coefficient (CR32[7:0],CR39[3:0])
|
|
bVZoom=0;
|
|
wTemp = ((WORD)(((DWORD)wSrcHeight << 12) / (DWORD)wDestHeight)) & 0x0FFF;
|
|
if (wTemp != 0) {
|
|
bVZoom=1;
|
|
fTemp = wTemp;
|
|
if (fTemp < 2048 ) // Zoom > 2.0
|
|
wTemp=((WORD)(((DWORD)wSrcHeight << 12) / (DWORD)(wDestHeight+1))) & 0x0FFF;
|
|
}
|
|
if (wTemp != 0 && bTop_clip)
|
|
{
|
|
srcTop_clip = srcTop_clip * (LONG)wTemp/4096 + ppdev->rOverlaySrc.top;
|
|
wSrcHeight_clip = (WORD)(LONG)(ppdev->rOverlaySrc.bottom -srcTop_clip);
|
|
}
|
|
else if (bTop_clip)
|
|
{
|
|
srcTop_clip = srcTop_clip + ppdev->rOverlaySrc.top;
|
|
wSrcHeight_clip = (WORD)(LONG)(ppdev->rOverlaySrc.bottom -srcTop_clip);
|
|
}
|
|
|
|
bRegCR39 |= (BYTE)(wTemp & 0x0F);
|
|
bRegCR32 = (BYTE)(wTemp >> 4) & 0xFF;
|
|
DISPDBG((0,"wTemp = 0x%x",wTemp));
|
|
|
|
// Determine Vertical Height (CR38[7:0], CR36[3:2])
|
|
// wTemp = wSrcHeight;
|
|
wTemp = wSrcHeight_clip; //myf32
|
|
DISPDBG((0,"fTemp = 0x%x",fTemp));
|
|
if (wTemp != 0 &&
|
|
(fTemp > 2730 || fTemp ==0 || ( fTemp > 1365 && fTemp < 2048 ) ) )
|
|
wTemp--; //#tt10, Height minus one only if upscale rate <1.5
|
|
//#tt10 2 < <3
|
|
|
|
bRegCR38 = (BYTE)wTemp;
|
|
bRegCR36 |= (wTemp & 0x0300) >> 6;
|
|
|
|
|
|
// Determine Horizontal position start (CR34[7:0], CR33[7:5])
|
|
// handle 7555-BB MVA pitch bug (QWORD should be DWORD)
|
|
wTemp = (WORD)rDest.left;
|
|
bRegCR34 = (BYTE)wTemp;
|
|
bRegCR33 = (wTemp & 0x0700) >> 3;
|
|
|
|
// Reset Brightness control (CR35[7:0])
|
|
bRegCR35 = 0x0;
|
|
|
|
// Determine Vertical Start (CR37[7:0], CR36[1:0])
|
|
wTemp = (WORD)rDest.top;
|
|
bRegCR37 = (BYTE)wTemp;
|
|
bRegCR36 |= (wTemp & 0x0300) >> 8;
|
|
|
|
|
|
// Determine Video Start Address (CR40[0], CR3A[6:0], CR3E[7:0], CR3F[3:0])
|
|
giAdjustSource = (srcTop_clip * lpSurface->lpGbl->lPitch)
|
|
+ ((srcLeft_clip * wBitCount) >> 3); //myf32
|
|
// giAdjustSource = (ppdev->rOverlaySrc.top * lpSurface->lpGbl->lPitch)
|
|
// + ((ppdev->rOverlaySrc.left * wBitCount) >> 3);
|
|
ppdev->sOverlay1.lAdjustSource = giAdjustSource; //myf32
|
|
dwFBOffset = (DWORD)(lpSurface->lpGbl->fpVidMem + giAdjustSource);
|
|
// dwFBOffset = (lpSurface->lpGbl->fpVidMem - ppdev->dwScreenFlatAddr)
|
|
// + giAdjustSource; //myf32
|
|
|
|
DISPDBG((0,"lpSurface->lpGbl->fpVidMem = 0x%08x",
|
|
lpSurface->lpGbl->fpVidMem));
|
|
DISPDBG((0,"giAdjustSource = 0x%08x",giAdjustSource));
|
|
DISPDBG((0,"dwFBOffset = 0x%08x",dwFBOffset));
|
|
|
|
dwFBOffset >>= 2;
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3A);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) ;
|
|
|
|
bRegCR3A = (bTemp & ~0x7F) | (BYTE)((dwFBOffset & 0x0FE000) >> 13);
|
|
bRegCR3E = (BYTE)((dwFBOffset & 0x001FE0) >> 5);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3F);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
bRegCR3F = (bTemp & ~0x0F) | (BYTE)((dwFBOffset & 0x00001E) >> 1);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x40);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) ;
|
|
bRegCR40 = (bTemp & ~0x01) | (BYTE)(dwFBOffset & 0x000001);
|
|
|
|
//Determine Video Pitch (CR3B[7:0], CR36[4])
|
|
wTemp = (WORD)(lpSurface->lpGbl->lPitch >> 4); //QWORDs
|
|
|
|
bRegCR3B = (BYTE)wTemp;
|
|
bRegCR36 |= (wTemp & 0x0100) >> 4;
|
|
|
|
// Determine Data Format (CR3E[3:0])
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3C);
|
|
bRegCR3C = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x10;
|
|
//mask out prev VW width
|
|
|
|
switch (dwFourcc)
|
|
{
|
|
case FOURCC_PACKJR:
|
|
bRegCR3C |= 0x02; // Pack JR
|
|
break;
|
|
|
|
case BI_RGB:
|
|
switch(wBitCount)
|
|
{
|
|
case 8:
|
|
bRegCR3C |= 0x09; // 8 bit palettized
|
|
break;
|
|
|
|
case 16:
|
|
bRegCR3C |= 0x01; // RGB 5:5:5
|
|
break;
|
|
}
|
|
break;
|
|
|
|
//myf32 added
|
|
case BI_BITFIELDS:
|
|
switch(wBitCount)
|
|
{
|
|
case 8:
|
|
bRegCR3C |= 0x09; // 8 bit palettized
|
|
break;
|
|
|
|
case 16:
|
|
bRegCR3C |= 0x04; // RGB 5:6:5
|
|
break;
|
|
}
|
|
break;
|
|
//myf32 end
|
|
|
|
case FOURCC_YUV422:
|
|
bRegCR3C |= 0x03; // YUV 4:2:2
|
|
break;
|
|
|
|
case FOURCC_YUY2: //myf34 test
|
|
bRegCR3C |= 0x03; // YUY2
|
|
// CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, 0x2C);
|
|
// bRegSR2C = CP_IN_BYTE(ppdev->pjPorts, SR_DATA) ;
|
|
// bRegSR2C |= 0x40; //SR2c[6] = 1
|
|
// CP_OUT_WORD(ppdev->pjPorts, SR_INDEX, 0x2C |(WORD)bRegSR2C << 8);
|
|
break;
|
|
}
|
|
|
|
|
|
// Determine Horizontal width (CR3D[7:0], CR3C[7:5])
|
|
// NOTE: assumes Horz Pixel Width [0] = 0
|
|
|
|
wTemp = wSrcWidth_clip; //myf32
|
|
// wTemp = wSrcWidth;
|
|
|
|
if (wTemp != 0 ) wTemp--; //Width minus one for laptop
|
|
bRegCR3D = (BYTE)((WORD)wTemp >> 1);
|
|
bRegCR3C |= (wTemp & 0x0600) >> 3;
|
|
bRegCR3C |= (BYTE)((wTemp & 0x0001) << 5) ;
|
|
|
|
|
|
// Enable Horizontal Pixel Interpolation (CR3F[7])
|
|
bRegCR3F |= 0x80;
|
|
|
|
// Enable Vertical Pixel Interpolation (CR3F[6])
|
|
//#tt Debug- The CE rev. has problem when vertical interpolation is on
|
|
//#tt Debug- Disable it for now.
|
|
//#tt bRegCR3F |= 0x40;
|
|
|
|
// Enable Right Side transition threshold (CR41[5:0])
|
|
bRegCR41 = 0x3E;
|
|
|
|
// Disable V-PORT (CR58[7:0])
|
|
bRegCR51 = 0x0;
|
|
|
|
/*
|
|
* If we are color keying, we will set that up now
|
|
*/
|
|
if (lpSurface->dwReserved1 & OVERLAY_FLG_COLOR_KEY)
|
|
{
|
|
bRegCR3F |= 0x20; //Enable Occlusion
|
|
bRegCR42 &= ~0x1; //Disable Chroma Key
|
|
bRegCR5F &= ~0x80; //myf32 //Disable CR5D[7:0] if color key,
|
|
//so disable CR5F[7]
|
|
bRegCR5D = 0; //myf32
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x1A);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
|
|
// Set CR1A[3:2] to timing ANDed w/ color
|
|
bTemp &= ~0x0C;
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_DATA, bTemp);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x1D);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) ;
|
|
|
|
if (ppdev->cBitsPerPixel == 8)
|
|
{
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_DATA, (bTemp & ~0x38));
|
|
ulTemp= 0x0C | (ppdev->wColorKey << 8);
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, ulTemp);// Output color to GRC
|
|
ulTemp= 0x0D;
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, ulTemp);// Output color to GRD
|
|
|
|
}
|
|
else
|
|
{
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_DATA, (bTemp & ~0x30) | 0x08);
|
|
ulTemp= 0x0C | (ppdev->wColorKey << 8);
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, ulTemp);// Output color to GRC
|
|
ulTemp= 0x0D | (ppdev->wColorKey & 0xff00);
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, ulTemp);// Output color to GRD
|
|
|
|
}
|
|
}
|
|
else if (lpSurface->dwReserved1 & OVERLAY_FLG_SRC_COLOR_KEY)
|
|
{
|
|
BYTE bYMax, bYMin, bUMax, bUMin, bVMax, bVMin;
|
|
|
|
bRegCR3F |= 0x20; //Enable Occlusion
|
|
bRegCR42 |= 0x1; //Enable Chroma Key
|
|
bRegCR5F &= ~0x80; //myf32 //Disable CR5D[7:0] if color key,
|
|
//so disable CR5F[7]
|
|
bRegCR5D = 0; //myf32
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x1A);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) ;
|
|
// Set CR1A[3:2] to timing ANDed w/ color
|
|
bTemp &= ~0x0C;
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_DATA, bTemp);
|
|
|
|
/*
|
|
* Determine min/max values
|
|
*/
|
|
if ((dwFourcc == FOURCC_YUV422) || (dwFourcc == FOURCC_YUVPLANAR) ||
|
|
(dwFourcc == FOURCC_YUY2) || //myf34
|
|
(dwFourcc == FOURCC_PACKJR)) //myf32
|
|
{
|
|
bYMax = (BYTE)(DWORD)(ppdev->dwSrcColorKeyHigh >> 16);
|
|
bYMin = (BYTE)(DWORD)(ppdev->dwSrcColorKeyLow >> 16);
|
|
bUMax = (BYTE)(DWORD)((ppdev->dwSrcColorKeyHigh >> 8) & 0xff);
|
|
bUMin = (BYTE)(DWORD)((ppdev->dwSrcColorKeyLow >> 8) & 0xff);
|
|
bVMax = (BYTE)(ppdev->dwSrcColorKeyHigh & 0xff);
|
|
bVMin = (BYTE)(ppdev->dwSrcColorKeyLow & 0xff);
|
|
if (dwFourcc == FOURCC_PACKJR)
|
|
{
|
|
bYMax |= 0x07;
|
|
bUMax |= 0x03;
|
|
bVMax |= 0x03;
|
|
bYMin &= ~0x07;
|
|
bUMin &= ~0x03;
|
|
bVMin &= ~0x03;
|
|
}
|
|
}
|
|
else if ((dwFourcc == 0) && (wBitCount == 16))
|
|
{
|
|
/*
|
|
* RGB 5:5:5
|
|
*/
|
|
bYMax = (BYTE)(DWORD)((ppdev->dwSrcColorKeyHigh >> 7) & 0xF8);
|
|
bYMin = (BYTE)(DWORD)((ppdev->dwSrcColorKeyLow >> 7) & 0xF8);
|
|
bUMax = (BYTE)(DWORD)((ppdev->dwSrcColorKeyHigh >> 2) & 0xF8);
|
|
bUMin = (BYTE)(DWORD)((ppdev->dwSrcColorKeyLow >> 2) & 0xF8);
|
|
bVMax = (BYTE)(ppdev->dwSrcColorKeyHigh << 3);
|
|
bVMin = (BYTE)(ppdev->dwSrcColorKeyLow << 3);
|
|
bYMax |= 0x07;
|
|
bUMax |= 0x07;
|
|
bVMax |= 0x07;
|
|
|
|
}
|
|
else if (dwFourcc == BI_BITFIELDS)
|
|
{
|
|
/*
|
|
* RGB 5:6:5
|
|
*/
|
|
bYMax = (BYTE)(DWORD)((ppdev->dwSrcColorKeyHigh >> 8) & 0xF8);
|
|
bYMin = (BYTE)(DWORD)((ppdev->dwSrcColorKeyLow >> 8) & 0xF8);
|
|
bUMax = (BYTE)(DWORD)((ppdev->dwSrcColorKeyHigh >> 3) & 0xFC);
|
|
bUMin = (BYTE)(DWORD)((ppdev->dwSrcColorKeyLow >> 3) & 0xFC);
|
|
bVMax = (BYTE)(ppdev->dwSrcColorKeyHigh << 3);
|
|
bVMin = (BYTE)(ppdev->dwSrcColorKeyLow << 3);
|
|
bYMax |= 0x07;
|
|
bUMax |= 0x03;
|
|
bVMax |= 0x07;
|
|
}
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, (0x0C | (WORD)bYMin <<8));//GRC
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, (0x0D | (WORD)bYMax <<8));//GRd
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, (0x1C | (WORD)bUMin <<8));//GR1C
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, (0x1D | (WORD)bUMax <<8));//GR1D
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, (0x1E | (WORD)bVMin <<8));//GR1E
|
|
CP_OUT_WORD(ppdev->pjPorts, INDEX_REG, (0x1F | (WORD)bVMax <<8));//GR1F
|
|
|
|
}
|
|
else
|
|
{
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x1A);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) ;
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, (bTemp & ~0x0C));
|
|
bRegCR3F &= ~0x20; // disable occlusion
|
|
|
|
}
|
|
|
|
/*
|
|
* Set up alignment info
|
|
*/
|
|
if (ppdev->cBitsPerPixel != 24)
|
|
{
|
|
WORD wXAlign;
|
|
WORD wXSize;
|
|
|
|
if (ppdev->cBitsPerPixel == 8)
|
|
{
|
|
wXAlign = (WORD)rDest.left & 0x03;
|
|
wXSize = (WORD)(rDest.right - rDest.left) & 0x03;
|
|
}
|
|
else
|
|
{
|
|
wXAlign = (WORD)(rDest.left & 0x01) << 1;
|
|
wXSize = (WORD)((rDest.right - rDest.left) & 0x01) << 1;
|
|
}
|
|
}
|
|
|
|
// disable overlay if totally clipped by viewport
|
|
// or overlay is too small to be supported by HW
|
|
//
|
|
if (bOverlayTooSmall)
|
|
{
|
|
DisableVideoWindow(ppdev); // disable overlay
|
|
ppdev->dwPanningFlag |= OVERLAY_OLAY_REENABLE; // totally clipped
|
|
}
|
|
else
|
|
{
|
|
|
|
/*
|
|
* Program the video window registers
|
|
*/
|
|
//myf32 added
|
|
CP_OUT_WORD(ppdev->pjPorts, SR_INDEX, 0x2F |(WORD)bRegSR2F << 8);//SR2F
|
|
CP_OUT_WORD(ppdev->pjPorts, SR_INDEX, 0x32 |(WORD)bRegSR32 << 8);//SR32
|
|
CP_OUT_WORD(ppdev->pjPorts, SR_INDEX, 0x34 |(WORD)bRegSR34 << 8);//SR34
|
|
//myf32 end
|
|
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x31 | (WORD)bRegCR31 << 8);//CR31
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x32 | (WORD)bRegCR32 << 8);//CR32
|
|
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x34 | (WORD)bRegCR34 << 8);//CR34
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x33 | (WORD)bRegCR33 << 8);//CR33
|
|
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x35 | (WORD)bRegCR35 << 8);//CR35
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x36 | (WORD)bRegCR36 << 8);//CR36
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x37 | (WORD)bRegCR37 << 8);//CR37
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x38 | (WORD)bRegCR38 << 8);//CR38
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x39 | (WORD)bRegCR39 << 8);//CR39
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3B | (WORD)bRegCR3B << 8);//CR3B
|
|
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3C | (WORD)bRegCR3C << 8);//CR3C
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3D | (WORD)bRegCR3D << 8);//CR3D
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x41 | (WORD)bRegCR41 << 8);//CR41
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x42 | (WORD)bRegCR42 << 8);//CR42
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x51 | (WORD)bRegCR51 << 8);//CR51
|
|
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x40 | (WORD)bRegCR40 << 8);//CR40
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3A | (WORD)bRegCR3A << 8);//CR3A
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3E | (WORD)bRegCR3E << 8);//CR3E
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3F | (WORD)bRegCR3F << 8);//CR3F
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x5D | (WORD)bRegCR5D << 8);//CR5D
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x5F | (WORD)bRegCR5F << 8);//CR5F
|
|
|
|
if (lpSurface->dwReserved1 & OVERLAY_FLG_YUVPLANAR)
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3F |(WORD)0x10 <<8);
|
|
|
|
EnableVideoWindow (ppdev);
|
|
}
|
|
}
|
|
/**********************************************************
|
|
*
|
|
* Name: RegMoveVideo
|
|
*
|
|
* Module Abstract:
|
|
* ----------------
|
|
* This function is called to move the video window that has
|
|
* already been programed.
|
|
*
|
|
* Output Parameters:
|
|
* ------------------
|
|
* none
|
|
*
|
|
***********************************************************
|
|
* Author: Teresa Tao
|
|
* Date: 10/22/96
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
*
|
|
*********************************************************/
|
|
|
|
VOID RegMove7555Video (PDEV * ppdev,PDD_SURFACE_LOCAL lpSurface)
|
|
{
|
|
RegInitVideo (ppdev,lpSurface);
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************
|
|
*
|
|
* Name: DisableVideoWindow
|
|
*
|
|
* Module Abstract:
|
|
* ----------------
|
|
* turn off video window
|
|
*
|
|
* Output Parameters:
|
|
* ------------------
|
|
* none
|
|
*
|
|
***********************************************************
|
|
* Author: Teresa Tao
|
|
* Date: 10/22/96
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
*
|
|
*********************************************************/
|
|
VOID DisableVideoWindow (PDEV * ppdev)
|
|
{
|
|
UCHAR temp;
|
|
|
|
DISPDBG((0, "DisableVideoWindow"));
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3c);
|
|
temp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_DATA, (temp & ~0x10));
|
|
|
|
}
|
|
|
|
/**********************************************************
|
|
*
|
|
* Name: EnableVideoWindow
|
|
*
|
|
* Module Abstract:
|
|
* ----------------
|
|
* turn on video window
|
|
*
|
|
* Output Parameters:
|
|
* ------------------
|
|
* none
|
|
*
|
|
***********************************************************
|
|
* Author: Teresa Tao
|
|
* Date: 10/22/96
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
*
|
|
*********************************************************/
|
|
VOID EnableVideoWindow (PDEV * ppdev)
|
|
{
|
|
UCHAR temp;
|
|
DISPDBG((0, "EnableVideoWindow"));
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3c);
|
|
temp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_DATA, (temp | 0x10));
|
|
|
|
}
|
|
|
|
/**********************************************************
|
|
*
|
|
* Name: ClearAltFIFOThreshold
|
|
*
|
|
* Module Abstract:
|
|
* ----------------
|
|
*
|
|
*
|
|
* Output Parameters:
|
|
* ------------------
|
|
* none
|
|
*
|
|
***********************************************************
|
|
* Author: Teresa Tao
|
|
* Date: 10/22/96
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
*
|
|
*********************************************************/
|
|
VOID ClearAltFIFOThreshold (PDEV * ppdev)
|
|
{
|
|
UCHAR temp;
|
|
DISPDBG((0, "ClearAltFIFOThreshold"));
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x41);
|
|
temp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_DATA, (temp & ~0x20));
|
|
}
|
|
|
|
|
|
|
|
/**********************************************************
|
|
*
|
|
* Name: Is7555SufficientBandwidth
|
|
*
|
|
* Module Abstract:
|
|
* ----------------
|
|
* Determines is sufficient bandwidth exists for the requested
|
|
* configuration.
|
|
*
|
|
* Output Parameters:
|
|
* ------------------
|
|
* TRUE/FALSE
|
|
* It also sets the global parameter lFifoThresh, which gets
|
|
* programed in RegInitVideo().
|
|
*
|
|
***********************************************************
|
|
* Author: Teresa Tao
|
|
* Date: 10/22/96
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
*
|
|
*
|
|
*
|
|
***********************************************************
|
|
*
|
|
* The FIFOs:
|
|
*
|
|
* CRT FIFO is 28 levels x 64-bits wide (SR7[0])
|
|
* MVA FIFO is ?? levels x ??-bits wide (????)
|
|
* DSTN FIFO is 16 levels x 32-bits wide (SR2F[3:0])
|
|
*
|
|
*
|
|
***********************************************************/
|
|
BOOL Is7555SufficientBandwidth (PDEV * ppdev,WORD wVideoDepth, LPRECTL lpSrc, LPRECTL lpDest, DWORD dwFlags)
|
|
{
|
|
//myf33 - New Bandwith Code
|
|
BOOL fSuccess = FALSE;
|
|
DWORD dwVCLK, dwMCLK;
|
|
|
|
USHORT uMCLKsPerRandom; //RAS# cycles in MCLKs
|
|
USHORT uMCLKsPerPage; //CAS# cycles in MCLKs
|
|
USHORT uGfxThresh; //Graphic FIFO Threshold (always 8)
|
|
USHORT uMVWThresh; //MVW FIFO Threshold (8,16 or 32)
|
|
USHORT uDSTNGfxThresh, uDSTNMVWThresh;
|
|
|
|
//VPort BW document variables
|
|
USHORT uGfx, uMVW; //Graphics, Video Window
|
|
USHORT uDSTNGfxA, uDSTNGfxB, uDSTNMVWA, uDSTNMVWB;
|
|
|
|
USHORT nVW = 0; //n (VW), n (Graphics)
|
|
USHORT nGfx = 0x40; //n (VW), n (Graphics)
|
|
USHORT vVW, vGfx; //v (VW), v (Gfx)
|
|
|
|
DWORD dwTemp;
|
|
BOOL fDSTN;
|
|
BYTE bSR0F, bSR20, bSR2F, bSR32, bSR34;
|
|
BYTE bGR18, bCR42;
|
|
BYTE bCR51, bCR5A, bCR5D, bCR01, bCR5F;
|
|
BYTE b3V;
|
|
BOOL fColorKey = FALSE; //myf32
|
|
DWORD dwSrcWidth, dwDestWidth;
|
|
|
|
if (dwFlags & (OVERLAY_FLG_COLOR_KEY | OVERLAY_FLG_SRC_COLOR_KEY))
|
|
fColorKey = TRUE;
|
|
|
|
// if ((ppdev->cBitsPerPixel == 16) && (ppdev->cxScreen == 1024))
|
|
// fColorKey = FALSE;
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x80);
|
|
bSR0F = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) ;
|
|
if ((ppdev->cBitsPerPixel == 16) && fColorKey)
|
|
{
|
|
if (((ppdev->Hres == 1024) && (bSR0F & 1)) ||
|
|
(ppdev->cxScreen == 1024))
|
|
{
|
|
DISPDBG((0, "IsSufficientBandwidth() : 16bpp XGA PANEL || 1K mode"));
|
|
return (FALSE);
|
|
}
|
|
}
|
|
|
|
//myf32 begin
|
|
if (ppdev->flCaps & CAPS_TV_ON) //if TV on disable HW video
|
|
{
|
|
// ppdev->ulCAPS |= CAPS_SW_POINTER;
|
|
DISPDBG((0, "IsSufficientBandwidth() : TV Enable"));
|
|
return (FALSE);
|
|
}
|
|
|
|
#if 0 //don't support panning scrolling
|
|
if ((ppdev->cxScreen > ppdev->Hres) && (bSR0F & 1))
|
|
{
|
|
DISPDBG((0, "IsSufficientBandwidth() : Panning Scroll Enable"));
|
|
return (FALSE);
|
|
}
|
|
#endif
|
|
|
|
//myf32 end
|
|
|
|
/*
|
|
* Don's support overlay if >=24bpp
|
|
*/
|
|
if (ppdev->cBitsPerPixel == 24 || ppdev->cBitsPerPixel == 32)
|
|
{
|
|
DISPDBG((0, "IsSufficientBandwidth() : 24bpp Mode enable"));
|
|
return (FALSE);
|
|
}
|
|
|
|
/*
|
|
* Get current register settings from the chip
|
|
*/
|
|
CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, 0x0f);
|
|
bSR0F = CP_IN_BYTE(ppdev->pjPorts, SR_DATA) ;
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, 0x20);
|
|
bSR20 = CP_IN_BYTE(ppdev->pjPorts, SR_DATA);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, 0x2f);
|
|
bSR2F = CP_IN_BYTE(ppdev->pjPorts, SR_DATA) & ~(BYTE)SR2F_HFAFIFOGFX_THRESH;
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, 0x32);
|
|
bSR32 = CP_IN_BYTE(ppdev->pjPorts, SR_DATA) & ~(BYTE)SR32_HFAFIFOMVW_THRESH;
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, INDEX_REG, 0x18);
|
|
bGR18 = CP_IN_BYTE(ppdev->pjPorts, DATA_REG) ;
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x01);
|
|
bCR01 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x5F);
|
|
bCR5F = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & ~0x80;
|
|
|
|
bCR5D = 0;
|
|
bCR51 = 0;
|
|
bCR5A = 0x40; //Alan Kobayashi
|
|
bSR34 = 0; // @@@ Is this right?
|
|
|
|
|
|
/*
|
|
* Determine MCLK and VCLK
|
|
*/
|
|
dwMCLK = Get7555MCLK(ppdev); // Measured in KHz
|
|
dwVCLK = GetVCLK(ppdev); // Measured in KHz
|
|
if ( dwVCLK ==0 )
|
|
return (FALSE);
|
|
|
|
//myf32 added
|
|
// check if 3.3 voltage, (SR2F[5] =0 : 3V, =1 : 5V)
|
|
if (bSR2F & 0x40)
|
|
b3V = 0;
|
|
else
|
|
b3V = 1;
|
|
|
|
if (ppdev->ulChipID == CL7556_ID)
|
|
{
|
|
if (dwVCLK > 80000)
|
|
{
|
|
DISPDBG ((0,"Insuffieint bandwidth() : dwVCLK > 80MHz"));
|
|
return(FALSE);
|
|
}
|
|
}
|
|
else if (ppdev->ulChipID == CL7555_ID)
|
|
{
|
|
if (b3V)
|
|
{
|
|
if (dwVCLK > 65000)
|
|
{
|
|
DISPDBG ((0,"Insuffieint bandwidth() : dwVCLK > 65MHz"));
|
|
return(FALSE);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (dwVCLK > 75000)
|
|
{
|
|
DISPDBG ((0,"Insuffieint bandwidth() : dwVCLK > 75MHz"));
|
|
return(FALSE);
|
|
}
|
|
}
|
|
}
|
|
//myf32 end
|
|
|
|
|
|
/*
|
|
* See if there is enough bandwidth.
|
|
*
|
|
* CL-GD7555 has sufficient bandwidth when the following
|
|
* equation is satisfied:
|
|
*
|
|
* (Gfx + MVW + VP + DSTN) * MCLK Period <= v * VCLK period
|
|
*
|
|
* (Gfx = Graphics, MVW = Motion Video Window, VP = Video
|
|
* Port, DSTN = Dual Scan Transistor Network, MCLK =
|
|
* Memory Clock, VCLK = Video Clock)
|
|
*
|
|
* In color/chroma key mode, this equation is checked once
|
|
* with VP based on n(Gfx), and using v(Gfx). In non-color/chroma
|
|
* key mode, this equation is checked twice, once without the
|
|
* MVW term, basing VP on n(Gfx), using DSTN for Gfx, and using
|
|
* v(Gfx), and once without the Gfx term, basing VP on n(MVW),
|
|
* using DSTN for MVW, and using v(MVW).
|
|
*/
|
|
|
|
/*
|
|
* Graphics = R + (GFX FIFO Threshold - 1)P
|
|
*/
|
|
|
|
// Get R based on the table (from AHRM v1.1):
|
|
//
|
|
// SR20[6] GR18[2] SR0F[2] R(MCLKs)
|
|
//
|
|
// 0 1 0 8
|
|
// 1 1 0 9
|
|
//
|
|
uMCLKsPerRandom = 100; // Start with an invalid value
|
|
if (!(bSR20 & SR20_9MCLK_RAS))
|
|
{
|
|
if (bGR18 & GR18_LONG_RAS)
|
|
{
|
|
if (!(bSR0F & SR0F_DISPLAY_RAS))
|
|
uMCLKsPerRandom = 8;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bGR18 & GR18_LONG_RAS)
|
|
{
|
|
if (!(bSR0F & SR0F_DISPLAY_RAS))
|
|
uMCLKsPerRandom = 9;
|
|
}
|
|
}
|
|
|
|
// See if we got a valid value
|
|
if (100 == uMCLKsPerRandom)
|
|
{
|
|
DISPDBG ((0,"IsSufficientBandwidth(): Unknown RAS# cycle timing."));
|
|
goto Error;
|
|
}
|
|
DISPDBG ((0," uMCLKsPerRandom = %u", uMCLKsPerRandom));
|
|
|
|
// Get P - We assume 2 MCLKs per page cycle
|
|
uMCLKsPerPage = 2;
|
|
DISPDBG ((0," uMCLKsPerPage = %u", uMCLKsPerPage));
|
|
|
|
// Get GFX FIFO Threshold - It's hardwired to 8
|
|
uGfxThresh = GFXFIFO_THRESH;
|
|
DISPDBG ((0," uGfxThresh = %u", uGfxThresh));
|
|
|
|
// Graphics = R + (GFX FIFO Threshold - 1) * P
|
|
uGfx = uMCLKsPerRandom + ((uGfxThresh - 1) * uMCLKsPerPage);
|
|
DISPDBG ((0," uGfx = %u", uGfx));
|
|
|
|
|
|
/*
|
|
* Video Window = R + (VW FIFO Threshold - 1) * P
|
|
*/
|
|
|
|
// Get VW FIFO Threshold - From table (on BW sheet)
|
|
//
|
|
// GFX Depth MVW Depth VW FIFO Thresh
|
|
//
|
|
// 8 8 8
|
|
// 16 8 8
|
|
// 8 16 16
|
|
// 16 16 8
|
|
//
|
|
if (fColorKey)
|
|
{
|
|
if (wVideoDepth > 8)
|
|
{
|
|
if (ppdev->cBitsPerPixel > 8)
|
|
uMVWThresh = 8;
|
|
else
|
|
uMVWThresh = 16;
|
|
}
|
|
else
|
|
uMVWThresh = 8;
|
|
}
|
|
else
|
|
{
|
|
if (wVideoDepth > 8)
|
|
uMVWThresh = 8;
|
|
else
|
|
uMVWThresh = 16;
|
|
}
|
|
DISPDBG ((0," uMVWThresh = %u", uMVWThresh));
|
|
|
|
// Video Window = R + (VW FIFO Threshold - 1) * P
|
|
uMVW = uMCLKsPerRandom + ((uMVWThresh - 1) * uMCLKsPerPage);
|
|
DISPDBG ((0," uMVW = %u", uMVW));
|
|
|
|
|
|
// Determine Source and Destination VW Widths
|
|
dwSrcWidth = lpSrc->right - lpSrc->left;
|
|
dwDestWidth = lpDest->right - lpDest->left;
|
|
DISPDBG ((0," dwSrcWidth = %d", dwSrcWidth));
|
|
DISPDBG ((0," dwDestWidth = %d", dwDestWidth));
|
|
|
|
|
|
// If the video port capture is enabled, calculate VPort stuff
|
|
#if 0 //00 for New structure Code
|
|
if (dwFlags & OVERLAY_FLG_CAPTURE )
|
|
{
|
|
int iNumShift, iDenomShift;
|
|
DWORD dwNum, dwDenom;
|
|
DWORD dwXferRate;
|
|
DWORD dwVPortFreq;
|
|
|
|
// Convert transfer rate to video port frequency, which assumes
|
|
// 16-bits per clock
|
|
if (!dwMaxPixelsPerSecond)
|
|
dwXferRate = 14750000ul;
|
|
else
|
|
dwXferRate = dwMaxPixelsPerSecond;
|
|
|
|
dwXferRate = 14750000ul; //hardcoded temporarily
|
|
|
|
dwVPortFreq = (dwXferRate * (DWORD)wVideoDepth) / 16;
|
|
DISPDBG ((0," dwVPortFreq = %lu", dwVPortFreq));
|
|
|
|
/*
|
|
* V-Port = R + (n - 1) * P
|
|
*
|
|
* n is calculated for graphics and video window.
|
|
*/
|
|
|
|
// Calculate n(Gfx) and VPort(Gfx)
|
|
|
|
// n(Gfx) = VPort freq * Gfx Thresh * VPort depth cap wdth
|
|
// ------------------------------------- * ---------
|
|
// VCLK * Gfx depth xfer wdth
|
|
|
|
// Being very careful to avoid overflows while maintaining decent
|
|
// accuracy.
|
|
|
|
iNumShift = ScaleMultiply(dwVPortFreq, (DWORD)uGfxThresh, &dwNum);
|
|
DISPDBG ((0," dwNum = %lu, iNumShift = %d", dwNum, iNumShift));
|
|
iNumShift += ScaleMultiply(dwNum, (DWORD)wVideoDepth, &dwNum);
|
|
DISPDBG ((0," dwNum = %lu, iNumShift = %d", dwNum, iNumShift));
|
|
iNumShift += ScaleMultiply(dwNum, (DWORD)dwPrescaleWidth, &dwNum);
|
|
DISPDBG ((0," dwNum = %lu, iNumShift = %d", dwNum, iNumShift));
|
|
|
|
iDenomShift = ScaleMultiply(dwVCLK, (DWORD)wGfxDepth,&dwDenom);
|
|
DISPDBG ((0," dwDenom = %lu, iDenomShift = %d", dwDenom, iDenomShift));
|
|
iDenomShift += ScaleMultiply(dwDenom, (DWORD)dwCropWidth, &dwDenom);
|
|
DISPDBG ((0," dwDenom = %lu, iDenomShift = %d", dwDenom, iDenomShift));
|
|
|
|
// Even things up for the divide
|
|
if (iNumShift > iDenomShift)
|
|
{
|
|
dwDenom >>= (iNumShift - iDenomShift);
|
|
}
|
|
else if (iDenomShift > iNumShift)
|
|
{
|
|
dwNum >>= (iDenomShift - iNumShift);
|
|
}
|
|
DISPDBG ((0," dwNum = %lu, dwDenom = %lu", dwNum, dwDenom));
|
|
|
|
// Be sure rounding below doesn't overflow
|
|
if ((0xFFFFFFFF - dwDenom) < dwNum)
|
|
{
|
|
dwNum >>= 1;
|
|
dwDenom >>= 1;
|
|
}
|
|
DISPDBG ((0," dwNum = %lu, dwDenom = %lu", dwNum, dwDenom));
|
|
|
|
// Protect from a divide by 0 - this should never happen
|
|
if (0 == dwDenom)
|
|
{
|
|
DISPDBG ((0,"ChipCheckBandwidth(): Invalid n(Gfx) denominator (0)."));
|
|
goto Error;
|
|
}
|
|
|
|
// Round up
|
|
nGfx = (UINT)((dwNum + dwDenom - 1ul) / dwDenom);
|
|
DISPDBG ((0," nGfx = %u", nGfx));
|
|
|
|
// Only 3 bits for nGfx, so scale it and save factor
|
|
uGfxFactor = 1;
|
|
while (nGfx > 7)
|
|
{
|
|
nGfx++;
|
|
nGfx >>= 1;
|
|
uGfxFactor <<= 1;
|
|
DISPDBG ((0," nGfx = %u, uGfxFactor = %u", nGfx, uGfxFactor));
|
|
}
|
|
|
|
// For a 0 n(Gfx), we assume the overhead is negligible.
|
|
if (0 == nGfx)
|
|
{
|
|
uVPortGfx = 0;
|
|
}
|
|
else
|
|
{
|
|
// V-Port = R + (n - 1) * P
|
|
uVPortGfx = uMCLKsPerRandom + ((nGfx - 1) * uMCLKsPerPage);
|
|
uVPortGfx *= uGfxFactor;
|
|
}
|
|
DISPDBG ((0," uVPortGfx = %u", uVPortGfx));
|
|
|
|
// If the video window is enabled, calculate n(MVW) and VPort(MVW)
|
|
if (dwFlags & OVERLAY_FLG_CAPTURE)
|
|
{
|
|
// n(VW) = VPort freq * VW Thresh * VPort depth disp wdth cap wdth
|
|
// ------------------------------------ * --------- * ---------
|
|
// VCLK * VW depth src wdth xfer wdth
|
|
|
|
// Being very careful to avoid overflows while maintaining decent
|
|
// accuracy.
|
|
|
|
iNumShift = ScaleMultiply(dwVPortFreq, (DWORD)uMVWThresh, &dwNum);
|
|
DISPDBG ((0," dwNum = %lu, iNumShift = %d", dwNum, iNumShift));
|
|
iNumShift += ScaleMultiply(dwNum, (DWORD)wVideoDepth, &dwNum);
|
|
DISPDBG ((0," dwNum = %lu, iNumShift = %d", dwNum, iNumShift));
|
|
iNumShift += ScaleMultiply(dwNum, (DWORD)dwDestWidth, &dwNum);
|
|
DISPDBG ((0," dwNum = %lu, iNumShift = %d", dwNum, iNumShift));
|
|
iNumShift += ScaleMultiply(dwNum, (DWORD)dwPrescaleWidth, &dwNum);
|
|
DISPDBG ((0," dwNum = %lu, iNumShift = %d", dwNum, iNumShift));
|
|
|
|
iDenomShift = ScaleMultiply(dwVCLK, (DWORD)wVideoDepth, &dwDenom);
|
|
DISPDBG ((0," dwDenom = %lu, iDenomShift = %d", dwDenom, iDenomShift));
|
|
iDenomShift += ScaleMultiply(dwDenom, (DWORD)dwSrcWidth, &dwDenom);
|
|
DISPDBG ((0," dwDenom = %lu, iDenomShift = %d", dwDenom, iDenomShift));
|
|
iDenomShift += ScaleMultiply(dwDenom, (DWORD)dwCropWidth, &dwDenom);
|
|
DISPDBG ((0," dwDenom = %lu, iDenomShift = %d", dwDenom, iDenomShift));
|
|
|
|
// Even things up for the divide
|
|
if (iNumShift > iDenomShift)
|
|
{
|
|
dwDenom >>= (iNumShift - iDenomShift);
|
|
}
|
|
else if (iDenomShift > iNumShift)
|
|
{
|
|
dwNum >>= (iDenomShift - iNumShift);
|
|
}
|
|
DISPDBG ((0," dwNum = %lu, dwDenom = %lu", dwNum, dwDenom));
|
|
|
|
// Be sure rounding below doesn't overflow
|
|
if ((0xFFFFFFFF - dwDenom) < dwNum)
|
|
{
|
|
dwNum >>= 1;
|
|
dwDenom >>= 1;
|
|
}
|
|
DISPDBG ((0," dwNum = %lu, dwDenom = %lu", dwNum, dwDenom));
|
|
|
|
// Protect from a divide by 0 even though this should never happen
|
|
if (0 == dwDenom)
|
|
{
|
|
DISPDBG ((0,"ChipCheckBandwidth(): Invalid n(VW) denominator (0)."));
|
|
goto Error;
|
|
}
|
|
|
|
// Divide (round up)
|
|
nVW = (UINT)((dwNum + dwDenom - 1) / dwDenom);
|
|
DISPDBG ((0," nVW = %u", nVW));
|
|
|
|
// Only 3 bits for nVW, so scale it and save factor
|
|
uMVWFactor = 1;
|
|
while (nVW > 7)
|
|
{
|
|
nVW++;
|
|
nVW >>= 1;
|
|
uMVWFactor <<= 1;
|
|
DISPDBG ((0," nVW = %u, uMVWFactor = %u", nVW, uMVWFactor));
|
|
}
|
|
|
|
// For a 0 n(VW), we assume the overhead is negligible.
|
|
if (0 == nVW)
|
|
{
|
|
uVPortMVW = 0;
|
|
}
|
|
else
|
|
{
|
|
// V-Port = R + (n - 1) * P
|
|
uVPortMVW = uMCLKsPerRandom + ((nVW - 1) * uMCLKsPerPage);
|
|
uVPortMVW *= uMVWFactor;
|
|
}
|
|
DISPDBG((0," uVPortMVW = %u", uVPortMVW));
|
|
}
|
|
}
|
|
#endif //00 -- fr new structure code
|
|
|
|
/*
|
|
* DSTN Frame Buffer = [R + P] + [1 + (2 * P)] (a)
|
|
* or = [R + (2 * P)] + [1 + (3 * P)] (b)
|
|
*/
|
|
dwTemp = (DWORD)(uMCLKsPerRandom + uMCLKsPerPage + 1 + (2 * uMCLKsPerPage));
|
|
uDSTNGfxA = (UINT)dwTemp;
|
|
dwTemp *= dwDestWidth;
|
|
dwTemp /= dwSrcWidth;
|
|
uDSTNMVWA = (UINT)dwTemp;
|
|
|
|
dwTemp = (DWORD)(uMCLKsPerRandom + (2 * uMCLKsPerPage) + 1 + (3 * uMCLKsPerPage));
|
|
uDSTNGfxB = (UINT)dwTemp;
|
|
dwTemp *= dwDestWidth;
|
|
dwTemp /= dwSrcWidth;
|
|
uDSTNMVWB = (UINT)dwTemp;
|
|
|
|
DISPDBG((0,"uDSTNGfxA = %u, uDSTNMVWA = %u, uDSTNGfxB = %u,uDSTNMVWB = %u",
|
|
uDSTNGfxA, uDSTNMVWA, uDSTNGfxB, uDSTNMVWB));
|
|
|
|
/*
|
|
* (Gfx + MVW + VP + DSTN) * MCLK Period <= VCLK period
|
|
*/
|
|
|
|
// Calculate v(VW) and v(Graphics) for comparison below
|
|
|
|
// Div 0 Protection done above
|
|
vVW = (UINT)((64ul * (DWORD)uMVWThresh * dwDestWidth)
|
|
/ (wVideoDepth * dwSrcWidth));
|
|
DISPDBG((0," vVW = %u", vVW));
|
|
|
|
// Div 0 Protection done above
|
|
vGfx = (USHORT)((64 * uGfxThresh) / ppdev->cBitsPerPixel);
|
|
DISPDBG((0," vGfx = %u", vGfx));
|
|
|
|
// See if DSTN is enabled
|
|
fDSTN = IsDSTN(ppdev);
|
|
|
|
// Check main equation, starting with Gfx-based equation (we won't
|
|
// do MVW-based equation below unless we are non-color/chroma keyed
|
|
// and the MVW is enabled.
|
|
|
|
{
|
|
DWORD dwLeft, dwRight, dwScaledRandomMCLKPeriod;
|
|
|
|
// Begin building left side of equation with DSTN contribution
|
|
if (fDSTN)
|
|
{
|
|
if (16 == ppdev->cBitsPerPixel)
|
|
{
|
|
dwLeft = (DWORD)uDSTNGfxA;
|
|
uDSTNGfxThresh = 4;
|
|
}
|
|
else
|
|
{
|
|
dwLeft = (DWORD)uDSTNGfxB;
|
|
uDSTNGfxThresh = 6;
|
|
}
|
|
if (uMVWThresh == wVideoDepth)
|
|
uDSTNMVWThresh = 6;
|
|
else
|
|
uDSTNMVWThresh = 4;
|
|
}
|
|
else
|
|
{
|
|
dwLeft = 0;
|
|
}
|
|
DISPDBG((0," dwLeft = %lu", dwLeft));
|
|
|
|
// Are we being displayed and color or chroma keyed?
|
|
if (fColorKey)
|
|
{
|
|
// Add graphics contribution (scaled)
|
|
dwLeft += ((DWORD)uGfx * dwDestWidth) / dwSrcWidth;
|
|
|
|
DISPDBG((0," dwLeft = %lu", dwLeft));
|
|
|
|
// Add video window contribution
|
|
dwLeft += (DWORD)uMVW;
|
|
}
|
|
else
|
|
{
|
|
// Add graphics contribution (1x)
|
|
dwLeft += (DWORD)uGfx;
|
|
}
|
|
DISPDBG((0," dwLeft = %lu", dwLeft));
|
|
|
|
if (fColorKey)
|
|
dwRight = (DWORD)vVW;
|
|
else
|
|
dwRight = (DWORD)vGfx;
|
|
DISPDBG((0," dwLeft = %lu, dwRight = %lu", dwLeft, dwRight));
|
|
|
|
// Only add video port if it's in use
|
|
#if 0 //00 - for new structure code
|
|
if (dwFlags & OVERLAY_FLG_CAPTURE)
|
|
{
|
|
if (fColorKey)
|
|
dwLeft += (DWORD)uVPortMVW;
|
|
else
|
|
dwLeft += (DWORD)uVPortGfx;
|
|
}
|
|
#endif //0 - for new structure code
|
|
|
|
DISPDBG((0," dwLeft = %lu, dwRight = %lu", dwLeft, dwRight));
|
|
|
|
// To avoid the divisions in (left/MCLK) <= (right/VCLK), we'll
|
|
// instead multiply left * VCLK and right * MCLK since the relationship
|
|
// will be the same.
|
|
{
|
|
int iLeftShift, iRightShift, iRandomMCLKShift;
|
|
|
|
iLeftShift = ScaleMultiply(dwLeft, dwVCLK, &dwLeft);
|
|
DISPDBG((0," dwLeft = %lu, iLeftShift = %d", dwLeft, iLeftShift));
|
|
|
|
iRightShift = ScaleMultiply(dwRight, dwMCLK, &dwRight);
|
|
DISPDBG((0," dwRight = %lu, iRightShift = %d", dwRight, iRightShift));
|
|
|
|
iRandomMCLKShift = ScaleMultiply((DWORD)uMCLKsPerRandom, dwVCLK,
|
|
&dwScaledRandomMCLKPeriod);
|
|
DISPDBG((0," dwScaledRandomMCLKPeriod = %lu,iRandomMCLKShift = %d",
|
|
dwScaledRandomMCLKPeriod, iRandomMCLKShift));
|
|
|
|
// Even things up
|
|
{
|
|
int iShift = iLeftShift;
|
|
|
|
if (iRightShift > iShift)
|
|
iShift = iRightShift;
|
|
|
|
if (iRandomMCLKShift > iShift)
|
|
iShift = iRandomMCLKShift;
|
|
|
|
if (iShift > iLeftShift)
|
|
dwLeft >>= (iShift - iLeftShift);
|
|
|
|
if (iShift > iRightShift)
|
|
dwRight >>= (iShift - iRightShift);
|
|
|
|
if (iShift > iRandomMCLKShift)
|
|
dwScaledRandomMCLKPeriod >>= (iShift - iRandomMCLKShift);
|
|
}
|
|
}
|
|
DISPDBG((0," dwLeft = %lu, dwRight = %lu", dwLeft, dwRight));
|
|
DISPDBG((0," dwScaledRandomMCLKPeriod = %lu", dwScaledRandomMCLKPeriod));
|
|
|
|
// See if there is enough bandwidth
|
|
if (dwLeft > dwRight)
|
|
{
|
|
DISPDBG((0,"IsSufficientBandwidth(): Insufficient bandwidth (Gfx)."));
|
|
goto Error;
|
|
}
|
|
|
|
if (dwLeft > (dwRight - dwScaledRandomMCLKPeriod))
|
|
{
|
|
// Set CPU stop bits
|
|
DISPDBG((0,"IsSufficientBandwidth(): CPU stop bits set (Gfx)."));
|
|
bSR34 = SR34_CPUSTOP_ENABLE | SR34_GFX_CPUSTOP | SR34_MVW_CPUSTOP;
|
|
if (fDSTN)
|
|
bSR34 |= SR34_DSTN_CPUSTOP;
|
|
DISPDBG((0," bSR34 = 0x%x", bSR34));
|
|
}
|
|
}
|
|
|
|
// Check main equation using MVW-based values if we are not
|
|
// color/chroma keyed and the MVW is enabled.
|
|
if (!fColorKey)
|
|
{
|
|
DWORD dwLeft, dwRight, dwScaledRandomMCLKPeriod;
|
|
|
|
// Begin building left side of equation with DSTN contribution
|
|
if (fDSTN)
|
|
{
|
|
if (uMVWThresh == wVideoDepth)
|
|
dwLeft = (DWORD)uDSTNMVWB;
|
|
else
|
|
dwLeft = (DWORD)uDSTNMVWA;
|
|
}
|
|
else
|
|
{
|
|
dwLeft = 0;
|
|
}
|
|
DISPDBG((0," dwLeft = %lu", dwLeft));
|
|
|
|
// Add MVW contribution
|
|
dwLeft += (DWORD)uMVW;
|
|
DISPDBG((0," dwLeft = %lu", dwLeft));
|
|
|
|
// Use v(MVW) for right
|
|
dwRight = (DWORD)vVW;
|
|
DISPDBG((0," dwLeft = %lu, dwRight = %lu", dwLeft, dwRight));
|
|
|
|
// To avoid the divisions in (left/MCLK) <= (right/VCLK), we'll
|
|
// instead multiply left * VCLK and right * MCLK since the relationship
|
|
// will be the same.
|
|
{
|
|
int iLeftShift, iRightShift, iRandomMCLKShift;
|
|
|
|
iLeftShift = ScaleMultiply(dwLeft, dwVCLK, &dwLeft);
|
|
DISPDBG((0," dwLeft = %lu, iLeftShift = %d", dwLeft, iLeftShift));
|
|
|
|
iRightShift = ScaleMultiply(dwRight, dwMCLK, &dwRight);
|
|
DISPDBG((0," dwRight = %lu, iRightShift = %d", dwRight, iRightShift));
|
|
|
|
iRandomMCLKShift = ScaleMultiply((DWORD)uMCLKsPerRandom, dwVCLK,
|
|
&dwScaledRandomMCLKPeriod);
|
|
DISPDBG((0," dwScaledRandomMCLKPeriod = %lu, iRandomMCLKShift = %d",
|
|
dwScaledRandomMCLKPeriod, iRandomMCLKShift));
|
|
|
|
// Even things up
|
|
{
|
|
int iShift = iLeftShift;
|
|
|
|
if (iRightShift > iShift)
|
|
iShift = iRightShift;
|
|
|
|
if (iRandomMCLKShift > iShift)
|
|
iShift = iRandomMCLKShift;
|
|
|
|
if (iShift > iLeftShift)
|
|
dwLeft >>= (iShift - iLeftShift);
|
|
|
|
if (iShift > iRightShift)
|
|
dwRight >>= (iShift - iRightShift);
|
|
|
|
if (iShift > iRandomMCLKShift)
|
|
dwScaledRandomMCLKPeriod >>= (iShift - iRandomMCLKShift);
|
|
}
|
|
}
|
|
|
|
DISPDBG((0," dwLeft = %lu, dwRight = %lu", dwLeft, dwRight));
|
|
DISPDBG((0," dwScaledRandomMCLKPeriod = %lu", dwScaledRandomMCLKPeriod));
|
|
|
|
// See if there is enough bandwidth
|
|
if (dwLeft > dwRight)
|
|
{
|
|
DISPDBG((0,"IsSufficientBandwidth(): Insufficient bandwidth (MVW)."));
|
|
goto Error;
|
|
}
|
|
|
|
if (dwLeft > (dwRight - dwScaledRandomMCLKPeriod))
|
|
{
|
|
// Set CPU stop bits
|
|
DISPDBG((0,"IsSufficientBandwidth(): CPU stop bits set (MVW)."));
|
|
|
|
bSR34 = SR34_CPUSTOP_ENABLE | SR34_MVW_CPUSTOP;
|
|
|
|
if (fDSTN)
|
|
bSR34 |= SR34_DSTN_CPUSTOP;
|
|
DISPDBG((0," bSR34 = 0x%x", bSR34));
|
|
}
|
|
}
|
|
|
|
// Return register settings
|
|
bSR2F |= (BYTE)uDSTNGfxThresh & SR2F_HFAFIFOGFX_THRESH;
|
|
bSR32 |= (BYTE)uDSTNMVWThresh & SR32_HFAFIFOMVW_THRESH;
|
|
|
|
switch (uMVWThresh)
|
|
{
|
|
case 8:
|
|
bCR42 = 0x04;
|
|
break;
|
|
|
|
case 16:
|
|
bCR42 = 0x00;
|
|
break;
|
|
|
|
default:
|
|
DISPDBG((0,"IsSufficientBandwidth(): Illegal MVW Thresh (%u).", uMVWThresh));
|
|
goto Error;
|
|
}
|
|
|
|
bCR51 |= ((BYTE)nVW << 5) & CR51_VPORTMVW_THRESH;
|
|
DISPDBG((0," bCR51 = 0x%02X", (int)bCR51));
|
|
|
|
bCR5A |= (BYTE)nGfx & CR5A_VPORTGFX_THRESH;
|
|
DISPDBG((0," bCR5A = 0x%02X", (int)bCR5A));
|
|
|
|
bCR5D=(BYTE)(((8 * (WORD)(bCR01 + 1)) + dwSrcWidth - dwDestWidth) / 8);
|
|
DISPDBG((0," bCR5D = 0x%02X", (int)bCR5D));
|
|
if (bCR5D)
|
|
bCR5F |= 0x80;
|
|
|
|
|
|
// Set global registers to be programmed in RegInitVideo()
|
|
//myf33 if (lpRegs)
|
|
{
|
|
Regs.bSR2F = bSR2F;
|
|
Regs.bSR32 = bSR32;
|
|
Regs.bSR34 = bSR34;
|
|
|
|
Regs.bCR42 = bCR42;
|
|
Regs.bCR51 = bCR51;
|
|
Regs.bCR5A = bCR5A;
|
|
Regs.bCR5D = bCR5D;
|
|
Regs.bCR5F = bCR5F;
|
|
}
|
|
|
|
fSuccess = TRUE;
|
|
DISPDBG((0,"IsSufficientBandwidth: OK!"));
|
|
Error:
|
|
return(fSuccess);
|
|
}
|
|
|
|
/**********************************************************
|
|
*
|
|
* Get7555MCLK()
|
|
*
|
|
* Determines the current MCLK frequency.
|
|
*
|
|
* Return: The MCLK frequency in KHz (Since the frequency
|
|
* could exceed 65535KHz, a DWORD is used).
|
|
*
|
|
***********************************************************
|
|
* Author: Rick Tillery
|
|
* Date: 09/27/95
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
* WHO WHEN WHAT/WHY/HOW
|
|
* --- ---- ------------
|
|
*
|
|
*********************************************************/
|
|
DWORD Get7555MCLK(PDEV * ppdev)
|
|
{
|
|
DWORD dwMCLK;
|
|
int nMCLK;
|
|
BYTE bTemp;
|
|
|
|
// Get MCLK register value
|
|
CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, 0x1f);
|
|
nMCLK = CP_IN_BYTE(ppdev->pjPorts, SR_DATA) & 0x3F;
|
|
|
|
|
|
// Calculate actual MCLK frequency
|
|
dwMCLK = (14318l * (DWORD)nMCLK) >> 3;
|
|
CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, 0x12);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, SR_DATA) ;
|
|
|
|
// Account for MCLK scaling
|
|
if (bTemp & 0x10)
|
|
{
|
|
dwMCLK >>= 1;
|
|
}
|
|
|
|
return(dwMCLK);
|
|
}
|
|
|
|
/**********************************************************
|
|
*
|
|
* IsDSTN()
|
|
*
|
|
* Determines whether a DSTN panel is being used for display.
|
|
*
|
|
* Return: TRUE/FALSE
|
|
*
|
|
***********************************************************
|
|
* Author: Teresa Tao
|
|
* Date: 10/22/96
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
* WHO WHEN WHAT/WHY/HOW
|
|
* --- ---- ------------
|
|
*
|
|
*********************************************************/
|
|
BOOL IsDSTN(PDEV * ppdev)
|
|
{
|
|
BOOL bTemp;
|
|
|
|
/*
|
|
* Is this an LCD?
|
|
*/
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x80);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
|
|
if (bTemp & 0x01)
|
|
{
|
|
/*
|
|
* Determine type of LCD.
|
|
*/
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x83);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x70;
|
|
bTemp >>= 4 ;
|
|
if (bTemp == 0)
|
|
return (TRUE);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
/**********************************************************
|
|
*
|
|
* IsXGA()
|
|
*
|
|
* Determines whether a XGA panel is being used for display.
|
|
*
|
|
* Return: TRUE/FALSE
|
|
*
|
|
***********************************************************
|
|
* Author: Teresa Tao
|
|
* Date: 10/22/96
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
* WHO WHEN WHAT/WHY/HOW
|
|
* --- ---- ------------
|
|
*
|
|
*********************************************************/
|
|
BOOL IsXGA(PDEV * ppdev)
|
|
{
|
|
BOOL bTemp;
|
|
|
|
/*
|
|
* Is this an LCD?
|
|
*/
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x80);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
|
|
if (bTemp & 0x01)
|
|
{
|
|
/*
|
|
* Determine size of LCD.
|
|
*/
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x83);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x03;
|
|
if (bTemp == 0x02)
|
|
return (TRUE);
|
|
}
|
|
return (FALSE);
|
|
}
|
|
|
|
|
|
/**********************************************************
|
|
*
|
|
* ScaleMultiply()
|
|
*
|
|
* Calculates product of two DWORD factors supplied. If the
|
|
* result would overflow a DWORD, the larger of the two factors
|
|
* is divided by 2 (shifted right) until the overflow will
|
|
* not occur.
|
|
*
|
|
* Returns: Number of right shifts applied to the product.
|
|
* Product of the factors shifted by the value above.
|
|
*
|
|
***********************************************************
|
|
* Author: Rick Tillery
|
|
* Date: 11/18/95
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
* WHO WHEN WHAT/WHY/HOW
|
|
* --- ---- ------------
|
|
*********************************************************/
|
|
static int ScaleMultiply(DWORD dw1,
|
|
DWORD dw2,
|
|
LPDWORD pdwResult)
|
|
{
|
|
int iShift = 0; // Start with no shifts
|
|
DWORD dwLimit;
|
|
|
|
// Either factor 0 will be a zero result and also cause a problem
|
|
// in our divide below.
|
|
if ((0 == dw1) || (0 == dw2))
|
|
{
|
|
*pdwResult = 0;
|
|
}
|
|
else
|
|
{
|
|
// Determine which factor is larger
|
|
if (dw1 > dw2)
|
|
{
|
|
// Determine largest number by with dw2 can be multiplied without
|
|
// overflowing a DWORD.
|
|
dwLimit = 0xFFFFFFFFul / dw2;
|
|
|
|
// Shift dw1, keeping track of how many times, until it won't
|
|
// overflow when multiplied by dw2.
|
|
while (dw1 > dwLimit)
|
|
{
|
|
dw1 >>= 1;
|
|
iShift++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Determine largest number by with dw1 can be multiplied without
|
|
// overflowing a DWORD.
|
|
dwLimit = 0xFFFFFFFFul / dw1;
|
|
|
|
// Shift dw2, keeping track of how many times, until it won't
|
|
// overflow when multiplied by dw1.
|
|
while (dw2 > dwLimit)
|
|
{
|
|
dw2 >>= 1;
|
|
iShift++;
|
|
}
|
|
}
|
|
// Calculate (scaled) product
|
|
*pdwResult = dw1 * dw2;
|
|
}
|
|
// Return the number of shifts we had to use
|
|
return(iShift);
|
|
}
|
|
|
|
|
|
//myf31 :
|
|
#if 1
|
|
/**********************************************************
|
|
*
|
|
* PanOverlay7555
|
|
*
|
|
* If panning scrolling enable, and enable HW video, modified video window value
|
|
*
|
|
* Return: none
|
|
*
|
|
***********************************************************
|
|
* Author: Rita Ma
|
|
* Date: 02/24/97
|
|
*
|
|
* Revision History:
|
|
* -----------------
|
|
*********************************************************/
|
|
VOID PanOverlay7555 (PDEV * ppdev,LONG x,LONG y)
|
|
// RegInit7555Video (PDEV * ppdev,PDD_SURFACE_LOCAL lpSurface)
|
|
{
|
|
DWORD dwTemp;
|
|
DWORD dwFourcc;
|
|
WORD wBitCount;
|
|
|
|
LONG lPitch;
|
|
WORD wTemp;
|
|
RECTL rDest;
|
|
WORD wSrcWidth;
|
|
WORD wSrcWidth_clip;
|
|
WORD wDestWidth;
|
|
WORD wSrcHeight;
|
|
WORD wSrcHeight_clip;
|
|
WORD wDestHeight;
|
|
DWORD dwFBOffset;
|
|
BYTE bRegCR31;
|
|
BYTE bRegCR32;
|
|
BYTE bRegCR33;
|
|
BYTE bRegCR34;
|
|
BYTE bRegCR35;
|
|
BYTE bRegCR36;
|
|
BYTE bRegCR37;
|
|
BYTE bRegCR38;
|
|
BYTE bRegCR39;
|
|
BYTE bRegCR3A;
|
|
BYTE bRegCR3B;
|
|
BYTE bRegCR3C;
|
|
BYTE bRegCR3D;
|
|
BYTE bRegCR3E;
|
|
BYTE bRegCR3F;
|
|
BYTE bRegCR40;
|
|
BYTE bRegCR41;
|
|
BYTE bRegCR42;
|
|
|
|
BYTE bRegCR51;
|
|
BYTE bTemp;
|
|
BYTE bVZoom;
|
|
WORD fTemp=0;
|
|
ULONG ulTemp=0;
|
|
BOOL bOverlayTooSmall = FALSE;
|
|
static DWORD giAdjustSource;
|
|
|
|
// USHORT VW_h_position, VW_v_position;
|
|
// USHORT VW_h_width, VW_v_height;
|
|
// ULONG VW_s_addr;
|
|
|
|
// PanOverlay1_Init return FALSE, exit here
|
|
if (!PanOverlay1_7555(ppdev, &rDest))
|
|
return;
|
|
|
|
// rDest is now adjusted & clipped to the panning viewport
|
|
// Disable overlay if totally clipped by viewport
|
|
//
|
|
if (((rDest.right - rDest.left) <= 15) ||
|
|
((rDest.bottom - rDest.top) <= 0) )
|
|
{
|
|
DisableVideoWindow(ppdev); // disable overlay
|
|
return;
|
|
}
|
|
|
|
// Initial some value
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x42);
|
|
bRegCR42 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0xFC; //mask Chroma Key
|
|
|
|
// keep bit6 video LUT enable
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x36);
|
|
bRegCR36 = (CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x40) | 0x20;
|
|
|
|
//
|
|
// Get video format and color depth of overlay data
|
|
//
|
|
dwFourcc = ppdev->sOverlay1.dwFourcc;
|
|
wBitCount= ppdev->sOverlay1.wBitCount;
|
|
lPitch = ppdev->lPitch_gbls; //??????????
|
|
|
|
wSrcWidth = (WORD)(LONG)(ppdev->rOverlaySrc.right - ppdev->rOverlaySrc.left);
|
|
wSrcHeight = (WORD)(LONG)(ppdev->rOverlaySrc.bottom - ppdev->rOverlaySrc.top);
|
|
|
|
wSrcWidth_clip = (WORD)(LONG)(ppdev->rOverlaySrc.right - srcLeft_clip);
|
|
wSrcHeight_clip = (WORD)(LONG)(ppdev->rOverlaySrc.bottom - srcTop_clip);
|
|
|
|
wDestWidth = (WORD)(LONG)(ppdev->rOverlayDest.right - ppdev->rOverlayDest.left);
|
|
wDestHeight = (WORD)(LONG)(ppdev->rOverlayDest.bottom - ppdev->rOverlayDest.top);
|
|
|
|
// Determine horizontal upscale coefficient (CR39[7:4],CR31[7:0])
|
|
wTemp = ((WORD)(((DWORD)wSrcWidth << 12) / (DWORD)wDestWidth)) & 0x0FFF;
|
|
|
|
if (wTemp != 0 && bLeft_clip)
|
|
{
|
|
srcLeft_clip = srcLeft_clip * (LONG)wTemp/4096 +ppdev->rOverlaySrc.left;
|
|
wSrcWidth_clip = (WORD)(LONG)(ppdev->rOverlaySrc.right - srcLeft_clip);
|
|
DISPDBG((0,"srcLeft_clip after zoom:%x",srcLeft_clip));
|
|
}
|
|
else if (bLeft_clip)
|
|
{
|
|
srcLeft_clip = srcLeft_clip + ppdev->rOverlaySrc.left;
|
|
wSrcWidth_clip = (WORD)(LONG)(ppdev->rOverlaySrc.right - srcLeft_clip);
|
|
DISPDBG((0,"srcLeft_clip after zoom:%x",srcLeft_clip));
|
|
}
|
|
|
|
bRegCR39 = (BYTE)((wTemp & 0x0F) << 4);
|
|
bRegCR31 = (BYTE)(wTemp >> 4) & 0xFF;
|
|
|
|
// Determine vertical upscale coefficient (CR39[3:0],CR32[7:0])
|
|
bVZoom=0;
|
|
wTemp = ((WORD)(((DWORD)wSrcHeight << 12) / (DWORD)wDestHeight)) & 0x0FFF;
|
|
if (wTemp != 0) {
|
|
bVZoom=1;
|
|
fTemp = wTemp;
|
|
if ( fTemp < 2048 ) // Zoom > 2.0
|
|
wTemp=((WORD)(((DWORD)wSrcHeight << 12) / (DWORD)(wDestHeight+1))) & 0x0FFF;
|
|
}
|
|
if (wTemp != 0 && bTop_clip)
|
|
{
|
|
srcTop_clip = srcTop_clip * (LONG)wTemp/4096 + ppdev->rOverlaySrc.top;
|
|
wSrcHeight_clip = (WORD)(LONG)(ppdev->rOverlaySrc.bottom - srcTop_clip);
|
|
DISPDBG((0,"srcTop_clip after zoom:%x",srcTop_clip));
|
|
}
|
|
else if (bTop_clip)
|
|
{
|
|
srcTop_clip = srcTop_clip + ppdev->rOverlaySrc.top;
|
|
wSrcHeight_clip = (WORD)(LONG)(ppdev->rOverlaySrc.bottom - srcTop_clip);
|
|
DISPDBG((0,"srcTop_clip after zoom:%x",srcTop_clip));
|
|
}
|
|
|
|
bRegCR39 |= (BYTE)(wTemp & 0x0F);
|
|
bRegCR32 = (BYTE)(wTemp >> 4) & 0xFF;
|
|
DISPDBG((0,"wTemp = 0x%x",wTemp));
|
|
|
|
// Determine Vertical Height (CR38[7:0], CR36[3:2])
|
|
wTemp = wSrcHeight_clip;
|
|
if (wTemp != 0 &&
|
|
( fTemp > 2730 || fTemp ==0 || ( fTemp > 1365 && fTemp < 2048 ) ) )
|
|
wTemp--; //#tt10, Height minus one only if upscale rate <1.5
|
|
//#tt10 2 < <3
|
|
|
|
bRegCR38 = (BYTE)wTemp;
|
|
bRegCR36 |= (wTemp & 0x0300) >> 6;
|
|
|
|
// Determine Horizontal position start (CR34[7:0], CR33[7:5])
|
|
wTemp = (WORD)rDest.left;
|
|
bRegCR34 = (BYTE)wTemp;
|
|
bRegCR33 = (wTemp & 0x0700) >> 3;
|
|
|
|
// Reset Brightness control (CR35[7:0])
|
|
bRegCR35 = 0x0;
|
|
|
|
// Determine Vertical Start (CR37[7:0], CR36[1:0])
|
|
wTemp = (WORD)rDest.top;
|
|
bRegCR37 = (BYTE)wTemp;
|
|
bRegCR36 |= (wTemp & 0x0300) >> 8;
|
|
|
|
|
|
// Determine Video Start Address (CR40[0], CR3A[6:0], CR3E[7:0], CR3F[3:0])
|
|
// giAdjustSource = (ppdev->rOverlaySrc.top * lpSurface->lpGbl->lPitch)
|
|
// + ((ppdev->rOverlaySrc.left * wBitCount) >> 3);
|
|
dwTemp = srcTop_clip * lPitch;
|
|
dwTemp = (srcLeft_clip * wBitCount) >> 3;
|
|
giAdjustSource = (srcTop_clip * lPitch)
|
|
+ ((srcLeft_clip * wBitCount) >> 3);
|
|
|
|
ppdev->sOverlay1.lAdjustSource = giAdjustSource; //myf32
|
|
dwFBOffset = (DWORD)(ppdev->fpVidMem_gbls + giAdjustSource);
|
|
|
|
DISPDBG((0,"giAdjustSource = 0x%08x",giAdjustSource));
|
|
DISPDBG((0,"dwFBOffset = 0x%08x",dwFBOffset));
|
|
|
|
dwFBOffset >>= 2;
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3A);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) ;
|
|
|
|
bRegCR3A = (bTemp & ~0x7F) | (BYTE)((dwFBOffset & 0x0FE000) >> 13);
|
|
bRegCR3E = (BYTE)((dwFBOffset & 0x001FE0) >> 5);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3F);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
bRegCR3F = (bTemp & ~0x0F) | (BYTE)((dwFBOffset & 0x00001E) >> 1);
|
|
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x40);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) ;
|
|
bRegCR40 = (bTemp & ~0x01) | (BYTE)(dwFBOffset & 0x000001);
|
|
|
|
//Determine Video Pitch (CR3B[7:0], CR36[4])
|
|
wTemp = (WORD)(lPitch >> 4); //QWORDs
|
|
|
|
bRegCR3B = (BYTE)wTemp;
|
|
bRegCR36 |= (wTemp & 0x0100) >> 4;
|
|
|
|
// Determine Data Format (CR3E[3:0])
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3C);
|
|
bRegCR3C = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x10;
|
|
|
|
switch (dwFourcc)
|
|
{
|
|
case FOURCC_PACKJR:
|
|
bRegCR3C |= 0x02; // Pack JR
|
|
break;
|
|
|
|
case BI_RGB:
|
|
switch(wBitCount)
|
|
{
|
|
case 8:
|
|
bRegCR3C |= 0x09; // 8 bit palettized
|
|
break;
|
|
|
|
case 16:
|
|
bRegCR3C |= 0x01; // RGB 5:5:5
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case BI_BITFIELDS:
|
|
switch(wBitCount)
|
|
{
|
|
case 8:
|
|
bRegCR3C |= 0x09; // 8 bit palettized
|
|
break;
|
|
|
|
case 16:
|
|
bRegCR3C |= 0x04; // RGB 5:6:5
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case FOURCC_YUV422:
|
|
bRegCR3C |= 0x03; // YUV 4:2:2
|
|
break;
|
|
|
|
case FOURCC_YUY2: //myf34 test
|
|
bRegCR3C |= 0x03; // YUY2
|
|
// CP_OUT_BYTE(ppdev->pjPorts, SR_INDEX, 0x2C);
|
|
// bRegSR2C = CP_IN_BYTE(ppdev->pjPorts, SR_DATA) ;
|
|
// bRegSR2C |= 0x40; //SR2c[6] = 1
|
|
// CP_OUT_WORD(ppdev->pjPorts, SR_INDEX, 0x2C |(WORD)bRegSR2C << 8);
|
|
break;
|
|
}
|
|
|
|
|
|
// Determine Horizontal width (CR3D[7:0], CR3C[7:5])
|
|
// NOTE: assumes Horz Pixel Width [0] = 0
|
|
|
|
wTemp = wSrcWidth_clip;
|
|
|
|
if (wTemp != 0 ) wTemp--; //Width minus one for laptop
|
|
bRegCR3D = (BYTE)((WORD)wTemp >> 1);
|
|
bRegCR3C |= (wTemp & 0x0600) >> 3;
|
|
bRegCR3C |= (BYTE)((wTemp & 0x0001) << 5) ;
|
|
|
|
// Enable Horizontal Pixel Interpolation (CR3F[7])
|
|
bRegCR3F |= 0x80;
|
|
|
|
// Enable Vertical Pixel Interpolation (CR3F[6])
|
|
//#tt Debug- The CE rev. has problem when vertical interpolation is on
|
|
//#tt Debug- Disable it for now.
|
|
//#tt bRegCR3F |= 0x40;
|
|
|
|
// Enable Right Side transition threshold (CR41[5:0])
|
|
bRegCR41 = 0x3E;
|
|
|
|
// Disable V-PORT (CR58[7:0])
|
|
bRegCR51 = 0x0;
|
|
|
|
// Disable CR5D if in panning & upscaling
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x80);
|
|
//myf33 if (bVZoom && (BYTE)wPanFlag)
|
|
if (bVZoom && (CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x01)) //myf33
|
|
{
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x5F);
|
|
bTemp = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & ~0x80;
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_DATA, (UCHAR)bTemp);
|
|
}
|
|
|
|
#if 0 // bad ideal code
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3C);
|
|
bRegCR3C = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA) & 0x10;
|
|
|
|
if (bRegCR3C)
|
|
{
|
|
// Horizontal position start (CR33[7:5], CR34[7:0])
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x34);
|
|
bRegCR34 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x33);
|
|
bRegCR33 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
VW_h_position = ((USHORT)(bRegCR33 & 0xE0)) << 3;
|
|
VW_h_position |= (USHORT)bRegCR34;
|
|
|
|
// Vertical position start (CR36[1:0], CR37[7:0])
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x37);
|
|
bRegCR37 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x36);
|
|
bRegCR36 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
VW_v_position = ((USHORT)(bRegCR36 & 0x03)) << 8;
|
|
VW_v_position |= (USHORT)bRegCR37;
|
|
|
|
//Video horizontal width (CR3C[7:6], CR3D[7:0], CR3C[5])
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3D);
|
|
bRegCR3D = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3C);
|
|
bRegCR3C = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
VW_h_width = (WORD)(bRegCR3C & 0x01);
|
|
VW_h_width |= (((USHORT)(bRegCR3C & 0xC0)) << 3);
|
|
VW_h_width |= (((USHORT)bRegCR3D) << 1);
|
|
|
|
//Video vertical height (CR36[3:2], CR38[7:0])
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x38);
|
|
bRegCR38 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
// CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x36);
|
|
// bRegCR36 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
VW_v_height = ((USHORT)(bRegCR36 & 0x0C)) << 6;
|
|
VW_v_height |= ((USHORT)bRegCR38);
|
|
|
|
//Video memory offset register (CR36[4], CR3B[7:0])
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3B);
|
|
bRegCR3B = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
lPitch = ((USHORT)(bRegCR36 & 0x10)) << 4;
|
|
lPitch |= ((USHORT)bRegCR3B);
|
|
lPitch <<= 4;
|
|
|
|
//Video memory start address (CR3A[6:0], CR3E[7:0], CR3F[3:0], CR40[0])
|
|
// update sequence CR40[0], CR3A[6:0], CR3E[7:0], CR3F[3:0]
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x40);
|
|
bRegCR40 = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3A);
|
|
bRegCR3A = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3E);
|
|
bRegCR3E = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
CP_OUT_BYTE(ppdev->pjPorts, CRTC_INDEX, 0x3F);
|
|
bRegCR3F = CP_IN_BYTE(ppdev->pjPorts, CRTC_DATA);
|
|
#if 0
|
|
VW_s_addr = (ULONG)(bRegCR40 & 0x01);
|
|
VW_s_addr |= (((ULONG)(bRegCR3F & 0x0F)) << 1);
|
|
VW_s_addr |= (((ULONG)bRegCR3E) << 5);
|
|
VW_s_addr |= (((ULONG)(bRegCR3A & 0x7F)) << 13);
|
|
VW_s_addr <<= 2;
|
|
#endif
|
|
|
|
// Update Video window Horizontal & Vertical position
|
|
DISPDBG((0,"PAN--Xmin=%x, Xmax=%x\n",ppdev->min_Xscrren,ppdev->max_Xscrren));
|
|
DISPDBG((0,"PAN--Ymin=%x, Ymax=%x\n",ppdev->min_Yscrren,ppdev->max_Yscrren));
|
|
DISPDBG((0,"PAN--h_position=%x, v_position=%x\n",VW_h_position,
|
|
VW_v_position));
|
|
DISPDBG((0,"PAN--h_height=%x, v_width=%x\n",VW_h_height,VW_v_width));
|
|
|
|
if (((ppdev->min_Xscreen <= VW_h_position) &&
|
|
(ppdev->max_Xscreen >= VW_h_position)) &&
|
|
((ppdev->min_Yscreen <= VW_v_position) &&
|
|
(ppdev->max_Yscreen >= VW_v_position)))
|
|
{
|
|
VW_h_position -= ppdev->min_Xscreen;
|
|
VW_v_position -= ppdev->min_Yscreen;
|
|
DISPDBG((0,"(1)--h_position=%x, v_position=%x\n",VW_h_position,
|
|
VW_v_position));
|
|
DISPDBG((0,"(1)--h_height=%x, v_width=%x\n",VW_h_height,VW_v_width));
|
|
}
|
|
// Video window in the left or right
|
|
else if ((ppdev->max_Xscreen < VW_h_position) ||
|
|
(ppdev->min_Xscreen > (VW_h_position+VW_h_width)))
|
|
{
|
|
DisableVideoWindow(ppdev); // disable overlay
|
|
ppdev->dwPanningFlag |= OVERLAY_OLAY_REENABLE; // totally clipped
|
|
DISPDBG((0,"(2)--DisableVideoWindow\n"));
|
|
}
|
|
// Video window in the top or bottom
|
|
else if ((ppdev->max_Yscreen < VW_v_position) ||
|
|
(ppdev->min_Yscreen > (VW_v_position+VW_v_height)))
|
|
{
|
|
DisableVideoWindow(ppdev); // disable overlay
|
|
ppdev->dwPanningFlag |= OVERLAY_OLAY_REENABLE; // totally clipped
|
|
DISPDBG((0,"(3)--DisableVideoWindow\n"));
|
|
}
|
|
// Update Video window memory start address
|
|
else if ((ppdev->min_Xscreen > VW_h_position) &&
|
|
(ppdev->min_Xscreen < (VW_h_position+VW_h_width)))
|
|
{
|
|
if ((ppdev->min_Xscreen-VW_h_position) > 0)
|
|
{
|
|
ppdev->rOverlaySrc.left = ppdev->min_Xscreen - VW_h_position;
|
|
VW_h_position = ppdev->min_Xscreen;
|
|
VW_h_width -= ppdev->rOverlaySrc.left;
|
|
}
|
|
if ((ppdev->min_Yscreen-VW_v_position) > 0)
|
|
{
|
|
ppdev->rOverlaySrc.top = ppdev->min_Yscreen - VW_v_position;
|
|
VW_v_position = ppdev->min_Yscreen;
|
|
VW_v_height -= ppdev->rOverlaySrc.top;
|
|
}
|
|
DISPDBG((0,"(4)--h_position=%x, v_position=%x\n",VW_h_position,
|
|
VW_v_position));
|
|
DISPDBG((0,"(4)--h_height=%x, v_width=%x\n",VW_h_height,VW_v_width));
|
|
DISPDBG((0,"(4)--Overlay.top=%x, left=%x\n",ppdev->rOverlaySrc.top,
|
|
ppdev->rOverlaySrc.left));
|
|
}
|
|
else if ((ppdev->min_Yscreen > VW_v_position) &&
|
|
(ppdev->min_Yscreen < (VW_v_position+VW_v_height)))
|
|
{
|
|
if ((ppdev->min_Xscreen-VW_h_position) > 0)
|
|
{
|
|
ppdev->rOverlaySrc.left = ppdev->min_Xscreen - VW_h_position;
|
|
VW_h_position = ppdev->min_Xscreen;
|
|
VW_h_width -= ppdev->rOverlaySrc.left;
|
|
}
|
|
if ((ppdev->min_Yscreen-VW_v_position) > 0)
|
|
{
|
|
ppdev->rOverlaySrc.top = ppdev->min_Yscreen - VW_v_position;
|
|
VW_v_position = ppdev->min_Yscreen;
|
|
VW_v_height -= ppdev->rOverlaySrc.top;
|
|
}
|
|
DISPDBG((0,"(5)--h_position=%x, v_position=%x\n",VW_h_position,
|
|
VW_v_position));
|
|
DISPDBG((0,"(5)--h_height=%x, v_width=%x\n",VW_h_height,VW_v_width));
|
|
}
|
|
giAdjustSource = (ppdev->rOverlaySrc.top * lPitch)
|
|
// ppdev->lpSrcColorSurface->lpGbl->lPitch)
|
|
+ ((ppdev->rOverlaySrc.left
|
|
* ppdev->sOverlay1.wBitCount) >> 3);
|
|
|
|
// DISPDBG((0,"lpSurface->fpVisibleOverlay= \n0x%08x\n",
|
|
// ppdev->fpVisibleOverlay));
|
|
// DISPDBG((0,"lpSurface->fpBaseOverlay = 0x%08x\n",
|
|
// ppdev->fpBaseOverlay));
|
|
DISPDBG((0,"PAN--fpVidMem=0x%8x\t",ppdev->fpVidMem));
|
|
DISPDBG((0,"PAN--giAdjustSource = 0x%08x\n",giAdjustSource));
|
|
dwFBOffset = (ppdev->fpVidMem_gbls - ) + giAdjustSource;
|
|
|
|
DISPDBG((0,"PAN--dwFBOffset = 0x%08x\n",dwFBOffset));
|
|
|
|
dwFBOffset >>= 2;
|
|
|
|
//Update Horizontal position start (CR33[7:5], CR34[7:0])
|
|
bRegCR34 = (BYTE)(VW_h_position & 0xFF);
|
|
bRegCR33 &= 0x1F;
|
|
bRegCR33 |= ((BYTE)((VW_h_position & 0x0700) >> 3));
|
|
|
|
// Vertical position start (CR36[1:0], CR37[7:0])
|
|
bRegCR37 = (BYTE)(VW_v_position & 0xFF);
|
|
bRegCR36 &= 0xFC;
|
|
bRegCR36 |= ((BYTE)((VW_v_position & 0x0300) >> 8));
|
|
|
|
//Video horizontal width (CR3C[7:6], CR3D[7:0], CR3C[5])
|
|
bRegCR3D = (BYTE)((VW_h_width & 0x1FE) >> 1);
|
|
bRegCR3C &= 0x1F;
|
|
bRegCR3C |= ((BYTE)(VW_h_width & 0x01)) << 5;
|
|
bRegCR3C |= ((BYTE)((VW_h_width & 0x0600) >> 3));
|
|
|
|
//Video vertical height (CR36[3:2], CR38[7:0])
|
|
bRegCR38 = (BYTE)(VW_v_height & 0xFF);
|
|
bRegCR36 &= 0xF3;
|
|
bRegCR36 |= ((BYTE)((VW_v_height & 0x0300) >> 6));
|
|
|
|
//Video memory start address (CR3A[6:0], CR3E[7:0], CR3F[3:0], CR40[0])
|
|
// update sequence CR40[0], CR3A[6:0], CR3E[7:0], CR3F[3:0]
|
|
bRegCR40 &= 0xFE;
|
|
bRegCR40 |= (BYTE)(dwFBOffset & 0x01);
|
|
bRegCR3F &= 0xF0;
|
|
bRegCR3F |= ((BYTE)(dwFBOffset & 0x1E)) >> 1;
|
|
bRegCR3E = (BYTE)((dwFBOffset & 0x1FE0) >> 5);
|
|
bRegCR3A &= 0x80;
|
|
bRegCR3A |= ((BYTE)((dwFBOffset & 0xFE000) >> 13));
|
|
#endif /0 - bad ideal
|
|
//
|
|
/*
|
|
* Program the video window registers
|
|
*/
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x31 | (WORD)bRegCR31 << 8);//CR31
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x32 | (WORD)bRegCR32 << 8);//CR32
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x33 | (WORD)bRegCR33 << 8);//CR33
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x34 | (WORD)bRegCR34 << 8);//CR34
|
|
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x35 | (WORD)bRegCR35 << 8);//CR35
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x36 | (WORD)bRegCR36 << 8);//CR36
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x37 | (WORD)bRegCR37 << 8);//CR37
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x38 | (WORD)bRegCR38 << 8);//CR38
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x39 | (WORD)bRegCR39 << 8);//CR39
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3B | (WORD)bRegCR3B << 8);//CR3B
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3C | (WORD)bRegCR3C << 8);//CR3C
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3D | (WORD)bRegCR3D << 8);//CR3D
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x41 | (WORD)bRegCR41 << 8);//CR41
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x42 | (WORD)bRegCR42 << 8);//CR42
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x51 | (WORD)bRegCR51 << 8);//CR51
|
|
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x40 | (WORD)bRegCR40 << 8);//CR40
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3A | (WORD)bRegCR3A << 8);//CR3A
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3E | (WORD)bRegCR3E << 8);//CR3E
|
|
CP_OUT_WORD(ppdev->pjPorts, CRTC_INDEX, 0x3F | (WORD)bRegCR3F << 8);//CR3F
|
|
|
|
// enable overlay if overlay was totally clipped by pnning viewport
|
|
//
|
|
if (ppdev->dwPanningFlag & OVERLAY_OLAY_REENABLE)
|
|
EnableVideoWindow (ppdev);
|
|
}
|
|
#endif
|
|
//myf31 end
|
|
|
|
#endif // DirectDraw
|