drivers/staging/xgifb/vb_init.c

   1 #include "osdef.h"
   2 #include "vgatypes.h"
   3
   4 #include <linux/version.h>
   5 #include <linux/types.h>
   6 #include <linux/delay.h> /* udelay */
   7 #include "XGIfb.h"
   8
   9 #include "vb_def.h"
  10 #include "vb_struct.h"
  11 #include "vb_util.h"
  12 #include "vb_setmode.h"
  13 #include "vb_init.h"
  14 #include "vb_ext.h"
  15
  16
  17 #include <asm/io.h>
  18
  19
  20
  21
  22 UCHAR    XGINew_ChannelAB,XGINew_DataBusWidth;
  23
  24 USHORT XGINew_DRAMType[17][5]={{0x0C,0x0A,0x02,0x40,0x39},{0x0D,0x0A,0x01,0x40,0x48},
  25                      {0x0C,0x09,0x02,0x20,0x35},{0x0D,0x09,0x01,0x20,0x44},
  26                      {0x0C,0x08,0x02,0x10,0x31},{0x0D,0x08,0x01,0x10,0x40},
  27                      {0x0C,0x0A,0x01,0x20,0x34},{0x0C,0x09,0x01,0x08,0x32},
  28                      {0x0B,0x08,0x02,0x08,0x21},{0x0C,0x08,0x01,0x08,0x30},
  29                      {0x0A,0x08,0x02,0x04,0x11},{0x0B,0x0A,0x01,0x10,0x28},
  30                      {0x09,0x08,0x02,0x02,0x01},{0x0B,0x09,0x01,0x08,0x24},
  31                      {0x0B,0x08,0x01,0x04,0x20},{0x0A,0x08,0x01,0x02,0x10},
  32                      {0x09,0x08,0x01,0x01,0x00}};
  33
  34 USHORT XGINew_SDRDRAM_TYPE[13][5]=
  35 {
  36 { 2,12, 9,64,0x35},
  37 { 1,13, 9,64,0x44},
  38 { 2,12, 8,32,0x31},
  39 { 2,11, 9,32,0x25},
  40 { 1,12, 9,32,0x34},
  41 { 1,13, 8,32,0x40},
  42 { 2,11, 8,16,0x21},
  43 { 1,12, 8,16,0x30},
  44 { 1,11, 9,16,0x24},
  45 { 1,11, 8, 8,0x20},
  46 { 2, 9, 8, 4,0x01},
  47 { 1,10, 8, 4,0x10},
  48 { 1, 9, 8, 2,0x00}
  49 };
  50
  51 USHORT XGINew_DDRDRAM_TYPE[4][5]=
  52 {
  53 { 2,12, 9,64,0x35},
  54 { 2,12, 8,32,0x31},
  55 { 2,11, 8,16,0x21},
  56 { 2, 9, 8, 4,0x01}
  57 };
  58 USHORT XGINew_DDRDRAM_TYPE340[4][5]=
  59 {
  60 { 2,13, 9,64,0x45},
  61 { 2,12, 9,32,0x35},
  62 { 2,12, 8,16,0x31},
  63 { 2,11, 8, 8,0x21}
  64 };
  65 USHORT XGINew_DDRDRAM_TYPE20[12][5]=
  66 {
  67 { 2,14,11,128,0x5D},
  68 { 2,14,10,64,0x59},
  69 { 2,13,11,64,0x4D},
  70 { 2,14, 9,32,0x55},
  71 { 2,13,10,32,0x49},
  72 { 2,12,11,32,0x3D},
  73 { 2,14, 8,16,0x51},
  74 { 2,13, 9,16,0x45},
  75 { 2,12,10,16,0x39},
  76 { 2,13, 8, 8,0x41},
  77 { 2,12, 9, 8,0x35},
  78 { 2,12, 8, 4,0x31}
  79 };
  80
  81 void     XGINew_SetDRAMSize_340(PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO);
  82 void     XGINew_SetDRAMSize_310(PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO);
  83 void     XGINew_SetMemoryClock(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO );
  84 void     XGINew_SetDRAMModeRegister(PVB_DEVICE_INFO );
  85 void     XGINew_SetDRAMModeRegister340( PXGI_HW_DEVICE_INFO HwDeviceExtension );
  86 void     XGINew_SetDRAMDefaultRegister340(PXGI_HW_DEVICE_INFO HwDeviceExtension, ULONG, PVB_DEVICE_INFO );
  87 UCHAR    XGINew_GetXG20DRAMType( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo);
  88 BOOLEAN  XGIInitNew( PXGI_HW_DEVICE_INFO HwDeviceExtension) ;
  89
  90 int      XGINew_DDRSizing340( PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO );
  91 void     XGINew_DisableRefresh( PXGI_HW_DEVICE_INFO ,PVB_DEVICE_INFO) ;
  92 void     XGINew_CheckBusWidth_310( PVB_DEVICE_INFO) ;
  93 int      XGINew_SDRSizing(PVB_DEVICE_INFO);
  94 int      XGINew_DDRSizing( PVB_DEVICE_INFO );
  95 void     XGINew_EnableRefresh( PXGI_HW_DEVICE_INFO, PVB_DEVICE_INFO);
  96 int      XGINew_RAMType;                  /*int      ModeIDOffset,StandTable,CRT1Table,ScreenOffset,REFIndex;*/
  97 ULONG    UNIROM;                          /* UNIROM */
  98 BOOLEAN  ChkLFB( PVB_DEVICE_INFO );
  99 void     XGINew_Delay15us(ULONG);
 100 void     SetPowerConsume (PXGI_HW_DEVICE_INFO HwDeviceExtension,ULONG XGI_P3d4Port);
 101 void     ReadVBIOSTablData( UCHAR ChipType , PVB_DEVICE_INFO pVBInfo);
 102 void     XGINew_DDR1x_MRS_XG20( ULONG P3c4 , PVB_DEVICE_INFO pVBInfo);
 103 void     XGINew_SetDRAMModeRegister_XG20( PXGI_HW_DEVICE_INFO HwDeviceExtension );
 104 void     XGINew_SetDRAMModeRegister_XG27( PXGI_HW_DEVICE_INFO HwDeviceExtension );
 105 void     XGINew_ChkSenseStatus ( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo ) ;
 106 void     XGINew_SetModeScratch ( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo ) ;
 107 void     XGINew_GetXG21Sense(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo) ;
 108 UCHAR    GetXG21FPBits(PVB_DEVICE_INFO pVBInfo);
 109 void     XGINew_GetXG27Sense(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo) ;
 110 UCHAR    GetXG27FPBits(PVB_DEVICE_INFO pVBInfo);
 111
 112 void DelayUS(ULONG MicroSeconds)
 113 {
 114         udelay(MicroSeconds);
 115 }
 116
 117
 118 /* --------------------------------------------------------------------- */
 119 /* Function : XGIInitNew */
 120 /* Input : */
 121 /* Output : */
 122 /* Description : */
 123 /* --------------------------------------------------------------------- */
 124 BOOLEAN XGIInitNew( PXGI_HW_DEVICE_INFO HwDeviceExtension )
 125 {
 126
 127     VB_DEVICE_INFO VBINF;
 128     PVB_DEVICE_INFO pVBInfo = &VBINF;
 129     UCHAR   i , temp = 0 , temp1 ;
 130      //       VBIOSVersion[ 5 ] ;
 131     PUCHAR  volatile pVideoMemory;
 132
 133     /* ULONG j, k ; */
 134
 135     PXGI_DSReg pSR ;
 136
 137     ULONG Temp ;
 138
 139     pVBInfo->ROMAddr = HwDeviceExtension->pjVirtualRomBase ;
 140
 141     pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress ;
 142
 143     pVBInfo->BaseAddr = (ULONG)HwDeviceExtension->pjIOAddress ;
 144
 145     pVideoMemory = ( PUCHAR )pVBInfo->ROMAddr;
 146
 147
 148 //    Newdebugcode( 0x99 ) ;
 149
 150
 151    /* if ( pVBInfo->ROMAddr == 0 ) */
 152    /* return( FALSE ) ; */
 153
 154     if ( pVBInfo->FBAddr == 0 )
 155 {
 156        printk("\n pVBInfo->FBAddr == 0 ");
 157        return( FALSE ) ;
 158 }
 159 printk("1");
 160     if ( pVBInfo->BaseAddr == 0 )
 161 {
 162        printk("\npVBInfo->BaseAddr == 0 ");
 163         return( FALSE ) ;
 164 }
 165 printk("2");
 166
 167     XGINew_SetReg3( ( pVBInfo->BaseAddr + 0x12 ) , 0x67 ) ;     /* 3c2 <- 67 ,ynlai */
 168
 169     pVBInfo->ISXPDOS = 0 ;
 170 printk("3");
 171
 172 if ( !HwDeviceExtension->bIntegratedMMEnabled )
 173 {
 174         return( FALSE ) ;       /* alan */
 175 }
 176 printk("4");
 177
 178 //    XGI_MemoryCopy( VBIOSVersion , HwDeviceExtension->szVBIOSVer , 4 ) ;
 179
 180  //   VBIOSVersion[ 4 ] = 0x0 ;
 181
 182     /* 09/07/99 modify by domao */
 183
 184     pVBInfo->P3c4 = pVBInfo->BaseAddr + 0x14 ;
 185     pVBInfo->P3d4 = pVBInfo->BaseAddr + 0x24 ;
 186     pVBInfo->P3c0 = pVBInfo->BaseAddr + 0x10 ;
 187     pVBInfo->P3ce = pVBInfo->BaseAddr + 0x1e ;
 188     pVBInfo->P3c2 = pVBInfo->BaseAddr + 0x12 ;
 189     pVBInfo->P3ca = pVBInfo->BaseAddr + 0x1a ;
 190     pVBInfo->P3c6 = pVBInfo->BaseAddr + 0x16 ;
 191     pVBInfo->P3c7 = pVBInfo->BaseAddr + 0x17 ;
 192     pVBInfo->P3c8 = pVBInfo->BaseAddr + 0x18 ;
 193     pVBInfo->P3c9 = pVBInfo->BaseAddr + 0x19 ;
 194     pVBInfo->P3da = pVBInfo->BaseAddr + 0x2A ;
 195     pVBInfo->Part0Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_00 ;
 196     pVBInfo->Part1Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_04 ;
 197     pVBInfo->Part2Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_10 ;
 198     pVBInfo->Part3Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_12 ;
 199     pVBInfo->Part4Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 ;
 200     pVBInfo->Part5Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 + 2 ;
 201 printk("5");
 202
 203     if ( HwDeviceExtension->jChipType < XG20 )                  /* kuku 2004/06/25 */
 204     XGI_GetVBType( pVBInfo ) ;         /* Run XGI_GetVBType before InitTo330Pointer */
 205
 206     InitTo330Pointer( HwDeviceExtension->jChipType,  pVBInfo ) ;
 207
 208     /* ReadVBIOSData */
 209     ReadVBIOSTablData( HwDeviceExtension->jChipType , pVBInfo) ;
 210
 211     /* 1.Openkey */
 212     XGINew_SetReg1( pVBInfo->P3c4 , 0x05 , 0x86 ) ;
 213 printk("6");
 214
 215     /* GetXG21Sense (GPIO) */
 216     if ( HwDeviceExtension->jChipType == XG21 )
 217     {
 218         XGINew_GetXG21Sense(HwDeviceExtension, pVBInfo) ;
 219     }
 220     if ( HwDeviceExtension->jChipType == XG27 )
 221     {
 222         XGINew_GetXG27Sense(HwDeviceExtension, pVBInfo) ;
 223     }
 224 printk("7");
 225
 226     /* 2.Reset Extended register */
 227
 228     for( i = 0x06 ; i < 0x20 ; i++ )
 229         XGINew_SetReg1( pVBInfo->P3c4 , i , 0 ) ;
 230
 231     for( i = 0x21 ; i <= 0x27 ; i++ )
 232         XGINew_SetReg1( pVBInfo->P3c4 , i , 0 ) ;
 233
 234     /* for( i = 0x06 ; i <= 0x27 ; i++ ) */
 235     /* XGINew_SetReg1( pVBInfo->P3c4 , i , 0 ) ; */
 236
 237 printk("8");
 238
 239     if(( HwDeviceExtension->jChipType >= XG20 ) || ( HwDeviceExtension->jChipType >= XG40))
 240     {
 241         for( i = 0x31 ; i <= 0x3B ; i++ )
 242             XGINew_SetReg1( pVBInfo->P3c4 , i , 0 ) ;
 243     }
 244     else
 245     {
 246         for( i = 0x31 ; i <= 0x3D ; i++ )
 247             XGINew_SetReg1( pVBInfo->P3c4 , i , 0 ) ;
 248     }
 249 printk("9");
 250
 251     if ( HwDeviceExtension->jChipType == XG42 )                 /* [Hsuan] 2004/08/20 Auto over driver for XG42 */
 252       XGINew_SetReg1( pVBInfo->P3c4 , 0x3B , 0xC0 ) ;
 253
 254     /* for( i = 0x30 ; i <= 0x3F ; i++ ) */
 255     /* XGINew_SetReg1( pVBInfo->P3d4 , i , 0 ) ; */
 256
 257     for( i = 0x79 ; i <= 0x7C ; i++ )
 258         XGINew_SetReg1( pVBInfo->P3d4 , i , 0 ) ;               /* shampoo 0208 */
 259
 260 printk("10");
 261
 262     if ( HwDeviceExtension->jChipType >= XG20 )
 263         XGINew_SetReg1( pVBInfo->P3d4 , 0x97 , *pVBInfo->pXGINew_CR97 ) ;
 264
 265     /* 3.SetMemoryClock
 266
 267     if ( HwDeviceExtension->jChipType >= XG40 )
 268         XGINew_RAMType = ( int )XGINew_GetXG20DRAMType( HwDeviceExtension , pVBInfo) ;
 269
 270     if ( HwDeviceExtension->jChipType < XG40 )
 271         XGINew_SetMemoryClock( HwDeviceExtension , pVBInfo ) ;  */
 272
 273 printk("11");
 274
 275     /* 4.SetDefExt1Regs begin */
 276     XGINew_SetReg1( pVBInfo->P3c4 , 0x07 , *pVBInfo->pSR07 ) ;
 277     if ( HwDeviceExtension->jChipType == XG27 )
 278     {
 279         XGINew_SetReg1( pVBInfo->P3c4 , 0x40 , *pVBInfo->pSR40 ) ;
 280         XGINew_SetReg1( pVBInfo->P3c4 , 0x41 , *pVBInfo->pSR41 ) ;
 281     }
 282     XGINew_SetReg1( pVBInfo->P3c4 , 0x11 , 0x0F ) ;
 283     XGINew_SetReg1( pVBInfo->P3c4 , 0x1F , *pVBInfo->pSR1F ) ;
 284     /* XGINew_SetReg1( pVBInfo->P3c4 , 0x20 , 0x20 ) ; */
 285     XGINew_SetReg1( pVBInfo->P3c4 , 0x20 , 0xA0 ) ;     /* alan, 2001/6/26 Frame buffer can read/write SR20 */
 286     XGINew_SetReg1( pVBInfo->P3c4 , 0x36 , 0x70 ) ;     /* Hsuan, 2006/01/01 H/W request for slow corner chip */
 287     if ( HwDeviceExtension->jChipType == XG27 )         /* Alan 12/07/2006 */
 288     XGINew_SetReg1( pVBInfo->P3c4 , 0x36 , *pVBInfo->pSR36 ) ;
 289
 290     /* SR11 = 0x0F ; */
 291     /* XGINew_SetReg1( pVBInfo->P3c4 , 0x11 , SR11 ) ; */
 292
 293 printk("12");
 294
 295    if ( HwDeviceExtension->jChipType < XG20 )           /* kuku 2004/06/25 */
 296     {
 297 //    /* Set AGP Rate */
 298 //    temp1 = XGINew_GetReg1( pVBInfo->P3c4 , 0x3B ) ;
 299 //    temp1 &= 0x02 ;
 300 //    if ( temp1 == 0x02 )
 301 //    {
 302 //        XGINew_SetReg4( 0xcf8 , 0x80000000 ) ;
 303 //       ChipsetID = XGINew_GetReg3( 0x0cfc ) ;
 304 //        XGINew_SetReg4( 0xcf8 , 0x8000002C ) ;
 305 //        VendorID = XGINew_GetReg3( 0x0cfc ) ;
 306 //        VendorID &= 0x0000FFFF ;
 307 //        XGINew_SetReg4( 0xcf8 , 0x8001002C ) ;
 308 //        GraphicVendorID = XGINew_GetReg3( 0x0cfc ) ;
 309 //        GraphicVendorID &= 0x0000FFFF;
 310 //
 311 //        if ( ChipsetID == 0x7301039 )
 312 ///            XGINew_SetReg1( pVBInfo->P3d4 , 0x5F , 0x09 ) ;
 313 //
 314 //        ChipsetID &= 0x0000FFFF ;
 315 ///
 316 //        if ( ( ChipsetID == 0x700E ) || ( ChipsetID == 0x1022 ) || ( ChipsetID == 0x1106 ) || ( ChipsetID == 0x10DE ) )
 317 //        {
 318 //            if ( ChipsetID == 0x1106 )
 319 //            {
 320 //                if ( ( VendorID == 0x1019 ) && ( GraphicVendorID == 0x1019 ) )
 321 //                    XGINew_SetReg1( pVBInfo->P3d4 , 0x5F , 0x0D ) ;
 322 //                else
 323 //                    XGINew_SetReg1( pVBInfo->P3d4 , 0x5F , 0x0B ) ;
 324 //            }
 325 //            else
 326 //                XGINew_SetReg1( pVBInfo->P3d4 , 0x5F , 0x0B ) ;
 327 //        }
 328 //    }
 329
 330 printk("13");
 331
 332     if ( HwDeviceExtension->jChipType >= XG40 )
 333     {
 334         /* Set AGP customize registers (in SetDefAGPRegs) Start */
 335         for( i = 0x47 ; i <= 0x4C ; i++ )
 336             XGINew_SetReg1( pVBInfo->P3d4 , i , pVBInfo->AGPReg[ i - 0x47 ] ) ;
 337
 338         for( i = 0x70 ; i <= 0x71 ; i++ )
 339             XGINew_SetReg1( pVBInfo->P3d4 , i , pVBInfo->AGPReg[ 6 + i - 0x70 ] ) ;
 340
 341         for( i = 0x74 ; i <= 0x77 ; i++ )
 342             XGINew_SetReg1( pVBInfo->P3d4 , i , pVBInfo->AGPReg[ 8 + i - 0x74 ] ) ;
 343         /* Set AGP customize registers (in SetDefAGPRegs) End */
 344         /*[Hsuan]2004/12/14 AGP Input Delay Adjustment on 850 */
 345 //        XGINew_SetReg4( 0xcf8 , 0x80000000 ) ;
 346 //        ChipsetID = XGINew_GetReg3( 0x0cfc ) ;
 347 //        if ( ChipsetID == 0x25308086 )
 348 //            XGINew_SetReg1( pVBInfo->P3d4 , 0x77 , 0xF0 ) ;
 349
 350         HwDeviceExtension->pQueryVGAConfigSpace( HwDeviceExtension , 0x50 , 0 , &Temp ) ;       /* Get */
 351         Temp >>= 20 ;
 352         Temp &= 0xF ;
 353
 354         if ( Temp == 1 )
 355             XGINew_SetReg1( pVBInfo->P3d4 , 0x48 , 0x20 ) ;     /* CR48 */
 356     }
 357 printk("14");
 358
 359     if ( HwDeviceExtension->jChipType < XG40 )
 360         XGINew_SetReg1( pVBInfo->P3d4 , 0x49 , pVBInfo->CR49[ 0 ] ) ;
 361     }   /* != XG20 */
 362
 363     /* Set PCI */
 364     XGINew_SetReg1( pVBInfo->P3c4 , 0x23 , *pVBInfo->pSR23 ) ;
 365     XGINew_SetReg1( pVBInfo->P3c4 , 0x24 , *pVBInfo->pSR24 ) ;
 366     XGINew_SetReg1( pVBInfo->P3c4 , 0x25 , pVBInfo->SR25[ 0 ] ) ;
 367 printk("15");
 368
 369     if ( HwDeviceExtension->jChipType < XG20 )          /* kuku 2004/06/25 */
 370     {
 371     /* Set VB */
 372     XGI_UnLockCRT2( HwDeviceExtension, pVBInfo) ;
 373     XGINew_SetRegANDOR( pVBInfo->Part0Port , 0x3F , 0xEF , 0x00 ) ;     /* alan, disable VideoCapture */
 374     XGINew_SetReg1( pVBInfo->Part1Port , 0x00 , 0x00 ) ;
 375     temp1 = ( UCHAR )XGINew_GetReg1( pVBInfo->P3d4 , 0x7B ) ;           /* chk if BCLK>=100MHz */
 376     temp = ( UCHAR )( ( temp1 >> 4 ) & 0x0F ) ;
 377
 378
 379         XGINew_SetReg1( pVBInfo->Part1Port , 0x02 , ( *pVBInfo->pCRT2Data_1_2 ) ) ;
 380
 381 printk("16");
 382
 383     XGINew_SetReg1( pVBInfo->Part1Port , 0x2E , 0x08 ) ;        /* use VB */
 384     } /* != XG20 */
 385
 386
 387     XGINew_SetReg1( pVBInfo->P3c4 , 0x27 , 0x1F ) ;
 388
 389     if ( ( HwDeviceExtension->jChipType == XG42 ) && XGINew_GetXG20DRAMType( HwDeviceExtension , pVBInfo) != 0 )        /* Not DDR */
 390     {
 391         XGINew_SetReg1( pVBInfo->P3c4 , 0x31 , ( *pVBInfo->pSR31 & 0x3F ) | 0x40 ) ;
 392         XGINew_SetReg1( pVBInfo->P3c4 , 0x32 , ( *pVBInfo->pSR32 & 0xFC ) | 0x01 ) ;
 393     }
 394     else
 395     {
 396         XGINew_SetReg1( pVBInfo->P3c4 , 0x31 , *pVBInfo->pSR31 ) ;
 397         XGINew_SetReg1( pVBInfo->P3c4 , 0x32 , *pVBInfo->pSR32 ) ;
 398     }
 399     XGINew_SetReg1( pVBInfo->P3c4 , 0x33 , *pVBInfo->pSR33 ) ;
 400 printk("17");
 401
 402 /*
 403     if ( HwDeviceExtension->jChipType >= XG40 )
 404       SetPowerConsume ( HwDeviceExtension , pVBInfo->P3c4);     */
 405
 406     if ( HwDeviceExtension->jChipType < XG20 )          /* kuku 2004/06/25 */
 407     {
 408     if ( XGI_BridgeIsOn( pVBInfo ) == 1 )
 409     {
 410         if ( pVBInfo->IF_DEF_LVDS == 0 )
 411         {
 412             XGINew_SetReg1( pVBInfo->Part2Port , 0x00 , 0x1C ) ;
 413             XGINew_SetReg1( pVBInfo->Part4Port , 0x0D , *pVBInfo->pCRT2Data_4_D ) ;
 414             XGINew_SetReg1( pVBInfo->Part4Port , 0x0E , *pVBInfo->pCRT2Data_4_E ) ;
 415             XGINew_SetReg1( pVBInfo->Part4Port , 0x10 , *pVBInfo->pCRT2Data_4_10 ) ;
 416             XGINew_SetReg1( pVBInfo->Part4Port , 0x0F , 0x3F ) ;
 417         }
 418
 419         XGI_LockCRT2( HwDeviceExtension, pVBInfo ) ;
 420     }
 421     }   /* != XG20 */
 422 printk("18");
 423
 424     if ( HwDeviceExtension->jChipType < XG40 )
 425         XGINew_SetReg1( pVBInfo->P3d4 , 0x83 , 0x00 ) ;
 426 printk("181");
 427
 428     if ( HwDeviceExtension->bSkipSense == FALSE )
 429     {
 430 printk("182");
 431
 432         XGI_SenseCRT1(pVBInfo) ;
 433
 434 printk("183");
 435         /* XGINew_DetectMonitor( HwDeviceExtension ) ; */
 436 pVBInfo->IF_DEF_CH7007 = 0;
 437         if ( ( HwDeviceExtension->jChipType == XG21 ) && (pVBInfo->IF_DEF_CH7007) )
 438         {
 439 printk("184");
 440            XGI_GetSenseStatus( HwDeviceExtension , pVBInfo ) ;  /* sense CRT2 */
 441 printk("185");
 442
 443         }
 444         if ( HwDeviceExtension->jChipType == XG21 )
 445         {
 446 printk("186");
 447
 448           XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x32 , ~Monitor1Sense , Monitor1Sense ) ; /* Z9 default has CRT */
 449           temp = GetXG21FPBits( pVBInfo ) ;
 450           XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x37 , ~0x01, temp ) ;
 451 printk("187");
 452
 453           }
 454         if ( HwDeviceExtension->jChipType == XG27 )
 455         {
 456           XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x32 , ~Monitor1Sense , Monitor1Sense ) ; /* Z9 default has CRT */
 457           temp = GetXG27FPBits( pVBInfo ) ;
 458           XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x37 , ~0x03, temp ) ;
 459         }
 460     }
 461 printk("19");
 462
 463     if ( HwDeviceExtension->jChipType >= XG40 )
 464     {
 465         if ( HwDeviceExtension->jChipType >= XG40 )
 466         {
 467           XGINew_RAMType = ( int )XGINew_GetXG20DRAMType( HwDeviceExtension , pVBInfo ) ;
 468          }
 469
 470         XGINew_SetDRAMDefaultRegister340( HwDeviceExtension ,  pVBInfo->P3d4,  pVBInfo ) ;
 471
 472         if ( HwDeviceExtension->bSkipDramSizing == TRUE )
 473         {
 474             pSR = HwDeviceExtension->pSR ;
 475             if ( pSR!=NULL )
 476             {
 477                 while( pSR->jIdx != 0xFF )
 478                 {
 479                     XGINew_SetReg1( pVBInfo->P3c4 , pSR->jIdx , pSR->jVal ) ;
 480                     pSR++ ;
 481                 }
 482             }
 483             /* XGINew_SetDRAMModeRegister340( pVBInfo ) ; */
 484         }       /* SkipDramSizing */
 485         else
 486         {
 487 #if 0
 488            if ( HwDeviceExtension->jChipType == XG20 )
 489             {
 490                 XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , pVBInfo->SR15[0][XGINew_RAMType] ) ;
 491                 XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , pVBInfo->SR15[1][XGINew_RAMType] ) ;
 492                 XGINew_SetReg1( pVBInfo->P3c4 , 0x20 , 0x20 ) ;
 493             }
 494             else
 495 #endif
 496 {
 497 printk("20");
 498
 499                XGINew_SetDRAMSize_340( HwDeviceExtension , pVBInfo) ;
 500 }
 501 printk("21");
 502
 503         }
 504     }           /* XG40 */
 505
 506 printk("22");
 507
 508
 509     /* SetDefExt2Regs begin */
 510 /*
 511     AGP = 1 ;
 512     temp =( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x3A ) ;
 513     temp &= 0x30 ;
 514     if ( temp == 0x30 )
 515         AGP = 0 ;
 516
 517     if ( AGP == 0 )
 518         *pVBInfo->pSR21 &= 0xEF ;
 519
 520     XGINew_SetReg1( pVBInfo->P3c4 , 0x21 , *pVBInfo->pSR21 ) ;
 521     if ( AGP == 1 )
 522         *pVBInfo->pSR22 &= 0x20 ;
 523     XGINew_SetReg1( pVBInfo->P3c4 , 0x22 , *pVBInfo->pSR22 ) ;
 524 */
 525
 526 //    base = 0x80000000 ;
 527 //    OutPortLong( 0xcf8 , base ) ;
 528 //    Temp = ( InPortLong( 0xcfc ) & 0xFFFF ) ;
 529 //    if ( Temp == 0x1039 )
 530 //    {
 531         XGINew_SetReg1( pVBInfo->P3c4 , 0x22 , ( UCHAR )( ( *pVBInfo->pSR22 ) & 0xFE ) ) ;
 532 //    }
 533 //    else
 534 //    {
 535 //        XGINew_SetReg1( pVBInfo->P3c4 , 0x22 , *pVBInfo->pSR22 ) ;
 536 //    }
 537
 538     XGINew_SetReg1( pVBInfo->P3c4 , 0x21 , *pVBInfo->pSR21 ) ;
 539
 540 printk("23");
 541
 542
 543     XGINew_ChkSenseStatus ( HwDeviceExtension , pVBInfo ) ;
 544     XGINew_SetModeScratch ( HwDeviceExtension , pVBInfo ) ;
 545
 546 printk("24");
 547
 548
 549 XGINew_SetReg1( pVBInfo->P3d4 , 0x8c , 0x87);
 550 XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x31);
 551 printk("25");
 552
 553     return( TRUE ) ;
 554 } /* end of init */
 555
 556
 557
 558
 559
 560 /* ============== alan ====================== */
 561
 562 /* --------------------------------------------------------------------- */
 563 /* Function : XGINew_GetXG20DRAMType */
 564 /* Input : */
 565 /* Output : */
 566 /* Description : */
 567 /* --------------------------------------------------------------------- */
 568 UCHAR XGINew_GetXG20DRAMType( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo)
 569 {
 570     UCHAR data, temp ;
 571
 572     if ( HwDeviceExtension->jChipType < XG20 )
 573     {
 574         if ( *pVBInfo->pSoftSetting & SoftDRAMType )
 575         {
 576             data = *pVBInfo->pSoftSetting & 0x07 ;
 577             return( data ) ;
 578         }
 579         else
 580         {
 581             data = XGINew_GetReg1( pVBInfo->P3c4 , 0x39 ) & 0x02 ;
 582
 583             if ( data == 0 )
 584                 data = ( XGINew_GetReg1( pVBInfo->P3c4 , 0x3A ) & 0x02 ) >> 1 ;
 585
 586             return( data ) ;
 587         }
 588     }
 589     else if ( HwDeviceExtension->jChipType == XG27 )
 590     {
 591         if ( *pVBInfo->pSoftSetting & SoftDRAMType )
 592         {
 593             data = *pVBInfo->pSoftSetting & 0x07 ;
 594             return( data ) ;
 595         }
 596         temp = XGINew_GetReg1( pVBInfo->P3c4 , 0x3B ) ;
 597
 598         if (( temp & 0x88 )==0x80)              /* SR3B[7][3]MAA15 MAA11 (Power on Trapping) */
 599           data = 0 ;                                    /*DDR*/
 600         else
 601           data = 1 ;                                    /*DDRII*/
 602         return( data ) ;
 603     }
 604     else if ( HwDeviceExtension->jChipType == XG21 )
 605     {
 606         XGINew_SetRegAND( pVBInfo->P3d4 , 0xB4 , ~0x02 ) ;              /* Independent GPIO control */
 607         DelayUS(800);
 608         XGINew_SetRegOR( pVBInfo->P3d4 , 0x4A , 0x80 ) ;                /* Enable GPIOH read */
 609         temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x48 ) ;                 /* GPIOF 0:DVI 1:DVO */
 610 // HOTPLUG_SUPPORT
 611 // for current XG20 & XG21, GPIOH is floating, driver will fix DDR temporarily
 612         if ( temp & 0x01 )                                              /* DVI read GPIOH */
 613           data = 1 ;                                                    /*DDRII*/
 614         else
 615           data = 0 ;                                                    /*DDR*/
 616 //~HOTPLUG_SUPPORT
 617         XGINew_SetRegOR( pVBInfo->P3d4 , 0xB4 , 0x02 ) ;
 618         return( data ) ;
 619     }
 620     else
 621     {
 622         data = XGINew_GetReg1( pVBInfo->P3d4 , 0x97 ) & 0x01 ;
 623
 624         if ( data == 1 )
 625             data ++ ;
 626
 627         return( data );
 628     }
 629 }
 630
 631
 632 /* --------------------------------------------------------------------- */
 633 /* Function : XGINew_Get310DRAMType */
 634 /* Input : */
 635 /* Output : */
 636 /* Description : */
 637 /* --------------------------------------------------------------------- */
 638 UCHAR XGINew_Get310DRAMType(PVB_DEVICE_INFO pVBInfo)
 639 {
 640     UCHAR data ;
 641
 642   /* index = XGINew_GetReg1( pVBInfo->P3c4 , 0x1A ) ; */
 643   /* index &= 07 ; */
 644
 645     if ( *pVBInfo->pSoftSetting & SoftDRAMType )
 646         data = *pVBInfo->pSoftSetting & 0x03 ;
 647     else
 648         data = XGINew_GetReg1( pVBInfo->P3c4 , 0x3a ) & 0x03 ;
 649
 650     return( data ) ;
 651 }
 652
 653
 654
 655 /* --------------------------------------------------------------------- */
 656 /* Function : XGINew_Delay15us */
 657 /* Input : */
 658 /* Output : */
 659 /* Description : */
 660 /* --------------------------------------------------------------------- */
 661 /*
 662 void XGINew_Delay15us(ULONG ulMicrsoSec)
 663 {
 664 }
 665 */
 666
 667
 668 /* --------------------------------------------------------------------- */
 669 /* Function : XGINew_SDR_MRS */
 670 /* Input : */
 671 /* Output : */
 672 /* Description : */
 673 /* --------------------------------------------------------------------- */
 674 void XGINew_SDR_MRS(  PVB_DEVICE_INFO pVBInfo )
 675 {
 676     USHORT data ;
 677
 678     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x16 ) ;
 679     data &= 0x3F ;          /* SR16 D7=0,D6=0 */
 680     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;   /* enable mode register set(MRS) low */
 681     /* XGINew_Delay15us( 0x100 ) ; */
 682     data |= 0x80 ;          /* SR16 D7=1,D6=0 */
 683     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;   /* enable mode register set(MRS) high */
 684     /* XGINew_Delay15us( 0x100 ) ; */
 685 }
 686
 687
 688 /* --------------------------------------------------------------------- */
 689 /* Function : XGINew_DDR1x_MRS_340 */
 690 /* Input : */
 691 /* Output : */
 692 /* Description : */
 693 /* --------------------------------------------------------------------- */
 694 void XGINew_DDR1x_MRS_340( ULONG P3c4 , PVB_DEVICE_INFO pVBInfo)
 695 {
 696     XGINew_SetReg1( P3c4 , 0x18 , 0x01 ) ;
 697     XGINew_SetReg1( P3c4 , 0x19 , 0x20 ) ;
 698     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
 699     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
 700
 701     if ( *pVBInfo->pXGINew_DRAMTypeDefinition != 0x0C ) /* Samsung F Die */
 702     {
 703         DelayUS( 3000 ) ;       /* Delay 67 x 3 Delay15us */
 704         XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;
 705         XGINew_SetReg1( P3c4 , 0x19 , 0x20 ) ;
 706         XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
 707         XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
 708     }
 709
 710     DelayUS( 60 ) ;
 711     XGINew_SetReg1( P3c4 , 0x18 , pVBInfo->SR15[ 2 ][ XGINew_RAMType ] ) ;      /* SR18 */
 712     XGINew_SetReg1( P3c4 , 0x19 , 0x01 ) ;
 713     XGINew_SetReg1( P3c4 , 0x16 , pVBInfo->SR16[ 0 ] ) ;
 714     XGINew_SetReg1( P3c4 , 0x16 , pVBInfo->SR16[ 1 ] ) ;
 715     DelayUS( 1000 ) ;
 716     XGINew_SetReg1( P3c4 , 0x1B , 0x03 ) ;
 717     DelayUS( 500 ) ;
 718     XGINew_SetReg1( P3c4 , 0x18 , pVBInfo->SR15[ 2 ][ XGINew_RAMType ] ) ;      /* SR18 */
 719     XGINew_SetReg1( P3c4 , 0x19 , 0x00 ) ;
 720     XGINew_SetReg1( P3c4 , 0x16 , pVBInfo->SR16[ 2 ] ) ;
 721     XGINew_SetReg1( P3c4 , 0x16 , pVBInfo->SR16[ 3 ] ) ;
 722     XGINew_SetReg1( P3c4 , 0x1B , 0x00 ) ;
 723 }
 724
 725
 726 /* --------------------------------------------------------------------- */
 727 /* Function : XGINew_DDR2x_MRS_340 */
 728 /* Input : */
 729 /* Output : */
 730 /* Description : */
 731 /* --------------------------------------------------------------------- */
 732 void XGINew_DDR2x_MRS_340( ULONG P3c4 , PVB_DEVICE_INFO pVBInfo)
 733 {
 734     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;
 735     XGINew_SetReg1( P3c4 , 0x19 , 0x20 ) ;
 736     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
 737     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
 738     DelayUS( 60 ) ;
 739     XGINew_SetReg1( P3c4 , 0x18 , pVBInfo->SR15[ 2 ][ XGINew_RAMType ] ) ;      /* SR18 */
 740     /* XGINew_SetReg1( P3c4 , 0x18 , 0x31 ) ; */
 741     XGINew_SetReg1( P3c4 , 0x19 , 0x01 ) ;
 742     XGINew_SetReg1( P3c4 , 0x16 , 0x05 ) ;
 743     XGINew_SetReg1( P3c4 , 0x16 , 0x85 ) ;
 744     DelayUS( 1000 ) ;
 745     XGINew_SetReg1( P3c4 , 0x1B , 0x03 ) ;
 746     DelayUS( 500 ) ;
 747     /* XGINew_SetReg1( P3c4 , 0x18 , 0x31 ) ; */
 748     XGINew_SetReg1( P3c4 , 0x18 , pVBInfo->SR15[ 2 ][ XGINew_RAMType ] ) ;      /* SR18 */
 749     XGINew_SetReg1( P3c4 , 0x19 , 0x00 ) ;
 750     XGINew_SetReg1( P3c4 , 0x16 , 0x05 ) ;
 751     XGINew_SetReg1( P3c4 , 0x16 , 0x85 ) ;
 752     XGINew_SetReg1( P3c4 , 0x1B , 0x00 ) ;
 753 }
 754
 755 /* --------------------------------------------------------------------- */
 756 /* Function : XGINew_DDRII_Bootup_XG27 */
 757 /* Input : */
 758 /* Output : */
 759 /* Description : */
 760 /* --------------------------------------------------------------------- */
 761 void XGINew_DDRII_Bootup_XG27( PXGI_HW_DEVICE_INFO HwDeviceExtension ,  ULONG P3c4 , PVB_DEVICE_INFO pVBInfo)
 762 {
 763     ULONG P3d4 = P3c4 + 0x10 ;
 764     XGINew_RAMType = ( int )XGINew_GetXG20DRAMType( HwDeviceExtension , pVBInfo ) ;
 765     XGINew_SetMemoryClock( HwDeviceExtension , pVBInfo ) ;
 766
 767    /* Set Double Frequency */
 768     /* XGINew_SetReg1( P3d4 , 0x97 , 0x11 ) ; */                /* CR97 */
 769     XGINew_SetReg1( P3d4 , 0x97 , *pVBInfo->pXGINew_CR97 ) ;    /* CR97 */
 770
 771     DelayUS( 200 ) ;
 772
 773     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;   /* Set SR18 */ //EMRS2
 774     XGINew_SetReg1( P3c4 , 0x19 , 0x80 ) ;   /* Set SR19 */
 775     XGINew_SetReg1( P3c4 , 0x16 , 0x20 ) ;   /* Set SR16 */
 776     DelayUS( 15 ) ;
 777     XGINew_SetReg1( P3c4 , 0x16 , 0xA0 ) ;   /* Set SR16 */
 778     DelayUS( 15 ) ;
 779
 780     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;   /* Set SR18 */ //EMRS3
 781     XGINew_SetReg1( P3c4 , 0x19 , 0xC0 ) ;   /* Set SR19 */
 782     XGINew_SetReg1( P3c4 , 0x16 , 0x20 ) ;   /* Set SR16 */
 783     DelayUS( 15 ) ;
 784     XGINew_SetReg1( P3c4 , 0x16 , 0xA0 ) ;   /* Set SR16 */
 785     DelayUS( 15) ;
 786
 787     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;   /* Set SR18 */ //EMRS1
 788     XGINew_SetReg1( P3c4 , 0x19 , 0x40 ) ;   /* Set SR19 */
 789     XGINew_SetReg1( P3c4 , 0x16 , 0x20 ) ;   /* Set SR16 */
 790     DelayUS( 30 ) ;
 791     XGINew_SetReg1( P3c4 , 0x16 , 0xA0 ) ;   /* Set SR16 */
 792     DelayUS( 15 ) ;
 793
 794     XGINew_SetReg1( P3c4 , 0x18 , 0x42 ) ;   /* Set SR18 */ //MRS, DLL Enable
 795     XGINew_SetReg1( P3c4 , 0x19 , 0x0A ) ;   /* Set SR19 */
 796     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;   /* Set SR16 */
 797     DelayUS( 30 ) ;
 798     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;   /* Set SR16 */
 799     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;   /* Set SR16 */
 800     /* DelayUS( 15 ) ; */
 801
 802     XGINew_SetReg1( P3c4 , 0x1B , 0x04 ) ;   /* Set SR1B */
 803     DelayUS( 60 ) ;
 804     XGINew_SetReg1( P3c4 , 0x1B , 0x00 ) ;   /* Set SR1B */
 805
 806     XGINew_SetReg1( P3c4 , 0x18 , 0x42 ) ;   /* Set SR18 */ //MRS, DLL Reset
 807     XGINew_SetReg1( P3c4 , 0x19 , 0x08 ) ;   /* Set SR19 */
 808     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;   /* Set SR16 */
 809
 810     DelayUS( 30 ) ;
 811     XGINew_SetReg1( P3c4 , 0x16 , 0x83 ) ;   /* Set SR16 */
 812     DelayUS( 15 ) ;
 813
 814     XGINew_SetReg1( P3c4 , 0x18 , 0x80 ) ;   /* Set SR18 */ //MRS, ODT
 815     XGINew_SetReg1( P3c4 , 0x19 , 0x46 ) ;   /* Set SR19 */
 816     XGINew_SetReg1( P3c4 , 0x16 , 0x20 ) ;   /* Set SR16 */
 817     DelayUS( 30 ) ;
 818     XGINew_SetReg1( P3c4 , 0x16 , 0xA0 ) ;   /* Set SR16 */
 819     DelayUS( 15 ) ;
 820
 821     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;   /* Set SR18 */ //EMRS
 822     XGINew_SetReg1( P3c4 , 0x19 , 0x40 ) ;   /* Set SR19 */
 823     XGINew_SetReg1( P3c4 , 0x16 , 0x20 ) ;   /* Set SR16 */
 824     DelayUS( 30 ) ;
 825     XGINew_SetReg1( P3c4 , 0x16 , 0xA0 ) ;   /* Set SR16 */
 826     DelayUS( 15 ) ;
 827
 828     XGINew_SetReg1( P3c4 , 0x1B , 0x04 ) ;   /* Set SR1B refresh control 000:close; 010:open */
 829     DelayUS( 200 ) ;
 830
 831
 832 }
 833 /* --------------------------------------------------------------------- */
 834 /* Function : XGINew_DDR2_MRS_XG20 */
 835 /* Input : */
 836 /* Output : */
 837 /* Description : */
 838 /* --------------------------------------------------------------------- */
 839 void XGINew_DDR2_MRS_XG20( PXGI_HW_DEVICE_INFO HwDeviceExtension ,  ULONG P3c4 , PVB_DEVICE_INFO pVBInfo)
 840 {
 841     ULONG P3d4 = P3c4 + 0x10 ;
 842
 843     XGINew_RAMType = ( int )XGINew_GetXG20DRAMType( HwDeviceExtension , pVBInfo ) ;
 844     XGINew_SetMemoryClock( HwDeviceExtension , pVBInfo ) ;
 845
 846     XGINew_SetReg1( P3d4 , 0x97 , 0x11 ) ;                      /* CR97 */
 847
 848     DelayUS( 200 ) ;
 849     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;                      /* EMRS2 */
 850     XGINew_SetReg1( P3c4 , 0x19 , 0x80 ) ;
 851     XGINew_SetReg1( P3c4 , 0x16 , 0x05 ) ;
 852     XGINew_SetReg1( P3c4 , 0x16 , 0x85 ) ;
 853
 854     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;                      /* EMRS3 */
 855     XGINew_SetReg1( P3c4 , 0x19 , 0xC0 ) ;
 856     XGINew_SetReg1( P3c4 , 0x16 , 0x05 ) ;
 857     XGINew_SetReg1( P3c4 , 0x16 , 0x85 ) ;
 858
 859     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;                      /* EMRS1 */
 860     XGINew_SetReg1( P3c4 , 0x19 , 0x40 ) ;
 861     XGINew_SetReg1( P3c4 , 0x16 , 0x05 ) ;
 862     XGINew_SetReg1( P3c4 , 0x16 , 0x85 ) ;
 863
 864    // XGINew_SetReg1( P3c4 , 0x18 , 0x52 ) ;                    /* MRS1 */
 865     XGINew_SetReg1( P3c4 , 0x18 , 0x42 ) ;                      /* MRS1 */
 866     XGINew_SetReg1( P3c4 , 0x19 , 0x02 ) ;
 867     XGINew_SetReg1( P3c4 , 0x16 , 0x05 ) ;
 868     XGINew_SetReg1( P3c4 , 0x16 , 0x85 ) ;
 869
 870     DelayUS( 15 ) ;
 871     XGINew_SetReg1( P3c4 , 0x1B , 0x04 ) ;                      /* SR1B */
 872     DelayUS( 30 ) ;
 873     XGINew_SetReg1( P3c4 , 0x1B , 0x00 ) ;                      /* SR1B */
 874     DelayUS( 100 ) ;
 875
 876     //XGINew_SetReg1( P3c4 , 0x18 , 0x52 ) ;                    /* MRS2 */
 877     XGINew_SetReg1( P3c4 , 0x18 , 0x42 ) ;                      /* MRS1 */
 878     XGINew_SetReg1( P3c4 , 0x19 , 0x00 ) ;
 879     XGINew_SetReg1( P3c4 , 0x16 , 0x05 ) ;
 880     XGINew_SetReg1( P3c4 , 0x16 , 0x85 ) ;
 881
 882     DelayUS( 200 ) ;
 883 }
 884
 885 /* --------------------------------------------------------------------- */
 886 /* Function : XGINew_DDR2_MRS_XG20 */
 887 /* Input : */
 888 /* Output : */
 889 /* Description : */
 890 /* --------------------------------------------------------------------- */
 891 void XGINew_DDR2_MRS_XG27( PXGI_HW_DEVICE_INFO HwDeviceExtension ,  ULONG P3c4 , PVB_DEVICE_INFO pVBInfo)
 892 {
 893     ULONG P3d4 = P3c4 + 0x10 ;
 894
 895      XGINew_RAMType = ( int )XGINew_GetXG20DRAMType( HwDeviceExtension , pVBInfo ) ;
 896      XGINew_SetMemoryClock( HwDeviceExtension , pVBInfo ) ;
 897
 898     XGINew_SetReg1( P3d4 , 0x97 , 0x11 ) ;                      /* CR97 */
 899     DelayUS( 200 ) ;
 900     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;                      /* EMRS2 */
 901     XGINew_SetReg1( P3c4 , 0x19 , 0x80 ) ;
 902
 903     XGINew_SetReg1( P3c4 , 0x16 , 0x10 ) ;
 904     DelayUS( 15 ) ;                          ////06/11/23 XG27 A0 for CKE enable
 905     XGINew_SetReg1( P3c4 , 0x16 , 0x90 ) ;
 906
 907     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;                      /* EMRS3 */
 908     XGINew_SetReg1( P3c4 , 0x19 , 0xC0 ) ;
 909
 910     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
 911     DelayUS( 15 ) ;                          ////06/11/22 XG27 A0
 912     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
 913
 914
 915     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;                      /* EMRS1 */
 916     XGINew_SetReg1( P3c4 , 0x19 , 0x40 ) ;
 917
 918     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
 919     DelayUS( 15 ) ;                          ////06/11/22 XG27 A0
 920     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
 921
 922     XGINew_SetReg1( P3c4 , 0x18 , 0x42 ) ;                      /* MRS1 */
 923     XGINew_SetReg1( P3c4 , 0x19 , 0x06 ) ;   ////[Billy]06/11/22 DLL Reset for XG27 Hynix DRAM
 924
 925     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
 926     DelayUS( 15 ) ;                          ////06/11/23 XG27 A0
 927     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
 928
 929     DelayUS( 30 ) ;                          ////06/11/23 XG27 A0 Start Auto-PreCharge
 930     XGINew_SetReg1( P3c4 , 0x1B , 0x04 ) ;                      /* SR1B */
 931     DelayUS( 60 ) ;
 932     XGINew_SetReg1( P3c4 , 0x1B , 0x00 ) ;                      /* SR1B */
 933
 934
 935     XGINew_SetReg1( P3c4 , 0x18 , 0x42 ) ;                      /* MRS1 */
 936     XGINew_SetReg1( P3c4 , 0x19 , 0x04 ) ;   //// DLL without Reset for XG27 Hynix DRAM
 937
 938     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
 939     DelayUS( 30 ) ;
 940     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
 941
 942     XGINew_SetReg1( P3c4 , 0x18 , 0x80 );     ////XG27 OCD ON
 943     XGINew_SetReg1( P3c4 , 0x19 , 0x46 );
 944
 945     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
 946     DelayUS( 30 ) ;
 947     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
 948
 949     XGINew_SetReg1( P3c4 , 0x18 , 0x00 );
 950     XGINew_SetReg1( P3c4 , 0x19 , 0x40 );
 951
 952     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
 953     DelayUS( 30 ) ;
 954     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
 955
 956     DelayUS( 15 ) ;                         ////Start Auto-PreCharge
 957     XGINew_SetReg1( P3c4 , 0x1B , 0x04 ) ;                      /* SR1B */
 958     DelayUS( 200 ) ;
 959     XGINew_SetReg1( P3c4 , 0x1B , 0x03 ) ;                      /* SR1B */
 960
 961 }
 962
 963 /* --------------------------------------------------------------------- */
 964 /* Function : XGINew_DDR1x_DefaultRegister */
 965 /* Input : */
 966 /* Output : */
 967 /* Description : */
 968 /* --------------------------------------------------------------------- */
 969 void XGINew_DDR1x_DefaultRegister( PXGI_HW_DEVICE_INFO HwDeviceExtension ,  ULONG Port , PVB_DEVICE_INFO pVBInfo)
 970 {
 971     ULONG P3d4 = Port ,
 972            P3c4 = Port - 0x10 ;
 973
 974     if ( HwDeviceExtension->jChipType >= XG20 )
 975     {
 976         XGINew_SetMemoryClock( HwDeviceExtension , pVBInfo ) ;
 977         XGINew_SetReg1( P3d4 , 0x82 , pVBInfo->CR40[ 11 ][ XGINew_RAMType ] ) ; /* CR82 */
 978         XGINew_SetReg1( P3d4 , 0x85 , pVBInfo->CR40[ 12 ][ XGINew_RAMType ] ) ; /* CR85 */
 979         XGINew_SetReg1( P3d4 , 0x86 , pVBInfo->CR40[ 13 ][ XGINew_RAMType ] ) ; /* CR86 */
 980
 981         XGINew_SetReg1( P3d4 , 0x98 , 0x01 ) ;
 982         XGINew_SetReg1( P3d4 , 0x9A , 0x02 ) ;
 983
 984         XGINew_DDR1x_MRS_XG20( P3c4 , pVBInfo) ;
 985     }
 986     else
 987     {
 988         XGINew_SetMemoryClock( HwDeviceExtension , pVBInfo ) ;
 989
 990         switch( HwDeviceExtension->jChipType )
 991         {
 992             case XG41:
 993             case XG42:
 994                 XGINew_SetReg1( P3d4 , 0x82 , pVBInfo->CR40[ 11 ][ XGINew_RAMType ] ) ; /* CR82 */
 995                 XGINew_SetReg1( P3d4 , 0x85 , pVBInfo->CR40[ 12 ][ XGINew_RAMType ] ) ; /* CR85 */
 996                 XGINew_SetReg1( P3d4 , 0x86 , pVBInfo->CR40[ 13 ][ XGINew_RAMType ] ) ; /* CR86 */
 997                 break ;
 998             default:
 999                 XGINew_SetReg1( P3d4 , 0x82 , 0x88 ) ;
1000                 XGINew_SetReg1( P3d4 , 0x86 , 0x00 ) ;
1001                 XGINew_GetReg1( P3d4 , 0x86 ) ;                         /* Insert read command for delay */
1002                 XGINew_SetReg1( P3d4 , 0x86 , 0x88 ) ;
1003                 XGINew_GetReg1( P3d4 , 0x86 ) ;
1004                 XGINew_SetReg1( P3d4 , 0x86 , pVBInfo->CR40[ 13 ][ XGINew_RAMType ] ) ;
1005                 XGINew_SetReg1( P3d4 , 0x82 , 0x77 ) ;
1006                 XGINew_SetReg1( P3d4 , 0x85 , 0x00 ) ;
1007                 XGINew_GetReg1( P3d4 , 0x85 ) ;                         /* Insert read command for delay */
1008                 XGINew_SetReg1( P3d4 , 0x85 , 0x88 ) ;
1009                 XGINew_GetReg1( P3d4 , 0x85 ) ;                         /* Insert read command for delay */
1010                 XGINew_SetReg1( P3d4 , 0x85 , pVBInfo->CR40[ 12 ][ XGINew_RAMType ] ) ; /* CR85 */
1011                 XGINew_SetReg1( P3d4 , 0x82 , pVBInfo->CR40[ 11 ][ XGINew_RAMType ] ) ; /* CR82 */
1012                 break ;
1013         }
1014
1015         XGINew_SetReg1( P3d4 , 0x97 , 0x00 ) ;
1016         XGINew_SetReg1( P3d4 , 0x98 , 0x01 ) ;
1017         XGINew_SetReg1( P3d4 , 0x9A , 0x02 ) ;
1018         XGINew_DDR1x_MRS_340( P3c4 , pVBInfo ) ;
1019     }
1020 }
1021
1022
1023 /* --------------------------------------------------------------------- */
1024 /* Function : XGINew_DDR2x_DefaultRegister */
1025 /* Input : */
1026 /* Output : */
1027 /* Description : */
1028 /* --------------------------------------------------------------------- */
1029 void XGINew_DDR2x_DefaultRegister( PXGI_HW_DEVICE_INFO HwDeviceExtension ,  ULONG Port ,PVB_DEVICE_INFO pVBInfo)
1030 {
1031     ULONG P3d4 = Port ,
1032            P3c4 = Port - 0x10 ;
1033
1034     XGINew_SetMemoryClock( HwDeviceExtension , pVBInfo ) ;
1035
1036     /* 20040906 Hsuan modify CR82, CR85, CR86 for XG42 */
1037     switch( HwDeviceExtension->jChipType )
1038     {
1039        case XG41:
1040        case XG42:
1041             XGINew_SetReg1( P3d4 , 0x82 , pVBInfo->CR40[ 11 ][ XGINew_RAMType ] ) ;     /* CR82 */
1042             XGINew_SetReg1( P3d4 , 0x85 , pVBInfo->CR40[ 12 ][ XGINew_RAMType ] ) ;     /* CR85 */
1043             XGINew_SetReg1( P3d4 , 0x86 , pVBInfo->CR40[ 13 ][ XGINew_RAMType ] ) ;     /* CR86 */
1044             break ;
1045        default:
1046          /* keep following setting sequence, each setting in the same reg insert idle */
1047          XGINew_SetReg1( P3d4 , 0x82 , 0x88 ) ;
1048          XGINew_SetReg1( P3d4 , 0x86 , 0x00 ) ;
1049          XGINew_GetReg1( P3d4 , 0x86 ) ;                                /* Insert read command for delay */
1050          XGINew_SetReg1( P3d4 , 0x86 , 0x88 ) ;
1051          XGINew_SetReg1( P3d4 , 0x82 , 0x77 ) ;
1052          XGINew_SetReg1( P3d4 , 0x85 , 0x00 ) ;
1053          XGINew_GetReg1( P3d4 , 0x85 ) ;                                /* Insert read command for delay */
1054          XGINew_SetReg1( P3d4 , 0x85 , 0x88 ) ;
1055          XGINew_GetReg1( P3d4 , 0x85 ) ;                                /* Insert read command for delay */
1056          XGINew_SetReg1( P3d4 , 0x85 , pVBInfo->CR40[ 12 ][ XGINew_RAMType ] ) ;        /* CR85 */
1057          XGINew_SetReg1( P3d4 , 0x82 , pVBInfo->CR40[ 11 ][ XGINew_RAMType ] ) ;        /* CR82 */
1058     }
1059     XGINew_SetReg1( P3d4 , 0x97 , 0x11 ) ;
1060     if ( HwDeviceExtension->jChipType == XG42 )
1061     {
1062       XGINew_SetReg1( P3d4 , 0x98 , 0x01 ) ;
1063     }
1064     else
1065     {
1066       XGINew_SetReg1( P3d4 , 0x98 , 0x03 ) ;
1067     }
1068     XGINew_SetReg1( P3d4 , 0x9A , 0x02 ) ;
1069
1070     XGINew_DDR2x_MRS_340( P3c4 , pVBInfo ) ;
1071 }
1072
1073
1074 /* --------------------------------------------------------------------- */
1075 /* Function : XGINew_DDR2_DefaultRegister */
1076 /* Input : */
1077 /* Output : */
1078 /* Description : */
1079 /* --------------------------------------------------------------------- */
1080 void XGINew_DDR2_DefaultRegister( PXGI_HW_DEVICE_INFO HwDeviceExtension, ULONG Port , PVB_DEVICE_INFO pVBInfo)
1081 {
1082     ULONG P3d4 = Port ,
1083            P3c4 = Port - 0x10 ;
1084
1085     /* keep following setting sequence, each setting in the same reg insert idle */
1086     XGINew_SetReg1( P3d4 , 0x82 , 0x77 ) ;
1087     XGINew_SetReg1( P3d4 , 0x86 , 0x00 ) ;
1088     XGINew_GetReg1( P3d4 , 0x86 ) ;                             /* Insert read command for delay */
1089     XGINew_SetReg1( P3d4 , 0x86 , 0x88 ) ;
1090     XGINew_GetReg1( P3d4 , 0x86 ) ;                             /* Insert read command for delay */
1091     XGINew_SetReg1( P3d4 , 0x86 , pVBInfo->CR40[ 13 ][ XGINew_RAMType ] ) ;     /* CR86 */
1092     XGINew_SetReg1( P3d4 , 0x82 , 0x77 ) ;
1093     XGINew_SetReg1( P3d4 , 0x85 , 0x00 ) ;
1094     XGINew_GetReg1( P3d4 , 0x85 ) ;                             /* Insert read command for delay */
1095     XGINew_SetReg1( P3d4 , 0x85 , 0x88 ) ;
1096     XGINew_GetReg1( P3d4 , 0x85 ) ;                             /* Insert read command for delay */
1097     XGINew_SetReg1( P3d4 , 0x85 , pVBInfo->CR40[ 12 ][ XGINew_RAMType ] ) ;     /* CR85 */
1098     if ( HwDeviceExtension->jChipType == XG27 )
1099       XGINew_SetReg1( P3d4 , 0x82 , pVBInfo->CR40[ 11 ][ XGINew_RAMType ] ) ;   /* CR82 */
1100     else
1101     XGINew_SetReg1( P3d4 , 0x82 , 0xA8 ) ;      /* CR82 */
1102
1103     XGINew_SetReg1( P3d4 , 0x98 , 0x01 ) ;
1104     XGINew_SetReg1( P3d4 , 0x9A , 0x02 ) ;
1105     if ( HwDeviceExtension->jChipType == XG27 )
1106        XGINew_DDRII_Bootup_XG27( HwDeviceExtension ,  P3c4 , pVBInfo) ;
1107     else
1108     XGINew_DDR2_MRS_XG20( HwDeviceExtension , P3c4, pVBInfo ) ;
1109 }
1110
1111
1112 /* --------------------------------------------------------------------- */
1113 /* Function : XGINew_SetDRAMDefaultRegister340 */
1114 /* Input : */
1115 /* Output : */
1116 /* Description : */
1117 /* --------------------------------------------------------------------- */
1118 void XGINew_SetDRAMDefaultRegister340( PXGI_HW_DEVICE_INFO HwDeviceExtension ,  ULONG Port , PVB_DEVICE_INFO pVBInfo)
1119 {
1120     UCHAR temp , temp1 , temp2 , temp3 ,
1121           i , j , k ;
1122
1123     ULONG P3d4 = Port ,
1124            P3c4 = Port - 0x10 ;
1125
1126     XGINew_SetReg1( P3d4 , 0x6D , pVBInfo->CR40[ 8 ][ XGINew_RAMType ] ) ;
1127     XGINew_SetReg1( P3d4 , 0x68 , pVBInfo->CR40[ 5 ][ XGINew_RAMType ] ) ;
1128     XGINew_SetReg1( P3d4 , 0x69 , pVBInfo->CR40[ 6 ][ XGINew_RAMType ] ) ;
1129     XGINew_SetReg1( P3d4 , 0x6A , pVBInfo->CR40[ 7 ][ XGINew_RAMType ] ) ;
1130
1131     temp2 = 0 ;
1132     for( i = 0 ; i < 4 ; i++ )
1133     {
1134         temp = pVBInfo->CR6B[ XGINew_RAMType ][ i ] ;                   /* CR6B DQS fine tune delay */
1135         for( j = 0 ; j < 4 ; j++ )
1136         {
1137             temp1 = ( ( temp >> ( 2 * j ) ) & 0x03 ) << 2 ;
1138             temp2 |= temp1 ;
1139             XGINew_SetReg1( P3d4 , 0x6B , temp2 ) ;
1140             XGINew_GetReg1( P3d4 , 0x6B ) ;                             /* Insert read command for delay */
1141             temp2 &= 0xF0 ;
1142             temp2 += 0x10 ;
1143         }
1144     }
1145
1146     temp2 = 0 ;
1147     for( i = 0 ; i < 4 ; i++ )
1148     {
1149         temp = pVBInfo->CR6E[ XGINew_RAMType ][ i ] ;                   /* CR6E DQM fine tune delay */
1150         for( j = 0 ; j < 4 ; j++ )
1151         {
1152             temp1 = ( ( temp >> ( 2 * j ) ) & 0x03 ) << 2 ;
1153             temp2 |= temp1 ;
1154             XGINew_SetReg1( P3d4 , 0x6E , temp2 ) ;
1155             XGINew_GetReg1( P3d4 , 0x6E ) ;                             /* Insert read command for delay */
1156             temp2 &= 0xF0 ;
1157             temp2 += 0x10 ;
1158         }
1159     }
1160
1161     temp3 = 0 ;
1162     for( k = 0 ; k < 4 ; k++ )
1163     {
1164         XGINew_SetRegANDOR( P3d4 , 0x6E , 0xFC , temp3 ) ;              /* CR6E_D[1:0] select channel */
1165         temp2 = 0 ;
1166         for( i = 0 ; i < 8 ; i++ )
1167         {
1168             temp = pVBInfo->CR6F[ XGINew_RAMType ][ 8 * k + i ] ;       /* CR6F DQ fine tune delay */
1169             for( j = 0 ; j < 4 ; j++ )
1170             {
1171                 temp1 = ( temp >> ( 2 * j ) ) & 0x03 ;
1172                 temp2 |= temp1 ;
1173                 XGINew_SetReg1( P3d4 , 0x6F , temp2 ) ;
1174                 XGINew_GetReg1( P3d4 , 0x6F ) ;                         /* Insert read command for delay */
1175                 temp2 &= 0xF8 ;
1176                 temp2 += 0x08 ;
1177             }
1178         }
1179         temp3 += 0x01 ;
1180     }
1181
1182     XGINew_SetReg1( P3d4 , 0x80 , pVBInfo->CR40[ 9 ][ XGINew_RAMType ] ) ;      /* CR80 */
1183     XGINew_SetReg1( P3d4 , 0x81 , pVBInfo->CR40[ 10 ][ XGINew_RAMType ] ) ;     /* CR81 */
1184
1185     temp2 = 0x80 ;
1186     temp = pVBInfo->CR89[ XGINew_RAMType ][ 0 ] ;                       /* CR89 terminator type select */
1187     for( j = 0 ; j < 4 ; j++ )
1188     {
1189         temp1 = ( temp >> ( 2 * j ) ) & 0x03 ;
1190         temp2 |= temp1 ;
1191         XGINew_SetReg1( P3d4 , 0x89 , temp2 ) ;
1192         XGINew_GetReg1( P3d4 , 0x89 ) ;                         /* Insert read command for delay */
1193         temp2 &= 0xF0 ;
1194         temp2 += 0x10 ;
1195     }
1196
1197     temp = pVBInfo->CR89[ XGINew_RAMType ][ 1 ] ;
1198     temp1 = temp & 0x03 ;
1199     temp2 |= temp1 ;
1200     XGINew_SetReg1( P3d4 , 0x89 , temp2 ) ;
1201
1202     temp = pVBInfo->CR40[ 3 ][ XGINew_RAMType ] ;
1203     temp1 = temp & 0x0F ;
1204     temp2 = ( temp >> 4 ) & 0x07 ;
1205     temp3 = temp & 0x80 ;
1206     XGINew_SetReg1( P3d4 , 0x45 , temp1 ) ;     /* CR45 */
1207     XGINew_SetReg1( P3d4 , 0x99 , temp2 ) ;     /* CR99 */
1208     XGINew_SetRegOR( P3d4 , 0x40 , temp3 ) ;    /* CR40_D[7] */
1209     XGINew_SetReg1( P3d4 , 0x41 , pVBInfo->CR40[ 0 ][ XGINew_RAMType ] ) ;      /* CR41 */
1210
1211     if ( HwDeviceExtension->jChipType == XG27 )
1212       XGINew_SetReg1( P3d4 , 0x8F , *pVBInfo->pCR8F ) ; /* CR8F */
1213
1214     for( j = 0 ; j <= 6 ; j++ )
1215         XGINew_SetReg1( P3d4 , ( 0x90 + j ) , pVBInfo->CR40[ 14 + j ][ XGINew_RAMType ] ) ;     /* CR90 - CR96 */
1216
1217     for( j = 0 ; j <= 2 ; j++ )
1218         XGINew_SetReg1( P3d4 , ( 0xC3 + j ) , pVBInfo->CR40[ 21 + j ][ XGINew_RAMType ] ) ;     /* CRC3 - CRC5 */
1219
1220     for( j = 0 ; j < 2 ; j++ )
1221         XGINew_SetReg1( P3d4 , ( 0x8A + j ) , pVBInfo->CR40[ 1 + j ][ XGINew_RAMType ] ) ;      /* CR8A - CR8B */
1222
1223     if ( ( HwDeviceExtension->jChipType == XG41 ) || ( HwDeviceExtension->jChipType == XG42 ) )
1224         XGINew_SetReg1( P3d4 , 0x8C , 0x87 ) ;
1225
1226     XGINew_SetReg1( P3d4 , 0x59 , pVBInfo->CR40[ 4 ][ XGINew_RAMType ] ) ;      /* CR59 */
1227
1228     XGINew_SetReg1( P3d4 , 0x83 , 0x09 ) ;      /* CR83 */
1229     XGINew_SetReg1( P3d4 , 0x87 , 0x00 ) ;      /* CR87 */
1230     XGINew_SetReg1( P3d4 , 0xCF , *pVBInfo->pCRCF ) ;   /* CRCF */
1231     if ( XGINew_RAMType )
1232     {
1233       //XGINew_SetReg1( P3c4 , 0x17 , 0xC0 ) ;          /* SR17 DDRII */
1234       XGINew_SetReg1( P3c4 , 0x17 , 0x80 ) ;            /* SR17 DDRII */
1235       if ( HwDeviceExtension->jChipType == XG27 )
1236         XGINew_SetReg1( P3c4 , 0x17 , 0x02 ) ;          /* SR17 DDRII */
1237
1238     }
1239     else
1240       XGINew_SetReg1( P3c4 , 0x17 , 0x00 ) ;            /* SR17 DDR */
1241     XGINew_SetReg1( P3c4 , 0x1A , 0x87 ) ;              /* SR1A */
1242
1243     temp = XGINew_GetXG20DRAMType( HwDeviceExtension, pVBInfo) ;
1244     if( temp == 0 )
1245       XGINew_DDR1x_DefaultRegister( HwDeviceExtension, P3d4, pVBInfo ) ;
1246     else
1247     {
1248       XGINew_SetReg1( P3d4 , 0xB0 , 0x80 ) ;            /* DDRII Dual frequency mode */
1249       XGINew_DDR2_DefaultRegister( HwDeviceExtension, P3d4, pVBInfo ) ;
1250     }
1251     XGINew_SetReg1( P3c4 , 0x1B , pVBInfo->SR15[ 3 ][ XGINew_RAMType ] ) ;      /* SR1B */
1252 }
1253
1254
1255 /* --------------------------------------------------------------------- */
1256 /* Function : XGINew_DDR_MRS */
1257 /* Input : */
1258 /* Output : */
1259 /* Description : */
1260 /* --------------------------------------------------------------------- */
1261 void XGINew_DDR_MRS(PVB_DEVICE_INFO pVBInfo)
1262 {
1263     USHORT data ;
1264
1265     PUCHAR volatile pVideoMemory = ( PUCHAR )pVBInfo->ROMAddr ;
1266
1267     /* SR16 <- 1F,DF,2F,AF */
1268     /* yriver modified SR16 <- 0F,DF,0F,AF */
1269     /* enable DLL of DDR SD/SGRAM , SR16 D4=1 */
1270     data = pVideoMemory[ 0xFB ] ;
1271     /* data = XGINew_GetReg1( pVBInfo->P3c4 , 0x16 ) ; */
1272
1273     data &= 0x0F ;
1274     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;
1275     data |= 0xC0 ;
1276     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;
1277     data &= 0x0F ;
1278     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;
1279     data |= 0x80 ;
1280     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;
1281     data &= 0x0F ;
1282     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;
1283     data |= 0xD0 ;
1284     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;
1285     data &= 0x0F ;
1286     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;
1287     data |= 0xA0 ;
1288     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , data ) ;
1289 /*
1290    else {
1291      data &= 0x0F;
1292      data |= 0x10;
1293      XGINew_SetReg1(pVBInfo->P3c4,0x16,data);
1294
1295      if (!(pVBInfo->SR15[1][XGINew_RAMType] & 0x10))
1296      {
1297        data &= 0x0F;
1298      }
1299
1300      data |= 0xC0;
1301      XGINew_SetReg1(pVBInfo->P3c4,0x16,data);
1302
1303
1304      data &= 0x0F;
1305      data |= 0x20;
1306      XGINew_SetReg1(pVBInfo->P3c4,0x16,data);
1307      if (!(pVBInfo->SR15[1][XGINew_RAMType] & 0x10))
1308      {
1309        data &= 0x0F;
1310      }
1311
1312      data |= 0x80;
1313      XGINew_SetReg1(pVBInfo->P3c4,0x16,data);
1314    }
1315 */
1316 }
1317
1318
1319 /* check if read cache pointer is correct */
1320
1321
1322
1323 /* --------------------------------------------------------------------- */
1324 /* Function : XGINew_VerifyMclk */
1325 /* Input : */
1326 /* Output : */
1327 /* Description : */
1328 /* --------------------------------------------------------------------- */
1329 void XGINew_VerifyMclk( PXGI_HW_DEVICE_INFO  HwDeviceExtension , PVB_DEVICE_INFO pVBInfo)
1330 {
1331     PUCHAR pVideoMemory = pVBInfo->FBAddr ;
1332     UCHAR i , j ;
1333     USHORT Temp , SR21 ;
1334
1335     pVideoMemory[ 0 ] = 0xaa ;          /* alan */
1336     pVideoMemory[ 16 ] = 0x55 ;         /* note: PCI read cache is off */
1337
1338     if ( ( pVideoMemory[ 0 ] != 0xaa ) || ( pVideoMemory[ 16 ] != 0x55 ) )
1339     {
1340         for( i = 0 , j = 16 ; i < 2 ; i++ , j += 16 )
1341         {
1342             SR21 = XGINew_GetReg1( pVBInfo->P3c4 , 0x21 ) ;
1343             Temp = SR21 & 0xFB ;        /* disable PCI post write buffer empty gating */
1344             XGINew_SetReg1( pVBInfo->P3c4 , 0x21 , Temp ) ;
1345
1346             Temp = XGINew_GetReg1( pVBInfo->P3c4 , 0x3C ) ;
1347             Temp |= 0x01 ;              /* MCLK reset */
1348
1349
1350             Temp = XGINew_GetReg1( pVBInfo->P3c4 , 0x3C ) ;
1351             Temp &= 0xFE ;              /* MCLK normal operation */
1352
1353             XGINew_SetReg1( pVBInfo->P3c4 , 0x21 , SR21 ) ;
1354
1355             pVideoMemory[ 16 + j ] = j ;
1356             if ( pVideoMemory[ 16 + j ] == j )
1357             {
1358                 pVideoMemory[ j ] = j ;
1359                 break ;
1360             }
1361         }
1362     }
1363 }
1364
1365
1366
1367
1368
1369 /* --------------------------------------------------------------------- */
1370 /* Function : XGINew_SetDRAMSize_340 */
1371 /* Input : */
1372 /* Output : */
1373 /* Description : */
1374 /* --------------------------------------------------------------------- */
1375 void XGINew_SetDRAMSize_340( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo)
1376 {
1377     USHORT  data ;
1378
1379     pVBInfo->ROMAddr = HwDeviceExtension->pjVirtualRomBase ;
1380     pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress ;
1381
1382     XGISetModeNew( HwDeviceExtension , 0x2e ) ;
1383
1384
1385     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x21 ) ;
1386     XGINew_SetReg1( pVBInfo->P3c4 , 0x21 , ( USHORT )( data & 0xDF ) ) ;        /* disable read cache */
1387     XGI_DisplayOff( HwDeviceExtension, pVBInfo );
1388
1389     /*data = XGINew_GetReg1( pVBInfo->P3c4 , 0x1 ) ;*/
1390     /*data |= 0x20 ;*/
1391     /*XGINew_SetReg1( pVBInfo->P3c4 , 0x01 , data ) ;*/                 /* Turn OFF Display */
1392     XGINew_DDRSizing340( HwDeviceExtension, pVBInfo ) ;
1393     data=XGINew_GetReg1( pVBInfo->P3c4 , 0x21 ) ;
1394     XGINew_SetReg1( pVBInfo->P3c4 , 0x21 , ( USHORT )( data | 0x20 ) ) ;        /* enable read cache */
1395
1396 }
1397
1398
1399 /* --------------------------------------------------------------------- */
1400 /* Function : */
1401 /* Input : */
1402 /* Output : */
1403 /* Description : */
1404 /* --------------------------------------------------------------------- */
1405 void XGINew_SetDRAMSize_310( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo)
1406 {
1407     USHORT data ;
1408     pVBInfo->ROMAddr  = HwDeviceExtension->pjVirtualRomBase ,
1409     pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress ;
1410 #ifdef XGI301
1411     /* XGINew_SetReg1( pVBInfo->P3d4 , 0x30 , 0x40 ) ; */
1412 #endif
1413
1414 #ifdef XGI302   /* alan,should change value */
1415     XGINew_SetReg1( pVBInfo->P3d4 , 0x30 , 0x4D ) ;
1416     XGINew_SetReg1( pVBInfo->P3d4 , 0x31 , 0xc0 ) ;
1417     XGINew_SetReg1( pVBInfo->P3d4 , 0x34 , 0x3F ) ;
1418 #endif
1419
1420     XGISetModeNew( HwDeviceExtension , 0x2e ) ;
1421
1422     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x21 ) ;
1423     XGINew_SetReg1( pVBInfo->P3c4 , 0x21 , ( USHORT )( data & 0xDF ) ) ;        /* disable read cache */
1424
1425     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x1 ) ;
1426     data |= 0x20 ;
1427     XGINew_SetReg1( pVBInfo->P3c4 , 0x01 , data ) ;             /* Turn OFF Display */
1428
1429     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x16 ) ;
1430
1431
1432     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , ( USHORT )( data | 0x0F ) ) ;                /* assume lowest speed DRAM */
1433
1434     XGINew_SetDRAMModeRegister( pVBInfo ) ;
1435     XGINew_DisableRefresh( HwDeviceExtension, pVBInfo ) ;
1436     XGINew_CheckBusWidth_310( pVBInfo) ;
1437     XGINew_VerifyMclk( HwDeviceExtension, pVBInfo ) ;   /* alan 2000/7/3 */
1438
1439
1440
1441     if ( XGINew_Get310DRAMType( pVBInfo ) < 2 )
1442     {
1443         XGINew_SDRSizing( pVBInfo ) ;
1444     }
1445     else
1446     {
1447         XGINew_DDRSizing( pVBInfo) ;
1448     }
1449
1450
1451
1452
1453     XGINew_SetReg1( pVBInfo->P3c4 , 0x16 , pVBInfo->SR15[ 1 ][ XGINew_RAMType ] ) ;     /* restore SR16 */
1454
1455     XGINew_EnableRefresh(  HwDeviceExtension, pVBInfo ) ;
1456     data=XGINew_GetReg1( pVBInfo->P3c4 ,0x21 ) ;
1457     XGINew_SetReg1( pVBInfo->P3c4 , 0x21 , ( USHORT )( data | 0x20 ) ) ;        /* enable read cache */
1458 }
1459
1460
1461
1462 /* --------------------------------------------------------------------- */
1463 /* Function : XGINew_SetDRAMModeRegister340 */
1464 /* Input : */
1465 /* Output : */
1466 /* Description : */
1467 /* --------------------------------------------------------------------- */
1468
1469 void XGINew_SetDRAMModeRegister340( PXGI_HW_DEVICE_INFO HwDeviceExtension )
1470 {
1471     UCHAR data ;
1472     VB_DEVICE_INFO VBINF;
1473     PVB_DEVICE_INFO pVBInfo = &VBINF;
1474     pVBInfo->ROMAddr = HwDeviceExtension->pjVirtualRomBase ;
1475     pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress ;
1476     pVBInfo->BaseAddr = (ULONG)HwDeviceExtension->pjIOAddress ;
1477     pVBInfo->ISXPDOS = 0 ;
1478
1479     pVBInfo->P3c4 = pVBInfo->BaseAddr + 0x14 ;
1480     pVBInfo->P3d4 = pVBInfo->BaseAddr + 0x24 ;
1481     pVBInfo->P3c0 = pVBInfo->BaseAddr + 0x10 ;
1482     pVBInfo->P3ce = pVBInfo->BaseAddr + 0x1e ;
1483     pVBInfo->P3c2 = pVBInfo->BaseAddr + 0x12 ;
1484     pVBInfo->P3ca = pVBInfo->BaseAddr + 0x1a ;
1485     pVBInfo->P3c6 = pVBInfo->BaseAddr + 0x16 ;
1486     pVBInfo->P3c7 = pVBInfo->BaseAddr + 0x17 ;
1487     pVBInfo->P3c8 = pVBInfo->BaseAddr + 0x18 ;
1488     pVBInfo->P3c9 = pVBInfo->BaseAddr + 0x19 ;
1489     pVBInfo->P3da = pVBInfo->BaseAddr + 0x2A ;
1490     pVBInfo->Part0Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_00 ;
1491     pVBInfo->Part1Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_04 ;
1492     pVBInfo->Part2Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_10 ;
1493     pVBInfo->Part3Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_12 ;
1494     pVBInfo->Part4Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 ;
1495     pVBInfo->Part5Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 + 2 ;
1496     if ( HwDeviceExtension->jChipType < XG20 )                  /* kuku 2004/06/25 */
1497     XGI_GetVBType( pVBInfo ) ;         /* Run XGI_GetVBType before InitTo330Pointer */
1498
1499     InitTo330Pointer(HwDeviceExtension->jChipType,pVBInfo);
1500
1501     ReadVBIOSTablData( HwDeviceExtension->jChipType , pVBInfo) ;
1502
1503     if ( XGINew_GetXG20DRAMType( HwDeviceExtension, pVBInfo) == 0 )
1504     {
1505         data = ( XGINew_GetReg1( pVBInfo->P3c4 , 0x39 ) & 0x02 ) >> 1 ;
1506         if ( data == 0x01 )
1507             XGINew_DDR2x_MRS_340( pVBInfo->P3c4, pVBInfo ) ;
1508         else
1509             XGINew_DDR1x_MRS_340( pVBInfo->P3c4, pVBInfo ) ;
1510     }
1511     else
1512         XGINew_DDR2_MRS_XG20( HwDeviceExtension, pVBInfo->P3c4, pVBInfo);
1513
1514     XGINew_SetReg1( pVBInfo->P3c4 , 0x1B , 0x03 ) ;
1515 }
1516
1517 /* --------------------------------------------------------------------- */
1518 /* Function : XGINew_SetDRAMModeRegister */
1519 /* Input : */
1520 /* Output : */
1521 /* Description : */
1522 /* --------------------------------------------------------------------- */
1523 void XGINew_SetDRAMModeRegister( PVB_DEVICE_INFO pVBInfo)
1524 {
1525     if ( XGINew_Get310DRAMType( pVBInfo ) < 2 )
1526     {
1527       XGINew_SDR_MRS(pVBInfo ) ;
1528     }
1529     else
1530     {
1531       /* SR16 <- 0F,CF,0F,8F */
1532       XGINew_DDR_MRS( pVBInfo ) ;
1533     }
1534 }
1535
1536
1537 /* --------------------------------------------------------------------- */
1538 /* Function : XGINew_DisableRefresh */
1539 /* Input : */
1540 /* Output : */
1541 /* Description : */
1542 /* --------------------------------------------------------------------- */
1543 void XGINew_DisableRefresh( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo)
1544 {
1545     USHORT  data ;
1546
1547
1548     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x1B ) ;
1549     data &= 0xF8 ;
1550     XGINew_SetReg1( pVBInfo->P3c4 , 0x1B , data ) ;
1551
1552 }
1553
1554
1555 /* --------------------------------------------------------------------- */
1556 /* Function : XGINew_EnableRefresh */
1557 /* Input : */
1558 /* Output : */
1559 /* Description : */
1560 /* --------------------------------------------------------------------- */
1561 void XGINew_EnableRefresh( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo)
1562 {
1563
1564     XGINew_SetReg1( pVBInfo->P3c4 , 0x1B , pVBInfo->SR15[ 3 ][ XGINew_RAMType ] ) ;     /* SR1B */
1565
1566
1567 }
1568
1569
1570 /* --------------------------------------------------------------------- */
1571 /* Function : XGINew_DisableChannelInterleaving */
1572 /* Input : */
1573 /* Output : */
1574 /* Description : */
1575 /* --------------------------------------------------------------------- */
1576 void XGINew_DisableChannelInterleaving( int index , USHORT XGINew_DDRDRAM_TYPE[][ 5 ] , PVB_DEVICE_INFO pVBInfo)
1577 {
1578     USHORT data ;
1579
1580     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x15 ) ;
1581     data &= 0x1F ;
1582
1583     switch( XGINew_DDRDRAM_TYPE[ index ][ 3 ] )
1584     {
1585         case 64:
1586             data |= 0 ;
1587             break ;
1588         case 32:
1589             data |= 0x20 ;
1590             break ;
1591         case 16:
1592             data |= 0x40 ;
1593             break ;
1594         case 4:
1595             data |= 0x60 ;
1596             break ;
1597         default:
1598             break ;
1599     }
1600     XGINew_SetReg1( pVBInfo->P3c4 , 0x15 , data ) ;
1601 }
1602
1603
1604 /* --------------------------------------------------------------------- */
1605 /* Function : XGINew_SetDRAMSizingType */
1606 /* Input : */
1607 /* Output : */
1608 /* Description : */
1609 /* --------------------------------------------------------------------- */
1610 void XGINew_SetDRAMSizingType( int index , USHORT DRAMTYPE_TABLE[][ 5 ] ,PVB_DEVICE_INFO pVBInfo)
1611 {
1612     USHORT data ;
1613
1614     data = DRAMTYPE_TABLE[ index ][ 4 ] ;
1615     XGINew_SetRegANDOR( pVBInfo->P3c4 , 0x13 , 0x80 , data ) ;
1616     DelayUS( 15 ) ;
1617    /* should delay 50 ns */
1618 }
1619
1620
1621 /* --------------------------------------------------------------------- */
1622 /* Function : XGINew_CheckBusWidth_310 */
1623 /* Input : */
1624 /* Output : */
1625 /* Description : */
1626 /* --------------------------------------------------------------------- */
1627 void XGINew_CheckBusWidth_310(  PVB_DEVICE_INFO pVBInfo)
1628 {
1629     USHORT data ;
1630     PULONG volatile pVideoMemory ;
1631
1632     pVideoMemory = (PULONG) pVBInfo->FBAddr;
1633
1634     if ( XGINew_Get310DRAMType( pVBInfo ) < 2 )
1635     {
1636         XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x00 ) ;
1637         XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x12 ) ;
1638         /* should delay */
1639         XGINew_SDR_MRS( pVBInfo ) ;
1640
1641         XGINew_ChannelAB = 0 ;
1642         XGINew_DataBusWidth = 128 ;
1643         pVideoMemory[ 0 ] = 0x01234567L ;
1644         pVideoMemory[ 1 ] = 0x456789ABL ;
1645         pVideoMemory[ 2 ] = 0x89ABCDEFL ;
1646         pVideoMemory[ 3 ] = 0xCDEF0123L ;
1647         pVideoMemory[ 4 ] = 0x55555555L ;
1648         pVideoMemory[ 5 ] = 0x55555555L ;
1649         pVideoMemory[ 6 ] = 0xFFFFFFFFL ;
1650         pVideoMemory[ 7 ] = 0xFFFFFFFFL ;
1651
1652         if ( ( pVideoMemory[ 3 ] != 0xCDEF0123L ) || ( pVideoMemory[ 2 ] != 0x89ABCDEFL ) )
1653         {
1654             /* ChannelA64Bit */
1655             XGINew_DataBusWidth = 64 ;
1656             XGINew_ChannelAB = 0 ;
1657             data=XGINew_GetReg1( pVBInfo->P3c4 , 0x14 ) ;
1658             XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , ( USHORT )( data & 0xFD ) ) ;
1659         }
1660
1661         if ( ( pVideoMemory[ 1 ] != 0x456789ABL ) || ( pVideoMemory[ 0 ] != 0x01234567L ) )
1662         {
1663             /* ChannelB64Bit */
1664             XGINew_DataBusWidth = 64 ;
1665             XGINew_ChannelAB = 1 ;
1666             data=XGINew_GetReg1( pVBInfo->P3c4 , 0x14 ) ;
1667             XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , ( USHORT )( ( data & 0xFD ) | 0x01 ) ) ;
1668         }
1669
1670         return ;
1671     }
1672     else
1673     {
1674         /* DDR Dual channel */
1675         XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x00 ) ;
1676         XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x02 ) ; /* Channel A, 64bit */
1677         /* should delay */
1678         XGINew_DDR_MRS( pVBInfo ) ;
1679
1680         XGINew_ChannelAB = 0 ;
1681         XGINew_DataBusWidth = 64 ;
1682         pVideoMemory[ 0 ] = 0x01234567L ;
1683         pVideoMemory[ 1 ] = 0x456789ABL ;
1684         pVideoMemory[ 2 ] = 0x89ABCDEFL ;
1685         pVideoMemory[ 3 ] = 0xCDEF0123L ;
1686         pVideoMemory[ 4 ] = 0x55555555L ;
1687         pVideoMemory[ 5 ] = 0x55555555L ;
1688         pVideoMemory[ 6 ] = 0xAAAAAAAAL ;
1689         pVideoMemory[ 7 ] = 0xAAAAAAAAL ;
1690
1691         if ( pVideoMemory[ 1 ] == 0x456789ABL )
1692         {
1693             if ( pVideoMemory[ 0 ] == 0x01234567L )
1694             {
1695                 /* Channel A 64bit */
1696                 return ;
1697             }
1698         }
1699         else
1700         {
1701             if ( pVideoMemory[ 0 ] == 0x01234567L )
1702             {
1703                 /* Channel A 32bit */
1704                 XGINew_DataBusWidth = 32 ;
1705                 XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x00 ) ;
1706                 return ;
1707             }
1708         }
1709
1710         XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x03 ) ; /* Channel B, 64bit */
1711         XGINew_DDR_MRS( pVBInfo);
1712
1713         XGINew_ChannelAB = 1 ;
1714         XGINew_DataBusWidth = 64 ;
1715         pVideoMemory[ 0 ] = 0x01234567L ;
1716         pVideoMemory[ 1 ] = 0x456789ABL ;
1717         pVideoMemory[ 2 ] = 0x89ABCDEFL ;
1718         pVideoMemory[ 3 ] = 0xCDEF0123L ;
1719         pVideoMemory[ 4 ] = 0x55555555L ;
1720         pVideoMemory[ 5 ] = 0x55555555L ;
1721         pVideoMemory[ 6 ] = 0xAAAAAAAAL ;
1722         pVideoMemory[ 7 ] = 0xAAAAAAAAL ;
1723
1724         if ( pVideoMemory[ 1 ] == 0x456789ABL )
1725         {
1726             /* Channel B 64 */
1727             if ( pVideoMemory[ 0 ] == 0x01234567L )
1728             {
1729                 /* Channel B 64bit */
1730                 return ;
1731             }
1732             else
1733             {
1734                 /* error */
1735             }
1736         }
1737         else
1738         {
1739             if ( pVideoMemory[ 0 ] == 0x01234567L )
1740             {
1741                 /* Channel B 32 */
1742                 XGINew_DataBusWidth = 32 ;
1743                 XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x01 ) ;
1744             }
1745             else
1746             {
1747                 /* error */
1748             }
1749         }
1750     }
1751 }
1752
1753
1754 /* --------------------------------------------------------------------- */
1755 /* Function : XGINew_SetRank */
1756 /* Input : */
1757 /* Output : */
1758 /* Description : */
1759 /* --------------------------------------------------------------------- */
1760 int XGINew_SetRank( int index , UCHAR RankNo , UCHAR XGINew_ChannelAB , USHORT DRAMTYPE_TABLE[][ 5 ] , PVB_DEVICE_INFO pVBInfo)
1761 {
1762     USHORT data ;
1763     int RankSize ;
1764
1765     if ( ( RankNo == 2 ) && ( DRAMTYPE_TABLE[ index ][ 0 ] == 2 ) )
1766         return 0 ;
1767
1768     RankSize = DRAMTYPE_TABLE[ index ][ 3 ] / 2 * XGINew_DataBusWidth / 32 ;
1769
1770     if ( ( RankNo * RankSize ) <= 128 )
1771     {
1772         data = 0 ;
1773
1774         while( ( RankSize >>= 1 ) > 0 )
1775         {
1776             data += 0x10 ;
1777         }
1778         data |= ( RankNo - 1 ) << 2 ;
1779         data |= ( XGINew_DataBusWidth / 64 ) & 2 ;
1780         data |= XGINew_ChannelAB ;
1781         XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , data ) ;
1782         /* should delay */
1783         XGINew_SDR_MRS( pVBInfo ) ;
1784         return( 1 ) ;
1785     }
1786     else
1787         return( 0 ) ;
1788 }
1789
1790
1791 /* --------------------------------------------------------------------- */
1792 /* Function : XGINew_SetDDRChannel */
1793 /* Input : */
1794 /* Output : */
1795 /* Description : */
1796 /* --------------------------------------------------------------------- */
1797 int XGINew_SetDDRChannel( int index , UCHAR ChannelNo , UCHAR XGINew_ChannelAB , USHORT DRAMTYPE_TABLE[][ 5 ] , PVB_DEVICE_INFO pVBInfo)
1798 {
1799     USHORT  data ;
1800     int RankSize ;
1801
1802     RankSize = DRAMTYPE_TABLE[index][3]/2 * XGINew_DataBusWidth/32;
1803     /* RankSize = DRAMTYPE_TABLE[ index ][ 3 ] ; */
1804     if ( ChannelNo * RankSize <= 128 )
1805     {
1806         data = 0 ;
1807         while( ( RankSize >>= 1 ) > 0 )
1808         {
1809             data += 0x10 ;
1810         }
1811
1812         if ( ChannelNo == 2 )
1813             data |= 0x0C ;
1814
1815         data |= ( XGINew_DataBusWidth / 32 ) & 2 ;
1816         data |= XGINew_ChannelAB ;
1817         XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , data ) ;
1818         /* should delay */
1819         XGINew_DDR_MRS( pVBInfo ) ;
1820         return( 1 ) ;
1821     }
1822     else
1823         return( 0 ) ;
1824 }
1825
1826
1827 /* --------------------------------------------------------------------- */
1828 /* Function : XGINew_CheckColumn */
1829 /* Input : */
1830 /* Output : */
1831 /* Description : */
1832 /* --------------------------------------------------------------------- */
1833 int XGINew_CheckColumn( int index , USHORT DRAMTYPE_TABLE[][ 5 ], PVB_DEVICE_INFO pVBInfo)
1834 {
1835     int i ;
1836     ULONG Increment , Position ;
1837
1838     /* Increment = 1 << ( DRAMTYPE_TABLE[ index ][ 2 ] + XGINew_DataBusWidth / 64 + 1 ) ; */
1839     Increment = 1 << ( 10 + XGINew_DataBusWidth / 64 ) ;
1840
1841     for( i = 0 , Position = 0 ; i < 2 ; i++ )
1842     {
1843         *( ( PULONG )( pVBInfo->FBAddr + Position ) ) = Position ;
1844         Position += Increment ;
1845     }
1846
1847
1848     for( i = 0 , Position = 0 ; i < 2 ; i++ )
1849     {
1850         /* if ( pVBInfo->FBAddr[ Position ] != Position ) */
1851         if ( ( *( PULONG )( pVBInfo->FBAddr + Position ) ) != Position )
1852             return( 0 ) ;
1853         Position += Increment ;
1854     }
1855     return( 1 ) ;
1856 }
1857
1858
1859 /* --------------------------------------------------------------------- */
1860 /* Function : XGINew_CheckBanks */
1861 /* Input : */
1862 /* Output : */
1863 /* Description : */
1864 /* --------------------------------------------------------------------- */
1865 int XGINew_CheckBanks( int index , USHORT DRAMTYPE_TABLE[][ 5 ], PVB_DEVICE_INFO pVBInfo)
1866 {
1867     int i ;
1868     ULONG Increment , Position ;
1869
1870     Increment = 1 << ( DRAMTYPE_TABLE[ index ][ 2 ] + XGINew_DataBusWidth / 64 + 2 ) ;
1871
1872     for( i = 0 , Position = 0 ; i < 4 ; i++ )
1873     {
1874         /* pVBInfo->FBAddr[ Position ] = Position ; */
1875         *( ( PULONG )( pVBInfo->FBAddr + Position ) ) = Position ;
1876         Position += Increment ;
1877     }
1878
1879     for( i = 0 , Position = 0 ; i < 4 ; i++ )
1880     {
1881         /* if (pVBInfo->FBAddr[ Position ] != Position ) */
1882         if ( ( *( PULONG )( pVBInfo->FBAddr + Position ) ) != Position )
1883             return( 0 ) ;
1884         Position += Increment ;
1885     }
1886     return( 1 ) ;
1887 }
1888
1889
1890 /* --------------------------------------------------------------------- */
1891 /* Function : XGINew_CheckRank */
1892 /* Input : */
1893 /* Output : */
1894 /* Description : */
1895 /* --------------------------------------------------------------------- */
1896 int XGINew_CheckRank( int RankNo , int index , USHORT DRAMTYPE_TABLE[][ 5 ], PVB_DEVICE_INFO pVBInfo)
1897 {
1898     int i ;
1899     ULONG Increment , Position ;
1900
1901     Increment = 1 << ( DRAMTYPE_TABLE[ index ][ 2 ] + DRAMTYPE_TABLE[ index ][ 1 ] +
1902                   DRAMTYPE_TABLE[ index ][ 0 ] + XGINew_DataBusWidth / 64 + RankNo ) ;
1903
1904     for( i = 0 , Position = 0 ; i < 2 ; i++ )
1905     {
1906         /* pVBInfo->FBAddr[ Position ] = Position ; */
1907         /* *( ( PULONG )( pVBInfo->FBAddr ) ) = Position ; */
1908         *( ( PULONG )( pVBInfo->FBAddr + Position ) ) = Position ;
1909         Position += Increment ;
1910     }
1911
1912     for( i = 0 , Position = 0 ; i < 2 ; i++ )
1913     {
1914         /* if ( pVBInfo->FBAddr[ Position ] != Position ) */
1915         /* if ( ( *( PULONG )( pVBInfo->FBAddr ) ) != Position ) */
1916         if ( ( *( PULONG )( pVBInfo->FBAddr + Position ) ) != Position )
1917             return( 0 ) ;
1918         Position += Increment ;
1919     }
1920     return( 1 );
1921 }
1922
1923
1924 /* --------------------------------------------------------------------- */
1925 /* Function : XGINew_CheckDDRRank */
1926 /* Input : */
1927 /* Output : */
1928 /* Description : */
1929 /* --------------------------------------------------------------------- */
1930 int XGINew_CheckDDRRank( int RankNo , int index , USHORT DRAMTYPE_TABLE[][ 5 ], PVB_DEVICE_INFO pVBInfo)
1931 {
1932     ULONG Increment , Position ;
1933     USHORT data ;
1934
1935     Increment = 1 << ( DRAMTYPE_TABLE[ index ][ 2 ] + DRAMTYPE_TABLE[ index ][ 1 ] +
1936                        DRAMTYPE_TABLE[ index ][ 0 ] + XGINew_DataBusWidth / 64 + RankNo ) ;
1937
1938     Increment += Increment / 2 ;
1939
1940     Position = 0;
1941     *( ( PULONG )( pVBInfo->FBAddr + Position + 0 ) ) = 0x01234567 ;
1942     *( ( PULONG )( pVBInfo->FBAddr + Position + 1 ) ) = 0x456789AB ;
1943     *( ( PULONG )( pVBInfo->FBAddr + Position + 2 ) ) = 0x55555555 ;
1944     *( ( PULONG )( pVBInfo->FBAddr + Position + 3 ) ) = 0x55555555 ;
1945     *( ( PULONG )( pVBInfo->FBAddr + Position + 4 ) ) = 0xAAAAAAAA ;
1946     *( ( PULONG )( pVBInfo->FBAddr + Position + 5 ) ) = 0xAAAAAAAA ;
1947
1948     if ( ( *( PULONG )( pVBInfo->FBAddr + 1 ) ) == 0x456789AB )
1949         return( 1 ) ;
1950
1951     if ( ( *( PULONG )( pVBInfo->FBAddr + 0 ) ) == 0x01234567 )
1952         return( 0 ) ;
1953
1954     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x14 ) ;
1955     data &= 0xF3 ;
1956     data |= 0x0E ;
1957     XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , data ) ;
1958     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x15 ) ;
1959     data += 0x20 ;
1960     XGINew_SetReg1( pVBInfo->P3c4 , 0x15 , data ) ;
1961
1962     return( 1 ) ;
1963 }
1964
1965
1966 /* --------------------------------------------------------------------- */
1967 /* Function : XGINew_CheckRanks */
1968 /* Input : */
1969 /* Output : */
1970 /* Description : */
1971 /* --------------------------------------------------------------------- */
1972 int XGINew_CheckRanks( int RankNo , int index , USHORT DRAMTYPE_TABLE[][ 5 ], PVB_DEVICE_INFO pVBInfo)
1973 {
1974     int r ;
1975
1976     for( r = RankNo ; r >= 1 ; r-- )
1977     {
1978         if ( !XGINew_CheckRank( r , index , DRAMTYPE_TABLE, pVBInfo ) )
1979             return( 0 ) ;
1980     }
1981
1982     if ( !XGINew_CheckBanks( index , DRAMTYPE_TABLE, pVBInfo ) )
1983         return( 0 ) ;
1984
1985     if ( !XGINew_CheckColumn( index , DRAMTYPE_TABLE, pVBInfo ) )
1986         return( 0 ) ;
1987
1988     return( 1 ) ;
1989 }
1990
1991
1992 /* --------------------------------------------------------------------- */
1993 /* Function : XGINew_CheckDDRRanks */
1994 /* Input : */
1995 /* Output : */
1996 /* Description : */
1997 /* --------------------------------------------------------------------- */
1998 int XGINew_CheckDDRRanks( int RankNo , int index , USHORT DRAMTYPE_TABLE[][ 5 ], PVB_DEVICE_INFO pVBInfo)
1999 {
2000     int r ;
2001
2002     for( r = RankNo ; r >= 1 ; r-- )
2003     {
2004         if ( !XGINew_CheckDDRRank( r , index , DRAMTYPE_TABLE, pVBInfo ) )
2005             return( 0 ) ;
2006     }
2007
2008     if ( !XGINew_CheckBanks( index , DRAMTYPE_TABLE, pVBInfo ) )
2009         return( 0 ) ;
2010
2011     if ( !XGINew_CheckColumn( index , DRAMTYPE_TABLE, pVBInfo ) )
2012         return( 0 ) ;
2013
2014     return( 1 ) ;
2015 }
2016
2017
2018 /* --------------------------------------------------------------------- */
2019 /* Function : */
2020 /* Input : */
2021 /* Output : */
2022 /* Description : */
2023 /* --------------------------------------------------------------------- */
2024 int XGINew_SDRSizing(PVB_DEVICE_INFO pVBInfo)
2025 {
2026     int    i ;
2027     UCHAR  j ;
2028
2029     for( i = 0 ; i < 13 ; i++ )
2030     {
2031         XGINew_SetDRAMSizingType( i , XGINew_SDRDRAM_TYPE , pVBInfo) ;
2032
2033         for( j = 2 ; j > 0 ; j-- )
2034         {
2035             if ( !XGINew_SetRank( i , ( UCHAR )j , XGINew_ChannelAB , XGINew_SDRDRAM_TYPE , pVBInfo) )
2036                 continue ;
2037             else
2038             {
2039                 if ( XGINew_CheckRanks( j , i , XGINew_SDRDRAM_TYPE, pVBInfo) )
2040                     return( 1 ) ;
2041             }
2042         }
2043     }
2044     return( 0 ) ;
2045 }
2046
2047
2048 /* --------------------------------------------------------------------- */
2049 /* Function : XGINew_SetDRAMSizeReg */
2050 /* Input : */
2051 /* Output : */
2052 /* Description : */
2053 /* --------------------------------------------------------------------- */
2054 USHORT XGINew_SetDRAMSizeReg( int index , USHORT DRAMTYPE_TABLE[][ 5 ], PVB_DEVICE_INFO pVBInfo)
2055 {
2056     USHORT data = 0 , memsize = 0 ;
2057     int RankSize ;
2058     UCHAR ChannelNo ;
2059
2060     RankSize = DRAMTYPE_TABLE[ index ][ 3 ] * XGINew_DataBusWidth / 32 ;
2061     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x13 ) ;
2062     data &= 0x80 ;
2063
2064     if ( data == 0x80 )
2065         RankSize *= 2 ;
2066
2067     data = 0 ;
2068
2069     if( XGINew_ChannelAB == 3 )
2070         ChannelNo = 4 ;
2071     else
2072         ChannelNo = XGINew_ChannelAB ;
2073
2074     if ( ChannelNo * RankSize <= 256 )
2075     {
2076         while( ( RankSize >>= 1 ) > 0 )
2077         {
2078             data += 0x10 ;
2079         }
2080
2081         memsize = data >> 4 ;
2082
2083         /* [2004/03/25] Vicent, Fix DRAM Sizing Error */
2084         XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , ( XGINew_GetReg1( pVBInfo->P3c4 , 0x14 ) & 0x0F ) | ( data & 0xF0 ) ) ;
2085
2086        /* data |= XGINew_ChannelAB << 2 ; */
2087        /* data |= ( XGINew_DataBusWidth / 64 ) << 1 ; */
2088        /* XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , data ) ; */
2089
2090         /* should delay */
2091         /* XGINew_SetDRAMModeRegister340( pVBInfo ) ; */
2092     }
2093     return( memsize ) ;
2094 }
2095
2096
2097 /* --------------------------------------------------------------------- */
2098 /* Function : XGINew_SetDRAMSize20Reg */
2099 /* Input : */
2100 /* Output : */
2101 /* Description : */
2102 /* --------------------------------------------------------------------- */
2103 USHORT XGINew_SetDRAMSize20Reg( int index , USHORT DRAMTYPE_TABLE[][ 5 ], PVB_DEVICE_INFO pVBInfo)
2104 {
2105     USHORT data = 0 , memsize = 0 ;
2106     int RankSize ;
2107     UCHAR ChannelNo ;
2108
2109     RankSize = DRAMTYPE_TABLE[ index ][ 3 ] * XGINew_DataBusWidth / 8 ;
2110     data = XGINew_GetReg1( pVBInfo->P3c4 , 0x13 ) ;
2111     data &= 0x80 ;
2112
2113     if ( data == 0x80 )
2114         RankSize *= 2 ;
2115
2116     data = 0 ;
2117
2118     if( XGINew_ChannelAB == 3 )
2119         ChannelNo = 4 ;
2120     else
2121         ChannelNo = XGINew_ChannelAB ;
2122
2123     if ( ChannelNo * RankSize <= 256 )
2124     {
2125         while( ( RankSize >>= 1 ) > 0 )
2126         {
2127             data += 0x10 ;
2128         }
2129
2130         memsize = data >> 4 ;
2131
2132         /* [2004/03/25] Vicent, Fix DRAM Sizing Error */
2133         XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , ( XGINew_GetReg1( pVBInfo->P3c4 , 0x14 ) & 0x0F ) | ( data & 0xF0 ) ) ;
2134         DelayUS( 15 ) ;
2135
2136        /* data |= XGINew_ChannelAB << 2 ; */
2137        /* data |= ( XGINew_DataBusWidth / 64 ) << 1 ; */
2138        /* XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , data ) ; */
2139
2140         /* should delay */
2141         /* XGINew_SetDRAMModeRegister340( pVBInfo ) ; */
2142     }
2143     return( memsize ) ;
2144 }
2145
2146
2147 /* --------------------------------------------------------------------- */
2148 /* Function : XGINew_ReadWriteRest */
2149 /* Input : */
2150 /* Output : */
2151 /* Description : */
2152 /* --------------------------------------------------------------------- */
2153 int XGINew_ReadWriteRest( USHORT StopAddr , USHORT StartAddr, PVB_DEVICE_INFO pVBInfo)
2154 {
2155     int i ;
2156     ULONG Position = 0 ;
2157
2158    *( ( PULONG )( pVBInfo->FBAddr + Position ) ) = Position ;
2159
2160     for( i = StartAddr ; i <= StopAddr ; i++ )
2161     {
2162         Position = 1 << i ;
2163         *( ( PULONG )( pVBInfo->FBAddr + Position ) ) = Position ;
2164     }
2165
2166     DelayUS( 500 ) ;    /* [Vicent] 2004/04/16. Fix #1759 Memory Size error in Multi-Adapter. */
2167
2168     Position = 0 ;
2169
2170    if ( ( *( PULONG )( pVBInfo->FBAddr + Position ) ) != Position )
2171         return( 0 ) ;
2172
2173     for( i = StartAddr ; i <= StopAddr ; i++ )
2174     {
2175         Position = 1 << i ;
2176         if ( ( *( PULONG )( pVBInfo->FBAddr + Position ) ) != Position )
2177             return( 0 ) ;
2178     }
2179     return( 1 ) ;
2180 }
2181
2182
2183 /* --------------------------------------------------------------------- */
2184 /* Function : XGINew_CheckFrequence */
2185 /* Input : */
2186 /* Output : */
2187 /* Description : */
2188 /* --------------------------------------------------------------------- */
2189 UCHAR XGINew_CheckFrequence( PVB_DEVICE_INFO pVBInfo )
2190 {
2191     UCHAR data ;
2192
2193     data = XGINew_GetReg1( pVBInfo->P3d4 , 0x97 ) ;
2194
2195     if ( ( data & 0x10 ) == 0 )
2196     {
2197         data = XGINew_GetReg1( pVBInfo->P3c4 , 0x39 ) ;
2198         data = ( data & 0x02 ) >> 1 ;
2199         return( data ) ;
2200     }
2201     else
2202         return( data & 0x01 ) ;
2203 }
2204
2205
2206 /* --------------------------------------------------------------------- */
2207 /* Function : XGINew_CheckChannel */
2208 /* Input : */
2209 /* Output : */
2210 /* Description : */
2211 /* --------------------------------------------------------------------- */
2212 void XGINew_CheckChannel( PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
2213 {
2214     UCHAR data;
2215
2216     switch( HwDeviceExtension->jChipType )
2217     {
2218       case XG20:
2219       case XG21:
2220           data = XGINew_GetReg1( pVBInfo->P3d4 , 0x97 ) ;
2221           data = data & 0x01;
2222           XGINew_ChannelAB = 1 ;                /* XG20 "JUST" one channel */
2223
2224           if ( data == 0 )  /* Single_32_16 */
2225           {
2226
2227               if (( HwDeviceExtension->ulVideoMemorySize - 1 ) > 0x1000000)
2228               {
2229
2230                 XGINew_DataBusWidth = 32 ;      /* 32 bits */
2231                 XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xB1 ) ;  /* 22bit + 2 rank + 32bit */
2232                 XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x52 ) ;
2233                 DelayUS( 15 ) ;
2234
2235                 if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2236                     return ;
2237
2238                 if (( HwDeviceExtension->ulVideoMemorySize - 1 ) > 0x800000)
2239                 {
2240                   XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x31 ) ;  /* 22bit + 1 rank + 32bit */
2241                   XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x42 ) ;
2242                   DelayUS( 15 ) ;
2243
2244                   if ( XGINew_ReadWriteRest( 23 , 23 , pVBInfo ) == 1 )
2245                       return ;
2246                 }
2247               }
2248
2249               if (( HwDeviceExtension->ulVideoMemorySize - 1 ) > 0x800000)
2250               {
2251                 XGINew_DataBusWidth = 16 ;      /* 16 bits */
2252                 XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xB1 ) ;  /* 22bit + 2 rank + 16bit */
2253                 XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x41 ) ;
2254                 DelayUS( 15 ) ;
2255
2256                 if ( XGINew_ReadWriteRest( 23 , 22 , pVBInfo ) == 1 )
2257                     return ;
2258                 else
2259                     XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x31 ) ;
2260                     DelayUS( 15 ) ;
2261               }
2262
2263           }
2264           else  /* Dual_16_8 */
2265           {
2266               if (( HwDeviceExtension->ulVideoMemorySize - 1 ) > 0x800000)
2267               {
2268
2269                 XGINew_DataBusWidth = 16 ;      /* 16 bits */
2270                 XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xB1 ) ;  /* (0x31:12x8x2) 22bit + 2 rank */
2271                 XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x41 ) ;  /* 0x41:16Mx16 bit*/
2272                 DelayUS( 15 ) ;
2273
2274                 if ( XGINew_ReadWriteRest( 23 , 22 , pVBInfo ) == 1 )
2275                     return ;
2276
2277                 if (( HwDeviceExtension->ulVideoMemorySize - 1 ) > 0x400000)
2278                 {
2279                   XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x31 ) ;  /* (0x31:12x8x2) 22bit + 1 rank */
2280                   XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x31 ) ;  /* 0x31:8Mx16 bit*/
2281                   DelayUS( 15 ) ;
2282
2283                   if ( XGINew_ReadWriteRest( 22 , 22 , pVBInfo ) == 1 )
2284                       return ;
2285                 }
2286               }
2287
2288
2289               if (( HwDeviceExtension->ulVideoMemorySize - 1 ) > 0x400000)
2290               {
2291                 XGINew_DataBusWidth = 8 ;       /* 8 bits */
2292                 XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xB1 ) ;  /* (0x31:12x8x2) 22bit + 2 rank */
2293                 XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x30 ) ;  /* 0x30:8Mx8 bit*/
2294                 DelayUS( 15 ) ;
2295
2296                 if ( XGINew_ReadWriteRest( 22 , 21 , pVBInfo ) == 1 )
2297                     return ;
2298                 else
2299                     XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x31 ) ;  /* (0x31:12x8x2) 22bit + 1 rank */
2300                     DelayUS( 15 ) ;
2301               }
2302           }
2303           break ;
2304
2305       case XG27:
2306           XGINew_DataBusWidth = 16 ;    /* 16 bits */
2307           XGINew_ChannelAB = 1 ;                /* Single channel */
2308           XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x51 ) ;  /* 32Mx16 bit*/
2309           break ;
2310       case XG41:
2311           if ( XGINew_CheckFrequence(pVBInfo) == 1 )
2312           {
2313               XGINew_DataBusWidth = 32 ;        /* 32 bits */
2314               XGINew_ChannelAB = 3 ;            /* Quad Channel */
2315               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xA1 ) ;
2316               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x4C ) ;
2317
2318               if ( XGINew_ReadWriteRest( 25 , 23 , pVBInfo ) == 1 )
2319                   return ;
2320
2321               XGINew_ChannelAB = 2 ;            /* Dual channels */
2322               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x48 ) ;
2323
2324               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2325                   return ;
2326
2327               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x49 ) ;
2328
2329               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2330                   return ;
2331
2332               XGINew_ChannelAB = 3 ;
2333               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x21 ) ;
2334               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x3C ) ;
2335
2336               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2337                   return ;
2338
2339               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x38 ) ;
2340
2341               if ( XGINew_ReadWriteRest( 8 , 4 , pVBInfo ) == 1 )
2342                   return ;
2343               else
2344                   XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x39 ) ;
2345           }
2346           else
2347           {                                     /* DDR */
2348               XGINew_DataBusWidth = 64 ;        /* 64 bits */
2349               XGINew_ChannelAB = 2 ;            /* Dual channels */
2350               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xA1 ) ;
2351               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x5A ) ;
2352
2353               if ( XGINew_ReadWriteRest( 25 , 24 , pVBInfo ) == 1 )
2354                   return ;
2355
2356               XGINew_ChannelAB = 1 ;            /* Single channels */
2357               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x52 ) ;
2358
2359               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2360                   return ;
2361
2362               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x53 ) ;
2363
2364               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2365                   return ;
2366
2367               XGINew_ChannelAB = 2 ;            /* Dual channels */
2368               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x21 ) ;
2369               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x4A ) ;
2370
2371               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2372                   return ;
2373
2374               XGINew_ChannelAB = 1 ;            /* Single channels */
2375               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x42 ) ;
2376
2377               if ( XGINew_ReadWriteRest( 8 , 4 , pVBInfo ) == 1 )
2378                   return ;
2379               else
2380                   XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x43 ) ;
2381           }
2382
2383           break ;
2384
2385       case XG42:
2386 /*
2387           XG42 SR14 D[3] Reserve
2388                     D[2] = 1, Dual Channel
2389                          = 0, Single Channel
2390
2391           It's Different from Other XG40 Series.
2392 */
2393           if ( XGINew_CheckFrequence(pVBInfo) == 1 )    /* DDRII, DDR2x */
2394           {
2395               XGINew_DataBusWidth = 32 ;        /* 32 bits */
2396               XGINew_ChannelAB = 2 ;            /* 2 Channel */
2397               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xA1 ) ;
2398               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x44 ) ;
2399
2400               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2401                   return ;
2402
2403               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x21 ) ;
2404               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x34 ) ;
2405               if ( XGINew_ReadWriteRest( 23 , 22 , pVBInfo ) == 1 )
2406                   return ;
2407
2408               XGINew_ChannelAB = 1 ;            /* Single Channel */
2409               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xA1 ) ;
2410               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x40 ) ;
2411
2412               if ( XGINew_ReadWriteRest( 23 , 22 , pVBInfo ) == 1 )
2413                   return ;
2414               else
2415               {
2416                   XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x21 ) ;
2417                   XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x30 ) ;
2418               }
2419           }
2420           else
2421           {                                     /* DDR */
2422               XGINew_DataBusWidth = 64 ;        /* 64 bits */
2423               XGINew_ChannelAB = 1 ;            /* 1 channels */
2424               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xA1 ) ;
2425               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x52 ) ;
2426
2427               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2428                   return ;
2429               else
2430               {
2431                   XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x21 ) ;
2432                   XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x42 ) ;
2433               }
2434           }
2435
2436           break ;
2437
2438       default:  /* XG40 */
2439
2440           if ( XGINew_CheckFrequence(pVBInfo) == 1 )    /* DDRII */
2441           {
2442               XGINew_DataBusWidth = 32 ;        /* 32 bits */
2443               XGINew_ChannelAB = 3 ;
2444               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xA1 ) ;
2445               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x4C ) ;
2446
2447               if ( XGINew_ReadWriteRest( 25 , 23 , pVBInfo ) == 1 )
2448                   return ;
2449
2450               XGINew_ChannelAB = 2 ;            /* 2 channels */
2451               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x48 ) ;
2452
2453               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2454                   return ;
2455
2456               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x21 ) ;
2457               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x3C ) ;
2458
2459               if ( XGINew_ReadWriteRest( 24 , 23 , pVBInfo ) == 1 )
2460                   XGINew_ChannelAB = 3 ;        /* 4 channels */
2461               else
2462               {
2463                   XGINew_ChannelAB = 2 ;        /* 2 channels */
2464                   XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x38 ) ;
2465               }
2466           }
2467           else
2468           {                                     /* DDR */
2469               XGINew_DataBusWidth = 64 ;        /* 64 bits */
2470               XGINew_ChannelAB = 2 ;            /* 2 channels */
2471               XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0xA1 ) ;
2472               XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x5A ) ;
2473
2474               if ( XGINew_ReadWriteRest( 25 , 24 , pVBInfo ) == 1 )
2475                   return ;
2476               else
2477               {
2478                   XGINew_SetReg1( pVBInfo->P3c4 , 0x13 , 0x21 ) ;
2479                   XGINew_SetReg1( pVBInfo->P3c4 , 0x14 , 0x4A ) ;
2480               }
2481           }
2482           break ;
2483     }
2484 }
2485
2486
2487 /* --------------------------------------------------------------------- */
2488 /* Function : XGINew_DDRSizing340 */
2489 /* Input : */
2490 /* Output : */
2491 /* Description : */
2492 /* --------------------------------------------------------------------- */
2493 int XGINew_DDRSizing340( PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
2494 {
2495     int i ;
2496     USHORT memsize , addr ;
2497
2498     XGINew_SetReg1( pVBInfo->P3c4 , 0x15 , 0x00 ) ;     /* noninterleaving */
2499     XGINew_SetReg1( pVBInfo->P3c4 , 0x1C , 0x00 ) ;     /* nontiling */
2500     XGINew_CheckChannel( HwDeviceExtension, pVBInfo ) ;
2501
2502
2503     if ( HwDeviceExtension->jChipType >= XG20 )
2504     {
2505       for( i = 0 ; i < 12 ; i++ )
2506       {
2507         XGINew_SetDRAMSizingType( i , XGINew_DDRDRAM_TYPE20, pVBInfo ) ;
2508         memsize = XGINew_SetDRAMSize20Reg( i , XGINew_DDRDRAM_TYPE20, pVBInfo ) ;
2509         if ( memsize == 0 )
2510             continue ;
2511
2512         addr = memsize + ( XGINew_ChannelAB - 2 ) + 20 ;
2513         if ( ( HwDeviceExtension->ulVideoMemorySize - 1 ) < ( ULONG )( 1 << addr ) )
2514             continue ;
2515
2516         if ( XGINew_ReadWriteRest( addr , 5, pVBInfo ) == 1 )
2517             return( 1 ) ;
2518       }
2519     }
2520     else
2521     {
2522       for( i = 0 ; i < 4 ; i++ )
2523       {
2524         XGINew_SetDRAMSizingType( i , XGINew_DDRDRAM_TYPE340, pVBInfo ) ;
2525         memsize = XGINew_SetDRAMSizeReg( i , XGINew_DDRDRAM_TYPE340, pVBInfo ) ;
2526
2527         if ( memsize == 0 )
2528             continue ;
2529
2530         addr = memsize + ( XGINew_ChannelAB - 2 ) + 20 ;
2531         if ( ( HwDeviceExtension->ulVideoMemorySize - 1 ) < ( ULONG )( 1 << addr ) )
2532             continue ;
2533
2534         if ( XGINew_ReadWriteRest( addr , 9, pVBInfo ) == 1 )
2535             return( 1 ) ;
2536       }
2537     }
2538     return( 0 ) ;
2539 }
2540
2541
2542 /* --------------------------------------------------------------------- */
2543 /* Function : XGINew_DDRSizing */
2544 /* Input : */
2545 /* Output : */
2546 /* Description : */
2547 /* --------------------------------------------------------------------- */
2548 int XGINew_DDRSizing(PVB_DEVICE_INFO pVBInfo)
2549 {
2550     int    i ;
2551     UCHAR  j ;
2552
2553     for( i = 0 ; i < 4 ; i++ )
2554     {
2555         XGINew_SetDRAMSizingType( i , XGINew_DDRDRAM_TYPE, pVBInfo ) ;
2556         XGINew_DisableChannelInterleaving( i , XGINew_DDRDRAM_TYPE , pVBInfo) ;
2557         for( j = 2 ; j > 0 ; j-- )
2558         {
2559             XGINew_SetDDRChannel( i , j , XGINew_ChannelAB , XGINew_DDRDRAM_TYPE , pVBInfo ) ;
2560             if ( !XGINew_SetRank( i , ( UCHAR )j , XGINew_ChannelAB , XGINew_DDRDRAM_TYPE, pVBInfo ) )
2561                 continue ;
2562             else
2563             {
2564                 if ( XGINew_CheckDDRRanks( j , i , XGINew_DDRDRAM_TYPE,  pVBInfo ) )
2565                 return( 1 ) ;
2566             }
2567         }
2568     }
2569     return( 0 ) ;
2570 }
2571
2572 /* --------------------------------------------------------------------- */
2573 /* Function : XGINew_SetMemoryClock */
2574 /* Input : */
2575 /* Output : */
2576 /* Description : */
2577 /* --------------------------------------------------------------------- */
2578 void XGINew_SetMemoryClock( PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
2579 {
2580
2581
2582     XGINew_SetReg1( pVBInfo->P3c4 , 0x28 , pVBInfo->MCLKData[ XGINew_RAMType ].SR28 ) ;
2583     XGINew_SetReg1( pVBInfo->P3c4 , 0x29 , pVBInfo->MCLKData[ XGINew_RAMType ].SR29 ) ;
2584     XGINew_SetReg1( pVBInfo->P3c4 , 0x2A , pVBInfo->MCLKData[ XGINew_RAMType ].SR2A ) ;
2585
2586
2587
2588     XGINew_SetReg1( pVBInfo->P3c4 , 0x2E , pVBInfo->ECLKData[ XGINew_RAMType ].SR2E ) ;
2589     XGINew_SetReg1( pVBInfo->P3c4 , 0x2F , pVBInfo->ECLKData[ XGINew_RAMType ].SR2F ) ;
2590     XGINew_SetReg1( pVBInfo->P3c4 , 0x30 , pVBInfo->ECLKData[ XGINew_RAMType ].SR30 ) ;
2591
2592     /* [Vicent] 2004/07/07, When XG42 ECLK = MCLK = 207MHz, Set SR32 D[1:0] = 10b */
2593     /* [Hsuan] 2004/08/20, Modify SR32 value, when MCLK=207MHZ, ELCK=250MHz, Set SR32 D[1:0] = 10b */
2594     if ( HwDeviceExtension->jChipType == XG42 )
2595     {
2596       if ( ( pVBInfo->MCLKData[ XGINew_RAMType ].SR28 == 0x1C ) && ( pVBInfo->MCLKData[ XGINew_RAMType ].SR29 == 0x01 )
2597         && ( ( ( pVBInfo->ECLKData[ XGINew_RAMType ].SR2E == 0x1C ) && ( pVBInfo->ECLKData[ XGINew_RAMType ].SR2F == 0x01 ) )
2598         || ( ( pVBInfo->ECLKData[ XGINew_RAMType ].SR2E == 0x22 ) && ( pVBInfo->ECLKData[ XGINew_RAMType ].SR2F == 0x01 ) ) ) )
2599       {
2600         XGINew_SetReg1( pVBInfo->P3c4 , 0x32 , ( ( UCHAR )XGINew_GetReg1( pVBInfo->P3c4 , 0x32 ) & 0xFC ) | 0x02 ) ;
2601       }
2602     }
2603 }
2604
2605
2606 /* --------------------------------------------------------------------- */
2607 /* Function : ChkLFB */
2608 /* Input : */
2609 /* Output : */
2610 /* Description : */
2611 /* --------------------------------------------------------------------- */
2612 BOOLEAN ChkLFB( PVB_DEVICE_INFO pVBInfo )
2613 {
2614     if ( LFBDRAMTrap & XGINew_GetReg1( pVBInfo->P3d4 , 0x78 ) )
2615         return( TRUE ) ;
2616     else
2617         return( FALSE );
2618 }
2619
2620
2621 /* --------------------------------------------------------------------- */
2622 /* input : dx ,valid value : CR or second chip's CR */
2623 /*  */
2624 /* SetPowerConsume : */
2625 /* Description: reduce 40/43 power consumption in first chip or */
2626 /* in second chip, assume CR A1 D[6]="1" in this case */
2627 /* output : none */
2628 /* --------------------------------------------------------------------- */
2629 void SetPowerConsume ( PXGI_HW_DEVICE_INFO HwDeviceExtension , ULONG XGI_P3d4Port )
2630 {
2631     ULONG   lTemp ;
2632     UCHAR   bTemp;
2633
2634     HwDeviceExtension->pQueryVGAConfigSpace( HwDeviceExtension , 0x08 , 0 , &lTemp ) ; /* Get */
2635     if ((lTemp&0xFF)==0)
2636     {
2637         /* set CR58 D[5]=0 D[3]=0 */
2638         XGINew_SetRegAND( XGI_P3d4Port , 0x58 , 0xD7 ) ;
2639         bTemp = (UCHAR) XGINew_GetReg1( XGI_P3d4Port , 0xCB ) ;
2640         if (bTemp&0x20)
2641         {
2642             if (!(bTemp&0x10))
2643             {
2644                 XGINew_SetRegANDOR( XGI_P3d4Port , 0x58 , 0xD7 , 0x20 ) ; /* CR58 D[5]=1 D[3]=0 */
2645             }
2646             else
2647             {
2648                 XGINew_SetRegANDOR( XGI_P3d4Port , 0x58 , 0xD7 , 0x08 ) ; /* CR58 D[5]=0 D[3]=1 */
2649             }
2650
2651         }
2652
2653     }
2654 }
2655
2656
2657 void XGINew_InitVBIOSData(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
2658 {
2659
2660         /* ULONG ROMAddr = (ULONG)HwDeviceExtension->pjVirtualRomBase; */
2661     pVBInfo->ROMAddr = HwDeviceExtension->pjVirtualRomBase ;
2662     pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress ;
2663     pVBInfo->BaseAddr = (ULONG)HwDeviceExtension->pjIOAddress ;
2664     pVBInfo->ISXPDOS = 0 ;
2665
2666     pVBInfo->P3c4 = pVBInfo->BaseAddr + 0x14 ;
2667     pVBInfo->P3d4 = pVBInfo->BaseAddr + 0x24 ;
2668     pVBInfo->P3c0 = pVBInfo->BaseAddr + 0x10 ;
2669     pVBInfo->P3ce = pVBInfo->BaseAddr + 0x1e ;
2670     pVBInfo->P3c2 = pVBInfo->BaseAddr + 0x12 ;
2671     pVBInfo->P3ca = pVBInfo->BaseAddr + 0x1a ;
2672     pVBInfo->P3c6 = pVBInfo->BaseAddr + 0x16 ;
2673     pVBInfo->P3c7 = pVBInfo->BaseAddr + 0x17 ;
2674     pVBInfo->P3c8 = pVBInfo->BaseAddr + 0x18 ;
2675     pVBInfo->P3c9 = pVBInfo->BaseAddr + 0x19 ;
2676     pVBInfo->P3da = pVBInfo->BaseAddr + 0x2A ;
2677     pVBInfo->Part0Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_00 ;
2678     pVBInfo->Part1Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_04 ;
2679     pVBInfo->Part2Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_10 ;
2680     pVBInfo->Part3Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_12 ;
2681     pVBInfo->Part4Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 ;
2682     pVBInfo->Part5Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 + 2 ;
2683     if ( HwDeviceExtension->jChipType < XG20 )                  /* kuku 2004/06/25 */
2684     XGI_GetVBType( pVBInfo ) ;         /* Run XGI_GetVBType before InitTo330Pointer */
2685
2686         switch(HwDeviceExtension->jChipType)
2687         {
2688         case XG40:
2689         case XG41:
2690         case XG42:
2691         case XG20:
2692         case XG21:
2693         default:
2694                 InitTo330Pointer(HwDeviceExtension->jChipType,pVBInfo);
2695                 return ;
2696         }
2697
2698 }
2699
2700 /* --------------------------------------------------------------------- */
2701 /* Function : ReadVBIOSTablData */
2702 /* Input : */
2703 /* Output : */
2704 /* Description : */
2705 /* --------------------------------------------------------------------- */
2706 void ReadVBIOSTablData( UCHAR ChipType , PVB_DEVICE_INFO pVBInfo)
2707 {
2708     PUCHAR  volatile pVideoMemory = ( PUCHAR )pVBInfo->ROMAddr ;
2709     ULONG   i ;
2710     UCHAR   j , k ;
2711 #if 0
2712     ULONG   ii , jj ;
2713     i = pVideoMemory[ 0x1CF ] | ( pVideoMemory[ 0x1D0 ] << 8 ) ;                /* UniROM */
2714     if ( i != 0 )
2715         UNIROM = 1 ;
2716
2717     ii = 0x90 ;
2718     for( jj = 0x00 ; jj < 0x08 ; jj++ )
2719     {
2720         pVBInfo->MCLKData[ jj ].SR28 = pVideoMemory[ ii ] ;
2721         pVBInfo->MCLKData[ jj ].SR29 = pVideoMemory[ ii + 1] ;
2722         pVBInfo->MCLKData[ jj ].SR2A = pVideoMemory[ ii + 2] ;
2723         pVBInfo->MCLKData[ jj ].CLOCK = pVideoMemory[ ii + 3 ] | ( pVideoMemory[ ii + 4 ] << 8 ) ;
2724         ii += 0x05 ;
2725     }
2726
2727     ii = 0xB8 ;
2728     for( jj = 0x00 ; jj < 0x08 ; jj++ )
2729     {
2730         pVBInfo->ECLKData[ jj ].SR2E = pVideoMemory[ ii ] ;
2731         pVBInfo->ECLKData[ jj ].SR2F=pVideoMemory[ ii + 1 ] ;
2732         pVBInfo->ECLKData[ jj ].SR30= pVideoMemory[ ii + 2 ] ;
2733         pVBInfo->ECLKData[ jj ].CLOCK= pVideoMemory[ ii + 3 ] | ( pVideoMemory[ ii + 4 ] << 8 ) ;
2734         ii += 0x05 ;
2735     }
2736
2737     /* Volari customize data area start */
2738     /* if ( ChipType == XG40 ) */
2739     if ( ChipType >= XG40 )
2740     {
2741         ii = 0xE0 ;
2742         for( jj = 0x00 ; jj < 0x03 ; jj++ )
2743         {
2744             pVBInfo->SR15[ jj ][ 0 ] = pVideoMemory[ ii ] ;             /* SR13, SR14, and SR18 */
2745             pVBInfo->SR15[ jj ][ 1 ] = pVideoMemory[ ii + 1 ] ;
2746             pVBInfo->SR15[ jj ][ 2 ] = pVideoMemory[ ii + 2 ] ;
2747             pVBInfo->SR15[ jj ][ 3 ] = pVideoMemory[ ii + 3 ] ;
2748             pVBInfo->SR15[ jj ][ 4 ] = pVideoMemory[ ii + 4 ] ;
2749             pVBInfo->SR15[ jj ][ 5 ] = pVideoMemory[ ii + 5 ] ;
2750             pVBInfo->SR15[ jj ][ 6 ] = pVideoMemory[ ii + 6 ] ;
2751             pVBInfo->SR15[ jj ][ 7 ] = pVideoMemory[ ii + 7 ] ;
2752             ii += 0x08 ;
2753         }
2754         ii = 0x110 ;
2755         jj = 0x03 ;
2756         pVBInfo->SR15[ jj ][ 0 ] = pVideoMemory[ ii ] ;         /* SR1B */
2757         pVBInfo->SR15[ jj ][ 1 ] = pVideoMemory[ ii + 1 ] ;
2758         pVBInfo->SR15[ jj ][ 2 ] = pVideoMemory[ ii + 2 ] ;
2759         pVBInfo->SR15[ jj ][ 3 ] = pVideoMemory[ ii + 3 ] ;
2760         pVBInfo->SR15[ jj ][ 4 ] = pVideoMemory[ ii + 4 ] ;
2761         pVBInfo->SR15[ jj ][ 5 ] = pVideoMemory[ ii + 5 ] ;
2762         pVBInfo->SR15[ jj ][ 6 ] = pVideoMemory[ ii + 6 ] ;
2763         pVBInfo->SR15[ jj ][ 7 ] = pVideoMemory[ ii + 7 ] ;
2764
2765         *pVBInfo->pSR07 = pVideoMemory[ 0x74 ] ;
2766         *pVBInfo->pSR1F = pVideoMemory[ 0x75 ] ;
2767         *pVBInfo->pSR21 = pVideoMemory[ 0x76 ] ;
2768         *pVBInfo->pSR22 = pVideoMemory[ 0x77 ] ;
2769         *pVBInfo->pSR23 = pVideoMemory[ 0x78 ] ;
2770         *pVBInfo->pSR24 = pVideoMemory[ 0x79 ] ;
2771         pVBInfo->SR25[ 0 ] = pVideoMemory[ 0x7A ] ;
2772         *pVBInfo->pSR31 = pVideoMemory[ 0x7B ] ;
2773         *pVBInfo->pSR32 = pVideoMemory[ 0x7C ] ;
2774         *pVBInfo->pSR33 = pVideoMemory[ 0x7D ] ;
2775         ii = 0xF8 ;
2776
2777         for( jj = 0 ; jj < 3 ; jj++ )
2778         {
2779             pVBInfo->CR40[ jj ][ 0 ] = pVideoMemory[ ii ] ;
2780             pVBInfo->CR40[ jj ][ 1 ] = pVideoMemory[ ii + 1 ] ;
2781             pVBInfo->CR40[ jj ][ 2 ] = pVideoMemory[ ii + 2 ] ;
2782             pVBInfo->CR40[ jj ][ 3 ] = pVideoMemory[ ii + 3 ] ;
2783             pVBInfo->CR40[ jj ][ 4 ] = pVideoMemory[ ii + 4 ] ;
2784             pVBInfo->CR40[ jj ][ 5 ] = pVideoMemory[ ii + 5 ] ;
2785             pVBInfo->CR40[ jj ][ 6 ] = pVideoMemory[ ii + 6 ] ;
2786             pVBInfo->CR40[ jj ][ 7 ] = pVideoMemory[ ii + 7 ] ;
2787             ii += 0x08 ;
2788         }
2789
2790         ii = 0x118 ;
2791         for( j = 3 ; j < 24 ; j++ )
2792         {
2793             pVBInfo->CR40[ j ][ 0 ] = pVideoMemory[ ii ] ;
2794             pVBInfo->CR40[ j ][ 1 ] = pVideoMemory[ ii + 1 ] ;
2795             pVBInfo->CR40[ j ][ 2 ] = pVideoMemory[ ii + 2 ] ;
2796             pVBInfo->CR40[ j ][ 3 ] = pVideoMemory[ ii + 3 ] ;
2797             pVBInfo->CR40[ j ][ 4 ] = pVideoMemory[ ii + 4 ] ;
2798             pVBInfo->CR40[ j ][ 5 ] = pVideoMemory[ ii + 5 ] ;
2799             pVBInfo->CR40[ j ][ 6 ] = pVideoMemory[ ii + 6 ] ;
2800             pVBInfo->CR40[ j ][ 7 ] = pVideoMemory[ ii + 7 ] ;
2801             ii += 0x08 ;
2802         }
2803
2804         i = pVideoMemory[ 0x1C0 ] | ( pVideoMemory[ 0x1C1 ] << 8 ) ;
2805
2806         for( j = 0 ; j < 8 ; j++ )
2807         {
2808             for( k = 0 ; k < 4 ; k++ )
2809                 pVBInfo->CR6B[ j ][ k ] = pVideoMemory[ i + 4 * j + k ] ;
2810         }
2811
2812         i = pVideoMemory[ 0x1C2 ] | ( pVideoMemory[ 0x1C3 ] << 8 ) ;
2813
2814         for( j = 0 ; j < 8 ; j++ )
2815         {
2816             for( k = 0 ; k < 4 ; k++ )
2817                 pVBInfo->CR6E[ j ][ k ] = pVideoMemory[ i + 4 * j + k ] ;
2818         }
2819
2820         i = pVideoMemory[ 0x1C4 ] | ( pVideoMemory[ 0x1C5 ] << 8 ) ;
2821         for( j = 0 ; j < 8 ; j++ )
2822         {
2823             for( k = 0 ; k < 32 ; k++ )
2824                 pVBInfo->CR6F[ j ][ k ] = pVideoMemory[ i + 32 * j + k ] ;
2825         }
2826
2827         i = pVideoMemory[ 0x1C6 ] | ( pVideoMemory[ 0x1C7 ] << 8 ) ;
2828
2829         for( j = 0 ; j < 8 ; j++ )
2830         {
2831             for( k = 0 ; k < 2 ; k++ )
2832                 pVBInfo->CR89[ j ][ k ] = pVideoMemory[ i + 2 * j + k ] ;
2833         }
2834
2835         i = pVideoMemory[ 0x1C8 ] | ( pVideoMemory[ 0x1C9 ] << 8 ) ;
2836         for( j = 0 ; j < 12 ; j++ )
2837             pVBInfo->AGPReg[ j ] = pVideoMemory[ i + j ] ;
2838
2839         i = pVideoMemory[ 0x1CF ] | ( pVideoMemory[ 0x1D0 ] << 8 ) ;
2840         for( j = 0 ; j < 4 ; j++ )
2841             pVBInfo->SR16[ j ] = pVideoMemory[ i + j ] ;
2842
2843         if ( ChipType == XG21 )
2844         {
2845             if (pVideoMemory[ 0x67 ] & 0x80)
2846             {
2847                 *pVBInfo->pDVOSetting = pVideoMemory[ 0x67 ];
2848             }
2849             if ( (pVideoMemory[ 0x67 ] & 0xC0) == 0xC0 )
2850             {
2851                 *pVBInfo->pCR2E = pVideoMemory[ i + 4 ] ;
2852                 *pVBInfo->pCR2F = pVideoMemory[ i + 5 ] ;
2853                 *pVBInfo->pCR46 = pVideoMemory[ i + 6 ] ;
2854                 *pVBInfo->pCR47 = pVideoMemory[ i + 7 ] ;
2855             }
2856         }
2857
2858         if ( ChipType == XG27 )
2859         {
2860             jj = i+j;
2861             for( i = 0 ; i <= 0xB ; i++,jj++ )
2862               pVBInfo->pCRD0[i] = pVideoMemory[ jj ] ;
2863             for( i = 0x0 ; i <= 0x1 ; i++,jj++ )
2864               pVBInfo->pCRDE[i] = pVideoMemory[ jj ] ;
2865
2866             *pVBInfo->pSR40 = pVideoMemory[ jj ] ;
2867             jj++;
2868             *pVBInfo->pSR41 = pVideoMemory[ jj ] ;
2869
2870             if (pVideoMemory[ 0x67 ] & 0x80)
2871             {
2872                 *pVBInfo->pDVOSetting = pVideoMemory[ 0x67 ];
2873             }
2874             if ( (pVideoMemory[ 0x67 ] & 0xC0) == 0xC0 )
2875             {
2876                 jj++;
2877                 *pVBInfo->pCR2E = pVideoMemory[ jj ] ;
2878                 *pVBInfo->pCR2F = pVideoMemory[ jj + 1 ] ;
2879                 *pVBInfo->pCR46 = pVideoMemory[ jj + 2 ] ;
2880                 *pVBInfo->pCR47 = pVideoMemory[ jj + 3 ] ;
2881             }
2882
2883         }
2884
2885         *pVBInfo->pCRCF = pVideoMemory[ 0x1CA ] ;
2886         *pVBInfo->pXGINew_DRAMTypeDefinition = pVideoMemory[ 0x1CB ] ;
2887         *pVBInfo->pXGINew_I2CDefinition = pVideoMemory[ 0x1D1 ] ;
2888         if ( ChipType >= XG20 )
2889         {
2890            *pVBInfo->pXGINew_CR97 = pVideoMemory[ 0x1D2 ] ;
2891            if ( ChipType == XG27 )
2892            {
2893              *pVBInfo->pSR36 = pVideoMemory[ 0x1D3 ] ;
2894              *pVBInfo->pCR8F = pVideoMemory[ 0x1D5 ] ;
2895            }
2896         }
2897
2898     }
2899 #endif
2900     /* Volari customize data area end */
2901
2902     if ( ChipType == XG21 )
2903     {
2904         pVBInfo->IF_DEF_LVDS = 0 ;
2905         if (pVideoMemory[ 0x65 ] & 0x1)
2906         {
2907             pVBInfo->IF_DEF_LVDS = 1 ;
2908             i = pVideoMemory[ 0x316 ] | ( pVideoMemory[ 0x317 ] << 8 );
2909             j = pVideoMemory[ i-1 ] ;
2910             if ( j != 0xff )
2911             {
2912               k = 0;
2913               do
2914               {
2915                 pVBInfo->XG21_LVDSCapList[k].LVDS_Capability = pVideoMemory[ i ] | ( pVideoMemory[ i + 1 ] << 8 );
2916                 pVBInfo->XG21_LVDSCapList[k].LVDSHT = pVideoMemory[ i + 2 ] | ( pVideoMemory[ i + 3 ] << 8 ) ;
2917                 pVBInfo->XG21_LVDSCapList[k].LVDSVT = pVideoMemory[ i + 4 ] | ( pVideoMemory[ i + 5 ] << 8 );
2918                 pVBInfo->XG21_LVDSCapList[k].LVDSHDE = pVideoMemory[ i + 6 ] | ( pVideoMemory[ i + 7 ] << 8 );
2919                 pVBInfo->XG21_LVDSCapList[k].LVDSVDE = pVideoMemory[ i + 8 ] | ( pVideoMemory[ i + 9 ] << 8 );
2920                 pVBInfo->XG21_LVDSCapList[k].LVDSHFP = pVideoMemory[ i + 10 ] | ( pVideoMemory[ i + 11 ] << 8 );
2921                 pVBInfo->XG21_LVDSCapList[k].LVDSVFP = pVideoMemory[ i + 12 ] | ( pVideoMemory[ i + 13 ] << 8 );
2922                 pVBInfo->XG21_LVDSCapList[k].LVDSHSYNC = pVideoMemory[ i + 14 ] | ( pVideoMemory[ i + 15 ] << 8 );
2923                 pVBInfo->XG21_LVDSCapList[k].LVDSVSYNC = pVideoMemory[ i + 16 ] | ( pVideoMemory[ i + 17 ] << 8 );
2924                 pVBInfo->XG21_LVDSCapList[k].VCLKData1 = pVideoMemory[ i + 18 ] ;
2925                 pVBInfo->XG21_LVDSCapList[k].VCLKData2 = pVideoMemory[ i + 19 ] ;
2926                 pVBInfo->XG21_LVDSCapList[k].PSC_S1 = pVideoMemory[ i + 20 ] ;
2927                 pVBInfo->XG21_LVDSCapList[k].PSC_S2 = pVideoMemory[ i + 21 ] ;
2928                 pVBInfo->XG21_LVDSCapList[k].PSC_S3 = pVideoMemory[ i + 22 ] ;
2929                 pVBInfo->XG21_LVDSCapList[k].PSC_S4 = pVideoMemory[ i + 23 ] ;
2930                 pVBInfo->XG21_LVDSCapList[k].PSC_S5 = pVideoMemory[ i + 24 ] ;
2931                 i += 25;
2932                 j--;
2933                 k++;
2934               } while ( (j>0) && ( k < (sizeof(XGI21_LCDCapList)/sizeof(XGI21_LVDSCapStruct)) ) );
2935             }
2936             else
2937             {
2938             pVBInfo->XG21_LVDSCapList[0].LVDS_Capability = pVideoMemory[ i ] | ( pVideoMemory[ i + 1 ] << 8 );
2939             pVBInfo->XG21_LVDSCapList[0].LVDSHT = pVideoMemory[ i + 2 ] | ( pVideoMemory[ i + 3 ] << 8 ) ;
2940             pVBInfo->XG21_LVDSCapList[0].LVDSVT = pVideoMemory[ i + 4 ] | ( pVideoMemory[ i + 5 ] << 8 );
2941             pVBInfo->XG21_LVDSCapList[0].LVDSHDE = pVideoMemory[ i + 6 ] | ( pVideoMemory[ i + 7 ] << 8 );
2942             pVBInfo->XG21_LVDSCapList[0].LVDSVDE = pVideoMemory[ i + 8 ] | ( pVideoMemory[ i + 9 ] << 8 );
2943             pVBInfo->XG21_LVDSCapList[0].LVDSHFP = pVideoMemory[ i + 10 ] | ( pVideoMemory[ i + 11 ] << 8 );
2944             pVBInfo->XG21_LVDSCapList[0].LVDSVFP = pVideoMemory[ i + 12 ] | ( pVideoMemory[ i + 13 ] << 8 );
2945             pVBInfo->XG21_LVDSCapList[0].LVDSHSYNC = pVideoMemory[ i + 14 ] | ( pVideoMemory[ i + 15 ] << 8 );
2946             pVBInfo->XG21_LVDSCapList[0].LVDSVSYNC = pVideoMemory[ i + 16 ] | ( pVideoMemory[ i + 17 ] << 8 );
2947             pVBInfo->XG21_LVDSCapList[0].VCLKData1 = pVideoMemory[ i + 18 ] ;
2948             pVBInfo->XG21_LVDSCapList[0].VCLKData2 = pVideoMemory[ i + 19 ] ;
2949             pVBInfo->XG21_LVDSCapList[0].PSC_S1 = pVideoMemory[ i + 20 ] ;
2950             pVBInfo->XG21_LVDSCapList[0].PSC_S2 = pVideoMemory[ i + 21 ] ;
2951             pVBInfo->XG21_LVDSCapList[0].PSC_S3 = pVideoMemory[ i + 22 ] ;
2952             pVBInfo->XG21_LVDSCapList[0].PSC_S4 = pVideoMemory[ i + 23 ] ;
2953             pVBInfo->XG21_LVDSCapList[0].PSC_S5 = pVideoMemory[ i + 24 ] ;
2954         }
2955         }
2956     }
2957 }
2958
2959 /* --------------------------------------------------------------------- */
2960 /* Function : XGINew_DDR1x_MRS_XG20 */
2961 /* Input : */
2962 /* Output : */
2963 /* Description : */
2964 /* --------------------------------------------------------------------- */
2965 void XGINew_DDR1x_MRS_XG20( ULONG P3c4 , PVB_DEVICE_INFO pVBInfo)
2966 {
2967
2968     XGINew_SetReg1( P3c4 , 0x18 , 0x01 ) ;
2969     XGINew_SetReg1( P3c4 , 0x19 , 0x40 ) ;
2970     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
2971     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
2972     DelayUS( 60 ) ;
2973
2974     XGINew_SetReg1( P3c4 , 0x18 , 0x00 ) ;
2975     XGINew_SetReg1( P3c4 , 0x19 , 0x40 ) ;
2976     XGINew_SetReg1( P3c4 , 0x16 , 0x00 ) ;
2977     XGINew_SetReg1( P3c4 , 0x16 , 0x80 ) ;
2978     DelayUS( 60 ) ;
2979     XGINew_SetReg1( P3c4 , 0x18 , pVBInfo->SR15[ 2 ][ XGINew_RAMType ] ) ;      /* SR18 */
2980     /* XGINew_SetReg1( P3c4 , 0x18 , 0x31 ) ; */
2981     XGINew_SetReg1( P3c4 , 0x19 , 0x01 ) ;
2982     XGINew_SetReg1( P3c4 , 0x16 , 0x03 ) ;
2983     XGINew_SetReg1( P3c4 , 0x16 , 0x83 ) ;
2984     DelayUS( 1000 ) ;
2985     XGINew_SetReg1( P3c4 , 0x1B , 0x03 ) ;
2986     DelayUS( 500 ) ;
2987     /* XGINew_SetReg1( P3c4 , 0x18 , 0x31 ) ; */
2988     XGINew_SetReg1( P3c4 , 0x18 , pVBInfo->SR15[ 2 ][ XGINew_RAMType ] ) ;      /* SR18 */
2989     XGINew_SetReg1( P3c4 , 0x19 , 0x00 ) ;
2990     XGINew_SetReg1( P3c4 , 0x16 , 0x03 ) ;
2991     XGINew_SetReg1( P3c4 , 0x16 , 0x83 ) ;
2992     XGINew_SetReg1( P3c4 , 0x1B , 0x00 ) ;
2993 }
2994
2995 /* --------------------------------------------------------------------- */
2996 /* Function : XGINew_SetDRAMModeRegister_XG20 */
2997 /* Input : */
2998 /* Output : */
2999 /* Description : */
3000 /* --------------------------------------------------------------------- */
3001 void XGINew_SetDRAMModeRegister_XG20( PXGI_HW_DEVICE_INFO HwDeviceExtension )
3002 {
3003     VB_DEVICE_INFO VBINF;
3004     PVB_DEVICE_INFO pVBInfo = &VBINF;
3005     pVBInfo->ROMAddr = HwDeviceExtension->pjVirtualRomBase ;
3006     pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress ;
3007     pVBInfo->BaseAddr = (ULONG)HwDeviceExtension->pjIOAddress ;
3008     pVBInfo->ISXPDOS = 0 ;
3009
3010     pVBInfo->P3c4 = pVBInfo->BaseAddr + 0x14 ;
3011     pVBInfo->P3d4 = pVBInfo->BaseAddr + 0x24 ;
3012     pVBInfo->P3c0 = pVBInfo->BaseAddr + 0x10 ;
3013     pVBInfo->P3ce = pVBInfo->BaseAddr + 0x1e ;
3014     pVBInfo->P3c2 = pVBInfo->BaseAddr + 0x12 ;
3015     pVBInfo->P3ca = pVBInfo->BaseAddr + 0x1a ;
3016     pVBInfo->P3c6 = pVBInfo->BaseAddr + 0x16 ;
3017     pVBInfo->P3c7 = pVBInfo->BaseAddr + 0x17 ;
3018     pVBInfo->P3c8 = pVBInfo->BaseAddr + 0x18 ;
3019     pVBInfo->P3c9 = pVBInfo->BaseAddr + 0x19 ;
3020     pVBInfo->P3da = pVBInfo->BaseAddr + 0x2A ;
3021     pVBInfo->Part0Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_00 ;
3022     pVBInfo->Part1Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_04 ;
3023     pVBInfo->Part2Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_10 ;
3024     pVBInfo->Part3Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_12 ;
3025     pVBInfo->Part4Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 ;
3026     pVBInfo->Part5Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 + 2 ;
3027
3028     InitTo330Pointer(HwDeviceExtension->jChipType,pVBInfo);
3029
3030     ReadVBIOSTablData( HwDeviceExtension->jChipType , pVBInfo) ;
3031
3032     if ( XGINew_GetXG20DRAMType( HwDeviceExtension, pVBInfo) == 0 )
3033         XGINew_DDR1x_MRS_XG20( pVBInfo->P3c4, pVBInfo ) ;
3034     else
3035         XGINew_DDR2_MRS_XG20( HwDeviceExtension , pVBInfo->P3c4 , pVBInfo ) ;
3036
3037     XGINew_SetReg1( pVBInfo->P3c4 , 0x1B , 0x03 ) ;
3038 }
3039
3040 void XGINew_SetDRAMModeRegister_XG27( PXGI_HW_DEVICE_INFO HwDeviceExtension )
3041 {
3042     VB_DEVICE_INFO VBINF;
3043     PVB_DEVICE_INFO pVBInfo = &VBINF;
3044     pVBInfo->ROMAddr = HwDeviceExtension->pjVirtualRomBase ;
3045     pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress ;
3046     pVBInfo->BaseAddr = (ULONG)HwDeviceExtension->pjIOAddress ;
3047     pVBInfo->ISXPDOS = 0 ;
3048
3049     pVBInfo->P3c4 = pVBInfo->BaseAddr + 0x14 ;
3050     pVBInfo->P3d4 = pVBInfo->BaseAddr + 0x24 ;
3051     pVBInfo->P3c0 = pVBInfo->BaseAddr + 0x10 ;
3052     pVBInfo->P3ce = pVBInfo->BaseAddr + 0x1e ;
3053     pVBInfo->P3c2 = pVBInfo->BaseAddr + 0x12 ;
3054     pVBInfo->P3ca = pVBInfo->BaseAddr + 0x1a ;
3055     pVBInfo->P3c6 = pVBInfo->BaseAddr + 0x16 ;
3056     pVBInfo->P3c7 = pVBInfo->BaseAddr + 0x17 ;
3057     pVBInfo->P3c8 = pVBInfo->BaseAddr + 0x18 ;
3058     pVBInfo->P3c9 = pVBInfo->BaseAddr + 0x19 ;
3059     pVBInfo->P3da = pVBInfo->BaseAddr + 0x2A ;
3060     pVBInfo->Part0Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_00 ;
3061     pVBInfo->Part1Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_04 ;
3062     pVBInfo->Part2Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_10 ;
3063     pVBInfo->Part3Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_12 ;
3064     pVBInfo->Part4Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 ;
3065     pVBInfo->Part5Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 + 2 ;
3066
3067     InitTo330Pointer(HwDeviceExtension->jChipType,pVBInfo);
3068
3069     ReadVBIOSTablData( HwDeviceExtension->jChipType , pVBInfo) ;
3070
3071     if ( XGINew_GetXG20DRAMType( HwDeviceExtension, pVBInfo) == 0 )
3072         XGINew_DDR1x_MRS_XG20( pVBInfo->P3c4, pVBInfo ) ;
3073     else
3074         //XGINew_DDR2_MRS_XG27( HwDeviceExtension , pVBInfo->P3c4 , pVBInfo ) ;
3075         XGINew_DDRII_Bootup_XG27( HwDeviceExtension , pVBInfo->P3c4 , pVBInfo) ;
3076
3077     //XGINew_SetReg1( pVBInfo->P3c4 , 0x1B , 0x03 ) ;
3078     XGINew_SetReg1( pVBInfo->P3c4 , 0x1B , pVBInfo->SR15[ 3 ][ XGINew_RAMType ] ) ;     /* SR1B */
3079
3080 }
3081 /*
3082 void XGINew_SetDRAMModeRegister_XG27( PXGI_HW_DEVICE_INFO HwDeviceExtension )
3083 {
3084
3085     UCHAR data ;
3086     VB_DEVICE_INFO VBINF;
3087     PVB_DEVICE_INFO pVBInfo = &VBINF;
3088     pVBInfo->ROMAddr = HwDeviceExtension->pjVirtualRomBase ;
3089     pVBInfo->FBAddr = HwDeviceExtension->pjVideoMemoryAddress ;
3090     pVBInfo->BaseAddr = HwDeviceExtension->pjIOAddress ;
3091     pVBInfo->ISXPDOS = 0 ;
3092
3093     pVBInfo->P3c4 = pVBInfo->BaseAddr + 0x14 ;
3094     pVBInfo->P3d4 = pVBInfo->BaseAddr + 0x24 ;
3095     pVBInfo->P3c0 = pVBInfo->BaseAddr + 0x10 ;
3096     pVBInfo->P3ce = pVBInfo->BaseAddr + 0x1e ;
3097     pVBInfo->P3c2 = pVBInfo->BaseAddr + 0x12 ;
3098     pVBInfo->P3ca = pVBInfo->BaseAddr + 0x1a ;
3099     pVBInfo->P3c6 = pVBInfo->BaseAddr + 0x16 ;
3100     pVBInfo->P3c7 = pVBInfo->BaseAddr + 0x17 ;
3101     pVBInfo->P3c8 = pVBInfo->BaseAddr + 0x18 ;
3102     pVBInfo->P3c9 = pVBInfo->BaseAddr + 0x19 ;
3103     pVBInfo->P3da = pVBInfo->BaseAddr + 0x2A ;
3104     pVBInfo->Part0Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_00 ;
3105     pVBInfo->Part1Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_04 ;
3106     pVBInfo->Part2Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_10 ;
3107     pVBInfo->Part3Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_12 ;
3108     pVBInfo->Part4Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 ;
3109     pVBInfo->Part5Port = pVBInfo->BaseAddr + XGI_CRT2_PORT_14 + 2 ;
3110
3111     InitTo330Pointer(HwDeviceExtension->jChipType,pVBInfo);
3112
3113     ReadVBIOSTablData( HwDeviceExtension->jChipType , pVBInfo) ;
3114
3115     if ( XGINew_GetXG20DRAMType( HwDeviceExtension, pVBInfo) == 0 )
3116         XGINew_DDR1x_MRS_XG20( pVBInfo->P3c4, pVBInfo ) ;
3117     else
3118         XGINew_DDR2_MRS_XG27( HwDeviceExtension , pVBInfo->P3c4 , pVBInfo ) ;
3119
3120     XGINew_SetReg1( pVBInfo->P3c4 , 0x1B , 0x03 ) ;
3121 }
3122 */
3123 /* -------------------------------------------------------- */
3124 /* Function : XGINew_ChkSenseStatus */
3125 /* Input : */
3126 /* Output : */
3127 /* Description : */
3128 /* -------------------------------------------------------- */
3129 void XGINew_ChkSenseStatus ( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo)
3130 {
3131     USHORT tempbx=0 , temp , tempcx , CR3CData;
3132
3133     temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x32 ) ;
3134
3135     if ( temp & Monitor1Sense )
3136         tempbx |= ActiveCRT1 ;
3137     if ( temp & LCDSense )
3138         tempbx |= ActiveLCD ;
3139     if ( temp & Monitor2Sense )
3140         tempbx |= ActiveCRT2 ;
3141     if ( temp & TVSense )
3142     {
3143         tempbx |= ActiveTV ;
3144         if ( temp & AVIDEOSense )
3145             tempbx |= ( ActiveAVideo << 8 );
3146         if ( temp & SVIDEOSense )
3147             tempbx |= ( ActiveSVideo << 8 );
3148         if ( temp & SCARTSense )
3149             tempbx |= ( ActiveSCART << 8 );
3150         if ( temp & HiTVSense )
3151             tempbx |= ( ActiveHiTV << 8 );
3152         if ( temp & YPbPrSense )
3153             tempbx |= ( ActiveYPbPr << 8 );
3154     }
3155
3156     tempcx = XGINew_GetReg1( pVBInfo->P3d4 , 0x3d ) ;
3157     tempcx |= ( XGINew_GetReg1( pVBInfo->P3d4 , 0x3e ) << 8 ) ;
3158
3159     if ( tempbx & tempcx )
3160     {
3161         CR3CData = XGINew_GetReg1( pVBInfo->P3d4 , 0x3c ) ;
3162         if ( !( CR3CData & DisplayDeviceFromCMOS ) )
3163         {
3164             tempcx = 0x1FF0 ;
3165             if ( *pVBInfo->pSoftSetting & ModeSoftSetting )
3166             {
3167                 tempbx = 0x1FF0 ;
3168             }
3169         }
3170     }
3171     else
3172     {
3173         tempcx = 0x1FF0 ;
3174         if ( *pVBInfo->pSoftSetting & ModeSoftSetting )
3175         {
3176             tempbx = 0x1FF0 ;
3177         }
3178     }
3179
3180     tempbx &= tempcx ;
3181     XGINew_SetReg1( pVBInfo->P3d4, 0x3d , ( tempbx & 0x00FF ) ) ;
3182     XGINew_SetReg1( pVBInfo->P3d4, 0x3e , ( ( tempbx & 0xFF00 ) >> 8 )) ;
3183 }
3184 /* -------------------------------------------------------- */
3185 /* Function : XGINew_SetModeScratch */
3186 /* Input : */
3187 /* Output : */
3188 /* Description : */
3189 /* -------------------------------------------------------- */
3190 void XGINew_SetModeScratch ( PXGI_HW_DEVICE_INFO HwDeviceExtension , PVB_DEVICE_INFO pVBInfo )
3191 {
3192     USHORT temp , tempcl = 0 , tempch = 0 , CR31Data , CR38Data;
3193
3194     temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x3d ) ;
3195     temp |= XGINew_GetReg1( pVBInfo->P3d4 , 0x3e ) << 8 ;
3196     temp |= ( XGINew_GetReg1( pVBInfo->P3d4 , 0x31 ) & ( DriverMode >> 8) ) << 8 ;
3197
3198     if ( pVBInfo->IF_DEF_CRT2Monitor == 1)
3199     {
3200         if ( temp & ActiveCRT2 )
3201            tempcl = SetCRT2ToRAMDAC ;
3202     }
3203
3204     if ( temp & ActiveLCD )
3205     {
3206         tempcl |= SetCRT2ToLCD ;
3207         if  ( temp & DriverMode )
3208         {
3209             if ( temp & ActiveTV )
3210             {
3211                 tempch = SetToLCDA | EnableDualEdge ;
3212                 temp ^= SetCRT2ToLCD ;
3213
3214                 if ( ( temp >> 8 ) & ActiveAVideo )
3215                     tempcl |= SetCRT2ToAVIDEO ;
3216                 if ( ( temp >> 8 ) & ActiveSVideo )
3217                     tempcl |= SetCRT2ToSVIDEO ;
3218                 if ( ( temp >> 8 ) & ActiveSCART )
3219                     tempcl |= SetCRT2ToSCART ;
3220
3221                 if ( pVBInfo->IF_DEF_HiVision == 1 )
3222                 {
3223                     if ( ( temp >> 8 ) & ActiveHiTV )
3224                     tempcl |= SetCRT2ToHiVisionTV ;
3225                 }
3226
3227                 if ( pVBInfo->IF_DEF_YPbPr == 1 )
3228                 {
3229                     if ( ( temp >> 8 ) & ActiveYPbPr )
3230                     tempch |= SetYPbPr ;
3231                 }
3232             }
3233         }
3234     }
3235     else
3236     {
3237         if ( ( temp >> 8 ) & ActiveAVideo )
3238            tempcl |= SetCRT2ToAVIDEO ;
3239         if ( ( temp >> 8 ) & ActiveSVideo )
3240            tempcl |= SetCRT2ToSVIDEO ;
3241         if ( ( temp >> 8 ) & ActiveSCART )
3242            tempcl |= SetCRT2ToSCART ;
3243
3244         if ( pVBInfo->IF_DEF_HiVision == 1 )
3245         {
3246            if ( ( temp >> 8 ) & ActiveHiTV )
3247            tempcl |= SetCRT2ToHiVisionTV ;
3248         }
3249
3250         if ( pVBInfo->IF_DEF_YPbPr == 1 )
3251         {
3252            if ( ( temp >> 8 ) & ActiveYPbPr )
3253            tempch |= SetYPbPr ;
3254         }
3255     }
3256
3257
3258     tempcl |= SetSimuScanMode ;
3259     if ( (!( temp & ActiveCRT1 )) && ( ( temp & ActiveLCD ) || ( temp & ActiveTV ) || ( temp & ActiveCRT2 ) ) )
3260        tempcl ^= ( SetSimuScanMode | SwitchToCRT2 ) ;
3261     if ( ( temp & ActiveLCD ) && ( temp & ActiveTV ) )
3262        tempcl ^= ( SetSimuScanMode | SwitchToCRT2 ) ;
3263     XGINew_SetReg1( pVBInfo->P3d4, 0x30 , tempcl ) ;
3264
3265     CR31Data = XGINew_GetReg1( pVBInfo->P3d4 , 0x31 ) ;
3266     CR31Data &= ~( SetNotSimuMode >> 8 ) ;
3267     if ( !( temp & ActiveCRT1 ) )
3268         CR31Data |= ( SetNotSimuMode >> 8 ) ;
3269     CR31Data &= ~( DisableCRT2Display >> 8 ) ;
3270     if  (!( ( temp & ActiveLCD ) || ( temp & ActiveTV ) || ( temp & ActiveCRT2 ) ) )
3271         CR31Data |= ( DisableCRT2Display >> 8 ) ;
3272     XGINew_SetReg1( pVBInfo->P3d4, 0x31 , CR31Data ) ;
3273
3274     CR38Data = XGINew_GetReg1( pVBInfo->P3d4 , 0x38 ) ;
3275     CR38Data &= ~SetYPbPr ;
3276     CR38Data |= tempch ;
3277     XGINew_SetReg1( pVBInfo->P3d4, 0x38 , CR38Data ) ;
3278
3279 }
3280
3281 /* -------------------------------------------------------- */
3282 /* Function : XGINew_GetXG21Sense */
3283 /* Input : */
3284 /* Output : */
3285 /* Description : */
3286 /* -------------------------------------------------------- */
3287 void XGINew_GetXG21Sense(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
3288 {
3289     UCHAR Temp;
3290     PUCHAR  volatile pVideoMemory = ( PUCHAR )pVBInfo->ROMAddr ;
3291
3292     pVBInfo->IF_DEF_LVDS = 0 ;
3293
3294 #if 1
3295     if (( pVideoMemory[ 0x65 ] & 0x01 ) )                       /* For XG21 LVDS */
3296     {
3297         pVBInfo->IF_DEF_LVDS = 1 ;
3298         XGINew_SetRegOR( pVBInfo->P3d4 , 0x32 , LCDSense ) ;
3299         XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x38 , ~0xE0 , 0xC0 ) ; /* LVDS on chip */
3300     }
3301     else
3302     {
3303 #endif
3304         XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x4A , ~0x03 , 0x03 ) ; /* Enable GPIOA/B read  */
3305         Temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x48 ) & 0xC0;
3306         if ( Temp == 0xC0 )
3307         {                                                               /* DVI & DVO GPIOA/B pull high */
3308           XGINew_SenseLCD( HwDeviceExtension, pVBInfo ) ;
3309           XGINew_SetRegOR( pVBInfo->P3d4 , 0x32 , LCDSense ) ;
3310           XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x4A , ~0x20 , 0x20 ) ;   /* Enable read GPIOF */
3311           Temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x48 ) & 0x04 ;
3312           if ( !Temp )
3313             XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x38 , ~0xE0 , 0x80 ) ; /* TMDS on chip */
3314           else
3315             XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x38 , ~0xE0 , 0xA0 ) ; /* Only DVO on chip */
3316           XGINew_SetRegAND( pVBInfo->P3d4 , 0x4A , ~0x20 ) ;        /* Disable read GPIOF */
3317         }
3318 #if 1
3319     }
3320 #endif
3321 }
3322
3323 /* -------------------------------------------------------- */
3324 /* Function : XGINew_GetXG27Sense */
3325 /* Input : */
3326 /* Output : */
3327 /* Description : */
3328 /* -------------------------------------------------------- */
3329 void XGINew_GetXG27Sense(PXGI_HW_DEVICE_INFO HwDeviceExtension, PVB_DEVICE_INFO pVBInfo)
3330 {
3331     UCHAR Temp,bCR4A;
3332
3333      pVBInfo->IF_DEF_LVDS = 0 ;
3334      bCR4A = XGINew_GetReg1( pVBInfo->P3d4 , 0x4A ) ;
3335      XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x4A , ~0x07 , 0x07 ) ; /* Enable GPIOA/B/C read  */
3336      Temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x48 ) & 0x07;
3337      XGINew_SetReg1( pVBInfo->P3d4, 0x4A , bCR4A ) ;
3338
3339      if ( Temp <= 0x02 )
3340      {
3341          pVBInfo->IF_DEF_LVDS = 1 ;
3342          XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x38 , ~0xE0 , 0xC0 ) ; /* LVDS setting */
3343          XGINew_SetReg1( pVBInfo->P3d4, 0x30 , 0x21 ) ;
3344      }
3345      else
3346      {
3347        XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x38 , ~0xE0 , 0xA0 ) ; /* TMDS/DVO setting */
3348      }
3349      XGINew_SetRegOR( pVBInfo->P3d4 , 0x32 , LCDSense ) ;
3350
3351 }
3352
3353 UCHAR GetXG21FPBits(PVB_DEVICE_INFO pVBInfo)
3354 {
3355     UCHAR CR38,CR4A,temp;
3356
3357     CR4A = XGINew_GetReg1( pVBInfo->P3d4 , 0x4A ) ;
3358     XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x4A , ~0x10 , 0x10 ) ; /* enable GPIOE read */
3359     CR38 = XGINew_GetReg1( pVBInfo->P3d4 , 0x38 ) ;
3360     temp =0;
3361     if ( ( CR38 & 0xE0 ) > 0x80 )
3362     {
3363         temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x48 ) ;
3364         temp &= 0x08;
3365         temp >>= 3;
3366     }
3367
3368     XGINew_SetReg1( pVBInfo->P3d4, 0x4A , CR4A ) ;
3369
3370     return temp;
3371 }
3372
3373 UCHAR GetXG27FPBits(PVB_DEVICE_INFO pVBInfo)
3374 {
3375     UCHAR CR4A,temp;
3376
3377     CR4A = XGINew_GetReg1( pVBInfo->P3d4 , 0x4A ) ;
3378     XGINew_SetRegANDOR( pVBInfo->P3d4 , 0x4A , ~0x03 , 0x03 ) ; /* enable GPIOA/B/C read */
3379     temp = XGINew_GetReg1( pVBInfo->P3d4 , 0x48 ) ;
3380     if ( temp <= 2 )
3381     {
3382         temp &= 0x03;
3383     }
3384     else
3385     {
3386         temp = ((temp&0x04)>>1) || ((~temp)&0x01);
3387     }
3388     XGINew_SetReg1( pVBInfo->P3d4, 0x4A , CR4A ) ;
3389
3390     return temp;
3391 }
3392