archive
/
windows-nt-4.0
mirror of https://github.com/lianthony/NT4.0
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Windows NT 4.0 source code leak
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2 Commits
1 Branch
0 Tags
184 MiB
 
 
 
 
 
 
Tree: b4a8d373d8
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'b4a8d373d8'
${ noResults }
windows-nt-4.0/private/ntos/video/mga_mil/mtxinit.c

835 lines
21 KiB
Raw Blame History

/**************************************************************************\
$Header: o:\src/RCS/MTXINIT.C 1.2 95/07/07 06:16:33 jyharbec Exp $
$Log: MTXINIT.C $
* Revision 1.2 95/07/07 06:16:33 jyharbec
* *** empty log message ***
*
* Revision 1.1 95/05/02 05:16:31 jyharbec
* Initial revision
*
\**************************************************************************/
/*/****************************************************************************
* name: mtxinit.c
*
* description: Routines to initialise MGA board
*
* designed: Benoit Leblanc , dec '94
* last modified: $Author: jyharbec $, $Date: 95/07/07 06:16:33 $
*
* version: $Id: MTXINIT.C 1.2 95/07/07 06:16:33 jyharbec Exp $
*
* HwData * mtxCheckHwAll(void)
* bool mtxSelectHw(HwData *pHardware)
* HwModeData * mtxGetHwModes(void)
* bool mtxSelectHwMode(HwModeData *pHwModeSelect)
* bool mtxSetDisplayMode(HwModeData *pDisplayModeSelect, dword Zoom)
* dword mtxGetMgaSel(void)
* void mtxGetInfo(HwModeData *pCurHwMode, HwModeData *pCurDispMode,
* byte *InitBuffer, byte *VideoBuffer)
* bool mtxSetLUT(word index, mtxRGB color)
* void mtxClose(void)
*
******************************************************************************/
#include "switches.h"
#ifdef MGA_DEBUG
#include <stdio.h>
#endif
#ifdef WIN31
#include "windows.h"
#endif
#include "defbind.h"
#include "bind.h"
#include "mga.h"
#include "def.h"
#include "mgai.h"
#include "edid.h"
#include "mtxpci.h"
#ifdef WINDOWS_NT
#include "ntmga.h"
#if defined(ALLOC_PRAGMA)
#pragma alloc_text(PAGE,mtxCheckHwAll)
#pragma alloc_text(PAGE,mtxSelectHw)
#pragma alloc_text(PAGE,mtxGetHwModes)
#pragma alloc_text(PAGE,mtxSelectHwMode)
#pragma alloc_text(PAGE,mtxSetDisplayMode)
#pragma alloc_text(PAGE,mtxGetInfo)
#pragma alloc_text(PAGE,mtxSetLUT)
#pragma alloc_text(PAGE,mtxClose)
#endif
#endif /* #ifdef WINDOWS_NT */
/*** GLOBAL VARIABLES ***/
volatile byte _FAR *pMGA;
HwData Hw[NB_BOARD_MAX+1];
byte NbBoard=0; /* total board detected */
byte iBoard=0; /* index of current selected board */
bool CheckHwAllDone=FALSE;
dword ProductMGA[NB_BOARD_MAX];
word mtxVideoMode;
char *fileEmu;
char *mgainf = (char *)0;
dword _FAR *BufBind;
SYSPARMS *sp;
HwModeData *HwModes[NB_BOARD_MAX];
OffScrData *OffScr[NB_BOARD_MAX];
byte InitBuf[NB_BOARD_MAX][INITBUF_S] = {0};
byte VideoBuf[NB_BOARD_MAX][VIDEOBUF_S] = {0};
bool interleave_mode;
dword BindingRC[NB_BOARD_MAX];
dword BindingCL[NB_BOARD_MAX];
dword MgaSel;
dword PresentMCLK;
extern byte ChooseDDC;
#ifdef WINDOWS_NT
extern PEXT_HW_DEVICE_EXTENSION pExtHwDeviceExtension;
extern PMGA_DEVICE_EXTENSION pMgaDevExt;
#else /* #ifdef WINDOWS_NT */
dword Val55mSec;
extern pciInfoDef pciInfo[];
#endif /* #ifdef WINDOWS_NT */
#ifdef WIN31
HINSTANCE hsxci=0;
typedef long (FAR PASCAL *FARPROC2)();
static FARPROC2 fp1;
word NbSxciLoaded=0;
int _FAR pascal LibMain(HANDLE hInstance, WORD wDataSeg, WORD wHeapSize, LPSTR lpszCmdLine)
{
if (wHeapSize > 0)
UnlockData(0);
return 1;
}
#endif
/*** PROTOTYPES ***/
#ifndef WINDOWS_NT
void removeBoard(word idx1);
#endif
extern bool MapBoard(void);
extern bool FillHwDataStruct(HwData *pHwData, byte Board);
extern void FillInitBuf(byte *pBuf, HwModeData *pHwMode);
extern void AllocInternalResource(byte Board);
#ifndef WINDOWS_NT
extern dword EvaluateTick(void);
#endif
extern void delay_us(dword delai);
extern void WriteErr(char string[]);
#ifndef WINDOWS_NT
extern bool ReadMgaInf(void);
#endif
extern void ScreenOn(void);
extern void ScreenOff(void);
extern void MGAVidInit(byte* pInitBuffer, byte* pVideoBuffer);
extern void MGASysInit(byte* pInitBuffer);
extern bool ProgSystemClock(byte Board);
extern bool BuildTables(byte Board);
extern bool calculCrtcParam(HwModeData *HwMode, HwModeData *DisplayMode,
dword Zoom, byte *pVideoBuf);
extern void UpdateHwModeTable(byte Board);
extern void ResetWRAM(void);
extern word FindPanXGranul(void);
#if( !defined(WIN31) && !defined(OS2) && !defined(WINDOWS_NT) )
extern byte* CaddiInit(byte *InitBuffer, byte *VideoBuffer);
extern void CaddiReInit(byte *InitBuffer, byte *VideoBuffer);
#endif
#ifdef WIN31
extern DWORD far *setmgasel (DWORD far *pBoardSel, DWORD dwBaseAddress,
WORD wNumPages);
#else
extern volatile byte _FAR *setmgasel(dword MgaSel, dword phyadr, dword limit);
#endif
#ifndef WINDOWS_NT
/*---------------------------------------------------------------------------
| name: mtxCheckHwAll
|
| description: Find and initialise each MGA board in the system
|
| parameters: -
|
| calls: EvaluateTick()
| MapBoard()
| ReadMgaInf()
| mtxSelectHw()
| FillHwDataStruct()
| BuildTables()
| ProgSystemClock()
| AllocInternalResource()
|
| returns: HwData * > 0: Pointer on HwData structure
| HwData = 0 : Error ; No MGA device found
|
----------------------------------------------------------------------------*/
HwData * mtxCheckHwAll(void)
{
byte Board, remBoard;
byte tmpByte;
bool desacBoard;
WriteErr("No error\n");
#ifdef MGA_DEBUG
{
FILE *fp;
fp = fopen("c:\\debug.log", "w");
fprintf(fp, "DEBUT mtxCheckHwAll:\n\n");
fclose(fp);
fp = fopen("c:\\modes.log", "w");
fprintf(fp, "DEBUT HwModes:\n\n");
fclose(fp);
}
#endif
if (! CheckHwAllDone)
{
Val55mSec = EvaluateTick();
#ifdef MGA_DEBUG
{
FILE *fp;
fp = fopen("c:\\debug.log", "a");
fprintf(fp, "Val55mSec = %ld\n\n", Val55mSec);
fclose(fp);
}
#endif
NbBoard = MapBoard();
if (NbBoard == 0)
{
WriteErr("mtxGetHwModes: No MGA device\n");
return(mtxFAIL);
}
}
if (! ReadMgaInf())
{
WriteErr("ReadMgaInf: Error\n");
return(mtxFAIL);
}
desacBoard = FALSE;
/* Initialize Hw[] structure for each board */
for (Board=0; Board<NbBoard; Board++)
{
iBoard = Board;
if (! mtxSelectHw(&Hw[Board]))
return(mtxFAIL);
/** Because of a MicroStation bug (blank window's screen when called
in a DOS box), we read a ramdac register to see if it has been
process before. (ex: by mtxSetDisplayMode).
If it's the case, we don't do this destructive sequence. ***/
/** if board has been programmed, bit nogscale = 1 **/
pciReadConfigByte( PCI_OPTION+2, &tmpByte);
if ( !(tmpByte&0x20) )
ResetWRAM();
if( FillHwDataStruct(&Hw[Board], Board) )
{
if(! ProgSystemClock(Board))
return(mtxFAIL);
if (! CheckHwAllDone)
{
if (! BuildTables(Board))
return(mtxFAIL);
}
UpdateHwModeTable(Board);
#if( !defined(WIN31) && !defined(OS2) && !defined(WINDOWS_NT) )
/* To set pMgaBaseAddr (in CADDI) before calling AllocInternalResource */
/* Set segment and offset for CaddiReInit in mtxSelectHw */
FillInitBuf(InitBuf[Board], HwModes[0]);
/* InitDefaultRC must be called at this point before doing
INITRC in mtxAllocRC in AllocInternalResource ***/
sp = (SYSPARMS *)CaddiInit(InitBuf[iBoard], VideoBuf[iBoard]);
AllocInternalResource(Board);
#endif
}
else
{
remBoard = Board;
desacBoard = TRUE;
}
}
if(desacBoard)
removeBoard(remBoard);
/* Verify the DDC capability and modify the HwModes */
if(ChooseDDC)
CheckDDC(&Hw[0]);
CheckHwAllDone = TRUE;
return(&Hw[0]);
}
#endif /* #ifndef WINDOWS_NT */
/*---------------------------------------------------------------------------
| name: mtxSelectHw
|
| description: Select the MGA device to be used for subsequent drawing
| operations.
| Build a pointer from the base address and the selector
|
| parameters: Pointer to an HwData structure
|
| calls: setmgasel()
| CaddiReInit()
|
| returns: mtxOK : Hardware select successful
| mtxFAIL : Hardware select failure
----------------------------------------------------------------------------*/
bool mtxSelectHw(HwData *pHardware)
{
HwData *pScanHwData;
bool FlagFoundHwData;
/*** VALIDATE pHardware and set iBoard ***/
FlagFoundHwData = FALSE;
iBoard = 0;
for (pScanHwData = &Hw[0]; pScanHwData->MapAddress != (dword)-1;
pScanHwData++, iBoard++)
{
if (pScanHwData == pHardware)
{
FlagFoundHwData = TRUE;
break;
}
}
if (! FlagFoundHwData)
{
WriteErr("mtxSelectHw: Can't find selected board in HwData[]\n");
return(mtxFAIL);
}
#if defined(WINDOWS_NT)
pMGA = Hw[iBoard].BaseAddress1;
pExtHwDeviceExtension = pMgaDevExt->HwDevExtToUse[iBoard];
#elif defined(WIN31)
pMGA = (volatile byte _FAR *)setmgasel(
(DWORD far *)MgaSel,
(DWORD)Hw[iBoard].MapAddress,
(WORD)4);
#else
pMGA = setmgasel(MgaSel, Hw[iBoard].MapAddress, 4);
#endif
#if( !defined(WIN31) && !defined(OS2) && !defined(WINDOWS_NT) )
if(CheckHwAllDone)
CaddiReInit(InitBuf[iBoard], VideoBuf[iBoard]);
#endif
return(mtxOK);
}
/*---------------------------------------------------------------------------
| name: mtxGetHwModes
|
| description: This function returns a pointer to a list of hardware
| modes available for the current MGA device
| as selected by mtxSelectHw()
|
| parameters: -
| calls: -
| returns: HwModes = 0 : MGA device not found
| HwModes != 0 : Pointer to HwModes array
----------------------------------------------------------------------------*/
HwModeData *mtxGetHwModes(void)
{
return(HwModes[iBoard]);
}
/*---------------------------------------------------------------------------
| name: mtxSelectHwMode
|
| description: Select a hardware mode from the list returned by
| mtxGetHwModes()
|
| parameters: Pointer on HwModeData structure
|
| modifies: -
| calls:
| mtxSetVideoMode()
| FillInitBuf()
| MGASysInit()
|
| returns: mtxOK : HwMode select successfull
| mtxFAIL : HwMode select failure
----------------------------------------------------------------------------*/
bool mtxSelectHwMode(HwModeData *pHwModeSelect)
{
bool FlagFindMode;
HwModeData *pScanHwMode;
/*** Special case for STORM: for system clock = 40MHz, no 3D in ***/
/*** 1280x1024x32 ***/
if(PresentMCLK <= 40000000 && pHwModeSelect->ZBuffer &&
pHwModeSelect->DispWidth == 1280 && pHwModeSelect->PixWidth == 32)
{
WriteErr("mtxSelectHwMode: no 3D in 1280x1024/32 for clock <= 40MHz\n");
return(mtxFAIL);
}
FlagFindMode = FALSE;
for ( pScanHwMode = HwModes[iBoard]; pScanHwMode->DispWidth != (word)-1;
pScanHwMode++)
{
if (pScanHwMode == pHwModeSelect)
{
FlagFindMode = TRUE;
break;
}
}
if (NbBoard == 0 || FlagFindMode == FALSE)
{
WriteErr("mtxSelectHwMode: Can't find HwMode in HwModes table\n");
return(mtxFAIL);
}
/*** Soft reset added because of bugs with screen saver 3d ***/
mgaWriteBYTE(*(pMGA+STORM_OFFSET + STORM_RST), 0x01);
delay_us(250);
mgaWriteBYTE(*(pMGA+STORM_OFFSET + STORM_RST), 0x00);
#ifdef MGA_DEBUG
{
FILE *fp;
fp = fopen("c:\\debug.log", "a");
fprintf(fp, "mtxSelectHwMode: %d x %d x %d\n\n",
pHwModeSelect->DispWidth, pHwModeSelect->DispHeight,
pHwModeSelect->PixWidth);
fclose(fp);
}
#endif
/*** We must force Hi-Res mode in case were applications don't call ***/
/*** mtxSetVideoMode before mtxSelectHwMode ***/
Hw[iBoard].pCurrentHwMode = NULL;
Hw[iBoard].pCurrentDisplayMode = NULL;
mtxSetVideoMode(mtxADV_MODE);
Hw[iBoard].pCurrentHwMode = pHwModeSelect;
MGASysInit(InitBuf[iBoard]);
FillInitBuf(InitBuf[iBoard], pHwModeSelect);
/*----- Program YDSTORG -----*/
mgaWriteDWORD(*(pMGA + STORM_OFFSET + STORM_YDSTORG),
*((dword*)(InitBuf[iBoard] + INITBUF_YDSTORG)));
Hw[iBoard].CurrentYDstOrg = *((dword*)(InitBuf[iBoard] + INITBUF_YDSTORG));
#if( !defined(WIN31) && !defined(OS2) && !defined(WINDOWS_NT) )
CaddiReInit(InitBuf[iBoard], VideoBuf[iBoard]);
#endif
return(mtxOK);
}
/*---------------------------------------------------------------------------
| name: mtxSetDisplayMode
|
| description: Select a display mode from the list returned by
| mtxGetHwModes()
|
| parameters: - Pointer on a HwModeData structure
| - Zoom (ex: 0x00010001)
|
| calls:
| ScreenOn()
| ScreenOff()
| mtxSetVideoMode()
| calculCrtcParam()
| MGAVidInit()
|
| returns: mtxOK : Display mode select successfull
| mtxFAIL : Display mode select failure
----------------------------------------------------------------------------*/
bool mtxSetDisplayMode(HwModeData *pDisplayModeSelect, dword Zoom)
{
if (Hw[iBoard].pCurrentHwMode == NULL)
{
WriteErr("mtxSetDisplayMode: CurrentHwMode not valid\n");
return(mtxFAIL);
}
/* Validate Display mode to see if it is <= Hard Mode */
if (pDisplayModeSelect->DispWidth > Hw[iBoard].pCurrentHwMode->DispWidth)
{
WriteErr("mtxSetDisplayMode: DisplayMode > HwMode\n");
return(mtxFAIL);
}
/* Validate pDisplayModeSelect to see if it is displayable */
if (pDisplayModeSelect->DispType & DISP_NOT_SUPPORT)
{
WriteErr("mtxSetDisplayMode: DisplayMode not displayable\n");
return(mtxFAIL);
}
ScreenOff();
/*** We must force Hi-Res mode in case were applications don't call ***/
/*** mtxSetVideoMode after they come back from VGA mode ***/
Hw[iBoard].pCurrentDisplayMode = NULL;
mtxSetVideoMode(mtxADV_MODE);
Hw[iBoard].pCurrentDisplayMode = pDisplayModeSelect;
Hw[iBoard].CurrentZoomFactor = Zoom;
Hw[iBoard].CurrentPanXGran = FindPanXGranul();
Hw[iBoard].CurrentPanYGran = 1;
/*** Load and calculate video parameters (CRTC registers) ***/
if(! calculCrtcParam(Hw[iBoard].pCurrentHwMode,
Hw[iBoard].pCurrentDisplayMode,
Zoom, VideoBuf[iBoard]))
return(mtxFAIL);
MGAVidInit(InitBuf[iBoard], VideoBuf[iBoard]);
#if( !defined(WIN31) && !defined(OS2) && !defined(WINDOWS_NT) )
CaddiReInit(InitBuf[iBoard], VideoBuf[iBoard]);
#endif
#ifdef WIN31
if(NbSxciLoaded)
{
fp1 = (FARPROC2)GetProcAddress(hsxci, "Win386LibEntry");
(*fp1)((byte _FAR *)InitBuf[iBoard], (byte _FAR *)VideoBuf[iBoard],
Hw[iBoard].pCurrentHwMode->FbPitch, ID_CallCaddiInit);
}
#endif
ScreenOn();
#if( !defined(WIN31) && !defined(OS2) && !defined(WINDOWS_NT))
mtxScClip(0, 0, pDisplayModeSelect->DispWidth-1, pDisplayModeSelect->DispHeight-1);
#endif
return(mtxOK);
}
#ifndef WINDOWS_NT
/*---------------------------------------------------------------------------
| name: mtxGetMgaSel
|
| description: Return the selector
| parameters: -
| calls: -
| returns: selector
----------------------------------------------------------------------------*/
dword mtxGetMgaSel(void)
{
return(Hw[iBoard].MapAddress);
}
#endif /* #ifndef WINDOWS_NT */
/*---------------------------------------------------------------------------
| name: mtxGetInfo
|
| description: Return usefull informations
|
| parameters: - Current hardware mode
| - Current display mode
| - Init buffer
| - Video buffer
| returns: -
----------------------------------------------------------------------------*/
void mtxGetInfo(HwModeData **pCurHwMode, HwModeData **pCurDispMode, byte **InitBuffer, byte **VideoBuffer)
{
*pCurHwMode = Hw[iBoard].pCurrentHwMode;
*pCurDispMode = Hw[iBoard].pCurrentDisplayMode;
*InitBuffer = InitBuf[iBoard];
*VideoBuffer = VideoBuf[iBoard];
}
/*---------------------------------------------------------------------------
| name: mtxSetLUT
|
| description: Initialise ramdac LUT
|
| parameters: - index of the LUT
| - color
|
| calls: -
| returns: - mtxOK - successfull
| mtxFAIL - failed (not in a LUT mode)
----------------------------------------------------------------------------*/
bool mtxSetLUT(word index, mtxRGB color)
{
if(! (Hw[iBoard].pCurrentHwMode->DispType & MODE_LUT))
{
WriteErr("mtxSetLUT: must be a LUT mode\n");
return mtxFAIL;
}
switch(Hw[iBoard].EpromData.RamdacType>>8)
{
case TVP3026:
case TVP3030:
dacWriteBYTE(TVP3026_WADR_PAL, (byte)index);
dacWriteBYTE(TVP3026_COL_PAL, (byte)color);
dacWriteBYTE(TVP3026_COL_PAL, (byte)(color >> 8));
dacWriteBYTE(TVP3026_COL_PAL, (byte)(color >> 16));
break;
default:
WriteErr("mtxSetLUT: Wrong DacType\n");
return mtxFAIL;
}
return mtxOK;
}
/*---------------------------------------------
* mtxClose
* Supported for compatibility. Nothing done
*---------------------------------------------*/
void mtxClose(void)
{
}
#ifndef WINDOWS_NT
/*---------------------------------------------------------------------------
| name: removeBoard
|
| description: Remove definition of on-board STORM
| Pack array
|
| parameters: - idx: index of the board to remove
| calls: -
| returns: -
----------------------------------------------------------------------------*/
void removeBoard(word idx1)
{
byte _FAR *pDest;
byte _FAR *pSource;
word i, index;
word nb;
/*** PACK HWDATA STRUCTURE ***/
/*** Copy HwData fields from one place to another ***/
for(index=idx1 ; index<NbBoard; index++)
{
pDest = (byte _FAR *)&Hw[index];
pSource = (byte _FAR *)&Hw[index+1];
if( Hw[index+1].StructLength == (word)-1 )
{
Hw[index].StructLength = (word)-1;
Hw[index].MapAddress = (dword)-1;
}
else
{
for(i=0; i<Hw[index+1].StructLength; i++)
{
*pDest = *pSource;
pDest++;
pSource++;
}
}
}
/*** PACK PCIINFO STRUCTURE ***/
/*** Copy pciInfo fields from one place to another ***/
for(index=idx1 ; index < (NbBoard-1); index++)
{
nb = sizeof(pciInfoDef);
pDest = (byte _FAR *)&pciInfo[index];
pSource = (byte _FAR *)&pciInfo[index+1];
for(i=0; i<nb; i++)
{
*pDest = *pSource;
pDest++;
pSource++;
}
}
for(index=idx1; index < NbBoard; index++)
HwModes[index] = HwModes[index+1];
for(index=idx1; index < (NbBoard-1); index++)
{
OffScr[index] = OffScr[index+1];
ProductMGA[index] = ProductMGA[index+1];
BindingRC[index] = BindingRC[index+1];
BindingCL[index] = BindingCL[index+1];
for(i=0; i< INITBUF_S; i++)
InitBuf[index][i] = InitBuf[index+1][i];
}
NbBoard--;
}
#endif /* #ifndef WINDOWS_NT */
#ifdef WINDOWS_NT
/*---------------------------------------------------------------------------
| name: mtxCheckHwAll
|
| description: initialize clock and mode tables
|
| returns: HwData * > 0: Pointer on HwData structure
| HwData = 0 : Error ; No MGA device found
|
----------------------------------------------------------------------------*/
HwData * mtxCheckHwAll(void)
{
byte Board;
/* Initialize clock and mode tables for each board. */
for (Board = 0; Board < NbBoard; Board++)
{
if (!mtxSelectHw(&Hw[Board]))
return(mtxFAIL);
if (!ProgSystemClock(Board))
return(mtxFAIL);
if (HwModes[Board] == NULL)
{
// We haven't built our table for this mode yet.
if (!BuildTables(Board))
return(mtxFAIL);
}
UpdateHwModeTable(Board);
}
#ifndef DONT_USE_DDC
/* Verify the DDC capability and modify the HwModes */
if(ChooseDDC)
CheckDDC(&Hw[0]);
#endif /* #ifndef DONT_USE_DDC */
for (Board = 0; Board < NbBoard; Board++)
{
if ((Hw[Board].VGAEnable == 0) &&
(mtxSelectHw(&Hw[Board])))
{
// Board is VGA-disabled and could be selected. Turn off sync
// so that any garbage in WRAM won't show. Sync will be
// restored if the board is required later.
ScreenOff();
}
}
CheckHwAllDone = TRUE;
return(&Hw[0]);
}
#endif /* #ifdef WINDOWS_NT */