{ 580, VIDDIV_PDIV_25 | (116 & VIDDIV_VDIV_MASK) },
    { 582, VIDDIV_PDIV_3  | ( 97 & VIDDIV_VDIV_MASK) },
    { 585, VIDDIV_PDIV_25 | (117 & VIDDIV_VDIV_MASK) },
    { 588, VIDDIV_PDIV_3  | ( 98 & VIDDIV_VDIV_MASK) },
    { 590, VIDDIV_PDIV_25 | (118 & VIDDIV_VDIV_MASK) },
    { 594, VIDDIV_PDIV_3  | ( 99 & VIDDIV_VDIV_MASK) },
    { 595, VIDDIV_PDIV_25 | (119 & VIDDIV_VDIV_MASK) },
    { 600, VIDDIV_PDIV_3  | (100 & VIDDIV_VDIV_MASK) },
    { 605, VIDDIV_PDIV_25 | (121 & VIDDIV_VDIV_MASK) },
    { 606, VIDDIV_PDIV_3  | (101 & VIDDIV_VDIV_MASK) },
    { 610, VIDDIV_PDIV_25 | (122 & VIDDIV_VDIV_MASK) },
    { 612, VIDDIV_PDIV_3  | (102 & VIDDIV_VDIV_MASK) },
    { 615, VIDDIV_PDIV_25 | (123 & VIDDIV_VDIV_MASK) },
    { 618, VIDDIV_PDIV_3  | (103 & VIDDIV_VDIV_MASK) },
    { 620, VIDDIV_PDIV_25 | (124 & VIDDIV_VDIV_MASK) },
    { 624, VIDDIV_PDIV_3  | (104 & VIDDIV_VDIV_MASK) },
    { 625, VIDDIV_PDIV_25 | (125 & VIDDIV_VDIV_MASK) },
    { 630, VIDDIV_PDIV_3  | (105 & VIDDIV_VDIV_MASK) },
    { 635, VIDDIV_PDIV_25 | (127 & VIDDIV_VDIV_MASK) },
    { 636, VIDDIV_PDIV_3  | (106 & VIDDIV_VDIV_MASK) },
    { 642, VIDDIV_PDIV_3  | (107 & VIDDIV_VDIV_MASK) },
    { 648, VIDDIV_PDIV_3  | (108 & VIDDIV_VDIV_MASK) },
    { 654, VIDDIV_PDIV_3  | (109 & VIDDIV_VDIV_MASK) },
    { 660, VIDDIV_PDIV_3  | (110 & VIDDIV_VDIV_MASK) },
    { 666, VIDDIV_PDIV_3  | (111 & VIDDIV_VDIV_MASK) },
    { 672, VIDDIV_PDIV_3  | (112 & VIDDIV_VDIV_MASK) },
    { 678, VIDDIV_PDIV_3  | (113 & VIDDIV_VDIV_MASK) },
    { 684, VIDDIV_PDIV_3  | (114 & VIDDIV_VDIV_MASK) },
    { 690, VIDDIV_PDIV_3  | (115 & VIDDIV_VDIV_MASK) },
    { 696, VIDDIV_PDIV_3  | (116 & VIDDIV_VDIV_MASK) },
    { 702, VIDDIV_PDIV_3  | (117 & VIDDIV_VDIV_MASK) },
    { 708, VIDDIV_PDIV_3  | (118 & VIDDIV_VDIV_MASK) },
    { 714, VIDDIV_PDIV_3  | (119 & VIDDIV_VDIV_MASK) },
    { 720, VIDDIV_PDIV_3  | (120 & VIDDIV_VDIV_MASK) },
    { 726, VIDDIV_PDIV_3  | (121 & VIDDIV_VDIV_MASK) },
    { 732, VIDDIV_PDIV_3  | (122 & VIDDIV_VDIV_MASK) },
    { 738, VIDDIV_PDIV_3  | (123 & VIDDIV_VDIV_MASK) },
    { 744, VIDDIV_PDIV_3  | (124 & VIDDIV_VDIV_MASK) },
    { 750, VIDDIV_PDIV_3  | (125 & VIDDIV_VDIV_MASK) },
    { 756, VIDDIV_PDIV_3  | (126 & VIDDIV_VDIV_MASK) },
    { 762, VIDDIV_PDIV_3  | (127 & VIDDIV_VDIV_MASK) }
};


//****************************************************************************
// CalculateClosestFreq
//****************************************************************************
// CalculateClosestFreq
// 
//   ulPLLFreq           -  PLL output Frequency (Mhz)
//   ulRequestedVidFreq  -  Requested Video Clock Frequency.
//   pulActualVideoFreq  -  Returned Actual Video Rate.
//   pulVidDiv           -  Video Divider register.
//
//   Return            0 - Failure
//                     1 - Success
//
static int CalculateClosestFreq
(
    ULONG   ulPLLFreq, 
    ULONG   ulRequestedVideoFreq,
    PULONG  pulActualVideoFreq,
    PULONG  pulVidDiv
)
{
    
    ULONG   ulLower;
    ULONG   ulUpper;
    ULONG   ulDiv;
    int     x;


    //
    // Calculate the closest divisor.
    //
    ulDiv =  (ulPLLFreq * 2)/ ulRequestedVideoFreq;

    for(x = 1; x < sizeof(VidDivTable)/sizeof(DIV_TABLE); x++)
    {

        //
        // Calculate the next greater and lower value.
        //
        ulLower = VidDivTable[x - 1].ulTotalDiv;     
        ulUpper = VidDivTable[x].ulTotalDiv;     

        //
        // Check to see if it is in between the two values.
        //
        if(ulLower <= ulDiv && ulDiv < ulUpper)
        {
            break;
        }
    }

    //
    // Return if we did not find a divisor.
    //
    if(x == sizeof(VidDivTable)/sizeof(DIV_TABLE))
    {
        *pulActualVideoFreq = 0;
        *pulVidDiv          = 0;
        return 0;
    }

    //
    // See which is closer, the upper or the lower case.
    //
    if(ulUpper * ulRequestedVideoFreq - ulPLLFreq * 2 >  
      ulPLLFreq * 2 - ulLower * ulRequestedVideoFreq)
    {
        x-=1;
    }
    *pulActualVideoFreq = (ulPLLFreq * 2)/ VidDivTable[x].ulTotalDiv;
    *pulVidDiv          = VidDivTable[x].ulVidDiv;
    return(1);
}


//****************************************************************************
// CRTVideoSetup
//****************************************************************************
//
//  ulWidth                 - Screen Width
//  ulHeight                - Screen Height 
//  ulColorDepth            - Color Depth
//  ulFrequency             - Refresh rate in Hertz.
//  ulPhysicalFramePointer  - Physical Address of the frame buffer.
//  pStartStop              - OUT Start Stop values for HSYNC.
//
// Here is the video setup for standard CRT monitiors.  Remember that the 
// horizontal sync must be at least 33Mhz and the refresh rate must be
// 60 Hz.
// 
//                                                       VSync---------+
//                                                                     |
//  |                                                                  V |
//  |                                                                |< >|
//  |            |                                         |             |
//  |<  VBlank  >|<---------- Screen Height--------------->|<  VBlank   >|
//  |    Start   |                                         |     End     |
//  |                                                                    |
//  |<----------------------- VLines Total ----------------------------->|
//
//
//                                                                       
//  |                   |                                                |
//  |<--HBlank Start--->|                                                |
//  |                   |                                  |             |
//  |           |       |                                  |             |
//  |<  HSync  >|       |<---------- Screen Width--------->|<  HBlank   >|
//  |           |       |                                  |     End     |
//  |                                                                    |
//  |<----------------------- HClocks Total ---------------------------->|
//
//
//  VBlankStart = 6.04  % of Screen Height
//  VBlankEnd   = 3.54 % of Screen Height
//  VSync       = .41 % of Screen Height
//
//  HBlankEnd   = 2.34 % of Screen Width
//  HBlankStart = 20.1 % of Screen Width
//  HSyncStart  = 15 % of Screen Width 
//
//
// These are the proportions of the windows.
//
#define     VBLANKSTART_SIZE     604
#define     VBLANKEND_SIZE       354
#define     VSYNC_SIZE           41
//#define     HBLANKEND_SIZE       234
//#define     HBLANKSTART_SIZE     2010
//#define     HSYNC_SIZE           1500
#define     HBLANKEND_SIZE        400
#define     HBLANKSTART_SIZE     4010
#define     HSYNC_SIZE           2000
#define     SIZE_DIVISOR         10000


void CRTVideoSetup
(
    ULONG           ulWidth, 
    ULONG           ulHeight, 
    ULONG           ulColorDepth, 
    ULONG           ulFrequency, 
    ULONG           ulPhysicalFramePointer,
    StartStop *     pStartStop
)
{

    ULONG   ulVStartBlankSize;
    ULONG   ulVEndBlankSize;
    ULONG   ulVSyncSize;
    ULONG   ulVLinesTotal;
    ULONG   ulHStartBlankSize;
    ULONG   ulHEndBlankSize;
    ULONG   ulHSyncSize;
    ULONG   ulHClocksTotal;
    
    ULONG   ulVBlankStart;
    ULONG   ulVBlankStop;
    ULONG   ulVSyncStart;
    ULONG   ulVSyncStop;
    ULONG   ulHBlankStart;
    ULONG   ulHBlankStop;
    ULONG   ulHSyncStart;
    ULONG   ulHSyncStop;
    ULONG   ulVidDiv, ulVid1Div, ulVid2Div;
    ULONG   ulVid1Freq, ulVid2Freq;
    ULONG   ulRequestedVideoFreq;
    ULONG   ulTemp;

    ulTemp = *GPIO_PADDR;
    *GPIO_PADDR = ulTemp | 0x2;

    ulTemp = *GPIO_PADR;
    *GPIO_PADR = ulTemp | 0x2;

        
    //
    // Calculate the sizes of each of the blocks in pixels
    //
    ulVStartBlankSize   = (VBLANKSTART_SIZE * ulHeight) / SIZE_DIVISOR;
    ulVEndBlankSize     = (VBLANKEND_SIZE * ulHeight) / SIZE_DIVISOR;
    ulVSyncSize         = 1 + (VSYNC_SIZE * ulHeight) / SIZE_DIVISOR;
    ulVLinesTotal       = ulVStartBlankSize + ulVEndBlankSize + ulHeight;
    ulHStartBlankSize   = (HBLANKSTART_SIZE * ulWidth) / SIZE_DIVISOR;
    ulHEndBlankSize     = (HBLANKEND_SIZE * ulWidth) / SIZE_DIVISOR;
    ulHSyncSize         = (HSYNC_SIZE * ulWidth) / SIZE_DIVISOR;
    ulHClocksTotal      = ulHStartBlankSize + ulHEndBlankSize + ulWidth;

    //
    // Calculate the starting and stoping pointer for each in the frame.
    //
    pStartStop->ulVActiveStop   = ulVEndBlankSize;
    pStartStop->ulVActiveStart  = ulVEndBlankSize + ulHeight;
    pStartStop->ulHActiveStop   = ulHEndBlankSize;
    pStartStop->ulHActiveStart  = ulHEndBlankSize + ulWidth;
    ulVBlankStop                = ulVEndBlankSize;
    ulVBlankStart               = ulVEndBlankSize + ulHeight;
    ulVSyncStart                = ulVSyncSize;
    ulVSyncStop                 = 0;
    ulHBlankStop                = ulHEndBlankSize;
    ulHBlankStart               = ulHEndBlankSize + ulWidth;
    ulHSyncStop                 = ulHClocksTotal - ulHSyncSize;
    ulHSyncStart                = ulHClocksTotal;


    //
    // Change to Raster on P3.
    //
    HalWriteCommonReg(CSC_DEVCFG, DEVCFG_RAS | DEVCFG_RASONP3, DEVCFG_RASONP3);

    ulRequestedVideoFreq = ( ulFrequency * ulHClocksTotal * ulVLinesTotal);

    CalculateClosestFreq
    (
        PLL1_CLOCK, 
        ulRequestedVideoFreq,
        &ulVid1Freq,
        &ulVid1Div
    );
    CalculateClosestFreq
    (
        PLL2_CLOCK, 
        ulRequestedVideoFreq,
        &ulVid2Freq,
        &ulVid2Div
    );

    //
    // See which is closer, Video rate 1 or video rate 2.
    //
    if(abs(ulVid1Freq - ulRequestedVideoFreq) <abs(ulVid2Freq -ulRequestedVideoFreq))
    {
        ulVidDiv =ulVid1Div;
    }
    else
    {
        ulVidDiv =ulVid2Div | VIDDIV_PSEL;
    }
    

    HalWriteCommonReg(CSC_VIDDIV, 0xFFFFFFFF, VIDDIV_VENA | VIDDIV_ESEL | ulVidDiv);

    *RASTER_REALITI_SWLOCK   = 0xaa;
    *RASTER_VLINESTOTAL      = ulVLinesTotal;
    ASSERT(ulVLinesTotal <VLINESTOTAL_MASK);

    *RASTER_REALITI_SWLOCK   = 0xaa;
    *RASTER_VSYNCSTRTSTOP    = (ulVSyncStart<<RASTER_START_SHIFT) | (ulVSyncStop<<RASTER_STOP_SHIFT);

    *RASTER_REALITI_SWLOCK   = 0xaa;
    *RASTER_VBLANKSTRTSTOP   = (ulVBlankStart<<RASTER_START_SHIFT) | (ulVBlankStop<<RASTER_STOP_SHIFT);

    *RASTER_REALITI_SWLOCK   = 0xaa;
    *RASTER_VACTIVESTRTSTOP  = ( pStartStop->ulVActiveStart<<RASTER_START_SHIFT) | 
                               ( pStartStop->ulVActiveStop<<RASTER_STOP_SHIFT);